Also, here is my code so far. (prepare yourself for some crappy code.) [code] /*this code is used to train a "robot" to face toward the brightest light in the room using an artificial neural network. This code is made by me (Moist_Plasma). based off my very limited knowledge of ANNs and coding. This could more than likely be done in a much more effictive way that I have created. */ int input1 = A0; int input2 = A1; int input3 = A2; int input4 = A3; float input1Val; float input2Val; float input3Val; float input4Val; float input1Weight[4]; float input2Weight[4]; float input3Weight[4]; float input4Weight[4]; float layer1_1Val; float layer1_2Val; float layer1_3Val; float layer1_4Val; float layer1_1Weight[2]; float layer1_2Weight[2]; float layer1_3Weight[2]; float layer1_4Weight[2]; float output1; float output2; //float learningRate = 0.2; unused for now. void setup() { Serial.begin(9600); delay(1000); generateInputWeights(); generateLayer1Weights(); } void loop() { /* VALUES COME FROM 4 LDRs input1Val = anaglogRead(input1); input2Val = anaglogRead(input2); input3Val = anaglogRead(input3); input4Val = anaglogRead(input4); */ //temp random values before LDR circuit is built. input1Val = 276; input2Val = 754; input3Val = 335; input4Val = 656; Serial.println("RAW INPUT VALUES"); Serial.print("input 1 = "); Serial.println(input1Val); Serial.print("input 2 = "); Serial.println(input2Val); Serial.print("input 3 = "); Serial.println(input3Val); Serial.print("input 4 = "); Serial.println(input4Val); Serial.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------"); //make LDR values between 0 and 1000 so thay can be can be converted to a value between 0 and 1. input1Val = map(input1Val, 0, 1023, 0, 1000); input2Val = map(input2Val, 0, 1023, 0, 1000); input3Val = map(input3Val, 0, 1023, 0, 1000); input4Val = map(input4Val, 0, 1023, 0, 1000); // convert input value to a decimal between 0 and 1. input1Val = input1Val / 1000; input2Val = input2Val / 1000; input3Val = input3Val / 1000; input4Val = input4Val / 1000; Serial.println("INPUT VALUES CONVERTED TO A DECIMAL POINT BETWEEN 0 AND 1"); Serial.print("input 1 = "); Serial.println(input1Val); Serial.print("input 2 = "); Serial.println(input2Val); Serial.print("input 3 = "); Serial.println(input3Val); Serial.print("input 4 = "); Serial.println(input4Val); Serial.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------"); //determine layer 1 values based upon inputs and weights. layer1_1Val = input1Val * input1Weight[0] + input2Val * input2Weight[0] + input3Val * input3Weight[0] + input4Val * input4Weight[0]; layer1_2Val = input1Val * input1Weight[1] + input2Val * input2Weight[1] + input3Val * input3Weight[1] + input4Val * input4Weight[1]; layer1_3Val = input1Val * input1Weight[2] + input2Val * input2Weight[2] + input3Val * input3Weight[2] + input4Val * input4Weight[2]; layer1_4Val = input1Val * input1Weight[3] + input2Val * input2Weight[3] + input3Val * input3Weight[3] + input4Val * input4Weight[3]; Serial.println("LAYER 1 NEURON VALUES BEFORE SIGMOID FUNCTION"); Serial.print("layer1_1Val = "); Serial.println(layer1_1Val); Serial.print("layer1_2Val = "); Serial.println(layer1_2Val); Serial.print("layer1_3Val = "); Serial.println(layer1_3Val); Serial.print("layer1_4Val = "); Serial.println(layer1_4Val); Serial.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------"); //takes the values of layer 1 "neurons" and applies a Sigmoid function to produce a number between 0 and 1. //the larger the number, the closer to 1 after the function. //the more negitive a number, the closer to 0 after the function. layer1_1Val = 1 / (1 + exp(-1 * layer1_1Val)); layer1_2Val = 1 / (1 + exp(-1 * layer1_2Val)); layer1_3Val = 1 / (1 + exp(-1 * layer1_3Val)); layer1_4Val = 1 / (1 + exp(-1 * layer1_4Val)); Serial.println("LAYER 1 NEURON VALUES AFTER SIGMOID FUNCTION"); Serial.print("layer1_1Val = "); Serial.println(layer1_1Val); Serial.print("layer1_2Val = "); Serial.println(layer1_2Val); Serial.print("layer1_3Val = "); Serial.println(layer1_3Val); Serial.print("layer1_4Val = "); Serial.println(layer1_4Val); Serial.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------"); //cauculates output value based upon layer 1 values and weights. output1 = layer1_1Val * layer1_1Weight[0] + layer1_2Val * layer1_2Weight[0] + layer1_3Val * layer1_3Weight[0] + layer1_4Val * layer1_4Weight[0]; output2 = layer1_1Val * layer1_1Weight[1] + layer1_2Val * layer1_2Weight[1] + layer1_3Val * layer1_3Weight[1] + layer1_4Val * layer1_4Weight[1]; Serial.println("OUTPUT VALUES BEFORE SIGMOID FUNCTION"); Serial.print("output1 = "); Serial.println(output1); Serial.print("output2 = "); Serial.println(output2); Serial.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------"); // APPLIES A SIGMOID FUNCTION TO OUTPUT VALUES. output1 = 1 / (1 + exp(-1 * output1)); output2 = 1 / (1 + exp(-1 * output2)); Serial.println("OUTPUT VALUES AFTER SIGMOID FUNCTION"); Serial.print("output1 = "); Serial.println(output1); Serial.print("output2 = "); Serial.println(output2); Serial.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------"); Serial.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------"); Serial.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------"); delay(1000); // this is just to slow the Serial monitor display. It will be removed after the network can train itself. // do what with output data??? //how do I change weights based upon output data??? } void generateInputWeights() { //---------------------------------------generate input weights------------------------------------------------------------------ //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX //generate input 1 weights for (int x = 0; x <= 3; x++) { input1Weight[x] = random(1, 101); //101 because random number generator subtracts 1 from max. } //generate input 2 weights for (int x = 0; x <= 3; x++) { input2Weight[x] = random(1, 101); //101 because random number generator subtracts 1 from max. } //generate input 3 weights for (int x = 0; x <= 3; x++) { input3Weight[x] = random(1, 101); //101 because random number generator subtracts 1 from max. } //generate input 4 weights for (int x = 0; x <= 3; x++) { input4Weight[x] = random(1, 101); //101 because random number generator subtracts 1 from max. } //--------------------------------------convert input weights to float values--------------------------------------------------- //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX for (int x = 0; x <= 3; x++) { input1Weight[x] = input1Weight[x] / 100; } for (int x = 0; x <= 3; x++) { input2Weight[x] = input2Weight[x] / 100; } for (int x = 0; x <= 3; x++) { input3Weight[x] = input3Weight[x] / 100; } for (int x = 0; x <= 3; x++) { input4Weight[x] = input4Weight[x] / 100; } } void generateLayer1Weights() { //---------------------------------------generate layer 1 weights---------------------------------------------------------------- //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX //generate layer 1-1 weights for (int x = 0; x <= 1; x++) { layer1_1Weight[x] = random(1, 101); //101 because random number generator subtracts 1 from max. } //generate layer 1-2 weights for (int x = 0; x <= 1; x++) { layer1_2Weight[x] = random(1, 101); //101 because random number generator subtracts 1 from max. } //generate layer 1-3 weights for (int x = 0; x <= 1; x++) { layer1_3Weight[x] = random(1, 101); //101 because random number generator subtracts 1 from max. } //generate layer 1-4 weights for (int x = 0; x <= 1; x++) { layer1_4Weight[x] = random(1, 101); //101 because random number generator subtracts 1 from max. } //--------------------------------------convert layer 1 weights to float values--------------------------------------------------- //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX for (int x = 0; x <= 1; x++) { layer1_1Weight[x] = layer1_1Weight[x] / 100; } for (int x = 0; x <= 1; x++) { layer1_2Weight[x] = layer1_2Weight[x] / 100; } for (int x = 0; x <= 1; x++) { layer1_3Weight[x] = layer1_3Weight[x] / 100; } for (int x = 0; x <= 1; x++) { layer1_4Weight[x] = layer1_4Weight[x] / 100; } } [/code]