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

Exemplo de sobrecarga de métodos

Script para cálculo de distâncias na superfície terrestre utilizando coordenadas geográficas

Imagem de Background atravez de um JDesktopPane

Cadastramento de Produtos com .JOptionPane

Calcular ritmo de corrida de rua