Enseignement supervisé

Comme le nom le suggère, supervised learningse déroule sous la supervision d'un enseignant. Ce processus d'apprentissage est dépendant. Lors de l'apprentissage de l'ANN sous apprentissage supervisé, le vecteur d'entrée est présenté au réseau, qui produira un vecteur de sortie. Ce vecteur de sortie est comparé au vecteur de sortie souhaité / cible. Un signal d'erreur est généré en cas de différence entre la sortie réelle et le vecteur de sortie souhaité / cible. Sur la base de ce signal d'erreur, les poids seraient ajustés jusqu'à ce que la sortie réelle corresponde à la sortie souhaitée.

Perceptron

Développé par Frank Rosenblatt en utilisant le modèle McCulloch et Pitts, le perceptron est l'unité opérationnelle de base des réseaux de neurones artificiels. Il utilise une règle d'apprentissage supervisé et est capable de classer les données en deux classes.

Caractéristiques opérationnelles du perceptron: Il se compose d'un seul neurone avec un nombre arbitraire d'entrées ainsi que des poids ajustables, mais la sortie du neurone est de 1 ou 0 selon le seuil. Il consiste également en un biais dont le poids est toujours 1. La figure suivante donne une représentation schématique du perceptron.

Perceptron a donc les trois éléments de base suivants -

  • Links - Il aurait un ensemble de liaisons de connexion, qui porte un poids comprenant un biais ayant toujours un poids 1.

  • Adder - Il ajoute l'entrée après avoir été multipliée par leurs poids respectifs.

  • Activation function- Il limite la sortie du neurone. La fonction d'activation la plus basique est une fonction d'étape Heaviside qui a deux sorties possibles. Cette fonction renvoie 1, si l'entrée est positive, et 0 pour toute entrée négative.

Algorithme de formation

Le réseau Perceptron peut être formé pour une seule unité de sortie ainsi que pour plusieurs unités de sortie.

Algorithme de formation pour une unité de sortie unique

Step 1 - Initialisez les éléments suivants pour démarrer la formation -

  • Weights
  • Bias
  • Taux d'apprentissage $ \ alpha $

Pour faciliter le calcul et la simplicité, les pondérations et les biais doivent être définis sur 0 et le taux d'apprentissage doit être défini sur 1.

Step 2 - Continuez l'étape 3-8 lorsque la condition d'arrêt n'est pas vraie.

Step 3 - Continuez l'étape 4-6 pour chaque vecteur d'entraînement x.

Step 4 - Activez chaque unité d'entrée comme suit -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: à \: n) $$

Step 5 - Obtenez maintenant l'entrée nette avec la relation suivante -

$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ limits_ {i} ^ n x_ {i}. \: w_ {i} $$

Ici ‘b’ est un parti pris et ‘n’ est le nombre total de neurones d'entrée.

Step 6 - Appliquez la fonction d'activation suivante pour obtenir la sortie finale.

$$ f (y_ {in}) \: = \: \ begin {cases} 1 & if \: y_ {in} \:> \: \ theta \\ 0 & if \: - \ theta \: \ leqslant \ : y_ {dans} \: \ leqslant \: \ theta \\ - 1 & if \: y_ {in} \: <\: - \ theta \ end {cases} $$

Step 7 - Ajustez le poids et le biais comme suit -

Case 1 - si y ≠ t puis,

$$ w_ {i} (nouveau) \: = \: w_ {i} (ancien) \: + \: \ alpha \: tx_ {i} $$

$$ b (nouveau) \: = \: b (ancien) \: + \: \ alpha t $$

Case 2 - si y = t puis,

$$ w_ {i} (nouveau) \: = \: w_ {i} (ancien) $$

$$ b (nouveau) \: = \: b (ancien) $$

Ici ‘y’ est la sortie réelle et ‘t’ est la sortie souhaitée / cible.

Step 8 - Testez la condition d'arrêt, qui se produirait lorsqu'il n'y a pas de changement de poids.

Algorithme de formation pour plusieurs unités de sortie

Le diagramme suivant est l'architecture de perceptron pour plusieurs classes de sortie.

Step 1 - Initialisez les éléments suivants pour démarrer la formation -

  • Weights
  • Bias
  • Taux d'apprentissage $ \ alpha $

Pour faciliter le calcul et la simplicité, les pondérations et les biais doivent être définis sur 0 et le taux d'apprentissage doit être défini sur 1.

Step 2 - Continuez l'étape 3-8 lorsque la condition d'arrêt n'est pas vraie.

Step 3 - Continuez l'étape 4-6 pour chaque vecteur d'entraînement x.

Step 4 - Activez chaque unité d'entrée comme suit -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: à \: n) $$

Step 5 - Obtenez l'entrée nette avec la relation suivante -

$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ limits_ {i} ^ n x_ {i} \: w_ {ij} $$

Ici ‘b’ est un parti pris et ‘n’ est le nombre total de neurones d'entrée.

Step 6 - Appliquer la fonction d'activation suivante pour obtenir la sortie finale pour chaque unité de sortie j = 1 to m -

$$ f (y_ {in}) \: = \: \ begin {cases} 1 & if \: y_ {inj} \:> \: \ theta \\ 0 & if \: - \ theta \: \ leqslant \ : y_ {inj} \: \ leqslant \: \ theta \\ - 1 & if \: y_ {inj} \: <\: - \ theta \ end {cas} $$

Step 7 - Ajustez le poids et le biais pour x = 1 to n et j = 1 to m comme suit -

Case 1 - si yj ≠ tj puis,

$$ w_ {ij} (nouveau) \: = \: w_ {ij} (ancien) \: + \: \ alpha \: t_ {j} x_ {i} $$

$$ b_ {j} (nouveau) \: = \: b_ {j} (ancien) \: + \: \ alpha t_ {j} $$

Case 2 - si yj = tj puis,

$$ w_ {ij} (nouveau) \: = \: w_ {ij} (ancien) $$

$$ b_ {j} (nouveau) \: = \: b_ {j} (ancien) $$

Ici ‘y’ est la sortie réelle et ‘t’ est la sortie souhaitée / cible.

Step 8 - Testez la condition d'arrêt, qui se produit lorsqu'il n'y a pas de changement de poids.

Neurone linéaire adaptatif (Adaline)

Adaline, qui signifie Adaptive Linear Neuron, est un réseau ayant une seule unité linéaire. Il a été développé par Widrow et Hoff en 1960. Quelques points importants sur Adaline sont les suivants -

  • Il utilise la fonction d'activation bipolaire.

  • Il utilise la règle delta pour l'entraînement afin de minimiser l'erreur quadratique moyenne (MSE) entre la sortie réelle et la sortie souhaitée / cible.

  • Les poids et le biais sont réglables.

Architecture

La structure de base d'Adaline est similaire au perceptron ayant une boucle de rétroaction supplémentaire à l'aide de laquelle la sortie réelle est comparée à la sortie souhaitée / cible. Après comparaison sur la base de l'algorithme d'entraînement, les poids et biais seront mis à jour.

Algorithme de formation

Step 1 - Initialisez les éléments suivants pour démarrer la formation -

  • Weights
  • Bias
  • Taux d'apprentissage $ \ alpha $

Pour faciliter le calcul et la simplicité, les pondérations et les biais doivent être définis sur 0 et le taux d'apprentissage doit être défini sur 1.

Step 2 - Continuez l'étape 3-8 lorsque la condition d'arrêt n'est pas vraie.

Step 3 - Continuez l'étape 4-6 pour chaque paire d'entraînement bipolaire s:t.

Step 4 - Activez chaque unité d'entrée comme suit -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: à \: n) $$

Step 5 - Obtenez l'entrée nette avec la relation suivante -

$$ y_ {in} \: = \: b \: + \: \ displaystyle \ sum \ limits_ {i} ^ n x_ {i} \: w_ {i} $$

Ici ‘b’ est un parti pris et ‘n’ est le nombre total de neurones d'entrée.

Step 6 - Appliquer la fonction d'activation suivante pour obtenir la sortie finale -

$$ f (y_ {in}) \: = \: \ begin {cases} 1 & if \: y_ {in} \: \ geqslant \: 0 \\ - 1 & if \: y_ {in} \: < \: 0 \ end {cases} $$

Step 7 - Ajustez le poids et le biais comme suit -

Case 1 - si y ≠ t puis,

$$ w_ {i} (nouveau) \: = \: w_ {i} (ancien) \: + \: \ alpha (t \: - \: y_ {in}) x_ {i} $$

$$ b (nouveau) \: = \: b (ancien) \: + \: \ alpha (t \: - \: y_ {in}) $$

Case 2 - si y = t puis,

$$ w_ {i} (nouveau) \: = \: w_ {i} (ancien) $$

$$ b (nouveau) \: = \: b (ancien) $$

Ici ‘y’ est la sortie réelle et ‘t’ est la sortie souhaitée / cible.

$ (t \: - \; y_ {in}) $ est l'erreur calculée.

Step 8 - Testez la condition d'arrêt, qui se produira lorsqu'il n'y a pas de changement de poids ou que le changement de poids le plus élevé survenu pendant l'entraînement est inférieur à la tolérance spécifiée.

Neurone linéaire adaptatif multiple (Madaline)

Madaline, qui signifie Multiple Adaptive Linear Neuron, est un réseau qui se compose de nombreux Adalines en parallèle. Il aura une seule unité de sortie. Voici quelques points importants sur Madaline:

  • C'est comme un perceptron multicouche, où Adaline agira comme une unité cachée entre l'entrée et la couche Madaline.

  • Les poids et le biais entre les couches d'entrée et Adaline, comme on le voit dans l'architecture Adaline, sont ajustables.

  • Les couches Adaline et Madaline ont des pondérations et un biais fixes de 1.

  • La formation peut être effectuée à l'aide de la règle Delta.

Architecture

L'architecture de Madaline se compose de “n” les neurones de la couche d'entrée, “m”neurones de la couche Adaline et 1 neurone de la couche Madaline. La couche Adaline peut être considérée comme la couche cachée car elle se trouve entre la couche d'entrée et la couche de sortie, c'est-à-dire la couche Madaline.

Algorithme de formation

A présent, nous savons que seuls les poids et biais entre l'entrée et la couche Adaline doivent être ajustés, et les poids et biais entre la couche Adaline et la couche Madaline sont fixes.

Step 1 - Initialisez les éléments suivants pour démarrer la formation -

  • Weights
  • Bias
  • Taux d'apprentissage $ \ alpha $

Pour faciliter le calcul et la simplicité, les pondérations et les biais doivent être définis sur 0 et le taux d'apprentissage doit être défini sur 1.

Step 2 - Continuez l'étape 3-8 lorsque la condition d'arrêt n'est pas vraie.

Step 3 - Continuez l'étape 4-6 pour chaque paire d'entraînement bipolaire s:t.

Step 4 - Activez chaque unité d'entrée comme suit -

$$ x_ {i} \: = \: s_ {i} \ :( i \: = \: 1 \: à \: n) $$

Step 5 - Obtenir l'entrée nette à chaque couche cachée, c'est-à-dire la couche Adaline avec la relation suivante -

$$ Q_ {inj} \: = \: b_ {j} \: + \: \ displaystyle \ sum \ limits_ {i} ^ n x_ {i} \: w_ {ij} \: \: \: j \: = \: 1 \: à \: m $$

Ici ‘b’ est un parti pris et ‘n’ est le nombre total de neurones d'entrée.

Step 6 - Appliquer la fonction d'activation suivante pour obtenir la sortie finale au niveau des couches Adaline et Madaline -

$$ f (x) \: = \: \ begin {cases} 1 & if \: x \: \ geqslant \: 0 \\ - 1 & if \: x \: <\: 0 \ end {cases} $ $

Sortie sur l'unité cachée (Adaline)

$$ Q_ {j} \: = \: f (Q_ {inj}) $$

Sortie finale du réseau

$$ y \: = \: f (y_ {dans}) $$

i.e. $ \: \: y_ {inj} \: = \: b_ {0} \: + \: \ sum_ {j = 1} ^ m \: Q_ {j} \: v_ {j} $

Step 7 - Calculez l'erreur et ajustez les poids comme suit -

Case 1 - si y ≠ t et t = 1 puis,

$$ w_ {ij} (nouveau) \: = \: w_ {ij} (ancien) \: + \: \ alpha (1 \: - \: Q_ {inj}) x_ {i} $$

$$ b_ {j} (nouveau) \: = \: b_ {j} (ancien) \: + \: \ alpha (1 \: - \: Q_ {inj}) $$

Dans ce cas, les poids seraient mis à jour le Qj où l'entrée nette est proche de 0 car t = 1.

Case 2 - si y ≠ t et t = -1 puis,

$$ w_ {ik} (nouveau) \: = \: w_ {ik} (ancien) \: + \: \ alpha (-1 \: - \: Q_ {ink}) x_ {i} $$

$$ b_ {k} (nouveau) \: = \: b_ {k} (ancien) \: + \: \ alpha (-1 \: - \: Q_ {ink}) $$

Dans ce cas, les poids seraient mis à jour le Qk où l'entrée nette est positive car t = -1.

Ici ‘y’ est la sortie réelle et ‘t’ est la sortie souhaitée / cible.

Case 3 - si y = t puis

Il n'y aurait aucun changement de poids.

Step 8 - Testez la condition d'arrêt, qui se produira lorsqu'il n'y a pas de changement de poids ou que le changement de poids le plus élevé survenu pendant l'entraînement est inférieur à la tolérance spécifiée.

Réseaux de neurones à propagation arrière

Back Propagation Neural (BPN) est un réseau neuronal multicouche composé de la couche d'entrée, d'au moins une couche cachée et d'une couche de sortie. Comme son nom l'indique, la rétro-propagation aura lieu dans ce réseau. L'erreur qui est calculée au niveau de la couche de sortie, en comparant la sortie cible et la sortie réelle, sera propagée vers la couche d'entrée.

Architecture

Comme le montre le diagramme, l'architecture de BPN a trois couches interconnectées avec des poids. Le calque caché ainsi que le calque de sortie ont également un biais, dont le poids est toujours 1, sur eux. Comme il ressort du diagramme, le fonctionnement de BPN se déroule en deux phases. Une phase envoie le signal de la couche d'entrée à la couche de sortie, et l'autre phase retourne l'erreur de la couche de sortie à la couche d'entrée.

Algorithme de formation

Pour la formation, BPN utilisera la fonction d'activation sigmoïde binaire. La formation de BPN comportera les trois phases suivantes.

  • Phase 1 - Phase d'avance

  • Phase 2 - Propagation en arrière de l'erreur

  • Phase 3 - Mise à jour des poids

Toutes ces étapes seront conclues dans l'algorithme comme suit

Step 1 - Initialisez les éléments suivants pour démarrer la formation -

  • Weights
  • Taux d'apprentissage $ \ alpha $

Pour faciliter le calcul et la simplicité, prenez quelques petites valeurs aléatoires.

Step 2 - Continuez l'étape 3-11 lorsque la condition d'arrêt n'est pas vraie.

Step 3 - Continuez les étapes 4 à 10 pour chaque paire d'entraînement.

La phase 1

Step 4 - Chaque unité d'entrée reçoit un signal d'entrée xi et l'envoie à l'unité cachée pour tous i = 1 to n

Step 5 - Calculez l'entrée nette à l'unité cachée en utilisant la relation suivante -

$$ Q_ {inj} \: = \: b_ {0j} \: + \: \ sum_ {i = 1} ^ n x_ {i} v_ {ij} \: \: \: \: j \: = \ : 1 \: à \: p $$

Ici b0j est le biais sur l'unité cachée, vij est le poids sur j unité de la couche cachée provenant de i unité de la couche d'entrée.

Calculez maintenant la sortie nette en appliquant la fonction d'activation suivante

$$ Q_ {j} \: = \: f (Q_ {inj}) $$

Envoyez ces signaux de sortie des unités de couche masquées aux unités de couche de sortie.

Step 6 - Calculez l'entrée nette à l'unité de couche de sortie en utilisant la relation suivante -

$$ y_ {ink} \: = \: b_ {0k} \: + \: \ sum_ {j = 1} ^ p \: Q_ {j} \: w_ {jk} \: \: k \: = \ : 1 \: à \: m $$

Ici b0k ⁡Est la polarisation sur l'unité de sortie, wjk est le poids sur k unité de la couche de sortie provenant de j unité de la couche cachée.

Calculez la sortie nette en appliquant la fonction d'activation suivante

$$ y_ {k} \: = \: f (y_ {encre}) $$

Phase 2

Step 7 - Calculez le terme de correction d'erreur, en correspondance avec le modèle cible reçu à chaque unité de sortie, comme suit -

$$ \ delta_ {k} \: = \ :( t_ {k} \: - \: y_ {k}) f ^ {'} (y_ {ink}) $$

Sur cette base, mettez à jour le poids et le biais comme suit -

$$ \ Delta v_ {jk} \: = \: \ alpha \ delta_ {k} \: Q_ {ij} $$

$$ \ Delta b_ {0k} \: = \: \ alpha \ delta_ {k} $$

Ensuite, renvoyez $ \ delta_ {k} $ au calque caché.

Step 8 - Maintenant, chaque unité cachée sera la somme de ses entrées delta des unités de sortie.

$$ \ delta_ {inj} \: = \: \ displaystyle \ sum \ limits_ {k = 1} ^ m \ delta_ {k} \: w_ {jk} $$

Le terme d'erreur peut être calculé comme suit -

$$ \ delta_ {j} \: = \: \ delta_ {inj} f ^ {'} (Q_ {inj}) $$

Sur cette base, mettez à jour le poids et le biais comme suit -

$$ \ Delta w_ {ij} \: = \: \ alpha \ delta_ {j} x_ {i} $$

$$ \ Delta b_ {0j} \: = \: \ alpha \ delta_ {j} $$

Phase 3

Step 9 - Chaque unité de sortie (ykk = 1 to m) met à jour le poids et le biais comme suit -

$$ v_ {jk} (nouveau) \: = \: v_ {jk} (ancien) \: + \: \ Delta v_ {jk} $$

$$ b_ {0k} (nouveau) \: = \: b_ {0k} (ancien) \: + \: \ Delta b_ {0k} $$

Step 10 - Chaque unité de sortie (zjj = 1 to p) met à jour le poids et le biais comme suit -

$$ w_ {ij} (nouveau) \: = \: w_ {ij} (ancien) \: + \: \ Delta w_ {ij} $$

$$ b_ {0j} (nouveau) \: = \: b_ {0j} (ancien) \: + \: \ Delta b_ {0j} $$

Step 11 - Vérifiez la condition d'arrêt, qui peut être le nombre d'époques atteintes ou la sortie cible correspond à la sortie réelle.

Règle d'apprentissage Delta généralisée

La règle Delta ne fonctionne que pour la couche de sortie. D'autre part, la règle delta généralisée, également appeléeback-propagation règle, est un moyen de créer les valeurs souhaitées du calque masqué.

Formulation mathématique

Pour la fonction d'activation $ y_ {k} \: = \: f (y_ {ink}) $ la dérivation de l'entrée nette sur la couche cachée ainsi que sur la couche de sortie peut être donnée par

$$ y_ {ink} \: = \: \ displaystyle \ sum \ limits_i \: z_ {i} w_ {jk} $$

Et $ \: \: y_ {inj} \: = \: \ sum_i x_ {i} v_ {ij} $

Maintenant l'erreur qui doit être minimisée est

$$ E \: = \: \ frac {1} {2} \ displaystyle \ sum \ limits_ {k} \: [t_ {k} \: - \: y_ {k}] ^ 2 $$

En utilisant la règle de la chaîne, nous avons

$$ \ frac {\ partial E} {\ partial w_ {jk}} \: = \: \ frac {\ partial} {\ partial w_ {jk}} (\ frac {1} {2} \ displaystyle \ sum \ limites_ {k} \: [t_ {k} \: - \: y_ {k}] ^ 2) $$

$$ = \: \ frac {\ partial} {\ partial w_ {jk}} \ lgroup \ frac {1} {2} [t_ {k} \: - \: t (y_ {ink})] ^ 2 \ rgroup $$

$$ = \: - [t_ {k} \: - \: y_ {k}] \ frac {\ partial} {\ partial w_ {jk}} f (y_ {ink}) $$

$$ = \: - [t_ {k} \: - \: y_ {k}] f (y_ {ink}) \ frac {\ partial} {\ partial w_ {jk}} (y_ {ink}) $$

$$ = \: - [t_ {k} \: - \: y_ {k}] f ^ {'} (y_ {encre}) z_ {j} $$

Disons maintenant $ \ delta_ {k} \: = \: - [t_ {k} \: - \: y_ {k}] f ^ {'} (y_ {ink}) $

Les poids sur les connexions à l'unité cachée zj peut être donné par -

$$ \ frac {\ partial E} {\ partial v_ {ij}} \: = \: - \ displaystyle \ sum \ limits_ {k} \ delta_ {k} \ frac {\ partial} {\ partial v_ {ij} } \ :( y_ {ink}) $$

En mettant la valeur de $ y_ {ink} $, nous obtiendrons ce qui suit

$$ \ delta_ {j} \: = \: - \ displaystyle \ sum \ limits_ {k} \ delta_ {k} w_ {jk} f ^ {'} (z_ {inj}) $$

La mise à jour du poids peut être effectuée comme suit -

Pour l'unité de sortie -

$$ \ Delta w_ {jk} \: = \: - \ alpha \ frac {\ partial E} {\ partial w_ {jk}} $$

$$ = \: \ alpha \: \ delta_ {k} \: z_ {j} $$

Pour l'unité cachée -

$$ \ Delta v_ {ij} \: = \: - \ alpha \ frac {\ partial E} {\ partial v_ {ij}} $$

$$ = \: \ alpha \: \ delta_ {j} \: x_ {i} $$