[quote name='CryoGenesis' timestamp='1332101788' post='4923102']
Whats the point of Bias?
Is it needed for the neural network to function?

Oh and does the bias have to be used for every node or just the input nodes?

[/quote]
The bias has to be used with any node that does signal integration, so typically all the nodes except input ones (since these are just 'slots' to provide input to the net).
[/quote]

Thanks for the info but now it always returns between 0.6 - 0.7...

Here is the source code just in case I've done something wrong


package AI;
public class Node {
public float[] weight;
public float value;
public float activation;
public final float e = 2.7183f;
public final float p = 1;

public boolean in = false;

public Node(float[] weight){
this.weight = weight;
}

public static void main(String[] args){
NeuralNetwork net = new NeuralNetwork(1,1,2,2);
net.createNetwork();
float[] f = {100f};
net.input(f);
System.out.println(net.getOutput(0));
}
public float activationSigmoidMethod(float activation){
double a = -activation/p;
double b = e;

double c = Math.pow(e, a);
double e = 1 + c;
double f = 1/e;

return (float) f;

}

public void input(Node[] node, int num){
if(in = true){
activation += 1;
}
for(int i = 0; i < node.length; i++){
activation += (node.value * node.weight[num]);
}
value = activationSigmoidMethod(activation);
activation = 0;
}

public float getOutput(){
return value;
}



}


package AI;
import java.util.Random;
public class NeuralNetwork {
public Node[] in;
public Node[] out;
public Node[][] node;

public NeuralNetwork(int ins, int outs, int layers, int num){
in = new Node[ins];
out = new Node[outs];
node = new Node[layers][num];
}

public float[][] returnInWeights(){
float[][] ini = new float[in.length][node[0].length];
for(int i = 0; i < in.length; i ++){
for(int b = 0; b < node[0].length; b++){
ini = in.weight;
}
}
return ini;
}
public float[][][] returnNodeNormWeights(){
float[][][] weight = new float[node.length][node[0].length][node[0][0].weight.length];
for(int i = 0; i < node.length - 1; i ++){
for(int b = 0; b < node.length; b ++){
for(int a = 0; a < node.weight.length; a++){
weight[a] =node.weight[a];
}
}
}
return weight;
}
public float[][] returnOutNodeWeights(){
int length = node.length - 1;
float[][] nodes = new float[node[length].length][node[length][node[length].length].weight.length];
for(int i = 0; i < node[length].length; i ++){
for(int b = 0; b < node[length][node[length].length].weight.length; b++){
nodes = node[length].weight;
}
}
return nodes;
}

public float[] returnRanWeights(int amount){
Random a = new Random();
float[] weight = new float[amount];
for(int i = 0; i < amount; i ++){
weight = a.nextFloat() + a.nextFloat() - 1;
}
return weight;
}

public void createNetwork(){
for(int i = 0; i < in.length; i ++){
in = new Node(returnRanWeights(node[0].length));
in.in = true;
}
for(int i = 0; i < node.length; i ++){
for(int b = 0; b < node.length; b ++){

if(i < node.length - 1){
node = new Node(returnRanWeights(node[i + 1].length));
}else{
node = new Node(returnRanWeights(out.length));
}

}
}
for(int i = 0; i < out.length; i ++){
out = new Node(null);

}
}

public void input(float[] inp){
for(int i = 0; i < in.length; i++){
in.value = inp;

}

for(int i = 0; i < node.length; i ++){
for(int b = 0; b < node.length; b ++){

if(i == 0){
node.input(in, b);
}else{

node.input(node[i-1],b);

}


}
}

for(int i = 0; i < out.length; i++){
out.input(node[node.length - 1], i);
}

}

public float getOutput(int num){
return out[num].getOutput();
}
public float[] getOutput(){
float[] a = new float[out.length];
for(int i = 0; i < a.length; i++){
a = getOutput(i);
}
return a;
}


}


(this is not activation+=1 but activation+=W0)

I think you can add a bias to your nodes without modifying too much your code.
Add an extra component to your input array and put 1.0 in it at the start of the program. Your input vectors are now : [1.0,i1,i2,....,in].
Then W0, ie the weigth associated to your constant input value 1.0 will evoluate like any other weight.

Finally adding a bias to a net is (just) equivalent to add a 1.0 extra input to it

(more precisely any constant value but [s]nobody cares[/s] that's irrelevant and 1.0 is the usual choice)

An example maybe ? Let's say I want to approximate a 2-parameters (x and y) function with a single node.
So I have to add a third component to the input set to 1.0
Then the node has 2+1 inputs (so 3 weights too) and the input vector is [1.0,x,y]
So the integration is W0*1+W1*x+W2*y

So the code of a node 'without bias' is perfect : just add an extra 1.0 to its input and it's done, you have a node with a bias.