INTELLIGENCE ARTIFICIELLE
NIVEAU 4 — AVANCÉ

📋 Sommaire — Niveau 4

Chapitre 31 — Les mathématiques de l'IA 📐

Derrière chaque réseau de neurones, il y a des mathématiques. Comprendre ces bases te permettra de vraiment contrôler tes modèles, pas juste les copier-coller.

📉 La fonction de perte (Loss Function)

La fonction de perte mesure à quel point ton modèle se trompe. Plus le chiffre est grand, plus le modèle est mauvais. L'objectif de l'entraînement : minimiser cette valeur.

⛰️ La descente de gradient

La descente de gradient est l'algorithme qui ajuste les poids du réseau pour réduire la perte. Imagine que tu es au sommet d'une colline et tu veux descendre vers le point le plus bas — c'est exactement ça.

# Descente de gradient — exemple simplifié
poids = 0.5          # valeur initiale aléatoire
taux_apprentissage = 0.01   # aussi appelé 'learning rate'

for etape in range(1000):   # 1000 itérations
    prediction = poids * entree
    erreur = prediction - vraie_valeur
    gradient = erreur * entree
    poids = poids - taux_apprentissage * gradient
    # Le poids se rapproche de la valeur optimale

print('Poids optimal trouvé :', round(poids, 4))

Chapitre 32 — Les CNN : Réseaux convolutifs pour la vision 👁️

Au Niveau 3, tu as vu la vision par ordinateur. Maintenant allons plus loin : les CNN (Convolutional Neural Networks) sont l'architecture qui a révolutionné la reconnaissance d'images.

🔍 Le principe de la convolution

Une convolution, c'est faire glisser un petit filtre sur une image pour détecter des motifs : bords, textures, formes. C'est comme chercher un motif wax spécifique dans un grand tissu.

🐍 Un CNN en Python avec Keras

import tensorflow as tf
from tensorflow.keras import layers, models

# Créer un CNN pour détecter les maladies du maïs
modele = models.Sequential([
    # Couche 1 : détecte les motifs de base (bords, couleurs)
    layers.Conv2D(32, (3,3), activation='relu', input_shape=(64,64,3)),
    layers.MaxPooling2D(2,2),

    # Couche 2 : détecte des motifs plus complexes (taches, formes)
    layers.Conv2D(64, (3,3), activation='relu'),
    layers.MaxPooling2D(2,2),

    # Couche de décision finale
    layers.Flatten(),
    layers.Dense(128, activation='relu'),
    layers.Dense(2, activation='softmax')  # 2 classes : sain / malade
])

modele.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

modele.summary()  # Affiche l'architecture complète

Chapitre 33 — Pipeline NLP complet : de la phrase au modèle 🗣️

Au Niveau 3, tu as compris le principe du NLP. Ici, tu vas implémenter un pipeline NLP complet en Python — de la phrase brute jusqu'à la prédiction.

🔧 Les étapes d'un pipeline NLP

# ═══ PIPELINE NLP COMPLET — Classification de sentiments ═══
# Objectif : Détecter si un avis sur un marché béninois est positif ou négatif

import re
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# ── ÉTAPE 1 : Données brutes (avis sur le marché Dantokpa) ──
avis = [
    'Le marché est bien organisé et propre',       # positif
    'Les prix sont raisonnables aujourd hui',      # positif
    'Trop de monde, impossible de circuler',       # négatif
    'Les vendeurs sont aimables et honnêtes',      # positif
    'Produits pas frais, odeur désagréable',       # négatif
    'Bonne ambiance, je reviendrai',               # positif
    'Vol à la tire, insécurité totale',            # négatif
    'Grand choix de tissus wax, très satisfait',   # positif
]
labels = [1, 1, 0, 1, 0, 1, 0, 1]   # 1=positif, 0=négatif

# ── ÉTAPE 2 : Nettoyer le texte ──
def nettoyer(texte):
    texte = texte.lower()                    # tout en minuscules
    texte = re.sub(r'[^a-záàâéèêëîïôùûç ]', '', texte)  # enlève ponctuation
    return texte

avis_propres = [nettoyer(a) for a in avis]

# ── ÉTAPE 3 : Vectorisation TF-IDF ──

# ── ÉTAPE 4 : Entraîner un pipeline complet ──
X_train, X_test, y_train, y_test = train_test_split(
    avis_propres, labels, test_size=0.25, random_state=42)

pipeline = Pipeline([
    ('tfidf', TfidfVectorizer()),
    ('classifieur', MultinomialNB())
])

pipeline.fit(X_train, y_train)

# ── ÉTAPE 5 : Évaluer et prédire ──
print(classification_report(y_test, pipeline.predict(X_test)))

# Test sur un nouvel avis
nouvel_avis = ['Excellent service, produits frais']
pred = pipeline.predict(nouvel_avis)
print('Sentiment :', 'Positif' if pred[0]==1 else 'Négatif')

Chapitre 34 — Évaluer un modèle : métriques et matrices 📊

« Mon modèle a 90 % de précision » — mais est-ce vraiment bon ? Parfois non ! Comprendre les bonnes métriques est crucial, surtout pour des applications médicales au Bénin.

🔢 Les 4 cas possibles : matrice de confusion

📐 Les métriques dérivées

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# Exemple : IA de dépistage du paludisme au Bénin
# y_reel  = [1,1,0,1,0,0,1,0]   # 1=paludisme, 0=sain
# y_predit = [1,0,0,1,0,1,1,0]

# Précision = VP / (VP + FP)
precision = precision_score(y_reel, y_predit)

# Rappel (Recall / Sensibilité) = VP / (VP + FN)
rappel = recall_score(y_reel, y_predit)

# F1-Score = 2 × (précision × rappel) / (précision + rappel)
f1 = f1_score(y_reel, y_predit)

print(f'Précision : {precision:.2f}  |  Rappel : {rappel:.2f}  |  F1 : {f1:.2f}')

Chapitre 35 — Régularisation : éviter le surapprentissage 🎯

Ton modèle obtient 99 % sur les données d'entraînement mais seulement 60 % sur de nouvelles données ? C'est le surapprentissage (overfitting) — le problème le plus fréquent en IA !

🛠️ Les techniques de régularisation

import tensorflow as tf
from tensorflow.keras import layers, regularizers

# ── Technique 1 : Dropout ──
modele = tf.keras.Sequential([
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.3),    # ← Dropout 30%
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.2),    # ← Dropout 20%
    layers.Dense(1, activation='sigmoid')
])

# ── Technique 2 : L2 Regularization ──
layers.Dense(64, activation='relu',
             kernel_regularizer=regularizers.l2(0.001))

# ── Technique 3 : Early Stopping ──
early_stop = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', patience=5, restore_best_weights=True)

modele.fit(X_train, y_train, epochs=100,
           validation_split=0.2,
           callbacks=[early_stop])

Chapitre 36 — Déployer une IA : API, Flask et mobile 🚀

Un modèle qui reste sur ton ordinateur ne sert à personne. Déployer, c'est le rendre accessible à tous — via une API web, une application mobile ou un SMS. Crucial pour l'Afrique !

🔌 C'est quoi une API ?

Une API (Application Programming Interface) est une porte d'entrée pour communiquer avec ton modèle IA. Tu envoies des données, tu reçois des prédictions — comme envoyer un SMS et recevoir une réponse.

🐍 Créer une API avec Flask

from flask import Flask, request, jsonify
import pickle
import numpy as np

app = Flask(__name__)   # Créer l'application web

# Charger le modèle entraîné
with open('modele_recolte.pkl', 'rb') as f:
    modele = pickle.load(f)

# ── ROUTE PRINCIPALE : Prédire la qualité d'une récolte ──
@app.route('/predire', methods=['POST'])
def predire_recolte():
    # Recevoir les données du paysan (ex: depuis son téléphone)
    data = request.get_json()
    temperature = data['temperature']
    pluie = data['pluie_mm']
    sol = data['type_sol']

    # Faire la prédiction
    entree = np.array([[temperature, pluie, sol]])
    prediction = modele.predict(entree)[0]
    confiance = modele.predict_proba(entree)[0].max()

    # Retourner le résultat en JSON (format standard API)
    resultat = {
        'qualite': 'BONNE' if prediction == 1 else 'MAUVAISE',
        'confiance': f'{confiance*100:.1f}%',
        'conseil': 'Continuez ainsi !' if prediction==1 else 'Irriguez davantage.'
    }
    return jsonify(resultat)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)   # Accessible sur le réseau local

# Test depuis n'importe quel téléphone sur le réseau :
# POST http://192.168.1.10:5000/predire
# Body: {"temperature": 28, "pluie_mm": 120, "type_sol": 1}

Chapitre 37 — IA responsable : gouvernance et droit au Bénin ⚖️

Tu sais maintenant créer des IA puissantes. Mais avec le pouvoir vient la responsabilité. Ce chapitre t'apprend le cadre légal et éthique dans lequel tu devras travailler.

Chapitre 38 — Créer une startup IA au Bénin 💼

Les meilleures IA ne sont pas toujours créées par les grandes entreprises. Des jeunes Béninois de ton âge, quelques années plus tard, ont lancé des startups qui changent l'Afrique. Voici comment faire.

Chapitre 39 — Projet bout-en-bout : IA de détection du paludisme 🦟

Voici le projet le plus ambitieux du cours. Tu vas construire, évaluer et déployer une IA complète pour aider à détecter le paludisme au Bénin — de A à Z.

🗂️ Étape 1 — Exploration des données

import os, numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Structure des dossiers attendue :
# malaria_data/
#   infected/   ← images de cellules infectées
#   uninfected/ ← images de cellules saines

# Compter les images
nb_infecte  = len(os.listdir('malaria_data/infected'))
nb_sain     = len(os.listdir('malaria_data/uninfected'))
print(f'Infectées : {nb_infecte} | Saines : {nb_sain}')

# Vérifier l'équilibre des classes
total = nb_infecte + nb_sain
print(f'Ratio infecté : {nb_infecte/total*100:.1f}%')

🏗️ Étape 2 — Construire et entraîner le CNN

from tensorflow.keras import layers, models
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

datagen_train = ImageDataGenerator(
    rescale=1./255,
    rotation_range=20,
    horizontal_flip=True,
    validation_split=0.2)

train_gen = datagen_train.flow_from_directory(
    'malaria_data', target_size=(64,64),
    batch_size=32, subset='training')

val_gen = datagen_train.flow_from_directory(
    'malaria_data', target_size=(64,64),
    batch_size=32, subset='validation')

modele = models.Sequential([
    layers.Conv2D(32,(3,3),activation='relu',input_shape=(64,64,3)),
    layers.MaxPooling2D(2,2),
    layers.Conv2D(64,(3,3),activation='relu'),
    layers.MaxPooling2D(2,2),
    layers.Conv2D(128,(3,3),activation='relu'),
    layers.MaxPooling2D(2,2),
    layers.Flatten(),
    layers.Dense(256,activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(1,activation='sigmoid')
])

modele.compile(optimizer='adam', loss='binary_crossentropy',
               metrics=['accuracy','Recall','Precision'])

callbacks = [
    EarlyStopping(patience=5, restore_best_weights=True),
    ModelCheckpoint('best_malaria_model.h5', save_best_only=True)
]

historique = modele.fit(train_gen, epochs=30,
                        validation_data=val_gen,
                        callbacks=callbacks)

📊 Étape 3 — Évaluation approfondie

from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns

# Prédictions sur données de test
y_pred_prob = modele.predict(val_gen)
y_pred = (y_pred_prob > 0.5).astype(int).flatten()
y_true = val_gen.classes

# Rapport complet
print(classification_report(y_true, y_pred,
      target_names=['Sain', 'Infecté']))

# Matrice de confusion visuelle
cm = confusion_matrix(y_true, y_pred)
sns.heatmap(cm, annot=True, fmt='d',
            xticklabels=['Sain','Infecté'],
            yticklabels=['Sain','Infecté'])
plt.title('Matrice de confusion — Détection Paludisme Bénin')
plt.savefig('matrice_confusion_paludisme.png')

🚀 Étape 4 — Déploiement WhatsApp Bot

# Stratégie de déploiement pour le Bénin :
# Un paysan ou agent de santé envoie une photo via WhatsApp
# Le bot analyse et répond en français ou en fon

from flask import Flask, request
from twilio.rest import Client   # API WhatsApp
import tensorflow as tf
from PIL import Image
import io, base64, requests

modele = tf.keras.models.load_model('best_malaria_model.h5')

@app.route('/whatsapp', methods=['POST'])
def repondre_whatsapp():
    # Recevoir la photo envoyée via WhatsApp
    image_url = request.form.get('MediaUrl0')
    expediteur = request.form.get('From')

    # Analyser l'image
    img = charger_et_preparer_image(image_url)
    probabilite = modele.predict(img)[0][0]

    if probabilite > 0.5:
        message = f'⚠️ Risque paludisme détecté ({probabilite*100:.0f}%). '
        message += 'Consultez un médecin immédiatement.'
    else:
        message = f'✅ Pas de parasite détecté ({(1-probabilite)*100:.0f}% confiance). '
        message += 'Répétez le test si les symptômes persistent.'

    envoyer_whatsapp(expediteur, message)
    return 'OK', 200

Chapitre 40 — Prépare ta carrière IA 🎓

Tu maîtrises maintenant les fondations solides de l'IA. Voici une feuille de route concrète pour devenir un ingénieur IA béninois de classe mondiale.

📚 Révisions — Niveau 4

Teste tout ce que tu as appris dans ce Niveau 4.

from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/sante', methods=['GET'])
def statut():
    return jsonify({'statut': 'API active', 'version': '1.0'})

✅ Corrigés — Niveau 4