Le « Calendrier de l’Avent » de Machine Learning Jour 23 : CNN dans Excel

ont été introduits pour la première fois pour les images, et pour les images, ils sont souvent faciles à comprendre.

Un filtre glisse sur les pixels et détecte les bords, les formes ou les textures. Vous pouvez lire cet article que j’ai écrit plus tôt pour comprendre comment fonctionnent les CNN pour les images avec Excel.

Pour le texte, l’idée est la même.

Au lieu de pixels, nous glissons des filtres dessus mots.

Au lieu de modèles visuels, nous détectons modèles linguistiques.

Et de nombreux modèles importants dans le texte sont très locaux. Prenons ces exemples très simples :

• « bien » est positif
• « mauvais » est négatif
• « pas bon » est négatif
• « pas mal » est souvent positif

Dans mon article précédent, nous avons vu comment représenter des mots sous forme de nombres à l’aide d’intégrations.

Nous avons également constaté une limite majeure : lorsque nous avons utilisé une moyenne mondiale, l’ordre des mots a été complètement ignoré.

Du point de vue du modèle, « pas bon » et « bon pas » se ressemblent exactement.

Le prochain défi est donc clair : nous voulons que le modèle prenne en compte l’ordre des mots.

Un réseau neuronal convolutif 1D est un outil naturel pour cela, car il scanne une phrase avec de petites fenêtres coulissantes et réagit lorsqu’il reconnaît des modèles locaux familiers.

1. Comprendre un CNN 1D pour le texte : architecture et profondeur

1.1. Construire un CNN 1D pour le texte dans Excel

Dans cet article, nous construisons une architecture CNN 1D dans Excel avec les composants suivants :

• Dictionnaire d’intégration
  Nous utilisons un plongement en 2 dimensions. Parce qu’une seule dimension ne suffit pas pour cette tâche.
  Encodage à une dimension sentimentet la deuxième dimension code négation.
• Couche Conv1D
  Il s’agit du composant central d’une architecture CNN.
  Il se compose de filtres qui glisser sur la phrase avec une longueur de fenêtre de 2 mots. Nous choisissons 2 mots pour être simple.
• ReLU et pooling maximum global
  Ces étapes conservent uniquement les correspondances les plus fortes détectées par les filtres.
  Nous discuterons également du fait que ReLU est facultatif.
• Régression logistique
  Il s’agit de la couche de classification finale, qui combine les modèles détectés en une probabilité.

Ce pipeline correspond à un classificateur de texte CNN standard.
La seule différence ici est que nous écrivons et visualisons explicitement la passe directe dans Excel.

1.2. Ce que signifie le « deep learning » dans cette architecture

Avant d’aller plus loin, prenons un peu de recul.
Oui, je sais, je fais ça souvent, mais avoir une vision globale des modèles aide vraiment à les comprendre.

La définition de apprentissage profond est souvent floue.
Pour de nombreuses personnes, l’apprentissage profond signifie simplement « plusieurs couches ».

Ici, j’adopterai un point de vue légèrement différent.

Ce qui caractérise vraiment le deep learning, ce n’est pas le nombre de couches, mais la profondeur de la transformation appliquée aux données d’entrée.

Avec cette définition :

• Même un modèle avec une seule couche de convolution peut être considéré comme un apprentissage profond,
• car l’entrée est transformée en une représentation plus structurée et abstraite.

D’un autre côté, prendre des données d’entrée brutes, appliquer un codage à chaud et empiler de nombreuses couches entièrement connectées ne rend pas nécessairement un modèle profond dans un sens significatif.
En théorie, si nous n’avons aucune transformation, une seule couche suffit.

Dans les CNN, la présence de plusieurs couches a une motivation très concrète.

Considérons une phrase comme :

Ce film n’est pas très bon

Avec une seule couche de convolution et une petite fenêtre, nous pouvons détecter des modèles locaux simples tels que : « très + bon »

Mais nous ne pouvons pas encore détecter des modèles de niveau supérieur tels que : « pas + (très bien) »

C’est pourquoi les CNN sont souvent empilés :

• la première couche détecte des modèles locaux simples,
• la deuxième couche les combine en couches plus complexes.

Dans cet article, nous nous concentrons délibérément sur une couche de convolution.
Cela rend chaque étape visible et facile à comprendre dans Excel, tout en gardant la logique identique aux architectures CNN plus profondes.

2. Transformer les mots en intégrations

Commençons par quelques mots simples. Nous allons essayer de détecter la négation, nous utiliserons donc ces termes, autrement dit (que nous ne modéliserons pas)

• « bien »
• « mauvais »
• « pas bon »
• « pas mal »

Nous gardons la représentation intentionnellement petite afin que chaque étape soit visible.

Nous n’utiliserons qu’un dictionnaire de trois mots : bon, mauvais et non.

Tous les autres mots auront 0 comme incorporation.

2.1 Pourquoi une seule dimension ne suffit pas

Dans un article précédent sur la détection des sentiments, nous avons utilisé une seule dimension.
Cela a fonctionné pour le « bien » contre le « mauvais ».

Mais maintenant nous voulons gérer négation.

Une dimension ne peut bien représenter qu’un seul concept.
Nous avons donc besoin deux dimensions:

• senti : polarité des sentiments
• neg : marqueur de négation

2.2 Le dictionnaire d’intégration

Chaque mot devient un vecteur 2D :

• bon → (senti = +1, neg = 0)
• mauvais → (senti = -1, neg = 0)
• pas → (senti = 0, neg = +1)
• n’importe quel autre mot → (0, 0)

Ce n’est pas à cela que ressemblent les véritables intégrations. Les intégrations réelles sont apprises, de grande dimension et ne sont pas directement interprétables.

Mais pour comprendre le fonctionnement de Conv1D, cette intégration de jouet est parfaite.

Dans Excel, il s’agit simplement d’une table de recherche.
Dans un véritable réseau de neurones, cette matrice d’intégration serait entraînable.

3. Filtres Conv1D comme détecteurs de modèles glissants

Nous arrivons maintenant à l’idée centrale d’un CNN 1D.

Un filtre Conv1D n’a rien de mystérieux. C’est juste un petit ensemble de poids plus un biais qui glisse sur la phrase.

Parce que:

• chaque intégration de mot a 2 valeurs (senti, neg)
• notre fenêtre contient 2 mots

chaque filtre a :

• 4 poids (2 dimensions × 2 positions)
• 1 biais

C’est tout.

Vous pouvez considérer un filtre comme posant de manière répétée la même question à chaque position :

« Ces deux mots voisins correspondent-ils à un modèle qui m’intéresse ?

3.1 Fenêtres coulissantes : comment Conv1D voit une phrase

Considérez cette phrase :

ce n’est pas mal du tout

Nous choisissons une taille de fenêtre de 2 mots.

Cela signifie que le modèle examine chaque paire adjacente :

• (c’est)
• (est, pas)
• (pas mal)
• (mauvais, à)
• (du tout)

Point important :
Les filtres glissent partoutmême lorsque les deux mots sont neutres (tous des zéros).

3.2 Quatre filtres intuitifs

Pour rendre le comportement facile à comprendre, nous utilisons quatre filtres.

Filtre 1 – « Je vois BIEN »

Ce filtre examine uniquement le sentiment du mot actuel.

Équation en texte brut pour une fenêtre :

z = senti (mot_actuel)

Si le mot est « bon », z = 1
Si le mot est « mauvais », z = -1
Si le mot est neutre, z = 0

Après ReLU, les valeurs négatives deviennent 0. Mais c’est facultatif.

Filtre 2 – « Je vois MAUVAIS »

Celui-ci est symétrique.

z = -senti (mot_actuel)

Donc:

• « mauvais » → z = 1
• « bon » → z = -1 → ReLU → 0

Filtre 3 – « Je ne vois PAS BON »

Ce filtre examine deux choses en même temps :

• négatif (mot_précédent)
• senti(mot_actuel)

Équation:

z = neg (mot_précédent) + senti (mot_actuel) – 1

Pourquoi le « -1 » ?
Cela agit comme un seuil pour que les deux conditions soient vraies.

Résultats:

• « pas bon » → 1 + 1 – 1 = 1 → activé
• « est bon » → 0 + 1 – 1 = 0 → non activé
• « pas mal » → 1 – 1 – 1 = -1 → ReLU → 0

Filtre 4 – « Je vois PAS MAL »

Même idée, signe légèrement différent :

z = neg (mot_précédent) + (-senti (mot_actuel)) – 1

Résultats:

• « pas mal » → 1 + 1 – 1 = 1
• « pas bon » → 1 – 1 – 1 = -1 → 0

C’est une intuition très importante :

Un filtre CNN peut se comporter comme un règle logique localeappris à partir des données.

3.3 Résultat final des fenêtres coulissantes

Voici les résultats finaux de ces 4 filtres.

4. ReLU et max pooling : du local au global

4.1 ReLU

Après avoir calculé z pour chaque fenêtre, nous appliquons ReLU :

ReLU(z) = max(0, z)

Signification:

• les preuves négatives sont ignorées
• les preuves positives sont conservées

Chaque filtre devient un détecteur de présence.

À propos, il s’agit d’une fonction d’activation dans le réseau neuronal. Un réseau de neurones n’est donc pas si difficile après tout.

4.2 Mise en commun Global Max

Puis vient mise en commun maximale globale.

Pour chaque filtre, nous gardons uniquement :

activation maximale sur toutes les fenêtres

Interprétation:
« Peu m’importe où le motif apparaît, seulement s’il apparaît fortement quelque part. »

À ce stade, la phrase entière est résumée par 4 chiffres :

• signal « bon » le plus fort
• le « mauvais » signal le plus fort
• signal « pas bon » le plus fort
• le signal « pas mal » le plus fort

4.3 Que se passe-t-il si nous supprimons ReLU ?

Sans ReLU :

• les valeurs négatives restent négatives
• la mise en commun maximale peut sélectionner des valeurs négatives

Cela mélange deux idées :

• absence de motif
• le contraire d’un motif

Le filtre cesse d’être un détecteur propre et devient une partition signée.

Le modèle pourrait encore fonctionner mathématiquement, mais son interprétation devient plus difficile.

5. La dernière couche est la régression logistique

Maintenant, nous combinons ces signaux.

Nous calculons un score en utilisant une combinaison linéaire :

score = 2 × F_good – 2 × F_bad – 3 × F_not_good – 3 × F_not_bad – biais

Ensuite on convertit le score en probabilité :

probabilité = 1 / (1 + exp(-score))

C’est exactement une régression logistique.

Alors oui :

• le CNN extrait des fonctionnalités : cette étape peut être considérée comme de l’ingénierie de fonctionnalités, non ?
• la régression logistique prend les décisions finales, c’est un modèle d’apprentissage automatique classique que nous connaissons bien

6. Exemples complets avec filtres coulissants

Exemple 1

« c’est mauvais, donc ce n’est pas bon du tout »

La phrase contient :

Après la mise en commun maximale :

• F_good = 1 (car « bon » existe)
• F_mauvais = 1
• F_not_good = 1
• F_not_bad = 0

Le score final devient fortement négatif.
Prédiction : sentiment négatif.

Exemple 2

« C’est bien. Oui, pas mal. »

La phrase contient :

Après la mise en commun maximale :

• F_bon = 1
• F_bad = 1 (car le mot « bad » apparaît)
• F_not_good = 0
• F_not_bad = 1

La couche linéaire finale apprend que « pas mal » doit l’emporter sur « mauvais ».

Prédiction : sentiment positif.

Cela montre également quelque chose d’important : le pooling maximum conserve tous les signaux forts.
La couche finale décide comment les combiner.

Exemple 3 avec une limitation qui explique pourquoi les CNN deviennent plus profonds

Essayez cette phrase :

« ce n’est pas très mal »

Avec une fenêtre de taille 2, le modèle voit :

Il ne voit jamais (pas mal), donc le filtre « pas mal » ne se déclenche jamais.

Cela explique pourquoi les modèles réels utilisent :

• fenêtres plus grandes
• plusieurs couches de convolution
• ou d’autres architectures pour des dépendances plus longues

Conclusion

La force d’Excel est la visibilité.

Vous pouvez voir :

• le dictionnaire d’intégration
• tous les poids et biais de filtre
• chaque fenêtre coulissante
• chaque activation de ReLU
• le résultat de pooling maximum
• les paramètres de régression logistique

La formation est simplement le processus d’ajustement de ces chiffres.

Une fois que vous voyez cela, les CNN cessent d’être mystérieux.

Ils deviennent ce qu’ils sont réellement : des détecteurs de modèles structurés et entraînables qui glissent sur les données.