Aprendizagem Supervisionada

Como o nome sugere, supervised learningocorre sob a supervisão de um professor. Este processo de aprendizagem é dependente. Durante o treinamento da RNA sob aprendizagem supervisionada, o vetor de entrada é apresentado à rede, que produzirá um vetor de saída. Este vetor de saída é comparado com o vetor de saída desejado / alvo. Um sinal de erro é gerado se houver uma diferença entre a saída real e o vetor de saída desejado / alvo. Com base nesse sinal de erro, os pesos seriam ajustados até que a saída real fosse combinada com a saída desejada.

Perceptron

Desenvolvido por Frank Rosenblatt usando o modelo de McCulloch e Pitts, o perceptron é a unidade operacional básica de redes neurais artificiais. Ele emprega regra de aprendizado supervisionado e é capaz de classificar os dados em duas classes.

Características operacionais do perceptron: consiste em um único neurônio com um número arbitrário de entradas junto com pesos ajustáveis, mas a saída do neurônio é 1 ou 0 dependendo do limite. Ele também consiste em um viés cujo peso é sempre 1. A figura a seguir fornece uma representação esquemática do perceptron.

Perceptron, portanto, tem os seguintes três elementos básicos -

  • Links - Teria um conjunto de links de conexão, que carrega um peso incluindo um viés sempre tendo peso 1.

  • Adder - Adiciona a entrada depois de multiplicada por seus respectivos pesos.

  • Activation function- Limita a saída do neurônio. A função de ativação mais básica é uma função de etapa de Heaviside que tem duas saídas possíveis. Esta função retorna 1, se a entrada for positiva, e 0 para qualquer entrada negativa.

Algoritmo de treinamento

A rede Perceptron pode ser treinada para uma única unidade de saída, bem como para várias unidades de saída.

Algoritmo de treinamento para unidade de saída única

Step 1 - Inicialize o seguinte para iniciar o treinamento -

  • Weights
  • Bias
  • Taxa de aprendizagem $ \ alpha $

Para facilitar o cálculo e simplicidade, os pesos e o bias devem ser definidos como 0 e a taxa de aprendizado deve ser definida como 1.

Step 2 - Continue a etapa 3-8 quando a condição de parada não for verdadeira.

Step 3 - Continue a etapa 4-6 para cada vetor de treinamento x.

Step 4 - Ative cada unidade de entrada da seguinte forma -

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

Step 5 - Agora obtenha a entrada líquida com a seguinte relação -

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

Aqui ‘b’ é preconceito e ‘n’ é o número total de neurônios de entrada.

Step 6 - Aplique a seguinte função de ativação para obter a saída final.

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

Step 7 - Ajuste o peso e o viés da seguinte forma -

Case 1 - se y ≠ t então,

$$ w_ {i} (novo) \: = \: w_ {i} (antigo) \: + \: \ alpha \: tx_ {i} $$

$$ b (novo) \: = \: b (antigo) \: + \: \ alpha t $$

Case 2 - se y = t então,

$$ w_ {i} (novo) \: = \: w_ {i} (antigo) $$

$$ b (novo) \: = \: b (antigo) $$

Aqui ‘y’ é a saída real e ‘t’ é a saída desejada / alvo.

Step 8 - Teste a condição de parada, que aconteceria quando não houvesse alteração no peso.

Algoritmo de treinamento para várias unidades de saída

O diagrama a seguir é a arquitetura do perceptron para várias classes de saída.

Step 1 - Inicialize o seguinte para iniciar o treinamento -

  • Weights
  • Bias
  • Taxa de aprendizagem $ \ alpha $

Para facilitar o cálculo e simplicidade, os pesos e o bias devem ser definidos como 0 e a taxa de aprendizado deve ser definida como 1.

Step 2 - Continue a etapa 3-8 quando a condição de parada não for verdadeira.

Step 3 - Continue a etapa 4-6 para cada vetor de treinamento x.

Step 4 - Ative cada unidade de entrada da seguinte forma -

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

Step 5 - Obtenha a entrada líquida com a seguinte relação -

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

Aqui ‘b’ é preconceito e ‘n’ é o número total de neurônios de entrada.

Step 6 - Aplique a seguinte função de ativação para obter a saída final para cada unidade de saída 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 {cases} $$

Step 7 - Ajuste o peso e o viés para x = 1 to n e j = 1 to m como segue -

Case 1 - se yj ≠ tj então,

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

$$ b_ {j} (novo) \: = \: b_ {j} (antigo) \: + \: \ alpha t_ {j} $$

Case 2 - se yj = tj então,

$$ w_ {ij} (novo) \: = \: w_ {ij} (antigo) $$

$$ b_ {j} (novo) \: = \: b_ {j} (antigo) $$

Aqui ‘y’ é a saída real e ‘t’ é a saída desejada / alvo.

Step 8 - Teste a condição de parada, que acontecerá quando não houver alteração de peso.

Neurônio Linear Adaptativo (Adalino)

Adaline, que significa Adaptive Linear Neuron, é uma rede com uma única unidade linear. Foi desenvolvido por Widrow e Hoff em 1960. Alguns pontos importantes sobre o Adaline são os seguintes -

  • Ele usa a função de ativação bipolar.

  • Ele usa a regra delta para treinamento para minimizar o erro quadrático médio (MSE) entre a saída real e a saída desejada / alvo.

  • Os pesos e a polarização são ajustáveis.

Arquitetura

A estrutura básica do Adaline é semelhante ao perceptron, tendo um loop de feedback extra com a ajuda do qual a saída real é comparada com a saída desejada / alvo. Após comparação com base no algoritmo de treinamento, os pesos e o viés serão atualizados.

Algoritmo de treinamento

Step 1 - Inicialize o seguinte para iniciar o treinamento -

  • Weights
  • Bias
  • Taxa de aprendizagem $ \ alpha $

Para facilitar o cálculo e simplicidade, os pesos e o bias devem ser definidos como 0 e a taxa de aprendizado deve ser definida como 1.

Step 2 - Continue a etapa 3-8 quando a condição de parada não for verdadeira.

Step 3 - Continue a etapa 4-6 para cada par de treinamento bipolar s:t.

Step 4 - Ative cada unidade de entrada da seguinte forma -

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

Step 5 - Obtenha a entrada líquida com a seguinte relação -

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

Aqui ‘b’ é preconceito e ‘n’ é o número total de neurônios de entrada.

Step 6 - Aplique a seguinte função de ativação para obter a saída final -

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

Step 7 - Ajuste o peso e o viés da seguinte forma -

Case 1 - se y ≠ t então,

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

$$ b (novo) \: = \: b (antigo) \: + \: \ alpha (t \: - \: y_ {in}) $$

Case 2 - se y = t então,

$$ w_ {i} (novo) \: = \: w_ {i} (antigo) $$

$$ b (novo) \: = \: b (antigo) $$

Aqui ‘y’ é a saída real e ‘t’ é a saída desejada / alvo.

$ (t \: - \; y_ {in}) $ é o erro calculado.

Step 8 - Teste para condição de parada, que acontecerá quando não houver mudança de peso ou a maior mudança de peso ocorrida durante o treinamento for menor do que a tolerância especificada.

Neurônio Linear Adaptativo Múltiplo (Madaline)

Madaline, que significa Multiple Adaptive Linear Neuron, é uma rede que consiste em muitos Adalines em paralelo. Terá uma única unidade de saída. Alguns pontos importantes sobre Madaline são os seguintes -

  • É como um perceptron multicamadas, onde Adaline atuará como uma unidade oculta entre a entrada e a camada Madaline.

  • Os pesos e a polarização entre as camadas de entrada e Adaline, como vemos na arquitetura Adaline, são ajustáveis.

  • As camadas Adaline e Madaline têm pesos fixos e viés de 1.

  • O treinamento pode ser feito com a ajuda da regra Delta.

Arquitetura

A arquitetura de Madaline consiste em “n” neurônios da camada de entrada, “m”neurônios da camada Adalina e 1 neurônio da camada Madalina. A camada Adaline pode ser considerada como a camada oculta, pois está entre a camada de entrada e a camada de saída, ou seja, a camada Madaline.

Algoritmo de treinamento

Por enquanto sabemos que apenas os pesos e a polarização entre a entrada e a camada Adaline devem ser ajustados, e os pesos e a polarização entre a Adaline e a camada Madaline são fixos.

Step 1 - Inicialize o seguinte para iniciar o treinamento -

  • Weights
  • Bias
  • Taxa de aprendizagem $ \ alpha $

Para facilitar o cálculo e simplicidade, os pesos e o bias devem ser definidos como 0 e a taxa de aprendizado deve ser definida como 1.

Step 2 - Continue a etapa 3-8 quando a condição de parada não for verdadeira.

Step 3 - Continue a etapa 4-6 para cada par de treinamento bipolar s:t.

Step 4 - Ative cada unidade de entrada da seguinte forma -

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

Step 5 - Obtenha a entrada líquida em cada camada oculta, ou seja, a camada Adaline com a seguinte relação -

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

Aqui ‘b’ é preconceito e ‘n’ é o número total de neurônios de entrada.

Step 6 - Aplicar a seguinte função de ativação para obter a saída final na camada Adaline e Madaline -

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

Saída na unidade oculta (Adaline)

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

Resultado final da rede

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

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

Step 7 - Calcule o erro e ajuste os pesos da seguinte forma -

Case 1 - se y ≠ t e t = 1 então,

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

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

Neste caso, os pesos seriam atualizados em Qj onde a entrada líquida é próxima de 0 porque t = 1.

Case 2 - se y ≠ t e t = -1 então,

$$ w_ {ik} (novo) \: = \: w_ {ik} (antigo) \: + \: \ alpha (-1 \: - \: Q_ {tinta}) x_ {i} $$

$$ b_ {k} (novo) \: = \: b_ {k} (antigo) \: + \: \ alpha (-1 \: - \: Q_ {tinta}) $$

Neste caso, os pesos seriam atualizados em Qk onde a entrada líquida é positiva porque t = -1.

Aqui ‘y’ é a saída real e ‘t’ é a saída desejada / alvo.

Case 3 - se y = t então

Não haveria mudança nos pesos.

Step 8 - Teste para condição de parada, que acontecerá quando não houver mudança de peso ou a maior mudança de peso ocorrida durante o treinamento for menor do que a tolerância especificada.

Redes Neurais de Retropropagação

Back Propagation Neural (BPN) é uma rede neural multicamadas que consiste na camada de entrada, pelo menos uma camada oculta e a camada de saída. Como o próprio nome sugere, a retropropagação ocorrerá nesta rede. O erro que é calculado na camada de saída, comparando a saída de destino e a saída real, será propagado de volta para a camada de entrada.

Arquitetura

Conforme mostrado no diagrama, a arquitetura do BPN possui três camadas interconectadas com pesos sobre elas. A camada oculta, assim como a camada de saída, também possui viés, cujo peso é sempre 1, sobre elas. Como fica claro no diagrama, o funcionamento do BPN está em duas fases. Uma fase envia o sinal da camada de entrada para a camada de saída e a outra fase propaga de volta o erro da camada de saída para a camada de entrada.

Algoritmo de treinamento

Para o treinamento, o BPN usará a função de ativação sigmóide binária. A formação do BPN terá as três fases seguintes.

  • Phase 1 - Fase de Feed Forward

  • Phase 2 - Retropropagação de erro

  • Phase 3 - Atualização de pesos

Todas essas etapas serão concluídas no algoritmo da seguinte forma

Step 1 - Inicialize o seguinte para iniciar o treinamento -

  • Weights
  • Taxa de aprendizagem $ \ alpha $

Para fácil cálculo e simplicidade, use alguns pequenos valores aleatórios.

Step 2 - Continue a etapa 3-11 quando a condição de parada não for verdadeira.

Step 3 - Continue a etapa 4-10 para cada par de treinamento.

Fase 1

Step 4 - Cada unidade de entrada recebe um sinal de entrada xi e envia para a unidade oculta para todos i = 1 to n

Step 5 - Calcule a entrada líquida na unidade oculta usando a seguinte relação -

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

Aqui b0j é o preconceito na unidade oculta, vij é o peso sobre j unidade da camada oculta proveniente de i unidade da camada de entrada.

Agora calcule a saída líquida aplicando a seguinte função de ativação

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

Envie esses sinais de saída das unidades da camada oculta para as unidades da camada de saída.

Step 6 - Calcule a entrada líquida na unidade da camada de saída usando a seguinte relação -

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

Aqui b0k Este é o viés na unidade de saída, wjk é o peso sobre k unidade da camada de saída proveniente de j unidade da camada oculta.

Calcule a saída líquida aplicando a seguinte função de ativação

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

Fase 2

Step 7 - Calcule o termo de correção de erro, em correspondência com o padrão de destino recebido em cada unidade de saída, como segue -

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

Com base nisso, atualize o peso e o viés da seguinte forma -

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

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

Então, envie $ \ delta_ {k} $ de volta para a camada oculta.

Step 8 - Agora, cada unidade oculta será a soma de suas entradas delta das unidades de saída.

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

O termo de erro pode ser calculado da seguinte forma -

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

Com base nisso, atualize o peso e o viés da seguinte forma -

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

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

Fase 3

Step 9 - Cada unidade de saída (ykk = 1 to m) atualiza o peso e o viés da seguinte forma -

$$ v_ {jk} (novo) \: = \: v_ {jk} (antigo) \: + \: \ Delta v_ {jk} $$

$$ b_ {0k} (novo) \: = \: b_ {0k} (antigo) \: + \: \ Delta b_ {0k} $$

Step 10 - Cada unidade de saída (zjj = 1 to p) atualiza o peso e o viés da seguinte forma -

$$ w_ {ij} (novo) \: = \: w_ {ij} (antigo) \: + \: \ Delta w_ {ij} $$

$$ b_ {0j} (novo) \: = \: b_ {0j} (antigo) \: + \: \ Delta b_ {0j} $$

Step 11 - Verifique a condição de parada, que pode ser o número de épocas alcançadas ou a saída de destino corresponde à saída real.

Regra de aprendizagem Delta generalizada

A regra delta funciona apenas para a camada de saída. Por outro lado, regra delta generalizada, também chamada deback-propagation regra, é uma forma de criar os valores desejados da camada oculta.

Formulação Matemática

Para a função de ativação $ y_ {k} \: = \: f (y_ {tinta}) $ a derivação da entrada líquida na camada Oculta, bem como na camada de saída pode ser dada por

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

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

Agora, o erro que deve ser minimizado é

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

Ao usar a regra da cadeia, temos

$$ \ 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_ {tinta}) \ frac {\ parcial} {\ parcial w_ {jk}} (y_ {tinta}) $$

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

Agora vamos dizer $ \ delta_ {k} \: = \: - [t_ {k} \: - \: y_ {k}] f ^ {'} (y_ {tinta}) $

Os pesos nas conexões com a unidade oculta zj pode ser dado por -

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

Colocando o valor de $ y_ {ink} $ obteremos o seguinte

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

A atualização do peso pode ser feita da seguinte forma -

Para a unidade de saída -

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

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

Para a unidade oculta -

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

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