Bonjour à tous ! Aujourd'hui, je partage avec vous mes notes personnelles sur les concepts fondamentaux en intelligence artificielle. Que vous soyez débutant ou que vous souhaitiez rafraîchir vos connaissances, ce résumé structuré vous aidera à naviguer dans ce domaine en constante évolution.
La régression linéaire est un modèle supervisé utilisé pour prédire une variable cible continue (comme le prix d'une maison). Son équation fondamentale est :
\[ y = \beta_0 + \beta_1 x + \epsilon \]
Où \(\beta_0\) est l'intercept, \(\beta_1\) est le coefficient de la variable indépendante, et \(\epsilon\) représente l'erreur résiduelle.
Le modèle minimise l'erreur quadratique moyenne (MSE) pour ajuster au mieux la droite aux données :
\[ \text{MSE} = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 \]
Les hypothèses clés à vérifier sont : linéarité entre les variables, indépendance des résidus, et homoscédasticité (variance constante des erreurs).
Très utilisée en économie, finance et pour des prévisions simples, la régression linéaire présente quelques limites : elle est sensible aux outliers et nécessite une vérification rigoureuse des hypothèses via des graphiques de résidus. Pour approfondir, je vous recommande ce guide visuel.
Contrairement à son nom, la régression logistique est un algorithme de classification binaire (par exemple, spam/non-spam). Elle utilise la fonction sigmoïde pour prédire des probabilités comprises entre 0 et 1 :
\[ P(y=1) = \frac{1}{1 + e^{-(\beta_0 + \beta_1 x)}} \]
L'optimisation se fait via la maximisation de la log-vraisemblance (ou minimisation du log loss).
Un seuil classique à 0.5 est utilisé pour la décision finale, mais ce seuil peut être ajusté selon le contexte. À ne pas confondre avec la régression linéaire : ici, la sortie est bornée entre 0 et 1, et on n'utilise pas la MSE comme fonction de perte. Plus de détails ici.
Les arbres de décision sont des algorithmes supervisés utilisés pour la classification et la régression. Leur principe est de découper les données via des seuils sur les caractéristiques, en minimisant l'entropie ou l'indice de Gini à chaque nœud.
L'entropie est définie par :
\[ H(S) = -\sum_{i=1}^{n} p_i \log_2 p_i \]
Leur principal avantage est leur interprétabilité et leur capacité à gérer les non-linéarités sans prétraitement complexe des données. En revanche, ils sont sujets au surajustement.
Le k-means est une méthode non supervisée pour regrouper des données similaires en clusters. L'algorithme fonctionne en 3 étapes principales :
L'inertie totale est donnée par :
\[ \sum_{i=1}^{k} \sum_{x \in C_i} \|x - \mu_i\|^2 \]
Le choix de \(k\) se fait souvent via la méthode du coude. Attention : le k-means est sensible aux outliers. Explication détaillée ici.
Supervisé : Utilise des données étiquetées (\(X \rightarrow y\)). L'objectif est de prédire ou de classer. Exemples : régression linéaire, forêts aléatoires.
Non supervisé : Fonctionne sans étiquettes. L'objectif est de découvrir des structures cachées (clustering, réduction de dimension). Exemples : k-means, PCA.
Plus d'informations ici et ici.
Les réseaux de neurones sont des modèles inspirés du cerveau humain, composés de couches de neurones interconnectés. Chaque neurone calcule une combinaison linéaire de ses entrées : \( z = Wx + b \), puis applique une fonction d'activation non linéaire comme ReLU (\( \max(0, z) \)) ou sigmoïde.
Le processus de propagation vers l'avant (forward pass) permet de générer une prédiction à partir des données d'entrée. Grâce à leurs couches cachées, ces réseaux peuvent modéliser des relations complexes entre les variables d'entrée et de sortie.
Ils sont utilisés dans de nombreuses applications, de la classification d'images à la génération de texte. Leur capacité à apprendre des représentations hiérarchiques à partir des données en fait un pilier du deep learning moderne.
La rétropropagation est l'algorithme fondamental qui permet aux réseaux de neurones d'apprendre. Elle calcule le gradient de la fonction de perte par rapport à chaque poids du réseau, en utilisant la règle de la chaîne du calcul différentiel.
Le processus se déroule en deux étapes : un forward pass pour calculer la prédiction et la perte, puis un backward pass pour propager l'erreur depuis la sortie jusqu'aux premières couches.
En fournissant une méthode efficace pour attribuer la responsabilité de l'erreur à chaque paramètre, la rétropropagation rend possible l'entraînement de réseaux profonds avec des millions de paramètres, en seulement deux passes.
La rétropropagation calcule les gradients de la fonction de perte par rapport aux poids via la règle de la chaîne :
\[ \frac{\partial \mathcal{L}}{\partial W} = \frac{\partial \mathcal{L}}{\partial z} \cdot \frac{\partial z}{\partial W} \]
Les optimiseurs mettent à jour les poids d'un réseau de neurones en utilisant les gradients calculés par la rétropropagation. L'optimiseur de base est le SGD (Stochastic Gradient Descent) : \( \theta_{t+1} = \theta_t - \eta \nabla_\theta \mathcal{L} \).
Des variantes comme Momentum ajoutent une inertie pour accélérer la convergence, tandis que RMSProp adapte le taux d'apprentissage dynamiquement. Adam combine ces deux approches et est devenu le choix par défaut dans de nombreuses applications.
Ces algorithmes permettent d'optimiser efficacement les modèles, en évitant les minima locaux et en stabilisant la descente de gradient, ce qui est crucial pour l'entraînement de modèles complexes.
SGD : \(\theta_{t+1} = \theta_t - \eta \nabla_\theta \mathcal{L}\)
Adam :
\[ m_t = \beta_1 m_{t-1} + (1-\beta_1) \nabla_\theta \mathcal{L} \]
\[ v_t = \beta_2 v_{t-1} + (1-\beta_2) (\nabla_\theta \mathcal{L})^2 \]
\[ \theta_{t+1} = \theta_t - \eta \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} \]
Les RNN (réseaux récurrents) traitent les séquences en utilisant une mémoire implicite : \( h_t = \tanh(W_h h_{t-1} + W_x x_t + b) \). Leur état caché \( h_t \) capture l'information du passé.
Leur principal problème est le vanishing gradient, qui empêche le modèle de mémoriser des informations à long terme, rendant difficile l'apprentissage de dépendances distantes.
Bien qu'efficaces pour des séquences courtes, cette limitation a conduit au développement de modèles plus avancés comme les LSTM et les Transformers.
Les LSTM (Long Short-Term Memory) résolvent le vanishing gradient grâce à un mécanisme de portes (gates) et un état cellulaire \( c_t \) qui permet de conserver l'information sur de longues périodes.
Les équations clés sont : \( c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t \) et \( h_t = o_t \odot \tanh(c_t) \), où \( f_t, i_t, o_t \) sont les portes d'oubli, d'entrée et de sortie.
Les GRU sont une version simplifiée avec moins de paramètres mais des performances similaires, utilisant des portes de reset et d'update. Ces modèles ont été largement utilisés avant l'ère des Transformers.
Explication détaillée des LSTM ici et des GRU ici.
Les modèles Seq2Seq utilisent un encodeur (RNN/LSTM) pour compresser l'entrée en un vecteur contexte fixe, puis un décodeur pour générer la sortie séquentielle.
Le problème majeur est la perte d'information dans le vecteur contexte unique, qui devient critique pour les longues séquences.
Le mécanisme d'attention résout ce problème en permettant au décodeur de se "concentrer" sur différentes parties de l'entrée à chaque pas de temps, en calculant un contexte dynamique : \( \text{context}_t = \sum \alpha_{tj} h_j \).
Mécanisme d'attention :
\[ \text{context}_t = \sum_{j=1}^{T} \alpha_{tj} h_j \]
\[ \alpha_{tj} = \frac{\exp(\text{score}(s_{t-1}, h_j))}{\sum_{k=1}^{T} \exp(\text{score}(s_{t-1}, h_k))} \]
Les Transformers remplacent les RNN par le mécanisme d'auto-attention, qui permet de traiter toute la séquence en parallèle : \( \text{Attention}(Q,K,V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V \).
Le multi-head attention permet de capturer différents types de relations contextuelles en projetant \( Q, K, V \) dans plusieurs sous-espaces. Le positional encoding ajoute l'information de position.
Cette architecture a révolutionné le NLP. BERT (encodeur seul) est optimisé pour la compréhension, tandis que GPT (décodeur seul) l'est pour la génération de texte.
Visualisation interactive ici et explication détaillée ici.
La quantification réduit la précision des poids (FP32 → INT8/FP16), ce qui permet d'accélérer l'inférence et de réduire la mémoire nécessaire.
L'avantage principal est une inférence 2-4x plus rapide avec moins de mémoire requise, ce qui est essentiel pour le déploiement sur des appareils mobiles ou embarqués.
La distillation entraîne un student (petit modèle) pour imiter un teacher (grand modèle). La perte combinée s'exprime comme :
\[ \mathcal{L} = \alpha \mathcal{L}_{task} + (1-\alpha) \mathcal{L}_{KL}(p_{teacher}, p_{student}) \]
Où \(\mathcal{L}_{KL}\) est la perte de Kullback-Leibler mesurant la divergence entre les distributions de probabilités du modèle teacher et student :
\[ \mathcal{L}_{KL}(P||Q) = \sum_{i} P(i) \log \frac{P(i)}{Q(i)} \]
Un exemple célèbre est DistilBERT, qui conserve 60 % des paramètres de BERT mais atteint 95 % de ses performances. Cette technique permet de créer des modèles plus légers tout en préservant une grande partie de la qualité.
Le fine-tuning est une technique essentielle pour adapter les modèles pré-entraînés à des tâches spécifiques :
Le critère de succès est l'adaptation rapide avec peu de données (ex. 1k exemples vs 300M pour le pré-entraînement). Cette approche exploite le savoir acquis lors du pré-entraînement tout en s'adaptant à la tâche spécifique.
Les réseaux de neurones convolutifs (CNNs) sont la base des modèles de vision par ordinateur modernes. Leurs couches clés sont :
Le transfer learning consiste à utiliser des poids pré-entraînés (ex. sur ImageNet) et à adapter uniquement la tête de classification. Cela réduit considérablement le besoin de données et de calcul, rendant les CNNs accessibles même avec des ressources limitées. Guide interactif ici.
Les GANs opposent deux réseaux : un générateur \( G \) qui crée des données fausses à partir d'un bruit, et un discriminateur \( D \) qui tente de distinguer les vraies des fausses.
La fonction de perte minimax est : \( \min_G \max_D \mathbb{E}[\log D(x)] + \mathbb{E}[\log(1-D(G(z)))] \). Les deux réseaux s'améliorent en compétition.
Les GANs sont puissants pour générer des images réalistes, mais souffrent d'instabilité d'entraînement et de mode collapse. Des variantes comme WGAN ont été créées pour résoudre ces problèmes.
Les principaux problèmes des GANs sont le mode collapse (diversité faible) et l'instabilité d'entraînement. Plusieurs variantes ont été développées pour résoudre ces problèmes :
Visualisation interactive ici.
Les VAEs sont des auto-encodeurs probabilistes. L'encodeur apprend une distribution gaussienne \( q_\phi(z|x) \) dans l'espace latent, et le reparametrization trick permet de l'échantillonner.
La fonction de perte combine la reconstruction (\( \mathbb{E}[\log p_\theta(x|z)] \)) et la régularisation KL (\( \text{KL}(q_\phi(z|x) \| p(z)) \)) pour que l'espace latent suive une distribution simple (ex. N(0,I)).
Les VAEs sont plus stables que les GANs et permettent l'interpolation dans l'espace latent, mais génèrent souvent des images plus floues.
La segmentation d'images consiste à attribuer une étiquette à chaque pixel :
Les modèles de diffusion génèrent des données en inversant un processus de bruitage progressif. Le forward process ajoute du bruit sur \( T \) étapes : \( x_t = \sqrt{\alpha_t} x_{t-1} + \sqrt{1-\alpha_t} \epsilon \).
Le reverse process entraîne un modèle \( \epsilon_\theta \) à prédire le bruit ajouté à chaque étape, permettant de reconstruire \( x_0 \) à partir de \( x_T \) (bruit pur).
Leur principal avantage est une qualité supérieure aux GANs avec une stabilité d'entraînement accrue, comme le montre Stable Diffusion. La fonction de perte est \( \mathbb{E}[\| \epsilon - \epsilon_\theta(x_t, t) \|^2] \).
\[ q(x_t | x_{t-1}) = \mathcal{N}(x_t; \sqrt{\alpha_t} x_{t-1}, (1-\alpha_t)I) \]
\[ \mathcal{L} = \mathbb{E}_{t,x_0,\epsilon} \left[ \| \epsilon - \epsilon_\theta(x_t, t) \|^2 \right] \]
Le flow matching est une alternative prometteuse aux modèles de diffusion pour une génération plus efficace :
\[ \frac{dx}{dt} = v_t(x) \]
\[ \mathbb{E} \left[ \| v_t(x) - v^*_t(x) \|^2 \right] \]
Des applications notables incluent Rectified Flow (convergence en 1-2 étapes) et son intégration dans des systèmes comme Stable Diffusion. Plus d'informations ici.
Le RLHF (Reinforcement Learning from Human Feedback) aligne les grands modèles de langage avec les préférences humaines en trois étapes : fine-tuning supervisé, entraînement d'un modèle de récompense, et fine-tuning par RL.
Le modèle de récompense est entraîné sur des paires de réponses classées par des humains. PPO est utilisé pour maximiser la récompense tout en évitant les dérives avec une pénalité KL.
DPO (Direct Preference Optimization) est une alternative plus simple qui optimise directement les préférences sans modèle de récompense ni PPO, en reformulant l'objectif.
\[ \mathcal{L} = -\log \sigma(r_\theta(y_w) - r_\theta(y_l)) \]
\[ \mathbb{E} \left[ r_\theta(y) - \beta \cdot \text{KL}(\pi_\theta \| \pi_{\text{SFT}}) \right] \]
avec pénalité KL pour éviter les dérivesLa variante DPO (Direct Preference Optimization) optimise directement les préférences sans modèle de récompense via
\[ \mathcal{L}_{\text{DPO}} = -\log \sigma\left(\beta \log \frac{\pi_\theta(y_w)}{\pi_{\text{ref}}(y_w)} - \beta \log \frac{\pi_\theta(y_l)}{\pi_{\text{ref}}(y_l)}\right) \]
Son avantage principal est d'éviter PPO (coûteux) et le modèle de récompense. Explication complète ici.Pour les applications de jeu, plusieurs algorithmes de base sont essentiels :
Le Q-learning est un algorithme hors politique qui apprend une fonction \( Q(s,a) \) représentant la valeur d'une action dans un état :
\[ Q(s,a) \leftarrow Q(s,a) + \alpha \left[ r + \gamma \max_{a'} Q(s',a') - Q(s,a) \right] \]
Converge vers \(Q^*\) si le taux d'apprentissage décroît.SARSA est une variante en politique qui met à jour \( Q(s,a) \) en utilisant l'action \( a' \) choisie par la politique courante, ce qui la rend plus prudente mais potentiellement moins optimiste.
\[ Q(s,a) \leftarrow Q(s,a) + \alpha \left[ r + \gamma Q(s',a') - Q(s,a) \right] \]
où \(a'\) suit la politique courante (ex. ε-greedy). Plus prudent que Q-learning car il gère l'exploration dans la mise à jour.Pour l'exploration, on utilise souvent :
\[ a_t = \arg\max_a \left[ Q(a) + c \sqrt{\frac{\ln t}{N(a)}} \right] \]
Un MDP (Markov Decision Process) est défini par \( (S, A, P, R, \gamma) \). L'objectif est de trouver une politique \( \pi \) qui maximise l'espérance des récompenses cumulées.
La programmation dynamique (policy/value iteration) résout exactement un MDP de petite taille. Le Monte Carlo estime la valeur par la moyenne des retours.
Le TD Learning (ex. TD(0)) combine les idées de Monte Carlo et de programmation dynamique, en utilisant des estimations bootstrap. TD(λ) pondère les retours à n pas.
Reinforcement Learning: An Introduction.
Ma recommandation musicale du jour : à écouter sans modération !
Écouter sur YouTube