private void setInputIsignalArray(ISignalArray inputArr, double[] inp) { for (int i = 0; i < inp.Length; i++) { inputArr[i] = inp[i]; } }
float ProcessInputPair(Renderer quadrant) { float output = 0f; //Input signals are used in the neural controller ISignalArray inputArr = box.InputSignalArray; inputArr[0] = input_1; inputArr[1] = input_2; //The neural network is activated box.Activate(); //And produces output signals (also in an array) ISignalArray outputArr = box.OutputSignalArray; //Output is between 0 and 1 output = (float)outputArr[0]; /* ISignalArray inputArr = box.InputSignalArray; * inputArr[0] = 0.88f; * inputArr[1] = 0.99f; * //inputArr[0] = input_1; * //inputArr[1] = input_2; * //The neural network is activated * box.Activate(); * //And produces output signals (also in an array) * ISignalArray outputArr = box.OutputSignalArray; * //Output is between 0 and 1 * output = (float)outputArr[0]; * Debug.Log(" "); * Debug.Log("Input array: " + inputArr[0] + " " + inputArr[1]); * Debug.Log("Output: " + output); * UnityEditor.EditorApplication.isPlaying = false;*/ return(output); }
private void FixedUpdate() { if (IsRunning) { target = GameObject.FindGameObjectWithTag("Target"); targetx = target.transform.position.x; targety = target.transform.position.y; // initialize input and output signal arrays ISignalArray inputArr = box.InputSignalArray; ISignalArray outputArr = box.OutputSignalArray; inputArr[0] = target.transform.position.x; inputArr[1] = target.transform.position.y; inputArr[3] = fitness; if (b == false) { box.Activate(); force.x = (float)outputArr[0] * 2000; force.y = (float)outputArr[1] * 2000; //Rotate(angle); Shoot(force); b = true; } distance = GetDistance(); if (distance > 0) {//cannot divide by zero and cannot be closer to something than 0 AddFitness(Mathf.Abs(1 / distance)); } } }
private List <string> SetInputSignalArray(ISignalArray inputArr, MyCell[] myBlocks) { var allBlockIds = new List <string>(); inputArr.Reset(); for (int row = 0; row < myBlocks.Length; row++) { for (int col = 0; col < myBlocks[row].Neighbours.Length; col++) { if (!allBlockIds.Contains(myBlocks[row].Neighbours[col].Id)) { allBlockIds.Add(myBlocks[row].Neighbours[col].Id); } var id = myBlocks[row].Neighbours[col].Id.Split('_'); var r = int.Parse(id[0]); var c = int.Parse(id[1]); inputArr[r * myBlocks.Length + c] = myBlocks[row].Neighbours[col].Owner == CellOwner.Own || myBlocks[row].Neighbours[col].Resources < 0 ? myBlocks[row].Neighbours[col].Resources : -myBlocks[row].Neighbours[col].Resources; } } allBlockIds.Sort(); return(allBlockIds); }
private void FixedUpdate() { if (IsRunning) { // initialize input and output signal arrays ISignalArray inputArr = box.InputSignalArray; ISignalArray outputArr = box.OutputSignalArray; inputArr[0] = red; inputArr[1] = green; inputArr[2] = blue; inputArr[3] = fitness; distance = Mathf.Sqrt((red - t_red) * (red - t_red) + (green - t_green) * (green - t_green) + (blue - t_blue) * (blue - t_blue)); box.Activate(); red = (float)outputArr[0]; green = (float)outputArr[1]; blue = (float)outputArr[2]; if (distance > 0) {//cannot divide by zero and cannot be closer to something than 0 AddFitness(Mathf.Abs(1 / distance)); } ChangeColor(red, green, blue); } }
private IEnumerator RunSim() { while (IsRunning) { outputArr = box.OutputSignalArray; inputArr = box.InputSignalArray; inputArr[0] = pos.x; inputArr[1] = pos.y; inputArr[2] = nodes.Count; inputArr[3] = timer; inputArr[4] = MaxX; inputArr[5] = MaxY; inputArr[6] = MinX; inputArr[7] = MinY; box.Activate(); for (int i = 0; i < muscles.Count; i++) { muscles[i].Length = (float)outputArr[i] * TestSettings.Instance.lMax; //print((float)outputArr[i] * TestSettings.Instance.lMax); //muscles[i].exertForce(nodes); } foreach (Node node in nodes) { //node.ApplyForces(); } timer += 2; yield return(new WaitForSeconds(0.2f)); } }
public FitnessInfo Test(IBlackBox box) { double fitness, altFitness; //these are our inputs and outputs ISignalArray inputArr = box.InputSignalArray; ISignalArray outputArr = box.OutputSignalArray; List <Sample> sampleList = LEEAParams.DOMAIN.getTestSamples(); int sampleCount = sampleList.Count; fitness = sampleList.Count; foreach (Sample sample in sampleList) { inputArr.CopyFrom(sample.Inputs, 0); box.ResetState(); box.Activate(); fitness -= Math.Abs(outputArr[0] - sample.Outputs[0]) * Math.Abs(outputArr[0] - sample.Outputs[0]); } fitness = Math.Max(fitness, LEEAParams.MINFITNESS) + LEEAParams.FITNESSBASE; return(new FitnessInfo(fitness, 0)); }
private void FixedUpdate() { if (isRunning) { // Pass sensor inputs to neural network ISignalArray inputArr = box.InputSignalArray; int i = 0; foreach (SectorSensor sectorSensor in sectorSensors) { for (int j = 0; j < sectorSensor.NumSenses; ++j) { inputArr[i] = sectorSensor.GetSectorSense(j); ++i; } } foreach (DistanceSensor distanceSensor in distanceSensors) { for (int j = 0; j < distanceSensor.numSensors; ++j) { inputArr[i] = distanceSensor.GetSense(j); ++i; } } if (attributes.needsFood) { // Response high at low energy inputArr[i] = 1 - attributes.Energy / attributes.maxEnergy; ++i; } if (attributes.needsWater) { // Response high at low hydration inputArr[i] = 1 - attributes.Hydration / attributes.maxHydration; ++i; } if (movementController.senseSpeed) { inputArr[i] = rb.velocity.magnitude / movementController.moveSpeed; ++i; } if (movementController.senseSwimming) { inputArr[i] = movementController.IsSwimming ? 1 : 0; ++i; } // Activate neural network box.Activate(); // Read outputs from neural network into movement input. ISignalArray outputArr = box.OutputSignalArray; xInput = (float)outputArr[0] * 2 - 1; yInput = (float)outputArr[1] * 2 - 1; } }
static bool CheckOutputs(ISignalArray output, IGameInstance gameInstance) { /* * outputs: * move < -.5 = left > .5 = right * rotate >= .5 * drop > .5 */ if (output[0] <= -0.5) { gameInstance.MoveLeft(); } else if (output[0] >= 0.5) { gameInstance.MoveRight(); } if (output[1] >= 0.5) { gameInstance.Rotate(); } if (output[2] > 0.5) { gameInstance.FinishMove(); return(true); } return(false); }
static void BlockTypeToInput(ISignalArray array, int offset, BlockType blockType) { for (var I = 0; I < NumBlockTypes; ++I) { array[I + offset] = I == (int)blockType ? 1 : -1; } }
public ISignalArray getInput(ISignalArray input) { // Do we see the monster? // TODO // Inputs input [0] = this.getPathCount(); // Forward path count input [1] = this.glanceDirection(false, 3); input [2] = this.glanceDirection(true, 3); input [3] = (float)(this.back_count / 24); // TODO input [4] = this.monsterDirection(); input [5] = this.seeBomb(); input [6] = this.seeCabinet(); // input [7] = this.seePowerUp (); input [7] = this.getHealth(); input [8] = this.hasSprintA(); if (has_bomb) { input [9] = 1.0f; } else { input [9] = 0.0f; } return(input); }
public void MapInputs(ISignalArray inputSignalArray, SimpleSnakeWorld SnakeWorld) { int wi, hi; //_phenome.InputSignalArray.Reset(); for (wi = 0; wi < SnakeWorld.Width; wi++) { for (hi = 0; hi < SnakeWorld.Height; hi++) { Tile currTile = SnakeWorld[wi, hi]; //maybe enclose in a function to linearize...? inputSignalArray[wi * SnakeWorld.Height + hi] = _tileToInput[currTile]; //HERES THE FOKKIN BUG //Console.WriteLine("_phenome.InputSignalArray[" + (wi * _sw.CurrHeight + hi) + "] = " + _tileToInput[currTile] + " - " + currTile); } } int i; for (i = InputCount - 4; i < InputCount; i++) { inputSignalArray[i] = -1; } inputSignalArray[InputCount - 1 - _dirToIndex[SnakeWorld.SnakeDirection]] = 1; }
void FixedUpdate() { if (isRunning) { // Set up inputs as array and feed it to the network ISignalArray inputArr = neat.InputSignalArray; double x = NormalizeValues(max, min, transform.position.x); double z = NormalizeValues(max, min, transform.position.z); inputArr[0] = x; inputArr[1] = z; neat.Activate(); // Get outputs //TODO: Make outputs be able to have negative values as well ISignalArray outputArr = neat.OutputSignalArray; outputArr[0] = (outputArr[0] < 0.5f) ? outputArr[0] * -1 : outputArr[0]; outputArr[1] = (outputArr[1] < 0.5f) ? outputArr[0] * -1 : outputArr[1]; float outputX = (float)outputArr[0] * 10.0f; float outputZ = (float)outputArr[1] * 10.0f; rb.AddForce(new Vector3(outputX, 0.0f, outputZ)); //DebugNetwork(inputArr, outputArr); } }
public void MapOutputs(ISignalArray outputSignalArray, SimpleSnakeWorld sw) { int dirIndex = 0; double maxVal = double.MinValue; //lock (_consoleLock) { //Console.WriteLine("--------------------"); //Console.WriteLine("outputSignalArray.Length = " + outputSignalArray.Length); for (int i = 0; i < outputSignalArray.Length; i++) { //Console.WriteLine("outputSignalArray[" + i + "] (Direction " + _intToDir[i] + ") - val: " + outputSignalArray[i]); if (outputSignalArray[i] > maxVal) { maxVal = outputSignalArray[i]; dirIndex = i; } } //Console.WriteLine("CHOSEN: outputSignalArray[" + dirIndex + "] (Direction " + _intToDir[dirIndex] + ") - val: " + outputSignalArray[dirIndex] + " - " + maxVal); //Console.WriteLine("--------------------"); } sw.NextDirection = _intToDir[dirIndex]; }
protected override void UpdateBlackBoxInputs(ISignalArray inputSignalArray) { float frontSensor = 0; float leftFrontSensor = 0; float leftSensor = 0; float rightFrontSensor = 0; float rightSensor = 0; // Five raycasts into different directions each measure how far a wall is away. RaycastHit hit; if (Physics.Raycast(transform.position + transform.forward * 1.1f, transform.TransformDirection(new Vector3(0, 0, 1).normalized), out hit, SensorRange)) { if (hit.collider.CompareTag("Wall")) { frontSensor = 1 - hit.distance / SensorRange; } } if (Physics.Raycast(transform.position + transform.forward * 1.1f, transform.TransformDirection(new Vector3(0.5f, 0, 1).normalized), out hit, SensorRange)) { if (hit.collider.CompareTag("Wall")) { rightFrontSensor = 1 - hit.distance / SensorRange; } } if (Physics.Raycast(transform.position + transform.forward * 1.1f, transform.TransformDirection(new Vector3(1, 0, 0).normalized), out hit, SensorRange)) { if (hit.collider.CompareTag("Wall")) { rightSensor = 1 - hit.distance / SensorRange; } } if (Physics.Raycast(transform.position + transform.forward * 1.1f, transform.TransformDirection(new Vector3(-0.5f, 0, 1).normalized), out hit, SensorRange)) { if (hit.collider.CompareTag("Wall")) { leftFrontSensor = 1 - hit.distance / SensorRange; } } if (Physics.Raycast(transform.position + transform.forward * 1.1f, transform.TransformDirection(new Vector3(-1, 0, 0).normalized), out hit, SensorRange)) { if (hit.collider.CompareTag("Wall")) { leftSensor = 1 - hit.distance / SensorRange; } } // modify the ISignalArray object of the blackbox that was passed into this function, by filling it with the sensor information. // Make sure that NeatSupervisor.NetworkInputCount fits the amount of sensors you have inputSignalArray[0] = frontSensor; inputSignalArray[1] = leftFrontSensor; inputSignalArray[2] = leftSensor; inputSignalArray[3] = rightFrontSensor; inputSignalArray[4] = rightSensor; }
public BlackBoxDummy(int inputCount, int outputCount) { InputCount = inputCount; OutputCount = outputCount; _inputSignalArray = new SignalArray(new double[inputCount + 1], 0, inputCount + 1); // +1 for bias _outputSignalArray = new SignalArray(new double[outputCount], 0, outputCount); Step = -1; }
public void MapOutputs(ISignalArray outputSignalArray, SimpleSnakeWorld sw) { //[-1,1] -> [0,4] double dirNum = (outputSignalArray[0] + 1) * 2; int dirIndex = (int)Math.Floor(dirNum); sw.NextDirection = _intToDir[dirIndex]; }
public void PrintOutputs(ISignalArray outputs) { Debug.Log("******** OUTPUT ARRAY FOR " + gameObject.name + ": ********"); for (int i = 0; i < outputs.Length; i++) { Debug.Log("[" + i + "]" + " : [" + outputs[i] + "]"); } }
// DEBUGGING FUNCTIONS: public void PrintInputs(ISignalArray inputs) { Debug.Log("******** INPUT ARRAY FOR " + gameObject.name + ": ********"); for (int i = 0; i < inputs.Length; i++) { Debug.Log("[" + i + "]" + " : [" + inputs[i] + "]"); } }
// Start is called before the first frame update void Start() { ISignalArray inputArr = box.InputSignalArray; ISignalArray outputArr = box.OutputSignalArray; inputArr[0] = 3; Debug.Log(outputArr[0]); }
void FixedUpdate() { if (IsRunning) { // input array assained to constant because without it output is constantly 0.5f ISignalArray inputArr = box.InputSignalArray; for (var i = 0; i < 21; i++) { inputArr[i] = 0.5f; } box.Activate(); ISignalArray outputArr = box.OutputSignalArray; JointCount = (int)Mathf.Round((float)outputArr[0] * 5 + 1); /* * string tests = ""; * for(var i = 0; i < 21; i++) * { * tests += i + ": " + (float)outputArr[i] + " "; * } * Debug.Log(tests); */ for (int i = 0; i < JointCount; i++) // spawning joints { // get joint position float JointPositionX = Mathf.Cos(i * 2f * Mathf.PI / JointCount); float JointPositionY = Mathf.Sin(i * 2f * Mathf.PI / JointCount); Vector3 JointPosition = new Vector3(JointPositionX, JointPositionY, 0f); // get joint rotation float JointRotationZ = 90f + i * (360 / JointCount); Quaternion JointRotation = Quaternion.Euler(new Vector3(transform.rotation.x, transform.rotation.y, JointRotationZ)); //create joint GameObject obj = Instantiate(JointPrefab, JointPosition, JointRotation, transform); //change joint scale obj.transform.localScale = new Vector3(transform.localScale.x, transform.localScale.y + (float)outputArr[i + 1], transform.localScale.z); //fix position based on scale float newObjPositionX = obj.transform.position.x + Mathf.Cos(i * 2f * Mathf.PI / JointCount) * obj.transform.localScale.y / 3; float newObjPositionY = obj.transform.position.y + Mathf.Sin(i * 2f * Mathf.PI / JointCount) * obj.transform.localScale.y / 3; obj.transform.position = new Vector3(newObjPositionX, newObjPositionY, obj.transform.position.z); //send wheel radius to joint obj.GetComponent <JointScript>().SetWheelRadius((float)outputArr[i + 11]); SetupHingeJointComponent(obj); } Stop(); } }
private void SetInputSignalArray(ISignalArray inputSignalArray, ScreenInputSignal screenInputSignal) { inputSignalArray[0] = screenInputSignal.YTopBirdCoordinate; inputSignalArray[1] = screenInputSignal.YBottomBirdCoordinate; inputSignalArray[2] = screenInputSignal.DistanceToNextObstacle; inputSignalArray[3] = screenInputSignal.ObstacleBoundary1; inputSignalArray[4] = screenInputSignal.ObstacleBoundary2; inputSignalArray[5] = screenInputSignal.IsBirdDead ? 1 : 0; }
public static void WriteImage(string imageName, ISignalArray outputSignalArray) { double[] convertedSignalArray = new double[outputSignalArray.Length]; for (int idx = 0; idx < outputSignalArray.Length; idx++) { convertedSignalArray[idx] = outputSignalArray[idx]; } WriteImage(imageName, convertedSignalArray); }
/// <summary> /// Calculates the output error for each node in the target layer and all hidden layers. Note that this is a wrapper /// method which takes a signal array, converts it to a double array, and passes that on to the method below. /// </summary> /// <param name="layers">The discrete layers in the ANN.</param> /// <param name="connections">Array of all connections in the ANN.</param> /// <param name="nodeActivationValues">The neuron activation values resulting from the last forward pass.</param> /// <param name="targetValues">The target values against which the network is being trained.</param> /// <param name="nodeActivationFunctions">The activation function for each neuron (this will only differ with HyperNEAT).</param> /// <returns>The errors for each output and hidden neuron.</returns> public static double[] CalculateErrorSignals(LayerInfo[] layers, FastConnection[] connections, double[] nodeActivationValues, ISignalArray outputValues, ISignalArray targetValues, IActivationFunction[] nodeActivationFunctions) { double[] targets = new double[targetValues.Length]; // Load the target double array from the input signal array targetValues.CopyTo(targets, 0); // Return the error signals return CalculateErrorSignals(layers, connections, nodeActivationValues, (MappingSignalArray) outputValues, targets, nodeActivationFunctions); }
private void FixedUpdate() { int offset = 0; Vector2 gridPos = new Vector2(Mathf.Round(transform.position.x / 3), Mathf.Round(transform.position.z / 3)); /********* INPUTS **********/ ISignalArray inputArr = box.InputSignalArray; inputArr[offset++] = Random.Range(0, 2); inputArr[offset++] = explored.Contains(gridPos) ? 1 : -1; float minDist = 99999; foreach (Eye eye in eyes) { eye.SetFollow(true); // Indica que si detecte al jugador List <double> rays = eye.Update(); for (int i = 0; i < rays.Count; i += 3) { inputArr[i + offset + 0] = (float)rays[i + 0]; // Distance inputArr[i + offset + 1] = (float)rays[i + 1]; // Player detected inputArr[i + offset + 2] = (float)rays[i + 2]; // Wall detected if ((rays[i + 1] == 1) && (rays[i + 0] < minDist)) { minDist = (float)rays[i + 0]; } } offset += rays.Count; } /********* ACTIVATE **********/ box.Activate(); /********* OUTPUTS **********/ ISignalArray outputArr = box.OutputSignalArray; // Cambia la función distancia para que no sea una función lineal (sino una sigmoide) minDist = (minDist < 0.9) ? (10f * minDist / Mathf.Sqrt(1f + 100f * minDist * minDist)) : 1; if (minDist < 0.2) { minDist = 0; } // El valor de la rotación, cambia la función para que se comporte no como lineal sino como una cúbica float rotation = (float)outputArr[0] * (float)outputArr[0] * (float)outputArr[0]; /********* MOVEMENT **********/ transform.Rotate(Vector3.up, (rotation * 2 - 1) * rotSpeed); transform.position += transform.forward * Time.fixedDeltaTime * speed * minDist; explored.Add(gridPos); }
// Loads the board into the input signal array. // This just flattens the 2d board into a 1d array. private void setInputSignalArray(ISignalArray inputArr, SquareTypes[,] board) { inputArr[0] = squareToInt(board[0, 0]); inputArr[1] = squareToInt(board[1, 0]); inputArr[2] = squareToInt(board[2, 0]); inputArr[3] = squareToInt(board[0, 1]); inputArr[4] = squareToInt(board[1, 1]); inputArr[5] = squareToInt(board[2, 1]); inputArr[6] = squareToInt(board[0, 2]); inputArr[7] = squareToInt(board[1, 2]); inputArr[8] = squareToInt(board[2, 2]); }
void NeatInputUpdate() { ISignalArray neatInputs = _box.InputSignalArray; RaycastHit hit; float dx = 0.1f; { int numHits = 0; float average = 0.0f; for (int i = 0; i < 3; i++) { if (Physics.Raycast(transform.position, transform.up + transform.right * (dx * (i - 1)), out hit, sensorRange)) { average += 1 - hit.distance / sensorRange; numHits += 1; } } numHits = Mathf.Max(numHits, 1); average /= numHits; neatInputs [0] = average; } if (Physics.Raycast(transform.position, transform.up - transform.right, out hit, sensorRange)) { neatInputs [1] = 1 - hit.distance / sensorRange; } if (Physics.Raycast(transform.position, transform.up + transform.right, out hit, sensorRange)) { neatInputs [2] = 1 - hit.distance / sensorRange; } if (Physics.Raycast(transform.position, -transform.right, out hit, sensorRange)) { neatInputs [3] = 1 - hit.distance / sensorRange; } if (Physics.Raycast(transform.position, transform.right, out hit, sensorRange)) { neatInputs [4] = 1 - hit.distance / sensorRange; } _box.Activate(); ISignalArray neatOutputs = _box.OutputSignalArray; forwardInput = (float)neatOutputs [0] * 2 - 1; turnInput = (float)neatOutputs [1] * 2 - 1; }
private void setInputSignalArray(ISignalArray inputSignalArray, Board board) { inputSignalArray[0] = (int)board.Squares[0, 0].State; inputSignalArray[1] = (int)board.Squares[1, 0].State; inputSignalArray[2] = (int)board.Squares[2, 0].State; inputSignalArray[3] = (int)board.Squares[0, 1].State; inputSignalArray[4] = (int)board.Squares[1, 1].State; inputSignalArray[5] = (int)board.Squares[2, 1].State; inputSignalArray[6] = (int)board.Squares[0, 2].State; inputSignalArray[7] = (int)board.Squares[1, 2].State; inputSignalArray[8] = (int)board.Squares[2, 2].State; }
protected override void UseBlackBoxOutpts(ISignalArray outputSignalArray) { // Called by the base class after the inputs have been processed // Read the outputs and do something with them // The size of the array corresponds to NeatSupervisor.NetworkOutputCount /* EXAMPLE */ //someMoveDirection = outputSignalArray[0]; //someMoveSpeed = outputSignalArray[1]; //... }
protected override void UpdateBlackBoxInputs(ISignalArray inputSignalArray) { // Called by the base class on FixedUpdate // Feed inputs into the Neural Net (IBlackBox) by modifying its InputSignalArray // The size of the input array corresponds to NeatSupervisor.NetworkInputCount /* EXAMPLE */ //inputSignalArray[0] = someSensorValue; //inputSignalArray[1] = someOtherSensorValue; //... }
public void MapInputs(ISignalArray inputSignalArray, SimpleSnakeWorld SnakeWorld) { IEnumerable <TwoDPoint> points = SnakeWorld.FoodPoints; int i; int elIndex; // count*2 perché devo contrare entrambe le coordinate for (i = 0; i < points.Count() * 2;) { elIndex = i / 2; inputSignalArray[i] = ((double)points.ElementAt(elIndex).X) / _width; i++; inputSignalArray[i] = ((double)points.ElementAt(elIndex).Y) / _height; i++; } for (i = 0; i < points.Count(); i++) { inputSignalArray[i + _foodCoordinatesNumber] = 1.0; } for (; i < _maxFood; i++) { inputSignalArray[i + _foodCoordinatesNumber] = -1.0; } points = SnakeWorld.GetSnakeHeadingPoints(_startLen); for (i = 0; i < _startLen * 2;) { elIndex = i / 2; inputSignalArray[i + _foodCoordinatesNumber + _maxFood] = ((double)points.ElementAt(elIndex).X) / _width;; i++; inputSignalArray[i + _foodCoordinatesNumber + _maxFood] = ((double)points.ElementAt(elIndex).Y) / _height; i++; } for (i = InputCount - 4; i < InputCount; i++) { inputSignalArray[i] = -1; } if (SnakeWorld.SnakeDirection == Direction.None) { return; } inputSignalArray[InputCount - 1 - _dirToIndex[SnakeWorld.SnakeDirection]] = 1; }
/// <summary> /// Evaluate the provided IBlackBox against the MNIST problem domain and return its fitness/novlety score. /// </summary> public FitnessInfo Evaluate(IBlackBox box) { //just keep track of evals //_evalCount++; double fitness, altFitness; //these are our inputs and outputs ISignalArray inputArr = box.InputSignalArray; ISignalArray outputArr = box.OutputSignalArray; List <Sample> sampleList = LEEAParams.DOMAIN.getSamples(); int sampleCount = sampleList.Count; fitness = sampleList.Count; foreach (Sample sample in sampleList) { inputArr.CopyFrom(sample.Inputs, 0); box.ResetState(); box.Activate(); fitness -= Math.Abs(outputArr[0] - sample.Outputs[0]) * Math.Abs(outputArr[0] - sample.Outputs[0]); } // set alternate fitness to fitness measured against all samples if (SharedParams.SharedParams.PERFORMFULLEVAL) { sampleList = LEEAParams.DOMAIN.getValidationSamples(); altFitness = sampleList.Count; foreach (Sample sample in sampleList) { inputArr.CopyFrom(sample.Inputs, 0); box.ResetState(); box.Activate(); altFitness -= Math.Abs(outputArr[0] - sample.Outputs[0]) * Math.Abs(outputArr[0] - sample.Outputs[0]); } } else { altFitness = 0; } fitness = Math.Max(fitness, LEEAParams.MINFITNESS) + LEEAParams.FITNESSBASE; return(new FitnessInfo(fitness, altFitness)); }
/// <summary> /// Calculates the error of the network by comparing the difference between each input and its corresponding output. /// The total of the differences is the error. /// </summary> /// <param name="inputSignalArray">The input signal array.</param> /// <param name="outputSignalArray">The output signal array.</param> /// <returns></returns> public static double CalculateOutputError(ISignalArray inputSignalArray, ISignalArray outputSignalArray) { // Make sure that the input and output array are of the same length Debug.Assert(inputSignalArray.Length == outputSignalArray.Length, "Input and output signal arrays are different lengths."); double activationDiff = 0.0; // Compare each input to its corresponding output, taking the absolute value of the difference in activation for (int idx = 0; idx < inputSignalArray.Length; idx++) { activationDiff += Math.Abs(inputSignalArray[idx] - outputSignalArray[idx]); } return activationDiff; }