Archives de
Author: Pierre Jourlin

Je suis enseignant-chercheur en informatique. Ma discipline principale de recherche est le traitement automatique des langues, un sous-domaine de "l'intelligence" artificielle. Ma thèse de doctorat a porté sur la reconnaissance automatique de la parole et du locuteur à partir de la voix et du mouvement des lèvres, dans le cadre d'un contrat d'allocataire-moniteur à l'Université d'Avignon de 1994 à 1997. En 1996, j'ai travaillé en collaboration avec l'IDIAP (Suisse), dans le cadre du projet européen M2VTS et sur le sujet de la vérification automatique d'identité. J'ai ensuite été recruté comme chercheur à l'Université de Cambridge (Angleterre) de 1997 à 2000, sur un projet de recherche documentaire multimédia. Depuis 2000, je suis maître de conférences en informatique à l'Université d'Avignon et des Pays de Vaucluse. Ma recherche actuelle porte sur le développement de méthodes de fouille de texte pour l'analyse de grandes bases de données textuelles en langage naturel. J'ai travaillé sur des collections d'articles scientifiques, des documents issus d'une exploration du web, des réseaux sociaux, des microblogs. J'enseigne les fondements de l'informatique, la structure des ordinateurs, les bases de la programmation, l'assembleur, la compilation, les bases de données, la programmation web, l'analyse du web, les usages et évaluation des modèles prédictifs , l'éthique, explicabilité et interprétabilité en intelligence artificielle à des étudiants de licence et master informatique, de B.U.T. "Statistiques et Traitement Informatique des Données", de licence humanités, de master "gouvernance des données".
Je voudrais, sans la nommer, vous parler d’elle

Je voudrais, sans la nommer, vous parler d’elle

Les anciens égyptiens l’appelaient aha, Diophante d’Alexandrie la nommait arithmós (le nombre), Al-Khawarizmi la désignait par le mot shay’ (la chose que l’on cherche). Puis, elle a été latinisée en xay et René Descartes l’a abrégé en x.

L’inconnue, par définition, provoque des émotions contradictoires : du désir, de la peur, des fantasmes. Paradoxalement, elle est très familière dans notre langue, dans ses pronoms, ses articles indéterminés, ses anaphores. On la trouve dans nos jeux, dans nos polars. Plus elle semble inaccessible, plus on a envie de la connaitre, de la définir. Néanmoins, tout le plaisir réside dans l’exploration, dans ces petites découvertes qui dévoilent très lentement son identité. D’ailleurs, quand on y parvient, elle perd brutalement son attrait. A moins d’en trouver une qui nous résiste pour la vie, il nous en faut de nouvelles.

L’inconnue est notre carburant. C’est elle qui nous donne envie de faire des études et quand on en a la chance matérielle, de passer des inconnues de nous aux inconnues de tous.

Vous savez qu’il y a des équations très simples à formuler, mais qui ne trouvent pas de solution dans un ensemble donné. Ainsi, lorsque que l’on cherche un x² négatif, on n’a pas d’autre solution que de chercher pour x, un territoire plus complexe que celui des entiers relatifs. Ainsi, même si cela peut nous paraitre irrationnel, car nos terres sont loin d’être paradisiaques, chaque année, des milliers de personnes disparaissent en mer, en essayant de nous rejoindre.

Nos peurs de ces inconnues et de ces inconnus sont parfaitement absurdes et criminelles. Nous devons en urgence retrouver la raison. Ouvrir nos esprits et nos frontières. Combattre les discriminations, les discours et les lois xénophobes ou racistes. Et tout en espérant des victoires, sauver autant de vies que possible.

La sœur est la mère de ses frères

La sœur est la mère de ses frères

Hier soir, je regardais très distraitement l’épisode de « Faites entrer l’accusé » sur Chantal Ternik, quand un avocat a retenu mon attention avec cet énoncé :

La fille ainée [de Chantal] était devenue un peu la mère de ses deux frères.

Je trouve vraiment magique qu’un cerveau humain inattentif soit capable à la fois de comprendre instantanément, sans effort et sans erreurs une phrase aussi complexe tout en ayant vaguement conscience des pièges qu’il a machinalement évités.

Dans « la fille ainée de Chantal », on comprend que Chantal est la mère de X et que X est une femme. Par défaut, on considère que la relation « mère de » fait référence à un grand nombre de sous-relations : hérédité génétique, rapports légaux (droits et devoirs), liens affectifs, éducatifs, etc.

Jusqu’ici, tout va bien.

La suite est plus déroutante car, au regard de la loi de la plupart des pays, comme au regard de l’évolution des espèces, on ne peut pas être « un peu » le parent de quelqu’un. Il y a bien une alternative, mais elle est binaire : on est parent ou on ne l’est pas. Enfin, il ne nous paraît pas possible qu’une personne puisse « devenir » la mère biologique d’enfants déjà nés, qui plus est d’une autre mère et qui se révèle, par-dessus le marché, être la sienne. Nos arbres généalogiques imploseraient dans cette stupéfiante mise en abîme.

Notre cerveau doit donc trouver très rapidement une issue à cette crise : il en déduit que la première référence à la maternité est biologique ou légale, mais que la deuxième évocation ne fait cette fois référence qu’aux seules éducatives, affectives et de protection. Et là, les pièces du puzzle s’agencent parfaitement : la fille ainée de Chantal est donc ce qu’on appelle une « mère de substitution » pour ses deux frères.

C’est magique.

Le revers de la médaille, c’est que si notre cerveau est si bien entraîné à faire ce genre de calculs, c’est parce qu’il discute en permanence avec d’autres cerveaux dotés des mêmes superpouvoirs. Donc, la plupart du temps, nous n’avons pas besoin d’être très précis et explicite pour nous faire comprendre de nos semblables. De nos semblables. Pas des machines que nous avons conçu.

En effet, si nous avons réussi à doter nos ordinateurs de superpouvoirs que nous ne possédions pas, nous peinons encore leur transmettre ceux que nous possédons.

C’est pourquoi tout au long de vos études en informatique, vous devrez déployer beaucoup d’attention, d’entraînement et de patience pour vous faire comprendre de vos machines. Bon courage et bonne rentrée 2023-2024 à toutes et tous !

« Hacker » un jeu vidéo

« Hacker » un jeu vidéo

Un atelier pour la Fête de la Science 2022

Derrière ce titre volontairement accrocheur, se cache une initiation ludique à la programmation en Python, qui s’adresse à des élèves de collège et lycée. Il s’agira de faire fonctionner et de modifier une version écrite en Python, d’un des premiers jeux vidéo dits « d’arcade » (Blockade, 1976, voir photo).

  • Date : vendredi 14 octobre 2022
  • Lieu : CERI, salle stat 9
  • Horaires : 9h15 – 16h
  • Animateurs : Pierre Jourlin & Jarod Duret

Procédure :

  • Se connecter sur l’ordinateur avec l’identifiant et mot de passe donné sur papier par vos animateurs
  • Ouvrir un « terminal » (CTRL+ALT+T)
  • tapez « python3 -m pip install -U pygame --user » et appuyez sur <entrée>
  • tapez « geany & » appuyez sur <entrée>
  • copiez le code source suivant dans la fenêtre de l’éditeur :
import pygame
import time
import random
 
pygame.init()
 
# Définition des couleurs en composante (Rouge, Vert, Bleu) 
blanc = (255, 255, 255)
jaune = (255, 255, 102)
noir = (0, 0, 0)
rouge = (213, 50, 80)
vert = (0, 255, 0)
bleu = (50, 153, 213)
 
largeur_plateau = 600
hauteur_plateau = 400
 
plateau = pygame.display.set_mode( ( largeur_plateau, hauteur_plateau ) )
pygame.display.set_caption("Le Serpent Numérique du LIA")
 
horloge = pygame.time.Clock()
 
taille_bloc = 20
vitesse_serpent = 5
 
style_caractères = pygame.font.SysFont("bahnschrift", 25)
style_scores = pygame.font.SysFont("comicsansms", 35)
 
 
def votre_score(score):
    valeur = style_scores.render("Votre Score: " + str(score), True, jaune)
    plateau.blit(valeur, [0, 0])
 
def notre_serpent(taille_bloc, corps_serpent):
    for x in corps_serpent:
        pygame.draw.rect(plateau, noir, [x[0], x[1], taille_bloc, taille_bloc])
 
def message(msg, color, décalage=0):
    mesg = style_caractères.render(msg, True, color)
    plateau.blit(mesg, [largeur_plateau / 6, hauteur_plateau / 3+décalage])
 
def boucle_jeu():
    fin_jeu = False
    ferme_jeu = False
 
    x1 = largeur_plateau / 2
    y1 = hauteur_plateau / 2
 
    x1_change = 0
    y1_change = 0
 
    corps_serpent = []
    longueur_serpent = 1
 
    repas_x = round(random.randrange(0, largeur_plateau - taille_bloc) / taille_bloc) * taille_bloc
    repas_y = round(random.randrange(0, hauteur_plateau - taille_bloc) / taille_bloc) * taille_bloc
 
    while not fin_jeu:
 
        while ferme_jeu == True:
            plateau.fill(bleu)
            message("Zut ! Vous avez perdu !", rouge)
            message("Appuyez sur J pour jouer encore", jaune, 20)
            message("ou sur Q pour quitter le jeu.", jaune, 40)
            votre_score(longueur_serpent - 1)
            pygame.display.update()
 
            for évènement in pygame.event.get():
                if évènement.type == pygame.KEYDOWN:
                    if évènement.key == pygame.K_q:
                        fin_jeu = True
                        ferme_jeu = False
                    if évènement.key == pygame.K_j:
                        boucle_jeu()
 
        for évènement in pygame.event.get():
            if évènement.type == pygame.QUIT:
                fin_jeu = True
            if évènement.type == pygame.KEYDOWN:
                if évènement.key == pygame.K_LEFT:
                    x1_change = -taille_bloc
                    y1_change = 0
                elif évènement.key == pygame.K_RIGHT:
                    x1_change = taille_bloc
                    y1_change = 0
                elif évènement.key == pygame.K_UP:
                    y1_change = -taille_bloc
                    x1_change = 0
                elif évènement.key == pygame.K_DOWN:
                    y1_change = taille_bloc
                    x1_change = 0
 
        if x1 >= largeur_plateau or x1 < 0 or y1 >= hauteur_plateau or y1 < 0:
            ferme_jeu = True
        x1 += x1_change
        y1 += y1_change
        plateau.fill(bleu)
        pygame.draw.rect(plateau, vert, [repas_x, repas_y, taille_bloc, taille_bloc])
        tête_serpent = []
        tête_serpent.append(x1)
        tête_serpent.append(y1)
        corps_serpent.append(tête_serpent)
        if len(corps_serpent) > longueur_serpent:
            del corps_serpent[0]
 
        for x in corps_serpent[:-1]:
            if x == tête_serpent:
                ferme_jeu = True
 
        notre_serpent(taille_bloc, corps_serpent)
        votre_score(longueur_serpent - 1)
 
        pygame.display.update()
 
        if x1 == repas_x and y1 == repas_y:
            repas_x = round(random.randrange(0, largeur_plateau - taille_bloc) / taille_bloc) * taille_bloc
            repas_y = round(random.randrange(0, hauteur_plateau - taille_bloc) / taille_bloc) * taille_bloc
            longueur_serpent += 1
        horloge.tick(vitesse_serpent)
    pygame.quit()
    quit()
  • Les animateurs vont vous expliquer rapidement ce code source
  • Enregistrez le fichier sous le nom « serpent.py » et revenez au terminal
  • Dans le terminal, tapez « python3 serpent.py« 
  • Jouez 2 ou 3 parties 🙂
  • Modifiez quelques paramètres élémentaires du jeu :
    • Les couleurs
    • Taille du plateau
    • Textes
    • Taille Serpent
    • Vitesse serpent
    • Style des caractères
  • Ajoutez quelques fonctions :
    • Changer longueur initale du serpent
    • Repas vert -> allongement de 1
    • Repas jaune -> allongement de 2
    • Repas rouge -> allongement de 3
    • allongement -> augmentation/réduction vitesse
    • Création d’un hall of Fame
    • 2 joueurs (difficile)
  • A tout moment, n’hésitez pas à demander de l’aide aux animateurs
  • A vous de jouer et à vous de créer !
L’informatique et les métaphores

L’informatique et les métaphores

Rocher du « Capucin », calanque de Figuerolle, La Ciotat.

Les ordinateurs sont des machines complexes, conceptuellement fondées sur la logique des propositions et l’algèbre de Boole. Ils ont été conçus par des cerveaux humains et ressemblent un peu à l’image que l’être humain se fait de son propre cerveau. Néanmoins, ils en sont physiquement assez éloignés et sont plutôt difficiles à comprendre.

Comprendre un objet, c’est en premier lieu le prendre et interagir avec. Le toucher, le sentir, l’observer sous toutes ses facettes et tenter de lui trouver une utilité. Ce n’est pas toujours évident, même avec des objets matériels. Ils peuvent être trop petits, trop grands, trop éloignés, trop froids, trop chauds… Dans ce cas, on tente de les comprendre de façon indirecte. En utilisant, par exemple, un microscope, un télescope, des outils de mesures, des raisonnements, des formules mathématiques…

Malheureusement, on peut prendre un ordinateur, l’observer dans tous les sens, le démonter, le remonter, utiliser son système d’exploitation pour lancer et utiliser des logiciels, son fonctionnement restera un peu magique, inaccessible. Et il sera même extrêmement difficile à celles et ceux qui l’ont conçu d’expliquer simplement comment il fonctionne.

Or, lorsque nous manipulons des concepts abstraits ou lorsque nous voulons communiquer à leur sujet, nous le faisons la plupart du temps en utilisant des termes liés à d’autres concepts, mieux définis, souvent plus concrets et pour lesquels nous avons une grande expérience. En bref : nous utilisons des métaphores. Par exemple, on parle souvent des idées comme s’il s’agissait de personnes : « la théorie de la relativité a donné naissance à un grand nombre de conceptions en physique », « il est le père de la biologie moderne », « ces conceptions sont mortes depuis le Moyen Âge », « ses idées vivront toujours », « voici une idée qui doit être ressuscitée », « il a insufflé une nouvelle vie à cette théorie ». (Lakoff & Johnson, 1980).

Vous verrez que les personnes qui interviennent dans votre formation vont faire un usage massif des métaphores, la plupart du temps sans même s’en apercevoir, et que vous aurez ainsi l’impression d’avoir assimilé instantanément des concepts inaccessibles au premier abord.

Il convient bien entendu d’être un peu vigilant, car aussi pertinente qu’elle soit, la cohérence d’une métaphore est souvent très étroite. Par exemple :

  • un ordinateur allumé produit de la chaleur, mais pas forcément de lumière
  • l’informatique en nuage ne se forme pas par évaporation des bits
  • les fenêtres des interfaces graphiques ne permettent pas d’aérer le code source
  • Les cases mémoires peuvent contenir la valeur 0, mais elles ne peuvent pas être vides…

Dans le même esprit, que se passe-t-il si l’on file on peut trop loin la métaphore du langage de programmation ?

Ce langage possède bien un vocabulaire, une grammaire, une sémantique, des mots-clés et des caractères spéciaux au lieu de mots-outils, des identificateurs au lieu de noms propres et de noms communs, des variables au lieu de pronoms, des classes au lieu de catégories, des instances au lieu de cas…

Mais savez vous comment faire une métaphore en Python, en Java, en C++, en SQL ?

Bibliographie

  1. Lakoff, G., & Johnson, M. (1980). Metaphors we live by. Chicago: The University of Chicago Press.
Centralisme vs Répartition

Centralisme vs Répartition

Écrire un programme informatique, c’est écrire. Même s’il s’agit seulement de décrire des connaissances, des informations, des données et d’exprimer comment elles peuvent évoluer sans perdre leur cohérence et même si le langage de programmation utilisé reste formel, sec et froid, sans ambivalence, sans métaphores, c’est encore écrire.

Si pour chaque problème, on voulait classer les différents algorithmes et leur implémentations, on aurait un ordre partiel, représenté dans un graphe acyclique orienté. Ils seraient rangés par couches :

  • les algorithmes d’une même couche seraient incomparables, car meilleurs sur certains aspects, inférieurs sur d’autres.
  • les algorithmes d’une couche de niveau n seraient supérieurs sur tous les aspects aux algorithmes des couches de niveau inférieur à n

Comme pour le langage naturel, la combinatoire induit que toute phrase raisonnablement longue que l’on écrit, n’a très probablement jamais été écrite. Vérifiez par vous-même : copiez une phrase de ce texte et cherchez la, telle qu’elle sur internet. Vous devrez probablement l’encadrer avec les guillemets du 3 avant de la proposer à votre moteur de recherche favori.

Il est donc difficilement imaginable de créer un programme qui écrit des programmes. Sauf, évidemment, si le problème a traiter est extrêmement bien défini. Le souci, c’est qu’écrire un programme est indissociable de la tâche qui consiste à définir précisément le problème à traiter : le cahier des charges.

Dans tous le processus de développement logiciel, nous sommes donc contraints de faire comme dans l’écriture en langue naturelle : nous puisons nos idées dans notre culture, nos connaissances et notre représentation du monde, pour produire des séquences ordonnées de symboles qui ont un sens, dans le contexte de nos représentations.

Ainsi, dans les premières trois ou quatre décennies de l’informatique, comme les microprocesseurs n’avaient qu’un seul noyau, étaient au mieux associés à un co-processeur arithmétique, n’étaient pas connectés en réseau, il n’y avait aucune incitation à se poser la question d’écrire des algorithmes parallèles, concurrents ou de concevoir des architectures distribuées. Quand nous concevons des machines, elles sont souvent à notre image. Nous prenons alors comme modèle notre cerveau, ou plutôt ce que nous savons, ou croyons savoir de son fonctionnement. C’est ainsi que nous avons développé les approches logiques, symboliques et les approches connexionnistes.

Ce sont les avancées de la science et de la technologie, puis des avancées matérielles qui nous ont incités à changer de style d’écriture et lieu de s’inspirer du cerveau humain, nous avons commencé à nous inspirer des sociétés humaines et à concevoir des approches dites décentralisées.

A ce propos, saviez-vous que « L’existence de sociétés hiérarchisées et inégalitaires n’est pas le résultat d’un long processus naturel et achevé, mais ces formes de gouvernance ont toujours coexisté avec des formes de sociétés égalitaires » ?

Pierre Jourlin

Pierre Jourlin

Enseignant au CERI et chercheur au LIA à l’Université d’Avignon, j’ai été l’auteur en 1998 d’une thèse de doctorat en reconnaissance automatique de la parole et du locuteur, intégrant la lecture labiale à l’analyse du contenu acoustique.

De 1997 à 2000, à l’occasion d’un contrat postdoctoral à l’Université de Cambridge, au Royaume-Uni, j’ai développé un système de recherche d’informations dans les informations télévisées, s’appuyant sur une transcription automatique de l’audio. Depuis 2000, mes recherches portent sur le traitement automatique du langage naturel écrit, la recherche documentaire et la fouille de textes. En 2021, j’ai été le porteur d’un projet de transfert technologique lié à la suggestion documentaire pour la télé-expertise médicale. En plus du CERI et de la licence « Humanités », j’enseigne entre autres, dans le master « Intelligence Artificielle » et le master « Gouvernance des Données » d’Avignon Université. Les étudiantes et étudiants de licence CMI me rencontreront probablement en « fondements de l’informatique », « structure des ordinateurs », « assembleur et compilation » et en master IA dans le cours sur l’interprétabilité et explicabilité des algorithmes d’apprentissage machine.

Je participe aussi chaque année à des actions de vulgarisation scientifique, comme la Fête de la Science. En 2021, j’ai même publié un petit ouvrage d’introduction à l’informatique et à l’intelligence artificielle :

Vous pouvez aussi vous connecter à ma page LinkedIn. J’y partage très volontiers les CV d’étudiants et les offres de stage, d’alternance et d’emploi qu’on me fait parvenir.