/**

*
* @author gilberto
*/
public class BackPropagation {
public static void main(String[] args) {
// TODO code application logic here
int M = 1;
int epocas = 1000;
int padrao = 1;
int H = 2; //numero de neuronios primeira camada
int L = 1; //numero de neuronios da segunda camada
double net;
double net2;
double n = 0.01;
double E;
//matriz de entradas da rede, onde cada linha representa um padrão
double matx[][] = {{ 1.0 }};//padrao de entrada
//matriz de saidas desejadas da rede, onde cada linha representa
//um padrao
double matd[][] = {{(1.0 + Math.sin(1.0*(Math.PI/4)))}};//padrao 4
double w1[][] = {{-0.48,-0.27},
{-0.13,-0.41}};//matriz de pesos primeira camada
double w2[][] = {{0.48,0.09,-0.17}};//matriz de pesos segunda camada
double waux1[][] = new double[ 2 ][ 2 ];//delta w
double waux2[][] = new double[ 1 ][ 3 ];//delta w
double y1[][] = new double[ padrao ][ H+1 ];//matriz de saidas estimada
s primeira camada
double derivada1[][] = new double[ padrao ][ H ];//matriz de derivadas
primeira camada
double derivada2 = 1.0;//derivada da segunda camada
double delta1;
double delta2[][] = new double[ padrao ][ H ];
double y2[][] = new double[ 1 ][ 1 ];//matriz de saidas estimadas segun
da camada
double x[] = new double[ 2 ];//vetor de entradas para cada padrao
double e[] = new double[ 1 ];//vetor de erro
double a[] = { 1.0 };//coeficiente angular da reta

BackPropagation obj = new BackPropagation(); //cria objeto da classe de

ntro do main

/****************
int aux1;
int aux2;
//inicializa os pesos aleatoriamente com valores
 //entre -1.0 e 1.0
for( int k1 = 0; k1<3; k1++ ){

for( int k2 = 0; k2<3; k2++ ){

aux2 = (int)(100 * Math.random());
if( aux2<50 ){
aux1 = -1;
}//fim do if
else{
aux1 = 1;
}//fim do else

w[ k1 ][ k2 ] = aux1 * Math.random();

}//fim for interno

}//fim do for
********************/
y1[ 0 ][ 0 ] = 1.0;//bias
x[ 0 ] = 1.0;//bias
for(int j = 0; j<epocas; j++ ){
for( int i = 0; i<padrao; i++ ){

for( int j1 = 0; j1<M; j1++ ){

x[ j1+1 ] = matx[ i ][ j1 ];
}//fim do for

//################ propagação direta ###############################################

#######

//faz a propagação direta dos sinais de entrada na primeira camada

for( int j2 = 0; j2<H; j2++ ){//percorre os neuronios da primeir
a camada
net = 0.0;
for( int i2 = 0; i2<M+1; i2++ ){//percorre as entradas + bia
s

net = net + w1[ j2 ][ i2 ] * x[ i2 ];//faz o somatorio p

ara cada neuronio da primeira camada

}//fim do for interno

y1[ i ][ j2+1 ] = obj.funcaoAtivacaoLogistica( net );//acha

a saida da rede
derivada1[ i ][ j2 ] = obj.derivadaFuncaoLogistica( net );//
calcula a derivada

}//fim do for

//faz a propagação direta dos sinais de entrada na segunda camada

for( int j21 = 0; j21<L; j21++ ){//percorre os neuronios da prim
eira camada
net2 = 0.0;
for( int i21 = 0; i21<H+1; i21++ ){//percorre as entradas +
bias

net2 = net2 + w2[ j21 ][ i21 ] * y1[ i ][ i21 ];//faz o

somatorio para cada neuronio da segunda camada

}//fim do for interno

y2[ i ][ j21 ] = a[ j21 ] * net2;//acha a saida da rede

e[ j21 ] = matd[ i ][ j21 ] - y2[ i ][ j21 ];//calcula o err
o

}//fim do for

//###############calcula os deltas de cada neuronio ############################

#############

delta1 = e[0] * derivada2;//delta para o neuronio da ultima cam

ada
for(int k2 = 0; k2<H; k2++){//calcula os deltas da segunda cama
da

delta2[ i ][ k2 ] = delta1 * w2[ 0 ][ k2+1 ] * derivada1

[ i ][ k2 ];
 }//fim do for

//########### faz a correção dos pesos #############################################

######

//faz a correção dos pesos da primeira camada

for( int j3 = 0; j3<H; j3++ ){

for( int i3 = 0; i3<M+1; i3++ ){

waux1[ j3 ][ i3 ] = n * delta2[ i ][ j3 ] * x[ i3 ];
w1[ j3 ][ i3 ] = w1[ j3 ][ i3 ] + waux1[ j3 ][ i3 ];

}//fim do for interno

}//fim do for

//corrige os pesos da segunda camada

for(int j5 = 0; j5<H+1; j5++ ){

waux2[ 0 ][ j5 ] = n * delta1 * y1[ i ][ j5 ];

w2[ 0 ][ j5 ] = w2[ 0 ][ j5 ] + waux2[ 0 ][ j5 ];

}//fim do for

//################# calcula e imprime erro quadratico ##########################

############

E = 0.5 * ( e[0]*e[0] );//calcula o erro quadratico

System.out.println("E = "+ E );//imprime o erro quadratico para
cada padrao
//################# se erro quadratico for menor que x imprime saida e pesos e s
ai do programa ###############

if( E<0.0001 ){//se o erro quadratico for menor que 0.01...

System.out.print("\n\nEpoca = "+ j +"\n\n");//imprime a epoc
a
System.out.print("SAIDA DESEJADA\nSAIDA ESTIMADA\n\n");
 //imprime as saidas desejadas e as saidas da rede
//apos o treinamento
//imprime uma linha da matriz de saida desejada
System.out.print("d["+0+"]["+0+"]= "+matd[ 0 ][ 0 ]+"\t\t\t"
);

System.out.println();
//imprime uma linha da matriz de saida desejada
System.out.print("y["+0+"]["+0+"]= "+y2[ 0 ][ 0 ]+"\t");

System.out.println("\n\nMATRIZ DE PESOS PRIMEIRA CAMADA:\n\n

");
//imprime a matriz de pesos primeira camada
for( int m1 = 0; m1<H; m1++ ){
for( int m2 = 0; m2<M+1; m2++ ){
System.out.print("w1["+m1+"]["+m2+"]="+w1[ m1 ][ m2
]+"\t");
}//fim do for interno
System.out.print("\n\n");
}//fim do for

System.out.println("\n\nMATRIZ DE PESOS SEGUNDA CAMADA:\n\n"

);
//imprime a matriz de pesos segunda camada
for( int m3 = 0; m3<H+1; m3++ ){
System.out.print("w2["+i+"]["+m3+"]="+w2[ i ][ m3 ]+"\t"
);
System.out.print("\n\n");
}//fim do for

System.exit(0);
}//fim do if

}//fim dos padroes

}//fim das epocas
System.out.print("\n\nEpoca = "+ epocas +"\n\n");//imprime a epoca
System.out.print("SAIDA DESEJADA\nSAIDA ESTIMADA\n\n");
 //imprime as saidas desejadas e as saidas da rede
//apos o treinamento
//imprime uma linha da matriz de saida desejada
System.out.print("d["+0+"]["+0+"]= "+matd[ 0 ][ 0 ]+"\t\t\t"
);

System.out.println();
//imprime uma linha da matriz de saida desejada
System.out.print("y["+0+"]["+0+"]= "+y2[ 0 ][ 0 ]+"\t");

System.out.println("\n\nMATRIZ DE PESOS PRIMEIRA CAMADA:\n\n

");
//imprime a matriz de pesos primeira camada
for( int m1 = 0; m1<H; m1++ ){
for( int m2 = 0; m2<M+1; m2++ ){
System.out.print("w1["+m1+"]["+m2+"]="+w1[ m1 ][ m2
]+"\t");
}//fim do for interno
System.out.print("\n\n");
}//fim do for

System.out.println("\n\nMATRIZ DE PESOS SEGUNDA CAMADA:\n\n"

);
//imprime a matriz de pesos segunda camada
for( int m3 = 0; m3<H+1; m3++ ){
System.out.print("w2["+0+"]["+m3+"]="+w2[ 0 ][ m3 ]+"\t"
);
System.out.print("\n\n");
}//fim do for

}//fim do main

public double funcaoAtivacaoLogistica( double somatorio ){

//metodo que retorna o valor
//da funçao logistica para somatorio
//onde somatorio é o valor do somatorio
//do produto dos pesos da camada pelas
double funcao;
//entradas da mesma
funcao = 1/( 1 + Math.pow( Math.E, -somatorio ));
//f(x) = 1 / [ 1 + exp( -x ) ]
return funcao;

}
//fim do metodo

//derivada da funcao logistica

public double derivadaFuncaoLogistica( double saida ){
//metodo que retorna a derivada
//da funçaologistica para saida
//onde saida é o valor de saida da camada
double derivada;
//declara variavel local
derivada = saida * ( 1 - saida );
return derivada;
//retorna a derivada

}
//fim do metodo

}//fim da classe