Aula 09.1 Perceptron e Mapa de Kohonen

Prévia do material em texto

Perceptron
Origem: Wikipédia, a enciclopédia livre.
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
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 JAVA
/*
* Classe PERCEPTRON responsável para aprendizado e resolução da tabela AND
*
* @author Dimas Kastibergue <k45t1b@gmail.com>;
*/
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
Aula 09.1 Perceptron e Mapa de Kohonen
domingo, maio 3, 2015 10:14 
 Página 1 de SIN260 - Sistemas Inteligentes 
 // 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
 Página 2 de SIN260 - Sistemas Inteligentes 
 // 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));
 }
 void testar() {
 System.out.println(" Teste 01 para 0 e 0 " + executar(0, 0));
 System.out.println(" Teste 02 para 0 e 1 " + executar(0, 1));
 System.out.println(" Teste 03 para 1 e 0 " + executar(1, 0));
 System.out.println(" Teste 04 para 0 e 0 " + executar(0, 0));
 System.out.println(" Teste 05 para 1 e 1 " + executar(1, 1));
 }
 public static void main(String[] arguments) {
 Perceptron p = new Perceptron();
 p.treinar();
 System.out.println("Para aprender o algoritmo treinou " + p.getCount() + " epocas! \n ");
 p.testar();
 }
}
De <http://pt.wikipedia.org/w/index.php?title=Perceptron&printable=yes> 
Mapas de Kohonen
Origem: Wikipédia, a enciclopédia livre.
O algoritmo de Kohonen foi desenvolvido por Teuvo Kohonen em 1982, sendo considerado 
relativamente simples e com a capacidade de organizar dimensionalmente dados complexos em 
grupos (clusters), de acordo com suas relações. Este método solicita apenas os parâmetros de 
entrada, mostrando-se ideal para problemas onde os padrões são desconhecidos ou 
indeterminados.
Este algoritmo é considerado um mapa auto-organizável (da sigla SOM, Self-organized map, em 
inglês), capaz de diminuir a dimensão de um grupo de dados, conseguindo manter a representação 
real com relação as propriedades relevantes dos vetores de entrada, tendo-se como resultado um 
conjunto das características do espaço de entrada.
Além disso, possui a propriedade de transformar um mapa multidimensional em bidimensional, 
adicionando os elementos ao novo mapa de tal forma que os objetos similares sejam posicionados 
próximos uns dos outros.
Apresenta duas importantes características: utiliza aproximação dos pontos similares onde os 
mesmos são processados separadamente e permite ao mapa obter centros em um plano 
bidimensional disponibilizando uma visualização facilmente compreensível.
O algoritmo de Kohonen ordena os objetos i, frequentemente organizados em uma grade 
retangular, atribuindo-os ao vetor modelo, denominado mi, no espaço multidimensional. Cada item 
 Página 3 de SIN260 - Sistemas Inteligentes 
retangular, atribuindo-os ao vetor modelo, denominado mi, no espaço multidimensional. Cada item 
xk é mapeado para a unidade do mapa ck mais adequada, conforme a menor distância entre mi e xk 
definida pela fórmula [2]: ck = argmin i xk – mi
Este algoritmo utiliza o método de aprendizagem por competição (competitive learning), 
considerado o mais comum nas RNA auto-organizáveis, permitindo que aconteça o aprendizado 
dividindo-se os padrões de entrada dos dados em conjuntos inseparáveis. Este método avalia os 
neurônios de saída da rede de maneira que ocorra uma competição entre eles, tendo-se como 
resultado o neurônio que possui maior ativação. A rede neural de Kohonen é composta por duas 
camadas: a de entrada e de Kohonen. Cada nó da camada de entrada tem a função de distribuir os 
valores padrões para a de Kohonen, que é um conjunto de nodos organizados de forma tabular. O 
vetor de entrada possui seus elementos conectados com cada nó da camada Kohonen por meio de 
ligações, as quais são responsáveis por manterem atualizados os valores durante o processo de 
treinamento da RNA.
Obtida de "http://pt.wikipedia.org/w/index.php?title=Mapas_de_Kohonen&oldid=38131103"Categorias:
Estatística•
Inteligência artificial•
Esta página foi modificada pela última vez à(s) 14h13min de 10 de fevereiro de 2014.•
Este texto é disponibilizado nos termos da licença Creative Commons - Atribuição -
Compartilha Igual 3.0 Não Adaptada (CC BY-SA 3.0); pode estar sujeito a condições 
adicionais. Para mais detalhes, consulte as Condições de Uso.
•
Computação autonômica•
De <http://pt.wikipedia.org/w/index.php?title=Mapas_de_Kohonen&printable=yes> 
 Página 4 de SIN260 - Sistemas Inteligentes