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!!!

• Download treinaRedeNeural.java
• Enviar nova versão

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");
                   }
                  
        } 
            
   }
   }
}

Conectando 2 Maquinas no Java

Pesquisa Binaria em um vetor ordenado

Ordenação de vetores com letras do alfabeto (atualizado)

Pesquisa Ternária em um vetor ordenado

Algoritmo para Gerar um Sudoku NxN válido