Feuille recto-verso

CM2Idée & architecture CNN

Deep Learning = RN avec beaucoup de couches → abstraction progressive (pixels → contours → objets).

CNN exploite la structure spatiale via connexion locale + partage de poids (1 filtre réutilisé partout).

Pipeline :

Input → Conv → Pool → Dropout → Flatten → Dense → Softmax

Profondeur ↗ · taille spatiale ↘ · abstraction ↗.

Ex : 28×28×1 → 26×26×32 → 13×13×32 → 11×11×64 → 5×5×64.

CM2Convolution

Filtre $W$ ($m \times m$) glisse sur image $T$ ($n \times n$, avec $m \le n$).

• valid ($p=0, s=1$) : $n - m + 1$
• same ($s=1, p=(n-1)/2$) : $m$ exact
• $s=2$ : env. $m/2$

Ex : Conv2D(32, 3×3) sur 28×28×1 → sortie 26×26×32, $32 \times (9 + 1) = 320$ params.

CM2Pooling, Dropout, Flatten

MaxPooling 2×2 : garde le max de chaque carré 2×2. Divise dims spatiales par 2. 0 param.

Dropout($p$) : met $p\times 100\%$ des neurones à 0 pendant l'apprentissage. Évite l'overfit. 0 param.

Flatten : tableau → vecteur (ex. 13×13×32 = 5408). 0 param.

ReLU : $\max(0, x)$ — apprentissage rapide, pas de vanishing.

Softmax : $\hat y_j = e^{z_j} / \sum_i e^{z_i}$ → probas (couche de sortie multi-classe).

CM2Dense, perte, entraînement

Ex : Dense(10) après Flatten 5408 → $10 \times 5409 = 54\,090$.

• Epoch = 1 passage complet sur le dataset
• Batch size = nb d'exemples avant 1 MAJ poids
• Optimiseur : adam (par défaut)
• Accuracy = bonnes / total · Précision X = VP / (VP+FP)

CM2Keras pattern (Fashion MNIST)

model = Sequential()
model.add(Conv2D(32, (3,3), activation='relu',
                 input_shape=(28,28,1)))
model.add(MaxPooling2D((2,2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

model.compile(
  loss='categorical_crossentropy',
  optimizer='adam',
  metrics=['accuracy'])

model.fit(X, Y, batch_size=128, epochs=10,
          validation_data=(Xv, Yv))

Params ? Oui : Conv2D, Dense, LSTM, Embedding. Non (0) : MaxPooling, Dropout, Flatten.

CM3RNN — pourquoi & quoi

Pour séquences (phrase, texte, vidéo) où l'ordre compte. Un RN classique perd la mémoire du passé.

RNN = RN avec une boucle : l'info à $t-1$ est réinjectée à $t$.

Hyperparamètres ($n, m, p, T$) : taille entrée, cachée, sortie, longueur séquence.

Paramètres (appris) :

• $U$ ($m \times n$) : entrée $X^t$ → caché $H^t$
• $V$ ($m \times m$) : ancien $H^{t-1}$ → $H^t$
• $W$ ($p \times m$) : $H^t$ → sortie $Y^t$
• $B^h$ ($m \times 1$), $B^o$ ($p \times 1$)

CM3Équations RNN

Softmax : $0 \le Y_i \le 1$, $\sum_i Y_i = 1$ → proba par mot du vocabulaire.

Erreur totale : $E = \sum_t E^t$ (somme sur le temps).

BPTT = Backpropagation Through Time : on déroule le RNN, on applique la rétroprop classique. Mêmes paramètres $U, V, W$ réutilisés à chaque étape (gradients accumulés).

CM3Types séquentiels

Évolution : DL → RNN → LSTM → Encodeur-Décodeur → Attention → Transformers.

CM3LSTM — 3 portes

Corrige mémoire courte du RNN (vanishing gradients). Mémoire interne $c_t$ + portes sigmoïdes $\in [0, 1]$ (0 = bloque, 1 = laisse passer).

Portes : $g_t = \sigma(W_{xg} X_t + W_{hg} h_{t-1} + B_g)$ pour $g \in \{i, f, o\}$.

CM3Encodeur-Décodeur & Attention

Encodeur-Décodeur : séquence-à-séquence (traduction).

Seq1 → [Encodeur] → vecteur contexte
     → [Décodeur] → Seq2

Décodeur s'arrête sur <end>. Problème : tout le sens dans 1 seul vecteur → insuffisant pour phrases longues.

Attention : donne des poids différents aux éléments d'entrée selon l'élément produit en sortie. Le réseau apprend où regarder.

model = Sequential()
model.add(Embedding(vocab, 128))
model.add(LSTM(64, return_sequences=False))
model.add(Dense(1, activation='sigmoid'))

CM4Cadre RL

RL : agent apprend par essai-erreur en interagissant avec un environnement. But : maximiser le cumul des récompenses LT.

Agent → action A → Env
Env → état S', récompense R → Agent

5 éléments : Agent · Env · État $S$ · Action $A$ · Récompense $R$.

Stratégie / Policy :

• Déterministe : $\pi : S \to A$
• Probabiliste : distribution sur $A$

CM4Markov & MDP

Chaîne de Markov : matrice de transition $P_{ij}$, somme par ligne $= 1$.

MDP $(S, A, T, R, \gamma)$ :

• $S$ : états · $A$ : actions
• $T(s, a, s')$ : proba transition
• $R(s, a)$ : récompense
• $\gamma \in [0, 1]$ : facteur d'actualisation

$\gamma \to 0$ : court terme · $\gamma \to 1$ : long terme.

CM4Valeurs & Bellman

3 modèles d'optimalité :

1. MHF (horizon fini) : $G = \sum_{t=0}^h r_t$
2. MHI (horizon infini) : $G = \sum_t \gamma^t r_t$
3. Récompense moyenne : $\lim \frac{1}{h}\sum r_t$

CM4Value & Policy Iteration

Value Iteration (cherche $V^*$, puis déduit $\pi^*$) :

Init V(s) ← 0
Répéter jusqu'à stabilité :
  Pour chaque s :
    Pour chaque a :
      Q(s,a) ← R(s,a) + γ Σ T·V(s')
    V(s) ← max_a Q(s,a)
π*(s) = argmax_a Q(s,a)

Policy Iteration (manipule directement $\pi$) :

1. Choisir $\pi$ initiale
2. Évaluer : calculer $V^\pi$
3. Améliorer : meilleures actions
4. Répéter jusqu'à $\pi$ stable

CM4Q-Learning (model-free)

Ne suppose pas $T, R$ connus. Apprend par interaction.

$Q(s, a)$ = qualité de faire $a$ dans $s$ puis comportement optimal ensuite.

• $\alpha$ : learning rate (mémoire)
• $\gamma$ : actualisation
• $r$ : récompense reçue

Une fois $Q^*$ apprise :

Convergence = quand $Q$ se stabilise.

CM4ε-greedy : explore vs exploit

• Avec proba $\varepsilon$ : action aléatoire (exploration)
• Sinon : argmax $Q$ (exploitation)

$\varepsilon = 0$ : pure exploit (risque de stratégie sous-optimale).

$\varepsilon = 1$ : pure explore aléatoire.

Bonne pratique : $\varepsilon$ décroît avec le temps.

Pièges : $V(s)$ vs $Q(s,a)$ ; MDP peut être stochastique ; déterministe ≠ obligatoire.

CM5NLP — vue d'ensemble

NLP = Natural Language Processing, branche IA. Communiquer en langue naturelle.

3 approches : Symbolique (règles) · Statistique (corpus) · Connexionniste (LSTM, ConvNet).

7 niveaux d'analyse :

1. Phonologie (sons)
2. Morphologie (forme des mots)
3. Lexical (rôle, sens)
4. Syntaxique (structure phrase)
5. Sémantique (sens)
6. Discours (texte global)
7. Pragmatique (connaissance monde)

NLP traite surtout lexical · syntaxique · sémantique.

CM5Analyse lexicale

Tokenization : découpe en tokens (mots, ponctuation, nombres). Lexique = base des mots autorisés.

9 POS : Adjective, Adverb, Conjunction, Determiner, Noun, Preposition, Pronoun, Proper noun, Verb. Ponctuation = pas de POS.

Mots ambigus → POS le plus probable selon contexte.

CM5Analyse syntaxique & CFG

Grammaire formelle = $(\Sigma, N, S, \text{règles})$ :

• $\Sigma$ : terminaux (mots, ponctuation)
• $N$ : non-terminaux (S, NP, VP…)
• $S$ : symbole de départ
• Règles : LHS → RHS

Hiérarchie de Chomsky = 4 classes selon forme des règles. Langues naturelles ⇒ au moins hors contexte.

CFG (Context-Free Grammar) : un seul non-terminal à gauche.

S  → NP VP | S Conj S
NP → Det Nn | PN | NP Conj NP
VP → V NP | V Prep NP | V Conj VP
Det → the | a
Nn → cat | dog | fish
V  → swam | barked | slept

Arbre d'analyse : racine S, feuilles = terminaux. Équivalent en bracketed string.

CM5Analyse sémantique & ambiguïté

Sémantique lexicale (mots) vs supralexicale (combinaisons).

3 types d'ambiguïté :

1. Lexicale : 1 mot, plusieurs sens (« married »)
2. Syntaxique : plusieurs arbres (« Police help dog bite victim »)
3. Référentielle : pronom ambigu

Relations lexicales :

• Horizontales : synonymie, antonymie, conversité (teach/learn), homonymie, polysémie
• Verticales : hyponymie/hypernymie (rose/flower), co-hyponymes (cat, dog), méronymie part-of (wheel/car)

Wordnet (NLTK) : synsets + relations.

CM5Compositionnalité & logique

Principe : sens combinaison = sens parties + manière combinées.

Logique du 1er ordre :

Modus ponens :

P : sick(Pierre)
P ⇒ Q : sick(x) ⇒ stays_home(x)
─────────────────────────────────
Q : stays_home(Pierre)

CM5NLTK — pipeline TD

import nltk
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer

tokens = word_tokenize(text)
tokens = [t.lower() for t in tokens
          if t.isalpha()]
tagged = nltk.pos_tag(tokens)
lem = WordNetLemmatizer()
lemmas = [lem.lemmatize(w, pos)
          for w, pos in tagged]

Sentiment — Naive Bayes :

from nltk.corpus import twitter_samples
from nltk import NaiveBayesClassifier

feats = lambda toks: {t: True for t in toks}
data = [(feats(clean(t)), 'pos') for t in pos]\
     + [(feats(clean(t)), 'neg') for t in neg]
clf = NaiveBayesClassifier.train(train)
classify.accuracy(clf, test)

Outils : word_tokenize, pos_tag, WordNetLemmatizer, NaiveBayesClassifier, twitter_samples.