void NaiveSampleGenerator::getSample(base::DataVector& sample) { // generate random sample with dimensionality corresponding to the // size of the given datavector (in 0 to 1) for (size_t i = 0; i < sample.getSize(); i++) { sample[i] = uniformRealDist(rng); } }
void StratifiedSampleGenerator::getSample(SGPP::base::DataVector& dv) { // Check for correct dimension of the parameter vector if (dv.getSize() != dimensions) return; // Choose a random number inside the stratum selected for this dimension for (size_t i = 0; i < dimensions; i++) { dv[i] = (static_cast<float_t>(currentStrata[i]) + uniformRealDist(rng)) * sizeOfStrata[i]; } // continue to the next stratum used for the next sample getNextStrata(); }
NeuralNetwork::NeuralNetwork(const NeuronPointerList::size_type neuronCount, int seed, double j_ee, double j_ie, double j_ei, double j_ii) : J_EE(j_ee), J_IE(j_ie), J_EI(j_ei), J_II(j_ii), //rng(world.rank()), this compiles but does it work? does not seem to work rng(), //uniformDist(rng), uniformRealDist(0.0, 1.0), spikeDelayDistribution(tau_d - s_d, tau_d + s_d), distributionJ_EE(J_EE, 0.1*J_EE), distributionJ_IE(J_IE, 0.1*J_IE), distributionJ_EI(-J_EI, 0.1*J_EI), distributionJ_II(-J_II, 0.1*J_II), neuronList(), localNeuronList(), maxSpikeDelay(int(tau_d + s_d)), localSpikeList(), remoteSpikeList(), totalSpikingNeuronCount(0) { std::cout << "process " << world.rank() << " using seed " << seed << std::endl; rng.seed(seed); // this works std::cout << "maximum spike delay: " << maxSpikeDelay << std::endl; std::cout << "creating local spike list" << std::endl; for ( int i = 0; i < maxSpikeDelay; i++ ) { localSpikeList.push_back(new std::vector<double>()); } // only need one remote spike list std::cout << "creating remote spike list" << std::endl; for ( int r = 0; r < 1; r++ ) { remoteSpikeList.push_back(new std::vector<double>()); } externalInputDistMean = connectionProbability * neuronCount * excitatoryFraction * nu_E_ms * dt; ExcitatoryNeuron::Jexternal = J_EE; InhibitoryNeuron::Jexternal = J_IE; ExcitatoryNeuron::decayCoefficient = 1.0 - dt/tau_E_ms; InhibitoryNeuron::decayCoefficient = 1.0 - dt/tau_I_ms; std::cout << "creating " << neuronCount << " neurons" << std::endl; excitatoryNeuronCount = 0; inhibitoryNeuronCount = 0; for ( int i = 0; i < neuronCount; i++ ) { // use the mpi process size and rank to determine which neurons are local // use i % mpiProcessSize // i i % mpiProcessSize=1 i % mpiProcessSize=2 i % mpiProcessSize=3 // 0 0 0 0 // 1 0 1 1 // 2 0 0 2 // 9 0 1 0 // 10 0 0 1 // if i % mpiProcessSize == (mpiProcessRank-1) then neuron i is local // the process rank of neuron i is easy to predict // processRankNeuronI = (i % mpiProcessSize) // if processRankNeuronI == mpiProcessRank then neuron i is local int mpiProcessRankOfNeuronI = (i % world.size()); //if ( i < 10 ) { // std::cout << "neuron " << i << " has mpiProcessRank " << mpiProcessRankOfNeuronI << std::endl; //} if ( mpiProcessRankOfNeuronI == world.rank() ) { // neuron i is local //if ( i < 10 ) { //std::cout << "neuron " << i << " in process with rank " << world.rank() << " is local" << std::endl; //} if ( uniformRealDist(rng) < excitatoryFraction ) { ExcitatoryNeuron* en = new ExcitatoryNeuron(i, mpiProcessRankOfNeuronI, &localSpikeList); neuronList.push_back(en); localNeuronList.push_back(en); excitatoryNeuronCount++; } else { InhibitoryNeuron* in = new InhibitoryNeuron(i, mpiProcessRankOfNeuronI, &localSpikeList); neuronList.push_back(in); localNeuronList.push_back(in); inhibitoryNeuronCount++; } } else { //if (i < 10) { // std::cout << "neuron " << i << " in process with rank " << world.rank() << " is remote" << std::endl; //} // neuron i is remote RemoteNeuron* rn = new RemoteNeuron(i, mpiProcessRankOfNeuronI, &remoteSpikeList); neuronList.push_back(rn); } } // send the type id of all local neurons to the other processes std::vector<int> neuronTypeIdBuffer; for ( int i = 0; i < localNeuronList.size(); i++ ) { neuronTypeIdBuffer.push_back(localNeuronList.at(i)->getId()); neuronTypeIdBuffer.push_back(localNeuronList.at(i)->getTypeId()); } std::vector< std::vector<int> > remoteNeuronTypeIdBufferList; boost::mpi::all_gather(world, neuronTypeIdBuffer, remoteNeuronTypeIdBufferList); std::vector< std::vector<int> >::const_iterator x = remoteNeuronTypeIdBufferList.begin(); for ( int allgather_rank = 0; allgather_rank < world.size(); allgather_rank++ ) { std::cout << "process " << world.rank() << " reading remote neuron type id buffer from mpi process with rank " << allgather_rank << std::endl; // do not do anything with this process's neurons if ( allgather_rank == world.rank() ) { std::cout << "skipping local neurons in process " << world.rank() << std::endl; } else { std::vector<int> remoteNeuronTypeIdBuffer = remoteNeuronTypeIdBufferList[allgather_rank]; std::vector<int>::const_iterator y = remoteNeuronTypeIdBuffer.begin(); while ( y != remoteNeuronTypeIdBuffer.end() ) { int remoteNeuronId = *y; y++; int remoteNeuronTypeId = *y; y++; //std::cout << "process with rank " << world.rank() // << " setting remote neuron " << remoteNeuronId // << " type to " << remoteNeuronTypeId // << std::endl; RemoteNeuron* remoteNeuron = (RemoteNeuron*) neuronList[remoteNeuronId]; neuronList[remoteNeuronId]->setTypeId(remoteNeuronTypeId); } } } std::cout << "creating connections" << std::endl; std::cout << localNeuronList.size() << " local neurons" << std::endl; std::cout << neuronList.size() << " total neurons" << std::endl; RandomNormalDistribution* distributionJ_xx[2][2]; distributionJ_xx[0][0] = &distributionJ_EE; distributionJ_xx[1][0] = &distributionJ_IE; distributionJ_xx[0][1] = &distributionJ_EI; distributionJ_xx[1][1] = &distributionJ_II; int connectionCounts[2][2]; connectionCounts[0][0] = 0; connectionCounts[1][0] = 0; connectionCounts[0][1] = 0; connectionCounts[1][1] = 0; connectionCount = 0; int localConnectionCount = 0; int remoteConnectionCount = 0; for (int i = 0; i < localNeuronList.size(); i++) { LocalNeuron* sourceNeuron = localNeuronList[i]; for (int j = 0; j < neuronList.size(); j++) { Neuron* targetNeuron = neuronList[j]; if (sourceNeuron->getId() == targetNeuron->getId()) { // do not connect a neuron to itself } else if ( uniformRealDist(rng) < connectionProbability ) { connectionCount++; int delay = spikeDelayDistribution(rng); int targetNeuronTypeId = targetNeuron->getTypeId(); int sourceNeuronTypeId = sourceNeuron->getTypeId(); connectionCounts[targetNeuronTypeId][sourceNeuronTypeId]++; RandomNormalDistribution* efficacyDistribution = distributionJ_xx[targetNeuron->getTypeId()][sourceNeuron->getTypeId()]; double efficacy = (*efficacyDistribution)(rng); sourceNeuron->addConnection( new Connection(sourceNeuron, targetNeuron, efficacy, delay) ); if ( sourceNeuron->getMpiRank() == targetNeuron->getMpiRank() ) { localConnectionCount++; } else { remoteConnectionCount++; } } else { // no connection between these neurons } } } std::cout << "process " << world.rank() << " : " << localConnectionCount << " local connections" << std::endl; std::cout << "process " << world.rank() << " : " << remoteConnectionCount << " remote connections" << std::endl; std::cout << "process " << world.rank() << " : " << connectionCounts[0][0] << " ee connections" << std::endl; std::cout << "process " << world.rank() << " : " << connectionCounts[1][0] << " ie connections" << std::endl; std::cout << "process " << world.rank() << " : " << connectionCounts[0][1] << " ei connections" << std::endl; std::cout << "process " << world.rank() << " : " << connectionCounts[1][1] << " ii connections" << std::endl; std::cout << "process " << world.rank() << " NeuralNetwork initialized" << std::endl; }
static void test_for_replica_exchange(FILE *fplog, const gmx_multisim_t *ms, struct gmx_repl_ex *re, const gmx_enerdata_t *enerd, real vol, gmx_int64_t step, real time) { int m, i, j, a, b, ap, bp, i0, i1, tmp; real delta = 0; gmx_bool bPrint, bMultiEx; gmx_bool *bEx = re->bEx; real *prob = re->prob; int *pind = re->destinations; /* permuted index */ gmx_bool bEpot = FALSE; gmx_bool bDLambda = FALSE; gmx_bool bVol = FALSE; gmx::ThreeFry2x64<64> rng(re->seed, gmx::RandomDomain::ReplicaExchange); gmx::UniformRealDistribution<real> uniformRealDist; gmx::UniformIntDistribution<int> uniformNreplDist(0, re->nrepl-1); bMultiEx = (re->nex > 1); /* multiple exchanges at each state */ fprintf(fplog, "Replica exchange at step %" GMX_PRId64 " time %.5f\n", step, time); if (re->bNPT) { for (i = 0; i < re->nrepl; i++) { re->Vol[i] = 0; } bVol = TRUE; re->Vol[re->repl] = vol; } if ((re->type == ereTEMP || re->type == ereTL)) { for (i = 0; i < re->nrepl; i++) { re->Epot[i] = 0; } bEpot = TRUE; re->Epot[re->repl] = enerd->term[F_EPOT]; /* temperatures of different states*/ for (i = 0; i < re->nrepl; i++) { re->beta[i] = 1.0/(re->q[ereTEMP][i]*BOLTZ); } } else { for (i = 0; i < re->nrepl; i++) { re->beta[i] = 1.0/(re->temp*BOLTZ); /* we have a single temperature */ } } if (re->type == ereLAMBDA || re->type == ereTL) { bDLambda = TRUE; /* lambda differences. */ /* de[i][j] is the energy of the jth simulation in the ith Hamiltonian minus the energy of the jth simulation in the jth Hamiltonian */ for (i = 0; i < re->nrepl; i++) { for (j = 0; j < re->nrepl; j++) { re->de[i][j] = 0; } } for (i = 0; i < re->nrepl; i++) { re->de[i][re->repl] = (enerd->enerpart_lambda[(int)re->q[ereLAMBDA][i]+1]-enerd->enerpart_lambda[0]); } } /* now actually do the communication */ if (bVol) { gmx_sum_sim(re->nrepl, re->Vol, ms); } if (bEpot) { gmx_sum_sim(re->nrepl, re->Epot, ms); } if (bDLambda) { for (i = 0; i < re->nrepl; i++) { gmx_sum_sim(re->nrepl, re->de[i], ms); } } /* make a duplicate set of indices for shuffling */ for (i = 0; i < re->nrepl; i++) { pind[i] = re->ind[i]; } rng.restart( step, 0 ); /* PLUMED */ int plumed_test_exchange_pattern=0; if(plumed_test_exchange_pattern && plumed_hrex) gmx_fatal(FARGS,"hrex not compatible with ad hoc exchange patterns"); /* END PLUMED */ if (bMultiEx) { /* multiple random switch exchange */ int nself = 0; for (i = 0; i < re->nex + nself; i++) { // For now this is superfluous, but just in case we ever add more // calls in different branches it is safer to always reset the distribution. uniformNreplDist.reset(); /* randomly select a pair */ /* in theory, could reduce this by identifying only which switches had a nonneglibible probability of occurring (log p > -100) and only operate on those switches */ /* find out which state it is from, and what label that state currently has. Likely more work that useful. */ i0 = uniformNreplDist(rng); i1 = uniformNreplDist(rng); if (i0 == i1) { nself++; continue; /* self-exchange, back up and do it again */ } a = re->ind[i0]; /* what are the indices of these states? */ b = re->ind[i1]; ap = pind[i0]; bp = pind[i1]; bPrint = FALSE; /* too noisy */ /* calculate the energy difference */ /* if the code changes to flip the STATES, rather than the configurations, use the commented version of the code */ /* delta = calc_delta(fplog,bPrint,re,a,b,ap,bp); */ delta = calc_delta(fplog, bPrint, re, ap, bp, a, b); /* we actually only use the first space in the prob and bEx array, since there are actually many switches between pairs. */ if (delta <= 0) { /* accepted */ prob[0] = 1; bEx[0] = TRUE; } else { if (delta > PROBABILITYCUTOFF) { prob[0] = 0; } else { prob[0] = exp(-delta); } // roll a number to determine if accepted. For now it is superfluous to // reset, but just in case we ever add more calls in different branches // it is safer to always reset the distribution. uniformRealDist.reset(); bEx[0] = uniformRealDist(rng) < prob[0]; } re->prob_sum[0] += prob[0]; if (bEx[0]) { /* swap the states */ tmp = pind[i0]; pind[i0] = pind[i1]; pind[i1] = tmp; } } re->nattempt[0]++; /* keep track of total permutation trials here */ print_allswitchind(fplog, re->nrepl, pind, re->allswaps, re->tmpswap); } else { /* standard nearest neighbor replica exchange */ m = (step / re->nst) % 2; /* PLUMED */ if(plumedswitch){ int partner=re->repl; plumed_cmd(plumedmain,"getExchangesFlag",&plumed_test_exchange_pattern); if(plumed_test_exchange_pattern>0){ int *list; snew(list,re->nrepl); plumed_cmd(plumedmain,"setNumberOfReplicas",&(re->nrepl)); plumed_cmd(plumedmain,"getExchangesList",list); for(i=0; i<re->nrepl; i++) re->ind[i]=list[i]; sfree(list); } for(i=1; i<re->nrepl; i++) { if (i % 2 != m) continue; a = re->ind[i-1]; b = re->ind[i]; if(re->repl==a) partner=b; if(re->repl==b) partner=a; } plumed_cmd(plumedmain,"GREX setPartner",&partner); plumed_cmd(plumedmain,"GREX calculate",NULL); plumed_cmd(plumedmain,"GREX shareAllDeltaBias",NULL); } /* END PLUMED */ for (i = 1; i < re->nrepl; i++) { a = re->ind[i-1]; b = re->ind[i]; bPrint = (re->repl == a || re->repl == b); if (i % 2 == m) { delta = calc_delta(fplog, bPrint, re, a, b, a, b); /* PLUMED */ if(plumedswitch){ real adb,bdb,dplumed; char buf[300]; sprintf(buf,"GREX getDeltaBias %d",a); plumed_cmd(plumedmain,buf,&adb); sprintf(buf,"GREX getDeltaBias %d",b); plumed_cmd(plumedmain,buf,&bdb); dplumed=adb*re->beta[a]+bdb*re->beta[b]; delta+=dplumed; if (bPrint) fprintf(fplog,"dplumed = %10.3e dE_Term = %10.3e (kT)\n",dplumed,delta); } /* END PLUMED */ if (delta <= 0) { /* accepted */ prob[i] = 1; bEx[i] = TRUE; } else { if (delta > PROBABILITYCUTOFF) { prob[i] = 0; } else { prob[i] = exp(-delta); } // roll a number to determine if accepted. For now it is superfluous to // reset, but just in case we ever add more calls in different branches // it is safer to always reset the distribution. uniformRealDist.reset(); bEx[i] = uniformRealDist(rng) < prob[i]; } re->prob_sum[i] += prob[i]; if (bEx[i]) { /* PLUMED */ if(!plumed_test_exchange_pattern) { /* standard neighbour swapping */ /* swap these two */ tmp = pind[i-1]; pind[i-1] = pind[i]; pind[i] = tmp; re->nexchange[i]++; /* statistics for back compatibility */ } else { /* alternative swapping patterns */ tmp = pind[a]; pind[a] = pind[b]; pind[b] = tmp; re->nexchange[i]++; /* statistics for back compatibility */ } /* END PLUMED */ } } else { prob[i] = -1; bEx[i] = FALSE; } } /* print some statistics */ print_ind(fplog, "ex", re->nrepl, re->ind, bEx); print_prob(fplog, "pr", re->nrepl, prob); fprintf(fplog, "\n"); re->nattempt[m]++; } /* PLUMED */ if(plumed_test_exchange_pattern>0) { for (i = 0; i < re->nrepl; i++) { re->ind[i] = i; } } /* END PLUMED */ /* record which moves were made and accepted */ for (i = 0; i < re->nrepl; i++) { re->nmoves[re->ind[i]][pind[i]] += 1; re->nmoves[pind[i]][re->ind[i]] += 1; } fflush(fplog); /* make sure we can see what the last exchange was */ }