Synapse Axon::getSynapse(nidx_t source, id32_t id) const { if(id >= size()) { throw nemo::exception(NEMO_INVALID_INPUT, "synapse id out or range"); } return Synapse(source, m_delays[id], AxonTerminal(id, m_targets[id], m_weights[id], m_plastic[id])); }
void SingleAN(double *px, double cf, int nrep, double tdres, int totalstim, double fibertype, double noiseType, double implnt, double *meanrate, double *varrate, double *psth) { /*variables for the signal-path, control-path and onward */ double *synouttmp,*sptime; int i,nspikes,ipst; double I,spont; double sampFreq = 10e3; /* Sampling frequency used in the synapse */ /* Declarations of the functions used in the program */ double Synapse(double *, double, double, int, int, double, double, double, double, double *); int SpikeGenerator(double *, double, int, int, double *); /* Allocate dynamic memory for the temporary variables */ synouttmp = (double*)mxCalloc(totalstim*nrep,sizeof(double)); sptime = (double*)mxCalloc((long) ceil(totalstim*tdres*nrep/0.00075),sizeof(double)); /* Spontaneous Rate of the fiber corresponding to Fibertype */ if (fibertype==1) spont = 0.1; if (fibertype==2) spont = 4.0; if (fibertype==3) spont = 100.0; /*====== Run the synapse model ======*/ I = Synapse(px, tdres, cf, totalstim, nrep, spont, noiseType, implnt, sampFreq, synouttmp); /* Wrapping up the unfolded (due to no. of repetitions) Synapse Output */ for(i = 0; i<I ; i++) { ipst = (int) (fmod(i,totalstim)); meanrate[ipst] = meanrate[ipst] + synouttmp[i]/nrep; }; /* Synapse Output taking into account the Refractory Effects (Vannucci and Teich, 1978) */ for(i = 0; i<totalstim ; i++) { varrate[i] = meanrate[i]/pow((1+0.75e-3*meanrate[i]),3); /* estimated instananeous variance in the discharge rate */ meanrate[i] = meanrate[i]/(1+0.75e-3*meanrate[i]); /* estimated instantaneous mean rate */ }; /*====== Spike Generations ======*/ nspikes = SpikeGenerator(synouttmp, tdres, totalstim, nrep, sptime); for(i = 0; i < nspikes; i++) { ipst = (int) (fmod(sptime[i],tdres*totalstim) / tdres); psth[ipst] = psth[ipst] + 1; }; /* Freeing dynamic memory allocated earlier */ mxFree(sptime); mxFree(synouttmp); } /* End of the SingleAN function */
void Network::createMultiLayer(int M, int N, double weight, double parameter) { // clear previous network _synapses.clear(); _neurons.clear(); _ptrInputNeurons.clear(); _ptrOutputNeurons.clear(); // reserve memory to store all neurons and synapses // otherwise reallocation and invalid pointers _neurons.reserve(M*M); _synapses.reserve(M*M*M); // add input neurons for (int i=0; i<M; i++) { _neurons.push_back(Neuron()); _neurons[i].init(parameter); _ptrInputNeurons.push_back(&_neurons[i]); } // add other neurons and add synapse // for all layer for (int i=M,k=0; i>N; i--) { // for all neurons of the sub-layer for (int j=0; j<i-1; j++) { // add a neuron _neurons.push_back(Neuron()); _neurons.back().init(parameter); // add synapses from neurons of the main layer to the new neuron for (int l=0; l<i; l++) { _synapses.push_back(Synapse()); _synapses.back().init(&_neurons[k+l], &_neurons.back(), weight); } } k += i; } // get output neurons for (int i=0; i<N; i++) { _ptrOutputNeurons.push_back(&_neurons[_neurons.size()-N+i]); } }
void Neuron::addSynapse(Neuron *n, double w, double d){ synapses.push_back(Synapse(n, w, d)); }
Phenotype *PhenotypeFactory::createPhenotype(Genotype const &genome) { NeuronMap neurons; std::unordered_map<size_t, std::vector<size_t>> terminals; std::unordered_map<size_t, size_t> sources; NeuronList inputs, hiddens, outputs; std::queue<size_t> peninsulas; struct h { size_t operator()(std::pair<size_t, size_t> const &p) const { return std::hash<size_t>()(p.first) ^ std::hash<size_t>()(p.second); } }; struct e { size_t operator()(std::pair<size_t, size_t> const &p1, std::pair<size_t, size_t> const &p2) const { return (p1.first == p2.first) && (p1.second == p2.second); } }; std::unordered_set<std::pair<size_t, size_t>, h, e> graph, visited; // Create neurons for (auto const &g : genotypeManager->neurons) { Neuron *n = new Neuron(g.second.type); neurons.insert({g.first, n}); terminals.insert({g.first, std::vector<size_t>()}); sources.insert({g.first, 0}); if (n->type == NeuronGene::NEURON_INPUT) { inputs.push_back(n); peninsulas.push(g.first); } else if (n->type == NeuronGene::NEURON_OUTPUT) outputs.push_back(n); //else // hiddens.push_back(n); } // Connect neurons for (auto const &g : genome.synapses) { SynapseGene const &sg = g.second; if (sg.isEnabled()) { Neuron *const &from = neurons.at(sg.from); Neuron *const &to = neurons.at(sg.to); from->synapses.push_back(Synapse(to, sg.getWeight())); sources.at(sg.to) += 1; terminals.at(sg.from).push_back(sg.to); graph.insert({sg.from, sg.to}); } } while (!peninsulas.empty()) { std::cout << "Next: " << peninsulas.front() << std::endl; size_t const ni = peninsulas.front(); Neuron *const &n = neurons.at(ni); if (n->type == NeuronGene::NEURON_HIDDEN) hiddens.push_back(n); for (size_t const &nj : terminals.at(ni)) { visited.insert({ni, nj}); std::cout << nj << " " << sources.at(nj) << std::endl; if ((sources.at(nj) -= 1) == 0) { peninsulas.push(nj); std::cout << nj << " pushed" << std::endl; } } peninsulas.pop(); } std::cout << "Edges: " << visited.size() << std::endl; std::cout << "OK? " << (visited.size() == graph.size()) << std::endl; if (visited.size() == graph.size()) return new Phenotype(inputs, hiddens, outputs); return nullptr; }
int UpdateMuscleLoop(double *loopState, double *mnPoolState, double *snPoolState, double *synPoolState, double *loopParam) { // PARAM LOAD double digSpikeSize = loopParam[1]; //???? double timeInterval = loopParam[2]; double reset = loopParam[8]; // *** Izh alpha motoneuron pool :: I (nanoAmp) -> spike double iniMNVolt = loopParam[9]; double iniMNRecov = loopParam[10]; double iniMNSpike = loopParam[11]; double mnState[NUM_MN_STATES]; double mnInput[3]; mnInput[0] = loopParam[0]; // current input to alpha mnInput[1] = digSpikeSize; // spike ? mnInput[1] : 0.0 mnInput[2] = timeInterval; // dt double mnSpikeCount = 0.0; if(reset > 0.01) // RESET -> initialize all motoneuron pool { for (int i = 0; i < NUM_MN; i++) { memcpy(mnState, mnPoolState + NUM_MN_STATES * i, NUM_MN_STATES * sizeof(double)); Izhikevich(mnState, mnInput); if (mnState[2] > 0) { mnSpikeCount += 1.0; //the number of spikes } memcpy(mnPoolState + NUM_MN_STATES * i, mnState, NUM_MN_STATES * sizeof(double)); } } else { for (int i = 0; i < NUM_MN; i++) { mnPoolState[3*i] = iniMNVolt; mnPoolState[3*i+1] = iniMNRecov; mnPoolState[3*i+2] = iniMNSpike; } } // *** Muscle Fiber:: spikes (accumulated) -> Force double musDrive = loopParam[5]; double musTimeConst = loopParam[6]; double musPeakForce = loopParam[7]; double nowF = loopState[3]; double preF = loopState[4]; double C = musTimeConst; double P = musPeakForce; double h = timeInterval; //???? CHECK it out double fiberState[3]; fiberState[0] = C/(exp(1)*P*h*h)-1/(exp(1)*P*h); // define the discretization of the ODE fiberState[1] = -2*C/(exp(1)*P*h*h)+1/(exp(1)*P*C); fiberState[2] = C/(exp(1)*P*h*h)+1/(exp(1)*P*h); double u; double f; u = musDrive/h; f = (u- fiberState[0]* preF - fiberState[1] * nowF)/fiberState[2]; preF = nowF; nowF = f; // *** Spindle :: (Lce, Gd, Gs) -> Ia firing rate (pps) double spindleState[14]; double spindleInput[4]; spindleInput[0] = loopParam[3]; //gd spindleInput[1] = loopParam[14]; //lce spindleInput[2] = timeInterval / (double) CYCLES_OF_INT; //a tenth of dt spindleInput[3] = loopParam[4];; //gs //Bag I spindleState[0] = loopState[3]; // x0 spindleState[1] = loopState[4]; // x1 spindleState[2] = loopState[5]; // x2 spindleState[3] = loopState[6]; // Ia firing rate spindleState[4] = loopState[10]; // dx0 spindleState[5] = loopState[11]; // dx1 spindleState[6] = loopState[12]; // dx2 //Bag II spindleState[7] = loopState[13]; // x3 spindleState[8] = loopState[14]; // x4 spindleState[9] = loopState[15]; // x5 spindleState[10] = loopState[16]; // IIa firing rate spindleState[11] = loopState[17]; // dx3 spindleState[12] = loopState[18]; // dx4 spindleState[13] = loopState[19]; // dx5 for (int j = 0; j < 10; j++) { Spindle(spindleState, spindleInput); } // *** Ia Sensory Neuron :: Ia postsyn current -> Ia_spike double snState[NUM_SN_STATES]; double snInput[3]; snInput[0] = loopParam[13]; // current input to sensory neuron snInput[1] = digSpikeSize; // spike size snInput[2] = timeInterval; // dt //TODO ADD THE OTHER VAR double snSpikeCount = 0.0; if(reset > 0.01) // RESET -> initialize all motoneuron pool { for (int i = 0; i < NUM_SN; i++) { memcpy(snState, snPoolState + NUM_SN_STATES * i, NUM_SN_STATES * sizeof(double)); Izhikevich(snState, snInput); if (snState[2] > 0) { snSpikeCount += 1.0; //the number of spikes } memcpy(snPoolState + NUM_SN_STATES * i, snState, NUM_SN_STATES* sizeof(double)); } } else { for (int i = 0; i < NUM_SN; i++) { snPoolState[3*i] = iniMNVolt; snPoolState[3*i+1] = iniMNRecov; snPoolState[3*i+2] = iniMNSpike; } } // *** synapse :: Ia_firingrate -> Ia_postsyn current double synState[NUM_SYNAPSE_STATES]; double synInput[1]; if(reset > 0.01) // RESET -> initialize all sensory pool { for (int i = 0; i < NUM_SYN; i++) { memcpy(synState, synPoolState + NUM_SYNAPSE_STATES * i, NUM_SYNAPSE_STATES*sizeof(double)); synInput[0]= snPoolState[NUM_SN_STATES * i + 2]; Synapse(synState, synInput); memcpy(synPoolState + NUM_SYNAPSE_STATES * i, mnState, NUM_SYNAPSE_STATES*sizeof(double)); } } if(reset > 0.01) { loopState[2] = mnSpikeCount; //the number of spikes loopState[3] = nowF; // loopState[4] = preF ; // //Bag I loopState[5] = spindleState[0] ; // x0 loopState[6] = spindleState[1] ;// x1 loopState[7] = spindleState[2] ; // x2 loopState[8] = spindleState[3] ;// Ia firing rate loopState[9] = spindleState[4] ; //d x0 loopState[10] = spindleState[5] ;// dx1 loopState[11] = spindleState[6] ; // dx2 //Bag II loopState[12] = spindleState[7] ; // x3 loopState[13] = spindleState[8] ; // x4 loopState[14] = spindleState[9] ; // x5 loopState[15] = spindleState[10]; // IIa firing rate loopState[16] = spindleState[11]; // dx3 loopState[17] = spindleState[12]; // dx4 loopState[18] = spindleState[13]; // dx5 loopState[19] = snSpikeCount; //the number of spikes loopState[20] = synState[0]; //synapse output } else //????? { loopState[2] = 0.0; //the number of spikes loopState[3] = 0.0; // loopState[4] = 0.0 ; // //Bag I loopState[5] = 0.0 ; // x0 loopState[6] = 0.9579 ;// x1 loopState[7] = 0.0 ; // x2 loopState[8] = 0.0 ;// Ia firing rate loopState[9] = 0.0 ; //d x0 loopState[10] = 0.0 ;// dx1 loopState[11] = 0.0 ; // dx2 //Bag II loopState[12] = 0.0 ; // x3 loopState[13] = 0.9579 ; // x4 loopState[14] = 0.0 ; // x5 loopState[15] = 0.0; // IIa firing rate loopState[16] = 0.0; // dx3 loopState[17] = 0.0; // dx4 loopState[18] = 0.0; // dx5 loopState[19] = 0.0; loopState[20] = 0.0; //synapse output } return 0; }