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

Tau.111 Soft Computing
Yksikerroksinen Perceptron. Neuronitason opetus.

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

import java.io.*;

public class Perceptron
{
	/** Käytettävä neuronitaso **/
	private Neuronitaso nt;
	/** Opetusnopeus **/
	private double alfa;

	/** Muodostin: sisäänmenoja, ulostuloja, opetusnopeus **/
	public Perceptron(int inputs, int outputs, double a)
	{
		nt=new Neuronitaso(inputs,outputs);
		alfa=a;		
	}

	/** Neuronitason palautus **/
	public Neuronitaso getHermoverkko()
	{
		return nt;
	}

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

	public void setAlfa(double a)
	{
		if(a>0 && a<1)
		{
			alfa=a;
		}
	}

	/** Opetus syötteellä ja sen toivotulla vasteella **/
	public void opeta(double[] x, double[] y)
	{
		double[] o=nt.o(x);
		double[] t=new double[o.length];
		for(int i=0;i<o.length;i++)
		{
			t[i]=y[i]-o[i];
		}
		double[][] dW=new double[o.length][x.length+1];
		for(int i=0;i<o.length;i++)
		{
			dW[i][0]=alfa*t[i]*1;
			for(int j=1;j<x.length+1;j++)
			{
				dW[i][j]=alfa*t[i]*x[j-1];
			}
		}
		nt.korjaaW(dW);
	}

	/** Iteratiivinen opetus joukolla syötteitä ja niiden vasteita. kpl = iteraatioiden määrä **/
	public double 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);
		return 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(nt.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;
	}

	/** Neuronitason tulostus **/
	public String toString()
	{
		return nt.toString();
	}

	/** Yleinen vektorin tulostusmetodi **/
	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)
	{
		java.text.NumberFormat nf=java.text.NumberFormat.getInstance();
		nf.setMaximumFractionDigits(2);
		System.out.print(otsikko+": ");
		for(int i=0;i<v.length;i++)
		{
			System.out.print("v"+i+"="+nf.format(v[i])+"; ");
		}
		System.out.println();
	}

	/** Testausta **/
	public static void main(String[] args) throws IOException
	{
		double wl=760; // nm, referenssiaallonpituus
		double[] omena={1,0,0,0}; // Haluttu vaste
		double[] omenax1={490/wl,1,0.1}; // Piirrevektori = [väri = 490 nm (Vihreä), a/b (1/eksentrisyys), painopisteen paikka 0 = keskellä]
		double[] paaryna={0,1,0,0};
		double[] paarynax1={500/wl,0.5,0.5};
		double[] appelsiini={0,0,1,0};
		double[] appelsiinix1={590/wl,1,0};
		double[] banaani={0,0,0,1};
		double[] banaanix1={570/wl,0.1,0.1};
		double[][] x={omenax1,paarynax1,appelsiinix1,banaanix1};
		double[][] y={omena,paaryna,appelsiini,banaani};

		Perceptron p=new Perceptron(3,4,0.1); // 3 sisäänmenoa 4 ulostuloa

		System.out.println(p);

		Perceptron.printVector(p.o(omenax1),"omena");
		Perceptron.printVector(p.o(paarynax1),"paaryna");
		Perceptron.printVector(p.o(appelsiinix1),"appelsiini");
		Perceptron.printVector(p.o(banaanix1),"banaani");

		for(int i=0;i<1;i++)
		{
			p.opeta(omenax1,omena);
			p.opeta(paarynax1,paaryna);
			p.opeta(appelsiinix1,appelsiini);
			p.opeta(banaanix1,banaani);
		}
		
		BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
		String s;
		do
		{
			System.out.println("Mitä opetetaan? (o,p,a,b,train,quit)");
			s=r.readLine();
			if(s.equals("o"))
			{
				p.opeta(omenax1,omena);
			}
			else if(s.equals("p"))
			{
				p.opeta(paarynax1,paaryna);
			}
			else if(s.equals("a"))
			{
				p.opeta(appelsiinix1,appelsiini);
			}
			else if(s.equals("b"))
			{
				p.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){}
				p.opeta(x,y,kpl,min);
			}
			else
			{
				System.out.println(p);
			}
			Perceptron.printVector(p.o(omenax1),"omena");
			Perceptron.printVector(p.o(paarynax1),"paaryna");
			Perceptron.printVector(p.o(appelsiinix1),"appelsiini");
			Perceptron.printVector(p.o(banaanix1),"banaani");
		}
		while(!s.equals("quit"));
		
		System.out.println(p);
	}
}