Breve descrição
Com o rápido desenvolvimento da Internet, a (ai) B (bigdata) C (nuvem) tornou -se a direção principal do desenvolvimento atualmente. Se os três são profundamente combinados, a IA é a parte mais central dela. Portanto, se todos precisam aprender a programação na sociedade futura, para programadores, a inteligência artificial é a tecnologia que eles devem dominar (o desenvolvimento da tecnologia é muito rápido).
Este artigo apresenta e usa o Java para implementar uma rede de perceptron mais simples, sem enrolar com derivação de fórmula, com o objetivo de fornecer idéias para aprender redes neurais e ter um entendimento difícil das redes neurais.
Análise do modelo de rede perceptron
Primeiro olhe para uma foto
Se você está um pouco interessado em redes neurais, deve estar familiarizado com esta imagem. Esta imagem é um diagrama estrutural de neurônios
X1 ~ XM representa a entrada, W1 ~ Wm representa o peso sináptico, σ representa o nó de somando, a função de ativação representa a função de ativação e, em seguida, sai um resultado. O processo específico é
Quando o neurônio recebe a entrada, cada entrada será multiplicada pelo peso em seu caminho relativo. Quando o nó de soma é atingido, o resultado do nó de soma é definido como z:
z = x1 * w1 + x2 * w2 + x3 * w3 + ...... + xm * wm
Em seguida, passe Z para a função de ativação (aqui chamamos a função de ativação F) para reconhecimento de padrões binários:
Se f (x)> e, y = 1else y = -1e é o limiar y é o resultado da classificação
Pode -se ver aqui que, se o valor de f (x) for maior que o limite, a classificação y = 1 é obtida e vice -versa y = -1
Nota: Comparado à resposta indicada pela estimulação dos neurônios biológicos, se a estimulação estiver dentro de uma faixa aceitável, o neurônio inibirá a estimulação (y = -1) e, se exceder o intervalo, será excitada (y = 1), e a bacia hidrográfica desse intervalo for o limite (e)
estudar
Descobrimos que, se o peso e o limiar forem fixos, essa rede neural não tem significado. Portanto, introduzimos o conceito de aprendizado e deixamos a rede neural modificar o peso e o limiar através do aprendizado, para que a precisão do reconhecimento de padrões possa ser corrigida dinamicamente. Esta é a essência do aprendizado de máquina.
Então, como aprender? Antes de usá -lo, precisamos fornecer um conjunto de dados de amostra a essa rede (que é levada aqui para aprender com o modo de professor), os dados da amostra incluem dados de entrada x e resultado de identificação correta y '.
Quando inserimos dados de treinamento x e obtemos reconhecimento de padrões y, se y! = Y ', o peso e o limiar dessa rede serão ajustados. Consulte a fórmula para ajuste. μ representa a taxa de aprendizado (taxa de correção) e a atualização representa a necessidade de ser corrigida:
atualização = μ * (yi - y ') update = (f (x) - y') Mav wi += atualização * xii = 1e += atualização
Quando o resultado da classificação do perceptron é igual à classificação correta, atualização = 0, e a rede não é ajustada; Se não for igual à classificação correta, todos os pesos (w) e limiares (e) serão ajustados
O exposto acima é o processo de aprendizado mais simples para perceptrons que introduzi:
Digite os dados -> Resumindo para obter z-> aguarde a função de ativação para aguardar os resultados da classificação -> Resultados da classificação não correspondem aos resultados corretos, ajuste a rede
Vamos implementar esta rede neural simples
Implementação de código Java
O que implementei aqui é aprender a reconhecer o positivo e o negativo dos números inteiros por meio de redes neurais. Primeiro, defina uma classe que define primeiro um perceptron.
/*** Criado por Cimzzz em 02/12/17. **/classe pública perceptron {/*** Taxa de aprendizagem*/private Final Float LearnRate; / *** Número de tempos de aprendizagem*/ private final int studyCount; / *** limiar*/ flutuação privada e; / *** Peso* Como apenas uma entrada é necessária para determinar o número inteiro positivo e negativo, há apenas um peso aqui e várias entradas podem ser definidas como uma matriz*/ flutuação privada w; / *** Taxa correta para cada aprendizado*/ float privado [] CORRATRATE; /// ** * Construtor inicializa a taxa de aprendizagem, o número de tempos de aprendizagem, o peso e o limite são inicializados para 0 * @param LearnRate Taxa de aprendizagem (faixa de valor 0 <LearnRate <1) * @param studyCount Número de tempos de aprendizagem */ public perceptron (float LearnRate, int studycount) {this.learnrate = learnrate; this.studyCount = studyCount; this.e = 0; this.w = 0; this.Cortrate = New Float [StudyCount]; } / *** Função de aprendizagem, as amostras são uma matriz bidimensional contendo dados de entrada e resultados de classificação,* amostras [] [0] representa dados de entrada* amostras [] [1] Representa resultados de classificação corretos* @param amostras de treinamento dados* / public void fit (int [] [] amostras) {Int SamplELngthngmen for (int i = 0; i <studyCount; i ++) {int errorCount = 0; para (int [] amostra: amostras) {float update = LearnRate * (amostra [1] -Predict (amostra [0])); // Atualize o peso e o limite w += atualização * amostra [0]; e += atualização; // Calcule o número do erro se (atualização! = 0) ErrorCount ++; } // Calcule a correção desse aprendizado corretamente [i] = 1 - ErrorCount * 1.0f /sampleLength; }} / *** Função da soma, simule os dados de entrada do nó de soma* peso* @param num Dados de entrada* @return soma resultado z* / soma de flutuação privada (int num) {return num* w + e; } / *** Ative a função, julgue resumindo o resultado Z e o limite e* @param num Data de entrada* @return Classification Result* / public int previst (int num) {retorna soma (num)> = 0? 1: -1; }/*** Print Precisão*/public void PrintCorcretrate () {for (int i = 0; i <studyCount; i ++) system.out.printf ("resultado do aprendizado em %d-> %.2f %%/n", i +1, correrato [i]* 100); }}Em seguida, escreva a função que gera os dados de treinamento
/*** Gere dados de treinamento* @return Training Data*/private static int [] [] GenStudyData () {// Aqui tomamos um número inteiro entre -100 e 100, e se maior que 0, defina -o para o modo y = 1, caso contrário, y = -1 int [] [] data = new int [201] [2]; for (int i = -100, j = 0; i <= 100; i ++, j ++) {data [j] [0] = i; dados [j] [1] = i> = 0? 1: -1; } retornar dados; } /*** Gere dados de treinamento* Dados de treinamento @return* /private static int [] [] GenStudyData2 () {// Aqui pegamos um número inteiro entre 1 ~ 250 e, se maior que 125, defina -o para o modo y = 1, caso contrário, y = -1 int [] dados = novo int [250] [2]; for (int i = 1, j = 0; i <= 250; i ++, j ++) {data [j] [0] = i; dados [j] [1] = i> = 125? 1: -1; } retornar dados; }Finalmente, a função principal
public static void main (string [] args) {// A taxa de aprendizado e os tempos de treinamento aqui podem ser ajustados manualmente de acordo com a situação perceptron perceptron = novo perceptron (0,4F, 500); perceptron.fit (GenStudyData ()); perceptron.printCortractRetrate (); System.out.println (perceptron.predict (-1)); System.out.println (perceptron.predict (126)); }Você pode testá -lo
limitação
Essa rede neural perceptron é relativamente simples e é adequada para dados divididos linearmente, como números positivos e negativos na classificação unidimensional e de coordenadas bidimensionais; Dados que não podem ser classificados corretamente não podem ser classificados, como encontrar números primos, etc.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.