Treinamento de rede neural

Publicado por Tiago R. de Oliveira 13/09/2006

[ Hits: 15.904 ]

Download treinaRedeNeural.java




Salve gurizada, este é um pedaço de um programinha que eu fiz para fazer o cálculo de uma rede neural, porém esta ainda é a versão -0.00001, somente um esboço, mas funciona. Passando os parâmetros certos ele salva, pega os pesos em arquivos texto e, ao fim, salva-os. Beleza, até mais!!!

  



Esconder código-fonte

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Random;

public class Treina {
   /**
    * Treinamento da Rede Neural
    * Classe que faz o treinamento de uma rede neural
    * com 36 entradas, 4 neuronios na camada oculta, e 1 na camada de saida
    * salvando os pesos em arquivo texto.
    */
   /*
    * construtor
    */
   public Treina(float vetorValores[], int valorASair) throws IOException{
      vetorValoNeuronioCamada1 = vetorValores;
      valorEsperado = valorASair;
      calcula();
   }
   
   public float vetorValoNeuronioCamada1 [];
   public float pesosNeuroniosCamada1 [][];
   public float vetorValorNeuronioCamada2 [];
   public float pesosNeuroniosCamada2 [];
   public int valorEsperado;
   
   /*
    * funcao de leitura dos pesos em um arquivo texto, onde os pesos de cada nruronio estao delimitado
    * pelos numeros 1 2 3 4 5 respectivamente
    */
   public void lePesosCamada1(int proximaPosicao, int posicaoMatriz) throws IOException{
      FileInputStream arq;
      arq = new FileInputStream("pesosCamada1.txt");
      int caracterlido = arq.read();
      for (int j = 0 ; j <= 143 ; j++){
      caracterlido = arq.read();   
      if (caracterlido == posicaoMatriz){
         for (int i = 0; i <= 34; i++){
            if (caracterlido != proximaPosicao){
               pesosNeuroniosCamada1[i][posicaoMatriz] = caracterlido;
               caracterlido = arq.read();
            }
            if (i == 34){
               break;
            }
            }
         }
      }
      arq.close();
   }
   public void lePesosCamada2() throws IOException{
      FileInputStream arq;
      arq = new FileInputStream("pesosCamada2.txt");
      int caracterlido = arq.read();
      for (int i = 0; i <= 3; i++){
               pesosNeuroniosCamada2[i] = caracterlido;
               caracterlido = arq.read();
      }
      arq.close();
   }
      
   public void calcula() throws IOException{
      
      boolean chegouOFim = false;
      while (chegouOFim = false){
      /**
       * inicia o calculo da camada oculta
       */
      float v11 = 0;
      float v12 = 0;
      float v13 = 0;
      float v14 = 0;
      lePesosCamada1(2,1);
      lePesosCamada1(3,2);
      lePesosCamada1(4,3);
      lePesosCamada1(5,4);
      /*
       * calcula o Vk da camada oculta
       */
      for (int i = 0; i <= 34; i++){
         v11 += vetorValoNeuronioCamada1[i] * pesosNeuroniosCamada1[i][0];
         v12 += vetorValoNeuronioCamada1[i] * pesosNeuroniosCamada1[i][1];
         v13 += vetorValoNeuronioCamada1[i] * pesosNeuroniosCamada1[i][2];
         v14 += vetorValoNeuronioCamada1[i] * pesosNeuroniosCamada1[i][4];
      }
      /*
       * calcula o Yk da camada oculta
       */
      float y11 = (float) (1 /(1+(Math.pow(2.7182,v11))));
      float y12 = (float) (1 /(1+(Math.pow(2.7182,v12))));
      float y13 = (float) (1 /(1+(Math.pow(2.7182,v13))));
      float y14 = (float) (1 /(1+(Math.pow(2.7182,v14))));
      vetorValorNeuronioCamada2[0] = y11;
      vetorValorNeuronioCamada2[1] = y12;
      vetorValorNeuronioCamada2[2] = y13;
      vetorValorNeuronioCamada2[3] = y14;
      
      /*
       * Inicia o calculo da camada de saida
       */
      float v21 = 0;
            
      /*
       * calcula o Vk da camada de saida
       */
      lePesosCamada2();
      for (int i = 0; i <= 3; i++){
         v21 += vetorValorNeuronioCamada2[i] * pesosNeuroniosCamada2[i];
      }
      /*
       * calcula o Yk da camada de saida
       */
      float y21 = (float) (1/(1+(Math.pow(2.7182,v21))));
      
      /**
       * faz o calculo do erro
       */
      float e21 = 0 - y21;
      /*
       * faz o teste do erro
       */
      if ((e21 >= (valorEsperado - 0.3)) && (e21 <= valorEsperado + 0.3)){
         System.out.println("acabou, pois o erro era de " + String.valueOf(e21));
          chegouOFim = true;
      }else{
         chegouOFim = false;
         /*
          * calcula o gradiente da camada de saida
          */
         float gradiente21 = (y21*(1-y21)) * e21;
         /*
          * corrige os pesos desta camada
          */
         float vetorDeltaCamadaSaida[] = null;
         for (int i = 0 ; i <= 3 ; i++){
            vetorDeltaCamadaSaida[i] = 1 * gradiente21 * pesosNeuroniosCamada2[i];
         }
         /*
          * correção dos pesos sinapticos desta camada
          */
         for (int i = 0 ; i <= 3 ; i++){
            pesosNeuroniosCamada2[i] = pesosNeuroniosCamada2[i] + vetorDeltaCamadaSaida[i];
         }
         /**
          * parte para a camada oculta
          */
         /*
          * calcula o gradiente da camada oculta
          */
         float gradiente11 = (vetorValoNeuronioCamada1[0]*(1-vetorValoNeuronioCamada1[0])) * 
         (pesosNeuroniosCamada2[0]*vetorDeltaCamadaSaida[0]);
         float gradiente12 = (vetorValoNeuronioCamada1[1]*(1-vetorValoNeuronioCamada1[1])) * 
         (pesosNeuroniosCamada2[1]*vetorDeltaCamadaSaida[1]);
         float gradiente13 = (vetorValoNeuronioCamada1[2]*(1-vetorValoNeuronioCamada1[2])) * 
         (pesosNeuroniosCamada2[2]*vetorDeltaCamadaSaida[2]);
         float gradiente14 = (vetorValoNeuronioCamada1[3]*(1-vetorValoNeuronioCamada1[3])) * 
         (pesosNeuroniosCamada2[3]*vetorDeltaCamadaSaida[3]);
         /*
          * corrige os pesos desta camada
          */
         float deltaN1C1[] = null;
         float deltaN2C1[] = null;
         float deltaN3C1[] = null;
         float deltaN4C1[] = null;
         for (int i = 0; i <= 34; i++){
            deltaN1C1[i] = (1 * gradiente11 * vetorValoNeuronioCamada1[i]);                        
            deltaN2C1[i] = (1 * gradiente12 * vetorValoNeuronioCamada1[i]);
            deltaN3C1[i] = (1 * gradiente13 * vetorValoNeuronioCamada1[i]);
            deltaN4C1[i] = (1 * gradiente14 * vetorValoNeuronioCamada1[i]);
         }
         /*
          * corrige os pesos sinapticos desta camada
          */         
         for (int j = 0; j<= 34; j++){
               pesosNeuroniosCamada1[j][0] = pesosNeuroniosCamada1[j][0] + deltaN1C1[j];
               pesosNeuroniosCamada1[j][1] = pesosNeuroniosCamada1[j][1] + deltaN1C1[j];
               pesosNeuroniosCamada1[j][2] = pesosNeuroniosCamada1[j][2] + deltaN1C1[j];
               pesosNeuroniosCamada1[j][3] = pesosNeuroniosCamada1[j][3] + deltaN1C1[j];
            }
         FileOutputStream arq;
            PrintStream ps;
            try{
               arq = new FileOutputStream("pesosCamada1.txt");
               ps = new PrintStream(arq);
               ps.print(1);
               for (int i = 0; i <= 35 ; i++){
                  ps.print(pesosNeuroniosCamada1[i][0]);                  
               }
               ps.print(2);
               for (int i = 0; i <= 35 ; i++){
                  ps.print(pesosNeuroniosCamada1[i][1]);                  
               }
               ps.print(3);
               for (int i = 0; i <= 35 ; i++){
                  ps.print(pesosNeuroniosCamada1[i][2]);                  
               }
               ps.print(4);
               for (int i = 0; i <= 35 ; i++){
                  ps.print(pesosNeuroniosCamada1[i][3]);                  
               }
               ps.print(5);    
               ps.close();
            }
            catch (FileNotFoundException e) {
               System.err.println
               ("Erro na tentativa de abrir o arquivo");
            }
            catch (IOException ex) {
               System.err.println
               ("Erro na escrita do arquivo");
                   }
                  
        } 
            
   }
   }
}

Scripts recomendados

RatingSistemaElo.java

MostraSeNumPrimo.java

Algoritmos para Teoria dos Números

Splash Screen!!!

Ordenação de vetores com letras do alfabeto


  

Comentários
[1] Comentário enviado por sombriks em 14/09/2006 - 02:13h

Legal... posta uns links ae sobre a utilidade de uma rede neural, :D

[2] Comentário enviado por eisen em 14/09/2006 - 08:36h

Neste links tem algumas explicações:
http://www.din.uem.br/ia/neurais/
http://www.inf.ufrgs.br/procpar/disc/cmp135/trabs/sergio/trab2/geo.html

Este algoritmo que eu desenvolvi, serve para verificar se uma pessoas é mal pagadora ou não. Após treinar a rede com valores pré-definidos, você pode inserir os dados, e ele responde. Estes dados devem seguir uma tabulação pré-definida.

[3] Comentário enviado por buster em 08/11/2007 - 09:58h

E ai Eisen.. tranquilo?
po legal tua RNA... to começando a fuçar nessa area.. tem como vc disponibilizar tb ou arquivos que vc usou para testar?
Valew!


Contribuir com comentário




Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts