Baixe o app para aproveitar ainda mais
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
Compartilhar