Backpropagation

/*
* Enlace 1: http://ccia.ei.uvigo.es/docencia/IA/ejemplo-BP.pdf
* Enlace 2: https://www.youtube.com/watch?v=26fG4qE2hvY
* Enlace 3: https://www.youtube.com/watch?v=zSVmxkwAU_M
*/
public class Backpropagation2Xor {

    public static double sumatoriaM(double e1,double e2,double e3,double e4,double e5){
        double sumatoria=0;
        sumatoria= Math.pow(e1, 2)+Math.pow(e2, 2)+Math.pow(e3, 2)+Math.pow(e4, 2)+Math.pow(e5, 2);
        return sumatoria;


    }



    public static double f(double entrada){

        double z=0.0;
        //funcion simoideal
        z=(1)/(1+Math.pow(Math.E, -entrada));
        return z;

        /*
         * si n >> 0 entonces z1
         * si n << 0 entonces z0
         * */
    }



    public static void main(String[] args) {
        //1. Inicializamos los pesos del MLP.


        double U0=-1.0; //umbral
        double U1=-1.0;
        double U2=-1.0;

        double a= 0.25;

        double W24=/*-17.20506886355809;*/2*Math.random()-1;
        double W25=/*-17.205083868742673;*/2*Math.random()-1;
        double W34=/*-6.187782754347626;*/2*Math.random()-1;
        double W35=/*-6.18778268016949;*/2*Math.random()-1;
        double W12=/*-295.88816065800427;*/2*Math.random()-1;
        double W13=/*285.8350132709512;*/2*Math.random()-1;


        //Para asegurarse forzo a que estos pesos estén entre 0 y 1.
        //Ya que las situaciones X0=0, X1=0 y X0=1, X1=1 requieren que estos sean positivos

        double W0 = Math.random();
        double W1 = Math.random();
        double W2 = Math.random();
        /*W24=0.25;
        W25=-0.5;

        W34=-0.5;
        W35=0.25;

        W12=0.5;
        W13=0.5;

        //Dejo los pesos de estáticos
        W0= 0.6;
        W1= 0.6;
        W2= 0.6;*/



        double peso24=W24;
        double peso25=W25;
        double peso34=W34;
        double peso35=W35;
        double peso12=W12;
        double peso13=W13;

        double []X1={0.0, 0.0, 1.0, 1.0};
        double []X2={0.0, 1.0, 0.0, 1.0};
        double []td={0.0, 1.0, 1.0, 0.0};

        //2.Mientras la condicion de parada sea falsa ejecutamos los pasos 3 al 12.
        double optenerEp=0.0;
        int ciclo=0;
        do{
            System.out.println("************************ciclo: "+ciclo);
            double sumatoriaP=0.0;
            for(int i=0; i<=td.length-1;i++){

                //3.aplicamos un vector de entrada Xp=[xp1,xp2........Xpn].


                //4.Calculamos los valores de entradas netas para la capa oculta.
                //para la neurona2
                double Neta2=(W24*X1[i])+ (W25*X2[i])+ (W1*U1);
                double Neta3=(W34*X1[i])+ (W35*X2[i])+ (W2*U2);
                //5.Calculamos la salidas de la capa oculta.

                double i2=f(Neta2);

                double i3=f(Neta3);

                //6.Calculamos los valores netos de entrada para la capa de salida.
                double Neta1 = (W12*i2) + (W13*i3)+ (W0*U0);

                //7.Calculamos la salida de la red.
                double y1=f(Neta1);
                //System.out.println("Salida: "+y1+ " Salida real "+td[i]);


                //8.Calculamos los terminos de error para las unidades de salidas.
                //Esta es la rapidez de la variación del error
                double errorSalida1= (td[i]-y1)*y1*(1-y1);


                //9.Estimamos loa   de error para las unidades ocultas.
                double errorSalida2= i2*(1-i2)*W12*errorSalida1;
                double errorSalida3= i3*(1-i3)*W13*errorSalida1;

                //10.Actualizamos los pesos en la capa de salida.
                W12=W12 + (a*errorSalida1*i2);
                W13=W13 + (a*errorSalida1*i3);
                W0 += (a*errorSalida1*U0);

                //11.Actualizamos los pesos en la capa oculta.
                W24=W24 +(a*errorSalida2*X1[i]);
                W34=W34 +(a*errorSalida3*X1[i]);

                W25=W25 +(a*errorSalida2*X2[i]);
                W35=W35 +(a*errorSalida3*X2[i]);

                W1 += (a*errorSalida2*U1);
                W2 += (a*errorSalida3*U2);

                //12.Verificamos si el error global cumplecon la  finalizar.
                //Asignamos(dpk-ypk) desde e1....en
                double e1=(td[i] - y1);
                double e2=(td[i] - i2);
                double e3=(td[i] - i3);
                double e4=0;
                double e5=0;

                double sumatoriaM=sumatoriaM(e1,e2,e3,e4,e5);

                sumatoriaP+=sumatoriaM;
            }

        //System.out.println(   "actuales=> W24:"+W24+"  W25:"+W25+"  W34:"+W34+" W35:"+W35+"\nW12:"+W12+" W13:"+W13+"  W0:"+W0+"  W1:"+W1+"  W2:"+W2);
        double Ep=(0.5)*sumatoriaP;
        //System.out.println("Ep: "+Ep);
        optenerEp=Ep;
        ciclo=ciclo+1;

    }while(ciclo<10000);
        System.out.println( "iniciale=> W24:"+peso24+"  W25:"+peso25+"  W34:"+peso34+" W35:"+peso35+" W12:"+peso12+" W13:"+peso13+"\n\n");
        System.out.println( "finales=> W24:"+W24+"  W25:"+W25+"  W34:"+W34+" W35:"+W35+" W12:"+W12+" W13:"+W13);

        System.out.println("********************prueba: ");
        //4.Calculamos los valores de entradas netas para la capa oculta.
        //para la neurona2

        for(int i = 0; i<td.length;i++){
            double Neta2=(W24*X1[i])+ (W25*X2[i])+W1*U1;
            double Neta3=(W34*X1[i])+ (W35*X2[i])+W2*U2;

            double i2=f(Neta2);
            double i3=f(Neta3);

            double Neta1= (W12*i2) + (W13*i3)+ (W0*U0);
            double y1=f(Neta1);

            System.out.println("Salida esperada "+td[i]+" Salida red: "+y1);
        }



    }

}