Perceptron

O perceptron foi inventado em 1943 por Warren McCulloch e Walter Pitts. A primeira implementação de hardware foi a máquina Mark I Perceptron construída em 1957 por Frank Rosenblatt no Cornell Aeronautical Laboratory.^[1]^[2] Ele pode ser visto como o tipo mais simples de rede neural feedforward: um classificador linear.^[1]^[2]

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

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

f(x)={\begin{cases}1&{\text{if }}w\cdot x+b\geq 0\\0&{\text{else}}\end{cases}}

Onde $w$ é um vetor de peso real e $w\cdot x$ é o produto escalar (que computa uma soma com pesos) e $b$ é o viés (do inglês "bias"), um termo constante que não depende de qualquer valor de entrada.

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

''' 	Este projeto esta disponivel no GiHub de Marcos castro de Sousa 	Implementação da rede neural Perceptron 	w = w + N * (d(k) - y) * x(k) '''  import random, copy  class Perceptron:  	def __init__(self, amostras, saidas, taxa_aprendizado=0.1, epocas=1000, limiar=-1):  		self.amostras = amostras # todas as amostras 		self.saidas = saidas # saídas respectivas de cada amostra 		self.taxa_aprendizado = taxa_aprendizado # taxa de aprendizado (entre 0 e 1) 		self.epocas = epocas # número de épocas 		self.limiar = limiar # limiar 		self.num_amostras = len(amostras) # quantidade de amostras 		self.num_amostra = len(amostras[0]) # quantidade de elementos por amostra 		self.pesos = [] # vetor de pesos   	# função para treinar a rede 	def treinar(self): 		 		# adiciona -1 para cada uma das amostras 		for amostra in self.amostras: 			amostra.insert(0, -1)  		# inicia o vetor de pesos com valores aleatórios 		for i in range(self.num_amostra): 			self.pesos.append(random.random())  		# insere o limiar no vetor de pesos 		self.pesos.insert(0, self.limiar)  		# inicia o contador de epocas 		num_epocas = 0  		while True:  			erro = False # o erro inicialmente inexiste  			# para todas as amostras de treinamento 			for i in range(self.num_amostras):  				u = 0  				''' 					realiza o somatório, o limite (self.amostra + 1) 					é porque foi inserido o -1 para cada amostra 				''' 				for j in range(self.num_amostra + 1): 					u += self.pesos[j] * self.amostras[i][j]  				# obtém a saída da rede utilizando a função de ativação 				y = self.sinal(u)  				# verifica se a saída da rede é diferente da saída desejada 				if y != self.saidas[i]:  					# calcula o erro: subtração entre a saída desejada e a saída da rede 					erro_aux = self.saidas[i] - y  					# faz o ajuste dos pesos para cada elemento da amostra 					for j in range(self.num_amostra + 1): 						self.pesos[j] = self.pesos[j] + self.taxa_aprendizado * erro_aux * self.amostras[i][j]  					erro = True # ainda existe erro  			# incrementa o número de épocas 			num_epocas += 1  			# critério de parada é pelo número de épocas ou se não existir erro 			if num_epocas > self.epocas or not erro: 				break   	# função utilizada para testar a rede 	# recebe uma amostra a ser classificada e os nomes das classes 	# utiliza a função sinal, se é -1 então é classe1, senão é classe2 	def testar(self, amostra, classe1, classe2):  		# insere o -1 		amostra.insert(0, -1)  		# utiliza o vetor de pesos que foi ajustado na fase de treinamento 		u = 0 		for i in range(self.num_amostra + 1): 			u += self.pesos[i] * amostra[i]  		# calcula a saída da rede 		y = self.sinal(u)  		# verifica a qual classe pertence 		if y == -1: 			print('A amostra pertence a classe %s' % classe1) 		else: 			print('A amostra pertence a classe %s' % classe2)   	# função de ativação: degrau bipolar (sinal) 	def sinal(self, u): 		return 1 if u >= 0 else -1   print('\nA ou B?\n')  # amostras: um total de 4 amostras amostras = [[0.1, 0.4, 0.7], [0.3, 0.7, 0.2],  				[0.6, 0.9, 0.8], [0.5, 0.7, 0.1]]  # saídas desejadas de cada amostra saidas = [1, -1, -1, 1]  # conjunto de amostras de testes testes = copy.deepcopy(amostras)  # cria uma rede Perceptron rede = Perceptron(amostras=amostras, saidas=saidas,	 						taxa_aprendizado=0.1, epocas=1000)  # treina a rede rede.treinar()  # testando a rede for teste in testes: 	rede.testar(teste, 'A', 'B')

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

  using System; using System.Linq;  namespace perceptron {     public class Perceptron     {         static readonly double[] w = new double[3];         private readonly int[,] _matrizAprendizado = new int[4, 3];         private double _net;          Perceptron()         {              //tabela AND             _matrizAprendizado[0, 0] = 0;             _matrizAprendizado[0, 1] = 0;             _matrizAprendizado[0, 2] = 0;              _matrizAprendizado[1, 0] = 0;             _matrizAprendizado[1, 1] = 1;             _matrizAprendizado[1, 2] = 0;              _matrizAprendizado[2, 0] = 1;             _matrizAprendizado[2, 1] = 0;             _matrizAprendizado[2, 2] = 0;              _matrizAprendizado[3, 0] = 1;             _matrizAprendizado[3, 1] = 1;             _matrizAprendizado[3, 2] = 1;              w[0] = 0;             w[1] = 0;             w[2] = 0;         }          public static void Main(string[] args)         {             //pesos antes do treinamento             w.ToList().ForEach(x => Console.WriteLine(x + ","));              Console.WriteLine("\n");              //efetua-se o treinamento da rede             new Perceptron().Treinar();              Console.WriteLine("\n");              //pesos ajustados após treinamento             w.ToList().ForEach(x => Console.WriteLine(x + ","));              //dados de entrada para rede treinada, 0 e 0 resulta em 0 (tabela and) -1 corresponde ao BIAS              int[] amostra1 = { 0, 1, -1 }; // 0 e 1 -> 0 Classe B             int[] amostra2 = { 1, 0, -1 }; // 1 e 0 -> 0 Classe B             int[] amostra3 = { 0, 0, -1 }; // 0 e 0 -> 0 Classe B             int[] amostra4 = { 1, 1, -1 }; // 1 e 1 -> 1 Classe A               ClassificarAmostra(amostra1);             ClassificarAmostra(amostra2);             ClassificarAmostra(amostra3);             ClassificarAmostra(amostra4);              Console.ReadKey();         }          public static void ClassificarAmostra(int[] amostra)         {             //pesos encontrados após o treinamento             int[] pesos = { 2, 1, 3 };              //aplicação da separação dos dados linearmente após aprendizado             var u = amostra.Select((t, k) => pesos[k] * t).Sum();              var y = LimiarAtivacao(u);              Console.WriteLine(y > 0 ? "Amostra da classe A >= 0" : "HelloWorld < 0");         }          private static int LimiarAtivacao(double u)         {             return (u >= 0) ? 1 : 0;         }          int Executar(int x1, int x2)         {             _net = (x1 * w[0]) + (x2 * w[1]) + ((-1) * w[2]);              return (_net >= 0) ? 1 : 0;         }          public void Treinar()         {             var treinou = true;              for (var i = 0; i < _matrizAprendizado.GetLength(0); i++)             {                 var saida = Executar(_matrizAprendizado[i, 0], _matrizAprendizado[i, 1]);                  if (saida != _matrizAprendizado[i, 2])                 {                     CorrigirPeso(i, saida);                      treinou = false;                 }             }              if (!treinou)                 Treinar();         }          void CorrigirPeso(int i, int saida)         {             w[0] = w[0] + (1 * (_matrizAprendizado[i, 2] - saida) * _matrizAprendizado[i, 0]);             w[1] = w[1] + (1 * (_matrizAprendizado[i, 2] - saida) * _matrizAprendizado[i, 1]);             w[2] = w[2] + (1 * (_matrizAprendizado[i, 2] - saida) * (-1));         }     } }

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

  #  # Classe PERCEPTRON responsável para aprendizado e resolução da tabela AND  #  class Perceptron     def initialize     # pesos sinápticos [0] entrada 1, [1] entrada 2, [3]BIAS     @w   = []      # variável responsável pelo somatório(rede).     @net = 0      # variavél responsável pelo número máximo de épocas     @epocasMax = 30      # variável responsável pela contagem das épocas durante o treinamento     @count      = 0      # declara o vetor da matriz de aprendizado     @matriz_aprendizado = []      self.inicia_matriz   end    def inicia_matriz     # Primeiro valor     @matriz_aprendizado[0]    = []     @matriz_aprendizado[0][0] = 0; # entrada 1     @matriz_aprendizado[0][1] = 0; # entrada 2     @matriz_aprendizado[0][2] = 0; # valor esperado      # Segundo Valor     @matriz_aprendizado[1]    = []     @matriz_aprendizado[1][0] = 0; # entrada 1     @matriz_aprendizado[1][1] = 1; # entrada 2     @matriz_aprendizado[1][2] = 0; # valor esperado      # terceiro valor     @matriz_aprendizado[2]    = []     @matriz_aprendizado[2][0] = 1; # entrada 1     @matriz_aprendizado[2][1] = 0; # entrada 2     @matriz_aprendizado[2][2] = 0; # valor esperado      # quarto valor     @matriz_aprendizado[3]    = []     @matriz_aprendizado[3][0] = 1; # entrada 1     @matriz_aprendizado[3][1] = 1; # entrada 2     @matriz_aprendizado[3][2] = 1; # valor esperado          # inicialização dos pesos sinápticos      # Peso sináptico para primeira entrada.     @w[0] = 0;     # Peso sináptico para segunda entrada.     @w[1] = 0;     # Peso sináptico para o BIAS     @w[2] = 0;   end    # Método responsávelpelo somatório e a função de ativação.   def executar(x1, x2)     # Somatório (NET)     @net = (x1 * @w[0]) + (x2 * @w[1]) + ((-1) * @w[2]);      # Função de Ativação     return 1 if (@net >= 0)       return 0;   end    # Método para treinamento da rede   def treinar()      # variavel utilizada responsável pelo controlede treinamento recebefalso     treinou = true;          # varável responsável para receber o valor da saída (y)     saida   = nil;      # laço usado para fazer todas as entradas     @matriz_aprendizado.length.times do |i|              # A saída recebe o resultado da rede que no caso é 1 ou 0       saida = self.executar(@matriz_aprendizado[i][0], @matriz_aprendizado[i][1]);             if (saida != @matriz_aprendizado[i][2])          # Caso a saída seja diferente do valor esperado                  # os pesos sinápticos serão corrigidos         self.corrigirPeso(i, saida);          # a variavél responsável pelo controlede treinamento recebe falso         treinou = false;       end     end      # acrescenta uma época     @count+=1;      # teste se houve algum erro duranteo treinamento e o número de epocas     #é menor qe o definido     if(not treinou and (@count < @epocasMax))       # chamada recursiva do método       self.treinar();     end   end    # fim do método para treinamento    # Método para a correção de pesos   def corrigirPeso(i, saida)      @w[0] = @w[0] + (1 * (@matriz_aprendizado[i][2] - saida) * @matriz_aprendizado[i][0]);     @w[1] = @w[1] + (1 * (@matriz_aprendizado[i][2] - saida) * @matriz_aprendizado[i][1]);     @w[2] = @w[2] + (1 * (@matriz_aprendizado[i][2] - saida) * (-1));   end end

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

   /*  * Classe PERCEPTRON responsável para aprendizado e resolução da tabela AND  */  public class Perceptron {      // pesos sinápticos [0] entrada 1, [1] entrada 2, [3]BIAS     private double[] w = new double[3];      // variável responsável pelo somatório(rede).     private double NET = 0;      // variavél responsável pelo número máximo de épocas     private final int epocasMax = 30;      // variável responsável pela contagem das épocas durante o treinamento     private int count = 0;      // declara o vetor da matriz de aprendizado     private int[][] matrizAprendizado = new int[4][3];      // MÉTODO DE RETORNO DO CONTADOR     public int getCount(){        return this.count;      }  // metodo de inicialização inicia o vetor da matriz de aprendizado   Perceptron() {      // Primeiro valor     this.matrizAprendizado[0][0] = 0; // entrada 1     this.matrizAprendizado[0][1] = 0; // entrada 2     this.matrizAprendizado[0][2] = 0; // valor esperado      // Segundo Valor     this.matrizAprendizado[1][0] = 0; // entrada 1     this.matrizAprendizado[1][1] = 1; // entrada 2     this.matrizAprendizado[1][2] = 0; // valor esperado      // terceiro valor     this.matrizAprendizado[2][0] = 1; // entrada 1     this.matrizAprendizado[2][1] = 0; // entrada 2     this.matrizAprendizado[2][2] = 0; // valor esperado      // quarto valor     this.matrizAprendizado[3][0] = 1; // entrada 1     this.matrizAprendizado[3][1] = 1; // entrada 2     this.matrizAprendizado[3][2] = 1; // valor esperado          // inicialização dos pesos sinápticos      // Peso sináptico para primeira entrada.     w[0] = 0;     // Peso sináptico para segunda entrada.     w[1] = 0;     // Peso sináptico para o BIAS     w[2]= 0;         }    // Método responsávelpelo somatório e a função de ativação.     int executar(int x1, int x2) {          // Somatório (NET)         NET = (x1 * w[0]) + (x2 * w[1]) + ((-1) * w[2]);          // Função de Ativação         if (NET >= 0) {             return 1;         }         return 0;     }      // Método para treinamento da rede     public void treinar() {          // variavel utilizada responsável pelo controlede treinamento recebefalso         boolean treinou= true;         // varável responsável para receber o valor da saída (y)         int saida;          // laço usado para fazer todas as entradas         for (int i = 0; i < matrizAprendizado.length; i++) {             // A saída recebe o resultado da rede que no caso é 1 ou 0             saida = executar(matrizAprendizado[i][0], matrizAprendizado[i][1]);                                      if (saida != matrizAprendizado[i][2]) {                 // Caso a saída seja diferente do valor esperado                                  // os pesos sinápticos serão corrigidos                 corrigirPeso(i, saida);                 // a variavél responsável pelo controlede treinamento recebe falso                 treinou = false;              }         }         // acrescenta uma época         this.count++;          // teste se houve algum erro duranteo treinamento e o número de epocas         //é menor qe o definido         if((treinou == false) && (this.count < this.epocasMax)) {             // chamada recursiva do método             treinar();          }      }    // fim do método para treinamento      // Método para a correção de pesos     void corrigirPeso(int i, int saida) {          w[0] = w[0] + (1 * (matrizAprendizado[i][2] - saida) * matrizAprendizado[i][0]);         w[1] = w[1] + (1 * (matrizAprendizado[i][2] - saida) * matrizAprendizado[i][1]);         w[2] = w[2] + (1 * (matrizAprendizado[i][2] - saida) * (-1)); }}

Referências

↑ ^a ^b Freund, Yoav; Schapire, Robert E. (1999). «Large Margin Classification: Using the Perceptron Algorithm» (PDF). UC San Diego. 37 (3): 2. Consultado em 23 de junho de 2020
↑ ^a ^b Lefkowitz, Melanie (25 de setembro de 2019). «Professor's perceptron paved the way for AI – 60 years too soon». Cornell Chronicle (em inglês). Consultado em 23 de junho de 2020

[:0-1] Freund, Yoav; Schapire, Robert E. (1999). «Large Margin Classification: Using the Perceptron Algorithm» (PDF). UC San Diego. 37 (3): 2. Consultado em 23 de junho de 2020

[:1-2] Lefkowitz, Melanie (25 de setembro de 2019). «Professor's perceptron paved the way for AI – 60 years too soon». Cornell Chronicle (em inglês). Consultado em 23 de junho de 2020

[1]

[2]