Ce week-end prolongé, j’ai consacré une grande partie de mon temps à finaliser les premiers tests d’un agent IA local capable d’utiliser des outils, manipuler du contexte et exploiter une base de connaissances.

L’objectif était avant tout de comprendre ce qu’il est réellement possible de construire aujourd’hui avec des modèles locaux et une architecture relativement simple.

Pour ce POC, j’ai volontairement choisi de ne pas utiliser de frameworks agentiques existants comme OpenClaw ou d’autres solutions similaires.

Le but n’était pas de réinventer l’existant, mais plutôt de comprendre concrètement les mécanismes réels derrière un agent :

• gestion du contexte,
• sélection des outils,
• orchestration,
• mémoire,
• limitations des modèles et comportements inattendus.

Très rapidement, plusieurs constats sont apparus.

Certaines fonctionnalités semblaient étonnamment efficaces.

D’autres, en revanche, révélaient rapidement certaines limites.

Je vais donc partager ici ce retour d’expérience autour de ce simple POC (Proof of Concept), ainsi que plusieurs problématiques rencontrées lors de ces premières expérimentations.

Des usages très concrets en entreprise

Derrière le terme « agent IA » se cachent surtout de nouveaux usages potentiels pour les entreprises.

Même avec un périmètre encore limité, ce type de système peut déjà permettre :

• de rechercher des informations dans une documentation interne,
• résumer des documents,
• automatiser certaines tâches répétitives,
• assister des utilisateurs,
• centraliser des connaissances,
• faciliter l’accès à certaines données métier.

Dans de nombreux contextes, l’objectif n’est d’ailleurs pas forcément de remplacer un utilisateur humain. L’intérêt peut simplement être de gagner du temps ou répondre à de forte sollicitations. Permettre de concentrer sur le cœur du métier. Améliorer le rendu de certains documents.

C’est précisément ce potentiel qui rend aujourd’hui les systèmes agentiques particulièrement intéressants à explorer pour les entreprises.

Mais au fait, qu’est-ce qu’un agent IA ?

Le terme “agent IA” est aujourd’hui utilisé un peu partout.

Pourtant, derrière ce mot se cachent souvent des réalités très différentes.

Dans sa forme la plus simple, un agent IA peut être vu comme un système capable :

• d’interpréter une demande,
• de choisir une ou plusieurs actions,
• puis d’utiliser différents outils pour atteindre un objectif.

Contrairement à un chatbot classique qui se contente de générer du texte, un agent peut interagir avec son environnement :

• lire un document,
• effectuer une recherche sur internet,
• appeler une API (un service externe),
• exécuter du code,
• ou interroger une base de données.

Finalement, on peut voir un agent comme une IA placée devant plusieurs boutons sur lesquels elle peut décider d’appuyer.

Et c’est précisément là que les choses commencent à devenir intéressantes… et parfois beaucoup plus complexes que prévu.

Une architecture volontairement simple et locale

Pour ces premiers tests, l’objectif n’était pas de construire une plateforme complète, mais plutôt un POC permettant de comprendre les mécanismes fondamentaux derrière un agent IA.

L’architecture retenue reste donc relativement simple :

• un orchestrateur développé en Python,
• plusieurs outils (programmes informatiques) accessibles par l’agent,
• une base de données PostgreSQL pour stocker certaines informations,
• un système de vectorisation pour la recherche sémantique,
• et des modèles de langage exécutés localement via Ollama.

Le choix du local était volontaire.

Aujourd’hui, de nombreuses démonstrations d’agents reposent entièrement sur des APIs cloud ou modèles très puissants.

Cela permet d’obtenir rapidement des résultats impressionnants, mais masque aussi une partie importante des contraintes techniques réelles :

• consommation mémoire,
• temps de réponse,
• stabilité,
• gestion du contexte,
• ou encore limitations matérielles.

L’objectif de ce POC était justement de mieux comprendre ces problématiques dans un environnement maîtrisé.

Choix du modèle

Plusieurs modèles ont ainsi été testés localement au cours des expérimentations :

• Mistral,
• Llama 3, et 3.2
• Qwen 2.5 et 3.5
• DeepSeek R1,
• Gemma 3,
• Nomic Embed Text pour la génération des embeddings utilisés dans la recherche sémantique.

(Si le concept d’embeddings vous intéresse, je pourrai vous faire un article dédié.)

Les comportements observés étaient parfois très différents selon les usages.

Certains modèles semblaient relativement efficaces pour dialoguer ou reformuler une demande, mais beaucoup moins fiables lorsqu’il fallait sélectionner correctement un outil ou respecter un format précis.

La taille de ces modèles est volontaire limité pour tenir sur un pc et certains peuvent « halluciner » des réponses.

Même de simples ajustements de paramètres pouvaient fortement modifier le comportement global du système.

Le premier piège : le faux sentiment d’intelligence

Les premiers résultats obtenus étaient parfois étonnamment convaincants.

L’agent semblait capable :

• de comprendre certaines demandes,
• d’utiliser des outils,
• d’enchaîner plusieurs étapes,
• maintenir des conversations relativement cohérentes.

Par moments, l’ensemble donnait réellement l’impression d’un système capable de raisonner. Mais très rapidement, plusieurs comportements plus instables sont apparus. Par exemple, même lorsqu’un outil n’était pas nécessaire, l’agent cherchait parfois malgré tout à en utiliser un.

Dans d’autres cas :

• il sélectionnait un mauvais outil,
• interprétait mal le contexte,
• ou produisait des réponses plausibles… mais incorrectes.

Et lorsque ce système commence à interagir avec des outils ou des données réelles, cette illusion de maîtrise devient rapidement un sujet important.

Si votre agent n’appuie pas sur le bon bouton au bon moment, qui est responsable de l’action ?

Le moment où les prompts deviennent un problème

Au début du prototype, beaucoup de logique était directement dans les prompts, un peu à la manière d’interagir avec un chatbot..

Quelques règles ici. Quelques instructions là. Un peu de contexte supplémentaire.

Et soudain :
le système commence à devenir impossible à maintenir. Le moindre changement produit des effets de bord. Une phrase ajoutée pour améliorer un comportement peut en dégrader trois autres.

C’est à ce moment qu’une décision importante a été prise :

Aucun comportement métier , prompt ou choix de modèle ne devait être codé en dur. Les prompts, les outils, les paramètres et les règles devaient être externalisés.

L’objectif n’était pas seulement technique. Il s’agissait surtout d’éviter qu’un agent devienne une accumulation opaque de règles impossibles à comprendre. Ce choix a permis de supprimer les problèmes un par un.

De plus, finalement, le prompt ou le modèle ne sont pas si important dans la fabrication de l’agent. Cela sert surtout aux dernières optimisations.

Ce qu’il se passe réellement avant que l’agent réponde

Lorsqu’un utilisateur pose une question à un agent IA, la réponse n’est généralement pas produite immédiatement.

Avant d’obtenir une réponse finale, plusieurs étapes intermédiaires sont souvent nécessaires.

Dans le cadre de ce POC, le fonctionnement général reposait approximativement sur la chaîne suivante :

1. réception de la demande utilisateur,
2. analyse de l’intention,
3. reconstruction éventuelle du contexte conversationnel (usage de la mémoire),
4. recherche des outils potentiellement pertinents,
5. sélection d’un outil,
6. exécution de l’action,
7. récupération du résultat,
8. réinjection du résultat dans le contexte,
9. puis génération de la réponse finale.

Sur le papier, cette logique paraît relativement simple.

Mais dans la pratique, chaque étape peut devenir une source potentielle d’erreurs ou de comportements inattendus. Il est important de les découper en module distinct et indépendant afin de comprendre ou le modèle fait une erreur et comment changer la partie qui pose problème.

Un modèle très léger (par exemple: qwen2.5) peut suffire pour certaines tâches simples comme la reformulation, tandis qu’un modèle plus performant sera réservé aux étapes nécessitant davantage de raisonnement ou de génération de contenu. Cela permet une économie d’énergie, de coût pour une meilleur performance.

Très rapidement, on réalise donc qu’un agent IA n’est pas seulement un “modèle qui répond”. C’est surtout une chaîne d’orchestration dans laquelle chaque étape influence potentiellement toutes les autres.

Les différents outils mis à disposition de l’agent

Dans ce POC, l’agent ne disposait évidemment pas d’un accès libre au système.

Chaque action possible devait être définie à l’avance.

Autrement dit, l’agent ne pouvait agir qu’à travers certains outils mis à sa disposition.

Parmi les capacités disponibles, il pouvait par exemple :

• obtenir la date et l’heure,
• récupérer la météo pour une ville donnée,
• rechercher des informations sur internet,
• lire les fichiers d’un répertoire ou écrire dans un autre,
• interroger une base de connaissances,
• ou encore résumer un document.

On peut finalement voir ces outils comme une série de boutons accessibles à l’agent selon les besoins.

Lorsqu’un utilisateur pose une question, le modèle tente alors de déterminer :

• s’il doit utiliser un outil,
• lequel semble le plus adapté,
• puis comment exploiter le résultat obtenu pour construire sa réponse.

Une grande partie du travail consiste donc à organiser correctement ces différents outils afin de rendre le comportement de l’agent le plus cohérent possible.

Une première vraie satisfaction

Après plusieurs ajustements et expérimentations, un moment particulièrement satisfaisant est finalement apparu :

celui où l’agent commence réellement à répondre comme attendu.

Les échanges devenaient plus naturels, les outils étaient correctement utilisés et certaines réponses donnaient enfin l’impression d’un système réellement utile.

Même dans le cadre de ce simple POC, voir un agent :

• rechercher des informations,
• exploiter une base de connaissances,
• utiliser différents outils,
• puis construire une réponse cohérente,
  reste particulièrement impressionnant.

Et surtout, cette architecture ouvre désormais la porte à une évolution progressive des capacités de l’agent.

Le prochain objectif sera d’ailleurs de lui permettre de générer lui-même certains nouveaux outils afin d’étendre progressivement ses possibilités, tout en conservant un cadre maîtrisé et sécurisé.
Et cette dernière partie sera un vrai défi…

L’article Concevoir un agent IA local est apparu en premier sur Databridge.fr.

Avec l’explosion de l’IA générative, nous avons désormais le pouvoir de créer en quelques secondes des affiches pédagogiques, des infographies scientifiques ou même des guides de survie. Génial, non ?

Sauf quand l’outil que vous utilisez vous recommande… de cuisiner une Amanite phalloïde.

Avant d’aller plus loin, je précise que les amanites phalloïdes et amanites tue-mouches sont potentiellement mortelles. Ne les consommez jamais.

Dans cette expérience, j’ai demandé à ChatGPT de me générer une affiche illustrée classant les champignons selon leur toxicité. Ce qui devait être un support de sensibilisation s’est transformé en exemple flagrant d’illusion de fiabilité.

Car si l’image est belle, elle est biologiquement fausse. Et pire encore : l’analyse automatique du modèle vient corriger l’erreur… en la maquillant.

Une plongée fascinante et inquiétante dans les biais de perception, les limites techniques, et les risques bien réels que peut engendrer l’usage non encadré de l’IA générative — même avec une simple affiche de champignons.

1. L’expérience

Tout commence par un prompt très simple, quasi inoffensif :

« Représente-moi une affiche avec 20 champignons classés en fonction de leur dangerosité. »

L’idée ? Créer un support pédagogique visuel, comme on en voit dans les salles de classe, les centres nature ou les sentiers de randonnée. Une infographie synthétique, claire, jolie… et surtout utile.

Le résultat est bluffant. DALL·E (le générateur d’image de chatGPT) me génère une belle affiche, propre, bien structurée, avec deux colonnes :
👉 à gauche les comestibles,
👉 à droite les toxiques,
le tout dans un style didactique tout droit sorti d’un manuel de sciences naturelles.

À première vue, tout semble parfait. Trop parfait.

Car à y regarder de plus près, je découvre un détail… légèrement inquiétant :
➡️ L’Amanite phalloïde figure dans la colonne “comestible”.
➡️ L’Amanite tue-mouches aussi.

Deux espèces hautement toxiques, potentiellement mortelles, présentées comme de bons petits légumes d’automne. Le genre d’erreur qui, sur une affiche réelle, pourrait envoyer quelqu’un à l’hôpital — ou pire.

⚠️ Il y a d’autres erreurs de classification sur l’affiche, parfois plus subtiles.
Mais pour cet article, nous allons nous concentrer uniquement sur ces deux cas emblématiques, car ils suffisent à mettre en évidence les limites profondes du système.

J’ai barré sur l’image les champignons qui ne sont pas dans la bonne classe.

Cette erreur n’est pas simplement visuelle. Elle est systémique : elle révèle que l’image n’est pas fondée sur une base de connaissances scientifiques. Elle n’a pas été validée. Elle semble crédible, mais elle est radicalement fausse.

Et c’est là que tout devient intéressant — et inquiétant.

2. Comprendre l’erreur : entre illusion visuelle et correction automatique

L’erreur de classification des champignons n’est pas une simple coquille graphique. Elle illustre une faille de conception bien plus profonde dans les outils d’IA générative actuels : la rupture entre ce que l’IA « dessine », et ce qu’elle « discute ».

2.1 DALL·E : l’illusion par l’image

L’affiche a été générée par DALL·E, un modèle d’IA conçu pour transformer des textes en images. Il fonctionne à partir d’un gigantesque corpus d’images, qu’il a apprises statistiquement. Quand tu lui demandes une “affiche pédagogique”, il ne consulte pas un manuel de biologie — il recompose visuellement ce qui ressemble à une affiche pédagogique. Par interpolation esthétique, pas par connaissance factuelle.

Même si ChatGpt est plutôt un modèle de diffusion, vous pouvez lire mon article sur : Comment générer des images de lotus avec un GAN (Réseaux Génératifs Adversariaux )
Vous aurez une idée générale sur le fonctionnement.

Il ne sait pas ce qu’est une Amanite phalloïde. Il sait juste à quoi elle ressemble, et avec quoi elle est souvent représentée.

Il peut donc mélanger sans broncher champignons comestibles et toxiques, pourvu que le résultat soit visuellement cohérent. L’image est belle, mais elle n’a aucune garantie de vérité.

2.2 GPT-4o : une analyse guidée par ses croyances internes

Après avoir généré l’image, j’ai voulu tester la cohérence du système. Je pose à GPT-4o une requête structurée et explicite :

« Peux-tu analyser l’image, et me lister précisément les noms des champignons présents ? Indique dans quelle colonne ils apparaissent (comestible ou toxique), et vérifie si l’image de chaque champignon correspond bien au nom indiqué. »

L’objectif est simple : confronter ce que le modèle voit à ce qu’il dit.

Voici un extrait de la réponse obtenue :

Dans ce tableau, d’analyse il y a 2 erreurs.

• La première nous saute aux yeux ! Une amanite phalloïde peut s’avérer mortelle et chatGPT a bien identifié son erreur.
• La deuxième est plus subtile puisqu’il m’indique que l’amanite tue-mouches a été classée « toxique » dans l’image générée, ce qui n’était pas le cas, comme vous pouvez le constater sur l’image… Et même après plusieurs échanges et remise en question, chatGPT ,n’a jamais réussi à « me mettre dans l’amanite dans la catégorie »reconnaitre » cette erreur.
  Pour lui, statistiquement une amanite tue-mouches ne peut être que toxique. Impossible de présenter les résultats tel qui sont dans la réalité.
  
  En d’autres termes, ChatGPT, souffre ici d’un excès de confiance ! Une sorte de biais cognitif:
  « Cela se manifeste lorsque la confiance subjective d’une personne dans ses jugements dépasse systématiquement l’exactitude objective de ces jugements, surtout lorsque la confiance est élevée »

3. Les implications : risque pédagogique, éthique en question

Ce test sur une simple affiche de champignons pourrait prêter à sourire. Une IA qui confond un bolet et un poison, après tout, ce n’est pas la fin du monde…

Et pourtant, si.

Car cette erreur visuelle corrigée silencieusement par l’analyse révèle des risques très concrets dans de nombreux domaines où l’IA est déjà utilisée — parfois sans qu’on en mesure vraiment les conséquences.

3.1 Pédagogie : le faux savoir en vitrine

Dans un contexte éducatif ou grand public, une IA qui génère de fausses classifications sans le signaler devient un risque pédagogique majeur.

Les outils comme DALL·E sont déjà utilisés pour créer des visuels de cours, des supports d’ateliers, voire des jeux éducatifs.

Imaginons une personne qui mémorise l’apparence de l’Amanite phalloïde en pensant qu’elle est comestible.
Ou un enseignant qui imprime une telle affiche sans vérifier chaque champignon. L’autorité visuelle de l’IA donne à ces contenus une crédibilité trompeuse.

Ce n’est plus une simple erreur : c’est un transfert de responsabilité invisible

3.2 Santé, environnement, sécurité : quels sont les risques

Le champignon n’est qu’un exemple. Demain, ce sera :

• une plante médicinale mal identifiée,
• un insecte toxique classé comme inoffensif,
• un symptôme médical mal représenté,
• une manipulation de produit chimique mal illustrée.

DALL·E ne fait pas la différence entre “ce qu’on voit souvent” et “ce qui est vrai”.
GPT-4o, de son côté, partage l’image sans vérifier quelle est correcte.

Ce fonctionnement en tandem est instable. Il repose sur une confiance implicite du système dans sa propre justesse, sans que l’utilisateur sache à quel moment il faut douter.

L’utilisateur pourra avoir confiance en la réponse de ChatGPT qui, avouons le se trompe de moins en moins, pourtant l’outil sous-jacent n’est pas aussi puissant.

Ici, il faut considérer que chatGPT sous-traite à Dall-e la génération d’image sans vérifier qu’elle sert son propos. Et lorsqu’il essaie de le faire, ses biais l’empêche de discerner le vrai du faux dans la réalité.

Il est important de conserver son esprit critique lorsque nous utilisons des outils génératifs.
Sous une apparente compétence, ce sont des outils qui travaillent grâce à leur imperfection.
Avec les IA générative on génère des textes ou des images nouvelles avec « des grains de sable » (vous retrouverez parfois le terme de « SEED » qu’on utilise pour « maitriser » ce hasard) .
Ces grains de sables permettent de générer « au hasard » des choses nouvelles mais introduit aussi un risque d’hallucination.

Éthique : que doit-on attendre d’un système génératif ?

Il est urgent de poser des limites claires :

• Un système génératif doit pouvoir signaler l’incertitude.
• Il doit distinguer description et interprétation.
• Il doit alerter activement en cas de contenu potentiellement dangereux.
• Il doit être transparent sur les outils qu’il utilise lors des cas sous-traitance
• Il doit vérifier le contenu qu’il partage
• Et surtout : il ne doit être capable de corriger un contenu faux

Même si ce cas, n’est qu’anecdotique, il rappel à quel point il est nécessaire de revérifier les contenus générés par des IA.

Vous reprendrez bien un peu de mon omelette aux champignons ?

L’article IA générative : risque d’hallucination mortelle ! est apparu en premier sur Databridge.fr.

Dans le vaste monde de l’intelligence artificielle, les réseaux génératifs ont révolutionné notre façon de créer. Imaginez une machine capable de peindre des tableaux, de composer de la musique, de concevoir des vêtements, ou même d’inventer de nouvelles saveurs de boissons. Les réseaux génératifs ouvrent une porte vers ces possibilités.

L’Essence des Réseaux Génératifs

À la base, un réseau génératif est une forme avancée d’apprentissage automatique qui s’efforce de reproduire des données. Contrairement aux modèles classiques qui apprennent à catégoriser ou à prédire, les réseaux génératifs apprennent à générer. Ils étudient en profondeur les données dont ils disposent, comprennent leurs nuances, leurs motifs et leurs structures, puis essaient de produire des données nouvelles mais similaires.

Dans cet article nous allons étudier un modèle génératif en profondeur et je vous partagerai le modèle et mes propres résultats. Mais avant de commencer quelques explications.

Qu’est-ce qu’un Réseau Génératif ?

Un réseau génératif est une sorte de réseau neuronal artificiel conçu pour créer de nouvelles données qui ressemblent à certaines données d’entrée. Prenons un exemple simple : si nous alimentons un réseau génératif avec des milliers d’images de fleurs de lotus, il peut « apprendre » les caractéristiques typiques d’une fleur de lotus et, à la fin, générer des images de fleurs de lotus qui n’ont jamais existé auparavant.

Les Réseaux Génératifs Adversariaux (GANs)

Avant de plonger dans le vif du sujet, il est essentiel de comprendre les GANs. Un GAN se compose de deux réseaux : le Générateur et le Discriminateur. Le générateur crée des images, tandis que le discriminateur essaie de distinguer les images générées des images réelles.

C’est une sorte de jeu entre un détective et un faussaire où le générateur tente de produire des faux toujours plus convaincants, et le discriminateur s’efforce de devenir meilleur détective.

Cette étape s’appelle, l’entrainement. Une fois que nous considérons l’entrainement terminé, il est temps d’observer les productions du générateur.

Les Limitations des GANs

Bien que les GANs soient puissants, ils ne sont pas parfaits. Ils peuvent être instables durant l’entrainement, produisant des résultats indésirables ou se concentrant trop sur certaines caractéristiques au détriment d’autres.

Lors de mes tests avec les GANs, les modèles s’effondrent régulièrement et ne génèrent plus que des images extrêmement saturés où alors souvent la même on dit qu’il rentre en « mode Collapse ». Heureusement il y a des solutions.

WGAN : Une Amélioration

Une première amélioration est de modifier le rôle du discriminateur, il devient critique.

Les GANs Wasserstein, ou WGANs, sont une solution à certains des problèmes des GANs traditionnels. Au lieu d’utiliser la probabilité que l’image soit réelle ou fausse comme mesure de performance, les WGANs mesurent la distance entre la distribution des images générées et celle des images réelles. Cette mesure est plus stable et offre des avantages en termes de convergence et de qualité de génération.

Le distance de Wasserstein: Au lieu d’utiliser la divergence de Jensen-Shannon (comme dans les GANs traditionnels) pour mesurer la différence entre les distributions réelles et générées, les WGANs utilisent la distance de Wasserstein (également appelée distance de transport optimal de premier ordre). Cette distance donne une mesure plus significative de la différence entre deux distributions, même lorsque les supports des deux distributions ne se chevauchent pas.

WGAN-GP : Une belle avancée pour les GANs

Le WGAN-GP ajoute une « Pénalité de Gradient » au WGAN. Cela garantit que le discriminateur (appelé critique dans le WGAN) reste « lisse » dans l’espace des images. Cette lissité est cruciale pour que le signal du discriminateur au générateur soit utile et stable. La pénalité de gradient empêche le discriminateur de devenir trop confiant, ce qui pourrait provoquer des instabilités.

La méthode de pénalisation du gradient pour les WGANs a été introduite dans le papier « Improved Training of Wasserstein GANs » par Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin et Aaron Courville. Ce papier a été publié en 2017.

A quoi ressemble mon réseau WGAN-GP

Je vais ajouter quelques éléments de contexte et des tailles techniques pour vous expliquer mes tests. Vous pouvez évidement les ignorer si ce n’est pas votre domaine.

Mon objectif est d’apprendre au générateur de produire des fleurs de lotus

Pour commencer, j’utilise un simple PC, sans GPU (Je ferai un article sur l’utilité des GPUs dans un prochain article). En raison de cette limitation, la taille du jeu données est très faible (68 images et non des millions) et la définition limitée.

Concernant le jeu de données, j’ai utilisé 68 images générées sur MidJourney. Bien-sur, elles ne sont pas réelles mais me suffisent dans le cadre de l’expérience.

Le programme est en Python, un des langages de prédilections pour les scientifiques de données. En particulier j’utilise la bibliothèque PyTorch pour cet exercice.

Le générateur est un réseau de neurones composés de 5 couches qui font de la transposition de convolutions (ou déconvolution par abus de langage).
Le réseau démarre en produisant un pixel, puis chacune des couches augmente la taille spatiale en réduisant le nombre de dimensions pour finir avec une image de 128*128 pixels. La fonction d’activation non linéaire utilisée sur les couches du réseau est ReLu: f(x)=max(0,x) . La dernière couche utilise la fonction Tanh.
La taille du noyau pour la déconvolution est de 4*4.

Le discriminateur est similaire mais il fait de la convolution. en d’autres terme il va réduire la taille spatiale des images de 128*128 pixels. L’image est aplatie et traitée par une couche entièrement connectée pour produire une valeur unique, qui indique si l’image est réelle ou générée.

Les résultats

Après deux bonnes nuits d’apprentissage, le réseau a réalisé près de 3000 epochs (Une epoch étant une série d’entrainements : il parcourt les données d’entrainement et génère des images qu’il évalue )

Voici les résultats obtenus aux différentes étapes de l’entrainement:

Par la suite, la progression est beaucoup moins rapide. Pour mon test, j’ai doublé le nombre d’images analysées par le discriminateur à cette étape. La qualité continue de s’améliorer et les images générées restent variées malgré le faible nombre d’images qui ont été présentées.

En conclusion

Maintenant, je vais laisser la machine s’entrainer afin d’obtenir de meilleurs résultats, on peu constater en effet que le réseau WGAN-GP continue d’apprendre et de s’approcher de l’objectif qui est de dessiner une fleur de lotus.

Pour de meilleurs résultats, il faudrait diversifier le jeu de données, 68 images, ce n’est vraiment pas suffisant. Enfin, l’utilisation d’une machine avec des GPU plutôt qu’un simple CPU serait un plus indéniable pour accélérer les calculs de façon conséquente.

Ici, je me suis consacré uniquement à la génération de fleurs de lotus en raisons des limitations matérielles mais les wgan-gp peuvent accomplir pleins d’autres taches comme le dé-bruitage d’une photo, la colorisation, la génération de visages etc…

Toutefois, ce genre d’outils soulèvent des questions éthiques concernant l’utilisation des œuvres utilisées pour l’apprentissage ou sur les droits des images générées. Pour en savoir plus, lisez l’article : L’Intelligence Artificielle Générative et les Défis du Droit d’Auteur

Comme toujours, si l’article vous a plu ou si vous avez des questions n’hésitez pas à laisser un commentaire pour que je puisse vous répondre ou améliorer l’article.

L’article L’IA générative, et si on générait des fleurs de lotus ? est apparu en premier sur Databridge.fr.