Quantification vectorielle d'apprentissage

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 d'apprentissage 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