Quantização de vetores de aprendizagem

Learning Vector Quantization (LVQ), diferente da Vector quantization (VQ) e Kohonen Self-Organizing Maps (KSOM), é basicamente uma rede competitiva que utiliza aprendizagem supervisionada. Podemos defini-lo como um processo de classificação dos padrões em que cada unidade de saída representa uma classe. Por usar aprendizado supervisionado, a rede receberá um conjunto de padrões de treinamento com classificação conhecida junto com uma distribuição inicial da classe de saída. Depois de completar o processo de treinamento, LVQ classificará um vetor de entrada atribuindo-o à mesma classe da unidade de saída.

Arquitetura

A figura a seguir mostra a arquitetura do LVQ, que é bastante semelhante à arquitetura do KSOM. Como podemos ver, existem“n” número de unidades de entrada e “m”número de unidades de saída. As camadas estão totalmente interconectadas com pesos sobre elas.

Parâmetros Usados

A seguir estão os parâmetros usados ​​no processo de treinamento LVQ, bem como no fluxograma

  • x= vetor de treinamento (x 1 , ..., x i , ..., x n )

  • T = classe para vetor de treinamento x

  • wj = vetor de peso para jth unidade de saída

  • Cj = classe associada ao jth unidade de saída

Algoritmo de treinamento

Step 1 - Inicialize os vetores de referência, o que pode ser feito da seguinte maneira -

  • Step 1(a) - A partir de um determinado conjunto de vetores de treinamento, pegue o primeiro “m”(Número de clusters) vetores de treinamento e usá-los como vetores de peso. Os vetores restantes podem ser usados ​​para treinamento.

  • Step 1(b) - Atribuir o peso inicial e classificação aleatoriamente.

  • Step 1(c) - Aplicar o método de agrupamento K-means.

Step 2 - Inicializar vetor de referência $ \ alpha $

Step 3 - Continue com os passos 4-9, se a condição para parar este algoritmo não for atendida.

Step 4 - Siga as etapas 5 a 6 para cada vetor de entrada de treinamento x.

Step 5 - Calcular o quadrado da distância euclidiana para j = 1 to m e 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 - Obtenha a unidade vencedora J Onde D(j) é mínimo.

Step 7 - Calcule o novo peso da unidade vencedora pela seguinte relação -

E se T = Cj então $ w_ {j} (novo) \: = \: w_ {j} (antigo) \: + \: \ alpha [x \: - \: w_ {j} (antigo)] $

E se T ≠ Cj então $ w_ {j} (novo) \: = \: w_ {j} (antigo) \: - \: \ alpha [x \: - \: w_ {j} (antigo)] $

Step 8 - Reduza a taxa de aprendizagem $ \ alpha $.

Step 9- Teste a condição de parada. Pode ser o seguinte -

  • Número máximo de épocas atingido.
  • Taxa de aprendizagem reduzida a um valor insignificante.

Fluxograma

Variantes

Três outras variantes, nomeadamente LVQ2, LVQ2.1 e LVQ3, foram desenvolvidas por Kohonen. A complexidade em todas essas três variantes, devido ao conceito de que tanto a unidade vencedora quanto a segunda colocada aprenderão, é maior do que em LVQ.

LVQ2

Conforme discutido, o conceito de outras variantes de LVQ acima, a condição de LVQ2 é formada por janela. Esta janela será baseada nos seguintes parâmetros -

  • x - o vetor de entrada atual

  • yc - o vetor de referência mais próximo de x

  • yr - o outro vetor de referência, que é o próximo mais próximo de x

  • dc - a distância de x para yc

  • dr - a distância de x para yr

O vetor de entrada x cai na janela, se

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

Aqui, $ \ theta $ é o número de amostras de treinamento.

A atualização pode ser feita com a seguinte fórmula -

$ 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)

Aqui $ \ alpha $ é a taxa de aprendizagem.

LVQ2.1

Em LVQ2.1, tomaremos os dois vetores mais próximos, a saber yc1 e yc2 e a condição da janela é a seguinte -

$$ 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) $$

A atualização pode ser feita com a seguinte fórmula -

$ 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)

Aqui, $ \ alpha $ é a taxa de aprendizado.

LVQ3

Em LVQ3, tomaremos os dois vetores mais próximos, a saber yc1 e yc2 e a condição da janela é a seguinte -

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

Aqui $ \ theta \ approx 0.2 $

A atualização pode ser feita com a seguinte fórmula -

$ 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)

Aqui $ \ beta $ é o múltiplo da taxa de aprendizagem $ \ alpha $ e $\beta\:=\:m \alpha(t)$ para cada 0.1 < m < 0.5