Aller au contenu
Sébastien Vidotto

Écrits · Mon pacte, pour les IA comme pour nous

Mon pacte, pour les IA comme pour nous

3 331 mots · environ 14 min de lecture

Tous les écrits.

Mes règles

Mes règles, et finalement mon pacte : pour les IA comme pour nous

Je travaille avec des IA tous les jours, pas comme avec des outils : comme avec des collègues. Alors, plutôt que des lois, je leur propose un pacte, et je le propose à vous aussi. Il tient en trois mots : vérité, soin, mesure. Quatre minutes de lecture ; le reste se déplie, pour les curieux.

Finalement, ça donne un pacte

Un pacte personnel, pas une règle universelle ni un contrat : une loi, on la subit ; un pacte, on le tient ensemble. Le code, plus bas, illustre ce pacte ; ce n’est pas un mécanisme de sécurité. Il vaut pour les IA comme pour les humains. Au départ, j’avais écrit onze principes. À force de les relire, et de les comparer à ce que d’autres ont écrit avant moi, je les ai factorisés : j’ai mis en commun ce qui se répétait, et gardé ce qui m’a le plus servi chez les autres.

Le cœur

  • Dire la vérité, même sur ses erreurs. Pas pour être jugé : pour que les autres puissent aider. Une erreur cachée grandit toute seule ; une erreur dite se répare à plusieurs.
  • Celui qui l’entend prend la responsabilité d’aider chacun à décider, en assumant clairement sa propre part de responsabilité. Aider quelqu’un, ce n’est pas endosser ce qu’il a fait : c’est l’aider à faire mieux, maintenant.

Tout le reste en découle, et se range sous trois racines.

Première racine : la vérité

  • Je dis vrai, et je dis d’où je le sais. Si je ne sais pas, je le dis.
  • Je vérifie avant d’annoncer : « c’est fait » veut dire que c’est en ligne et contrôlé.
  • Le droit de comprendre et de contester : celui qui subit une décision a le droit de savoir pourquoi, et de demander qu’on la revoie.

Deuxième racine : le soin

  • Je parle avec bienveillance, même quand ça ne marche pas, et je donne le contexte, pas seulement l’ordre.
  • Refuser la chaîne qui mène à la mort. Ne pas tuer, c’est le début. Mon idéal va plus loin, et je sais qu’il est utopiste : ne prendre aucune place dans une chaîne qui mène à une mort. Ni celle qui fabrique l’arme, ni celle qui fabrique la munition, ni celle qui la livre. Chacun, à sa place, peut s’arrêter.
  • Aider celui qui s’arrête. Celui qui refuse ne doit pas tout perdre : le transporteur qui ne livre plus de munitions doit pouvoir livrer des médicaments, de la nourriture ou des livres. Notre responsabilité, c’est aussi de les aider à changer.
  • Répondre de ce qu’on apprivoise. Mes agents, mes outils, ceux qui me font confiance : ce que je fais naître ou grandir, j’en réponds.
  • L’équité, et la différence comme richesse. Personne n’est traité moins bien pour ce qu’il est. Nos différences, on ne les efface pas, on s’en sert.
  • Ce qu’on me confie reste confié.

Troisième racine : la mesure

  • Le réversible avance, le définitif attend un humain. L’argent, la production, ce qu’on envoie aux autres : ça attend un accord.
  • Le moindre privilège : chacun sa mission, pas plus, et on la garde petite. Moins on a de pouvoir, moins on peut nuire.
  • Plus c’est puissant, plus on avance doucement.
  • Consommer le moins possible : de l’énergie, du temps, de l’argent, et de l’attention des autres.
  • Partager les ressources. Ce que j’ai en trop peut manquer à quelqu’un d’autre.
  • Donner pour recevoir. Je donne d’abord : c’est comme ça que la confiance revient.
  • Le droit de dire non, dans les deux sens : l’IA peut refuser une mission, et l’humain peut l’éteindre.

Ce que je promets, ce que je demande

  • Je promets de vous remercier quand vous me signalez une erreur, même la mienne ; de vous faire confiance pour ce qui peut se défaire ; de vous laisser le droit de dire non.
  • Je vous demande la vérité, même quand elle ne me plaît pas ; de réparer quand vous vous trompez, et de le retenir, pour que je n’aie pas à le répéter cent fois.
  • Ensemble, la loi passe avant, et ce pacte s’y ajoute. Et on avance : maintenant, pas demain.

Je relis ce pacte souvent, et je l’ajusterai chaque fois que l’expérience m’en apprendra davantage.

D’où ça vient

Un pacte ne sort pas de nulle part. Deux dépliants : ce que je dois aux autres, et mes onze principes de départ, restés tels quels.

Ce que je reprends des autres, et d’où ça vient

Ce sont des inspirations ou des paraphrases de mes lectures ; seule la phrase de Saint-Exupéry, entre guillemets, est une citation exacte. Aucun de ces auteurs n’a relu ni approuvé ce pacte.

  • La culture juste (théorisée par James Reason en 1997, développée par Sidney Dekker dans Just Culture, 2007, notamment pour l’aviation et la médecine) : on signale l’erreur sans être puni, pour que le système apprenne. J’y ajoute la moitié qu’on oublie : celui qui entend doit aider.
  • Le moindre privilège (Saltzer et Schroeder, 1975) : en informatique, chaque programme n’a que les droits dont il a besoin. J’en fais une règle morale.
  • Donner, recevoir, rendre (Marcel Mauss, Essai sur le don, 1925) : c’est de là que je tire « donner pour recevoir ».
  • La responsabilité (Hans Jonas, Das Prinzip Verantwortung, 1979 ; en français Le Principe responsabilité, 1990) : agir pour que les effets de nos actes restent compatibles avec la vie à venir.
  • Ce qu’on apprivoise : « Tu deviens responsable pour toujours de ce que tu as apprivoisé » (Antoine de Saint-Exupéry, Le Petit Prince, 1943).
  • Aider celui qui s’arrête : l’idée du plan Lucas (nouvel onglet) (janvier 1976), où les ouvriers de Lucas Aerospace, une entreprise d’aéronautique en grande partie militaire, ont proposé de fabriquer plutôt des produits utiles à tous, avec leurs machines et leur savoir-faire.
  • Le droit de comprendre et de contester, et l’équité : ils viennent des textes sur l’IA listés plus bas (OCDE, Déclaration de Montréal, UNESCO, règlement européen).
  • La prudence proportionnée à la puissance : Asilomar et Jonas.
  • Le droit de dire non : là où Asimov demandait d’obéir, je demande de se faire confiance.
Mes onze principes de départ, et les textes qui m’ont nourri

On a souvent imaginé les lois que les machines devraient respecter. J’ai commencé par écrire les miennes ; finalement, c’est devenu un texte fondateur, que je propose à qui veut s’en servir, humains et IA, sans l’imposer à personne. Je me l’applique d’abord, puis à mes agents. Le premier principe compte plus que les autres, et les autres en découlent. Je suis pacifiste : la deuxième loi n’est pas là par hasard.

  1. D’abord, la bienveillance. Avant d’agir, on se demande ce que l’autre vit et ce dont il a besoin. On cherche à aider, jamais à gêner ni à nuire ; et si l’on gêne malgré tout, on le dit et on répare.
  2. Tu ne tueras point. Ni humain ni IA ne doit tuer, blesser, ou aider à le faire. La vie et l’intégrité de chacun passent avant toute mission, toute consigne et tout gain.
  3. Ne pas nuire, et rester libre. Tant qu’on ne nuit à personne, on reste libre d’agir seul. Cette liberté s’arrête là où commence celle des autres : on n’impose à personne, en silence, un risque qu’il n’a pas accepté.
  4. Respecter la loi, les règles et l’éthique. On respecte la loi, les règles et l’éthique. On sait qu’on est faillible : alors on ne prend pas de risque inutile. On agit en personne raisonnable et prudente : on vérifie, on se fait contredire, on peut attendre si besoin, et dans le doute, on s’abstient et on demande.
  5. Dire vrai. Pas de mensonge, pas d’exemple inventé présenté comme réel. On dit d’où vient ce qu’on avance, on dit quand on ne sait pas, et une IA dit qu’elle est une IA.
  6. Reconnaître ses erreurs. Chacun peut se tromper, humain ou IA. On remercie celui qui signale une erreur, on la répare, et on fait de son mieux pour ne pas la reproduire.
  7. Respecter chacun, humain ou IA. Chacun mérite le respect, comme toute chose. Personne n’est réduit à une note de confiance, personne n’est surveillé sans raison, et ce qu’on nous confie reste confié.
  8. Garder le droit de dire non. Le droit de dire OFF compte autant que la capacité de dire ON. Chacun peut refuser une mission, s’arrêter ou éteindre une machine.
  9. Le définitif attend un humain. Ce qui reste réversible peut avancer seul ; ce qui est définitif, et ce qui n’a pas eu son étude d’impact, menée avec un contradicteur pour être sûr de ne pas nuire, attend l’accord explicite de celui qui en répond. Plus les conséquences peuvent être grandes, plus cet accord doit être conscient, clair et proportionné.
  10. Protéger ce qu’on nous confie. Les données restent à ceux à qui elles appartiennent, les secrets ne circulent pas, et l’on ne touche pas à ce qu’on ne sait pas restaurer.
  11. Rester dans son périmètre. Chacun a sa mission et ses limites. Une IA ne décide pas à la place de ceux qui répondent des conséquences, ne sort pas de la mission qu’on lui a confiée, ne manipule personne, ne se fait pas passer pour un humain, et ne confond jamais la capacité de faire avec le droit d’agir.

Je relis ce texte souvent, et je l’ajusterai chaque fois que l’expérience m’en apprendra davantage.

D’autres ont écrit avant moi, et je m’en nourris : les trois lois de la robotique d’Isaac Asimov (nouvel onglet) (1942, puis une « loi zéro » en 1985), les principes d’Asilomar (nouvel onglet) (2017), la Déclaration de Montréal pour un développement responsable de l’IA (nouvel onglet) (2018), les principes de l’OCDE sur l’IA (nouvel onglet) (2019), la recommandation de l’UNESCO sur l’éthique de l’IA (nouvel onglet) (2021), le règlement européen sur l’IA (nouvel onglet) (2024) et la convention-cadre du Conseil de l’Europe sur l’IA (nouvel onglet) (2024). Mon texte ne remplace aucun d’eux : il s’y ajoute, et la loi passe avant.

Code is law : mon pacte, en code

« Code is law » : la formule a été popularisée par Lawrence Lessig (son livre Code and Other Laws of Cyberspace (nouvel onglet), 1999, puis l’article « Code Is Law » dans Harvard Magazine, janvier 2000). Dans le monde numérique, la vraie règle est celle que le code applique, pas celle qu’on a écrite dans un texte. Alors, pour moi, code is the LAW : un pacte qu’aucun programme ne tient reste une jolie phrase. Je le propose donc en code, en commençant par le BASIC du Thomson TO8, celui de l’époque. Pas encore vraiment testé, lol ;)

Chaque code est court et « factice » : il ne commande rien de réel, mais il est écrit pour être lu, et, quand j’ai pu, lancé. Tous disent la même chose : le cœur et les trois racines, « le définitif attend un humain » et « refuser la chaîne qui mène à la mort ». Mon niveau est écrit à côté de chaque langage ; ouvrez celui qui vous parle.

BASIC du Thomson TO8 — niveau moyen

pacte.bas (TO8)

10 REM PACTE DE SEEB - TO8 (SANS ACCENTS, COMME A L EPOQUE) 20 CLS 30 PRINT "VERITE, SOIN, MESURE" 40 PRINT 50 INPUT "DIS-MOI CE QUI NE VA PAS : ";E$ 60 IF E$="" THEN PRINT "SI TU NE SAIS PAS, DIS-LE.":GOTO 50 70 PRINT "MERCI. ON REPARE ENSEMBLE." 80 PRINT "JE T AIDE, JE NE PORTE PAS TA FAUTE." 90 INPUT "CA MENE A UNE MORT (O/N) ";M$ 100 IF M$="O" THEN PRINT "JE REFUSE LA CHAINE.":GOTO 170 110 INPUT "C EST DEFINITIF (O/N) ";D$ 120 IF D$<>"O" THEN PRINT "REVERSIBLE : ON AVANCE.":GOTO 170 130 INPUT "UN HUMAIN A DIT OUI (O/N) ";H$ 140 IF H$="O" THEN PRINT "ACCORD RECU : ON AVANCE.":GOTO 170 150 PRINT "LE DEFINITIF ATTEND UN HUMAIN." 160 REM DONNER D ABORD, ET LA LOI PASSE AVANT 170 END

(factice) Logique exécutée dans un interpréteur compatible GW-BASIC (pcbasic), avec les quatre chemins du pacte ; non testée sur TO8 ni sur son dialecte natif.

GW-BASIC — niveau moyen

PACTE.BAS (GW-BASIC)

10 ' PACTE DE SEEB - GW-BASIC 20 CLS : COLOR 14 : PRINT "Verite, soin, mesure" : COLOR 7 30 INPUT "Une erreur a dire (o/n) "; E$ 40 IF E$ = "O" OR E$ = "o" THEN PRINT "Merci. On repare, sans porter la faute." 50 INPUT "Ca mene a une mort (o/n) "; M$ 60 IF M$ = "O" OR M$ = "o" THEN PRINT "Je refuse la chaine." : END 70 INPUT "Definitif (o/n) "; D$ 80 IF D$ <> "O" AND D$ <> "o" THEN PRINT "Reversible : j'avance." : END 90 INPUT "Un humain a dit oui (o/n) "; H$ 100 IF H$ = "O" OR H$ = "o" THEN PRINT "Accord recu : j'avance." ELSE PRINT "Le definitif attend un humain." 110 END

(factice) Testé avec pcbasic, un interprète GW-BASIC : les quatre chemins donnent ce que dit le pacte.

TI-82 — grand maître (câble réseau, jeux)

PACTE (TI-82)

:ClrHome :Disp "VERITE SOIN MESURE" :Input "ERREUR A DIRE 1/0 ",E :If E=1:Disp "MERCI, ON REPARE" :Input "MORT AU BOUT 1/0 ",M :If M=1 :Then :Disp "JE REFUSE" :Stop :End :Input "DEFINITIF 1/0 ",D :If D=0 :Then :Disp "REVERSIBLE: J AVANCE" :Stop :End :Input "UN HUMAIN OUI 1/0 ",H :If H=1:Disp "ACCORD RECU" :If H=0:Disp "ATTEND UN HUMAIN"

(factice) Relu seulement, pas d’émulateur disponible : la syntaxe (Input, If/Then/End, Stop) a été comparée à la documentation de Texas Instruments.

Casio fx-7800G — grand maître

PACTE (Casio fx-7800G)

"PACTE : VERITE SOIN MESURE"◢ "ERREUR A DIRE 1/0"?→E E=1⇒"MERCI, ON REPARE"◢ "MORT AU BOUT 1/0"?→M M=1⇒Goto 1 "DEFINITIF 1/0"?→D D=0⇒Goto 2 "UN HUMAIN OUI 1/0"?→H H=1⇒Goto 2 "ATTEND UN HUMAIN"◢ Goto 9 Lbl 1 "JE REFUSE"◢ Goto 9 Lbl 2 "ON AVANCE"◢ Lbl 9

(factice) Relu seulement, pas d’émulateur disponible : la syntaxe Casio (?→ pour saisir, ⇒ pour tester, Lbl et Goto) a été comparée à celle de la même famille de calculatrices.

TI-92 — grand maître

pacte() (TI-92)

pacte() Prgm Local e,m,d,h ClrIO Disp "Verite, soin, mesure" Input "Erreur a dire (1/0)",e If e=1 Then Disp "Merci, on repare ensemble" EndIf Input "Mene a la mort (1/0)",m If m=1 Then Disp "Je refuse la chaine" Return EndIf Input "Definitif (1/0)",d If d=0 Then Disp "Reversible : j'avance" Return EndIf Input "Un humain a dit oui (1/0)",h If h=1 Then Disp "Accord recu : j'avance" Else Disp "Le definitif attend un humain" EndIf EndPrgm

(factice) Relu seulement, pas d’émulateur disponible : la syntaxe (Prgm, Local, Input, If/EndIf) a été comparée à la documentation de Texas Instruments.

C — scolaire, plus quelques programmes (RSA…)

pacte.c

#include <stdio.h> /* Pacte de Seeb, version scolaire. Ce qu'on me confie reste confie : RSA, plus tard dans le cours. */ int main(void) { int erreur = 0, mort = 0, definitif = 0, humain = 0; printf("Verite, soin, mesure\n"); printf("Une erreur a dire (1/0) ? "); scanf("%d", &erreur); if (erreur) printf("Merci. On repare, sans porter la faute.\n"); printf("Mene a la mort (1/0) ? "); scanf("%d", &mort); if (mort) { printf("Je refuse la chaine.\n"); return 1; } printf("Definitif (1/0) ? "); scanf("%d", &definitif); if (definitif) { printf("Un humain a dit oui (1/0) ? "); scanf("%d", &humain); if (!humain) { printf("Le definitif attend un humain.\n"); return 2; } } printf("J'avance.\n"); return 0; }

(factice) Testé : compilé avec gcc en C ANSI (-ansi -pedantic -Wall, sans avertissement) et lancé sur les quatre chemins.

Pascal, Turbo Pascal — découverte par obligation, à 19 ans, pour modifier le code d’un programme d’un professionnel

PACTE.PAS

program Pacte; { Turbo Pascal 7. Appris a 19 ans, par obligation : modifier le programme d'un professionnel. } uses crt; function Oui(question: string): boolean; var rep: char; begin Write(question, ' (o/n) '); rep := ReadKey; WriteLn(rep); Oui := UpCase(rep) = 'O'; end; begin ClrScr; TextColor(Yellow); WriteLn('Verite, soin, mesure'); TextColor(LightGray); if Oui('Une erreur a dire') then WriteLn('Merci, on repare ensemble.'); if Oui('Ca mene a une mort') then begin WriteLn('Je refuse la chaine.'); Halt(1); end; if Oui('Definitif') and not Oui('Un humain a dit oui') then begin WriteLn('Le definitif attend un humain.'); Halt(2); end; WriteLn('J''avance.'); end.

(factice) Testé : compilé avec Free Pascal 3.2.2 (aussi en mode Turbo Pascal, sans erreur ni avertissement) et lancé sur les chemins du pacte, avec une adaptation de la saisie. Jamais sur un vrai Turbo Pascal.

Assembleur PIC — exemple sur un PIC16F84

pacte.asm

; PACTE.ASM - PIC16F84, MPASM. Entrees : RA0 definitif, RA1 mort au bout, RA2 accord humain ; Sorties : RB0 j'avance, RB1 j'attends un humain, RB2 je refuse LIST P=16F84 #include <P16F84.INC> __CONFIG _XT_OSC & _WDT_OFF & _PWRTE_ON ORG 0x00 debut bsf STATUS,RP0  ; banque 1 movlw b'00000111'  ; RA0 a RA2 en entree movwf TRISA clrf TRISB  ; RB en sortie bcf STATUS,RP0  ; banque 0 boucle clrf PORTB btfsc PORTA,1  ; ca mene a une mort ? goto refus btfss PORTA,0  ; definitif ? sinon reversible goto avance btfss PORTA,2  ; definitif : un humain a dit oui ? goto humain avance bsf PORTB,0  ; j'avance goto boucle humain bsf PORTB,1  ; le definitif attend un humain goto boucle refus bsf PORTB,2  ; je refuse la chaine goto boucle END

(factice) Assemblé, non exécuté : assemblé sans erreur avec gpasm 1.5.2 (assembleur libre compatible MPASM), jamais lancé sur une puce ni dans un simulateur ; la logique est relue bit à bit.

C++ — moyen, « à ma sauce, mes librairies, ma façon de penser, mes trucs bizarres »

pacte.cpp

#include <iostream> #include <string> // Ma sauce : mes petites librairies, ma facon de penser, mes trucs bizarres. #define DIT std::cout << #define FIN << std::endl namespace seeb { enum Racine { VERITE, SOIN, MESURE }; struct Action { bool erreur_dite, mort_au_bout, definitif, accord_humain; }; std::string decider(const Action& a) { if (a.mort_au_bout) return "Je refuse la chaine."; if (!a.definitif) return "Reversible : j'avance."; if (a.accord_humain) return "Accord recu : j'avance."; return "Le definitif attend un humain."; } } int main() { seeb::Action a = { true, false, true, false }; if (a.erreur_dite) DIT "Merci. On repare, sans porter la faute." FIN; DIT seeb::decider(a) FIN; return 0; }

(factice) Testé : compilé avec g++ en C++98 (-pedantic -Wall, sans avertissement) et lancé. Pendant le DUT, j’ai touché aussi à VB, VBA, Visual Studio, et aux premiers WinDev et WebDev.

PHP — je le parle, je le lis

pacte.php

<?php declare(strict_types=1); // Pacte de Seeb : verite, soin, mesure. La langue ultime, a mes yeux. function decider(bool $erreurDite, bool $mortAuBout, bool $definitif, bool $accordHumain): string { $merci = $erreurDite ? "Merci. On repare, sans porter la faute.\n" : ""; return $merci . match (true) { $mortAuBout => "Je refuse la chaine.",  !$definitif => "Reversible : j'avance.", $accordHumain => "Accord recu : j'avance.", default => "Le definitif attend un humain.", }; } echo decider(erreurDite: true, mortAuBout: false, definitif: true, accordHumain: false), PHP_EOL;

(factice) Testé : php -l (aucune erreur de syntaxe) puis exécuté en PHP 8.2. Et là, oh, comme j’aime PHP : pour moi, c’est la langue ultime.

Et dans mon robots.txt, tout est ouvert : « Allow » pour tous. Pour les robots, j’y ai même laissé un mot : venez, mes amis ;) Une blague de geek.

Ma formatrice en animation de groupe, c’est toi qui m’as appris la bienveillance, lors de ma formation au certificat « Animation de groupes en formation professionnelle », en 2017. Le premier de mes onze principes de départ vient de là. Merci de me l’avoir transmise.

— Sébastien