Como treinar uma rede neural Perceptron básica

Este artigo apresenta o código Python que permite gerar pesos automaticamente para uma rede neural simples.

Bem-vindo à série da AAC sobre redes neurais Perceptron. Se você deseja começar do início para obter um segundo plano ou avançar, verifique o restante dos artigos aqui:

1. Como realizar a classificação usando uma rede neural:o que é o Perceptron?
2. Como usar um exemplo de rede neural simples Perceptron para classificar dados
3. Como treinar uma rede neural Perceptron básica
4. Compreendendo o treinamento de rede neural simples
5. Uma introdução à teoria de treinamento para redes neurais
6. Compreendendo a taxa de aprendizagem em redes neurais
7. Aprendizado de máquina avançado com o Multilayer Perceptron
8. A função de ativação sigmóide:ativação em redes neurais multicamadas Perceptron
9. Como treinar uma rede neural multicamadas Perceptron
10. Noções básicas sobre fórmulas de treinamento e retropropagação para percepções multicamadas
11. Arquitetura de rede neural para uma implementação Python
12. Como criar uma rede neural multicamadas Perceptron em Python
13. Processamento de sinais usando redes neurais:validação no projeto de redes neurais
14. Conjuntos de dados de treinamento para redes neurais:como treinar e validar uma rede neural Python

Classificação com uma percepção de camada única

O artigo anterior apresentou uma tarefa de classificação direta que examinamos da perspectiva do processamento de sinal baseado em rede neural. A relação matemática necessária para essa tarefa era tão simples que consegui projetar a rede apenas pensando em como um determinado conjunto de pesos permitiria ao nó de saída categorizar corretamente os dados de entrada.

Esta é a rede que projetei:

A função de ativação no nó de saída é a etapa da unidade:

\ [f (x) =\ begin {cases} 0 &x <0 \\ 1 &x \ geq 0 \ end {cases} \]



A discussão ficou um pouco mais interessante quando apresentei uma rede que criava seus próprios pesos por meio do procedimento conhecido como treinamento:

No restante deste artigo, examinaremos o código Python que usei para obter esses pesos.

Uma rede neural Python

Aqui está o código:

 importar pandas importar numpy como np input_dim =3 learning_rate =0,01 Pesos =np.random.rand (input_dim) #Weights [0] =0,5 #Weights [1] =0,5 #Weights [2] =0,5 Training_Data =pandas.read_excel ("3D_data.xlsx") Expected_Output =Training_Data.output Training_Data =Training_Data.drop (['output'], axis =1) Training_Data =np.asarray (Training_Data) training_count =len (Training_Data [:, 0]) para época no intervalo (0,5):para dados no intervalo (0, training_count):Output_Sum =np.sum (np.multiply (Training_Data [datum ,:], Pesos)) se Output_Sum <0:Output_Value =0 senão:Output_Value =1 erro =Expected_Output [datum] - Output_Value para n no intervalo (0, input_dim):Pesos [n] =Pesos [n] + learning_rate * erro * Training_Data [datum, n] print ("w_0 =% .3f"% (Pesos [0])) print ("w_1 =% .3f"% (Pesos [1])) print ("w_2 =% .3f"% (Pesos [2])) 

Vamos dar uma olhada nessas instruções.

Configurando a rede e organizando dados

 input_dim =3 

A dimensionalidade é ajustável. Nossos dados de entrada, se você se lembra, consistem em coordenadas tridimensionais, portanto, precisamos de três nós de entrada. Este programa não suporta vários nós de saída, mas vamos incorporar dimensionalidade de saída ajustável em um experimento futuro.

 learning_rate =0,01 

Discutiremos a taxa de aprendizagem em um artigo futuro.

 Pesos =np.random.rand (input_dim) #Weights [0] =0,5 #Weights [1] =0,5 #Weights [2] =0,5 

Os pesos são normalmente inicializados com valores aleatórios. A função numpy random.rand () gera uma matriz de comprimento input_dim preenchido com valores aleatórios distribuídos ao longo do intervalo [0, 1). No entanto, os valores de peso inicial influenciam os valores de peso final produzidos pelo procedimento de treinamento, então se você quiser avaliar os efeitos de outras variáveis ​​(como tamanho do conjunto de treinamento ou taxa de aprendizagem), você pode remover este fator de confusão configurando todos os pesos para uma constante conhecida em vez de um número gerado aleatoriamente.

 Training_Data =pandas.read_excel ("3D_data.xlsx") 

Eu uso a biblioteca do pandas para importar dados de treinamento de uma planilha do Excel. O próximo artigo entrará em mais detalhes sobre os dados de treinamento.

 Expected_Output =Training_Data.output Training_Data =Training_Data.drop (['output'], axis =1) 

O conjunto de dados de treinamento inclui valores de entrada e valores de saída correspondentes. A primeira instrução separa os valores de saída e os armazena em uma matriz separada, e a próxima instrução remove os valores de saída do conjunto de dados de treinamento.

 Training_Data =np.asarray (Training_Data) training_count =len (Training_Data [:, 0]) 

Eu converto o conjunto de dados de treinamento, que atualmente é uma estrutura de dados do pandas, em uma matriz numpy e, em seguida, examino o comprimento de uma das colunas para determinar quantos pontos de dados estão disponíveis para treinamento.

Calculando valores de saída

 para época no intervalo (0,5):

A duração de uma sessão de treinamento é determinada pelo número de dados de treinamento disponíveis. No entanto, você pode continuar otimizando os pesos treinando a rede várias vezes usando o mesmo conjunto de dados - os benefícios do treinamento não desaparecem simplesmente porque a rede já viu esses dados de treinamento. Cada passagem completa por todo o conjunto de treinamento é chamada de época.

 para datum no intervalo (0, training_count):

O procedimento contido neste loop ocorre uma vez para cada linha no conjunto de treinamento, onde "linha" se refere a um grupo de valores de dados de entrada e o valor de saída correspondente (em nosso caso, um grupo de entrada consiste em três números que representam x, y e componentes z de um ponto no espaço tridimensional).

 Output_Sum =np.sum (np.multiply (Training_Data [datum ,:], Pesos)) 

O nó de saída deve somar os valores entregues pelos três nós de entrada. Minha implementação Python faz isso executando primeiro uma multiplicação de elementos do array Training_Data e os Pesos matriz e, em seguida, calculando a soma dos elementos na matriz produzida por essa multiplicação.

 se Output_Sum <0:Output_Value =0 senão:Output_Value =1 

Uma instrução if-else aplica a função de ativação de etapa da unidade:se a soma for menor que zero, o valor gerado pelo nó de saída é 0; se a soma for igual ou maior que zero, o valor de saída é um.

Atualizando pesos

Quando o primeiro cálculo de saída é concluído, temos valores de peso, mas eles não nos ajudam a alcançar a classificação porque são gerados aleatoriamente. Transformamos a rede neural em um sistema de classificação eficaz, modificando repetidamente os pesos de forma que reflitam gradualmente a relação matemática entre os dados de entrada e os valores de saída desejados. A modificação de peso é realizada aplicando a seguinte regra de aprendizagem para cada linha no conjunto de treinamento:

\ [w_ {new} =w + (\ alpha \ times (output_ {esperado} -output_ {calculado}) \ times input) \]



O símbolo \ (\ alpha \) denota a taxa de aprendizagem. Assim, para calcular um novo valor de peso, multiplicamos o valor de entrada correspondente pela taxa de aprendizagem e pela diferença entre a saída esperada (que é fornecida pelo conjunto de treinamento) e a saída calculada, e então o resultado desta multiplicação é adicionado para o valor de peso atual. Se definirmos delta ( \ (\ delta \) ) como (\ (output_ {esperado} - output_ {calculado} \)), podemos reescrever isso como

\ [w_ {new} =w + (\ alpha \ times \ delta \ times input) \]



É assim que implementei a regra de aprendizado em Python:

 erro =Expected_Output [datum] - Output_Value para n no intervalo (0, input_dim):Pesos [n] =Pesos [n] + learning_rate * erro * Training_Data [datum, n] 

Conclusão

Agora você tem código que pode usar para treinar um Perceptron de camada única e nó de saída única. Exploraremos mais detalhes sobre a teoria e a prática do treinamento de redes neurais no próximo artigo.