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]);
}
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;
}
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));
}
// 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]);
}
/// <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;
}
