public static NeuronValues GetNeuron(string str, NeuronTypes neuronType)
{
NeuronValues values = new NeuronValues(neuronType);
switch (neuronType)
{
case NeuronTypes.feedForward:
values.weigths = StringToDoubleList(str);
break;
case NeuronTypes.lSTM:
LSTMCell cell = LSTMCell.FromString(str);
values.lstmWeigths = cell.recurrent;
values.weigths = cell.Weigths;
break;
case NeuronTypes.recurrent:
RecurrentNeuron neuron = RecurrentNeuron.FromString(str);
values.weigths = neuron.Weigths;
values.recurrentWeigth = neuron.recurrentWeigth;
values.lstmWeigths = new LSTMCell.LSTMWeigths();
values.lstmWeigths.hiddenState = neuron.hiddenState;
break;
default:
throw new NotImplementedException();
}
return(values);
}
/// <summary>
/// Constructor for neuron
/// </summary>
public Neuron(double Bias, NeuronTypes Type, int WeightsNum)
{
NBias = Bias;
NType = Type;
NWeights = new double[WeightsNum];
SetRandomWeights(WeightsNum);
}
public Neuron(int countNeuron, NeuronTypes type = NeuronTypes.Hidden)
{
neuronType = type;
weights = new List <double>();
for (int i = 0; i < weights.Count; i++)
{
weights.Add(1);
}
}
/// <summary>
/// Конструктор макета сети по ступенчатому массиву, автоматически включает в себя нейрон смещения
/// </summary>
/// <param name="netMaket">Макет сети, без нейронов смещения (сам добавляет) </param>
public NetConstructor(int[][] netMaket)
{
NetTypes = new NeuronTypes[netMaket.Length][];
for (int i = 0; i < netMaket.Length; i++)
{
if (i != netMaket.Length - 1)
{
NetTypes[i] = new NeuronTypes[netMaket[i].Length + 1];
}
else
{
NetTypes[i] = new NeuronTypes[netMaket[i].Length];
}
}
for (int i = 0; i < NetTypes.Length; i++)
{
if (i == 0)
{
for (int j = 0; j < NetTypes[i].Length; j++)
{
if (j == NetTypes[i].Length - 1)
{
NetTypes[i][j] = NeuronTypes.BIAS;
continue;
}
else
{
NetTypes[i][j] = NeuronTypes.INPUT;
}
}
continue;
}
if (i == NetTypes.Length - 1)
{
for (int j = 0; j < NetTypes[i].Length; j++)
{
NetTypes[i][j] = NeuronTypes.OUTPUT;
}
continue;
}
for (int j = 0; j < NetTypes[i].Length; j++)
{
if (j == NetTypes[i].Length - 1)
{
NetTypes[i][j] = NeuronTypes.BIAS;
continue;
}
else
{
NetTypes[i][j] = NeuronTypes.HIDDEN;
}
}
}
}
public static List <NeuronTypes> GetNeuronTypeList(int length, NeuronTypes neuronType)
{
List <NeuronTypes> output = new List <NeuronTypes>();
for (int i = 0; i < length; i++)
{
output.Add(neuronType);
}
return(output);
}
/// <summary>
/// Constructor for neuron
/// </summary>
public Neuron(double Bias, NeuronTypes Type, double[] Weights)
{
NBias = Bias;
NType = Type;
if (Weights != null)
{
NWeights = new double[Weights.Length];
Array.Copy(Weights, NWeights, Weights.Length);
}
}
public Neuron(NeuronTypes neuronType)
{
m_Key = System.Guid.NewGuid().ToString();
m_NeuronType = neuronType;
if (m_NeuronType == NeuronTypes.Interneuron)
{
IsEmptyNeuron = true;
}
}
/// <summary>
///
/// </summary>
/// <param name="neuronType">Inhibitory or exitatory neuron</param>
/// <param name="paramA">Parameter a of Izhikevhich neuron</param>
/// <param name="paramB">Parameter b of Izhikevhich neuron</param>
/// <param name="paramC">Parameter c of Izhikevhich neuron</param>
/// <param name="paramD">Parameter d of Izhikevhich neuron</param>
public IzhikevichNeuron(NeuronTypes neuronType, float paramA, float paramB, float paramC, float paramD)
: base(neuronType)
{
a = paramA;
b = paramB;
c = paramC;
d = paramD;
v = c;
u = b * v;
}
void buildLayer(int nodeSize, NeuronTypes neuronType)
{
var layer = new Layer();
var nodeBuilder = new List <Neuron>();
for (int i = 0; i < nodeSize; i++)
{
nodeBuilder.Add(new Neuron(neuronType, maxNeuronConnection));
}
layer.Neurons = nodeBuilder.ToArray();
Layers.Add(layer);
}
internal void AddNeuron(int layerIndex, NeuronTypes neuronType)
{
if (layerIndex >= 0 && layerIndex < TemporalLayers.Count)
{
TemporalLayers[layerIndex].Add(neuronType);
AdjustLayerConnectionsForAddedNeuron(layerIndex);
AddneuronToConnectionsConnectedTo(layerIndex);
if (layerIndex < TemporalLayers.Count - 1)
{
TemporalLayers[layerIndex + 1].AdjustToPreviousLayer();
}
}
}
public Neuron(int rank, int column, int length, NeuronTypes neuronType, ConnectionTypes connectionType, int maxSynapses = 0)
{
Key = Guid.NewGuid().ToString();
Rank = rank;
AxonLength = length;
Column = column;
m_NeuronType = neuronType;
if (m_NeuronType == NeuronTypes.Interneuron)
{
IsEmptyNeuron = true;
}
ConnectionType = connectionType;
Synapses = new List <Synapse> ();
MaxSynapses = maxSynapses;
}
protected Layer(int neuronsCount, int prevLayerNeuronsCount, NeuronTypes neuronType)
{
NeuronsCount = neuronsCount;
PrevLayerNeuronsCount = prevLayerNeuronsCount;
Neurons = new Neuron[neuronsCount];
NeuronType = neuronType;
var weights = InitWeights(MemoryModes.Get);
for (var i = 0; i < neuronsCount; ++i)
{
var tempWeights = new double[prevLayerNeuronsCount];
for (var j = 0; j < prevLayerNeuronsCount; ++j)
{
tempWeights[j] = weights[i, j];
}
Neurons[i] = new Neuron(null, tempWeights, neuronType);
}
}
/// <summary>
/// Generate random weigths
/// </summary>
public NeuronValues(int previousLayerLenght, NeuronTypes neuronType)
{
weigths = GenerateRandomWeigths(previousLayerLenght);
switch (neuronType)
{
case NeuronTypes.feedForward:
break;
case NeuronTypes.lSTM:
lstmWeigths = new LSTMCell.LSTMWeigths(previousLayerLenght);
break;
case NeuronTypes.recurrent:
recurrentWeigth = GenerateRandomWeigth();
break;
default:
throw new NotImplementedException();
}
}
public NeuronInfo(int arrayIndex, NeuronTypes neuronType)
{
this.ArrayIndex = arrayIndex;
this.neuronType = neuronType;
}
/// <summary>
/// Constructor for Input Layer
/// </summary>
public Neuron()
{
NBias = 0;
NType = NeuronTypes.INPUT;
}
public Neuron(double[] inputs, double[] weights, NeuronTypes type)
{
_type = type;
Weights = weights;
Inputs = inputs;
}
internal NeuronValues(NeuronTypes neuronTypes)
{
this.NeuronType = neuronTypes;
weigths = new List <double>();
lstmWeigths = new LSTMCell.LSTMWeigths();
}
} //for the sake of inheritance and generics!
/// <summary>
/// Creats and initializes a neuron (it must be called by all inherited classes!).
/// </summary>
/// <param name="neuronType">Inhibitory or exitatory neuron</param>
public Neuron(NeuronTypes neuronType)
{
Initialize();
Type = neuronType;
}
//public LIFNeuron(NeuronTypes neuronType) : base(neuronType) { }
public LIFNeuron(NeuronTypes neuronType, float lifEquilibriumPotential, float lifTao, float lifAfterSpikePotential,
float lifThreshold) : base(neuronType)
{
SetParameters(lifEquilibriumPotential, lifTao, lifAfterSpikePotential, lifThreshold);
}
