IA générative : comment coder une IA simple ?
- Par
Pollen - Publié le
- 10/06/2025
- Temps de lecture
- 12min
En 2025 : coder une IA n’a jamais été aussi simple… et stratégique
Avec l’essor des grands modèles de langage, de ChatGPT à Mistral, de Midjourney à Dust, l’IA s’est invitée dans tous les métiers. Mais entre tester un outil et coder soi-même une intelligence artificielle, il y a un monde. Un monde qui semble encore réservé aux experts, chercheurs, ou développeurs aguerris.
Et si cela n’était qu’un mythe ?
Aujourd’hui, vous pouvez créer un modèle d’IA simple en quelques lignes de code, sans doctorat, sans GPU de compétition. Une IA qui prédit, qui classe, qui génère, bref, une IA qui fonctionne vraiment. Et le constat est souvent le même : ceux qui passent de la théorie à la pratique prennent une longueur d’avance, coder une IA pourrait vous permettre de véritablement craquer les concepts clés du machine learning appliqués à votre métier.
Alors par où commencer ?
Quel langage utiliser ? Faut-il tout coder à la main ? Comment entraîner un modèle ? Et surtout : à quoi ça sert, concrètement ?
📌 À la clé :
✅ des lignes de code prêtes à l’emploi
✅ les bons outils à connaître
✅ des cas d’usage concrets
✅ et les erreurs à éviter quand on débute
Avant de commencer à coder, comprendre les bases de l’IA
Avant de plonger dans Python et les frameworks, prenons une minute pour clarifier ce que nous entendons par « coder une IA ». Car spoiler alert : vous n’allez pas inventer un nouveau ChatGPT. Et c’est tant mieux. Développons plutôt un outil simple, capable de vous aider sur un cas d’usage précis.
IA, Machine Learning, Deep Learning : quelles différences ?
- L’Intelligence artificielle (IA) : un programme de calcul capable de réaliser des tâches simples qui requièrent normalement une intelligence humaine
Exemple concret : une IA qui trie les CVs.
- Le Machine learning (ML) : sous catégorie de l’IA : algorithme qui permet à l’IA d’apprendre et progresser à partir de données d’entrainement sans être explicitement programmée.
Exemple concret : un modèle algorithmique qui prédit un score de crédit
- Le Deep learning (DL) : sous-catégorie du ML : algorithmes de machine learning avec une structure logique qui imite les réseaux de neurones du cerveau humain.
Exemple concret : les LLM, comme ChatGPT, Midjourney ou Mistral
Que signifie « coder une IA » ?
Le rôle du code est de :
- Préparer les données d’entrée
- Choisir un modèle d’apprentissage
- Entraîner le modèle
- Tester son efficacité
- L’utiliser pour prédire ou générer une réponse
📋 Exemples de ce que l’on peut coder (et rapidement)
Voici à quoi ressemblerait un premier code d’IA
⭐️ Objectif : prédire si un client achètera un produit selon ses données historiques.
python
CopierModifier
# Étape 1 : Importer les bibliothèques
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
# Étape 2 : Charger les données (exemple CSV)
df = pd.read_csv("clients.csv")
# Étape 3 : Préparer les features et la cible
X = df[["âge", "revenu", "nombre_visites_site"]]
y = df["acheteur"] # 1 = oui, 0 = non
# Étape 4 : Séparer entraînement / test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Étape 5 : Créer et entraîner le modèle
model = RandomForestClassifier()
model.fit(X_train, y_train)
# Étape 6 : Prédire et évaluer
y_pred = model.predict(X_test)
print("Précision :", accuracy_score(y_test, y_pred))
Ce que fait ce code :
- Lit un fichier de données clients
- Utilise un algorithme d’apprentissage supervisé
- Prédit si un nouveau client achètera ou non
- Donne une précision (%) du modèle
Et après ?
L’IA codée ici est simple, mais fonctionnelle. Une fois cette base comprise, vous pouvez :
- tester d’autres modèles (logistic regression, SVM…)
- intégrer des données temps réel
- déployer l’IA dans une interface web (on en parle plus bas)
Étape 1 : Choisir un cas d’usage d’IA à coder
Avant même d’écrire une ligne de code, il faut répondre à une question essentielle : pourquoi voulez-vous coder une IA ? Existe-t-il déjà une solution sur le marché, un outil no-code, une IA générative pour vous aider ? Et si oui, pourquoi passer par un code local ?
3 types de cas d’usage :
Notre conseil : commencez par un modèle de classification. C’est intuitif, rapide à tester, et vous verrez immédiatement l’impact de vos données et de vos choix techniques.
Comment choisir votre cas d’usage ?
Voici une grille rapide pour vous guider :
📎 Ressource bonus : Le KIT IA Pollen
Besoin d’intégrer les meilleures pratiques IA des leaders du marché ? Le KIT IA Pollen réunit des contenus clefs, présentations, évènements exclusifs pour ce lancer.
Étape 2 : Préparer les données(et les comprendre)
La clé d’une IA exploitable et performante c’est vos données. Proprement préparées, correctement organisées, et surtout : intelligibles.
Pourquoi cette étape est essentielle ?
Parce qu’un algorithme, aussi puissant soit-il, ne fera que reproduire les tendances de vos données d’entrainement. Si ces dernières sont déséquilibrées, incomplètes ou biaisées, le modèle le sera aussi.
En IA, on dit souvent :
2.1 Trouver ou créer son dataset
Pas besoin de collecter des millions de lignes de donnée pour démarrer.
💡 3 solutions simples :
- Utiliser des datasets open source (Kaggle, OpenML, Hugging Face Datasets)
- Simuler un petit jeu de données avec pandas (pratique pour tester)
- Utiliser des données internes (si vous travaillez en entreprise)
2.2 Explorer ses données
Une fois votre fichier .csv chargé, l’objectif est d’analyser rapidement ce qu’il contient, identifier les incohérences, et comprendre les corrélations potentielles.
python
CopierModifier
import pandas as pd
# Chargement des données
df = pd.read_csv("donnees_clients.csv")
# Aperçu rapide
print(df.head())
# Statistiques de base
print(df.describe())
# Informations sur les types de variables
print(df.info())
2.3 Nettoyer les données
Cas typiques à traiter :
- Valeurs manquantes
- Données aberrantes (ex. : un client avec 300 ans ou -10 € de revenu)
- Formats incohérents (date en texte, oui/non en chiffres…)
python
CopierModifier
# Suppression des lignes incomplètes (option 1)
df_cleaned = df.dropna()
# Ou remplacement des valeurs manquantes (option 2)
df["revenu"] = df["revenu"].fillna(df["revenu"].median())
# Conversion de texte en numérique (ex. oui/non → 1/0)
df["abonné_newsletter"] = df["abonné_newsletter"].map({"oui": 1, "non": 0})
2.4 Séparer les features et la cible
À ce stade, vous devez déjà répondre à cette question :
Qu’est-ce que je veux prédire ?
Exemple :
Vous voulez prédire si un client va acheter → la cible, c’est la colonne achat.
Tout le reste (âge, revenu, fréquence de visite, etc.) deviennent vos features.
python
CopierModifier
X = df_cleaned[["âge", "revenu", "visites"]]
y = df_cleaned["achat"]
2.5 Créer un jeu d'entraînement et un jeu de test
Avant de lancer l’apprentissage, vous devez diviser vos données : une partie pour entraîner le modèle, une autre pour tester sa capacité à généraliser.
python
CopierModifier
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42
)
À ce stade, vous avez :
✅ Un jeu de données nettoyé
✅ Des variables numériques exploitables
✅ Un jeu d’entraînement pour faire apprendre l’IA
✅ Un jeu de test pour évaluer sa performance
Ce qu’il faut retenir :
- Préparer les données, c’est 80% du travail en machine learning.
- Plus vos données sont claires, plus votre IA sera fiable.
- C’est aussi à cette étape que vous comprenez réellement votre sujet.
Étape 3 : entraîner un premier modèle d’IA en Python
Maintenant que vos données sont prêtes, il est temps de passer à l’étape centrale du machine learning : entraîner votre modèle.
Autrement dit, permettre à votre programme d’apprendre automatiquement à prédire un résultat, à partir des exemples qu’on lui fournit.
L’algorithme que nous allons utiliser
Pour ce premier projet, nous allons utiliser un modèle très répandu : Random Forest.
- C’est un algorithme d’apprentissage supervisé
- Il est robuste, rapide et interprétable
- Il fonctionne bien même avec peu de données
📌 Étape par étape : entraîner votre IA
Voici un code complet, commenté ligne par ligne.
python
CopierModifier
# 1. Importer le modèle RandomForest de scikit-learn
from sklearn.ensemble import RandomForestClassifier
# 2. Créer une instance du modèle
model = RandomForestClassifier(random_state=42)
# 3. Entraîner le modèle sur les données d'entraînement
model.fit(X_train, y_train)
🔍 Étape suivante : faire des prédictions
python
CopierModifier
# 4. Utiliser le modèle pour prédire les résultats sur les données test
y_pred = model.predict(X_test)
Vous venez de créer votre première IA fonctionnelle.
Mais est-elle fiable ? C’est ce que nous allons évaluer.
🧪 Évaluer les performances de votre modèle
On commence par une première métrique essentielle : la précision (accuracy).
python
CopierModifier
from sklearn.metrics import accuracy_score
# 5. Évaluer le score de précision
accuracy = accuracy_score(y_test, y_pred)
print("Précision du modèle : {:.2f}%".format(accuracy * 100))
Comment interpréter ce score ?
Précision (%)
> 90% : Excellent (mais attention au sur-apprentissage
70-90% : Bon début, surtout avec peu de données < 70% : Il faut améliorer la qualité du data set ou ajuster le modèle
💡 Et maintenant, que peut-on améliorer ?
Même si votre IA fonctionne, c’est souvent un point de départ, pas une fin en soi.
Vous pouvez ensuite :
- Tester d’autres modèles (ex. : LogisticRegression, GradientBoosting, etc.)
- Ajuster les paramètres de votre modèle.
- Ajouter des variables ou retravailler la préparation des données
- Appliquer une validation croisée (cross-validation)
Bonus : scikit-learn propose une API très simple pour tester plusieurs modèles avec les mêmes données.
Ce qu’il faut retenir
- Entraîner une IA = faire apprendre un modèle à partir d’un jeu de données
- Random Forest est un bon modèle par défaut, robuste et facile à mettre en œuvre
- La précision seule ne suffit pas toujours : l’interprétation métier reste essentielle
Étape 4 : Tester et améliorer son IA
Votre modèle est entraîné. Il donne des prédictions. Mais… sont-elles fiables ? Utilisables ? Améliorables ?
C’est tout l’enjeu de cette étape : évaluer la qualité du modèle et comprendre comment l’améliorer, sans repartir de zéro.
✅ Précision ≠ performance
Vous avez peut-être obtenu 85 % de précision. Bonne nouvelle.
Mais en IA, un seul chiffre ne dit jamais tout.
Prenons un exemple concret :
Vous entraînez un modèle pour détecter des fraudes bancaires.
Si 99,5 % des transactions sont normales… un modèle qui dit “tout est normal” aura 99,5 % de précision.
📊 Comprendre les bonnes métriques
Voici les indicateurs que vous devez maîtriser pour évaluer une IA de classification :
- Accuracy :
- Recall (sensibilité) :
- Precision :
- F1-score :
📦 Utiliser une matrice de confusion
Une matrice de confusion permet de visualiser facilement les performances.
python
CopierModifier
from sklearn.metrics import confusion_matrix, classification_report
# Calcul des métriques avancées
cm = confusion_matrix(y_test, y_pred)
report = classification_report(y_test, y_pred)
print("Matrice de confusion :\n", cm)
print("Rapport complet :\n", report)
Exemple d'affichage (pour 0 = non-achat, 1 = achat) :
lua
CopierModifier
Matrice :
[[75 5]
[12 28]]
Interprétation :
- 75 : bien prédits comme non-acheteurs (vrais négatifs)
- 5 : faussement prédits comme acheteurs (faux positifs)
- 12 : acheteurs oubliés (faux négatifs)
- 28 : bien prédits comme acheteurs (vrais positifs)
🔧 3 leviers pour améliorer votre modèle algorithmique
1. Améliorer les données
- Ajouter de nouvelles variables explicatives (par ex. : canal d’acquisition, ancienneté client)
- Supprimer les colonnes peu utiles ou redondantes
- Mieux nettoyer ou normaliser certaines valeurs
2. Changer d’algorithme
- Essayez d’autres modèles avec scikit-learn : LogisticRegression, GradientBoostingClassifier, KNeighborsClassifir…
- Utilisez GridSearchCV pour tester plusieurs combinaisons automatiquement
3. Ajuster les hyperparamètres
Chaque algorithme possède des paramètres internes (appelés hyperparamètres) que vous pouvez personnaliser.
Exemple pour RandomForestClassifier :
python
CopierModifier
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)
📦 Pour automatiser ces tests, utilisez :
python
CopierModifier
from sklearn.model_selection import GridSearchCV
params = {"n_estimators": [50, 100, 200], "max_depth": [3, 5, 10]}
grid = GridSearchCV(RandomForestClassifier(), params, cv=5)
grid.fit(X_train, y_train)
print("Meilleurs paramètres :", grid.best_params_)
Ce qu’il faut retenir
- Ne vous arrêtez pas à la précision. Comprenez ce que votre IA fait bien… ou mal.
- Tester, c’est aussi observer les erreurs pour les corriger ensuite.
- Améliorer un modèle, c’est souvent améliorer les données avant l’algorithme.