layer.java

Single-layer neural networks can be trained using various learning algorithms. The best-known algori

import java.util.*;



class Layer
{
    Vector neurons;
    int size;

    // for the pocket algorithm
    double p1,p2,p3;
    int Rp;
    int Rw;
	static ArrayList points;
	//static double threshold = 0;	
	//static double z[] = new double[2]; // z[0] = z_minus; z[1] = z_plus


    public Layer(String l,int s)
    {
		String label;
		size    = s;
		neurons = new Vector();
		for(int i = 0; i < s; i++)
		{
			label = new String(l) + String.valueOf(i);
			neurons.addElement(new Neuron(label));
		}
		initPocket();
    }
	
    public Neuron getNeuron(int i)
    {
		int         j=0;
		boolean     found=false;
		Neuron      neuron=null;
		Enumeration e = neurons.elements();
		while(e.hasMoreElements())
	    {
		neuron = (Neuron)e.nextElement();
		if (i==j)
		    {
			found = true;
			break;
		    } else j++;
	    }
	if (found==false) neuron = null;
	return neuron;
    }
	
    public void computeOutputs(Sample sample)
    {
		Neuron neuron;
		Enumeration e = neurons.elements();
		while(e.hasMoreElements())
	    {
			neuron = (Neuron)e.nextElement();
			neuron.computeOutput(sample);
	    }
    }
	
    public void computeAdaline(Vector s)
    {
	Neuron neuron;
	Synapse synapse;
	Enumeration syn;
	Enumeration e = neurons.elements();
	Enumeration d = s.elements();
	while(e.hasMoreElements())
	    {
		neuron = (Neuron)e.nextElement();
		neuron.computeAdalineDelta(((Double)d.nextElement()).doubleValue());
		syn = neuron.inlinks.elements();
		while(syn.hasMoreElements())
		    {
			synapse = (Synapse)syn.nextElement();
			synapse.weight += Neuron.learningRate *
			    synapse.from.output * neuron.delta;
			// (neuron.delta - 0.5);
		    }
	    }
    }
	
    public void computePerceptron(Vector s)
    {
		Neuron neuron;
		Synapse synapse;
		Enumeration syn;
		Enumeration e = neurons.elements();
		Enumeration d = s.elements();
		while(e.hasMoreElements())
	    {
			neuron = (Neuron)e.nextElement();
			neuron.computePerceptronDelta(((Double)d.nextElement()).doubleValue());
			syn = neuron.inlinks.elements();
			if (Math.abs(neuron.delta) >= 0.5) // misclassified pattern
		    while(syn.hasMoreElements())
			{
			    synapse = (Synapse)syn.nextElement();
			    synapse.weight += neuron.delta * Neuron.learningRate *
				synapse.from.output;
			}
	    }
    }
	
	public void initOptimal() {
		
	}
	
	public void computeOptimal(Sample s, boolean last_sample)
	{
		//System.out.println("computeOptimal");
		Neuron neuron;
		Synapse synapse;
		Enumeration syn;
		Enumeration e =  neurons.elements();
		//Enumeration d = s.out.elements();
		boolean supportvector;
		Perceptron.threshold_neuron.output = -1.0;
		int i = 0;
		
		while(e.hasMoreElements()) {
			neuron = (Neuron)e.nextElement();
			double t_out = s.o_out;
			//System.out.println("t_out:" + t_out);
			double gamma = t_out * neuron.output; 
			//System.out.println("gamma:" + gamma + " output:" + neuron.output);
			double delta_alpha = Neuron.learningRate * (1 - gamma);
			//System.out.println("delta_alpha: " + delta_alpha);
			if (0 > s.alpha + delta_alpha) {
				s.alpha = 0.0;
				supportvector = false;
			}
			else {
				//System.out.println("s.alpha vorher:" + s.alpha);
				s.alpha = s.alpha + delta_alpha;
				//System.out.println("s.alpha nachher:" + s.alpha);
				//if (2 < s.alpha) {s.alpha = 2;}
				supportvector = true;
			}
			//System.out.println("alpha:" + s.alpha);
			syn = neuron.inlinks.elements();
			
			if (supportvector)
				for (int j = 0; 2 > j; j++) {
					synapse = (Synapse)syn.nextElement();
				    //synapse.weight += s.alpha * delta_alpha * t_out * synapse.from.output;
					synapse.weight += delta_alpha * t_out * synapse.from.output;
					//System.out.println("sfo:" + synapse.from.output + " Weight:" + synapse.weight);
						/*neuron.delta * Neuron.learningRate *
					synapse.from.output;*/
			}
			//Enumeration in = Perceptron.inputSamples.elements();
			//Enumeration out = Perceptron.outputSamples.elements();
			boolean[] i_z = new boolean[2];
			i_z[0] = true;
			i_z[1] = true;
			double[] z = new double[2];
			Enumeration tns = Perceptron.threshold_neuron.outlinks.elements();
			Synapse tnsyn = (Synapse)tns.nextElement();
			Enumeration samples = InputSpaceCanvas.points.elements();
			while (samples.hasMoreElements()) {
				/*
				Vector v_in = (Vector) in.nextElement();
				Enumeration e_v_in = v_in.elements();
				
				syn = neuron.inlinks.elements();
				double sum = 0;
				while (syn.hasMoreElements()) {
					synapse = (Synapse)syn.nextElement();
					sum += synapse.from.getOutput() * synapse.getWeight();; 
				}*/
				Sample sample = (Sample) samples.nextElement();
				double v_out = sample.out;
				//Enumeration e_v_out = v_out.elements();
				
				Vector output =  SimplePerceptronApplet.perceptron.recognize(sample);
				double d_output = ((Double) output.get(0)).doubleValue() + tnsyn.weight;
				//int to = ((Double) e_v_out.nextElement()).intValue(); 
				switch ((int) sample.o_out) {
				case -1:
					if (i_z[0]) {
						i_z[0] = false;
						z[0] = d_output;
					}
					else {
						z[0] = Math.max(z[0], d_output);
					}
					break;
				case 1:
					if (i_z[1]) {
						i_z[1] = false;
						z[1] = d_output;
					}
					else {
						z[1] = Math.min(z[1], d_output);
					}
					break;
				default:
					System.out.println("to");
					break;
				}
			}
			//System.out.println("th0:" + Perceptron.threshold_neuron.output);
			//System.out.println("z0:" + z[0] + " z1:" + z[1]);
			//System.out.println("z0 + z1:" + (z[0] + z[1]));
			//Perceptron.threshold = (z[0] + z[1]) / 2;
			//Perceptron.threshold_neuron.output = - Perceptron.threshold;
			/*
			if (last_sample) {
				if ((z[0] > z[1]) && (Math.abs((z[1] - z[0])/(z[1] + z[0])) > Perceptron.z_temp) && (0.0 != Perceptron.z_temp)) {
					SimplePerceptronApplet.notSeparable.show();
				}
				Perceptron.z_temp = Math.abs((z[1] - z[0])/(z[1] + z[0]));
				System.out.println("z_temp:" + Perceptron.z_temp);
				tnsyn.weight = (z[0] + z[1])/2;
				System.out.println("tnsyn:" + tnsyn.weight);
			}
			*/
			tnsyn.weight = (z[0] + z[1])/2;
			//System.out.println("tnsyn:" + tnsyn.weight);
			i++;
		}
	}
	
	public void computeSVM(Sample s) {
		Neuron neuron;
		Synapse synapse;
		Enumeration syn;
		Enumeration e = neurons.elements();
		double z_my;
		Enumeration tns = Perceptron.threshold_neuron.outlinks.elements();
		Synapse threshold = (Synapse)tns.nextElement();
		neuron = (Neuron)e.nextElement();
		Enumeration samples = InputSpaceCanvas.points.elements();
		z_my = z(s);
		double gamma = s.o_out * z_my; 
		double delta_alpha = Neuron.learningRate * (1 - gamma);
		if (0 > s.alpha + delta_alpha) {
			s.alpha = 0.0;
		}
		else {
			s.alpha += delta_alpha;
		}
		syn = neuron.inlinks.elements();
		double[] z = svm_get_z_min_max();
		threshold.weight += (z[0] + z[1])/2;
		System.out.println("th:" + threshold.weight + " z0:" + z[0] + " z1:" + z[1]);
		for (int j = 0; 2 > j; j++) {
			synapse = (Synapse)syn.nextElement();
			synapse.weight = svm_weight(j);
		}
	}
	
	public double[] svm_get_z_min_max() {
		boolean[] i_z = new boolean[2];
		i_z[0] = true;
		i_z[1] = true;
		double[] z = new double[2];

		Enumeration samples = InputSpaceCanvas.points.elements();
		
		while (samples.hasMoreElements()) {
			Sample sample = (Sample) samples.nextElement();
			double z_t = z(sample); 
			switch ((int) sample.o_out) {
			case -1:
				if (i_z[0]) {
					i_z[0] = false;
					z[0] = z_t;
				}
				else {
					z[0] = Math.max(z[0], z_t);
				}
				break;
			case 1:
				if (i_z[1]) {
					i_z[1] = false;
					z[1] = z_t;
				}
				else {
					z[1] = Math.min(z[1], z_t);
				}
				break;
			default:
				System.out.println("to");
				break;
			}
		}
		return z;
	}
	
	public double svm_weight(int j) {
		double weight = 0;
		Enumeration samples = InputSpaceCanvas.points.elements();
		while (samples.hasMoreElements()) {
			Sample sample = (Sample) samples.nextElement();
			weight += sample.alpha * sample.o_out * sample.in[j];
		}
		return weight;
	}
	

	public static double K(double[] a, double[] b) {
		double K = 0;
		switch (Perceptron.kernel) {
		case Perceptron.POLY: 
			K = Math.pow((a[0] * b[0] + a[1] * b[1] + Perceptron.C), Perceptron.P);
			break;
		case Perceptron.GAUSS:
			double diff_x = a[0] - b[0];
			double diff_y = a[1] - b[1];
			double zaehler = diff_x * diff_x + diff_y * diff_y;
			double nenner = 2 * Perceptron.S * Perceptron.S;
			K = Math.exp(-zaehler/nenner);
			break;
		}		
		return K;
	}
	
	public double z (Sample my) {
		double z_my = 0;
		Enumeration tns = Perceptron.threshold_neuron.outlinks.elements();
		Synapse tnsyn = (Synapse)tns.nextElement();
		Enumeration samples = InputSpaceCanvas.points.elements();
		while (samples.hasMoreElements()){
			Sample sample = (Sample) samples.nextElement();
			z_my += sample.alpha * sample.o_out * K(sample.in, my.in);
		}
		z_my -= tnsyn.weight;
		return z_my;
	}
	
    public void computePocket(Vector s) // works only for 2 in / 1 out
    {
		boolean change = false;
	
		Neuron neuron;
		Synapse synapse;
		Enumeration syn;
		Enumeration e = neurons.elements();
		Enumeration d = s.elements();
		while(e.hasMoreElements())
	    {
			neuron = (Neuron)e.nextElement();
			neuron.computePerceptronDelta(((Double)d.nextElement()).doubleValue());
			if (Math.abs(neuron.delta) < 0.5) // well classified pattern
		    {
				Rw++;
				if (Rw > Rp)
			    {
					syn = neuron.inlinks.elements();  // save weights
					synapse = (Synapse)syn.nextElement();
					p1 = synapse.weight;
					synapse = (Synapse)syn.nextElement();
					p2 = synapse.weight;
					synapse = (Synapse)syn.nextElement();
					p3 = synapse.weight;
					Rp = Rw;
			    }
		    }
			else
		    {
				syn = neuron.inlinks.elements();
				while(syn.hasMoreElements())
			    {
					synapse = (Synapse)syn.nextElement();
					synapse.weight += neuron.delta * 
				    Neuron.learningRate * synapse.from.output;
			    }
				Rw = 0;
		    }
	    }
    }
	
    public void initPocket()
    {
		Rw = 0;
		Rp = 0;
		p1 = 0.0;
		p3 = 0.0;
		p2 = 0.0;
    }
	
    public void restorePocket()
	{
		Neuron neuron;
		Synapse synapse;
		Enumeration syn;
	
		Enumeration e = neurons.elements();
		neuron = (Neuron)e.nextElement();
		syn = neuron.inlinks.elements();
		synapse = (Synapse)syn.nextElement();
		synapse.weight = p1;
		synapse = (Synapse)syn.nextElement();
		synapse.weight = p2;
		synapse = (Synapse)syn.nextElement();
		synapse.weight = p3;
    }
	
    public void computeBackpropDeltas(Vector s) // for output neurons
    {
		Neuron neuron;
		Enumeration e = neurons.elements();
		Enumeration d = s.elements();
		while(e.hasMoreElements())
	    {
			neuron = (Neuron)e.nextElement();
			neuron.computeBackpropDelta(((Double)d.nextElement()).doubleValue());
	    }
    }
	
    public void computeBackpropDeltas() // for hidden neurons
    {
		Neuron neuron;
		Enumeration e = neurons.elements();
		while(e.hasMoreElements())
	    {
			neuron = (Neuron)e.nextElement();
			neuron.computeBackpropDelta();
	    }
    }
	
    public void computeWeights()
    {
		Neuron neuron;
		Enumeration e = neurons.elements();
		while(e.hasMoreElements())
	    {
			neuron = (Neuron)e.nextElement();
			neuron.computeWeight();
	    }
    }
	
    public void print()
    {
		Neuron neuron;
		Enumeration e = neurons.elements();
		while(e.hasMoreElements())
	    {
			neuron = (Neuron)e.nextElement();
			neuron.print();
	    }
    }
}