Beispiel #1
0
        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;
        }
Beispiel #2
0
        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;
        }
Beispiel #3
0
        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;
        }
Beispiel #4
0
        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;
        }