Dijkstracula fucked around with this message at 19:16 on Jun 4, 2009

Nippashish fucked around with this message at 03:00 on Jun 7, 2009

package main;
import java.util.ArrayList;

public class Neuron {
	protected ArrayList<Neuron> predecessors;
	protected ArrayList<Neuron> successors;	
	protected ArrayList<Integer> successorSlots;	// Slight perf enhancement: we know where in the successor input arrays our output goes.
	protected ArrayList<Double> inputWeights;
	protected ArrayList<Double> inputs;
	protected double output;
	protected int ID;
	private static int rotatingIDs = 0;
	
	public Neuron() throws Exception {
		predecessors = new ArrayList<Neuron>();
		successors = new ArrayList<Neuron>();
		successorSlots = new ArrayList<Integer>();
		inputWeights = new ArrayList<Double>();
		inputs = new ArrayList<Double>();
		ID = rotatingIDs;
		rotatingIDs++;		// Increment IDs pointer.  Overflow could happen. :(
		if(rotatingIDs == 0) {
			throw new Exception("Overflow occurred incrementing Neuron rotating ID pointers");
		}
		
		// Output value is undefined until we run a calculation.
		output = new Double(Double.NaN);
	}
	
	public void addPredecessor(Neuron predecessor, double weight) {
		predecessors.add(predecessor);
		inputWeights.add(weight);
		predecessor.successors.add(this);		
		
		inputs.add(predecessor.output);
		predecessor.successorSlots.add(inputs.size() - 1);
	}
	
	public void linkToSuccessor(Neuron successor, double weight) {
		successor.addPredecessor(this, weight);
	}
	
	// Evaluation function that fires based on predecessors, and propagates the result to successors.
	public double stimulate() {
		double summation = 0.0d;
		for(int predIdx = 0; predIdx < predecessors.size(); predIdx++) {
			summation += inputWeights.get(predIdx) * inputs.get(predIdx);
		}
		
		// Apply to sigmoid function: 1 / (1 + e^-t)
		output = 1 / (1 + Math.exp(-1.0d * summation));
		
		// Propagate to successors.
		for(int succIdx = 0; succIdx < successors.size(); succIdx++) {
			successors.get(succIdx).inputs.set(successorSlots.get(succIdx), output);
		}
		
		return output;
	}
	
	public double getOutput() {
		return output;
	}
	
	public boolean equals(Object comparee) {
		if(!(comparee instanceof Neuron)) {
			return false;
		} else {
			Neuron compareeNeuron = (Neuron) comparee;
			return compareeNeuron.ID == ID;
		}
	}
	
	// If we override equals() we have to re-implement hashCode()
	public int hashCode() {
		return 		successors.hashCode()
				^ 	predecessors.hashCode()
				^ 	successorSlots.hashCode()
				^ 	inputWeights.hashCode();				
	}
	
	public static void main(String args[]) {
		try {
	
			// Based on [url]http://www.gene-expression-programming.com/GepBook/Chapter5/Section3/SS1.htm[/url]
			
			InputNeuron x = new InputNeuron();
			InputNeuron y = new InputNeuron();

			// 2nd tree (commented out)
/*			Neuron hidden1 = new Neuron();
			Neuron outputNeuron = new Neuron();
			
			hidden1.addPredecessor(x, 0.773);
			hidden1.addPredecessor(y, 0.443);
			
			outputNeuron.addPredecessor(hidden1, -1.924);
			outputNeuron.addPredecessor(x, 1.161);
			outputNeuron.addPredecessor(y, 1.161);
			
			x.stimulate(1.0d);
			y.stimulate(0.0d);
		
			hidden1.stimulate();
			
			System.out.println(outputNeuron.stimulate());
*/
			
			// 1st tree (commented out)
			Neuron hidden1 = new Neuron();
			Neuron hidden2 = new Neuron();
			Neuron outputNeuron = new Neuron();
			
			hidden1.addPredecessor(x, -0.342);
			hidden1.addPredecessor(x, 1.694);
			hidden1.addPredecessor(x, 1.175);
			hidden1.addPredecessor(y, 1.956);

			hidden2.addPredecessor(x, 1.088);
			hidden2.addPredecessor(y, -0.738);
			hidden2.addPredecessor(y, -1.694);
			
			outputNeuron.addPredecessor(hidden1, 1.694);
			outputNeuron.addPredecessor(hidden2, -0.738);
			outputNeuron.addPredecessor(x, 1.088);
			
			x.stimulate(0.0d);
			y.stimulate(0.0d);
		
			hidden1.stimulate();
			hidden2.stimulate();
			
			System.out.println(outputNeuron.stimulate());
			
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
}

package main;

public class InputNeuron extends Neuron {

	public InputNeuron() throws Exception {
		super();
	}
	
	public void addPredecessor(Neuron predecessor, double weight) {
		// No predecessor
	}

	public void stimulate(Double _output) {
		output = _output;
		
		// Propagate to successors.
		for(int succIdx = 0; succIdx < successors.size(); succIdx++) {
			successors.get(succIdx).inputs.set(successorSlots.get(succIdx), output);
		}
	}
	
}

Rocko Bonaparte fucked around with this message at 04:45 on Jun 7, 2009

tripwire fucked around with this message at 00:51 on Jun 8, 2009

Rocko Bonaparte fucked around with this message at 17:52 on Jun 10, 2009