simpleperceptronapplet.java

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

import java.applet.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;

public class SimplePerceptronApplet extends Applet
{
    /**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	InputSpaceCanvas inputSpaceCanvas;
    static Perceptron       perceptron;
    Choice          colorChoice;
    Choice          algoChoice;
	Choice			kernelChoice;
    TextField       iterationsTF;
    TextField       learningRateTF;
	TextField		timedelayTF;
	TextField		cTF;
	TextField		pTF;
	TextField		sTF;
	
    Label            counter, totalIterations;
    Panel            controls, parameters;
    ErrorGraph       errorGraph;
	static Frame	notSeparable = new Frame();
    Button           init;
    Button           learn;
	Button			play;
    Button           clear;
    final String redItem = "1 (red)";
    final String blueItem = "0 (blue)";
    final String backpropLabel = "Backprop";
    final String adalineLabel = "Adaline";
    final String perceptronLabel = "Perceptron";
    final String pocketLabel = "Pocket";
	final String optimalLabel = "Optimal Perceptron";
	final String svmLabel = "Support Vector Machine";
	final String polyLabel = "(x * y + c)^P";
	final String gaussLabel = "exp(-(x - y)^2 / (2 * sigma^2)";

    public SimplePerceptronApplet()
    {
		initPerceptron();
		notSeparable.setSize(200, 100);
		Button close = new Button("not separable!");
		notSeparable.add(close);
		ActionListener closeListener = new ActionListener() {
		    public void actionPerformed(ActionEvent e) {
			notSeparable.setVisible(false); 
			//System.out.println("message-close");
		    }
		};
		close.addActionListener(closeListener);
    }

    public void init()
	{
		setLayout(new BorderLayout());
		controls = new Panel();
		algoChoice = new Choice();
		Perceptron.applet_mode = this.getParameter("applet_mode");
		if (null == (Perceptron.applet_mode)) {
			Perceptron.applet_mode = "";
		}
		if (!Perceptron.applet_mode.equalsIgnoreCase("SVM")){
			algoChoice.addItem(backpropLabel);
			algoChoice.addItem(adalineLabel);
			algoChoice.addItem(perceptronLabel);
			algoChoice.addItem(pocketLabel);
			algoChoice.addItem(optimalLabel);
		}

		System.out.println("applet_mode: " + Perceptron.applet_mode);
		ItemListener algoChoiceListener = new ItemListener() {
			public void itemStateChanged(ItemEvent e) {
				algoChoicePerformed(e);
			}
		};
		algoChoice.addItemListener(algoChoiceListener);
		controls.add(algoChoice);
		Choice kernelChoice = new Choice();
		kernelChoice.addItem(polyLabel);
		kernelChoice.addItem(gaussLabel);
		ItemListener kernelChoiceListener = new ItemListener() {
			public void itemStateChanged(ItemEvent e) {
				kernelChoicePerformed(e);
			}
		};
		kernelChoice.addItemListener(kernelChoiceListener);
		controls.add(kernelChoice);
		if (!Perceptron.applet_mode.equalsIgnoreCase("Perceptron")) {
			algoChoice.addItem(svmLabel);
			kernelChoice.setVisible(true);
		}
		else {
			kernelChoice.setVisible(false);
		}
		init = new Button("Init");
		ActionListener initListener = new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				initPerformed();
			}
	    };
		init.addActionListener(initListener);
		controls.add(init);
		learn = new Button("Learn");
		play = new Button("Play");
		ActionListener learnListener = new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				learnPerformed();
			}
	    };
		ActionListener playListener = new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				playPerformed();
			}
	    };
		
		learn.addActionListener(learnListener);
		controls.add(learn);
		play.addActionListener(playListener);
		controls.add(play);
		clear = new Button("Clear");
		ActionListener clearListener = new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				clearPerformed();
			}
		};
		clear.addActionListener(clearListener);
		controls.add(clear);
		colorChoice = new Choice();
		ItemListener choiceListener = new ItemListener() {
			public void itemStateChanged(ItemEvent e) {
		    	choicePerformed(e);
			}
	    };	
		colorChoice.addItemListener(choiceListener);
		colorChoice.addItem(redItem);
		colorChoice.addItem(blueItem);
		controls.add(colorChoice);
		add("North",controls);
    
		parameters = new Panel();
		parameters.add(new Label("Learning rate:"));
		learningRateTF = new TextField(String.valueOf(Neuron.learningRate),4);
		parameters.add(learningRateTF);
		parameters.add(new Label("Iterations:"));
		iterationsTF = new TextField("10",4);
		timedelayTF = new TextField("100", 4);
		cTF = new TextField("0", 4);
		pTF = new TextField("1", 4);
		sTF = new TextField("0.2", 4);
		parameters.add(iterationsTF);
		parameters.add(new Label("Delay:"));
		parameters.add(timedelayTF);
		if (!Perceptron.applet_mode.equalsIgnoreCase("Perceptron")) {
			parameters.add(new Label("c:"));
			parameters.add(cTF);
			parameters.add(new Label("P:"));
			parameters.add(pTF);
			parameters.add(new Label("sigma:"));
			parameters.add(sTF);
		}
		counter = new Label("0   ");
		parameters.add(counter);
		add("South",parameters);
		totalIterations = new Label ("    0");
		parameters.add(new Label ("Total It.:"));
		parameters.add (totalIterations);
		inputSpaceCanvas = new InputSpaceCanvas();
		add("Center",inputSpaceCanvas);

		errorGraph = new ErrorGraph (this);
	}

    public void initPerformed() {
		initPerceptron();
		totalIterations.setText("    0");
		for(double x1 = 0.0; x1<=1.01; x1+=0.05)
		    for(double x2 = 0.0; x2<=1.01; x2+=0.05)
			inputSpaceCanvas.setBackground(x1,x2,-100);
		inputSpaceCanvas.repaint();
		errorGraph.graph.startNewTrace ();
    }

    public void clearPerformed() {
		Confirm c = new Confirm(new Frame(),true,"Are you sure ?");
		c.show();
		if (Confirm.answer==Confirm.OK) {
		    for(double x1 = 0.0; x1<=1.01; x1+=0.05)
			for(double x2 = 0.0; x2<=1.01; x2+=0.05)
			    inputSpaceCanvas.setBackground(x1,x2,-100.0);
		    initPerceptron();
		    totalIterations.setText("    0");
		    inputSpaceCanvas.clearPoints();
		    errorGraph.graph.startNewTrace ();
		}
		inputSpaceCanvas.repaint();
    }

    public void learnPerformed() {
		try {
		    learnPoints();
		}
		catch (NumberFormatException e) {}
    }
	
	public void playPerformed() {
		if (inputSpaceCanvas.play) {
			inputSpaceCanvas.play = false;
			play.setLabel("Play");
		}
		else {
			inputSpaceCanvas.play = true;
			play.setLabel("Stop");
		}
		inputSpaceCanvas.startAnimation(this);
		
		/*
		for (int i = 0; i < 10; i++) {
			try {
			    learnPoints();
			}
			catch (NumberFormatException e) {}
			inputSpaceCanvas.show();
			try {
				Thread.sleep(1000);
			}
			catch(Exception f) {}
		}
		*/
    }
	

    public void choicePerformed(ItemEvent e) {
		if (((Choice)(e.getSource())).getSelectedItem() == redItem) {
		    inputSpaceCanvas.setValue(1);
		}
		else if (((Choice)(e.getSource())).getSelectedItem() == blueItem) {
		    inputSpaceCanvas.setValue(0);
		}
		else {}
    }

    public void algoChoicePerformed(ItemEvent e) {
		if (((Choice)(e.getSource())).getSelectedItem() == perceptronLabel) {
		    Perceptron.algorithm = Perceptron.PERCEPTRON;
			//this.kernelChoice.isVisible();
			//kernelChoice.setEnabled(false);
		}
		else if (((Choice)(e.getSource())).getSelectedItem() == backpropLabel) {
		    Perceptron.algorithm = Perceptron.BACKPROP;

		}
		else if (((Choice)(e.getSource())).getSelectedItem() == adalineLabel) {
		    Perceptron.algorithm = Perceptron.ADALINE;
		}
		else if (((Choice)(e.getSource())).getSelectedItem() == pocketLabel) {
		    Perceptron.algorithm = Perceptron.POCKET;
		}
		else if (((Choice)(e.getSource())).getSelectedItem() == optimalLabel) {
		    Perceptron.algorithm = Perceptron.OPTIMAL;
		}
		else if (((Choice)(e.getSource())).getSelectedItem() == svmLabel) {
		    Perceptron.algorithm = Perceptron.SVM;
		}
		else {}
    }
	public void kernelChoicePerformed(ItemEvent e) {
		if (((Choice)(e.getSource())).getSelectedItem() == polyLabel) {
		    Perceptron.kernel = Perceptron.POLY;
		}
		else if (((Choice)(e.getSource())).getSelectedItem() == gaussLabel) {
		    Perceptron.kernel = Perceptron.GAUSS;
		}
		else {System.out.println("no kernel");}
    }

    public void initPerceptron()
    {
		int i;
		if (perceptron!= null) i = Perceptron.algorithm;
		else i = Perceptron.BACKPROP;
		perceptron = new Perceptron(2,1,i); // 2 inputs / 1 output
		perceptron.connect(0,0,1,0);
		perceptron.connect(0,1,1,0);
		perceptron.biasConnect(1,0);
		Perceptron.weights_set = false;
    }
	
    public void learnPoints()
    {
		
		if (Perceptron.OPTIMAL == Perceptron.algorithm) {
			setSamples(-1.0);
			Perceptron.threshold = 0.0;
			Perceptron.threshold_weight = 1.0;
		}
		else {
			setSamples(0.0);
			Perceptron.threshold = 1.0;
			Perceptron.threshold_weight = 0.5;
		}
		// perceptron.printSamples();
		Integer iterations = Integer.valueOf(iterationsTF.getText());
		Perceptron.P = Double.valueOf(pTF.getText()).doubleValue();
		Perceptron.C = Double.valueOf(cTF.getText()).doubleValue();
		Perceptron.S = Double.valueOf(sTF.getText()).doubleValue();
		Double learningRate = Double.valueOf(learningRateTF.getText());
		Neuron.learningRate = learningRate.doubleValue();
		disableDuringLearning ();
		if (Perceptron.algorithm == Perceptron.POCKET) perceptron.initPocket();
		if (Perceptron.OPTIMAL == Perceptron.algorithm) perceptron.initOptimal();
		int max = iterations.intValue();
		for(int i = 0; i < max; i++)
	    {
			counter.setText(String.valueOf(max - i));
			counter.repaint(); // not so bad
			//if (Perceptron.OPTIMAL == perceptron.algorithm) {
			//	perceptron.learnOptimal(1);
			//}
			//else {
			perceptron.learn(1);	
			//}
	    }
		counter.setText("0   ");
		if (Perceptron.algorithm == Perceptron.POCKET) // restore the W_best 
	    perceptron.restorePocket();
		totalIterations.setText(String.valueOf((int)max
					       +getFieldAsInt(totalIterations)
					       ));
		drawSpace();
		enableDuringLearning();
		errorGraph.graph.add (iterations.intValue(), 
			      perceptron.currentError());
		errorGraph.show ();
	// perceptron.print();
    }
	/*
	public void setSamplesOptimal() {
		
		Layer.points = new ArrayList();
		
		Enumeration e = inputSpaceCanvas.points1.elements();
		while (e.hasMoreElements())
		{
			double x =  ((Double) e.nextElement()).doubleValue();
			double y =  ((Double) e.nextElement()).doubleValue();
			Point point = new Point(x, y, 1);
			Layer.points.add(point);
		}
		e = inputSpaceCanvas.points0.elements();
		while (e.hasMoreElements())
		{
			double x =  ((Double) e.nextElement()).doubleValue();
			double y =  ((Double) e.nextElement()).doubleValue();
			Point point = new Point(x, y, -1);
			Layer.points.add(point);
		}
	}
	*/
    public void setSamples(double output_false)
    {
		
		//Vector input;
		//Vector output;
		//perceptron.removeSamples();
		Enumeration e = InputSpaceCanvas.points.elements();
		Perceptron.sample_sum[0][0] = 0.0;
		Perceptron.sample_sum[0][1] = 0.0;
		Perceptron.sample_sum[1][0] = 0.0;
		Perceptron.sample_sum[1][1] = 0.0;
		int[] anzahl = new int[2];
		while(e.hasMoreElements())
	    {
			//output = new Vector();
			//output.addElement(new Double(1.0));
			//Sample sample_output = new Sample(output);
			//input  = new Vector();
			//Double input_value = (Double)e.nextElement();
			Sample sample = (Sample)e.nextElement();
			//input.addElement(input_value);
			//Enumeration f = sample.out.elements();
			Perceptron.sample_sum[(int) sample.out][0] += sample.in[0];
			//input_value = (Double)e.nextElement();
			//input.addElement(input_value);
			Perceptron.sample_sum[(int) sample.out][1] += sample.in[1];
			//perceptron.addSample(sample);
			anzahl[(int) sample.out]++;
	    }
		Perceptron.num_samples = anzahl[0] + anzahl[1];
		Neuron output_neuron = (Neuron) perceptron.outputLayer.neurons.get(0);
		Enumeration syn = output_neuron.inlinks.elements();
		Synapse synapse;
		if (! Perceptron.weights_set) {
			for (int i = 0; 2 > i; i++) {
				synapse = (Synapse)syn.nextElement();
				synapse.weight = Perceptron.sample_sum[1][i]/anzahl[1] - Perceptron.sample_sum[0][i]/anzahl[0];
				System.out.println("i:" + i + " weight:" + synapse.weight);
			}
			Perceptron.weights_set = true;
		}
	}
	
    public void drawSpace()
    {
		Vector input;
		Vector output;
	
		for(double x1 = 0.0; x1<=1.01; x1+=0.05)
		    for(double x2 = 0.0; x2<=1.01; x2+=0.05)
			{
			    //input = new Vector();
			    //input.addElement(new Double(x1));
			    //input.addElement(new Double(x2));
				double[] in = new double[2];
				in[0] = x1;
				in[1] = x2;
				Sample sample = new Sample(in, 0.0);
			    output = perceptron.recognize(sample);
			    inputSpaceCanvas.setBackground(x1,x2,
							   ((Double)output.firstElement()).doubleValue());
				
			}
		inputSpaceCanvas.repaint();
    }
    /**
     * Disables the text fields and controls during training.
     */

    public void disableDuringLearning() {
		parameters.setEnabled(false);
		controls.setEnabled(false);
    }

    /**
     * Enables the text fields.
     */

    public void enableDuringLearning() {
		parameters.setEnabled(true);
		controls.setEnabled(true);
    }

    /**
     * Return the contents of a textfield as an int.
     * @param TextField t - the textfield component.
     * @return int.
     * @exception NumberFormatException.
     */

    public int getFieldAsInt(Label t) {
		try {
		    return (Integer.valueOf(t.getText())).intValue();
		}
		catch (NumberFormatException e) {
		    t.setText("    0");
		    return 0;
		}
    }
	
    public void graphClose () {
		errorGraph.setVisible(false);
    } 
    
    public void destroy() {
	this.errorGraph.dispose();
    }

    public void stop() {
	this.errorGraph.dispose();
    }
    
    public static void main(String[] args) {
		SimplePerceptronApplet perceptronApplet = new SimplePerceptronApplet();
		
		System.out.println("apm: " + perceptronApplet.getParameter("applet_mode"));
		perceptronApplet.init();
		WindowListener windowListener = new WindowListener() {
			public void windowActivated(WindowEvent e) {}             
			public void windowClosed(WindowEvent e) {}
			public void windowClosing(WindowEvent e) {
			    System.exit(0);
			}
			public void windowDeactivated(WindowEvent e) {}
			public void windowDeiconified(WindowEvent e) {}
			public void windowIconified(WindowEvent e) {} 
			public void windowOpened(WindowEvent e) {}
		    };
		Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
		
		Frame myFrame = new Frame("Adaline, Perceptron, Backprop");
		myFrame.add(perceptronApplet);
		myFrame.addWindowListener(windowListener);
		
		myFrame.pack();
		myFrame.setLocation(Math.abs((dimension.width-myFrame.getSize().width)/2),Math.abs((dimension.height-myFrame.getSize().height)/2));
		myFrame.show();
    }
	
}