INTELLIGENCE ARTIFICIELLE
NIVEAU 5 — EXPERT

📋 Sommaire — Niveau 5

Chapitre 41 — GANs : réseaux génératifs adversariaux 🎨

Les GANs (Generative Adversarial Networks) sont l'architecture qui génère des images ultra-réalistes. Ils sont utilisés pour créer des visages, des œuvres d'art, des deepfakes — et potentiellement des images de plantes africaines pour augmenter les datasets.

⚔️ Le principe adversarial

🐍 GAN simple avec Keras

import tensorflow as tf
from tensorflow.keras import layers
import numpy as np

LATENT_DIM = 100   # dimension du bruit d'entrée

# ── GÉNÉRATEUR ──
def build_generator():
    model = tf.keras.Sequential([
        layers.Dense(256, activation='relu', input_dim=LATENT_DIM),
        layers.BatchNormalization(),
        layers.Dense(512, activation='relu'),
        layers.BatchNormalization(),
        layers.Dense(28*28, activation='tanh'),
        layers.Reshape((28, 28, 1))   # image 28x28 pixels
    ])
    return model

# ── DISCRIMINATEUR ──
def build_discriminator():
    model = tf.keras.Sequential([
        layers.Flatten(input_shape=(28,28,1)),
        layers.Dense(512, activation='leaky_relu'),
        layers.Dropout(0.3),
        layers.Dense(256, activation='leaky_relu'),
        layers.Dense(1, activation='sigmoid')  # vrai=1, faux=0
    ])
    model.compile(optimizer='adam', loss='binary_crossentropy',
                  metrics=['accuracy'])
    return model

G = build_generator()
D = build_discriminator()

# ── ENTRAÎNEMENT GAN ──
def entrainer_gan(G, D, n_epochs=50, batch=64):
    for epoch in range(n_epochs):
        # 1. Entraîner D sur de vraies + fausses images
        bruit = np.random.randn(batch, LATENT_DIM)
        fausses = G.predict(bruit, verbose=0)
        vraies  = obtenir_vraies_images(batch)  # ton dataset
        X = np.vstack([vraies, fausses])
        y = np.hstack([np.ones(batch), np.zeros(batch)])
        D.train_on_batch(X, y)

        # 2. Entraîner G : il veut que D dise '1' pour ses fausses images
        bruit = np.random.randn(batch, LATENT_DIM)
        y_tromper = np.ones(batch)   # G veut tromper D
        # (D est figé pendant cette étape)
        loss_G = entrainer_generateur(G, D, bruit, y_tromper)
        if epoch % 10 == 0:
            print(f'Epoch {epoch} | Loss G : {loss_G:.3f}')

Chapitre 42 — MLOps : mettre l'IA en production comme un pro ⚙️

Un modèle IA qui reste dans un notebook Jupyter est inutile. MLOps (Machine Learning Operations) est l'ensemble des pratiques pour déployer, monitorer et maintenir des modèles en production — comme le font Google, Meta et les startups africaines sérieuses.

🐍 Versionner un modèle avec MLflow

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import f1_score

# Démarrer une expérience MLflow
mlflow.set_experiment('detection_paludisme_benin')

with mlflow.start_run(run_name='RF_v1_borgou_data'):
    # Logger les hyperparamètres
    mlflow.log_param('n_estimators', 100)
    mlflow.log_param('max_depth', 10)
    mlflow.log_param('dataset', 'borgou_cliniques_2024')

    # Entraîner
    modele = RandomForestClassifier(n_estimators=100, max_depth=10)
    modele.fit(X_train, y_train)

    # Logger les métriques
    f1 = f1_score(y_test, modele.predict(X_test))
    rappel = recall_score(y_test, modele.predict(X_test))
    mlflow.log_metric('f1_score', f1)
    mlflow.log_metric('rappel', rappel)

    # Sauvegarder le modèle avec sa version
    mlflow.sklearn.log_model(modele, 'modele',
        registered_model_name='PaludismeDetector')

    print(f'F1={f1:.3f} | Rappel={rappel:.3f} | Run loggé !')

🚨 Monitoring : détecter la dérive des données

from scipy.stats import ks_2samp

def detecter_derive(donnees_train, donnees_prod, seuil=0.05):
    """Test KS : vérifie si 2 distributions sont similaires"""
    stat, p_value = ks_2samp(donnees_train, donnees_prod)
    if p_value < seuil:
        print(f'⚠️  DÉRIVE DÉTECTÉE ! p={p_value:.4f} < {seuil}')
        print('   → Déclencher le réentraînement du modèle.')
        return True
    else:
        print(f'✅  Pas de dérive. p={p_value:.4f}')
        return False

import numpy as np
temp_train = np.random.normal(30, 3, 1000)
temp_prod  = np.random.normal(33, 4, 500)
detecter_derive(temp_train, temp_prod)

Chapitre 43 — IA Fédérée : entraîner sans centraliser les données 🔒

Problème majeur en Afrique : les données médicales de 10 hôpitaux béninois ne peuvent pas être partagées pour des raisons de confidentialité. L'IA fédérée résout ce problème.

🐍 Federated Averaging (FedAvg) simplifié

import numpy as np

hopitaux = {
    'CHU Cotonou':    {'n_patients': 500, 'poids': None},
    'Hopital Parakou':{'n_patients': 200, 'poids': None},
    'Clinique Abomey':{'n_patients': 150, 'poids': None},
    'Hopital Lokossa':{'n_patients': 120, 'poids': None},
    'Hopital Kandi':  {'n_patients':  80, 'poids': None},
}
total_patients = sum(h['n_patients'] for h in hopitaux.values())

def entrainement_local(poids_global, donnees_locales):
    bruit_local = np.random.randn(*poids_global.shape) * 0.01
    return poids_global + bruit_local

def federated_averaging(hopitaux, total):
    poids_agreges = np.zeros_like(list(hopitaux.values())[0]['poids'])
    for nom, hop in hopitaux.items():
        contribution = hop['n_patients'] / total
        poids_agreges += contribution * hop['poids']
    return poids_agreges

poids_global = np.random.randn(100)

for round_num in range(1, 6):
    for nom, hop in hopitaux.items():
        hop['poids'] = entrainement_local(poids_global, hop)
    poids_global = federated_averaging(hopitaux, total_patients)
    print(f'Round {round_num} : norme poids = {np.linalg.norm(poids_global):.4f}')

print('Modèle global entraîné sur 1050 patients béninois sans partager 1 dossier !')

Chapitre 44 — Sécurité et attaques adversariales 🛡️

Les modèles IA peuvent être trompés, volés ou sabotés. En tant qu'ingénieur IA au Bénin, tu dois connaître ces attaques pour protéger tes systèmes.

🐍 Générer et détecter un exemple adversarial (FGSM)

import tensorflow as tf
import numpy as np

def attaque_fgsm(modele, image, vraie_classe, epsilon=0.01):
    """Fast Gradient Sign Method — attaque adversariale simple"""
    image_tf = tf.cast(image, tf.float32)

    with tf.GradientTape() as tape:
        tape.watch(image_tf)
        prediction = modele(tf.expand_dims(image_tf, 0))
        perte = tf.keras.losses.sparse_categorical_crossentropy(
            [vraie_classe], prediction)

    gradient = tape.gradient(perte, image_tf)
    perturbation = epsilon * tf.sign(gradient)
    image_adversariale = image_tf + perturbation
    return tf.clip_by_value(image_adversariale, 0, 1)

print('Epsilon 0.01 peut tromper un CNN avec des changements invisibles à l’œil !')

🔐 Sécuriser ton API IA en production

from flask import Flask, request, jsonify, abort
from functools import wraps
import time, hashlib

app = Flask(__name__)
API_KEYS = {'clinic_cotonou': 'hashed_key_1', 'hopital_parakou': 'hashed_key_2'}
RATE_LIMIT = {}

def require_api_key(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        key = request.headers.get('X-API-Key')
        if not key or key not in API_KEYS:
            abort(401, 'Clé API invalide')
        return f(*args, **kwargs)
    return decorated

def rate_limit(max_req=10, window=60):
    def decorator(f):
        @wraps(f)
        def decorated(*args, **kwargs):
            ip = request.remote_addr
            now = time.time()
            RATE_LIMIT.setdefault(ip, [])
            RATE_LIMIT[ip] = [t for t in RATE_LIMIT[ip] if now-t < window]
            if len(RATE_LIMIT[ip]) >= max_req:
                abort(429, 'Trop de requêtes — réessaie dans 1 minute')
            RATE_LIMIT[ip].append(now)
            return f(*args, **kwargs)
        return decorated
    return decorator

@app.route('/predire', methods=['POST'])
@require_api_key
@rate_limit(max_req=10, window=60)
def predire():
    data = request.get_json()
    if not all(k in data for k in ['temperature','pluie','sol']):
        abort(400, 'Données manquantes')
    return jsonify({'resultat': 'OK'})

Chapitre 45 — Lire et comprendre un article de recherche IA 📄

Pour être à la pointe de l'IA, tu dois lire des papers (articles scientifiques). C'est intimidant au début, mais avec une méthode, tu peux en extraire l'essentiel en 30 minutes.

Chapitre 46 — Construire son portfolio GitHub IA 💼

Un portfolio GitHub solide est ton passeport pour les universités, les stages et les emplois IA. Voici comment en construire un qui impressionne dès maintenant.

📁 Structure d'un bon repo IA

mon_projet_ia_benin/
├── README.md
├── requirements.txt
├── data/
│   ├── raw/
│   ├── processed/
│   └── README.md
├── notebooks/
│   ├── 01_exploration.ipynb
│   ├── 02_preprocessing.ipynb
│   └── 03_modelisation.ipynb
├── src/
│   ├── data_prep.py
│   ├── model.py
│   ├── train.py
│   └── evaluate.py
├── api/
│   ├── app.py
│   └── Dockerfile
├── tests/
│   └── test_model.py
└── models/
    └── best_model.h5

📝 Un README.md qui impressionne

# MalariaNet Bénin 🇧🇯🦟

## Présentation
CNN de détection du paludisme entraîné sur des données de 4 hôpitaux béninois.
Déployé via WhatsApp Bot dans 12 districts ruraux.

## Résultats
| Métrique | Notre modèle | Radiologues humains |
|----------|-------------|---------------------|
| Rappel   | 97.1%       | 94.2%               |
| Précision| 96.3%       | 95.8%               |

## Installation
git clone https://github.com/ton_nom/malarianet-benin
pip install -r requirements.txt
python api/app.py

Chapitre 47 — Capstone : Système RAG pour étudiants béninois 📚

Voici le projet le plus avancé du cours. Tu vas construire un système RAG (Retrieval-Augmented Generation) — la technologie derrière les assistants IA qui peuvent lire des documents et répondre sur leur contenu.

🐍 Implémenter un RAG complet

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.llms import Anthropic

loader = PyPDFLoader('manuel_maths_terminale_benin.pdf')
docs   = loader.load()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50)
chunks = splitter.split_documents(docs)

embedding_model = HuggingFaceEmbeddings(
    model_name='sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')

vectorstore = FAISS.from_documents(chunks, embedding_model)
vectorstore.save_local('index_manuels_benin')

retriever = vectorstore.as_retriever(search_kwargs={'k': 4})

llm = Anthropic(model='claude-sonnet-4-20250514')

rag_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever,
    return_source_documents=True)

Chapitre 48 — Vers l'université : préparer ta candidature IA 🎓

Tu as maintenant un niveau pré-universitaire solide en IA. Voici comment transformer ce bagage en une candidature universitaire qui ouvre les meilleures portes.

📚 Révisions — Niveau 5

✅ Corrigés — Niveau 5