/// <summary>
/// Create new struct from existing.
/// </summary>
/// <param name="src">Existing layer to copy.</param>
public NeuralNetworkLayer(NeuralNetworkLayer src)
{
numberOfNeurons = src.numberOfNeurons;
recurring = src.recurring;
activationFunction = src.activationFunction;
biases = null;
}
//breed data with partner, partner must have the same # neurons/synapses
//takes a random selection of weights and biases from partner and replaces the a %(partPartner) of this classes weights/classes with those
//partPartner is the % of weights and biases to use from the partner, 0 being none and 1 being all the weights/biases
/// <summary>
/// Breed with another layer(partner) taking a %(partPartner) of randomly selected biases.
/// </summary>
/// <param name="partner">Partner layer.</param>
/// <param name="partPartner">Percent(0-1) of biases to take from partner.</param>
public void Breed(NeuralNetworkLayer partner)
{
int i = numberOfNeurons;
while (i-- > 0)
{
//randomly mix
float val = Utils.NextFloat01();
biases[i] = biases[i] * val + partner.biases[i] * (1.0f - val);
}
}
/// <summary>
/// Copy biases from layer.
/// </summary>
/// <param name="nnl">Layer.</param>
public void CopyBiases(NeuralNetworkLayer nnl)
{
float[] cb = nnl.biases;
int i = numberOfNeurons;
while (i-- > 0)
{
biases[i] = cb[i];
}
}
/// <summary>
/// Load NeuralNetwork structure from stream.
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
public static NeuralNetwork LoadStructure(Stream s)
{
NeuralNetworkLayer inLayer = new NeuralNetworkLayer();
inLayer.LoadStructure(s);
NeuralNetworkLayer[] hidden = new NeuralNetworkLayer[Utils.IntFromStream(s)];
for (int i = 0; i < hidden.Length; i++)
{
hidden[i] = new NeuralNetworkLayer();
hidden[i].LoadStructure(s);
}
NeuralNetworkLayer outLayer = new NeuralNetworkLayer();
outLayer.LoadStructure(s);
return(new NeuralNetwork(inLayer, hidden, outLayer));
}
/// <summary>
/// Create new NeuralNetwork from existing(src).
/// </summary>
/// <param name="src">Existing NeuralNetwork to copy.</param>
public NeuralNetwork(NeuralNetwork src)
{
inputLayer = new NeuralNetworkLayer(src.inputLayer);
hiddenLayers = new NeuralNetworkLayer[src.hiddenLayers.Length];
for (int i = 0; i < hiddenLayers.Length; i++)
{
hiddenLayers[i] = new NeuralNetworkLayer(src.hiddenLayers[i]);
hiddenLayers[i].Init();
}
outputLayer = new NeuralNetworkLayer(src.outputLayer);
outputLayer.Init();
//setup layer connections
if (hiddenLayers.Length > 0)
{
//hidden layer connections
hiddenConnections = new NeuralNetworkLayerConnection[hiddenLayers.Length];
hiddenRecurringConnections = new NeuralNetworkLayerConnection[hiddenLayers.Length];
maxNumberOfHiddenNeurons = 0;
maxNumberOfSynapses = 0;
for (int i = 0; i < hiddenLayers.Length; i++)
{
if (i == 0)
{
hiddenConnections[0] = new NeuralNetworkLayerConnection(inputLayer, hiddenLayers[0]);
}
else
{
hiddenConnections[i] = new NeuralNetworkLayerConnection(hiddenLayers[i - 1], hiddenLayers[i]);
}
//recurrent connection for hidden layer
if (hiddenLayers[i].recurring)
{
hiddenRecurringConnections[i] = new NeuralNetworkLayerConnection(hiddenLayers[i], hiddenLayers[i]);
}
else
{
hiddenRecurringConnections[i] = null;
}
//calc max hidden neurons
if (hiddenLayers[i].numberOfNeurons > maxNumberOfHiddenNeurons)
{
maxNumberOfHiddenNeurons = hiddenLayers[i].numberOfNeurons;
}
if (hiddenConnections[i].numberOfSynapses > maxNumberOfSynapses)
{
maxNumberOfSynapses = hiddenConnections[i].numberOfSynapses;
}
}
//output connection
outputConnection = new NeuralNetworkLayerConnection(hiddenLayers[hiddenLayers.Length - 1], outputLayer);
if (outputConnection.numberOfSynapses > maxNumberOfSynapses)
{
maxNumberOfSynapses = outputConnection.numberOfSynapses;
}
}
else
{
maxNumberOfHiddenNeurons = 0;
maxNumberOfSynapses = 0;
//direct input to output connection
outputConnection = new NeuralNetworkLayerConnection(inputLayer, outputLayer);
if (outputConnection.numberOfSynapses > maxNumberOfSynapses)
{
maxNumberOfSynapses = outputConnection.numberOfSynapses;
}
}
}
/// <summary>
/// Create new struct.
/// </summary>
/// <param name="inLayer">Input layer.</param>
/// <param name="outLayer">Output layer.</param>
public NeuralNetworkLayerConnection(NeuralNetworkLayer inLayer, NeuralNetworkLayer outLayer)
{
numberOfSynapses = inLayer.numberOfNeurons * outLayer.numberOfNeurons;
weights = new float[numberOfSynapses];
}
