void Tree::bootstrap() { // Use fraction (default 63.21%) of the samples size_t num_samples_inbag = (size_t) num_samples * sample_fraction; // Reserve space, reserve a little more to be save) sampleIDs[0].reserve(num_samples_inbag); oob_sampleIDs.reserve(num_samples * (exp(-sample_fraction) + 0.1)); std::uniform_int_distribution<size_t> unif_dist(0, num_samples - 1); // Start with all samples OOB inbag_counts.resize(num_samples, 0); // Draw num_samples samples with replacement (num_samples_inbag out of n) as inbag and mark as not OOB for (size_t s = 0; s < num_samples_inbag; ++s) { size_t draw = unif_dist(random_number_generator); sampleIDs[0].push_back(draw); ++inbag_counts[draw]; } // Save OOB samples for (size_t s = 0; s < inbag_counts.size(); ++s) { if (inbag_counts[s] == 0) { oob_sampleIDs.push_back(s); } } num_samples_oob = oob_sampleIDs.size(); if (!keep_inbag) { inbag_counts.clear(); } }
FastDMSamplingBase::value_t FastDMSamplingInvNorm::rand(rngeng_t& rngeng) { std::uniform_real_distribution<double> unif_dist; while (true) { const value_t t = randin(rngeng, invabsmu_, invmu2_); const value_t one2t = 0.5 / t; if (t < 2.5) { // short-time series if (acceptt(t, exp(-one2t) * unif_dist(rngeng), one2t)) return t; } else { // long-time series constexpr value_t Cl = -0.6773740579341821; // -log(pi/4)-log(2pi)/2; if (acceptt(t, exp(Cl - one2t - 3 / 2 * log(t)) * unif_dist(rngeng), PI * PI * t / 8)) return t; } } }
void SpikingOutput::randomize_state(){ CImg<double>::iterator next_spk_time_it = next_spk_time->begin(); while(next_spk_time_it < next_spk_time->end()){ // For every spiking output // To randomize the state of each output, we set the last next_spk_time // to the next firing reduced to a random percentage defined by Random_init. *next_spk_time_it = (1.0 - Random_init*unif_dist(rand_gen)) * *next_spk_time_it; // random number in the interval [0,1) seconds from unif. dist. multiplied by previous initial firing period next_spk_time_it++; } }
FastDMSamplingBase::value_t FastDMSamplingInvNorm::randin(rngeng_t& rngeng, value_t mu, value_t mu2) { std::normal_distribution<value_t> randn; std::uniform_real_distribution<double> unif_dist; const value_t z = randn(rngeng); const value_t y = z * z; const value_t x = mu + (mu2 * y - mu * sqrt((4 * mu + mu2 * y) * y)) / 2; return unif_dist(rngeng) <= 1 / (1 + x / mu) ? x : mu2 / x; }
FastDMSamplingBase::value_t FastDMSamplingNormExp::rand(rngeng_t& rngeng) { std::uniform_real_distribution<double> unif_dist; while (true) { const value_t P = F1inf_ * unif_dist(rngeng); if (P <= CF1st_) { // short-time series const value_t erfcinvP = erfcinv(P / Cf1s_); const value_t t = 1 / (2 * a_ * erfcinvP * erfcinvP); if (acceptt(t, exp(- 0.5/(a_ * t) - sqrtamu_ + mu2_ * t / 2) * unif_dist(rngeng), 0.5 / t)) return t; } else { // long-time series const value_t t = -log1p(- (P - CF1st_) / Cf1l_ - F1lt_) / fourmu2pi_; const value_t pi2t8 = PI * PI * t / 8; if (acceptt(t, exp(-pi2t8) * unif_dist(rngeng), pi2t8)) return t; } } }
double mostFrequentValue(std::unordered_map<double, size_t>& class_count, std::mt19937_64 random_number_generator) { std::vector<double> major_classes; // Find maximum count size_t max_count = 0; for (auto& class_value : class_count) { if (class_value.second > max_count) { max_count = class_value.second; major_classes.clear(); major_classes.push_back(class_value.first); } else if (class_value.second == max_count) { major_classes.push_back(class_value.first); } } if (major_classes.size() == 1) { return major_classes[0]; } else { // Choose randomly std::uniform_int_distribution<size_t> unif_dist(0, major_classes.size() - 1); return major_classes[unif_dist(random_number_generator)]; } }
DMSample DMConstDriftConstBound::rand(rngeng_t& rngeng) { compute_dm_consts(); if (!fpt_sampler_) { // initialise sampler at first use const double smu = fabs(dm_consts_->c3()); fpt_sampler_.reset(FastDMSamplingBase::create(smu)); } // use sampler with time re-scaling for non-unit bounds double t = fpt_sampler_->rand(rngeng); std::uniform_real_distribution<double> unif_dist; return DMSample(t * dm_consts_->c1() / 4, unif_dist(rngeng) <= dm_consts_->c5()); }
void TreeClassification::bootstrapBalanced() { // Find the smallest class we want to align to size_t size_smallest = *class_counts->begin(); for (auto current : *class_counts) { size_smallest = (current < size_smallest ? current : size_smallest); } // Reserve space sampleIDs[0].reserve(size_smallest * class_counts->size()); oob_sampleIDs.reserve(num_samples - size_smallest * class_counts->size()); // Start with all samples OOB inbag_counts.resize(num_samples, 0); // Draw size_smallest samples with replacement as inbag and mark as not OOB size_t skip = 0; for (auto current_class : *class_counts) { for (size_t i = 0; i < size_smallest; ++i) { std::uniform_int_distribution<size_t> unif_dist(skip, skip + current_class - 1); size_t draw = unif_dist(random_number_generator); sampleIDs[0].push_back((*sampleIDs_by_class)[draw]); ++inbag_counts[(*sampleIDs_by_class)[draw]]; } skip += current_class; } // Save OOB samples for (size_t s = 0; s < inbag_counts.size(); ++s) { if (inbag_counts[s] == 0) { oob_sampleIDs.push_back(s); } } num_samples_oob = oob_sampleIDs.size(); if (!keep_inbag) { inbag_counts.clear(); } }
void drawWithoutReplacementSimple(std::vector<size_t>& result, std::mt19937_64& random_number_generator, size_t max, std::vector<size_t>& skip, size_t num_samples) { result.reserve(num_samples); // Set all to not selected std::vector<bool> temp; temp.resize(max, false); std::uniform_int_distribution<size_t> unif_dist(0, max - 1 - skip.size()); for (size_t i = 0; i < num_samples; ++i) { size_t draw; do { draw = unif_dist(random_number_generator); for (auto& skip_value : skip) { if (draw >= skip_value) { ++draw; } } } while (temp[draw]); temp[draw] = true; result.push_back(draw); } }
DMSample DMConstDriftConstABound::rand(rngeng_t& rngeng) { value_t t = 0.0; value_t x = 0.0; std::uniform_real_distribution<double> unif_dist; while (true) { const double xlo = fabs(x - b_lo_); const double xup = fabs(x - b_up_); if (fabs(xlo - xup) < 1e-20) { // symmetric bounds, diffusion model in [x - xup, x + xup] const double mutheta = xup * drift_; FastDMSamplingBase* fpt_sampler = FastDMSamplingBase::create(mutheta); t += xup * xup * fpt_sampler->rand(rngeng); delete fpt_sampler; return DMSample(t, unif_dist(rngeng) < 1 / (1 + exp(-2 * mutheta))); } else if (xlo > xup) { // x closer to upper bound, diffusion model in [x - xup, x + xup] const double mutheta = xup * drift_; FastDMSamplingBase* fpt_sampler = FastDMSamplingBase::create(mutheta); t += xup * xup * fpt_sampler->rand(rngeng); delete fpt_sampler; if (unif_dist(rngeng) < 1 / (1 + exp(-2 * mutheta))) return DMSample(t, true); x -= xup; } else { // x closer to lower bound, diffusion model in [x - xlo, x + xlo] const double mutheta = xlo * drift_; FastDMSamplingBase* fpt_sampler = FastDMSamplingBase::create(mutheta); t += xlo * xlo * fpt_sampler->rand(rngeng); delete fpt_sampler; if (unif_dist(rngeng) > 1 / (1 + exp(-2 * mutheta))) return DMSample(t, false); x += xlo; } } }