private void SetPoolDistInterconnections(int poolID, PoolSettings poolSettings)
{
int connectionsPerNeuron = (int)Math.Round(poolSettings.Dim.Size * poolSettings.InterconnectionDensity, 0);
if (connectionsPerNeuron > 0)
{
for (int targetNeuronIdx = 0; targetNeuronIdx < poolSettings.Dim.Size; targetNeuronIdx++)
{
List <INeuron> srcNeurons = SelectNeuronsByDistance(_poolNeuronsCollection[poolID][targetNeuronIdx], _poolNeuronsCollection[poolID], poolSettings.InterconnectionAvgDistance, connectionsPerNeuron + (poolSettings.InterconnectionAllowSelfConn ? 0 : 1));
int addedSynapses = 0;
for (int i = 0; i < srcNeurons.Count && addedSynapses < connectionsPerNeuron; i++)
{
if (poolSettings.InterconnectionAllowSelfConn || srcNeurons[i] != _poolNeuronsCollection[poolID][targetNeuronIdx])
{
StaticSynapse synapse = new StaticSynapse(srcNeurons[i],
_poolNeuronsCollection[poolID][targetNeuronIdx],
_rand.NextDouble(poolSettings.InterconnectionSynapseWeight.Min, poolSettings.InterconnectionSynapseWeight.Max, poolSettings.InterconnectionSynapseWeight.RandomSign, poolSettings.InterconnectionSynapseWeight.DistrType)
);
AddInterconnection(_neuronNeuronConnectionsCollection, synapse, false);
++addedSynapses;
}
}
}
}
return;
}
private void SetPool2PoolInterconnections(ReservoirSettings.PoolsInterconnection cfg)
{
PoolSettings targetPoolSettings = _settings.PoolSettingsCollection[cfg.TargetPoolID];
PoolSettings sourcePoolSettings = _settings.PoolSettingsCollection[cfg.SourcePoolID];
int[] targetIndices = new int[targetPoolSettings.Dim.Size];
targetIndices.ShuffledIndices(_rand);
int numOfTargetNeurons = (int)Math.Round(targetPoolSettings.Dim.Size * cfg.TargetConnectionDensity, 0);
int[] srcIndices = new int[sourcePoolSettings.Dim.Size];
srcIndices.Indices();
int numOfSrcNeurons = (int)Math.Round(sourcePoolSettings.Dim.Size * cfg.SourceConnectionDensity, 0);
for (int i = 0; i < numOfTargetNeurons; i++)
{
INeuron targetneuron = _poolNeuronsCollection[cfg.TargetPoolID][targetIndices[i]];
_rand.Shuffle(srcIndices);
for (int j = 0; j < numOfSrcNeurons; j++)
{
INeuron srcNeuron = _poolNeuronsCollection[cfg.SourcePoolID][srcIndices[j]];
StaticSynapse synapse = new StaticSynapse(srcNeuron,
targetneuron,
_rand.NextDouble(cfg.SynapseWeight.Min, cfg.SynapseWeight.Max, cfg.SynapseWeight.RandomSign, cfg.SynapseWeight.DistrType)
);
AddInterconnection(_neuronNeuronConnectionsCollection, synapse, false);
}
}
return;
}
//Methods
/// <summary>
/// See the base.
/// </summary>
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
PoolSettings cmpSettings = obj as PoolSettings;
if (InstanceName != cmpSettings.InstanceName ||
!Equals(Dim, cmpSettings.Dim) ||
RouteToReadout != cmpSettings.RouteToReadout ||
InputConnectionDensity != cmpSettings.InputConnectionDensity ||
!Equals(InputSynapseWeight, cmpSettings.InputSynapseWeight) ||
!Equals(ExcitatoryActivation, cmpSettings.ExcitatoryActivation) ||
!Equals(ExcitatoryBias, cmpSettings.ExcitatoryBias) ||
!Equals(InhibitoryActivation, cmpSettings.InhibitoryActivation) ||
!Equals(InhibitoryBias, cmpSettings.InhibitoryBias) ||
InhibitoryNeuronsDensity != cmpSettings.InhibitoryNeuronsDensity ||
InterconnectionDensity != cmpSettings.InterconnectionDensity ||
InterconnectionAvgDistance != cmpSettings.InterconnectionAvgDistance ||
!Equals(InterconnectionSynapseWeight, cmpSettings.InterconnectionSynapseWeight) ||
RetainmentNeuronsFeature != cmpSettings.RetainmentNeuronsFeature ||
RetainmentNeuronsDensity != cmpSettings.RetainmentNeuronsDensity ||
RetainmentMinRate != cmpSettings.RetainmentMinRate ||
RetainmentMaxRate != cmpSettings.RetainmentMaxRate
)
{
return(false);
}
return(true);
}
private void SetPoolRandInterconnections(int poolID, PoolSettings poolSettings)
{
int connectionsPerNeuron = (int)Math.Round(poolSettings.Dim.Size * poolSettings.InterconnectionDensity, 0);
if (connectionsPerNeuron > 0)
{
int[] indices = new int[poolSettings.Dim.Size];
indices.Indices();
for (int targetNeuronIdx = 0; targetNeuronIdx < poolSettings.Dim.Size; targetNeuronIdx++)
{
_rand.Shuffle(indices);
int addedSynapses = 0;
for (int i = 0; i < indices.Length && addedSynapses < connectionsPerNeuron; i++)
{
int srcNeuronIdx = indices[i];
if (poolSettings.InterconnectionAllowSelfConn || srcNeuronIdx != targetNeuronIdx)
{
StaticSynapse synapse = new StaticSynapse(_poolNeuronsCollection[poolID][srcNeuronIdx],
_poolNeuronsCollection[poolID][targetNeuronIdx],
_rand.NextDouble(poolSettings.InterconnectionSynapseWeight.Min, poolSettings.InterconnectionSynapseWeight.Max, poolSettings.InterconnectionSynapseWeight.RandomSign, poolSettings.InterconnectionSynapseWeight.DistrType)
);
AddInterconnection(_neuronNeuronConnectionsCollection, synapse, false);
++addedSynapses;
}
}
}
}
return;
}
/// <summary>
/// The deep copy constructor
/// </summary>
/// <param name="source">Source instance</param>
public PoolSettings(PoolSettings source)
{
InstanceName = source.InstanceName;
Dim = null;
if (source.Dim != null)
{
Dim = new PoolDimensions(source.Dim.X, source.Dim.Y, source.Dim.Z);
}
RouteToReadout = source.RouteToReadout;
InputConnectionDensity = source.InputConnectionDensity;
InputSynapseWeight = null;
if (source.InputSynapseWeight != null)
{
InputSynapseWeight = source.InputSynapseWeight.DeepClone();
}
InhibitoryNeuronsDensity = source.InhibitoryNeuronsDensity;
InhibitoryActivation = null;
if (source.InhibitoryActivation != null)
{
InhibitoryActivation = source.InhibitoryActivation.DeepClone();
}
InhibitoryBias = null;
if (source.InhibitoryBias != null)
{
InhibitoryBias = source.InhibitoryBias.DeepClone();
}
ExcitatoryActivation = null;
if (source.ExcitatoryActivation != null)
{
ExcitatoryActivation = source.ExcitatoryActivation.DeepClone();
}
ExcitatoryBias = null;
if (source.ExcitatoryBias != null)
{
ExcitatoryBias = source.ExcitatoryBias.DeepClone();
}
InterconnectionDensity = source.InterconnectionDensity;
InterconnectionAvgDistance = source.InterconnectionAvgDistance;
InterconnectionSynapseWeight = null;
if (source.InterconnectionSynapseWeight != null)
{
InterconnectionSynapseWeight = source.InterconnectionSynapseWeight.DeepClone();
}
RetainmentNeuronsFeature = source.RetainmentNeuronsFeature;
RetainmentNeuronsDensity = source.RetainmentNeuronsDensity;
RetainmentMinRate = source.RetainmentMinRate;
RetainmentMaxRate = source.RetainmentMaxRate;
return;
}
private void SetPoolInputConnections(int poolID, PoolSettings poolSettings)
{
int connectionsPerInput = (int)Math.Round(poolSettings.Dim.Size * poolSettings.InputConnectionDensity, 0);
if (connectionsPerInput > 0)
{
int[] indices = new int[poolSettings.Dim.Size];
indices.Indices();
for (int inpIdx = 0; inpIdx < _inputNeurons.Length; inpIdx++)
{
_rand.Shuffle(indices);
for (int i = 0; i < connectionsPerInput; i++)
{
int targetNeuronIdx = indices[i];
StaticSynapse synapse = new StaticSynapse(_inputNeurons[inpIdx],
_poolNeuronsCollection[poolID][targetNeuronIdx],
_rand.NextDouble(poolSettings.InputSynapseWeight.Min, poolSettings.InputSynapseWeight.Max, poolSettings.InputSynapseWeight.RandomSign, poolSettings.InputSynapseWeight.DistrType)
);
AddInterconnection(_neuronInputConnectionsCollection, synapse, false);
}
}
}
return;
}
/// <summary>
/// Creates the simplified configuration of the state machine following the pure LSM design.
/// </summary>
/// <param name="totalSize">The total number of hidden neurons.</param>
/// <param name="spikingActivationCfg">The configuration of the spiking activation function.</param>
/// <param name="excitabilityCfg">The homogenous excitability configuration.</param>
/// <param name="inputConnectionDensity">The density of the input field connections to hidden neurons.</param>
/// <param name="maxInputDelay">The maximum delay of an input synapse.</param>
/// <param name="interconnectionDensity">The density of the hidden neurons recurrent interconnection.</param>
/// <param name="maxInternalDelay">The maximum delay of an internal synapse.</param>
/// <param name="steadyBias">The constant bias (0 means no bias).</param>
/// <param name="predictorsProviderCfg">The configuration of the predictors provider.</param>
public StateMachineSettings CreatePureLSMCfg(int totalSize,
IActivationSettings spikingActivationCfg,
HomogenousExcitabilitySettings excitabilityCfg,
double inputConnectionDensity,
int maxInputDelay,
double interconnectionDensity,
int maxInternalDelay,
double steadyBias,
PredictorsProviderSettings predictorsProviderCfg
)
{
//Check NP is not bypassed
if (BypassedNP)
{
throw new InvalidOperationException("Neural preprocessor is bypassed thus LSM design can't be created.");
}
//Activation check
if (ActivationFactory.CreateAF(spikingActivationCfg, new Random()).TypeOfActivation != ActivationType.Spiking)
{
throw new ArgumentException("Specified activation must be spiking.", "spikingActivationCfg");
}
//One neuron group
SpikingNeuronGroupSettings grp = CreateSpikingGroup(spikingActivationCfg, predictorsProviderCfg, excitabilityCfg, steadyBias);
//Simple spiking pool
PoolSettings poolCfg = new PoolSettings(BuildPoolName(ActivationContent.Spiking, 0),
new ProportionsSettings(totalSize, 1, 1),
new NeuronGroupsSettings(grp),
new InterconnSettings(new RandomSchemaSettings(interconnectionDensity, 0d, false, false))
);
//Simple reservoir structure
ReservoirStructureSettings resStructCfg = new ReservoirStructureSettings(BuildResStructName(ActivationContent.Spiking, 0),
new PoolsSettings(poolCfg)
);
//Input connections configuration
List <InputConnSettings> inputConns = new List <InputConnSettings>(InputEncoderCfg.VaryingFieldsCfg.ExternalFieldsCfg.FieldCfgCollection.Count);
foreach (ExternalFieldSettings fieldCfg in InputEncoderCfg.VaryingFieldsCfg.ExternalFieldsCfg.FieldCfgCollection)
{
InputConnSettings inputConnCfg = new InputConnSettings(fieldCfg.Name,
poolCfg.Name,
inputConnectionDensity,
0
);
inputConns.Add(inputConnCfg);
}
//Synapse general configuration
SpikingSourceSTInputSettings spikingSourceSTInputSettings = new SpikingSourceSTInputSettings(new URandomValueSettings(0, 1), new PlasticitySTInputSettings(new NonlinearDynamicsSTInputSettings()));
SpikingSourceSTExcitatorySettings spikingSourceSTExcitatorySettings = new SpikingSourceSTExcitatorySettings(new URandomValueSettings(0, 1), new PlasticitySTExcitatorySettings(new NonlinearDynamicsSTExcitatorySettings()));
SpikingSourceSTInhibitorySettings spikingSourceSTInhibitorySettings = new SpikingSourceSTInhibitorySettings(new URandomValueSettings(0, 1), new PlasticitySTInhibitorySettings(new NonlinearDynamicsSTInhibitorySettings()));
SynapseSTInputSettings synapseSTInputSettings = new SynapseSTInputSettings(Synapse.SynapticDelayMethod.Random, maxInputDelay, null, spikingSourceSTInputSettings);
SynapseSTExcitatorySettings synapseSTExcitatorySettings = new SynapseSTExcitatorySettings(Synapse.SynapticDelayMethod.Random, maxInternalDelay, 4, null, spikingSourceSTExcitatorySettings);
SynapseSTInhibitorySettings synapseSTInhibitorySettings = new SynapseSTInhibitorySettings(Synapse.SynapticDelayMethod.Random, maxInternalDelay, 1, null, spikingSourceSTInhibitorySettings);
SynapseSTSettings synapseSTCfg = new SynapseSTSettings(synapseSTInputSettings, synapseSTExcitatorySettings, synapseSTInhibitorySettings);
SynapseSettings synapseCfg = new SynapseSettings(synapseSTCfg, null);
//Create reservoir instance
ReservoirInstanceSettings resInstCfg = new ReservoirInstanceSettings(GetResInstName(ResDesign.PureLSM, 0),
resStructCfg.Name,
new InputConnsSettings(inputConns),
synapseCfg
);
//Build and return SM configuration
return(new StateMachineSettings(new NeuralPreprocessorSettings(InputEncoderCfg,
new ReservoirStructuresSettings(resStructCfg),
new ReservoirInstancesSettings(resInstCfg)
),
ReadoutLayerCfg
));
}
/// <summary>
/// Creates the simplified configuration of the state machine following the pure ESN design.
/// </summary>
/// <param name="totalSize">The total number of hidden neurons.</param>
/// <param name="maxInputStrength">The max sum of weights of input synapses per an analog hidden neuron (see the constant DefaultAnalogMaxInputStrength).</param>
/// <param name="inputConnectionDensity">The density of the input field connections to hidden neurons.</param>
/// <param name="maxInputDelay">The maximum delay of an input synapse.</param>
/// <param name="interconnectionDensity">The density of the hidden neurons recurrent interconnection.</param>
/// <param name="maxInternalDelay">The maximum delay of an internal synapse.</param>
/// <param name="maxAbsBias">The maximum absolute value of the bias (0 means no bias).</param>
/// <param name="maxRetainmentStrength">The maximum retainment strength (0 means no retainment).</param>
/// <param name="predictorsProviderCfg">The configuration of the predictors provider.</param>
public StateMachineSettings CreatePureESNCfg(int totalSize,
double maxInputStrength,
double inputConnectionDensity,
int maxInputDelay,
double interconnectionDensity,
int maxInternalDelay,
double maxAbsBias,
double maxRetainmentStrength,
PredictorsProviderSettings predictorsProviderCfg
)
{
//Check NP is not bypassed
if (BypassedNP)
{
throw new InvalidOperationException("Neural preprocessor is bypassed thus ESN design can't be created.");
}
//Default ESN activation
IActivationSettings analogActivationCfg = new AFAnalogTanHSettings();
//One neuron group
AnalogNeuronGroupSettings grp = CreateAnalogGroup(analogActivationCfg, predictorsProviderCfg, maxAbsBias, maxRetainmentStrength);
//Simple analog pool
PoolSettings poolCfg = new PoolSettings(BuildPoolName(ActivationContent.Analog, 0),
new ProportionsSettings(totalSize, 1, 1),
new NeuronGroupsSettings(grp),
new InterconnSettings(new RandomSchemaSettings(interconnectionDensity))
);
//Simple reservoir structure
ReservoirStructureSettings resStructCfg = new ReservoirStructureSettings(BuildResStructName(ActivationContent.Analog, 0),
new PoolsSettings(poolCfg)
);
//Input connections configuration
List <InputConnSettings> inputConns = new List <InputConnSettings>(InputEncoderCfg.VaryingFieldsCfg.ExternalFieldsCfg.FieldCfgCollection.Count);
foreach (ExternalFieldSettings fieldCfg in InputEncoderCfg.VaryingFieldsCfg.ExternalFieldsCfg.FieldCfgCollection)
{
InputConnSettings inputConnCfg = new InputConnSettings(fieldCfg.Name,
poolCfg.Name,
0,
inputConnectionDensity
);
inputConns.Add(inputConnCfg);
}
//Synapse general configuration
SynapseATInputSettings synapseATInputSettings = new SynapseATInputSettings(Synapse.SynapticDelayMethod.Random, maxInputDelay, new AnalogSourceSettings(new URandomValueSettings(0d, maxInputStrength)));
SynapseATIndifferentSettings synapseATIndifferentSettings = new SynapseATIndifferentSettings(Synapse.SynapticDelayMethod.Random, maxInternalDelay);
SynapseATSettings synapseATCfg = new SynapseATSettings(SynapseATSettings.DefaultSpectralRadiusNum, synapseATInputSettings, synapseATIndifferentSettings);
SynapseSettings synapseCfg = new SynapseSettings(null, synapseATCfg);
//Create reservoir instance
ReservoirInstanceSettings resInstCfg = new ReservoirInstanceSettings(GetResInstName(ResDesign.PureESN, 0),
resStructCfg.Name,
new InputConnsSettings(inputConns),
synapseCfg
);
//Build and return SM configuration
return(new StateMachineSettings(new NeuralPreprocessorSettings(InputEncoderCfg,
new ReservoirStructuresSettings(resStructCfg),
new ReservoirInstancesSettings(resInstCfg)
),
ReadoutLayerCfg
));
}
/// <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;
}
/// <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
));
}
/// <summary>
/// Creates StateMachine configuration following pure ESN design
/// </summary>
/// <param name="totalSize">Total number of hidden neurons</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="maxAbsBias">Maximum absolute value of the bias (0 means bias is not required)</param>
/// <param name="maxRetainmentStrength">Maximum retainment strength (0 means retainment property is not required)</param>
/// <param name="predictorsParamsCfg">Predictors parameters (use null for defaults)</param>
/// <param name="allowedPredictor">Allowed predictor(s)</param>
public StateMachineSettings CreatePureESNCfg(int totalSize,
double inputConnectionDensity,
int maxInputDelay,
double interconnectionDensity,
int maxInternalDelay,
double maxAbsBias,
double maxRetainmentStrength,
PredictorsParamsSettings predictorsParamsCfg,
params PredictorsProvider.PredictorID[] allowedPredictor
)
{
const double MaxInputWeightSum = 2.75d;
//Default ESN activation
RCNetBaseSettings aFnCfg = new TanHSettings();
//One neuron group
AnalogNeuronGroupSettings grp = CreateAnalogGroup(aFnCfg, maxAbsBias, maxRetainmentStrength);
//Simple analog pool
PoolSettings poolCfg = new PoolSettings(GetPoolName(ActivationContent.Analog, 0),
new ProportionsSettings(totalSize, 1, 1),
new NeuronGroupsSettings(grp),
new InterconnSettings(new RandomSchemaSettings(interconnectionDensity))
);
//Simple reservoir structure
ReservoirStructureSettings resStructCfg = new ReservoirStructureSettings(GetResStructName(ActivationContent.Analog, 0),
new PoolsSettings(poolCfg)
);
//Input connections configuration
List <InputConnSettings> inputConns = new List <InputConnSettings>(InputCfg.VaryingFieldsCfg.ExternalFieldsCfg.FieldCfgCollection.Count);
double maxInpSynWeight = MaxInputWeightSum / InputCfg.VaryingFieldsCfg.ExternalFieldsCfg.FieldCfgCollection.Count;
foreach (ExternalFieldSettings fieldCfg in InputCfg.VaryingFieldsCfg.ExternalFieldsCfg.FieldCfgCollection)
{
InputConnSettings inputConnCfg = new InputConnSettings(fieldCfg.Name,
poolCfg.Name,
0,
inputConnectionDensity
);
inputConns.Add(inputConnCfg);
}
//Synapse general configuration
AnalogSourceSettings asc = new AnalogSourceSettings(new URandomValueSettings(0, maxInpSynWeight));
SynapseATInputSettings synapseATInputSettings = new SynapseATInputSettings(Synapse.SynapticDelayMethod.Random, maxInputDelay, asc, null);
SynapseATIndifferentSettings synapseATIndifferentSettings = new SynapseATIndifferentSettings(Synapse.SynapticDelayMethod.Random, maxInternalDelay);
SynapseATSettings synapseATCfg = new SynapseATSettings(SynapseATSettings.DefaultSpectralRadiusNum, synapseATInputSettings, synapseATIndifferentSettings);
SynapseSettings synapseCfg = new SynapseSettings(null, synapseATCfg);
//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.PureESN, 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
));
}
/// <summary>
/// Creates the deep copy instance of this instance
/// </summary>
public PoolSettings DeepClone()
{
PoolSettings clone = new PoolSettings(this);
return(clone);
}
