Perceptron

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Question book.svg
Esta página ou secção não cita fontes confiáveis e independentes, o que compromete sua credibilidade (desde maio de 2010). Por favor, adicione referências e insira-as corretamente no texto ou no rodapé. Conteúdo sem fontes poderá ser removido.
Encontre fontes: Google (notícias, livros e acadêmico)

O perceptron é um tipo de rede neural artificial inventada em 1957 no Cornell Aeronautical Laboratory por Frank Rosenblatt. Ele pode ser visto como o tipo mais simples de rede neural feedforward: um classificador linear.

Definição[editar | editar código-fonte]

O perceptron é um classificador binário que mapeia sua entrada (um vetor de valor real) para um valor de saída (uma valor binário simples) através da matriz.

Onde é um vetor de peso real e é o produto escalar (que computa uma soma com pesos). é a 'inclinação', um termo constante que não depende de qualquer valor de entrada.

Implementação em C#[editar | editar código-fonte]

  1  using System;
  2 using System.Linq;
  3 
  4 namespace perceptron
  5 {
  6     public class Perceptron
  7     {
  8         static readonly double[] w = new double[3];
  9         private readonly int[,] _matrizAprendizado = new int[4, 3];
 10         private double _net;
 11 
 12         Perceptron()
 13         {
 14              //tabela AND
 15             _matrizAprendizado[0, 0] = 0;
 16             _matrizAprendizado[0, 1] = 0;
 17             _matrizAprendizado[0, 2] = 0;
 18 
 19             _matrizAprendizado[1, 0] = 0;
 20             _matrizAprendizado[1, 1] = 1;
 21             _matrizAprendizado[1, 2] = 0;
 22 
 23             _matrizAprendizado[2, 0] = 1;
 24             _matrizAprendizado[2, 1] = 0;
 25             _matrizAprendizado[2, 2] = 0;
 26 
 27             _matrizAprendizado[3, 0] = 1;
 28             _matrizAprendizado[3, 1] = 1;
 29             _matrizAprendizado[3, 2] = 1;
 30 
 31             w[0] = 0;
 32             w[1] = 0;
 33             w[2] = 0;
 34         }
 35 
 36         public static void Main(string[] args)
 37         {
 38             //pesos antes do treinamento
 39             w.ToList().ForEach(x => Console.WriteLine(x + ","));
 40 
 41             Console.WriteLine("\n");
 42 
 43             //efetua-se o treinamento da rede
 44             new Perceptron().Treinar();
 45 
 46             Console.WriteLine("\n");
 47 
 48             //pesos ajustados após treinamento
 49             w.ToList().ForEach(x => Console.WriteLine(x + ","));
 50 
 51             //dados de entrada para rede treinada, 0 e 0 resulta em 0 (tabela and) -1 corresponde ao BIAS
 52 
 53             int[] amostra1 = { 0, 1, -1 }; // 0 e 1 -> 0 Classe B
 54             int[] amostra2 = { 1, 0, -1 }; // 1 e 0 -> 0 Classe B
 55             int[] amostra3 = { 0, 0, -1 }; // 0 e 0 -> 0 Classe B
 56             int[] amostra4 = { 1, 1, -1 }; // 1 e 1 -> 1 Classe A
 57 
 58             ClassificarAmostra(amostra1);
 59             ClassificarAmostra(amostra2);
 60             ClassificarAmostra(amostra3);
 61             ClassificarAmostra(amostra4);
 62 
 63             Console.ReadKey();
 64         }
 65 
 66         public static void ClassificarAmostra(int[] amostra)
 67         {
 68             //pesos encontrados após o treinamento
 69             int[] pesos = { 2, 1, 3 };
 70 
 71             //aplicação da separação dos dados linearmente após aprendizado
 72             var u = amostra.Select((t, k) => pesos[k] * t).Sum();
 73 
 74             var y = LimiarAtivação(u);
 75 
 76             Console.WriteLine(y > 0 ? "Amostra da classe A >= 0" : "Amostra da classe B < 0");
 77         }
 78 
 79         private static int LimiarAtivação(double u)
 80         {
 81             return (u >= 0) ? 1 : 0;
 82         }
 83 
 84         int Executar(int x1, int x2)
 85         {
 86             _net = (x1 * w[0]) + (x2 * w[1]) + ((-1) * w[2]);
 87 
 88             return (_net >= 0) ? 1 : 0;
 89         }
 90 
 91         public void Treinar()
 92         {
 93             var treinou = true;
 94 
 95             for (var i = 0; i < _matrizAprendizado.GetLength(0); i++)
 96             {
 97                 var saida = Executar(_matrizAprendizado[i, 0], _matrizAprendizado[i, 1]);
 98 
 99                 if (saida != _matrizAprendizado[i, 2])
100                 {
101                     CorrigirPeso(i, saida);
102 
103                     treinou = false;
104                 }
105             }
106 
107             if (!treinou)
108                 Treinar();
109         }
110 
111         void CorrigirPeso(int i, int saida)
112         {
113             w[0] = w[0] + (1 * (_matrizAprendizado[i, 2] - saida) * _matrizAprendizado[i, 0]);
114             w[1] = w[1] + (1 * (_matrizAprendizado[i, 2] - saida) * _matrizAprendizado[i, 1]);
115             w[2] = w[2] + (1 * (_matrizAprendizado[i, 2] - saida) * (-1));
116         }
117     }
118 }

Implementação em Ruby[editar | editar código-fonte]

  1   #
  2  # Classe PERCEPTRON responsável para aprendizado e resolução da tabela AND
  3  #
  4 
  5 class Perceptron 
  6 
  7   def initialize
  8     # pesos sinápticos [0] entrada 1, [1] entrada 2, [3]BIAS
  9     @w   = []
 10 
 11     # variável responsável pelo somatório(rede).
 12     @net = 0
 13 
 14     # variavél responsável pelo número máximo de épocas
 15     @epocasMax = 30
 16 
 17     # variável responsável pela contagem das épocas durante o treinamento
 18     @count      = 0
 19 
 20     # declara o vetor da matriz de aprendizado
 21     @matriz_aprendizado = []
 22 
 23     self.inicia_matriz
 24   end
 25 
 26   def inicia_matriz
 27     # Primeiro valor
 28     @matriz_aprendizado[0]    = []
 29     @matriz_aprendizado[0][0] = 0; # entrada 1
 30     @matriz_aprendizado[0][1] = 0; # entrada 2
 31     @matriz_aprendizado[0][2] = 0; # valor esperado
 32 
 33     # Segundo Valor
 34     @matriz_aprendizado[1]    = []
 35     @matriz_aprendizado[1][0] = 0; # entrada 1
 36     @matriz_aprendizado[1][1] = 1; # entrada 2
 37     @matriz_aprendizado[1][2] = 0; # valor esperado
 38 
 39     # terceiro valor
 40     @matriz_aprendizado[2]    = []
 41     @matriz_aprendizado[2][0] = 1; # entrada 1
 42     @matriz_aprendizado[2][1] = 0; # entrada 2
 43     @matriz_aprendizado[2][2] = 0; # valor esperado
 44 
 45     # quarto valor
 46     @matriz_aprendizado[3]    = []
 47     @matriz_aprendizado[3][0] = 1; # entrada 1
 48     @matriz_aprendizado[3][1] = 1; # entrada 2
 49     @matriz_aprendizado[3][2] = 1; # valor esperado
 50     
 51     # inicialização dos pesos sinápticos
 52 
 53     # Peso sináptico para primeira entrada.
 54     @w[0] = 0;
 55     # Peso sináptico para segunda entrada.
 56     @w[1] = 0;
 57     # Peso sináptico para o BIAS
 58     @w[2] = 0;
 59   end
 60 
 61   # Método responsávelpelo somatório e a função de ativação.
 62   def executar(x1, x2)
 63     # Somatório (NET)
 64     @net = (x1 * @w[0]) + (x2 * @w[1]) + ((-1) * @w[2]);
 65 
 66     # Função de Ativação
 67     return 1 if (@net >= 0) 
 68 
 69     return 0;
 70   end
 71 
 72   # Método para treinamento da rede
 73   def treinar() 
 74     # variavel utilizada responsável pelo controlede treinamento recebefalso
 75     treinou = true;
 76     
 77     # varável responsável para receber o valor da saída (y)
 78     saida   = nil;
 79 
 80     # laço usado para fazer todas as entradas
 81     @matriz_aprendizado.length.times do |i|
 82       
 83       # A saída recebe o resultado da rede que no caso é 1 ou 0
 84       saida = self.executar(@matriz_aprendizado[i][0], @matriz_aprendizado[i][1]);
 85      
 86       if (saida != @matriz_aprendizado[i][2]) 
 87         # Caso a saída seja diferente do valor esperado
 88         
 89         # os pesos sinápticos serão corrigidos
 90         self.corrigirPeso(i, saida);
 91 
 92         # a variavél responsável pelo controlede treinamento recebe falso
 93         treinou = false;
 94       end
 95     end
 96 
 97     # acrescenta uma época
 98     @count+=1;
 99 
100     # teste se houve algum erro duranteo treinamento e o número de epocas
101     #é menor qe o definido
102     if(not treinou and (@count < @epocasMax))
103       # chamada recursiva do método
104       self.treinar();
105     end
106   end    # fim do método para treinamento
107 
108   # Método para a correção de pesos
109   def corrigirPeso(i, saida) 
110     @w[0] = @w[0] + (1 * (@matriz_aprendizado[i][2] - saida) * @matriz_aprendizado[i][0]);
111     @w[1] = @w[1] + (1 * (@matriz_aprendizado[i][2] - saida) * @matriz_aprendizado[i][1]);
112     @w[2] = @w[2] + (1 * (@matriz_aprendizado[i][2] - saida) * (-1));
113   end
114 end

Implementação em JAVA[editar | editar código-fonte]

  1  
  2  /*
  3  * Classe PERCEPTRON responsável para aprendizado e resolução da tabela AND
  4  */
  5 
  6 public class Perceptron {
  7 
  8     // pesos sinápticos [0] entrada 1, [1] entrada 2, [3]BIAS
  9     private double[] w = new double[3];
 10 
 11     // variável responsável pelo somatório(rede).
 12     private double NET = 0;
 13 
 14     // variavél responsável pelo número máximo de épocas
 15     private final int epocasMax = 30;
 16 
 17     // variável responsável pela contagem das épocas durante o treinamento
 18     private int count = 0;
 19 
 20     // declara o vetor da matriz de aprendizado
 21     private int[][] matrizAprendizado = new int[4][3];
 22 
 23     // MÉTODO DE RETORNO DO CONTADOR
 24     public int getCount(){
 25 
 26       return this.count;
 27 
 28     }
 29  // metodo de inicialização inicia o vetor da matriz de aprendizado
 30   Perceptron() {
 31 
 32     // Primeiro valor
 33     this.matrizAprendizado[0][0] = 0; // entrada 1
 34     this.matrizAprendizado[0][1] = 0; // entrada 2
 35     this.matrizAprendizado[0][2] = 0; // valor esperado
 36 
 37     // Segundo Valor
 38     this.matrizAprendizado[1][0] = 0; // entrada 1
 39     this.matrizAprendizado[1][1] = 1; // entrada 2
 40     this.matrizAprendizado[1][2] = 0; // valor esperado
 41 
 42     // terceiro valor
 43     this.matrizAprendizado[2][0] = 1; // entrada 1
 44     this.matrizAprendizado[2][1] = 0; // entrada 2
 45     this.matrizAprendizado[2][2] = 0; // valor esperado
 46 
 47     // quarto valor
 48     this.matrizAprendizado[3][0] = 1; // entrada 1
 49     this.matrizAprendizado[3][1] = 1; // entrada 2
 50     this.matrizAprendizado[3][2] = 1; // valor esperado
 51     
 52     // inicialização dos pesos sinápticos
 53 
 54     // Peso sináptico para primeira entrada.
 55     w[0] = 0;
 56     // Peso sináptico para segunda entrada.
 57     w[1] = 0;
 58     // Peso sináptico para o BIAS
 59     w[2]= 0;
 60        
 61 }
 62 
 63   // Método responsávelpelo somatório e a função de ativação.
 64     int executar(int x1, int x2) {
 65 
 66         // Somatório (NET)
 67         NET = (x1 * w[0]) + (x2 * w[1]) + ((-1) * w[2]);
 68 
 69         // Função de Ativação
 70         if (NET >= 0) {
 71             return 1;
 72         }
 73         return 0;
 74     }
 75 
 76     // Método para treinamento da rede
 77     public void treinar() {
 78 
 79         // variavel utilizada responsável pelo controlede treinamento recebefalso
 80         boolean treinou= true;
 81         // varável responsável para receber o valor da saída (y)
 82         int saida;
 83 
 84         // laço usado para fazer todas as entradas
 85         for (int i = 0; i < matrizAprendizado.length; i++) {
 86             // A saída recebe o resultado da rede que no caso é 1 ou 0
 87             saida = executar(matrizAprendizado[i][0], matrizAprendizado[i][1]);
 88             
 89            
 90             if (saida != matrizAprendizado[i][2]) {
 91                 // Caso a saída seja diferente do valor esperado
 92                 
 93                 // os pesos sinápticos serão corrigidos
 94                 corrigirPeso(i, saida);
 95                 // a variavél responsável pelo controlede treinamento recebe falso
 96                 treinou = false;
 97 
 98             }
 99         }
100         // acrescenta uma época
101         this.count++;
102 
103         // teste se houve algum erro duranteo treinamento e o número de epocas
104         //é menor qe o definido
105         if((treinou == false) && (this.count < this.epocasMax)) {
106             // chamada recursiva do método
107             treinar();
108 
109         }
110 
111     }    // fim do método para treinamento
112 
113     // Método para a correção de pesos
114     void corrigirPeso(int i, int saida) {
115 
116         w[0] = w[0] + (1 * (matrizAprendizado[i][2] - saida) * matrizAprendizado[i][0]);
117         w[1] = w[1] + (1 * (matrizAprendizado[i][2] - saida) * matrizAprendizado[i][1]);
118         w[2] = w[2] + (1 * (matrizAprendizado[i][2] - saida) * (-1));
119 }}