Réseau de neurones artificiels - Guide rapide

Les réseaux neuronaux sont des dispositifs informatiques parallèles, qui sont essentiellement une tentative de créer un modèle informatique du cerveau. L'objectif principal est de développer un système pour effectuer diverses tâches de calcul plus rapidement que les systèmes traditionnels. Ces tâches comprennent la reconnaissance et la classification de modèles, l'approximation, l'optimisation et la mise en cluster des données.

Qu'est-ce que le réseau neuronal artificiel?

Artificial Neural Network (ANN) est un système informatique efficace dont le thème central est emprunté à l'analogie des réseaux de neurones biologiques. Les ANN sont également appelés «systèmes neuronaux artificiels», ou «systèmes de traitement distribués parallèles» ou «systèmes connexionnistes». ANN acquiert une grande collection d'unités qui sont interconnectées selon un certain modèle pour permettre la communication entre les unités. Ces unités, également appelées nœuds ou neurones, sont de simples processeurs qui fonctionnent en parallèle.

Chaque neurone est connecté à un autre neurone via un lien de connexion. Chaque lien de connexion est associé à un poids contenant des informations sur le signal d'entrée. Il s'agit de l'information la plus utile pour les neurones pour résoudre un problème particulier car le poids excite ou inhibe généralement le signal qui est communiqué. Chaque neurone a un état interne, appelé signal d'activation. Les signaux de sortie, qui sont produits après la combinaison des signaux d'entrée et de la règle d'activation, peuvent être envoyés à d'autres unités.

Une brève histoire de ANN

L'histoire d'ANN peut être divisée en trois époques suivantes -

ANN des années 40 aux années 60

Voici quelques développements clés de cette époque:

1943 - On a supposé que le concept de réseau de neurones a commencé avec les travaux du physiologiste, Warren McCulloch, et du mathématicien, Walter Pitts, lorsqu'en 1943 ils ont modélisé un simple réseau de neurones à l'aide de circuits électriques afin de décrire comment les neurones du cerveau pourraient fonctionner .
1949- Le livre de Donald Hebb, The Organization of Behavior , met en avant le fait que l'activation répétée d'un neurone par un autre augmente sa force à chaque fois qu'ils sont utilisés.
1956 - Un réseau de mémoire associative a été introduit par Taylor.
1958 - Une méthode d'apprentissage pour le modèle de neurone McCulloch et Pitts nommé Perceptron a été inventée par Rosenblatt.
1960 - Bernard Widrow et Marcian Hoff ont développé des modèles appelés «ADALINE» et «MADALINE».

ANN des années 60 aux années 80

Voici quelques développements clés de cette époque:

1961 - Rosenblatt a fait une tentative infructueuse mais a proposé le schéma de «rétropropagation» pour les réseaux multicouches.
1964 - Taylor a construit un circuit gagnant-gagnant avec des inhibitions parmi les unités de sortie.
1969 - Le perceptron multicouche (MLP) a été inventé par Minsky et Papert.
1971 - Kohonen a développé des mémoires associatives.
1976 - Stephen Grossberg et Gail Carpenter ont développé la théorie de la résonance adaptative.

ANN des années 1980 à aujourd'hui

Voici quelques développements clés de cette époque:

1982 - Le développement majeur a été l'approche énergétique de Hopfield.
1985 - La machine Boltzmann a été développée par Ackley, Hinton et Sejnowski.
1986 - Rumelhart, Hinton et Williams ont introduit la règle de delta généralisée.
1988 - Kosko a développé la mémoire associative binaire (BAM) et a également donné le concept de logique floue dans ANN.

La revue historique montre que des progrès significatifs ont été réalisés dans ce domaine. Des puces basées sur des réseaux neuronaux font leur apparition et des applications à des problèmes complexes sont en cours de développement. Certes, aujourd'hui est une période de transition pour la technologie des réseaux neuronaux.

Neurone biologique

Une cellule nerveuse (neurone) est une cellule biologique spéciale qui traite les informations. Selon une estimation, il existe un grand nombre de neurones, environ 10 ¹¹ avec de nombreuses interconnexions, environ 10 ¹⁵ .

Diagramme schématique

Fonctionnement d'un neurone biologique

Comme le montre le diagramme ci-dessus, un neurone typique se compose des quatre parties suivantes à l'aide desquelles nous pouvons expliquer son fonctionnement -

Dendrites- Ce sont des branches arborescentes, chargées de recevoir les informations des autres neurones auxquels elles sont connectées. En un autre sens, on peut dire qu'ils sont comme les oreilles du neurone.
Soma - C'est le corps cellulaire du neurone et est responsable du traitement des informations, qu'ils ont reçues des dendrites.
Axon - C'est comme un câble par lequel les neurones envoient les informations.
Synapses - C'est la connexion entre l'axone et les autres dendrites neuronales.

ANN contre BNN

Avant de jeter un œil aux différences entre le réseau neuronal artificiel (ANN) et le réseau neuronal biologique (BNN), examinons les similitudes basées sur la terminologie entre ces deux.

Réseau neuronal biologique (BNN)	Réseau de neurones artificiels (ANN)
Soma	Nœud
Les dendrites	Contribution
Synapse	Poids ou interconnexions
Axon	Production

Le tableau suivant montre la comparaison entre ANN et BNN sur la base de certains critères mentionnés.

Critères	BNN	ANN
Processing	Massivement parallèle, lent mais supérieur à ANN	Massivement parallèle, rapide mais inférieur à BNN
Size	10 ¹¹ neurones et 10 ¹⁵ interconnexions	10 ² à 10 ⁴ nœuds (dépend principalement du type d'application et du concepteur de réseau)
Learning	Ils peuvent tolérer l'ambiguïté	Des données très précises, structurées et formatées sont nécessaires pour tolérer l'ambiguïté
Fault tolerance	Les performances se dégradent avec des dommages même partiels	Il est capable de performances robustes et a donc le potentiel d'être tolérant aux pannes
Storage capacity	Stocke les informations dans la synapse	Stocke les informations dans des emplacements de mémoire continus

Modèle de réseau neuronal artificiel

Le diagramme suivant représente le modèle général de ANN suivi de son traitement.

Pour le modèle général ci-dessus de réseau de neurones artificiels, l'entrée nette peut être calculée comme suit -

$$ y_ {dans} \: = \: x_ {1} .w_ {1} \: + \: x_ {2} .w_ {2} \: + \: x_ {3} .w_ {3} \: \ dotso \: x_ {m} .w_ {m} $$

c'est-à-dire, entrée nette $ y_ {in} \: = \: \ sum_i ^ m \: x_ {i} .w_ {i} $

La sortie peut être calculée en appliquant la fonction d'activation sur l'entrée nette.

$$ Y \: = \: F (y_ {dans}) $$

Sortie = fonction (entrée nette calculée)

Le traitement de l'ANN dépend des trois éléments de base suivants -

Topologie du réseau
Ajustements de poids ou apprentissage
Fonctions d'activation

Dans ce chapitre, nous discuterons en détail de ces trois éléments constitutifs de l'ANN

Topologie du réseau

Une topologie de réseau est la disposition d'un réseau avec ses nœuds et ses lignes de connexion. Selon la topologie, ANN peut être classé comme suit:

Réseau Feedforward

Il s'agit d'un réseau non récurrent ayant des unités / nœuds de traitement en couches et tous les nœuds d'une couche sont connectés aux nœuds des couches précédentes. La connexion a des poids différents sur eux. Il n'y a pas de boucle de rétroaction, ce qui signifie que le signal ne peut circuler que dans une seule direction, de l'entrée à la sortie. Il peut être divisé en deux types:

Single layer feedforward network- Le concept est de l'ANN par anticipation n'ayant qu'une seule couche pondérée. En d'autres termes, nous pouvons dire que la couche d'entrée est entièrement connectée à la couche de sortie.

Multilayer feedforward network- Le concept consiste en un ANN à action directe ayant plus d'une couche pondérée. Comme ce réseau a une ou plusieurs couches entre la couche d'entrée et la couche de sortie, il est appelé couches cachées.

Réseau de rétroaction

Comme son nom l'indique, un réseau de rétroaction a des chemins de rétroaction, ce qui signifie que le signal peut circuler dans les deux sens à l'aide de boucles. Cela en fait un système dynamique non linéaire, qui change continuellement jusqu'à ce qu'il atteigne un état d'équilibre. Il peut être divisé selon les types suivants -

Recurrent networks- Ce sont des réseaux de rétroaction avec des boucles fermées. Voici les deux types de réseaux récurrents.
Fully recurrent network - C'est l'architecture de réseau neuronal la plus simple car tous les nœuds sont connectés à tous les autres nœuds et chaque nœud fonctionne à la fois en entrée et en sortie.

Jordan network - Il s'agit d'un réseau en boucle fermée dans lequel la sortie retournera à l'entrée en retour comme indiqué dans le diagramme suivant.

Ajustements de poids ou apprentissage

L'apprentissage, en réseau de neurones artificiels, est la méthode de modification des poids des connexions entre les neurones d'un réseau spécifié. L'apprentissage en ANN peut être classé en trois catégories, à savoir l'apprentissage supervisé, l'apprentissage non supervisé et l'apprentissage par renforcement.

Enseignement supervisé

Comme son nom l'indique, ce type d'apprentissage se fait 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 donnera un vecteur de sortie. Ce vecteur de sortie est comparé au vecteur de sortie souhaité. Un signal d'erreur est généré s'il y a une différence entre la sortie réelle et le vecteur de sortie souhaité. Sur la base de ce signal d'erreur, les poids sont ajustés jusqu'à ce que la sortie réelle corresponde à la sortie souhaitée.

Apprentissage non supervisé

Comme son nom l'indique, ce type d'apprentissage se fait sans la supervision d'un enseignant. Ce processus d'apprentissage est indépendant.

Au cours de la formation de ANN sous apprentissage non supervisé, les vecteurs d'entrée de type similaire sont combinés pour former des grappes. Lorsqu'un nouveau modèle d'entrée est appliqué, le réseau neuronal donne une réponse de sortie indiquant la classe à laquelle appartient le modèle d'entrée.

Il n'y a aucun retour de l'environnement sur ce que devrait être la sortie souhaitée et si elle est correcte ou incorrecte. Par conséquent, dans ce type d'apprentissage, le réseau lui-même doit découvrir les modèles et les caractéristiques des données d'entrée, et la relation des données d'entrée sur la sortie.

Apprentissage par renforcement

Comme son nom l'indique, ce type d'apprentissage est utilisé pour renforcer ou renforcer le réseau sur certaines informations critiques. Ce processus d'apprentissage est similaire à l'apprentissage supervisé, mais nous pourrions avoir très moins d'informations.

Lors de la formation du réseau sous apprentissage par renforcement, le réseau reçoit des retours de l'environnement. Cela le rend quelque peu similaire à l'apprentissage supervisé. Cependant, le retour d'expérience obtenu ici est évaluatif et non instructif, ce qui signifie qu'il n'y a pas d'enseignant comme dans l'apprentissage supervisé. Après avoir reçu les commentaires, le réseau effectue des ajustements des poids pour obtenir de meilleures informations critiques à l'avenir.

Fonctions d'activation

Il peut être défini comme la force ou l'effort supplémentaire appliqué sur l'entrée pour obtenir une sortie exacte. Dans ANN, nous pouvons également appliquer des fonctions d'activation sur l'entrée pour obtenir la sortie exacte. Voici quelques fonctions d'activation intéressantes -

Fonction d'activation linéaire

Elle est également appelée fonction d'identité car elle n'effectue aucune édition d'entrée. Il peut être défini comme -

$$ F (x) \: = \: x $$

Fonction d'activation sigmoïde

Il est de deux types comme suit -

Binary sigmoidal function- Cette fonction d'activation effectue l'édition d'entrée entre 0 et 1. Elle est de nature positive. Il est toujours borné, ce qui signifie que sa sortie ne peut pas être inférieure à 0 et supérieure à 1. Elle est également de nature strictement croissante, ce qui signifie que plus l'entrée la plus élevée serait la sortie. Il peut être défini comme

$$ F (x) \: = \: sigm (x) \: = \: \ frac {1} {1 \: + \: exp (-x)} $$
Bipolar sigmoidal function- Cette fonction d'activation effectue l'édition d'entrée entre -1 et 1. Elle peut être de nature positive ou négative. Il est toujours borné, ce qui signifie que sa sortie ne peut pas être inférieure à -1 et supérieure à 1. Elle est également de nature strictement croissante comme la fonction sigmoïde. Il peut être défini comme

$$ F (x) \: = \: sigm (x) \: = \: \ frac {2} {1 \: + \: exp (-x)} \: - \: 1 \: = \: \ frac {1 \: - \: exp (x)} {1 \: + \: exp (x)} $$

Comme indiqué précédemment, ANN est complètement inspiré par le fonctionnement du système nerveux biologique, c'est-à-dire du cerveau humain. La caractéristique la plus impressionnante du cerveau humain est d'apprendre, d'où la même caractéristique est acquise par ANN.

Qu'est-ce que l'apprentissage dans ANN?

Fondamentalement, apprendre signifie faire et adapter le changement en lui-même au fur et à mesure qu'il y a un changement d'environnement. ANN est un système complexe ou plus précisément on peut dire qu'il s'agit d'un système adaptatif complexe, qui peut changer sa structure interne en fonction des informations qui le traversent.

Pourquoi c'est important?

Étant un système adaptatif complexe, l'apprentissage en ANN implique qu'une unité de traitement est capable de changer son comportement d'entrée / sortie en raison du changement d'environnement. L'importance de l'apprentissage dans ANN augmente en raison de la fonction d'activation fixe ainsi que du vecteur d'entrée / sortie, lorsqu'un réseau particulier est construit. Maintenant, pour changer le comportement d'entrée / sortie, nous devons ajuster les poids.

Classification

Il peut être défini comme le processus d'apprentissage pour distinguer les données d'échantillons en différentes classes en trouvant des caractéristiques communes entre les échantillons des mêmes classes. Par exemple, pour effectuer une formation sur ANN, nous avons des échantillons de formation avec des fonctionnalités uniques, et pour effectuer ses tests, nous avons des échantillons de test avec d'autres fonctionnalités uniques. La classification est un exemple d'apprentissage supervisé.

Règles d'apprentissage du réseau neuronal

Nous savons que, lors de l'apprentissage ANN, pour changer le comportement d'entrée / sortie, nous devons ajuster les poids. Par conséquent, une méthode est nécessaire à l'aide de laquelle les poids peuvent être modifiés. Ces méthodes sont appelées règles d'apprentissage, qui sont simplement des algorithmes ou des équations. Voici quelques règles d'apprentissage pour le réseau neuronal -

Règle d'apprentissage Hebbian

Cette règle, l'une des plus anciennes et des plus simples, a été introduite par Donald Hebb dans son livre The Organization of Behavior en 1949. Il s'agit d'une sorte d'apprentissage par anticipation et non supervisé.

Basic Concept - Cette règle est basée sur une proposition donnée par Hebb, qui a écrit -

«Lorsqu'un axone de la cellule A est suffisamment proche pour exciter une cellule B et participe de manière répétée ou persistante à son déclenchement, un processus de croissance ou un changement métabolique se produit dans une ou les deux cellules de telle sorte que l'efficacité de A, comme l'une des cellules déclenchant B , est augmenté. »

À partir du postulat ci-dessus, nous pouvons conclure que les connexions entre deux neurones pourraient être renforcées si les neurones se déclenchent en même temps et pourraient s'affaiblir s'ils se déclenchent à des moments différents.

Mathematical Formulation - Selon la règle d'apprentissage Hebbian, voici la formule pour augmenter le poids de la connexion à chaque pas de temps.

$$ \ Delta w_ {ji} (t) \: = \: \ alpha x_ {i} (t) .y_ {j} (t) $$

Ici, $ \ Delta w_ {ji} (t) $ ⁡ = incrément par lequel le poids de la connexion augmente au pas de temps t

$ \ alpha $ = le taux d'apprentissage positif et constant

$ x_ {i} (t) $ = la valeur d'entrée du neurone pré-synaptique au pas de temps t

$ y_ {i} (t) $ = la sortie du neurone pré-synaptique au même pas de temps t

Règle d'apprentissage Perceptron

Cette règle est une erreur corrigeant l'algorithme d'apprentissage supervisé des réseaux à anticipation monocouche avec fonction d'activation linéaire, introduit par Rosenblatt.

Basic Concept- Comme étant de nature supervisée, pour calculer l'erreur, il y aurait une comparaison entre la sortie souhaitée / cible et la sortie réelle. S'il y a une différence trouvée, alors une modification doit être apportée aux poids de connexion.

Mathematical Formulation - Pour expliquer sa formulation mathématique, supposons que nous ayons un nombre 'n' de vecteurs d'entrée finis, x (n), ainsi que son vecteur de sortie souhaité / cible t (n), où n = 1 à N.

Maintenant, la sortie `` y '' peut être calculée, comme expliqué précédemment sur la base de l'entrée nette, et la fonction d'activation appliquée sur cette entrée nette peut être exprimée comme suit -

$$ y \: = \: f (y_ {in}) \: = \: \ begin {cases} 1, & y_ {in} \:> \: \ theta \\ 0, & y_ {in} \: \ leqslant \: \ theta \ end {cas} $$

Où θ est le seuil.

La mise à jour du poids peut être effectuée dans les deux cas suivants -

Case I - quand t ≠ y, puis

$$ w (nouveau) \: = \: w (ancien) \: + \; tx $$

Case II - quand t = y, puis

Pas de changement de poids

Règle d'apprentissage Delta (règle Widrow-Hoff)

Elle est introduite par Bernard Widrow et Marcian Hoff, également appelée méthode des moindres carrés (LMS), pour minimiser l'erreur sur tous les modèles d'apprentissage. C'est une sorte d'algorithme d'apprentissage supervisé avec une fonction d'activation continue.

Basic Concept- La base de cette règle est l'approche en descente, qui se poursuit pour toujours. La règle Delta met à jour les poids synaptiques afin de minimiser l'entrée nette dans l'unité de sortie et la valeur cible.

Mathematical Formulation - Pour mettre à jour les poids synaptiques, la règle delta est donnée par

$$ \ Delta w_ {i} \: = \: \ alpha \ :. x_ {i} .e_ {j} $$

Ici $ \ Delta w_ {i} $ = changement de poids pour le i ^ème modèle;

$ \ alpha $ = le taux d'apprentissage positif et constant;

$ x_ {i} $ = la valeur d'entrée du neurone pré-synaptique;

$ e_ {j} $ = $ (t \: - \: y_ {in}) $, la différence entre la sortie souhaitée / cible et la sortie réelle ⁡ $ y_ {in} $

La règle delta ci-dessus ne concerne qu'une seule unité de sortie.

La mise à jour du poids peut être effectuée dans les deux cas suivants -

Case-I - quand t ≠ y, puis

$$ w (nouveau) \: = \: w (ancien) \: + \: \ Delta w $$

Case-II - quand t = y, puis

Pas de changement de poids

Règle d'apprentissage compétitif (le gagnant prend tout)

Il s'agit d'un apprentissage non supervisé dans lequel les nœuds de sortie essaient de se concurrencer pour représenter le modèle d'entrée. Pour comprendre cette règle d'apprentissage, il faut comprendre le réseau concurrentiel qui se donne comme suit -

Basic Concept of Competitive Network- Ce réseau est comme un réseau à anticipation monocouche avec connexion de rétroaction entre les sorties. Les connexions entre les sorties sont de type inhibitrices, représentées par des lignes pointillées, ce qui signifie que les concurrents ne se soutiennent jamais.

Basic Concept of Competitive Learning Rule- Comme indiqué précédemment, il y aura une concurrence entre les nœuds de sortie. Par conséquent, le concept principal est que pendant l'entraînement, l'unité de sortie avec l'activation la plus élevée d'un modèle d'entrée donné sera déclarée gagnante. Cette règle est également appelée Winner-takes-all car seul le neurone gagnant est mis à jour et le reste des neurones reste inchangé.

Mathematical formulation - Voici les trois facteurs importants pour la formulation mathématique de cette règle d'apprentissage -

Condition to be a winner - Supposons que si un neurone $ y_ {k} $ ⁡ ⁡ veut être le gagnant alors il y aurait la condition suivante -

$$ y_ {k} \: = \: \ begin {cases} 1 & if \: v_ {k} \:> \: v_ {j} \: for \: all \: j, \: j \: \ neq \: k \\ 0 & sinon \ end {cases} $$

Cela signifie que si un neurone, disons $ y_ {k} $ ⁡, veut gagner, alors son champ local induit (la sortie de l'unité de sommation), disons $ v_ {k} $, doit être le plus grand parmi tous les autres neurones dans le réseau.

Condition of sum total of weight - Une autre contrainte sur la règle d'apprentissage compétitif est que la somme des poids pour un neurone de sortie particulier va être de 1. Par exemple, si nous considérons neurone k puis -

$$ \ displaystyle \ sum \ limits_ {j} w_ {kj} \: = \: 1 \: \: \: \: \: \: \: \: \: for \: all \: k $$

Change of weight for winner- Si un neurone ne répond pas au modèle d'entrée, alors aucun apprentissage n'a lieu dans ce neurone. Cependant, si un neurone particulier gagne, les poids correspondants sont ajustés comme suit

$$ \ Delta w_ {kj} \: = \: \ begin {cases} - \ alpha (x_ {j} \: - \: w_ {kj}), & if \: neuron \: k \: wins \\ 0, & if \: neuron \: k \: loss \ end {cases} $$

Ici $ \ alpha $ est le taux d'apprentissage.

Cela montre clairement que nous favorisons le neurone gagnant en ajustant son poids et s'il y a une perte de neurone, alors nous n'avons pas besoin de nous soucier de réajuster son poids.

Règle d'apprentissage Outstar

Cette règle, introduite par Grossberg, concerne l'apprentissage supervisé car les résultats souhaités sont connus. Il est également appelé apprentissage de Grossberg.

Basic Concept- Cette règle est appliquée sur les neurones disposés en couche. Il est spécialement conçu pour produire une sortie souhaitéed de la couche de p les neurones.

Mathematical Formulation - Les ajustements de poids dans cette règle sont calculés comme suit

$$ \ Delta w_ {j} \: = \: \ alpha \ :( d \: - \: w_ {j}) $$

Ici d est la sortie neuronale souhaitée et $ \ alpha $ est le taux d'apprentissage.

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 liens 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 y_j ≠ t_j puis,

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

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

Case 2 - si y_j = t_j 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 de l'Adaline et de la couche 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 Q_j 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 Q_k 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.

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 comporte trois couches interconnectées ayant des poids. La couche masquée ainsi que la couche de sortie ont également un biais, dont le poids est toujours 1, sur eux. Comme le montre clairement le 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 comprendra 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 x_i 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 b_0j est le biais sur l'unité cachée, v_ij 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 b_0k ⁡Est la polarisation sur l'unité de sortie, w_jk 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 à partir 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 (y_kk = 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 (z_jj = 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 z_j 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} $$

Comme son nom l'indique, ce type d'apprentissage se fait sans la supervision d'un enseignant. Ce processus d'apprentissage est indépendant. Au cours de la formation de ANN sous apprentissage non supervisé, les vecteurs d'entrée de type similaire sont combinés pour former des grappes. Lorsqu'un nouveau modèle d'entrée est appliqué, le réseau neuronal donne une réponse de sortie indiquant la classe à laquelle appartient le modèle d'entrée. En cela, il n'y aurait aucune rétroaction de l'environnement sur ce qui devrait être la sortie souhaitée et si elle est correcte ou incorrecte. Par conséquent, dans ce type d'apprentissage, le réseau lui-même doit découvrir les modèles, les caractéristiques des données d'entrée et la relation entre les données d'entrée et la sortie.

Réseaux gagnant-gagnant-tout

Ces types de réseaux sont basés sur la règle de l'apprentissage compétitif et utiliseront la stratégie où il choisit le neurone avec le plus grand nombre d'entrées totales comme gagnant. Les connexions entre les neurones de sortie montrent la concurrence entre eux et l'un d'eux serait «ON», ce qui signifie que ce serait le gagnant et que les autres seraient «OFF».

Voici quelques-uns des réseaux basés sur ce concept simple utilisant un apprentissage non supervisé.

Réseau Hamming

Dans la plupart des réseaux de neurones utilisant l'apprentissage non supervisé, il est essentiel de calculer la distance et d'effectuer des comparaisons. Ce type de réseau est le réseau Hamming, où pour chaque vecteur d'entrée donné, il serait regroupé en différents groupes. Voici quelques caractéristiques importantes de Hamming Networks -

Lippmann a commencé à travailler sur les réseaux Hamming en 1987.
C'est un réseau monocouche.
Les entrées peuvent être binaires {0, 1} ou bipolaires {-1, 1}.
Les poids du réseau sont calculés par les vecteurs exemplaires.
Il s'agit d'un réseau de poids fixe, ce qui signifie que les poids resteraient les mêmes même pendant l'entraînement.

Net maximum

Il s'agit également d'un réseau à poids fixe, qui sert de sous-réseau pour sélectionner le nœud ayant l'entrée la plus élevée. Tous les nœuds sont entièrement interconnectés et il existe des poids symétriques dans toutes ces interconnexions pondérées.

Architecture

Il utilise le mécanisme qui est un processus itératif et chaque nœud reçoit des entrées inhibitrices de tous les autres nœuds via des connexions. Le nœud unique dont la valeur est maximale serait actif ou gagnant et les activations de tous les autres nœuds seraient inactives. Max Net utilise la fonction d'activation d'identité avec $$ f (x) \: = \: \ begin {cases} x & if \: x> 0 \\ 0 & if \: x \ leq 0 \ end {cases} $$

La tâche de ce réseau est accomplie par le poids d'auto-excitation de +1 et la magnitude de l'inhibition mutuelle, qui est définie comme [0 <ɛ <$ \ frac {1} {m} $] où “m” est le nombre total de nœuds.

Apprentissage compétitif en ANN

Il s'agit d'un apprentissage non supervisé dans lequel les nœuds de sortie essaient de se concurrencer pour représenter le modèle d'entrée. Pour comprendre cette règle d'apprentissage, nous devrons comprendre le net concurrentiel qui est expliqué comme suit -

Concept de base du réseau concurrentiel

Ce réseau est comme un réseau à anticipation monocouche ayant une connexion de rétroaction entre les sorties. Les connexions entre les sorties sont de type inhibitrices, ce qui est indiqué par des lignes pointillées, ce qui signifie que les concurrents ne se soutiennent jamais.

Concept de base de la règle d'apprentissage compétitif

Comme indiqué précédemment, il y aurait une concurrence entre les nœuds de sortie, donc le concept principal est - pendant l'entraînement, l'unité de sortie qui a l'activation la plus élevée pour un modèle d'entrée donné sera déclarée gagnante. Cette règle est également appelée Winner-takes-all car seul le neurone gagnant est mis à jour et le reste des neurones reste inchangé.

Formulation mathématique

Voici les trois facteurs importants pour la formulation mathématique de cette règle d'apprentissage -

Condition pour être gagnant

Supposons que si un neurone y_k veut être le gagnant, alors il y aurait la condition suivante

$$ y_ {k} \: = \: \ begin {cases} 1 & if \: v_ {k}> v_ {j} \: for \: all \: \: j, \: j \: \ neq \ : k \\ 0 & sinon \ end {cases} $$

Cela signifie que si un neurone, disons, y_k veut gagner, alors son champ local induit (la sortie de l'unité de sommation), disons v_k, doit être le plus grand parmi tous les autres neurones du réseau.
Condition de la somme totale de poids

Une autre contrainte sur la règle d'apprentissage compétitif est la somme totale des poids pour un neurone de sortie particulier va être 1. Par exemple, si nous considérons neurone k puis

$$ \ displaystyle \ sum \ limits_ {k} w_ {kj} \: = \: 1 \: \: \: \: for \: all \: \: k $$
Changement de poids pour le gagnant

Si un neurone ne répond pas au modèle d'entrée, alors aucun apprentissage n'a lieu dans ce neurone. Cependant, si un neurone particulier gagne, les poids correspondants sont ajustés comme suit -

$$ \ Delta w_ {kj} \: = \: \ begin {cases} - \ alpha (x_ {j} \: - \: w_ {kj}), & if \: neuron \: k \: wins \\ 0 & if \: neuron \: k \: pertes \ end {cases} $$

Ici $ \ alpha $ est le taux d'apprentissage.

Cela montre clairement que nous favorisons le neurone gagnant en ajustant son poids et si un neurone est perdu, alors nous n'avons pas besoin de nous soucier de réajuster son poids.

Algorithme de clustering K-means

K-means est l'un des algorithmes de clustering les plus populaires dans lequel nous utilisons le concept de procédure de partition. Nous commençons par une partition initiale et déplaçons à plusieurs reprises des modèles d'un cluster à un autre, jusqu'à ce que nous obtenions un résultat satisfaisant.

Algorithme

Step 1 - Sélectionnez kpoints comme centres de gravité initiaux. Initialiserk prototypes (w₁,…,w_k), par exemple, nous pouvons les identifier avec des vecteurs d'entrée choisis au hasard -

$$ W_ {j} \: = \: i_ {p}, \: \: \: où \: j \: \ in \ lbrace1, ...., k \ rbrace \: et \: p \: \ dans \ lbrace1, ...., n \ rbrace $$

Chaque cluster C_j est associé au prototype w_j.

Step 2 - Répétez les étapes 3-5 jusqu'à ce que E ne diminue plus ou que l'appartenance au cluster ne change plus.

Step 3 - Pour chaque vecteur d'entrée i_p où p ∈ {1,…,n}, mettre i_p dans le cluster C_j* avec le prototype le plus proche w_j* ayant la relation suivante

$$ | i_ {p} \: - \: w_ {j *} | \: \ leq \: | i_ {p} \: - \: w_ {j} |, \: j \: \ in \ lbrace1, ...., k \ rbrace $$

Step 4 - Pour chaque cluster C_j, où j ∈ { 1,…,k}, mettre à jour le prototype w_j être le centre de gravité de tous les échantillons actuellement C_j , pour que

$$ w_ {j} \: = \: \ sum_ {i_ {p} \ in C_ {j}} \ frac {i_ {p}} {| C_ {j} |} $$

Step 5 - Calculez l'erreur de quantification totale comme suit -

$$ E \: = \: \ sum_ {j = 1} ^ k \ sum_ {i_ {p} \ in w_ {j}} | i_ {p} \: - \: w_ {j} | ^ 2 $$

Néocognitron

Il s'agit d'un réseau à réaction multicouche, qui a été développé par Fukushima dans les années 1980. Ce modèle est basé sur un apprentissage supervisé et est utilisé pour la reconnaissance visuelle de formes, principalement des caractères écrits à la main. Il s'agit essentiellement d'une extension du réseau Cognitron, qui a également été développé par Fukushima en 1975.

Architecture

C'est un réseau hiérarchique, qui comprend de nombreuses couches et il existe un modèle de connectivité localement dans ces couches.

Comme nous l'avons vu dans le diagramme ci-dessus, le néocognitron est divisé en différentes couches connectées et chaque couche a deux cellules. L'explication de ces cellules est la suivante -

S-Cell - C'est ce qu'on appelle une cellule simple, qui est formée pour répondre à un modèle particulier ou à un groupe de modèles.

C-Cell- C'est ce qu'on appelle une cellule complexe, qui combine la sortie de la cellule S et réduit simultanément le nombre d'unités dans chaque tableau. Dans un autre sens, C-cell déplace le résultat de S-cell.

Algorithme de formation

On constate que la formation du néocognitron progresse couche par couche. Les pondérations de la couche d'entrée à la première couche sont entraînées et figées. Ensuite, les poids de la première couche à la deuxième couche sont entraînés, et ainsi de suite. Les calculs internes entre S-cell et Ccell dépendent des poids provenant des couches précédentes. Par conséquent, nous pouvons dire que l'algorithme d'apprentissage dépend des calculs sur la cellule S et la cellule C.

Calculs dans la cellule S

La cellule S possède le signal excitateur reçu de la couche précédente et possède des signaux inhibiteurs obtenus au sein de la même couche.

$$ \ theta = \: \ sqrt {\ sum \ sum t_ {i} c_ {i} ^ 2} $$

Ici, t_i est le poids fixe et c_i est la sortie de C-cell.

L'entrée mise à l'échelle de la cellule S peut être calculée comme suit -

$$ x \: = \: \ frac {1 \: + \: e} {1 \: + \: vw_ {0}} \: - \: 1 $$

Ici, $ e \: = \: \ sum_i c_ {i} w_ {i} $

w_i est le poids ajusté de la cellule C à la cellule S.

w₀ est le poids réglable entre l'entrée et la S-cell.

v est l'entrée excitatrice de C-cell.

L'activation du signal de sortie est,

$$ s \: = \: \ begin {cases} x, & if \: x \ geq 0 \\ 0, & if \: x <0 \ end {cases} $$

Calculs en cellule C

L'entrée nette de la couche C est

$$ C \: = \: \ displaystyle \ sum \ limits_i s_ {i} x_ {i} $$

Ici, s_i est la sortie de S-cell et x_i est le poids fixe de la cellule S à la cellule C.

La sortie finale est la suivante -

$$ C_ {out} \: = \: \ begin {cases} \ frac {C} {a + C}, & if \: C> 0 \\ 0, & sinon \ end {cases} $$

Ici ‘a’ est le paramètre qui dépend des performances du réseau.

La quantification vectorielle d'apprentissage (LVQ), différente de la quantification vectorielle (VQ) et des cartes auto-organisées de Kohonen (KSOM), est essentiellement un réseau compétitif qui utilise l'apprentissage supervisé. Nous pouvons le définir comme un processus de classification des modèles où chaque unité de sortie représente une classe. Comme il utilise l'apprentissage supervisé, le réseau recevra un ensemble de modèles de formation avec une classification connue avec une distribution initiale de la classe de sortie. Une fois le processus d'apprentissage terminé, LVQ classifiera un vecteur d'entrée en l'attribuant à la même classe que celle de l'unité de sortie.

Architecture

La figure suivante montre l'architecture de LVQ qui est assez similaire à l'architecture de KSOM. Comme on peut le voir, il y a“n” nombre d'unités d'entrée et “m”nombre d'unités de sortie. Les couches sont entièrement interconnectées avec des poids dessus.

Paramètres utilisés

Voici les paramètres utilisés dans le processus de formation LVQ ainsi que dans l'organigramme

x= vecteur d'apprentissage (x ₁ , ..., x _i , ..., x _n )
T = classe pour vecteur de formation x
w_j = vecteur de poids pour j^th unité de sortie
C_j = classe associée au j^th unité de sortie

Algorithme de formation

Step 1 - Initialiser les vecteurs de référence, ce qui peut être fait comme suit -

Step 1(a) - À partir de l'ensemble donné de vecteurs d'apprentissage, prenez le premier "m”(Nombre de grappes) et les utiliser comme vecteurs de poids. Les vecteurs restants peuvent être utilisés pour la formation.
Step 1(b) - Attribuez le poids initial et la classification au hasard.
Step 1(c) - Appliquer la méthode de clustering K-means.

Step 2 - Initialiser le vecteur de référence $ \ alpha $

Step 3 - Continuez avec les étapes 4 à 9, si la condition d'arrêt de cet algorithme n'est pas remplie.

Step 4 - Suivez les étapes 5 à 6 pour chaque vecteur d'entrée d'entraînement x.

Step 5 - Calculer le carré de la distance euclidienne pour j = 1 to m et i = 1 to n

$$ D (j) \: = \: \ displaystyle \ sum \ limits_ {i = 1} ^ n \ displaystyle \ sum \ limits_ {j = 1} ^ m (x_ {i} \: - \: w_ {ij }) ^ 2 $$

Step 6 - Obtenez l'unité gagnante J où D(j) est minimum.

Step 7 - Calculez le nouveau poids de l'unité gagnante par la relation suivante -

si T = C_j puis $ w_ {j} (nouveau) \: = \: w_ {j} (ancien) \: + \: \ alpha [x \: - \: w_ {j} (ancien)] $

si T ≠ C_j puis $ w_ {j} (nouveau) \: = \: w_ {j} (ancien) \: - \: \ alpha [x \: - \: w_ {j} (ancien)] $

Step 8 - Réduisez le taux d'apprentissage $ \ alpha $.

Step 9- Testez la condition d'arrêt. Cela peut être comme suit -

Nombre maximum d'époques atteint.
Taux d'apprentissage réduit à une valeur négligeable.

Organigramme

Variantes

Trois autres variantes à savoir LVQ2, LVQ2.1 et LVQ3 ont été développées par Kohonen. La complexité dans toutes ces trois variantes, en raison du concept que le gagnant ainsi que l'unité finaliste apprendront, est plus que dans LVQ.

LVQ2

Comme discuté, le concept d'autres variantes de LVQ ci-dessus, la condition de LVQ2 est formée par fenêtre. Cette fenêtre sera basée sur les paramètres suivants -

x - le vecteur d'entrée courant
y_c - le vecteur de référence le plus proche de x
y_r - l'autre vecteur de référence, qui est le plus proche de x
d_c - la distance de x à y_c
d_r - la distance de x à y_r

Le vecteur d'entrée x tombe dans la fenêtre, si

$$ \ frac {d_ {c}} {d_ {r}} \:> \: 1 \: - \: \ theta \: \: et \: \: \ frac {d_ {r}} {d_ {c }} \:> \: 1 \: + \: \ theta $$

Ici, $ \ theta $ est le nombre d'échantillons d'apprentissage.

La mise à jour peut être effectuée avec la formule suivante -

$ y_ {c} (t \: + \: 1) \: = \: y_ {c} (t) \: + \: \ alpha (t) [x (t) \: - \: y_ {c} (t)] $ (belongs to different class)

$ y_ {r} (t \: + \: 1) \: = \: y_ {r} (t) \: + \: \ alpha (t) [x (t) \: - \: y_ {r} (t)] $ (belongs to same class)

Ici $ \ alpha $ est le taux d'apprentissage.

LVQ2.1

Dans LVQ2.1, nous prendrons les deux vecteurs les plus proches à savoir y_c1 et y_c2 et la condition pour la fenêtre est la suivante -

$$ Min \ begin {bmatrix} \ frac {d_ {c1}} {d_ {c2}}, \ frac {d_ {c2}} {d_ {c1}} \ end {bmatrix} \:> \ :( 1 \ : - \: \ theta) $$

$$ Max \ begin {bmatrix} \ frac {d_ {c1}} {d_ {c2}}, \ frac {d_ {c2}} {d_ {c1}} \ end {bmatrix} \: <\ :( 1 \ : + \: \ theta) $$

La mise à jour peut être effectuée avec la formule suivante -

$ y_ {c1} (t \: + \: 1) \: = \: y_ {c1} (t) \: + \: \ alpha (t) [x (t) \: - \: y_ {c1} (t)] $ (belongs to different class)

$ y_ {c2} (t \: + \: 1) \: = \: y_ {c2} (t) \: + \: \ alpha (t) [x (t) \: - \: y_ {c2} (t)] $ (belongs to same class)

Ici, $ \ alpha $ est le taux d'apprentissage.

LVQ3

Dans LVQ3, nous prendrons les deux vecteurs les plus proches à savoir y_c1 et y_c2 et la condition pour la fenêtre est la suivante -

$$ Min \ begin {bmatrix} \ frac {d_ {c1}} {d_ {c2}}, \ frac {d_ {c2}} {d_ {c1}} \ end {bmatrix} \:> \ :( 1 \ : - \: \ theta) (1 \: + \: \ theta) $$

Ici $ \ theta \ environ 0,2 $

La mise à jour peut être effectuée avec la formule suivante -

$ y_ {c1} (t \: + \: 1) \: = \: y_ {c1} (t) \: + \: \ beta (t) [x (t) \: - \: y_ {c1} (t)] $ (belongs to different class)

$ y_ {c2} (t \: + \: 1) \: = \: y_ {c2} (t) \: + \: \ beta (t) [x (t) \: - \: y_ {c2} (t)] $ (belongs to same class)

Ici $ \ beta $ est le multiple du taux d'apprentissage $ \ alpha $ et $\beta\:=\:m \alpha(t)$ pour chaque 0.1 < m < 0.5

Ce réseau a été développé par Stephen Grossberg et Gail Carpenter en 1987. Il est basé sur la concurrence et utilise un modèle d'apprentissage non supervisé. Les réseaux de la théorie de la résonance adaptative (ART), comme leur nom l'indique, sont toujours ouverts à de nouveaux apprentissages (adaptatifs) sans perdre les anciens modèles (résonance). Fondamentalement, le réseau ART est un classificateur vectoriel qui accepte un vecteur d'entrée et le classe dans l'une des catégories en fonction du motif stocké auquel il ressemble le plus.

Directeur d'exploitation

L'opération principale de la classification ART peut être divisée en les phases suivantes -

Recognition phase- Le vecteur d'entrée est comparé à la classification présentée à chaque nœud de la couche de sortie. La sortie du neurone devient «1» si elle correspond le mieux à la classification appliquée, sinon elle devient «0».
Comparison phase- Dans cette phase, une comparaison du vecteur d'entrée avec le vecteur de couche de comparaison est effectuée. La condition pour la réinitialisation est que le degré de similitude soit inférieur au paramètre de vigilance.
Search phase- Dans cette phase, le réseau recherchera la réinitialisation ainsi que la correspondance effectuée dans les phases ci-dessus. Par conséquent, s'il n'y a pas de réinitialisation et que le match est assez bon, le classement est terminé. Sinon, le processus serait répété et l'autre motif stocké doit être envoyé pour trouver la correspondance correcte.

ART1

Il s'agit d'un type d'ART, conçu pour regrouper des vecteurs binaires. Nous pouvons comprendre cela avec l'architecture de celui-ci.

Architecture d'ART1

Il se compose des deux unités suivantes -

Computational Unit - Il est composé des éléments suivants -

Input unit (F₁ layer) - Il comporte en outre les deux parties suivantes -
- F₁(a) layer (Input portion)- Dans ART1, il n'y aurait pas de traitement dans cette partie plutôt que d'avoir uniquement les vecteurs d'entrée. Il est connecté à la couche F ₁ (b) (partie d'interface).
- F₁(b) layer (Interface portion)- Cette partie combine le signal de la partie d'entrée avec celui de la couche F ₂ . La couche F ₁ (b) est connectée à la couche F ₂ par des poids de bas en hautb_ijet la couche F ₂ est connectée à la couche F ₁ (b) par des poids de haut en bast_ji.
Cluster Unit (F₂ layer)- C'est une couche compétitive. L'unité ayant la plus grande entrée nette est sélectionnée pour apprendre le modèle d'entrée. L'activation de toutes les autres unités de cluster est définie sur 0.
Reset Mechanism- Le travail de ce mécanisme est basé sur la similitude entre le poids descendant et le vecteur d'entrée. Maintenant, si le degré de cette similitude est inférieur au paramètre de vigilance, alors le cluster n'est pas autorisé à apprendre le modèle et un repos se produirait.

Supplement Unit - En fait, le problème avec le mécanisme de réinitialisation est que la couche F₂doit être inhibé dans certaines conditions et doit également être disponible lorsqu'un apprentissage se produit. C'est pourquoi deux unités supplémentaires à savoir,G₁ et G₂ est ajouté avec l'unité de réinitialisation, R. Ils s'appellentgain control units. Ces unités reçoivent et envoient des signaux aux autres unités présentes dans le réseau.‘+’ indique un signal excitateur, tandis que ‘−’ indique un signal inhibiteur.

Paramètres utilisés

Les paramètres suivants sont utilisés -

n - Nombre de composants dans le vecteur d'entrée
m - Nombre maximum de clusters pouvant être formés
b_ij- Poids de la couche F ₁ (b) à F ₂ , c.-à-d. Poids ascendant
t_ji- Poids de la couche F ₂ à F ₁ (b), c'est-à-dire poids de haut en bas
ρ - Paramètre de vigilance
||x|| - Norme du vecteur x

Algorithme

Step 1 - Initialisez le taux d'apprentissage, le paramètre de vigilance et les poids comme suit -

$$ \ alpha \:> \: 1 \: \: et \: \: 0 \: <\ rho \: \ leq \: 1 $$

$$ 0 \: <\: b_ {ij} (0) \: <\: \ frac {\ alpha} {\ alpha \: - \: 1 \: + \: n} \: \: et \: \: t_ {ij} (0) \: = \: 1 $$

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

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

Step 4- Réglez les activations de toutes les unités F ₁ (a) et F ₁ comme suit

F₂ = 0 and F₁(a) = input vectors

Step 5- Le signal d'entrée de la couche F ₁ (a) à F ₁ (b) doit être envoyé comme

$$ s_ {i} \: = \: x_ {i} $$

Step 6- Pour chaque nœud F ₂ inhibé

$ y_ {j} \: = \: \ sum_i b_ {ij} x_ {i} $ la condition est y_j ≠ -1

Step 7 - Exécutez les étapes 8 à 10, lorsque la réinitialisation est vraie.

Step 8 - Trouver J pour y_J ≥ y_j pour tous les nœuds j

Step 9- Calculez à nouveau l'activation sur F ₁ (b) comme suit

$$ x_ {i} \: = \: sitJi $$

Step 10 - Maintenant, après avoir calculé la norme du vecteur x et vecteur s, nous devons vérifier la condition de réinitialisation comme suit -

Si ||x||/ ||s|| <paramètre de vigilance ρ, ⁡Puis⁡inhiber ⁡noeud J et passez à l'étape 7

Sinon si ||x||/ ||s|| ≥ paramètre de vigilance ρ, puis continuez.

Step 11 - Mise à jour du poids pour le nœud J peut être fait comme suit -

$$ b_ {ij} (nouveau) \: = \: \ frac {\ alpha x_ {i}} {\ alpha \: - \: 1 \: + \: || x ||} $$

$$ t_ {ij} (nouveau) \: = \: x_ {i} $$

Step 12 - La condition d'arrêt de l'algorithme doit être vérifiée et elle peut être la suivante -

N'ayez aucun changement de poids.
La réinitialisation n'est pas effectuée pour les unités.
Nombre maximum d'époques atteint.

Supposons que nous ayons un certain modèle de dimensions arbitraires, cependant, nous en avons besoin dans une ou deux dimensions. Ensuite, le processus de mappage de caractéristiques serait très utile pour convertir le large espace de motif en un espace de caractéristiques typique. Maintenant, la question se pose de savoir pourquoi avons-nous besoin d'une carte de caractéristiques auto-organisée? La raison est que, en plus de la capacité de convertir les dimensions arbitraires en 1-D ou 2-D, il doit également avoir la capacité de préserver la topologie voisine.

Topologies voisines dans Kohonen SOM

Il peut y avoir différentes topologies, mais les deux topologies suivantes sont les plus utilisées -

Topologie de grille rectangulaire

Cette topologie a 24 nœuds dans la grille distance-2, 16 nœuds dans la grille distance-1 et 8 nœuds dans la grille distance-0, ce qui signifie que la différence entre chaque grille rectangulaire est de 8 nœuds. L'unité gagnante est indiquée par #.

Topologie de grille hexagonale

Cette topologie a 18 nœuds dans la grille distance-2, 12 nœuds dans la grille distance-1 et 6 nœuds dans la grille distance-0, ce qui signifie que la différence entre chaque grille rectangulaire est de 6 nœuds. L'unité gagnante est indiquée par #.

Architecture

L'architecture de KSOM est similaire à celle du réseau concurrent. Avec l'aide des projets de quartier, évoqués précédemment, la formation peut se dérouler sur la région étendue du réseau.

Algorithme de formation

Step 1 - Initialiser les poids, le taux d'apprentissage α et le schéma topologique de voisinage.

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

Step 3 - Continuez l'étape 4-6 pour chaque vecteur d'entrée x.

Step 4 - Calculer le carré de la distance euclidienne pour j = 1 to m

$$ D (j) \: = \: \ displaystyle \ sum \ limits_ {i = 1} ^ n \ displaystyle \ sum \ limits_ {j = 1} ^ m (x_ {i} \: - \: w_ {ij }) ^ 2 $$

Step 5 - Obtenez l'unité gagnante J où D(j) est minimum.

Step 6 - Calculez le nouveau poids de l'unité gagnante par la relation suivante -

$$ w_ {ij} (nouveau) \: = \: w_ {ij} (ancien) \: + \: \ alpha [x_ {i} \: - \: w_ {ij} (ancien)] $$

Step 7 - Mettre à jour le taux d'apprentissage α par la relation suivante -

$$ \ alpha (t \: + \: 1) \: = \: 0.5 \ alpha t $$

Step 8 - Réduisez le rayon du schéma topologique.

Step 9 - Vérifiez la condition d'arrêt du réseau.

Ces types de réseaux de neurones fonctionnent sur la base d'une association de modèles, ce qui signifie qu'ils peuvent stocker différents modèles et, au moment de donner une sortie, ils peuvent produire l'un des modèles stockés en les faisant correspondre avec le modèle d'entrée donné. Ces types de souvenirs sont également appelésContent-Addressable Memory(CAME). La mémoire associative effectue une recherche parallèle avec les modèles stockés sous forme de fichiers de données.

Voici les deux types de mémoires associatives que nous pouvons observer -

Mémoire associative automatique
Mémoire associative hétéro

Mémoire associative automatique

Il s'agit d'un réseau neuronal à couche unique dans lequel le vecteur d'apprentissage d'entrée et les vecteurs cibles de sortie sont les mêmes. Les poids sont déterminés de sorte que le réseau stocke un ensemble de modèles.

Architecture

Comme le montre la figure suivante, l'architecture du réseau de mémoire auto-associative a ‘n’ nombre de vecteurs de formation d'entrée et similaires ‘n’ nombre de vecteurs cibles de sortie.

Algorithme de formation

Pour la formation, ce réseau utilise la règle d'apprentissage Hebb ou Delta.

Step 1 - Initialisez tous les poids à zéro comme w_ij = 0 (i = 1 to n, j = 1 to n)

Step 2 - Exécutez les étapes 3-4 pour chaque vecteur d'entrée.

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

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

Step 4 - Activez chaque unité de sortie comme suit -

$$ y_ {j} \: = \: s_ {j} \ :( j \: = \: 1 \: à \: n) $$

Step 5 - Ajustez les poids comme suit -

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

Algorithme de test

Step 1 - Réglez les poids obtenus lors de la formation pour la règle de Hebb.

Step 2 - Exécutez les étapes 3 à 5 pour chaque vecteur d'entrée.

Step 3 - Réglez l'activation des unités d'entrée égale à celle du vecteur d'entrée.

Step 4 - Calculez l'entrée nette de chaque unité de sortie j = 1 to n

$$ y_ {inj} \: = \: \ displaystyle \ sum \ limits_ {i = 1} ^ n x_ {i} w_ {ij} $$

Step 5 - Appliquer la fonction d'activation suivante pour calculer la sortie

$$ y_ {j} \: = \: f (y_ {inj}) \: = \: \ begin {cases} +1 & if \: y_ {inj} \:> \: 0 \\ - 1 & if \: y_ {inj} \: \ leqslant \: 0 \ end {cases} $$

Mémoire associative hétéro

Semblable au réseau de mémoire associative automatique, il s'agit également d'un réseau neuronal monocouche. Cependant, dans ce réseau, le vecteur d'apprentissage d'entrée et les vecteurs cibles de sortie ne sont pas les mêmes. Les poids sont déterminés de sorte que le réseau stocke un ensemble de modèles. Le réseau hétéro associatif est de nature statique, par conséquent, il n'y aurait pas d'opérations non linéaires et de retard.

Architecture

Comme le montre la figure suivante, l'architecture du réseau de mémoire associative hétéro ‘n’ nombre de vecteurs d'apprentissage d'entrée et ‘m’ nombre de vecteurs cibles de sortie.

Algorithme de formation

Pour la formation, ce réseau utilise la règle d'apprentissage Hebb ou Delta.

Step 1 - Initialisez tous les poids à zéro comme w_ij = 0 (i = 1 to n, j = 1 to m)

Step 2 - Exécutez les étapes 3-4 pour chaque vecteur d'entrée.

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

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

Step 4 - Activez chaque unité de sortie comme suit -

$$ y_ {j} \: = \: s_ {j} \ :( j \: = \: 1 \: à \: m) $$

Step 5 - Ajustez les poids comme suit -

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

Algorithme de test

Step 1 - Réglez les poids obtenus lors de la formation pour la règle de Hebb.

Step 2 - Exécutez les étapes 3 à 5 pour chaque vecteur d'entrée.

Step 3 - Réglez l'activation des unités d'entrée égale à celle du vecteur d'entrée.

Step 4 - Calculez l'entrée nette de chaque unité de sortie j = 1 to m;

$$ y_ {inj} \: = \: \ displaystyle \ sum \ limits_ {i = 1} ^ n x_ {i} w_ {ij} $$

Step 5 - Appliquer la fonction d'activation suivante pour calculer la sortie

$$ y_ {j} \: = \: f (y_ {inj}) \: = \: \ begin {cases} +1 & if \: y_ {inj} \:> \: 0 \\ 0 & if \ : y_ {inj} \: = \: 0 \\ - 1 & if \: y_ {inj} \: <\: 0 \ end {cases} $$

Le réseau de neurones Hopfield a été inventé par le Dr John J. Hopfield en 1982. Il se compose d'une seule couche qui contient un ou plusieurs neurones récurrents entièrement connectés. Le réseau Hopfield est couramment utilisé pour les tâches d'auto-association et d'optimisation.

Réseau Hopfield discret

Un réseau de Hopfield qui fonctionne en ligne discrète ou en d'autres termes, on peut dire que les modèles d'entrée et de sortie sont des vecteurs discrets, qui peuvent être de nature binaire (0,1) ou bipolaire (+1, -1). Le réseau a des poids symétriques sans auto-connexions, c'est-à-direw_ij = w_ji et w_ii = 0.

Architecture

Voici quelques points importants à garder à l'esprit concernant le réseau Hopfield discret -

Ce modèle se compose de neurones avec une sortie inverseuse et une sortie non inverseuse.
La sortie de chaque neurone doit être l'entrée d'autres neurones mais pas l'entrée de soi.
Le poids / la force de connexion est représenté par w_ij.
Les connexions peuvent être à la fois excitatrices et inhibitrices. Ce serait excitateur, si la sortie du neurone était la même que l'entrée, sinon inhibitrice.
Les poids doivent être symétriques, c'est-à-dire w_ij = w_ji

La sortie de Y₁ aller à Y₂, Y_i et Y_n avoir les poids w₁₂, w_1i et w_1nrespectivement. De même, d'autres arcs ont les poids sur eux.

Algorithme de formation

Au cours de la formation du réseau Hopfield discret, les pondérations seront mises à jour. Comme nous savons que nous pouvons avoir les vecteurs d'entrée binaires ainsi que les vecteurs d'entrée bipolaires. Par conséquent, dans les deux cas, les mises à jour de poids peuvent être effectuées avec la relation suivante

Case 1 - Modèles d'entrée binaires

Pour un ensemble de modèles binaires s(p), p = 1 to P

Ici, s(p) = s₁(p), s₂(p),..., s_i(p),..., s_n(p)

La matrice de poids est donnée par

$$ w_ {ij} \: = \: \ sum_ {p = 1} ^ P [2s_ {i} (p) - \: 1] [2s_ {j} (p) - \: 1] \: \: \: \: \: pour \: i \: \ neq \: j $$

Case 2 - Modèles d'entrée bipolaires

Pour un ensemble de modèles binaires s(p), p = 1 to P

Ici, s(p) = s₁(p), s₂(p),..., s_i(p),..., s_n(p)

La matrice de poids est donnée par

$$ w_ {ij} \: = \: \ sum_ {p = 1} ^ P [s_ {i} (p)] [s_ {j} (p)] \: \: \: \: \: for \ : i \: \ neq \: j $$

Algorithme de test

Step 1 - Initialisez les poids, qui sont obtenus à partir de l'algorithme d'entraînement en utilisant le principe Hebbian.

Step 2 - Effectuez les étapes 3 à 9, si les activations du réseau ne sont pas consolidées.

Step 3 - Pour chaque vecteur d'entrée X, effectuez les étapes 4 à 8.

Step 4 - Rendre l'activation initiale du réseau égale au vecteur d'entrée externe X comme suit -

$$ y_ {i} \: = \: x_ {i} \: \: \: pour \: i \: = \: 1 \: à \: n $$

Step 5 - Pour chaque unité Y_i, effectuez les étapes 6 à 9.

Step 6 - Calculez l'entrée nette du réseau comme suit -

$$ y_ {ini} \: = \: x_ {i} \: + \: \ displaystyle \ sum \ limits_ {j} y_ {j} w_ {ji} $$

Step 7 - Appliquer l'activation comme suit sur l'entrée nette pour calculer la sortie -

$$ y_ {i} \: = \ begin {cases} 1 & if \: y_ {ini} \:> \: \ theta_ {i} \\ y_ {i} & if \: y_ {ini} \: = \: \ theta_ {i} \\ 0 & if \: y_ {ini} \: <\: \ theta_ {i} \ end {cases} $$

Ici $ \ theta_ {i} $ est le seuil.

Step 8 - Diffuser cette sortie y_i à toutes les autres unités.

Step 9 - Testez le réseau pour la conjonction.

Évaluation de la fonction énergétique

Une fonction énergétique est définie comme une fonction liée et non croissante de l'état du système.

Fonction énergétique E_f⁡, ⁡ aussi appelé Lyapunov function détermine la stabilité du réseau de Hopfield discret, et se caractérise comme suit -

$$ E_ {f} \: = \: - \ frac {1} {2} \ displaystyle \ sum \ limits_ {i = 1} ^ n \ displaystyle \ sum \ limits_ {j = 1} ^ n y_ {i} y_ {j} w_ {ij} \: - \: \ displaystyle \ sum \ limits_ {i = 1} ^ n x_ {i} y_ {i} \: + \: \ displaystyle \ sum \ limits_ {i = 1} ^ n \ theta_ {i} y_ {i} $$

Condition - Dans un réseau stable, chaque fois que l'état du nœud change, la fonction d'énergie ci-dessus diminue.

Supposons que le nœud i a changé d'état de $ y_i ^ {(k)} $ à $ y_i ^ {(k \: + \: 1)} $ ⁡ alors le changement d'énergie $ \ Delta E_ {f} $ est donné par la relation suivante

$$ \ Delta E_ {f} \: = \: E_ {f} (y_i ^ {(k + 1)}) \: - \: E_ {f} (y_i ^ {(k)}) $$

$$ = \: - \ left (\ begin {array} {c} \ displaystyle \ sum \ limits_ {j = 1} ^ n w_ {ij} y_i ^ {(k)} \: + \: x_ {i} \: - \: \ theta_ {i} \ end {array} \ right) (y_i ^ {(k + 1)} \: - \: y_i ^ {(k)}) $$

$$ = \: - \ :( net_ {i}) \ Delta y_ {i} $$

Ici $ \ Delta y_ {i} \: = \: y_i ^ {(k \: + \: 1)} \: - \: y_i ^ {(k)} $

Le changement d'énergie dépend du fait qu'une seule unité peut mettre à jour son activation à la fois.

Réseau Hopfield continu

En comparaison avec le réseau de Hopfield discret, le réseau continu a le temps comme variable continue. Il est également utilisé dans les problèmes d'association automatique et d'optimisation tels que le problème du voyageur de commerce.

Model - Le modèle ou l'architecture peut être construit en ajoutant des composants électriques tels que des amplificateurs qui peuvent mapper la tension d'entrée à la tension de sortie via une fonction d'activation sigmoïde.

Évaluation de la fonction énergétique

$$ E_f = \ frac {1} {2} \ displaystyle \ sum \ limits_ {i = 1} ^ n \ sum _ {\ substack {j = 1 \\ j \ ne i}} ^ n y_i y_j w_ {ij} - \ displaystyle \ sum \ limits_ {i = 1} ^ n x_i y_i + \ frac {1} {\ lambda} \ displaystyle \ sum \ limits_ {i = 1} ^ n \ sum _ {\ substack {j = 1 \\ j \ ne i}} ^ n w_ {ij} g_ {ri} \ int_ {0} ^ {y_i} a ^ {- 1} (y) dy $$

Ici λ est le paramètre de gain et g_ri conductance d'entrée.

Ce sont des processus d'apprentissage stochastiques ayant une structure récurrente et sont à la base des premières techniques d'optimisation utilisées en ANN. Boltzmann Machine a été inventée par Geoffrey Hinton et Terry Sejnowski en 1985. Plus de clarté peut être observée dans les mots de Hinton sur Boltzmann Machine.

«Une caractéristique surprenante de ce réseau est qu'il n'utilise que des informations disponibles localement. Le changement de poids dépend uniquement du comportement des deux unités qu'il relie, même si le changement optimise une mesure globale »- Ackley, Hinton 1985.

Quelques points importants sur Boltzmann Machine -

Ils utilisent une structure récurrente.
Ils sont constitués de neurones stochastiques, qui ont l'un des deux états possibles, 1 ou 0.
Certains neurones sont adaptatifs (état libre) et certains sont bloqués (état gelé).
Si nous appliquons un recuit simulé sur un réseau de Hopfield discret, il deviendrait Boltzmann Machine.

Objectif de la machine Boltzmann

L'objectif principal de Boltzmann Machine est d'optimiser la solution d'un problème. C'est le travail de Boltzmann Machine d'optimiser les poids et la quantité liés à ce problème particulier.

Architecture

Le schéma suivant montre l'architecture de la machine Boltzmann. Il ressort clairement du diagramme qu'il s'agit d'un tableau d'unités à deux dimensions. Ici, les poids sur les interconnexions entre les unités sont–p où p > 0. Les poids des auto-connexions sont donnés parb où b > 0.

Algorithme de formation

Comme nous savons que les machines Boltzmann ont des poids fixes, il n'y aura donc pas d'algorithme d'entraînement car nous n'avons pas besoin de mettre à jour les poids dans le réseau. Cependant, pour tester le réseau, nous devons définir les pondérations ainsi que trouver la fonction de consensus (CF).

La machine Boltzmann a un ensemble d'unités U_i et U_j et a des connexions bidirectionnelles sur eux.

Nous considérons le poids fixe dire w_ij.
w_ij ≠ 0 si U_i et U_j est connecté.
Il existe également une symétrie d'interconnexion pondérée, c'est-à-dire w_ij = w_ji.
w_ii existe également, c'est-à-dire qu'il y aurait l'auto-connexion entre les unités.
Pour toute unité U_i, son état u_i serait 1 ou 0.

L'objectif principal de Boltzmann Machine est de maximiser la fonction de consensus (CF) qui peut être donnée par la relation suivante

$$ CF \: = \: \ displaystyle \ sum \ limits_ {i} \ displaystyle \ sum \ limits_ {j \ leqslant i} w_ {ij} u_ {i} u_ {j} $$

Maintenant, lorsque l'état passe de 1 à 0 ou de 0 à 1, alors le changement de consensus peut être donné par la relation suivante -

$$ \ Delta CF \: = \ :( 1 \: - \: 2u_ {i}) (w_ {ij} \: + \: \ displaystyle \ sum \ limits_ {j \ neq i} u_ {i} w_ { ij}) $$

Ici u_i est l'état actuel de U_i.

La variation du coefficient (1 - 2u_i) est donnée par la relation suivante -

$$ (1 \: - \: 2u_ {i}) \: = \: \ begin {cases} +1, & U_ {i} \: est \: actuellement \: off \\ - 1, & U_ {i } \: est \: actuellement \: on \ end {cases} $$

Généralement, l'unité U_ine change pas son état, mais si c'est le cas, les informations résideront localement dans l'unité. Avec ce changement, il y aurait également une augmentation du consensus du réseau.

La probabilité du réseau d'accepter le changement d'état de l'unité est donnée par la relation suivante -

$$ AF (i, T) \: = \: \ frac {1} {1 \: + \: exp [- \ frac {\ Delta CF (i)} {T}]} $$

Ici, Test le paramètre de contrôle. Il diminuera lorsque CF atteindra la valeur maximale.

Algorithme de test

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

Poids représentant la contrainte du problème
Paramètre de contrôle T

Step 2 - Continuez les étapes 3 à 8, lorsque la condition d'arrêt n'est pas vraie.

Step 3 - Exécutez les étapes 4-7.

Step 4 - Supposons que l'un des états a changé le poids et choisissez l'entier I, J sous forme de valeurs aléatoires entre 1 et n.

Step 5 - Calculez le changement de consensus comme suit -

$$ \ Delta CF \: = \ :( 1 \: - \: 2u_ {i}) (w_ {ij} \: + \: \ displaystyle \ sum \ limits_ {j \ neq i} u_ {i} w_ { ij}) $$

Step 6 - Calculer la probabilité que ce réseau accepte le changement d'état

$$ AF (i, T) \: = \: \ frac {1} {1 \: + \: exp [- \ frac {\ Delta CF (i)} {T}]} $$

Step 7 - Acceptez ou rejetez ce changement comme suit -

Case I - si R < AF, acceptez le changement.

Case II - si R ≥ AF, rejetez le changement.

Ici, R est le nombre aléatoire compris entre 0 et 1.

Step 8 - Réduisez le paramètre de contrôle (température) comme suit -

T(new) = ⁡0.95T(old)

Step 9 - Test des conditions d'arrêt qui peuvent être les suivantes -

La température atteint une valeur spécifiée
Il n'y a pas de changement d'état pour un nombre spécifié d'itérations

Le réseau neuronal Brain-State-in-a-Box (BSB) est un réseau neuronal auto-associatif non linéaire et peut être étendu à l'hétéro-association avec deux couches ou plus. Il est également similaire au réseau Hopfield. Il a été proposé par JA Anderson, JW Silverstein, SA Ritz et RS Jones en 1977.

Quelques points importants à retenir sur BSB Network -

C'est un réseau entièrement connecté avec le nombre maximum de nœuds en fonction de la dimensionnalité n de l'espace d'entrée.
Tous les neurones sont mis à jour simultanément.
Les neurones prennent des valeurs comprises entre -1 et +1.

Formulations mathématiques

La fonction de nœud utilisée dans le réseau BSB est une fonction de rampe, qui peut être définie comme suit -

$$ f (net) \: = \: min (1, \: max (-1, \: net)) $$

Cette fonction de rampe est limitée et continue.

Comme nous savons que chaque nœud changerait son état, cela peut être fait à l'aide de la relation mathématique suivante -

$$ x_ {t} (t \: + \: 1) \: = \: f \ left (\ begin {array} {c} \ displaystyle \ sum \ limits_ {j = 1} ^ n w_ {i, j } x_ {j} (t) \ end {array} \ right) $$

Ici, x_i(t) est l'état du i_th nœud à la fois t.

Poids de i_th nœud vers j_th nœud peut être mesuré avec la relation suivante -

$$ w_ {ij} \: = \: \ frac {1} {P} \ displaystyle \ sum \ limits_ {p = 1} ^ P (v_ {p, i} \: v_ {p, j}) $$

Ici, P est le nombre de modèles d'entraînement, qui sont bipolaires.

L'optimisation consiste à rendre quelque chose comme la conception, la situation, les ressources et le système aussi efficace que possible. En utilisant une ressemblance entre la fonction de coût et la fonction d'énergie, nous pouvons utiliser des neurones hautement interconnectés pour résoudre des problèmes d'optimisation. Un tel type de réseau de neurones est le réseau de Hopfield, qui consiste en une seule couche contenant un ou plusieurs neurones récurrents entièrement connectés. Cela peut être utilisé pour l'optimisation.

Points à retenir lors de l'utilisation du réseau Hopfield pour l'optimisation -

La fonction énergétique doit être au minimum du réseau.
Il trouvera une solution satisfaisante plutôt que de sélectionner un des modèles stockés.
La qualité de la solution trouvée par le réseau Hopfield dépend fortement de l'état initial du réseau.

Problème de vendeur itinérant

Trouver l'itinéraire le plus court parcouru par le vendeur est l'un des problèmes de calcul, qui peut être optimisé en utilisant le réseau neuronal de Hopfield.

Concept de base du TSP

Le problème du voyageur de commerce (TSP) est un problème d'optimisation classique dans lequel un vendeur doit voyager nvilles, qui sont connectées les unes aux autres, en gardant au minimum le coût ainsi que la distance parcourue. Par exemple, le vendeur doit parcourir un ensemble de 4 villes A, B, C, D et l’objectif est de trouver le circuit circulaire le plus court, ABC – D, afin de minimiser le coût, qui comprend également le coût du voyage depuis la dernière ville D jusqu'à la première ville A.

Représentation matricielle

En fait, chaque visite du TSP n-city peut être exprimée comme n × n matrice dont i_th la ligne décrit le i_thl'emplacement de la ville. Cette matrice,M, pour 4 villes A, B, C, D peuvent être exprimées comme suit -

$$ M = \ begin {bmatrix} A: & 1 & 0 & 0 & 0 \\ B: & 0 & 1 & 0 & 0 \\ C: & 0 & 0 & 1 & 0 \\ D: & 0 & 0 & 0 & 1 \ end {bmatrix} $$

Solution par Hopfield Network

En considérant la solution de ce TSP par le réseau Hopfield, chaque nœud du réseau correspond à un élément de la matrice.

Calcul de la fonction énergétique

Pour être la solution optimisée, la fonction énergétique doit être minimale. Sur la base des contraintes suivantes, nous pouvons calculer la fonction énergétique comme suit -

Contrainte-I

La première contrainte, sur la base de laquelle nous allons calculer la fonction énergétique, est qu'un élément doit être égal à 1 dans chaque ligne de matrice M et les autres éléments de chaque ligne doivent être égaux à 0car chaque ville ne peut apparaître qu'à une seule position dans la tournée TSP. Cette contrainte peut s'écrire mathématiquement comme suit -

$$ \ displaystyle \ sum \ limits_ {j = 1} ^ n M_ {x, j} \: = \: 1 \: for \: x \: \ in \: \ lbrace1, ..., n \ rbrace $ $

Maintenant, la fonction d'énergie à minimiser, basée sur la contrainte ci-dessus, contiendra un terme proportionnel à -

$$ \ displaystyle \ sum \ limits_ {x = 1} ^ n \ left (\ begin {array} {c} 1 \: - \: \ displaystyle \ sum \ limits_ {j = 1} ^ n M_ {x, j } \ end {array} \ right) ^ 2 $$

Contrainte-II

Comme nous le savons, dans TSP, une ville peut apparaître dans n'importe quelle position de la tournée, donc dans chaque colonne de la matrice M, un élément doit être égal à 1 et les autres éléments doivent être égaux à 0. Cette contrainte peut s'écrire mathématiquement comme suit -

$$ \ displaystyle \ sum \ limits_ {x = 1} ^ n M_ {x, j} \: = \: 1 \: for \: j \: \ in \: \ lbrace1, ..., n \ rbrace $ $

Maintenant, la fonction d'énergie à minimiser, basée sur la contrainte ci-dessus, contiendra un terme proportionnel à -

$$ \ displaystyle \ sum \ limits_ {j = 1} ^ n \ left (\ begin {array} {c} 1 \: - \: \ displaystyle \ sum \ limits_ {x = 1} ^ n M_ {x, j } \ end {array} \ right) ^ 2 $$

Calcul de la fonction de coût

Supposons une matrice carrée de (n × n) désigné par C désigne la matrice de coût de TSP pour n villes où n > 0. Voici quelques paramètres lors du calcul de la fonction de coût -

C_{x, y} - L'élément de matrice de coût désigne le coût du voyage depuis la ville x à y.
La contiguïté des éléments de A et B peut être représentée par la relation suivante -

$$ M_ {x, i} \: = \: 1 \: \: et \: \: M_ {y, i \ pm 1} \: = \: 1 $$

Comme nous le savons, dans Matrix, la valeur de sortie de chaque nœud peut être 0 ou 1, donc pour chaque paire de villes A, B, nous pouvons ajouter les termes suivants à la fonction d'énergie -

$$ \ displaystyle \ sum \ limits_ {i = 1} ^ n C_ {x, y} M_ {x, i} (M_ {y, i + 1} \: + \: M_ {y, i-1}) $$

Sur la base de la fonction de coût et de la valeur de contrainte ci-dessus, la fonction d'énergie finale E peut être donné comme suit -

$$ E \: = \: \ frac {1} {2} \ displaystyle \ sum \ limits_ {i = 1} ^ n \ displaystyle \ sum \ limits_ {x} \ displaystyle \ sum \ limits_ {y \ neq x} C_ {x, y} M_ {x, i} (M_ {y, i + 1} \: + \: M_ {y, i-1}) \: + $$

$$ \: \ begin {bmatrix} \ gamma_ {1} \ displaystyle \ sum \ limits_ {x} \ left (\ begin {array} {c} 1 \: - \: \ displaystyle \ sum \ limits_ {i} M_ {x, i} \ end {array} \ right) ^ 2 \: + \: \ gamma_ {2} \ displaystyle \ sum \ limits_ {i} \ left (\ begin {array} {c} 1 \: - \ : \ displaystyle \ sum \ limits_ {x} M_ {x, i} \ end {array} \ right) ^ 2 \ end {bmatrix} $$

Ici, γ₁ et γ₂ sont deux constantes de pesée.

Technique de descente de gradient itérée

La descente de gradient, également appelée descente la plus raide, est un algorithme d'optimisation itératif pour trouver un minimum local d'une fonction. Tout en minimisant la fonction, nous nous préoccupons du coût ou de l'erreur à minimiser (Souvenez-vous du problème du voyageur de commerce). Il est largement utilisé dans l'apprentissage en profondeur, ce qui est utile dans une grande variété de situations. Le point à retenir ici est que nous sommes concernés par l'optimisation locale et non par l'optimisation globale.

Idée de travail principale

Nous pouvons comprendre l'idée de travail principale de la descente de gradient à l'aide des étapes suivantes -

Tout d'abord, commencez par une première estimation de la solution.
Ensuite, prenez le gradient de la fonction à ce point.
Plus tard, répétez le processus en faisant avancer la solution dans le sens négatif du gradient.

En suivant les étapes ci-dessus, l'algorithme finira par converger là où le gradient est nul.

Concept mathématique

Supposons que nous ayons une fonction f(x)et nous essayons de trouver le minimum de cette fonction. Voici les étapes pour trouver le minimum def(x).

Tout d'abord, donnez une valeur initiale $ x_ {0} \: pour \: x $
Prenons maintenant la fonction gradient $ \ nabla f $ ⁡of, avec l'intuition que le gradient donnera la pente de la courbe en x et sa direction indiquera l'augmentation de la fonction, pour trouver la meilleure direction pour la minimiser.
Maintenant changez x comme suit -

$$ x_ {n \: + \: 1} \: = \: x_ {n} \: - \: \ theta \ nabla f (x_ {n}) $$

Ici, θ > 0 est le taux d'entraînement (taille de pas) qui force l'algorithme à faire de petits sauts.

Estimation de la taille des pas

En fait, une taille de pas incorrecte θpeut ne pas atteindre la convergence, par conséquent une sélection minutieuse de la même chose est très importante. Les points suivants doivent être rappelés lors du choix de la taille de pas

Ne choisissez pas une taille de pas trop grande, sinon cela aura un impact négatif, c'est-à-dire qu'il divergera plutôt que de converger.
Ne choisissez pas une taille de pas trop petite, sinon il faut beaucoup de temps pour converger.

Quelques options en ce qui concerne le choix de la taille du pas -

Une option consiste à choisir une taille de pas fixe.
Une autre option consiste à choisir une taille de pas différente pour chaque itération.

Recuit simulé

Le concept de base du recuit simulé (SA) est motivé par le recuit dans les solides. Dans le processus de recuit, si nous chauffons un métal au-dessus de son point de fusion et le refroidissons, les propriétés structurelles dépendront de la vitesse de refroidissement. On peut aussi dire que SA simule le processus métallurgique de recuit.

Utilisation dans ANN

SA est une méthode de calcul stochastique, inspirée de l'analogie du recuit, pour approximer l'optimisation globale d'une fonction donnée. Nous pouvons utiliser SA pour former des réseaux de neurones à réaction directe.

Algorithme

Step 1 - Générez une solution aléatoire.

Step 2 - Calculez son coût en utilisant une fonction de coût.

Step 3 - Générer une solution voisine aléatoire.

Step 4 - Calculez le coût de la nouvelle solution par la même fonction de coût.

Step 5 - Comparez le coût d'une nouvelle solution avec celui d'une ancienne solution comme suit -

Si Cost_{New Solution} < Cost_{Old Solution} puis passez à la nouvelle solution.

Step 6 - Tester la condition d'arrêt, qui peut être le nombre maximum d'itérations atteint ou obtenir une solution acceptable.

La nature a toujours été une grande source d'inspiration pour toute l'humanité. Les algorithmes génétiques (AG) sont des algorithmes basés sur la recherche basés sur les concepts de sélection naturelle et de génétique. Les GA sont un sous-ensemble d'une branche beaucoup plus vaste du calcul connue sous le nom deEvolutionary Computation.

GAs a été développé par John Holland et ses étudiants et collègues de l'Université du Michigan, notamment David E. Goldberg et a depuis été essayé sur divers problèmes d'optimisation avec un haut degré de succès.

Dans les AG, nous avons un pool ou une population de solutions possibles au problème donné. Ces solutions subissent ensuite une recombinaison et une mutation (comme dans la génétique naturelle), produisant de nouveaux enfants, et le processus se répète sur différentes générations. Chaque individu (ou solution candidate) se voit attribuer une valeur de fitness (basée sur sa valeur de fonction objective) et les individus en meilleure forme ont une plus grande chance de s'accoupler et de produire des individus plus «en forme». Ceci est conforme à la théorie darwinienne de la «survie du plus apte».

De cette façon, nous continuons à «faire évoluer» de meilleurs individus ou solutions au fil des générations, jusqu'à ce que nous atteignions un critère d'arrêt.

Les algorithmes génétiques sont de nature suffisamment aléatoire, mais ils fonctionnent bien mieux que la recherche locale aléatoire (dans laquelle nous essayons simplement diverses solutions aléatoires, en gardant une trace des meilleures à ce jour), car ils exploitent également les informations historiques.

Avantages des AG

Les AG présentent divers avantages qui les ont rendus extrêmement populaires. Ceux-ci comprennent -

Ne nécessite aucune information dérivée (qui peut ne pas être disponible pour de nombreux problèmes du monde réel).
Est plus rapide et plus efficace par rapport aux méthodes traditionnelles.
Possède de très bonnes capacités parallèles.
Optimise les fonctions continues et discrètes ainsi que les problèmes multi-objectifs.
Fournit une liste de «bonnes» solutions et pas seulement une solution unique.
Obtient toujours une réponse au problème, qui s'améliore avec le temps.
Utile lorsque l'espace de recherche est très grand et qu'un grand nombre de paramètres sont impliqués.

Limitations des GA

Comme toute technique, les GA souffrent également de quelques limitations. Ceux-ci comprennent -

Les GA ne conviennent pas à tous les problèmes, en particulier aux problèmes simples et pour lesquels des informations dérivées sont disponibles.
La valeur de la forme physique est calculée à plusieurs reprises, ce qui peut être coûteux en calcul pour certains problèmes.
Being stochastic, there are no guarantees on the optimality or the quality of the solution.
If not implemented properly, GA may not converge to the optimal solution.

GA – Motivation

Genetic Algorithms have the ability to deliver a “good-enough” solution “fast-enough”. This makes Gas attractive for use in solving optimization problems. The reasons why GAs are needed are as follows −

Solving Difficult Problems

In computer science, there is a large set of problems, which are NP-Hard. What this essentially means is that, even the most powerful computing systems take a very long time (even years!) to solve that problem. In such a scenario, GAs prove to be an efficient tool to provide usable near-optimal solutions in a short amount of time.

Failure of Gradient Based Methods

Traditional calculus based methods work by starting at a random point and by moving in the direction of the gradient, till we reach the top of the hill. This technique is efficient and works very well for single-peaked objective functions like the cost function in linear regression. However, in most real-world situations, we have a very complex problem called as landscapes, made of many peaks and many valleys, which causes such methods to fail, as they suffer from an inherent tendency of getting stuck at the local optima as shown in the following figure.

Getting a Good Solution Fast

Some difficult problems like the Travelling Salesman Problem (TSP), have real-world applications like path finding and VLSI Design. Now imagine that you are using your GPS Navigation system, and it takes a few minutes (or even a few hours) to compute the “optimal” path from the source to destination. Delay in such real-world applications is not acceptable and therefore a “good-enough” solution, which is delivered “fast” is what is required.

How to Use GA for Optimization Problems?

We already know that optimization is an action of making something such as design, situation, resource, and system as effective as possible. Optimization process is shown in the following diagram.

Stages of GA Mechanism for Optimization Process

Followings are the stages of GA mechanism when used for optimization of problems.

Generate the initial population randomly.
Select the initial solution with the best fitness values.
Recombine the selected solutions using mutation and crossover operators.
Insert offspring into the population.
Now if the stop condition is met, then return the solution with their best fitness value. Else, go to step 2.

Before studying the fields where ANN has been used extensively, we need to understand why ANN would be the preferred choice of application.

Why Artificial Neural Networks?

We need to understand the answer to the above question with an example of a human being. As a child, we used to learn the things with the help of our elders, which includes our parents or teachers. Then later by self-learning or practice we keep learning throughout our life. Scientists and researchers are also making the machine intelligent, just like a human being, and ANN plays a very important role in the same due to the following reasons −

With the help of neural networks, we can find the solution of such problems for which algorithmic method is expensive or does not exist.
Neural networks can learn by example, hence we do not need to program it at much extent.
Neural networks have the accuracy and significantly fast speed than conventional speed.

Areas of Application

Followings are some of the areas, where ANN is being used. It suggests that ANN has an interdisciplinary approach in its development and applications.

Speech Recognition

Speech occupies a prominent role in human-human interaction. Therefore, it is natural for people to expect speech interfaces with computers. In the present era, for communication with machines, humans still need sophisticated languages which are difficult to learn and use. To ease this communication barrier, a simple solution could be, communication in a spoken language that is possible for the machine to understand.

Great progress has been made in this field, however, still such kinds of systems are facing the problem of limited vocabulary or grammar along with the issue of retraining of the system for different speakers in different conditions. ANN is playing a major role in this area. Following ANNs have been used for speech recognition −

Multilayer networks
Multilayer networks with recurrent connections
Kohonen self-organizing feature map

The most useful network for this is Kohonen Self-Organizing feature map, which has its input as short segments of the speech waveform. It will map the same kind of phonemes as the output array, called feature extraction technique. After extracting the features, with the help of some acoustic models as back-end processing, it will recognize the utterance.

Character Recognition

It is an interesting problem which falls under the general area of Pattern Recognition. Many neural networks have been developed for automatic recognition of handwritten characters, either letters or digits. Following are some ANNs which have been used for character recognition −

Multilayer neural networks such as Backpropagation neural networks.
Neocognitron

Though back-propagation neural networks have several hidden layers, the pattern of connection from one layer to the next is localized. Similarly, neocognitron also has several hidden layers and its training is done layer by layer for such kind of applications.

Signature Verification Application

Signatures are one of the most useful ways to authorize and authenticate a person in legal transactions. Signature verification technique is a non-vision based technique.

For this application, the first approach is to extract the feature or rather the geometrical feature set representing the signature. With these feature sets, we have to train the neural networks using an efficient neural network algorithm. This trained neural network will classify the signature as being genuine or forged under the verification stage.

Human Face Recognition

It is one of the biometric methods to identify the given face. It is a typical task because of the characterization of “non-face” images. However, if a neural network is well trained, then it can be divided into two classes namely images having faces and images that do not have faces.

First, all the input images must be preprocessed. Then, the dimensionality of that image must be reduced. And, at last it must be classified using neural network training algorithm. Following neural networks are used for training purposes with preprocessed image −

Fully-connected multilayer feed-forward neural network trained with the help of back-propagation algorithm.
For dimensionality reduction, Principal Component Analysis (PCA) is used.

Next page ↱