//Methods
public void Run()
{
MackeyGlassGeneratorSettings modSettings = new MackeyGlassGeneratorSettings(18, 0.1, 0.2);
IGenerator generator = new MackeyGlassGenerator(modSettings);
int steps = 100;
for (int i = 0; i < steps; i++)
{
Console.WriteLine(generator.Next());
}
Console.ReadLine();
generator.Reset();
for (int i = 0; i < steps; i++)
{
Console.WriteLine(generator.Next());
}
Console.ReadLine();
///*
SimpleIFSettings settings = new SimpleIFSettings(1,
new RandomValueSettings(15, 15),
new RandomValueSettings(0.05, 0.05),
new RandomValueSettings(5, 5),
new RandomValueSettings(20, 20),
0
);
IActivationFunction af = ActivationFactory.Create(settings, new Random(0));
//*/
TestActivation(af, 800, 0.15, 10, 600);
return;
}
//Methods
//Static methods
/// <summary>
/// Fuction checks if specified activation can be used in FF network
/// </summary>
/// <param name="activationSettings">Activation settings</param>
/// <returns></returns>
public static bool IsAllowedActivation(ActivationSettings activationSettings)
{
IActivationFunction af = ActivationFactory.Create(activationSettings);
if (!af.Stateless || !af.SupportsComputeDerivativeMethod)
{
return(false);
}
return(true);
}
//Methods
//Static methods
/// <summary>
/// Fuction checks if specified activation can be used in FF network
/// </summary>
/// <param name="activationSettings">Activation settings</param>
/// <param name="outputRange">Returned range of the activation function</param>
public static bool IsAllowedActivation(Object activationSettings, out Interval outputRange)
{
IActivationFunction af = ActivationFactory.Create(activationSettings, new Random());
outputRange = af.OutputRange.DeepClone();
if (!af.Stateless || !af.SupportsDerivative)
{
return(false);
}
return(true);
}
/// <summary>
/// Instantiates an initialized feed forward network
/// </summary>
/// <param name="numOfInputValues">Number of network's input values</param>
/// <param name="numOfOutputValues">Number of network's output values</param>
/// <param name="settings">Configuration parameters</param>
public FeedForwardNetwork(int numOfInputValues, int numOfOutputValues, FeedForwardNetworkSettings settings)
: this(numOfInputValues, numOfOutputValues)
{
//Initialize FF network
for (int i = 0; i < settings.HiddenLayerCollection.Count; i++)
{
AddLayer(settings.HiddenLayerCollection[i].NumOfNeurons,
ActivationFactory.Create(settings.HiddenLayerCollection[i].Activation)
);
}
FinalizeStructure(ActivationFactory.Create(settings.OutputLayerActivation));
return;
}
//Methods
public void Run()
{
//Filter test
RealFeatureFilter rff = new RealFeatureFilter(new Interval(-1, 1));
for (int i = 1; i <= 1500; i++)
{
rff.Update(_rand.NextDouble() * _rand.Next(0, 10000));
}
double featureValue = 0.5;
double filterValue = rff.ApplyFilter(featureValue);
double reverseValue = rff.ApplyReverse(filterValue);
Console.WriteLine($"Feature: {featureValue} Filter: {filterValue} Reverse: {reverseValue}");
//Pulse generator test
BasicStat sampleStat = new BasicStat();
sampleStat.Reset();
PulseGeneratorSettings modSettings = new PulseGeneratorSettings(1, 1.5, PulseGeneratorSettings.TimingMode.Poisson);
IGenerator generator = new PulseGenerator(modSettings);
int steps = 10000;
double period = 0;
for (int i = 0; i < steps; i++)
{
++period;
double sample = generator.Next();
//Console.WriteLine(sample);
if (sample != 0)
{
sampleStat.AddSampleValue(period);
period = 0;
}
}
Console.WriteLine($"Mean: {sampleStat.ArithAvg} StdDev: {sampleStat.StdDev} Min: {sampleStat.Min} Max: {sampleStat.Max}");
Console.ReadLine();
//Random distributions test
BasicStat rStat = new BasicStat();
for (int i = 0; i < 200; i++)
{
double r = _rand.NextFilterredGaussianDouble(0.5, 1, -0.5, 1);
rStat.AddSampleValue(r);
Console.WriteLine(r);
}
Console.WriteLine($"Mean: {rStat.ArithAvg} StdDev: {rStat.StdDev} Min: {rStat.Min} Max: {rStat.Max}");
Console.ReadLine();
//Activation tests
double fadingSum = 0;
for (int i = 0; i < 1000; i++)
{
fadingSum *= (1d - 0.1);
fadingSum += 1d;
Console.WriteLine(fadingSum);
}
Console.ReadLine();
IActivationFunction testAF = ActivationFactory.Create(new SimpleIFSettings(refractoryPeriods: 0), new Random(0));
TestActivation(testAF, 100, 3.5, 10, 70);
SimpleIFSettings setup = new SimpleIFSettings();
FindAFInputBorders(ActivationFactory.Create(setup, new Random(0)),
-0.1,
20
);
//Linear algebra test
double[] flatData =
{
0.2, 5, 17.3, 1.01, 54, 7,
2.2, 5.5, 12.13, 11.57, 5.71, -85,
-70.1, 15, -18.3, 0.3, 42, -6.25,
0.042, 1, 7.75, -81.01, -21.29, 5.44,
0.1, 4, -4.3, 18.01, 7.12, -3.14,
-80.1, 24.4, 4.3, 12.03, 2.789, -13
};
Matrix testM = new Matrix(6, 6, flatData);
/*
* //Inversion test
* Matrix resultM = new Matrix(testM);
* resultM.SingleThreadInverse();
*/
/*
* //Transpose test
* Matrix resultM = testM.Transpose();
*/
/*
* //Multiply test
* Matrix resultM = Matrix.Multiply(testM, testM);
* for (int i = 0; i < resultM.NumOfRows; i++)
* {
* Console.WriteLine($"{resultM.Data[i][0]}; {resultM.Data[i][1]}; {resultM.Data[i][2]}; {resultM.Data[i][3]}; {resultM.Data[i][4]}; {resultM.Data[i][5]}");
* }
*/
;
int numOfweights = 3;
int xIdx, dIdx = 0;
double[][] data = new double[3][];
data[dIdx] = new double[numOfweights];
xIdx = -1;
data[dIdx][++xIdx] = 2;
data[dIdx][++xIdx] = 1;
data[dIdx][++xIdx] = 3;
++dIdx;
data[dIdx] = new double[numOfweights];
xIdx = -1;
data[dIdx][++xIdx] = 1;
data[dIdx][++xIdx] = 3;
data[dIdx][++xIdx] = -3;
++dIdx;
data[dIdx] = new double[numOfweights];
xIdx = -1;
data[dIdx][++xIdx] = -2;
data[dIdx][++xIdx] = 4;
data[dIdx][++xIdx] = 4;
//Matrix M = new Matrix(data, true);
//Matrix I = M.Inverse(false);
//Matrix identity = M * I; //Must lead to identity matrix
Matrix I = new Matrix(3, 3);
I.AddScalarToDiagonal(1);
Matrix X = new Matrix(I);
X.Multiply(0.1);
Matrix XT = X.Transpose();
Matrix R = XT * X;
Console.ReadLine();
///*
SimpleIFSettings settings = new SimpleIFSettings(new RandomValueSettings(15, 15),
new RandomValueSettings(0.05, 0.05),
new RandomValueSettings(5, 5),
new RandomValueSettings(20, 20),
0
);
IActivationFunction af = ActivationFactory.Create(settings, new Random(0));
//*/
TestActivation(af, 800, 0.15, 10, 600);
return;
}
/// <summary>
/// Instantiates the reservoir
/// </summary>
/// <param name="instanceName">The name of the reservoir instance</param>
/// <param name="numOfInputNodes">Number of reservoir inputs</param>
/// <param name="inputRange">Range of input values</param>
/// <param name="settings">Reservoir settings</param>
/// <param name="augmentedStates">Specifies whether this reservoir will add augmented states to output predictors</param>
/// <param name="randomizerSeek">
/// A value greater than or equal to 0 will always ensure the same initialization of the internal
/// random number generator and therefore the same reservoir structure, which is good for tuning purposes.
/// A value less than 0 causes a fully random initialization each time creating a reservoir instance.
/// </param>
public Reservoir(string instanceName, int numOfInputNodes, Interval inputRange, ReservoirSettings settings, bool augmentedStates, int randomizerSeek = -1)
{
//Set instance name
_instanceName = instanceName;
//Copy settings
_settings = settings.DeepClone();
//Random generator initialization
if (randomizerSeek < 0)
{
_rand = new Random();
}
else
{
_rand = new Random(randomizerSeek);
}
//Prepare neuron buffers
//Input neurons
_inputNeurons = new INeuron[numOfInputNodes];
for (int i = 0; i < numOfInputNodes; i++)
{
if (_settings.InputCoding == CommonEnums.InputCodingType.Analog)
{
//Analog input
_inputNeurons[i] = new InputAnalogNeuron(i, inputRange);
}
else
{
//Spiking input
_inputNeurons[i] = new InputSpikingNeuron(i, inputRange, _settings.InputDuration);
}
}
//Pools
_numOfPredictors = 0;
List <INeuron> allNeurons = new List <INeuron>();
int neuronGlobalFlatIdx = 0;
int totalNumOfNeurons = 0;
_poolNeuronsCollection = new List <INeuron[]>(_settings.PoolSettingsCollection.Count);
for (int poolID = 0; poolID < _settings.PoolSettingsCollection.Count; poolID++)
{
PoolSettings poolSettings = _settings.PoolSettingsCollection[poolID];
totalNumOfNeurons += poolSettings.Dim.Size;
_numOfPredictors += poolSettings.RouteToReadout ? poolSettings.Dim.Size : 0;
INeuron[] poolNeurons = new INeuron[poolSettings.Dim.Size];
//Retainment rates
double[] retRates = new double[poolSettings.Dim.Size];
retRates.Populate(0);
if (poolSettings.RetainmentNeuronsFeature)
{
int[] indices = new int[poolSettings.Dim.Size];
indices.ShuffledIndices(_rand);
int numOfRetNeurons = (int)Math.Round(poolSettings.RetainmentNeuronsDensity * poolSettings.Dim.Size, 0);
for (int i = 0; i < numOfRetNeurons; i++)
{
retRates[indices[i]] = _rand.NextDouble(poolSettings.RetainmentMinRate, poolSettings.RetainmentMaxRate, false, RandomClassExtensions.DistributionType.Uniform);
}
}
//Neuron signal types distribution
CommonEnums.NeuronSignalType[] sigTypes = new CommonEnums.NeuronSignalType[poolSettings.Dim.Size];
sigTypes.Populate(CommonEnums.NeuronSignalType.Excitatory);
int[] inhibitoryIndices = new int[poolSettings.Dim.Size];
inhibitoryIndices.ShuffledIndices(_rand);
int numOfInhibitoryNeurons = (int)Math.Round(poolSettings.InhibitoryNeuronsDensity * poolSettings.Dim.Size, 0);
for (int i = 0; i < numOfInhibitoryNeurons; i++)
{
sigTypes[inhibitoryIndices[i]] = CommonEnums.NeuronSignalType.Inhibitory;
}
//Instantiate neurons
int neuronPoolIdx = 0;
for (int x = 0; x < poolSettings.Dim.X; x++)
{
for (int y = 0; y < poolSettings.Dim.Y; y++)
{
for (int z = 0; z < poolSettings.Dim.Z; z++)
{
NeuronPlacement placement = new NeuronPlacement(neuronGlobalFlatIdx, poolID, neuronPoolIdx, x, y, z);
IActivationFunction activation = null;
double bias = 0;
if (sigTypes[neuronPoolIdx] == CommonEnums.NeuronSignalType.Excitatory)
{
//Activation and bias for Excitatory neuron
activation = ActivationFactory.Create(poolSettings.ExcitatoryActivation);
bias = _rand.NextDouble(poolSettings.ExcitatoryBias.Min, poolSettings.ExcitatoryBias.Max, poolSettings.ExcitatoryBias.RandomSign, poolSettings.ExcitatoryBias.DistrType);
}
else
{
//Activation and bias for Inhibitory neuron
activation = ActivationFactory.Create(poolSettings.InhibitoryActivation);
bias = _rand.NextDouble(poolSettings.InhibitoryBias.Min, poolSettings.InhibitoryBias.Max, poolSettings.InhibitoryBias.RandomSign, poolSettings.InhibitoryBias.DistrType);
}
//Neuron instance
if (activation.OutputSignalType == ActivationFactory.FunctionOutputSignalType.Spike)
{
//Spiking neuron
poolNeurons[neuronPoolIdx] = new ReservoirSpikingNeuron(placement,
sigTypes[neuronPoolIdx],
activation,
bias
);
}
else
{
//Analog neuron
poolNeurons[neuronPoolIdx] = new ReservoirAnalogNeuron(placement,
sigTypes[neuronPoolIdx],
activation,
bias,
retRates[neuronPoolIdx]
);
}
allNeurons.Add(poolNeurons[neuronPoolIdx]);
++neuronPoolIdx;
++neuronGlobalFlatIdx;
}
}
}
_poolNeuronsCollection.Add(poolNeurons);
}
//All neurons flat structure
_neurons = allNeurons.ToArray();
//Interconnections
//Banks allocations
_neuronInputConnectionsCollection = new List <ISynapse> [totalNumOfNeurons];
_neuronNeuronConnectionsCollection = new List <ISynapse> [totalNumOfNeurons];
for (int n = 0; n < totalNumOfNeurons; n++)
{
_neuronInputConnectionsCollection[n] = new List <ISynapse>();
_neuronNeuronConnectionsCollection[n] = new List <ISynapse>();
}
//Wiring setup
//Pools internal connections
for (int poolID = 0; poolID < _poolNeuronsCollection.Count; poolID++)
{
//Input connection
SetPoolInputConnections(poolID, _settings.PoolSettingsCollection[poolID]);
//Pool interconnection
if (_settings.PoolSettingsCollection[poolID].InterconnectionAvgDistance > 0)
{
//Required to keep average distance
SetPoolDistInterconnections(poolID, _settings.PoolSettingsCollection[poolID]);
}
else
{
//Not required to keep average distance
SetPoolRandInterconnections(poolID, _settings.PoolSettingsCollection[poolID]);
}
}
//Add pool to pool connections
foreach (ReservoirSettings.PoolsInterconnection poolsInterConn in _settings.PoolsInterconnectionCollection)
{
SetPool2PoolInterconnections(poolsInterConn);
}
//Spectral radius
if (_settings.SpectralRadius > 0)
{
double maxEigenValue = ComputeMaxEigenValue();
if (maxEigenValue == 0)
{
throw new Exception("Invalid reservoir weights. Max eigenvalue is 0.");
}
double scale = _settings.SpectralRadius / maxEigenValue;
//Scale internal weights
foreach (List <ISynapse> connCollection in _neuronNeuronConnectionsCollection)
{
foreach (ISynapse conn in connCollection)
{
conn.Weight *= scale;
}
}
}
//Augmented states
_augmentedStatesFeature = augmentedStates;
return;
}
//Methods
public void Run()
{
//Linear algebra test
double[] flatData =
{
0.2, 5, 17.3, 1.01, 54, 7,
2.2, 5.5, 12.13, 11.57, 5.71, -85,
-70.1, 15, -18.3, 0.3, 42, -6.25,
0.042, 1, 7.75, -81.01, -21.29, 5.44,
0.1, 4, -4.3, 18.01, 7.12, -3.14,
-80.1, 24.4, 4.3, 12.03, 2.789, -13
};
Matrix testM = new Matrix(6, 6, flatData);
/*
* //Inversion test
* Matrix resultM = new Matrix(testM);
* resultM.SingleThreadInverse();
*/
/*
* //Transpose test
* Matrix resultM = testM.Transpose();
*/
/*
* //Multiply test
* Matrix resultM = Matrix.Multiply(testM, testM);
* for (int i = 0; i < resultM.NumOfRows; i++)
* {
* Console.WriteLine($"{resultM.Data[i][0]}; {resultM.Data[i][1]}; {resultM.Data[i][2]}; {resultM.Data[i][3]}; {resultM.Data[i][4]}; {resultM.Data[i][5]}");
* }
*/
;
int numOfweights = 4;
int xIdx, dIdx = 0;
double[][] data = new double[5][];
data[dIdx] = new double[numOfweights];
xIdx = -1;
data[dIdx][++xIdx] = 1; //Bias
data[dIdx][++xIdx] = 2;
data[dIdx][++xIdx] = 1;
data[dIdx][++xIdx] = 3;
++dIdx;
data[dIdx] = new double[numOfweights];
xIdx = -1;
data[dIdx][++xIdx] = 1; //Bias
data[dIdx][++xIdx] = 1;
data[dIdx][++xIdx] = 3;
data[dIdx][++xIdx] = -3;
++dIdx;
data[dIdx] = new double[numOfweights];
xIdx = -1;
data[dIdx][++xIdx] = 1; //Bias
data[dIdx][++xIdx] = -2;
data[dIdx][++xIdx] = 4;
data[dIdx][++xIdx] = 4;
++dIdx;
data[dIdx] = new double[numOfweights];
xIdx = -1;
data[dIdx][++xIdx] = 1; //Bias
data[dIdx][++xIdx] = -5;
data[dIdx][++xIdx] = 7;
data[dIdx][++xIdx] = 6;
++dIdx;
data[dIdx] = new double[numOfweights];
xIdx = -1;
data[dIdx][++xIdx] = 1; //Bias
data[dIdx][++xIdx] = 1;
data[dIdx][++xIdx] = 12;
data[dIdx][++xIdx] = 5;
Matrix M = new Matrix(data, true);
Vector desired = new Vector(5);
dIdx = -1;
desired.Data[++dIdx] = 8;
desired.Data[++dIdx] = 13;
desired.Data[++dIdx] = 5;
desired.Data[++dIdx] = 7;
desired.Data[++dIdx] = 10;
Vector weights = Matrix.RidgeRegression(M, desired, 0);
//Display results
for (int i = 0; i < data.Length; i++)
{
double result = 0;
for (int j = 0; j < weights.Length; j++)
{
result += data[i][j] * weights[j];
}
Console.WriteLine($"Computed {result}, Desired {desired.Data[i]}");
}
for (int i = 0; i < weights.Length; i++)
{
Console.WriteLine($"Weight[{i}] = {weights[i]}");
}
Console.WriteLine();
//QRD
QRD decomposition = new QRD(M);
Matrix B = new Matrix(desired.Length, 1, desired.Data);
Matrix W = decomposition.Solve(B);
//Display results
for (int i = 0; i < data.Length; i++)
{
double result = 0;
for (int j = 0; j < W.Data.Length; j++)
{
result += data[i][j] * W.Data[j][0];
}
Console.WriteLine($"Computed {result}, Desired {desired.Data[i]}");
}
for (int i = 0; i < W.Data.Length; i++)
{
Console.WriteLine($"Weight[{i}] = {W.Data[i][0]}");
}
;
//TimeSeriesGenerator.SaveTimeSeriesToCsvFile("MackeyGlass_big.csv", "Value", TimeSeriesGenerator.GenMackeyGlassTimeSeries(16000), CultureInfo.InvariantCulture);
MackeyGlassGeneratorSettings modSettings = new MackeyGlassGeneratorSettings(18, 0.1, 0.2);
IGenerator generator = new MackeyGlassGenerator(modSettings);
int steps = 100;
for (int i = 0; i < steps; i++)
{
Console.WriteLine(generator.Next());
}
Console.ReadLine();
generator.Reset();
for (int i = 0; i < steps; i++)
{
Console.WriteLine(generator.Next());
}
Console.ReadLine();
///*
SimpleIFSettings settings = new SimpleIFSettings(1,
new RandomValueSettings(15, 15),
new RandomValueSettings(0.05, 0.05),
new RandomValueSettings(5, 5),
new RandomValueSettings(20, 20),
0
);
IActivationFunction af = ActivationFactory.Create(settings, new Random(0));
//*/
TestActivation(af, 800, 0.15, 10, 600);
return;
}
/// <summary>
/// Creates StateMachine configuration following pure LSM design
/// </summary>
/// <param name="proportionsCfg">LSM pool proportions</param>
/// <param name="aFnCfg">Spiking activation function configuration</param>
/// <param name="hes">Homogenous excitability configuration</param>
/// <param name="inputConnectionDensity">Density of the input field connections to hidden neurons</param>
/// <param name="maxInputDelay">Maximum delay of input synapse</param>
/// <param name="interconnectionDensity">Density of the hidden neurons interconnection</param>
/// <param name="maxInternalDelay">Maximum delay of internal synapse</param>
/// <param name="steadyBias">Constant bias (0 means bias is not required)</param>
/// <param name="predictorsParamsCfg">Predictors parameters (use null for defaults)</param>
/// <param name="allowedPredictor">Allowed predictor(s)</param>
public StateMachineSettings CreatePureLSMCfg(ProportionsSettings proportionsCfg,
RCNetBaseSettings aFnCfg,
HomogenousExcitabilitySettings hes,
double inputConnectionDensity,
int maxInputDelay,
double interconnectionDensity,
int maxInternalDelay,
double steadyBias,
PredictorsParamsSettings predictorsParamsCfg,
params PredictorsProvider.PredictorID[] allowedPredictor
)
{
//Activation check
if (ActivationFactory.Create(aFnCfg, new Random()).TypeOfActivation != ActivationType.Spiking)
{
throw new ArgumentException("Specified activation must be spiking.", "aFnCfg");
}
//One neuron group
SpikingNeuronGroupSettings grp = CreateSpikingGroup(aFnCfg, hes, steadyBias);
//Simple spiking pool
PoolSettings poolCfg = new PoolSettings(GetPoolName(ActivationContent.Spiking, 0),
proportionsCfg,
new NeuronGroupsSettings(grp),
new InterconnSettings(new RandomSchemaSettings(interconnectionDensity, 0d, false, false))
);
//Simple reservoir structure
ReservoirStructureSettings resStructCfg = new ReservoirStructureSettings(GetResStructName(ActivationContent.Spiking, 0),
new PoolsSettings(poolCfg)
);
//Input connections configuration
List <InputConnSettings> inputConns = new List <InputConnSettings>(InputCfg.VaryingFieldsCfg.ExternalFieldsCfg.FieldCfgCollection.Count);
foreach (ExternalFieldSettings fieldCfg in InputCfg.VaryingFieldsCfg.ExternalFieldsCfg.FieldCfgCollection)
{
InputConnSettings inputConnCfg = new InputConnSettings(fieldCfg.Name,
poolCfg.Name,
inputConnectionDensity,
0
);
inputConns.Add(inputConnCfg);
}
//Synapse general configuration
SynapseSTInputSettings synapseSTInputSettings = new SynapseSTInputSettings(Synapse.SynapticDelayMethod.Random, maxInputDelay);
SynapseSTExcitatorySettings synapseSTExcitatorySettings = new SynapseSTExcitatorySettings(Synapse.SynapticDelayMethod.Random, maxInternalDelay);
SynapseSTInhibitorySettings synapseSTInhibitorySettings = new SynapseSTInhibitorySettings(Synapse.SynapticDelayMethod.Random, maxInternalDelay);
SynapseSTSettings synapseSTCfg = new SynapseSTSettings(synapseSTInputSettings, synapseSTExcitatorySettings, synapseSTInhibitorySettings);
SynapseSettings synapseCfg = new SynapseSettings(synapseSTCfg, null);
//Initially set all switches to false - all available predictors are forbidden
bool[] predictorSwitches = new bool[PredictorsProvider.NumOfSupportedPredictors];
predictorSwitches.Populate(false);
//Enable specified predictors
foreach (PredictorsProvider.PredictorID predictorID in allowedPredictor)
{
predictorSwitches[(int)predictorID] = true;
}
//Create predictors configuration using default params
PredictorsSettings predictorsCfg = new PredictorsSettings(predictorSwitches, predictorsParamsCfg);
//Create reservoir instance
ReservoirInstanceSettings resInstCfg = new ReservoirInstanceSettings(GetResInstName(ResDesign.PureLSM, 0),
resStructCfg.Name,
new InputConnsSettings(inputConns),
synapseCfg,
predictorsCfg
);
//Build and return SM configuration
return(new StateMachineSettings(new NeuralPreprocessorSettings(InputCfg,
new ReservoirStructuresSettings(resStructCfg),
new ReservoirInstancesSettings(resInstCfg)
),
ReadoutCfg
));
}
//Methods
/// <summary>
/// Builds name of the specified activation function
/// </summary>
/// <param name="activationCfg">Activation function configuration</param>
private string GetActivationName(RCNetBaseSettings activationCfg)
{
IActivationFunction aFn = ActivationFactory.Create(activationCfg, _rand);
return(aFn.TypeOfActivation.ToString() + "-" + aFn.GetType().Name.Replace("Settings", string.Empty));
}