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