Cette revue de presse sur Internet fait partie du travail de veille mené par l’April dans le cadre de son action de défense et de promotion du logiciel libre. Les positions exposées dans les articles sont celles de leurs auteurs et ne rejoignent pas forcément celles de l’April.

• [clubic.com] Intel voudrait un meilleur retour sur investissement pour… ses projets open-source
• [Next] La Free Software Foundation a 40 ans: nouveau président et projet de téléphone libre
• [Reporterre] Fin de Windows 10: ne jetez pas votre PC trop vite!
• [Paperjam News] La blague de l'open source base de souveraineté

[clubic.com] Intel voudrait un meilleur retour sur investissement pour… ses projets open-source

✍ Mélina Loupi, le samedi 11 octobre 2025.

Intel diffuse depuis plusieurs années une variété de logiciels open source largement utilisés dans le secteur technologique. Récemment, Kevork Kechichian, à la tête de la division Data Center chez Intel, a indiqué que l’entreprise souhaite que ses contributions apportent un avantage plus direct à ses propres produits, et non principalement à ses concurrents.

[Next] La Free Software Foundation a 40 ans: nouveau président et projet de téléphone libre

✍ Vincent Hermann, le jeudi 9 octobre 2025.

L’ONG a fêté ses 40 ans le 4 octobre. Elle a profité d’un évènement dédié pour faire plusieurs annonces, dont la nomination de son nouveau président, Ian Kelling. La FSF a également provoqué une petite surprise en annonçant un projet de téléphone libre, nommé sobrement LibrePhone.

[Reporterre] Fin de Windows 10: ne jetez pas votre PC trop vite!

✍ Benjamin Douriez, le mardi 7 octobre 2025.

Face aux critiques, Microsoft consent à prolonger d’un an le support pour Windows 10. Mais sous conditions. Le point sur les différentes solutions pour éviter de jeter les PC concernés.

[Paperjam News] La blague de l'open source base de souveraineté

✍ Thierry Labro, le mardi 23 septembre 2025.

L’open source est un colosse aux pieds d’argile: si, à ses balbutiements, il louait la noble ambition de libérer la créativité, les Big Tech ont compris avec internet, puis avec le lancement de leurs propres produits, qu’elles n’avaient pas intérêt à laisser le logiciel libre se développer. Aujourd’hui, elles contrôlent financièrement et humainement tous les acteurs majeurs. Même l’UE doit s’extirper du guêpier dans lequel elle s’est fourrée.

Samedi 4 octobre 2025, la Free Software Foundation (FSF) fête ses 40 ans d'existence ! 4 décennies pour défendre les 4 libertés fondamentales sur lesquelles se fonde le logiciel libre.

• la liberté d'exécuter le programme, pour tous les usages ;
• la liberté d'étudier le fonctionnement du programme et de l'adapter à ses besoins ;
• la liberté de redistribuer des copies du programme (ce qui implique la possibilité aussi bien de donner que de vendre des copies) ;
• la liberté d'améliorer le programme et de distribuer ces améliorations au public, pour en faire profiter toute la communauté.

Pour revenir sur ces 40 ans de combat en faveur du logiciel libre, j'ai eu l’honneur de pouvoir avoir un entretien avec Richard Stallman (RMS), fondateur du projet GNU, de la FSF, et l’initiateur du mouvement du logiciel libre.

Vous trouverez la transcription de cet entretien dans cette dépêche, ainsi que le lien vers la vidéo de celle-ci.

Merci du fond du cœur à Richard pour sa gentillesse, sa patience et sa bienveillance pour cette interview qui était une première pour moi. Entre le stress et mes bégaiements, il fallait bien quelqu'un d'aussi cool que lui. 😅

Et un grand merci aussi à Aurore, la monteuse de cette vidéo, qui a réussi astucieusement à masquer ces fameux bégaiements ! 😉

Le texte de cet entretien est sous licence CC-BY-ND

Stéphane :
Bonjour Richard.

Richard :
Bonjour, c’est un plaisir.

Stéphane :
Le plaisir est pour moi également. Merci beaucoup de me permettre de t’interroger à l’occasion des 40 ans de la Free Software Foundation. Pour commencer, puisque l’histoire de la FSF est indissociable de celle du projet GNU, j’aimerais revenir aux origines. Comment est né le projet GNU ? Pourquoi ce nom, quelle en était la philosophie, les fondements techniques ? Et en quoi la création de la FSF, deux ans plus tard, a-t-elle été une continuité de ce projet ?

Richard :
J’ai d’abord décidé de développer un système d’exploitation constitué uniquement de logiciels libres. Dans les années 1970, j’utilisais déjà un système libre, développé dans le même laboratoire que moi, et mon travail consistait à l’améliorer en modifiant son code. Tout le monde pouvait accéder à ce code, c’était dans les faits du logiciel libre. Mais ce système a fini par disparaître, ainsi que la communauté qui l’entourait.

Pour moi, ce fut une perte immense. J’ai alors pris conscience du caractère injuste et tyrannique du logiciel privateur. J’ai compris que cela ne pourrait jamais être juste. Pour remplacer ce que j’avais perdu, je voulais créer un autre système libre, capable de soutenir une communauté similaire. J’ai choisi de m’inspirer de l’organisation d’Unix : c’était le meilleur modèle à suivre.

Je cherchais aussi un acronyme récursif comme nom : GNU, pour GNU’s Not Unix. Cela ajoutait une touche d’humour. J’ai annoncé publiquement le projet en septembre 1983 et invité d’autres personnes à développer les différents composants, car un système de type Unix se compose de nombreux éléments plus ou moins indépendants.

Deux ans plus tard, nous avions suffisamment de succès pour qu’il devienne utile de créer une fondation : pour gérer les financements, conserver les droits d’auteur et soutenir le projet. C’est ainsi qu’est née la FSF, Free Software Foundation, ou Fondation pour le logiciel libre en français.

Ce point est d’ailleurs important : en français, la distinction entre "gratuit" et “libre” est claire. Cela m’a appris à préciser en anglais : depuis vingt ans, je n’emploie plus “free” pour dire gratuit, je dis gratis. Et pour la liberté, j’utilise toujours freedom. Ainsi, il n’y a plus d’ambiguïté.

Stéphane :
En anglais, l’ambiguïté est apparue avec le logiciel : auparavant, le contexte levait toute confusion. Mais dans l’informatique, on trouve des programmes gratuits… qui ne sont pas libres du tout.

Richard :
C’est vrai. Et inversement, on peut payer pour acquérir une copie d’un programme libre. Les deux catégories — libre et gratuit — sont indépendantes.

Stéphane :
Exactement. Et donc, la FSF permettait non seulement de financer le projet, mais aussi de garantir les droits d’auteur. Car il est légalement impossible de rédiger une licence qui assure à 100 % qu’un programme restera libre. Par exemple, si je publie un logiciel sous GPL, ceux qui utiliseront mon logiciel, devront publier leurs modifications sous la même licence. Mais moi, je pourrais rendre à tout moment le code privateur…

Richard :
Il faut bien distinguer deux choses : ce que l’auteur peut faire, et ce que les utilisateurs, qui reçoivent le logiciel sous une licence libre, peuvent faire. Les utilisateurs sont légalement contraints par la licence : s’il s’agit d’une licence avec gauche d’auteur (copyleft), ils ne peuvent créer que des versions libres.

Mais l’auteur, lui, ne dépend pas de sa propre licence : il reste propriétaire du code. Il peut donc publier une autre version, y compris privatrice. Mais s’il est un activiste du logiciel libre, il ne voudra pas le faire.

Stéphane :
Bien sûr. Et c’est là qu’une fondation comme la FSF est essentielle : elle garantit que les logiciels sous son copyright resteront toujours libres.

Richard :
Oui. C’est la mission de la FSF : protéger la liberté des utilisateurs. Autrement dit, éviter qu’un utilisateur ne prenne du pouvoir sur les autres. Si la liberté est pour tous, ça veut dire que personne n'a de pouvoir sur personne.

Stéphane :
On comprend donc bien le rôle essentiel de la FSF, en complément du projet GNU : protéger juridiquement, notamment via le droit d’auteur, et assurer aussi un soutien financier. Parce qu’il arrive que certaines entreprises publient des logiciels qu’elles qualifient de « libres » ou « open source » — les deux termes étant souvent confondus —, mais parfois dans l’unique but de profiter du travail bénévole, avant de fermer le code…

Richard :
Je préfère qu’on n’utilise pas les termes « ouvrir » ou « fermer », car cela renvoie à la logique de l’open source. Or, moi, je ne défends pas l’open source, je défends la liberté.
Il est vrai que la plupart des programmes dits open source sont aussi libres. Mais certains ne le sont pas, et il est important de faire la distinction. Puisque notre combat porte sur le logiciel libre, il est plus clair d’éviter les expressions qui risquent de brouiller le message et de laisser croire qu’il s’agit simplement d’open source.

Stéphane :
Du coup, j’avais une autre question par rapport au début du projet GNU. Avant l’arrivée de Linux… Moi, quand je parle de Linux, comme toi, je parle uniquement du noyau, parce qu’il y a un amalgame terrible entre le système GNU/Linux et le noyau Linux.
Alors, avant 1991, comment les utilisateurs de GNU faisaient-ils pour utiliser le système ?

Richard :
Ils l’utilisaient sur Unix. C’était la seule manière. Nous n’avions pas encore de noyau libre, donc pas de système complet. Les gens installaient les composants GNU et d’autres composants libres sur Unix, pour remplacer certains éléments. Mais il était impossible de tout remplacer. C’était le but, mais il n’était pas encore atteint.

Quand Torvalds a publié la première version de Linux, son noyau n’était pas libre. Il avait assisté à ma conférence en Finlande, mais n’avait pas suivi mes conseils. Il a choisi une licence qui ne donnait pas toutes les libertés nécessaires. Mais six mois plus tard, il a finalement publié Linux sous la GPL de GNU. C’est à ce moment-là que Linux est devenu libre.

De notre côté, nous avions déjà commencé un projet de noyau libre, le Hurd. Au départ, d’après l’évaluation d’un ami, Linux ne paraissait pas très intéressant. Mais il avançait très vite, alors que notre conception, trop complexe, posait beaucoup de difficultés. Finalement, nous avons décidé d’utiliser Linux comme noyau.

Stéphane :
Justement, à ce moment-là, quand Linux a commencé à prendre de l’ampleur, comment se passaient les relations entre la FSF et le projet GNU d’un côté, et Linus Torvalds de l’autre ? Est-ce qu’il a été question, à un moment donné, d’intégrer Linux officiellement comme projet GNU ?

Richard :
Non. Linus n’était pas très amical envers nous. Je soupçonne que notre insistance sur le nom “GNU/Linux” le dérangeait. Il n’aimait pas que nous refusions d’appeler notre projet “Linux”, comme si c’était le sien. Je crois qu’il avait des émotions contradictoires. Parfois, il reconnaissait l’histoire, et parfois il revenait dessus. C’était compliqué, et je ne peux pas deviner ses sentiments exacts.

Stéphane :
Une autre question : le noyau Hurd, qui au départ s’appelait “Alix” si je ne me trompe pas… Est-ce que le fait de le développer comme un micro-noyau a freiné son avancée ? Parce que tu disais que Linux progressait très rapidement. Est-ce que c’était une approche trop avant-gardiste, qui a permis à Linux de prendre l’avantage ?

Richard :
Oui, le développement du Hurd a traîné très longtemps. Et il a rencontré des problèmes fondamentaux, très difficiles à résoudre. Personne ne savait vraiment comment les résoudre. C’est ça qui m’a convaincu qu’il ne valait plus la peine d’insister.

Quant au nom “Alix”, c’était au départ une blague. J’avais une copine qui s’appelait Alix, administratrice d’un groupe Unix. Elle avait plaisanté en disant qu’il faudrait donner son prénom à un noyau. J’ai décidé de le faire, secrètement, pour la surprendre.

Stéphane :
Ça a dû lui faire plaisir.

Richard :
Oui, un peu. Mais ensuite des évènements ont changé les plans, le développeur principal du Hurd préférait le nom “Hurd”. Il a relégué “Alix” à une seule partie du code. Un changement de conception a finalement supprimé cette partie. Et puis, ma copine a changé de nom, et nous nous sommes séparés. Mais certains avaient déjà vu “Alix” apparaître dans le code, la rumeur a circulé, et elle en a ri.

Stéphane :
Donc, si je comprends bien, à l’origine “Alix” désignait l’ensemble du noyau, puis seulement une composante, et cette composante a finalement été supprimée ?

Richard :
Exactement. “Alix” désignait la partie qui gérait les appels système. Mais on a fini par se rendre compte qu’il n’y avait pas besoin de cette couche spécifique : la bibliothèque C pouvait très bien assurer la communication avec les serveurs du Hurd.

Stéphane:
Vous avez laissé le développement de Hurd quand Linux est arrivé.

Richard:
Non, pas immédiatement, quelques années plus tard.

Stéphane :
Au début des années 1990, beaucoup de choses se sont mises en place. On a vu l’arrivée du noyau Linux en 1991, qui, combiné avec GNU, permettait enfin un système complet. Dès 1992, certaines sociétés ont commencé à distribuer des versions commerciales de GNU/Linux, comme Red Hat ou SUSE.
Comment perçois-tu aujourd’hui leur rôle ? Red Hat, par exemple, contribue énormément à des projets libres comme GNOME, dont ils sont même les principaux contributeurs. Mais en même temps, dans leurs discours, ils se revendiquent davantage du mouvement “open source”.

Richard :
Ah non. Ce n’est pas exact de parler d’un “mouvement open source”. L’idée de l’open source n’était pas de se constituer en mouvement.

Stéphane :
C’est vrai.

Richard :
Le mouvement du logiciel libre, est un mouvement pour corriger un mal dans la société, une injustice. Nous disons qu’il faut remplacer les programmes privateurs par des logiciels libres, afin de libérer les utilisateurs de l’informatique. Ceux qui ont lancé l’idée d’“open source”, eux, ont rejeté cette dimension éthique. Ils ne voulaient pas reconnaître l’injustice qu’il y avait à priver les gens de liberté.

Ils présentent l’open source comme quelque chose de plus agréable, une manière plus commode de développer ou d’utiliser un logiciel, si tu en as envie. Mais ils n’ont pas l’objectif de corriger cette injustice. Donc, pour moi, ce n’est pas un mouvement.

Stéphane :
C’est plus une méthode de travail.

Richard :
Oui. D’ailleurs, Eric Raymond a associé l’open source à une méthode de développement particulière. Ce n’était pas uniquement lui : Linus Torvalds avait sans doute initié cette approche. Mais une fois qu’Eric Raymond l’a décrite dans ses écrits, beaucoup de gens ont commencé à l’expérimenter, y compris les développeurs du Hurd.

Finalement, cette méthode s’est retrouvée liée à l’expression “open source”. Mais en vérité, le choix d’une méthode de développement est indépendant de toute philosophie morale.

Stéphane :
Tout à fait. Et donc, dans ce contexte, l’open source, officiellement, naît en 1998 avec l’Open Source Initiative. Mais Red Hat et SUSE distribuaient déjà des versions commerciales de GNU/Linux dès 1992. Est-ce qu’avant la création de l’OSI, ces sociétés avaient la volonté de collaborer réellement avec le mouvement du logiciel libre ?

Richard :
Elles collaboraient parfois, oui. Mais elles agissaient aussi à l’inverse de notre éthique. Les deux en même temps.

Stéphane :
Donc elles avaient déjà des contradictions à l’époque ?

Richard :
Je ne dirais pas des contradictions, car elles n’ont jamais vraiment adhéré aux principes du mouvement du logiciel libre. Dès le début, elles distribuaient un système qui mélangeait beaucoup de programmes libres avec, parfois, des programmes privateurs. Pour nous, c’était un problème.

Nous ne pouvions pas recommander ces distributions, ni dire à quelqu’un “installez Red Hat” ou “installez SUSE”, si elles contenaient des logiciels privateurs.

Stéphane :
Bien sûr. Mais malgré tout, par leurs contributions importantes à des projets libres, est-ce qu’elles pouvaient être considérées comme des alliées ?

Richard :
Oui, en un sens. Mais c’était difficile pour nous de savoir comment en parler. Dans une logique de “donnant-donnant”, on aurait pu se dire : “Puisqu’elles contribuent beaucoup, la récompense naturelle serait de recommander leur système.” Mais pour nous, c’était impossible.

Nous ne pouvions pas recommander l’installation de quoi que ce soit qui contienne un logiciel privateur, car ce serait cautionner une injustice. Cela nous aurait placés dans une contradiction morale.

Stéphane :
Donc, quand l’OSI est créée en 1998, c’est bien une scission. Certains ne se reconnaissaient pas dans l’éthique du logiciel libre. Qu’est-ce qui a réellement provoqué cette séparation ? Était-ce le copyleft ?

Richard :
Non, ça n’avait rien à voir avec le copyleft. C’était une divergence philosophique, fondamentale. Pour nous, tout repose sur une question de liberté et de justice face à l’injustice. Imposer à quelqu'un l'interdiction de partager des copies est injuste et immoral. C’est détestable ! Il faut ne jamais le faire.

Quand il s’agit d’œuvres fonctionnelles — c’est-à-dire destinées à être utilisées — les gens méritent la liberté de collaborer avec les autres. Dans la communauté du logiciel libre, tout le monde n’était pas d’accord avec cette philosophie, mais cela n’empêchait pas de contribuer. On peut contribuer pour d’autres raisons, et ces contributions gardent leur valeur.

Mais la philosophie reste importante.

Stéphane :
Donc, la question du copyleft, à elle seule, n’aurait pas pu provoquer cette scission ? Parce que longtemps j’ai cru qu’un logiciel libre sans copyleft n’était pas vraiment libre.

Richard :
C’etait une erreur. Pourquoi tant de gens la commettent, je ne comprends pas. Sur gnu.org, nous avons une liste de licences que nous avons évaluées, et tu peux voir lesquelles sont libres ou non. Tu verras que beaucoup de licences sans gauche d'auteur — que beaucoup appellent à tort “licences open source” — sont aussi des licences libres.

Les gauches d'auteurs, c’est une autre question philosophique. Entre deux manières de respecter la liberté des utilisateurs :

• soit on exige que les versions modifiées restent libres sous la même licence,
• soit on permet que quelqu’un publie une version modifiée non libre.

Le gauche d'auteur est la méthode qui impose que toute version modifiée reste libre de la même manière. Les licences “permissives”, elles, autorisent des versions modifiés non libres.

Stéphane :
Certaines personnes te trouvent trop radical. Mais finalement, je me rends compte que par certains côtés, j’étais encore plus radical que toi, puisque je voulais exclure du logiciel libre les programmes sans copyleft.

Richard :
C’est vrai, mais j’avais mes raisons. Mon objectif était de pouvoir distribuer un système d’exploitation complet qui respecte la liberté fondamentale des utilisateurs. Et pour cela, les licences sans gauche d'auteur pouvaient suffire pour certains composants de ce système.

Dès les années 1980, il existait déjà des logiciels libres utiles publiés sous des licences sans gauche d'auteur, car ce type de licence existait avant même le gauche d'auteur. Comme il n’était pas nécessaire de les rejeter, je préférais les utiliser.

Stéphane :
Je comprends. Mais sans copyleft, j’ai l’impression qu’il y a un risque : celui qu’un programme soit, un jour, fermé…

Richard :
Soit fermé ou restreint

Stéphane :
Restreint, disons… Oui, je n’ai pas encore ce réflexe de langage d’éviter de dire « fermé ». Ce que je voulais dire, c’est que sans copyleft, on prend un risque : celui que la liberté disparaisse.
Je pense notamment à macOS, basé sur FreeBSD. C’est une version d’Unix libre, mais protégée par des licences sans gauche d'auteur. Résultat : Apple a pu reprendre tout ce travail et construire un système qui prive complètement les utilisateurs de leur liberté. C’est pour ça que je considère le copyleft comme important.

Richard Stallman :
Oui, mais il faut préciser que FreeBSD existe toujours, n’est-ce pas ?

Stéphane :
Tout à fait, c’est vrai.

Richard Stallman :
Les mots que tu as employés laissaient entendre qu’Apple avait pris le pouvoir sur FreeBSD et l’avait rendu privateur. Mais ce n’est pas le cas. Apple a créé sa propre version privatrice, mais n'a pas converti FreeBSD en projet privateur.

Stéphane :
C’est vrai.

Richard Stallman :
Il faut éviter ce genre d’exagération, car elle porte à confusion.

Stéphane :
Mais même s’ils ne l’ont pas supprimé, FreeBSD existe toujours, c’est vrai. Pourtant, Apple bénéficie énormément du travail qui a été fait de manière, disons, « ouverte », et a eu le droit de le « fermer ». Et c'est vrai que…

Richard Stallman :
« Ouverte » et « fermée »…

Stéphane :
Oui, tu as raison. J’ai intégré certains réflexes, comme ne pas confondre open source et logiciel libre. Mais dans les discussions avec des développeurs, les termes « ouvert » et « fermé » reviennent tellement souvent que j’ai tendance à les répéter. Je dois faire attention à ce tic de langage.

Richard Stallman :
Je veux souligner un point philosophique. Le vrai problème, c’est qu’Apple distribue des programmes privateurs. Le fait qu’elle ait utilisé du code libre provenant de FreeBSD pour le développer est secondaire, un détail.
Ce n’est pas pour ça que les actions d'Apple sont injustes. Si Apple avait embauché beaucoup de programmeurs pour écrire un autre code, sans réutiliser celui de FreeBSD, mais avec le même résultat, l’injustice aurait été exactement la même.

Stéphane :
C’est vrai.

Richard Stallman :
Les chercheurs et développeurs de FreeBSD ont écrit ce code, et maintenant Apple l’utilise sans contribuer en retour à la communauté. C'est une autre question morale, mais qui ne relève pas directement du mouvement du logiciel libre.

Stéphane :
D’accord, je comprends.

Richard Stallman :

Le mal qu'Apple fait est un mal à tous les utilisateurs des produits d'Apple. Tout programme privateur, fait toujours du mal à ses utilisateurs. Ma mission est de faire comprendre aux gens cette question.

Je ne veux pas que ce soit confondu avec la question de savoir si les développeurs de FreeBSD ont été récompensés comme ils le méritaient. C'est une autre question qui n'appartient pas à la question du logiciel libre.

Stéphane :
Oui, c’est une question à part, en quelque sorte. On peut avoir un avis dessus, mais ça reste extérieur au mouvement du logiciel libre.

Richard Stallman :
Oui. Et imagine qu’Apple ait payé 100 millions de dollars aux développeurs de FreeBSD pour obtenir l’autorisation de faire ce qu’elle a fait. Est-ce que ça aurait changé quoi que ce soit au problème moral ?

Stéphane :
Non, pas du tout. En réalité, ma question n’était pas sur la rémunération. Elle concernait surtout le fait que l’absence de copyleft a permis à Apple de créer une version dérivée de FreeBSD — même si ce n’est plus vraiment FreeBSD aujourd’hui, vu toutes les modifications — sans donner aux utilisateurs la possibilité de vérifier comment le code fonctionne.

Richard Stallman :
Sans les quatre libertés essentielles qui définissent le logiciel libre. Pour moi, distribuer un programme non libre est toujours injuste, car cela prive les utilisateurs de ces quatre libertés fondamentales, nécessaires pour avoir le contrôle de leur informatique.

Stéphane :
Je voulais aussi te parler de Debian GNU/Linux, lancé en 1993 par Ian Murdoch, avec au départ le soutien de la FSF. Debian a sa propre définition du logiciel libre, un peu différente de celle de la FSF. Comment cela s’est-il passé au début ? Y avait-il une collaboration entre la FSF et Debian ?

Richard :
Oui. La FSF a financé Debian à son commencement. Mais rapidement, le projet, qui comptait plus de contributeurs, a voulu formuler une définition de la liberté différente, avec l’intention d’être équivalente.

À l’époque, j’ai commis une erreur : j’aurais dû vérifier plus attentivement s’il pouvait y avoir des divergences d’interprétation entre le projet GNU et Debian. La définition me paraissait équivalente, même si elle était formulée autrement. J’ai dit : “C’est bon.” Mais en réalité, il y avait des problèmes potentiels.

Plus tard, quand l’open source a émergé, ils ont repris la définition de Debian, je ne sais plus s'il ont changé quelques mots mais ils ont surtout changé l’interprétation. Dès lors, elle n’était plus équivalente à celle du logiciel libre. Il existe aujourd’hui des programmes considérés comme “open source” mais pas comme logiciels libres, et inversement.

J’ai d’ailleurs expliqué ces différences dans mon essai Open Source Misses the Point.

Mais je dois noter, que Debian, enfin, voulait inclure des programmes privateurs dans leur distribution, mais les ont mis ailleurs, pour établir une séparation très claire entre les composants libres et privateurs. Et comme ça, il était possible de recommander la section main de Debian pour installer un système libre. Mais, après quelques changements de politique il y a quelques années ce n'est plus vrai.

Stéphane :
Pourtant, Debian, à l’époque, voulait maintenir une séparation claire entre le libre et le non libre.

Richard :
Oui. Debian mettait les programmes privateurs dans une section distincte, et la partie “main” de Debian pouvait être recommandée comme un système libre. Mais il y a quelques années, ils ont changé leur politique. Aujourd’hui, même l’installeur officiel de Debian peut inclure des pilotes privateurs. Pour cette raison, nous ne pouvons plus recommander Debian, pas même sa section “main”. Et c’est dommage.

Stéphane :
C'est vrai. Oui, ils ont récemment changé leur contrat social qui donne, certains disent, plus de souplesse. Mais en fait, en réalité, c'est que maintenant, il peut y avoir automatiquement quelques pilotes privateurs, que l'installeur officiel de Debian peut installer.

Richard :
Et pour ça, nous ne pouvons plus recommander l'installation de Debian, ni même de la section main de Debian. Et c'est dommage.

Stéphane :
Oui, c'est dommage. C'est quand même une distribution qui est populaire et c'est vrai que c'est dommage qu'elle se dirige du mauvais côté en plus. Et est-ce que tu fais quand même une distinction entre, comment on pourrait dire ça, c'est vrai qu'il n'y a pas de mouvement de l'open source, mais dire les partisans de l'open source et Debian, est-ce que quand même Debian s'inscrit plus dans une logique éthique que l'open source ou est-ce que tu penses qu'aujourd'hui…

Richard :
Oui, c'est vrai. Mais Debian ne le suit pas complètement comme avant. Dommage.
Pour plus d’informations sur ce sujet, je recommande de consulter la page gnu.org/distros.

Stéphane :
Si l’on retrace les 40 années de lutte pour le logiciel libre, on a beaucoup parlé d’acteurs qui se revendiquaient proches du mouvement. Mais il y a aussi eu un adversaire de taille : Microsoft. À l’époque, leur modèle reposait sur la vente de logiciels privateurs à des prix élevés, uniquement en version binaire. En 2001, face à la montée en puissance du logiciel libre, Microsoft s’est inquiété et a multiplié les attaques, en particulier contre la GPL, en tentant de la discréditer.
À ce moment-là, tu avais donné une conférence à l’Université de New York en réponse. Peux-tu nous parler de cette période et de ses enjeux ?

Richard Stallman :
Les grands éditeurs de logiciels privateurs n’ont pas détruit le logiciel libre, ni le mouvement, ni le système GNU — heureusement. Mais je n’ai plus beaucoup de souvenirs précis de cette époque. Par exemple, la conférence à New York… J’en ai donné tellement à travers les années que je ne sais plus laquelle tu évoques.

Stéphane :
Ah, tu ne t’en souviens plus ? Je pensais que cette conférence avait marqué un tournant. Microsoft, à l’époque, avançait notamment l’argument — faux — d’une supposée « viralité » de la GPL, prétendant qu’un programme sous GPL contaminait tout logiciel tournant sur le même système.

Richard Stallman :
Évidemment, c’est faux. Ce qui est vrai, c’est que si tu prends un programme distribué sous GPL et que tu combines son code avec un programme privateur pour en faire un seul logiciel que tu veux redistribuer, tu es confronté à une incompatibilité : tu ne peux pas respecter à la fois la licence privatrice et la GPL. Mais deux programmes distincts tournant sur le même système, ce n’est pas du tout le même cas.

Stéphane :
Et aujourd’hui, quelles sont les relations entre la FSF et Microsoft ?

Richard Stallman :
Il n’y a pas de relation. Nous critiquons simplement les fonctionnalités malveillantes présentes dans leurs logiciels privateurs. Nous en avons une longue liste, avec des centaines d’exemples, publiée sur gnu.org/malware.

Un programme est malveillant lorsqu’il est conçu pour maltraiter l’utilisateur. C’est une tentation forte dans le modèle privateur : le développeur a du pouvoir sur l’utilisateur et peut être tenté de l’abuser, en ajoutant des fonctionnalités qui renforcent son contrôle.

Stéphane :
Et en plus de ça, il y a aussi l’impossibilité de corriger des erreurs légitimes.

Richard Stallman :
Oui. Les logiciels privateurs ont beaucoup d’effets négatifs, mais je distingue clairement les erreurs des fonctionnalités malveillantes.

Stéphane :
Je voudrais aborder le cas particulier du jeu vidéo. Tu en as un peu parlé au début : c’est un domaine qui mêle différents types d’œuvres…

Richard Stallman :
Oui. Je distingue les œuvres fonctionnelles des œuvres artistiques. Les œuvres fonctionnelles — par exemple les logiciels, les recettes de cuisine, les plans d’architecture ou les patrons de couture — sont faites pour être utilisées. Ces œuvres doivent être libres.
À l’inverse, la fiction ou l’art sont destinés à être appréciés, pas utilisés de manière pratique. Dans un jeu vidéo, il y a les programmes qui implémentent les règles — eux doivent être libres, puisque ce sont des logiciels fonctionnels. Mais il y a aussi de l’art, de la musique, de la narration. Ceux-ci peuvent rester privateurs.
Un exemple : le code source de Doom a été libéré, mais pas l'art, pas la musique. Cela a permis à la communauté de créer d’autres variantes du jeu avec des ressources alternatives.

Stéphane :
Oui, exactement. C’est l’exemple que je voulais évoquer : John Carmack avait libéré le moteur, mais pas les assets artistiques. Et cela a donné naissance à une multitude de déclinaisons. D’où ma question : faut-il une licence spécifique pour le jeu vidéo ?

Richard Stallman :
Non. La confusion vient du fait qu’on pense au jeu vidéo comme à un tout, un paquet qui contient tout. En réalité, il faut le décomposer : le moteur, qui est un programme, doit être libre ; l’art et la musique peuvent ne pas l’être. Comme ça, la question devient facile.

Stéphane :
Je voudrais maintenant aborder un sujet de plus en plus présent : la surveillance de masse. Cela inclut les caméras algorithmiques, la reconnaissance faciale, mais aussi les services de messagerie comme WhatsApp, propriété de Meta. Tout cela pose de grandes questions sur la vie privée. Est-ce que la FSF envisage de lutter contre ces technologies, ou est-ce en dehors de son champ d’action ?

Richard Stallman :
La FSF ne peut pas faire grand-chose sur ce terrain. Son rôle est de promouvoir le logiciel libre. Mais si un logiciel de surveillance appartient à l’État, il doit être libre : l’État doit avoir le droit de le modifier. Ce serait même dangereux qu’il dépende d’une entreprise privée pour gérer ses propres systèmes.
Cependant, le problème de la surveillance ne disparaît pas parce que le logiciel utilisé est libre. Ce sont deux questions distinctes : d’un côté, l’exigence que l’État utilise du logiciel libre ; de l’autre, la nécessité d’imposer des limites à ce que l’État peut faire. La FSF, qui reste une organisation modeste, n’a pas les moyens de lutter directement contre la surveillance de masse.

Moi, je ne vois pas de caméras de reconnaissance faciale dans les rues. Je ne vois pas non plus ce que fait WhatsApp, ou ce qu’il ne fait pas, parce que je refuse de l’utiliser. Son programme client est privateur : je refuse de l'utiliser.

Il y a beaucoup d’injustices dans ces soi-disant services qui exercent du pouvoir sur leurs utilisateurs. Par principe, je ne les utilise jamais. Je résiste.
Il existe des logiciels libres qui permettent de communiquer de façon chiffrée, et je les utilise. Mais jamais avec une application privatrice, jamais via le serveur d’une entreprise dont je me méfie.

Et puis, il y a d’autres systèmes de surveillance. Par exemple, en France, l’obligation d’inscrire son nom sur un billet de train est injuste. Il faut lutter pour supprimer ce type de suivi.

Il y a aussi des systèmes dont l’objectif, en soi, est admirable, mais qui sont conçus de manière à identifier chaque participant. Par exemple, un système pour réduire les émissions toxiques : c’est une bonne chose de vouloir les réduire. Mais il faut pouvoir participer à ce système pour atteindre son objectif sans avoir à s’identifier.

Il faut éviter d’imposer à chacun l’utilisation d’un programme client privateur pour s’identifier auprès d’un serveur et obtenir, par exemple, l’autocollant à coller sur sa voiture.

L’État français s’intéresse à l’usage du logiciel libre dans ses ministères, et c’est une bonne chose : cela l’aide à échapper au pouvoir injuste des grandes entreprises. Mais il devrait aussi veiller à protéger les citoyens — et même les visiteurs en France — contre le danger du contrôle numérique. Car le suivi des gens, la surveillance de masse, est extrêmement dangereuse. On peut le voir en Chine : c’est la base idéale pour répression.

Et aussi, imposent souvent l’utilisation de programmes privateurs. De tels programmes ne pourraient pas tourner sur mon ordinateur, sauf s’ils sont écrits en JavaScript. Mais dans ce cas, je bloque le JavaScript privateur, et je refuse de m’identifier sur ces sites.

J’ai imaginé une solution au problème des zones à faibles émissions. Chaque ville participante devrait installer, à des endroits bien signalés, des points de vente où l’on puisse acheter, en liquide, les plaques nécessaires, en fournissant uniquement les informations sur le véhicule. Cela permettrait de respecter les règles de réduction des émissions, mais sans passer par un système numérique injuste. Quelques points de ce type, placés sur les principales routes d’accès, suffiraient pour chaque ville.

Ainsi, on éviterait aussi le piège consistant à devoir acheter ces plaques avant même d’entrer en France. Et il est important que le paiement puisse se faire en liquide : c’est une protection contre la surveillance et la répression.

Si, dans un magasin, il te manque de l’argent liquide pour payer, il vaut mieux aller retirer de l’argent à un distributeur plutôt que d’utiliser une carte. Car si tu paies en espèces, le système saura seulement où tu as retiré ton argent, mais pas ce que tu as acheté avec. Et pour moi, c’est essentiel.

Je n’utilise jamais ma carte pour mes achats quotidiens. J’ai bien une carte de crédit, mais je ne m’en sers qu’exceptionnellement, par exemple pour les billets d’avion — puisqu’on ne peut pas voyager anonymement — ou pour certaines factures à mon nom, comme celles de mon appartement. Pour les soins médicaux et les ordonnances, je peux payer par chèque. Mais en dehors de ces cas particuliers, je règle toujours en liquide.

Stéphane :
C’est donc surtout pour éviter d’être tracé dans tes achats, en fait ?

Richard :
Non, c’est plus large que ça. La question n’est pas simplement d’éviter, moi, d’être suivi personnellement. Il s’agit de résister à la tendance générale qui impose une surveillance à tout le monde.
Moi, je fais ma part : je résiste à la surveillance quand elle me concerne directement. Mais résister à la surveillance qui pèse sur toi ou sur les autres, ça, je ne peux pas le faire à leur place. Chacun doit assumer sa part.

Stéphane :
Oui, l’idée est d’éviter que ce système ne se généralise trop.

Richard :
Mais il est déjà trop généralisé ! Il y a beaucoup trop de contrôle, trop de surveillance, trop de suivi… et donc trop de répression.

Stéphane :
Et donc, pour terminer, le dernier thème que j’aimerais aborder avec toi, c’est ce que les médias de masse appellent l’intelligence artificielle. Parce que là aussi, derrière, il y a du logiciel. Je voulais savoir quelle est aujourd’hui la position de la FSF sur ce sujet. Et est-ce qu’il existe, selon toi, une définition d’un modèle de LLM éthique ?

Richard Stallman :
Je dois d’abord distinguer mon opinion des suppositions contenues dans ta question.

Stéphane :
D’accord.

Richard Stallman :
Je fais la différence entre ce que j’appelle l’intelligence artificielle et ce que j’appelle les générateurs de merde. Les programmes comme ChatGPT ne sont pas de l’intelligence.
L’intelligence, ça veut dire avoir la capacité de savoir ou de comprendre quelque chose, au moins dans un domaine réduit. Mais plus que rien.

ChatGPT, lui, ne comprend rien. Il n’a aucune intelligence. Il manipule des phrases sans les comprendre. Il n’a aucune idée sémantique de la signification des mots qu’il produit. C’est pour ça que je dis que ce n’est pas de l’intelligence.

En revanche, il existe des programmes qui comprennent vraiment dans un domaine restreint.
Par exemple, certains peuvent analyser une image et dire si elle montre des cellules cancéreuses, ou bien identifier un insecte : est-ce une guêpe en train d’attaquer des abeilles ? C’est un vrai problème dans certains pays. Ce sont des immigrants vraiment dangereux.
Ces programmes, dans leur petit champ, comprennent aussi bien qu’un humain. Je les appelle donc de l’intelligence artificielle.

Mais les LLM, les grands modèles de langage, ne comprennent rien. Il faut insister pour ne pas les appeler « intelligence artificielle ». C’est uniquement une campagne de marketing destinée à vendre des produits, et malheureusement presque tout le monde l’accepte. Cette confusion fait déjà des dégâts dans la société.

En dehors de ça, si tu veux utiliser un LLM, il faut avoir les quatre libertés essentielles. Tu dois pouvoir l’exécuter dans ton propre ordinateur, pas l’utiliser dans le serveur de quelqu’un d’autre, parce que dans ce cas-là c’est lui qui choisit le programme, et si le programme est libre, c’est lui qui a le droit de le changer, pas toi. Et si tu l’exécutes chez toi mais que tu n’as pas le droit de le modifier, ni de l’utiliser comme tu veux en liberté, évidemment c’est injuste. Donc je ne dis pas que les LLM sont essentiellement injustes, mais normalement ils ne respectent pas la liberté des utilisateurs, et ça, c’est injuste.

Et il faut bien reconnaître aussi ce qu’ils ne sont pas capables de faire : ils ne comprennent pas, ils ne savent pas.

Stéphane :
Oui, c’est vrai que c’est du marketing de les appeler « intelligence artificielle ». Mais beaucoup de gens y trouvent un usage utile. Je pense par exemple à la traduction, qui donne parfois des résultats corrects. Donc si les gens veulent utiliser des LLM, ce que tu recommandes, c’est de privilégier les modèles sous licence libre, c’est bien ça ?

Richard Stallman :
Oui. Nous sommes en train d’écrire comment adapter les critères du logiciel libre pour qu’ils s’appliquent aussi aux programmes d’apprentissage automatique.

Stéphane :
Donc ça, c’est quelque chose que la FSF va publier dans le futur ?

Richard Stallman :
Oui, mais ce n’est pas encore terminé.

Stéphane :
On arrive au bout des questions que j’avais prévues. Ça fait 40 ans que la FSF existe. Il y a eu, je pense, beaucoup d’avancées positives. Mais aujourd’hui l’informatique est partout dans nos vies, et donc la question des libertés informatiques est plus importante que jamais. Est-ce que tu aurais un message à lancer pour inciter les gens à rejoindre le logiciel libre ?

Richard :
Oui. D’abord, rejetez la technologie injuste : les applications non libres, celles qui identifient l’utilisateur, celles qui suivent les gens depuis ton ordinateur ou ton téléphone. Cherchez à remplacer chaque élément pour lequel il existe du logiciel libre, avec du chiffrement libre de bout en bout.
Rejetez aussi les objets censés être « chez toi » mais qui t'écoutent, rejetez les produits où les commandes passent par le serveur du fabricant qui espionne tout, et résistez aux systèmes qui pistent leurs utilisateurs. Payez en liquide quand c’est possible.
Et si tu es programmeur, tu peux contribuer au développement de programmes libres, et tu peux aussi t’inscrire comme membre de la FSF sur fsf.org. Regarde aussi gnu.org/help. Une chose encore : si tu travailles dans une université, invite-moi pour une conférence.

Stéphane :
D’accord. Et quand tu regardes ces 40 années de lutte pour le logiciel libre, est-ce que tu es satisfait de la tournure que prennent les choses aujourd’hui, de l’impact ?

Richard :
Non, bien sûr que non. Sous l’empire, les choses vont de pire en pire. Je ne suis pas satisfait. Parfois j’aurais pu agir plus efficacement, mais avec ce que je savais au début, je n’aurais pas su faire mieux. Mais je suis déçu de la direction que prennent les choses.

Stéphane :
C’est pour ça que c’est important que toutes les personnes sensibilisées contribuent autant que possible : en informant autour d’elles, en incitant à ne pas utiliser de logiciels privateurs et en aidant à passer au logiciel libre.

Richard :
Oui. Mais il faut aussi que les Français s’unissent pour exiger que les services numériques de l’État respectent le logiciel libre. Spécifiquement, qu’ils cessent de transmettre des programmes privateurs à exécuter sur la machine des utilisateurs, et qu’ils respectent davantage l’anonymat des individus. Parce que les données personnelles, une fois collectées dans une base, finiront par être abusées, peut-être même par l’État.

Stéphane :
Avec l’arrivée de Donald Trump, je sais par exemple que la fondation Mozilla a expliqué être en difficulté financière, parce qu’ils ont perdu des financements qu’ils avaient de l’État. Est-ce que la FSF est aussi victime financièrement ?

Richard :
Non, parce que nous ne recevions rien de l’État.

Stéphane :
Donc vous avez plus d’indépendance que Mozilla de base.

Richard :
Oui, et nous avons plus de financements grâce aux dons. C’est pour ça que je prie tout le monde d’adhérer à la FSF.

Stéphane :
Merci beaucoup, Richard, pour cet entretien. Donc là, on fête les 40 ans de la FSF. J’espère que pour les 50 ans, le logiciel libre sera beaucoup plus utilisé que le logiciel privateur. On verra bien.

Richard:
Puis-je faire un jeu de mots ?

Stéphane:
Bien sûr.

Richard:
J'adore le thé, mais je ne bois que les thés qui se dégradent avec le temps, parce que les autres sont détestables.
Au revoir.

Stéphane:
Au revoir.

Ces derniers temps, on a beaucoup parlé d’intelligence artificielle sur LinuxFr.org. D’IA propriétaires, et d’IA libres. Mais peut-on vraiment faire une IA libre ? La notion n’est pas sans poser quelques difficultés. Une (pas si) courte discussion du problème.

Sommaire

• On appellera IA un réseau de neurones artificiels
• Pour comprendre le réseau de neurones, il est nécessaire de disposer de bases statistiques
  • Les statistiques reposent sur la modélisation
    • Un exemple : la régression linéaire
• Le réseau de neurones
  • Le neurone naturel
  • Le neurone formel
  • La mise en réseau
  • Le réseau de neurones est Turing-complet
  • Le réseau de neurones présente un effet boîte noire important
  • Le réseau de neurones est un modèle statistique
    • Tous les modèles sont faux, certains sont utiles, et c’est vrai aussi pour le réseau de neurones
• Le but du logiciel libre est de rendre le pouvoir à l’utilisateur
  • La première des libertés est celle de savoir ce que je fais
  • Si je sais ce que je fais, je dois pouvoir modifier ce que je fais
• Le réseau de neurones est difficilement compatible avec le libre
  • Personne ne sait vraiment ce que fait un réseau de neurones
  • Disposer de la description complète d’un réseau de neurones ne permet pas de l’améliorer
  • La définition du code source d’un réseau de neurones est ambiguë
  • Cette ambiguïté fait courir un risque juridique sous certaines licences libres
    • Comment les boîtes qui font de l’IA non libre résolvent-elles ce dilemme ? Elles ne le résolvent pas
  • La définition d’une IA open source ressemble furieusement à un constat d’échec
• Conclusion : qu’attendre d’une IA libre ?

On appellera IA un réseau de neurones artificiels

Commençons par définir notre objet d’étude : qu’est-ce qu’une IA ? Par « intelligence artificielle », on pourrait entendre tout dispositif capable de faire réaliser par un ordinateur une opération réputée requérir une tâche cognitive. Dans cette acception, un système expert qui prend des décisions médicales en implémentant les recommandations d’une société savante est une IA. Le pilote automatique d’un avion de ligne est une IA.

Cependant, ce n’est pas la définition la plus couramment employée ces derniers temps. Une IA a battu Lee Sedol au go, mais ça fait des années que des ordinateurs battent les humains aux échecs et personne ne prétend que c’est une IA. Des IA sont employées pour reconnaître des images alors que reconnaître un chien nous semble absolument élémentaire, mais l’algorithme de Youtube qui te suggère des vidéos pouvant te plaire parmi les milliards hébergées fait preuve d’une certaine intelligence et personne ne l’appelle IA. Il semble donc que le terme « IA » s’applique donc à une technique pour effectuer une tâche plus qu’à la tâche en elle-même, ou plutôt à un ensemble de techniques partageant un point commun : le réseau de neurones artificiels.

Dans la suite de cette dépêche, j’utiliserai donc indifféremment les termes d’IA et de réseau de neurones¹.

Pour comprendre le réseau de neurones, il est nécessaire de disposer de bases statistiques

Les statistiques (ou la statistique, on peut dire les deux, comme en Alexandrie), c’est la branche des mathématiques qui s’intéresse aux moyens, à partir de données observées et fondamentalement probabilistes, d’en tirer des conclusions généralisables (et idéalement, de prédire l’avenir à partir du passé).

La data science, c’est la branche de l’informatique qui s’intéresse aux moyens, à partir de données emmagasinées sur lesquelles on ne fait pas d’hypothèse de mode de génération, d’en tirer des conclusions généralisables (et idéalement, de prédire les données futures).

Ça vous semble similaire ? Ça l’est. Les deux champs vont avoir des divergences de vocabulaire, de langages (les stateux préfèreront R, les data scientists Python), de formation (les stateux sont plutôt des universitaires, les data scientists plutôt des informaticiens au niveau licence, mais ils ont les mêmes masters et doctorats), mais fondamentalement, et surtout mathématiquement, c’est la même chose. Les connaissances en inférence statistique (notamment bayésienne, pour ceux à qui ça parle) se généralisent très bien à la data science.

Pour faire court, un statisticien est un data scientist qui se la pète, alors qu’un data scientist est un informaticien qui, n’étant pas assez bon pour survivre à la rude concurrence universitaire, a multiplié son salaire par 10 ou 20 en allant vendre ses compétences statistiques à Facebook.

Les statistiques reposent sur la modélisation

En statistique, la manière la plus courante de répondre à une question est de construire un modèle. Prenons une question simple : je dispose d’un jeu de données où j’ai enregistré, pour 1000 personnes, leur IMC et leur taux de cholestérol. Je souhaite savoir s’il y a un lien entre les deux. On souhaiterait, dans ce cas simple, rechercher une relation monotone, sans faire d’hypothèse sur le type de relation.

Un exemple : la régression linéaire

Une manière de répondre à ma question est d’écrire et de trouver les meilleurs A et B pour que la droite « colle » le mieux possible au nuage de points. On démontre que la meilleure droite est celle qui minimise un certain critère, la somme des carrés des erreurs. Une fois qu’on a la meilleure droite possible, on peut faire plein de choses avec :

• On peut rétro-prédire le taux de cholestérol des personnes déjà observées et voir de combien la prédiction s’écarte du réel, ce qui fournit une erreur moyenne de prédiction ;
• On peut faire de même en prédisant juste le taux de cholestérol moyen pour tous les individus et comparer les erreurs moyennes de prédiction, ce qui permet de voir de combien le modèle améliore la prédiction (et donc de quantifier la quantité d’info apportée par la donnée IMC sur la variable cholestérol) ;
• On peut étudier le signe de A : si A est négatif, prendre du poids fait baisser le cholestérol : si A est positif, prendre du poids augmente le cholestérol : si A est nul, le poids n’apporte pas d’info sur le cholestérol.
• Par contre, on ne peut rien dire de la causalité. Tout ce qu’on a observé, ce sont des personnes qui, au même moment, avaient un IMC et un taux de cholestérol donnés. Impossible de dire s’ils ont ce cholestérol parce qu’ils ont cet IMC, s’ils ont cet IMC parce qu’ils ont ce cholestérol, ou s’ils ont ce cholestérol et cet IMC parce qu’ils ont une troisième exposition.
• On peut enfin faire effectuer de la prédiction à notre modèle : en lui passant une personne dont on ne connaît que l’IMC, on peut estimer son taux de cholestérol et assortir cette prédiction d’un niveau de certitude (ça demande un peu plus de maths, mais c’est l’idée).

On peut vouloir ajouter une troisième variable, mettons le tabagisme. On écrira alors :

Avec la variable tabac codée à 0 (non fumeur) ou 1 (fumeur). Noter que notre modèle est alors passé en dimension 3 : on ne cherche plus à faire passer la meilleure droite par rapport au nuage de points en 2D, mais à faire passer le meilleur plan par rapport au nuage de points en 3D. Noter aussi qu’on peut facilement inclure des variables qualitatives : il suffit de les coder 0 ou 1. On peut d’ailleurs inclure des variables à n modalités : il suffit de les recoder en n-1 sous-variables en 0-1 (la modalité de référence étant celle pour laquelle toutes les sous-variables sont à 0).

Les sont appelés des paramètres : c’est en les faisant varier qu’on ajuste le modèle aux données.

On peut ainsi ajouter un nombre quelconque de variables… Ou peut-être pas. En effet, on va finir par atteindre un seuil où le meilleur hyperplan est tout simplement celui qui passe par tous les points ! Si j’ai 50 individus et 50 paramètres, il est facile de choisir un plan qui passe par tous les individus. C’est ce qu’on appelle le surapprentissage : le modèle a tout simplement appris le jeu de données par cœur ! Le surapprentissage est un écueil des modèles trop complexes et un réseau de neurones est tout à fait capable de surapprendre.

Le réseau de neurones

Le neurone naturel

Les neurones sont les cellules du système nerveux. Elles sont spécialisées dans la transmission d’information.

Comme tu peux le voir sur cette image issue de Wikimedia (source), un neurone comprend un nombre quelconque de dendrites, un corps cellulaire, et un axone. Point crucial : l’axone est unique. Il peut lui-même transmettre de l’information à différents neurones en aval, mais il transmet la même information. Or l’information, dans un neurone, peut entrer par les dendrites et par le corps cellulaire, mais elle ne peut ressortir que par l’axone (on peut faire abstraction de la gaine de myéline et des nœuds de Ranvier, qui ont un rôle central dans la vitesse de conduction de l’information mais qui ne changent rien aux calculs effectués). Autrement dit, un neurone transmet la même information à tous les neurones d’aval, et si ceux-ci en font un usage différent, c’est uniquement lié à leurs propres calculs en interne.

Le neurone formel

On peut modéliser un neurone, par analogie avec le neurone naturel. Notre neurone formel pourra donc prendre un nombre quelconque d’entrées, mais comme un neurone naturel, il ne produira qu’une seule sortie. Notre neurone est donc une fonction de ses entrées :

En pratique (mais ça n’a rien d’obligatoire), on prend souvent une fonction d’une combinaison linéaire des entrées :

Avec une contrainte : la fonction (qu’on appelle fonction d’activation) doit être monotone (idéalement strictement monotone), dérivable presque partout (c’est nécessaire à l’optimisation du réseau, qu’on verra plus tard), définie sur un intervalle suffisamment large pour qu’on soit toujours dedans, et non linéaire (sinon mettre les neurones en réseau n’a aucun intérêt, autant faire directement une unique régression linéaire).

En pratique, on prend donc quelques fonctions classiques :

• La fonction binaire : si , sinon
• La fonction logistique, une amélioration de la fonction binaire : . Avantage : elle est strictement monotone, dérivable partout, et elle prend quand même ses valeurs entre 0 et 1.
• La fonction Rectified Linear Unit (ReLU, qu’on peut prononcer « relou ») : si , sinon. Avantage : elle est très facile (donc rapide) à calculer et à dériver. On peut la rendre strictement monotone en la modifiant à la marge : si , sinon, avec .

La mise en réseau

Tout l’intérêt du neurone formel réside dans sa mise en réseau. Un unique neurone ne fait pas mieux qu’une régression linéaire. On construit donc un réseau de neurones. Pour ce faire, on va donc générer plusieurs neurones, chacun prenant en entrée la sortie de plusieurs neurones et produisant une sortie unique, qui sera à son tour utilisée en entrée par d’autres neurones. On ajoute un ensemble de neurones qu’on pourrait qualifier de « sensitifs », au sens où ils prennent en entrée non pas la sortie d’un neurone antérieur, mais directement l’input de l’utilisateur, ou plutôt une partie de l’input : un pixel, un mot… Enfin, une sortie est ajoutée : elle produit le résultat final.

Étant donné que les neurones sont virtuels et n’ont pas d’emplacement géographique, il est assez logique de les représenter en couches : la couche 0 est constituée des neurones sensitifs, la couche 1 prend en entrée les résultats de la couche 0, et ainsi de suite. Classiquement, tous les neurones de la couche n+1 prennent en entrée les sorties de tous les neurones de la couche n.

Se pose alors la question : combien de neurones par couche, et combien de couches au total ?
On peut considérer deux types de topologies : soit il y a plus de neurones par couche que de couches : le réseau est plus large que long, on parlera de réseau large. Soit il y a plus de couches que de neurones par couche, auquel cas le réseau est plus long que large, mais on ne va pas parler de réseau long parce que ça pourrait se comprendre « réseau lent ». On parlera de réseau profond. C’est de là que viennent les Deep et les Large qu’on voit un peu partout dans le marketing des IA. Un Large Language Model, c’est un modèle, au sens statistique, de langage large, autrement dit un réseau de neurones avec plus de neurones par couche que de couches, entraîné à traiter du langage naturel. On constate empiriquement que certaines topologies de réseau sont plus efficaces pour certaines tâches. Par exemple, à nombre de neurones constant, un modèle large fera mieux pour du langage. À l’inverse, un modèle profond fera mieux pour de la reconnaissance d’images.

Le réseau de neurones est Turing-complet

Un résultat théorique important est que les réseaux de neurones sont Turing-complets. C’est-à-dire que, pour tout programme que l’on peut coder et qui sorte une réponse algorithmique, il existe un réseau de neurones qui donne le même résultat. La réciproque est vraie aussi : ce qui est faisable avec un réseau de neurones est faisable en C ou dans un autre langage, au pire en recodant le réseau dans ce langage.

Le réseau de neurones présente un effet boîte noire important

Prenons maintenant un élément d’information et essayons de suivre son trajet dans le modèle jusqu’à la sortie. Dans une régression linéaire, c’est assez facile : le poids de l’IMC va peser pour dans le résultat final. Dans une forêt aléatoire, on peut toujours isoler les arbres où apparaît une donnée et essayer de regarder combien elle pèse. C’est fastidieux mais ça reste faisable. Dans un réseau de neurones, c’est impossible. Chaque neurone de la couche 1 va passer un résultat agrégé à la couche 2, où chaque donnée de la couche 0 ne compte plus que comme partie d’un tout. De même, chaque neurone de la couche 2 va agréger tous les résultats de la couche 1. Il devient impossible d’individualiser l’effet d’une donnée ou même celui d’un neurone.

Ainsi, même si je connais l’intégralité du contenu du modèle, il m’est impossible de donner du sens à une partie du modèle, prise isolément. Le modèle se comporte comme un bloc monolithique, et la seule manière d’étudier un nouvel exemple est de lui appliquer tout le modèle et de voir ce qui sort. C’est ce qu’on nomme l’effet boîte noire.

Attention : l’effet boîte noire n’est pas lié au nombre de paramètres du modèle. Si je fais de la génétique, et que j’étudie 2000 mutations génétiques individuelles (des SNP, pour single nucleotide polymorphism), je peux assez facilement ajuster un modèle de régression logistique (qui est une variante de la régression linéaire où on fait prédire non pas une variable quantitative, mais une probabilité) à 2000 paramètres (un pour chaque SNP). Chaque paramètre sera parfaitement compréhensible et il n’y aura pas d’effet boîte noire.

Il n’est pas non plus lié à ta méconnaissance des mathématiques, cher lectorat. Des statisticiens chevronnés se cassent les dents sur l’effet boîte noire. Il est intégralement lié à la structure du modèle. Certains types de modèles en ont, d’autres n’en ont pas. Les réseaux de neurones en ont.

Cet effet a une conséquence perturbante : même si on sait ce que fait un réseau de neurones, il est impossible de savoir comment il le fait ! On pourrait argumenter que ce n’est pas forcément différent de ce que nous faisons : si on montre à un enfant de 3 ans une photo de chien, il saura dire que c’est un chien, mais il ne saura pas dire pourquoi c’est un chien. Cependant, on demande rarement à un programme d’être réflexif, mais on demande toujours à son auteur de savoir comment il tourne. C’est un peu la base de la programmation.

Le réseau de neurones est un modèle statistique

Reprenons : on a un paradigme (le réseau de neurones) capable d’effectuer n’importe quelle tâche pour laquelle il existe une solution algorithmique, à condition de le programmer correctement… Mais on ne sait pas le programmer ! Heureusement, il existe un contournement : on ne va pas le programmer, on va l’ajuster, comme un modèle statistique. Ou l’entraîner, si on préfère le terme de « machine learning ».

Tu t’en souviens, cher lecteur, un réseau de neurones est un ensemble de fonctions dont chacune prend en entrée différentes données avec des coefficients (les fameux ). On va commencer par initialiser l’apprentissage en donnant des valeurs aléatoires à ces coefficients. Ensuite, on va soumettre à notre réseau de neurones des tas et des tas de données correctes, et qu’on va comparer ce qu’il prédit à ce qu’on attend. La différence s’appelle l’erreur. Et à chaque itération, on va identifier les neurones les plus générateurs d’erreur et les pénaliser (réduire leur poids, ou plutôt réduire leur poids dans les neurones où c’est nécessaire), tout en favorisant les meilleurs neurones. Les détails de la technique (qui s’appelle la rétropropagation de l’erreur) dépassent largement le cadre de cette courte introduction, mais l’essentiel est qu’à la fin, on obtient un réseau capable de donner des réponses proches de ce qui existait dans l’ensemble des données correctes qu’on lui a passé et de généraliser quand la demande est différente d’une donnée de l’ensemble d’apprentissage. Avantage : en pratique, un réseau de neurones est capable de prendre en entrée n’importe quel type de structure de données : image, texte, son… Tant que les neurones d’entrée sont adaptés et qu’il existe un ensemble d’apprentissage suffisamment grand, c’est bon.

Tous les modèles sont faux, certains sont utiles, et c’est vrai aussi pour le réseau de neurones

Bien sûr, il y a des limites. La première est la complexité algorithmique. Un réseau de neurones nécessite de réaliser un nombre astronomique d’opérations simples : pour chaque couche, il faut, pour chaque neurone, calculer la somme des produits des coefficients avec toutes les sorties de la couche antérieure, soit multiplications, où n est le nombre de neurones par couche et c le nombre de couches. Par exemple, pour un petit réseau de 10 couches de 20 neurones, plus une couche d’entrée, on réaliserait à chaque itération multiplications en virgule flottante, et encore, c’est ici un tout petit réseau : un réseau comme ChatGPT a des neurones qui se comptent par millions, voire dizaines de millions !

Une autre limite est la précision des réponses. Le réseau de neurones étant un modèle statistique, il n’est capable que d’interpoler, c’est-à-dire trouver une réponse à partir de cas similaires. Cette interpolation est rarement aussi précise que celle que donnerait une réponse formelle si elle existait : si Newton avait eu accès à des réseaux de neurones, nous aurions une prédiction du mouvement des planètes qui ne baserait sur aucune théorie, qui serait à peu près exacte mais insuffisamment précise pour envoyer des sondes sur Mars. Quant à s’interroger sur la précession du périhélie de Mercure, on oublie.

De manière générale, on peut s’interroger sur ce qui amène un réseau de neurones à se planter. On peut diviser les erreurs en plusieurs catégories :

• La question posée n’a aucun rapport avec les données passées en entrée. Par exemple : « Sachant que la dernière personne que j’ai croisée dans la rue avait 42 ans, indique-moi son genre ». Le modèle n’a pas assez d’information pour répondre.
• La question posée n’a aucun rapport avec l’ensemble d’apprentissage. Par exemple, demander à un modèle entraîné à reconnaître des photos de chien de reconnaître une voiture. En général, ce problème est résolu en contraignant le format des questions ; dans cet exemple, il suffirait de ne pas permettre à l’utilisateur de poser une question, juste de poster une photo et de recevoir une réponse. D’ailleurs, on ne voit pas très bien pourquoi entraîner un tel modèle à traiter du langage.
• L’ensemble d’apprentissage est trop restreint/biaisé. L’exemple typique est le modèle qui prétendait reconnaître les délinquants à une simple photo et identifiait en fait tous les noirs : ben oui, ils étaient majoritaires dans les délinquants de l’ensemble d’apprentissage. Noter qu’il existe des problèmes où l’ensemble d’apprentissage sera toujours trop restreint pour un certain niveau de précision exigé. Si on demande à un réseau de dire si un point donné est à l’intérieur ou à l’extérieur d’un flocon de Koch, il va falloir lui passer une infinité de données d’apprentissage pour qu’il apprenne les cas limites juste par interpolation (alors qu’avec un modèle formel, ça serait assez facile).
• Le modèle est parasité par une donnée annexe : c’est une problématique assez spécifique du réseau de neurones. L’exemple le plus classique est celui des images de mains : après tout, le voisin le plus probable d’un doigt, c’est un autre doigt. L’amusant, c’est que ce problème serait résolu assez facilement en demandant au modèle de compter 4 doigts et un pouce. Mais comme on ne peut pas programmer directement un réseau de neurones…
• Enfin, si les motifs précédents ont été écartés, je dois me demander si mon modèle n’est pas inadapté : soit qu’il n’a pas assez de neurones, soit que la topologie n’est pas bonne. Plus de neurones permettent de traiter des données plus complexes et leur disposition permet d’augmenter leur efficacité.

En définitive, on peut voir le réseau de neurones comme un outil qui résout approximativement un problème mal posé. S’il existe une solution formelle, et qu’on sait la coder en un temps acceptable, il faut le faire. Sinon, le réseau de neurones fera un taf acceptable.

Le but du logiciel libre est de rendre le pouvoir à l’utilisateur

On a beaucoup glosé, et on continuera de le faire longtemps, sur la philosophie du Libre. Free Software Foundation d’un côté, Open Source Initiative de l’autre, les sujets de discorde ne manquent pas. Mais il faut au moins créditer l’OSI sur un point : avoir clarifié le fait que le Libre est avant tout un mouvement politique, au sens noble du terme : il vise à peser sur la vie de la cité, alors que l’Open Source vise avant tout à disposer de logiciels de qualité.

La première des libertés est celle de savoir ce que je fais

Ça paraît évident dans la vie de tous les jours : je sais ce que je fais. Si je décide de prendre une pelle et de planter un arbre dans mon jardin, je sais que je suis en train de prendre une pelle et de planter un arbre dans mon jardin. Si je décide de prendre un couteau et de le planter dans le thorax de mon voisin, je sais ce que je fais. C’est une liberté fondamentale, au sens où elle fonde toutes les autres. Si je ne sais pas ce que je fais, je ne peux signer un contrat, par exemple (c’est d’ailleurs le principe qui sous-tend le régime de la tutelle en droit). D’ailleurs, comme toute liberté, elle fonde une responsabilité. Si je ne savais pas ce que je faisais (et que je peux le prouver), je peux plaider l’abolition du discernement et échapper à ma responsabilité pénale, quelle que soit l’infraction commise, même les plus graves²

Dans la vie de tous les jours, donc, il est évident que je sais ce que je fais. Mais avec un ordinateur, c’est beaucoup moins évident. Quand j’exécute Windows, je ne sais pas ce que je fais. Pas seulement parce que je ne connais pas la séquence de boot, mais de façon beaucoup plus fondamentale : parce que n’ayant pas accès au code source, je ne sais pas ce que fait le programme que j’exécute. Ce qui pose un problème majeur de confiance dans le logiciel exécuté :

• Confiance dans le fait que le programme fait bien ce que son programmeur a voulu qu’il fasse (absence de bugs)
• Confiance dans le fait que le programmeur avait bien mon intérêt en tête et pas seulement le sien (sincérité du programmeur, fréquemment prise en défaut dans le logiciel non libre)

Dans le système des 4 libertés du logiciel libre, cette liberté est la liberté 1. Elle passe après la liberté 0 (liberté d’exécuter le programme) et avant la liberté 2 (liberté de redistribuer le programme). On pourrait légitimement discuter de sa priorité par rapport à la liberté 0 (est-il raisonnable d’exécuter un programme dont on ne sait pas ce qu’il fait ?) mais ça dépasserait l’objet de cette dépêche.

Si je sais ce que je fais, je dois pouvoir modifier ce que je fais

Conséquence logique de la liberté précédente : si je n’aime pas ce que fait un programme, je dois pouvoir l’améliorer. Si je ne sais pas le faire moi-même, je dois pouvoir payer quelqu’un pour l’améliorer. Là encore, ça suppose l’accès au code source, ne serait-ce que pour savoir ce que fait le programme. Il s’agit de la liberté 3 du logiciel libre.

Le réseau de neurones est difficilement compatible avec le libre

Personne ne sait vraiment ce que fait un réseau de neurones

On l’a vu, les réseaux de neurones présentent un effet boîte noire important. Déjà, la plupart des IA commerciales ne sont accessibles qu’au travers d’une interface ou une API. Elles n’exposent que rarement les neurones. Mais même pour une personne disposant de tous les neurones, autrement dit de la description complète du réseau, l’effet boîte noire est tel que le fonctionnement du réseau de neurones est inintelligible. D’ailleurs, s’il était intelligible, il serait très vite simplifié !

En effet, on peut recoder tout réseau de neurones dans un langage plus rapide, dès lors qu’on comprend ce qu’il fait (puisqu’il est Turing-complet). Vu la consommation astronomique d’énergie des réseaux de neurones, s’il existait un moyen de comprendre ce que fait un réseau de neurones et de le traduire dans un autre langage, on le ferait très vite. Ce qui fournirait d’ailleurs des réponses à des questions théoriques ouvertes comme : qu’est-ce que comprendre une phrase ? Comment reconnaît-on un chien, un visage, un avion ?

Disposer de la description complète d’un réseau de neurones ne permet pas de l’améliorer

On l’a vu : si je dispose de la totalité des neurones, je dispose de la totalité de la description du réseau de neurones. Mais comme je suis incapable de savoir ce qu’il fait, je ne suis pas plus avancé pour l’améliorer, qu’il s’agisse de retirer un défaut ou d’ajouter une fonctionnalité. Noter d’ailleurs que ceci n’est pas forcément impactant de la même manière pour tous les aspects du réseau de neurones : si je n’ai aucun moyen d’être sûr de l’absence de bugs (c’est même le contraire ! Il y a forcément des bugs, c’est juste que je ne les ai pas trouvés ou qu’ils ne sont pas corrigeables), j’ai en revanche peu d’inquiétude à avoir concernant la sincérité du programmeur : comme lui non plus ne maîtrise pas sa bestiole, pas de risque qu’il soit insincère³.

La définition du code source d’un réseau de neurones est ambiguë

Posons-nous un instant la question : qu’est-ce que le code source d’un réseau de neurones ? Est-ce la liste des neurones ? Comme on l’a vu, ils ne permettent ni de comprendre ce que fait le réseau, ni de le modifier. Ce sont donc de mauvais candidats. La GPL fournit une définition : le code source est la forme de l’œuvre privilégiée pour effectuer des modifications. Dans cette acception, le code source d’un réseau de neurones serait l’algorithme d’entraînement, le réseau de neurones de départ et le corpus sur lequel le réseau a été entraîné.

Cette ambiguïté fait courir un risque juridique sous certaines licences libres

Tu devines alors, cher lecteur, là où je veux en venir… Si le corpus comprend des œuvres non libres, tu n’as tout simplement pas le droit de le diffuser sous une licence libre ! Et si tu t’es limité à des œuvres libres pour entraîner ton modèle, tu risques fort d’avoir un ensemble d’apprentissage trop restreint, donc un réseau de neurones sans intérêt.

Alors il y a quatre moyens de tricher.
Le premier, c’est de t’asseoir sur la GPL et de considérer qu’en distribuant les neurones, tu as fait le taf. La ficelle est grossière. Je viens de passer une dépêche à te démontrer que c’est faux, tu pourrais au moins me montrer un peu plus de respect.

Le deuxième, c’est de distribuer sous une licence non copyleft, genre BSD ou WTFPL. Une licence qui ne nécessite pas de distribuer le code source. Certes, mais en fait tu ne fais pas du Libre.

Le troisième, c’est de considérer le réseau de neurones comme une donnée, pas un exécutable. Donc pas de code source. La partie sous GPL serait alors l’interface graphique, et le réseau, une donnée. C’est assez limite. Une donnée exécutable, ça s’approche dangereusement d’un blob binaire.

Le quatrième, c’est de repenser complètement le paradigme du logiciel libre et de considérer qu’il vise avant tout à rééquilibrer les rapports de pouvoir entre programmeur et utilisateur, et qu’en redistribuant les neurones, tu as fait le job. Sur les rapports de pouvoir, tu n’as pas tort ! Mais d’une part, ça ne tiendra pas la route devant un tribunal. D’autre part, il persiste une asymétrie de pouvoir : tu as accès au corpus, pas l’utilisateur.

Quand bien même on admettrait que le code source est l’ensemble corpus + algorithme d’optimisation + réseau de neurones de départ, l’optimisation d’un réseau de neurones consomme autrement plus de ressources que la compilation d’un programme plus classique, des ressources qui sont loin d’être à la portée du quidam classique. À quoi servirait un code source impossible à compiler ?

Enfin, même cette définition du code source pose problème : elle n’est en fait pas beaucoup plus lisible que le réseau lui-même. Ce n’est pas parce que j’ai accès aux centaines (de milliers) de textes sur lesquels un réseau a été entraîné que je peux prédire comment il va se comporter face à une nouvelle question.

Comment les boîtes qui font de l’IA non libre résolvent-elles ce dilemme ? Elles ne le résolvent pas

C’est presque enfoncer une porte ouverte que dire que l’IA pose de nombreuses questions de droit d’auteur, y compris dans le petit microcosme du non-libre. Cependant, les IA non-libres ont un avantage sur ce point : si le réseau de neurones ne permet pas de remonter au corpus initial (donc en l’absence de surapprentissage), alors elles peuvent tranquillement nier avoir plagié une œuvre donnée. Tu ne me verras pas défendre les pauvres auteurs spoliés, car j’ai toujours considéré que la nature même de l’information est de circuler sans barrières (Information wants to be free, tout ça) et que le droit d’auteur en est une, et particulièrement perverse.

La définition d’une IA open source ressemble furieusement à un constat d’échec

L’OSI a publié une définition d’IA open source. Cette définition mérite qu’on s’y attarde.

Premier point intéressant : après des années à tenter de se démarquer du Libre, notamment via la définition de l’Open Source qui tente de reformuler les 4 libertés sans recopier les 4 libertérs, l’OSI baisse les bras : est open source une IA qui respecte les 4 libertés.

Deuxième point intéressant : est open source une IA qui publie la liste des neurones, le corpus d’entraînement et la méthode d’entraînement. En fait, ça revient à ne pas choisir entre les neurones et leur méthode d’entraînement. Soit, mais ça ne résout pas le problème de l’effet boîte noire. Au mieux, ça revient à admettre qu’il est le même pour le programmeur et l’utilisateur.

Conclusion : qu’attendre d’une IA libre ?

Il ne fait aucun doute que développer des IA libres exigera de nouvelles licences. La GPL, on l’a vu, expose à un risque juridique du fait de l’ambiguïté de la définition du code source.

Il est à noter, d’ailleurs, qu’une IA repose rarement exclusivement sur son réseau de neurones : il y a systématiquement au moins un logiciel classique pour recueillir les inputs de l’utilisateur et les passer au réseau de neurones, et un second en sortie pour présenter les outputs. Ces briques logicielles, elles, peuvent tout à fait suivre le paradigme classique du logiciel libre.

En définitive, cher lecteur qui ne développes pas d’IA, je t’invite surtout à te demander : qu’attends-tu d’une IA ? Qu’entends-tu quand on te parle d’IA libre ? Plus fondamentalement, l’IA serait-elle un des rares domaines où il existe une distinction pratique entre libre et Open Source ?

Il n’y a pas de façon simple de faire une IA libre, il n’y a peut-être pas de façon du tout. Mais le principe du libre, c’est que c’est à l’utilisateur in fine de prendre ses décisions, et les responsabilités qui vont avec. Je n’espère pas t’avoir fait changer d’avis : j’espère modestement t’avoir fourni quelques clés pour enrichir ta réflexion sur le sens à donner au vocable IA open source qu’on voit fleurir ici et là.