Musée virtuel de l’informatique à la Banque de France

Histoire de l’informatique à la Banque de France

Extrait de la présentation de ce site très intéressant (page d’accueil) :

L’informatique à la Banque de France : une révolution qui a commencé dès les années cinquante.
À cette époque, la mécanographie laisse peu à peu place à l’électromécanique et aux tous premiers ordinateurs.
Le mot d’ordre : automatiser, moderniser. Une évolution nécessaire marquée en 1968 par la création d’une direction spécifique, l’Organisation et Informatique et d’un service majeur, le Centre électronique de traitement de l’information (CETI), au cœur du déploiement des dernières technologies.

De réorganisation en restructuration, ces deux entités changeront d’identité, de structure mais feront de la Banque une pionnière dans ce domaine en constante évolution. Aujourd’hui, télématique, bureautique, numérique gouvernent toutes nos activités, prouvant que notre établissement a toujours su tirer le meilleur parti de l’informatique pour être innovante.

Découvrez en images l’histoire de l’informatique à la Banque de France.

Concours de vidéos : #ScienceInfoStream « L’informatique en stream »

La Société Informatique de France (SIF) propose un concours de création vidéo autour du thème de la science informatique.

Le concours est ouvert à tous, sans limite d’âge ni de niveau.

Pour participer, une déclaration d’intention doit être envoyée avant le 1er décembre 2017 et la vidéo finale devra être disponible avant le 8 janvier 2018.

Vous êtes passionné(e)s de science informatique ?

Vous aimez les défis ?

Vous vous sentez l’âme d’un vidéaste ?

N’attendez plus ! Prenez votre smartphone, webcam, ou  caméra : vous avez moins de 256 secondes pour partager ces pépites de science qui vous fascinent.

Votre vidéo, tournée en français, aura une durée comprise entre 27 (128) et 28 (256) secondes. Elle sera au format de votre choix (les formats libres, comme ogv, sont encouragés) et mise à disposition sur le web (via votre page personnelle ou via un site de streaming). La soumission se fera par email à l’adresse scienceinfostream@societe-informatique-de-france.fr, une déclaration d’intention est attendue avant le 1er décembre 2017, la soumission finale devra arriver avant le 8 janvier 2018. Le mail contiendra, outre le lien, le titre de la vidéo et les noms et prénoms de son ou de ses auteur(s) avec une présentation succincte (âge, rôles respectifs dans le projet…).

Plus d’information sur le site de la SIF : http://www.societe-informatique-de-france.fr/2017/07/concours-de-videos-scienceinfostream/

Source : https://pixees.fr/linformatique-en-stream/

Site Prog en cours …

Le site Prog en cours est un site collaboratif créé par des collègues de l’académie de Rennes. Il présente des idées de projets et d’activités numériques sur le codage pour l’enseignement de l’ISN et de l’ICN.

On y trouve déjà beaucoup de ressources très intéressantes.

Petites vidéos de culture informatique Class’code

Dans le cadre de la formation en ligne Class’code, le blog binaire du Monde met en ligne toute une série de courtes vidéos de vulgarisation informatique très intéressantes :

Concours Prologin 2018

Prologin est un concours d’informatique ouvert à tous les étudiants âgés de moins de 21, organisé par l’association Prologin. Son but est de faire découvrir le monde de la programmation et de l’algorithmique aux étudiants et de les confronter à des problèmes classiques et des challenges excitants. Le concours se déroule en trois étapes de sélections consécutives présentées dans les sections suivantes. Prologin est une association à but non lucratif, et son concours est totalement gratuit.

1e étape – Sélection

Le questionnaire de sélection vous permet de vous qualifier pour les épreuves régionales. Il s’agit de résoudre une sélection de problèmes d’algorithmique de difficulté croissante. Le questionnaire doit être soumis directement sur le site du concours.

Les inscriptions sont totalement gratuites, vous avez uniquement besoin d’un accès à Internet pour envoyer vos réponses.

2e étape – Les épreuves régionales

Les épreuves régionales permettent aux 100 meilleurs participants de se qualifier pour la finale. L’événement dure une journée et se déroule un samedi en janvier ou février, en fonction des villes. Les participants sont répartis dans les différents centres d’examens en France. La sélection se base sur trois épreuves : un examen écrit sur un problème d’algorithmique original, des exercices à résoudre sur ordinateur et un entretien avec un membre de l’association Prologin.

3e étape – La finale

La finale se déroule sur 3 jours à Paris, habituellement fin avril. Les candidats doivent coder leur propre intelligence artificielle pour un jeu créé pour l’occasion, en seulement 36h. Les programmes des candidats sont ensuite confrontés les uns aux autres dans un tournoi automatisé. C’est aussi une opportunité unique de rencontrer des passionnés d’informatique dans une ambiance sympathique et détendue !

Pour s’entraîner, les sujets des années précédentes sont mis en ligne.

Pour participer, cliquer sur l’affiche ci-dessous.

Source : https://prologin.org/about/contest

MOOC gratuit et en français d’initiation à la cybersécurité

SecNum Académie de l’ANSSI (Agence nationale de la sécurité des systèmes d’information) propose gratuitement de s’initier à la cybersécurité en s’inscrivant à un MOOC conçu pour un public de débutants. Ce MOOC (Massive Open Online Course) vous fournira l’ensemble des informations pour vous initier à  la cybersécurité ou approfondir vos connaissances dans ce domaine, et ainsi agir efficacement sur la protection de vos outils numériques. On y pense peu, mais la sécurité informatique est un enjeu important, mais souvent négligé même au sein des grandes entreprises et des administrations.

Source : MOOC gratuit et en français d’initiation à la cybersécurité

Jeu « Pierre, papier, ciseaux » avec Kivy

Exemple de programmation d’une application en Python avec Kivy

Ce sujet est complètement inspiré du chapitre 4 de la partie “Python 3 : Objectif jeux” du site de Didier Müller

http://www.apprendre-en-ligne.net/pj/ppcg/index.html

Le T.P. proposé sur ce site utilise la bibliothèque TkInter pour créer une interface graphique au jeu “Pierre, papier, ciseaux”. Le sujet a été modifié ici pour l’utilisation de la bibliothèque Kivy, ce qui permettra d’aboutir à une application fonctionnant à la fois sous Android, Linux ou Windows.


Règle du jeu

Tout le monde connaît le jeu pierre-papier-ciseaux, aussi connu sous le nom de “chifoumi”. Deux joueurs se montrent simultanément leur main qui symbolisera une pierre (poing fermé), un papier (main tendue) ou des ciseaux (l’index et le majeur forment un V).

La pierre bat les ciseaux, les ciseaux battent le papier et le papier bat la pierre. Si les deux joueurs jouent le même symbole, il y a égalité.

Création de l’application

Kivy, Python et le langage kv

Petit résumé pour ceux qui n’ont jamais utilisé Kivy.

La bibliothèque Kivy permet de définir une interface graphique compatible avec les écrans tactiles et les systèmes d’exploitation associés. Elle permet aussi de séparer dans deux fichiers séparés la partie algorithmique du programme (fichier Python) et la partie qui définit l’interface graphique (fichier kv). Ce dernier fichier utilise un langage propre à Kivy, le langage kv dans lequel l’interface graphique est définie sous la forme d’une “arbre de widgets”.

Le ficher kv doit avoir le même nom que la classe de l’application dans le fichier Python, mais tout en minuscules. Il sera ainsi automatiquement chargé lors de l’exécution du programme.

Dans PyCharm, créer un nouveau projet (c’est-à-dire un nouveau dossier) nommé PierrePapierCiseaux et, dans ce dossier, créer un fichier main.py et un fichier pierrepapierciseaux.kv. Créer aussi un sous-dossier Images dans lequel on placera les images fournies.

Structure de l’interface graphique

Avant de créer le fichier kv, il faut réfléchir à la structure de notre fenêtre (mise en page). L’écran du jeu doit ressembler à l’image ci-contre.

Le plus simple est d’utiliser une mise en page basée sur un widget principal de type BoxLayout version verticale qui empile son contenu verticalement. Ce widget contiendra une série de widgets BoxLayout, version horizontale, qui contiendront des widgets de type Label pour afficher les mots “Humain”, “Machine” et les scores correspondants, les images et les boutons.

Le fichier kv

Le texte du fichier kv traduit la structure décrite ci-dessus, sous forme d’arbre indenté.

Bonne pratique : donner un identifiant aux widgets qui devront être modifiés depuis le programme Python permet d’y accéder pour en changer des propriétés (changer les images pas exemple).

Les scores seront conservés dans les variables score_humain et score_machine, définies dans le fichier Python.

<ImageButton@ButtonBehavior+Image>:
    keep_ratio: True

<EcranPrincipal>:
    BoxLayout:
        orientation: "vertical"
        BoxLayout:
            orientation: "horizontal"
            Label:
                text: "Humain"
            Label:
            Label:
                text: "Machine"
        BoxLayout:
            orientation: "horizontal"
            Label:
                text: str(root.score_humain)
            Label:
            Label:
                text: str(root.score_machine)
        BoxLayout:
            orientation: "horizontal"
            Image:
                id: coup_humain
                source: "Images/rien.gif"
            Image:
                source: "Images/versus.gif"
            Image:
                id: coup_machine
                source: "Images/rien.gif"
        Label:
            text: "Pour jouer, cliquer sur un des boutons ci-dessous."
        BoxLayout:
            orientation: "horizontal"
            ImageButton:
                source: "Images/papier.gif"
            ImageButton:
                source: "Images/pierre.gif"
            ImageButton:
                source: "Images/ciseaux.gif"
        BoxLayout:
            orientation: "horizontal"
            Button:
                text: "Recommencer"
            Label:
            Button:
                text: "Quitter"

Explications :

  • Lignes 1 et 2 : on définit un widget personnalisé basé sur une image à laquelle on ajoute le comportement d’un bouton (image cliquable). La ligne 2 indique que cette image n’est pas déformable.
  • Ligne 4 : EcranPrincipal sera le nom de la classe correspondante dans le fichier Python (on y fait référence en utilisant l’identifiant root) dans la suite. La mise en page est basée sur un widget de type BoxLayout.
  • Ligne 17 : root.score_humain, variable score_humain, propriété de la classe EcranPrincipal désignée par root (racine de l’arbre des widgets).

Pour visualiser l’interface graphique, on utilisera la fichier main.py minimal ci-dessous:

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.properties import NumericProperty


class EcranPrincipal(BoxLayout):

    score_humain = NumericProperty(0)
    score_machine = NumericProperty(0)
    
    pass


class PapierPierreCiseaux(App):

    def build(self):
        return EcranPrincipal()


PapierPierreCiseaux().run()

Les scores sont des objets du type NumericProperty : il s’agit de nombres. L’utilisation de ce type permet de mettre automatiquement à jour l’affichage à chaque changement de valeur de ces variables.

Le programme final

L’aspect obtenu n’est pas optimal, mais tous les éléments sont bien présents.

Voici la version finale du fichier kv dans lequel quelques éléments de mise en page ont été définis et les actions des boutons sont définies :

<ImageButton@ButtonBehavior+Image>:
    keep_ratio: True
    
<EcranPrincipal>: 
    BoxLayout:
        canvas.before:
            Color:
                rgb: 0,0,1,0.5
            Rectangle:
                size: self.size
                pos: self.pos
        orientation: "vertical"
        padding: '10sp'
        spacing: '10sp'
        BoxLayout:
            orientation: "horizontal"
            padding: '10sp'
            spacing: '10sp'
            size_hint_y: 0.2
            Label:
                text: "Humain"
                font_size: '30sp'
            Label:
            Label:
                text: "Machine"
                font_size: '30sp'
        BoxLayout:
            orientation: "horizontal"
            padding: '10sp'
            spacing: '10sp'
            size_hint_y: 0.1
            Label:
                text: str(root.score_humain)
                font_size: '30dp'
            Label:
            Label:
                text: str(root.score_machine)
                font_size: '30sp'
        BoxLayout:
            orientation: "horizontal"
            Image:
                id: coup_humain
                source: "Images/rien.gif"
            Image:
                source: "Images/versus.gif"
            Image:
                id: coup_machine
                source: "Images/rien.gif"
        Label:
            text: "Pour jouer, cliquer sur un des boutons ci-dessous."
            size_hint_y: 0.1
        BoxLayout:
            orientation: "horizontal"
            ImageButton:
                source: "Images/papier.gif"
                on_press: root.jouer_papier()
            ImageButton:
                source: "Images/pierre.gif"
                on_press: root.jouer_pierre()
            ImageButton:
                source: "Images/ciseaux.gif"
                on_press: root.jouer_ciseaux()
        BoxLayout:
            orientation: "horizontal"
            Button:
                text: "Recommencer"
                size_hint_y: 0.2
                on_press: root.reinit()
            Label:
                text: ""
                size_hint_y: 0.2
            Button:
                text: "Quitter"
                size_hint_y: 0.2
                on_press: app.stop()

Explications :

  • Lignes 7 à 11 : on définit un arrière plan bleu, avec une transparence de 50% pour l’écran de jeu.
  • Lignes 13 et 14 : padding correspond à l’espacement entre le widget considéré et son widget parent, spacing correspond à l’espacement entre les widgets fils du widget considéré.
  • Ligne 19 : on indique que la boîte horizontale doit avoir une taille verticale égale à 20% de la hauteur du widget principal.
  • Lignes 56, 59 et 62 : on définit l’action à déclencher lorsque l’image-bouton est cliquée. root correspond au widget principal, c’est-à-dire à la classe EcranPrincipal dans le fichier Python. Les fonctions appelées doivent donc être définies à l’intérieur de cette classe.

Voici maintenant le programme principal associé :

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.properties import NumericProperty

from random import randint


class EcranPrincipal(BoxLayout):

    score_humain = NumericProperty(0)
    score_machine = NumericProperty(0)

    def augmenter_scores(self,mon_coup, ton_coup):
        if mon_coup == 1 and ton_coup == 2:
            self.score_humain += 1
        elif mon_coup == 2 and ton_coup == 1:
            self.score_machine += 1
        elif mon_coup == 1 and ton_coup == 3:
            self.score_machine += 1
        elif mon_coup == 3 and ton_coup == 1:
            self.score_humain += 1
        elif mon_coup == 3 and ton_coup == 2:
            self.score_machine += 1
        elif mon_coup == 2 and ton_coup == 3:
            self.score_humain += 1

    def jouer(self, ton_coup):
        mon_coup = randint(1, 3)
        if mon_coup == 1:
            self.ids.coup_machine.source="Images/pierre.gif"
        elif mon_coup == 2:
            self.ids.coup_machine.source = "Images/papier.gif"
        else:
            self.ids.coup_machine.source = "Images/ciseaux.gif"
        self.augmenter_scores(mon_coup, ton_coup)

    def jouer_pierre(self):
        self.jouer(1)
        self.ids.coup_humain.source = "Images/pierre.gif"

    def jouer_papier(self):
        self.jouer(2)
        self.ids.coup_humain.source = "Images/papier.gif"

    def jouer_ciseaux(self):
        self.jouer(3)
        self.ids.coup_humain.source = "Images/ciseaux.gif"

    def reinit(self):
        self.score_humain = 0
        self.score_machine = 0
        self.ids.coup_machine.source = "Images/rien.gif"
        self.ids.coup_humain.source = "Images/rien.gif"


class PapierPierreCiseaux(App):

    def build(self):
        return EcranPrincipal()


PapierPierreCiseaux().run()

On voit qu’on accède aux widgets créés dans le fichier kv par leur identifiant. Par exemple, la ligne 30 va changer l’image du widget dont l’identifiant est coup_machine.

Test sous Android

  • Installer l’application “Kivy Launcher” : https://play.google.com/store/apps/details?id=org.kivy.pygame.
  • Sur l’appareil, créer un dossier kivy dans le dosser sdcard.
  • Créer un fichier android.txt contenant les trois lignes suivantes :
    title=Papier, Pierre, Ciseaux
    author=Evariste GALOIS
    orientation=portrait
  • Créer un dossier PierrePapierCiseaux dans le dossier kivy de l’appareil et y placer le fichier main.py, le fichier pierrepapierciseaux.kv, le dossier Images et le fichier android.txt.
  • Lancer l’application Kivy Launcher et toucher PierrePapierCiseaux pour lancer le jeu.

Exercices

Énoncés repris de la partie “Python 3 : Objectif jeux” du site http://www.apprendre-en-ligne.net/pj/ppcg/index.html.

Exercice 1

Reproduisez la fenêtre ci-dessous. Le bouton « Incrémenter » augmentera de 1 le compteur. Le bouton « Recommencer » remettra le compteur à 0 et le bouton « Quitter » fermera la fenêtre.

Exercice 2

Reproduisez la fenêtre ci-dessous. Les effets des boutons seront les mêmes que dans l’exercice 1.

Exercice 3

Modifiez le code du jeu.

Ajoutez un quatrième symbole : le puits. La pierre et les ciseaux tombent dans le puits (donc le puits gagne contre eux). Par contre, le papier recouvre le puits (le puits perd donc contre le papier).

Attention ! Les probabilités de gain changent, et la stratégie aussi !

Jeu de Go : AlphaGo s’impose encore une fois face au numéro un mondial de la discipline, le programme est désormais le champion du monde de Go

Source : Jeu de Go : AlphaGo s’impose encore une fois face au numéro un mondial de la discipline, le programme est désormais le champion du monde de Go

On a testé pour vous… Deep Dream, la machine à « rêves » psychédéliques de Google

Très étonnante utilisation de l’intelligence artificielle (deep learning) pour des créations visuelles.

On a testé pour vous le programme d’intelligence artificielle de Google permettant de faire apparaître des formes dans les images.

Source : On a testé pour vous… Deep Dream, la machine à « rêves » psychédéliques de Google

Comment le « deep learning » révolutionne l’intelligence artificielle

Un article du Monde fort intéressant sur le deep learning.

Cette technologie d’apprentissage, basée sur des réseaux de neurones artificiels, a complètement bouleversé le domaine de l’intelligence artificielle en moins de cinq ans.

Source : Comment le « deep learning » révolutionne l’intelligence artificielle