/*************************************************************************************
Janne Koljonen
Vaasan yliopisto
15.11.2003

Tau.111 Soft Computing
Multilayer-Perceptron

**************************************************************************************/

import java.io.*;

public class MLP
{
	/** Käytettävä hermoverkko **/
	private Hermoverkko he;
	/** Tasojen määrä **/
	private int layers;
	/** Opetusnopeuden kerroin **/
	private double alfa;

	/** Muodostin: tasojen sisäänmenot, ulostulot, opetusnopeus **/
	public MLP(int[] inputs, int[] outputs, double a)
	{
		he=new Hermoverkko(inputs,outputs);
		layers=inputs.length;
		alfa=a;
	}

	/** Hermoverkon palautus **/
	public Hermoverkko getHermoverkko()
	{
		return he;
	}

	/** Hermoverkon ulostulo **/
	public double[] o(double[] x)
	{
		return he.o(x);
	}

	/** Opetusalgoritmi yhdelle syöte-vaste -parille **/
	public void opeta(double[] x1, double[] y)
	{
		double[][] o=new double[layers][];
		double[][] x=new double[layers][];
		x[0]=x1;
		for(int k=0;k<layers;k++)
		{
			o[k]=he.o(x[k],k); // Vasteet tasoittain
			if(k<layers-1) x[k+1]=o[k]; // Seuraavan tason syötteet
		}	
		
		double[] ex=y; // Toivotut vasteet
		for(int k=layers-1;k>=0;k--)
		{
			double[] t=new double[o[k].length]; // Korjaustermit

			for(int i=0;i<o[k].length;i++)
			{
				if(k==layers-1)
				{
					t[i]=o[k][i]*(1-o[k][i])*(ex[i]-o[k][i]);
				}
				else
				{
					t[i]=o[k][i]*(1-o[k][i])*ex[i];
				}
			}

			// Edellisen kerroksen toivottu vaste
			double[][] W=he.getW(k);
			ex=new double[x[k].length];
			for(int j=0;j<x[k].length;j++)
			{
				for(int i=0;i<W.length;i++)
				{
					ex[j]+=t[i]*W[i][j+1];
				}
			}

			// Tämän kerroksen painojen korjaukset
			double[][] dW=new double[o[k].length][x[k].length+1];
			for(int i=0;i<o[k].length;i++)
			{
				dW[i][0]=alfa*t[i]*1;
				for(int j=1;j<x[k].length+1;j++)
				{
					dW[i][j]=alfa*t[i]*x[k][j-1];
				}
			}

			he.korjaaW(dW,k);
		}
	}

	/** Iteratiivinen opetus usealla syöte-vaste -parilla. kpl = iteraatioiden määrä **/
	public void opeta(double[][] x, double[][] y, int kpl, double errorthreshold)
	{
		double error=error(x,y);
		int n=0;
		while(error>errorthreshold && n<kpl)
		{
			int s=(int)(x.length*Math.random());
			opeta(x[s],y[s]);
			error=error(x,y);
			n++;
		}
		System.out.println("Error="+error);
	}

	/** Keskivirhe yhden näytteen yhtä ulostuloa kohti **/
	public double error(double[][] x, double[][] y)
	{
		return Math.sqrt(sumOfSquaresError(x,y)/x.length/y.length);
	}

	/** Kaikkien opetusnäytteiden neliövirheiden summa **/
	public double sumOfSquaresError(double[][] x, double[][] y)
	{
		double error=0;
		for(int s=0;s<x.length;s++)
		{
			error+=sumOfSquaresError(he.o(x[s]),y[s]);
		}
		return error;
	}

	/** Yhden opetusnäytteen neliövirheiden summa **/
	public double sumOfSquaresError(double[] o, double[] y)
	{
		double error=0;
		for(int i=0;i<o.length;i++)
		{
			error+=Math.abs(o[i]-y[i])*Math.abs(o[i]-y[i]);
		}
		return error;
	}

	/** Hermoverkon tulostus **/
	public String toString()
	{
		return he.toString();
	}

	/** Vektorin tulostus **/
	public static void printVector(double[] v)
	{
		for(int i=0;i<v.length;i++)
		{
			System.out.print("v"+i+"="+v[i]+"; ");
		}
		System.out.println();
	}

	/** Vektorin nimen ja sisällön tulostus **/
	public static void printVector(double[] v, String otsikko)
	{
		System.out.print(otsikko+": ");
		for(int i=0;i<v.length;i++)
		{
			System.out.print("v"+i+"="+v[i]+"; ");
		}
		System.out.println();
	}

	/** Testausta **/
	public static void main(String[] args) throws IOException
	{
		double wl=760;
		double[] omena={1,0,0};
		double[] omenax1={490/wl,1}; // Vihreä
		double[] appelsiini={0,1,0};
		double[] appelsiinix1={590/wl,1};
		double[] banaani={0,0,1};
		double[] banaanix1={570/wl,0.1};
		double[][] x={omenax1,appelsiinix1,banaanix1};
		double[][] y={omena,appelsiini,banaani};

		// Kaksikerroksinen
		int[] inputs={2,3};
		int[] outputs={3,3};
		MLP mlp=new MLP(inputs,outputs,0.1);
		/*
		// Kolmikerroksinen
		int[] inputs={2,3,3};
		int[] outputs={3,3,3};
		MLP mlp=new MLP(inputs,outputs,0.1);
		*/

		System.out.println(mlp);

		for(int i=0;i<100;i++)
		{
			mlp.opeta(omenax1,omena);
			mlp.opeta(appelsiinix1,appelsiini);
			mlp.opeta(banaanix1,banaani);
		}

		Perceptron.printVector(mlp.o(omenax1),"omena");
		Perceptron.printVector(mlp.o(appelsiinix1),"appelsiini");
		Perceptron.printVector(mlp.o(banaanix1),"banaani");

		Perceptron.printVector(mlp.he.o(omenax1,0),"väli");
		Perceptron.printVector(mlp.he.o(appelsiinix1,0),"väli");
		Perceptron.printVector(mlp.he.o(banaanix1,0),"väli");

		BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
		String s;
		do
		{
			System.out.println("Mitä opetetaan? (o,a,b,train,quit)");
			s=r.readLine();
			if(s.equals("o"))
			{
				mlp.opeta(omenax1,omena);
			}
			else if(s.equals("a"))
			{
				mlp.opeta(appelsiinix1,appelsiini);
			}
			else if(s.equals("b"))
			{
				mlp.opeta(banaanix1,banaani);
			}
			else if(s.equals("train"))
			{
				System.out.print("Iteraatioden määrä:");
				int kpl=1000;
				try
				{
					kpl=Integer.parseInt(r.readLine());
				}
				catch(NumberFormatException ex){}
				System.out.print("Minimivirhe (0-1):");
				double min=0.1;
				try
				{
					min=Double.parseDouble(r.readLine());
				}
				catch(NumberFormatException ex){}
				mlp.opeta(x,y,kpl,min);
			}
			else
			{
				System.out.println(mlp);
			}
			Perceptron.printVector(mlp.o(omenax1),"omena");
			Perceptron.printVector(mlp.o(appelsiinix1),"appelsiini");
			Perceptron.printVector(mlp.o(banaanix1),"banaani");
		}
		while(!s.equals("quit"));
		
		System.out.println(mlp);
	}
}