void assign_sard_params (SARDState* p_sard_state, SAWData *p_saw_data, const SARDInputModel *p_in_model, SARDSimParams *p_sim_params, double *sard_params, int normalize_mix_p) { p_sim_params->iters_per_move = (int)round(sard_params[0]); p_sim_params->SAW_length_min = (int)round(sard_params[1]); p_sim_params->SAW_length_max = (int)round(sard_params[1]+sard_params[2]); p_sim_params->P_LL = sard_params[3]; p_sim_params->P_LH = sard_params[4]; p_sim_params->P_HL = sard_params[5]; p_sim_params->gamma_hi = sard_params[7]+sard_params[6]; p_sim_params->gamma_lo = sard_params[7]; if (!normalize_mix_p) { resetSAWHeaps(p_saw_data, p_in_model, p_sim_params); return; } // Pick P_LL, P_LH and P_HL, satisfying the constraint that // P_LL + P_LH + P_HL = 1 by normalizing. double mix_Z = exp(log_sum_exp(log_sum_exp(log(p_sim_params->P_LL), log(p_sim_params->P_HL)), log(p_sim_params->P_LH))); p_sim_params->P_LL /= mix_Z; p_sim_params->P_LH /= mix_Z; p_sim_params->P_HL /= mix_Z; int debug = 0; if (debug) { printf("iters_per_move: %d\n", p_sim_params->iters_per_move); printf("length_min: %d\n", p_sim_params->SAW_length_min); printf("length_max: %d\n", p_sim_params->SAW_length_max); printf("p_sim_params->P_LL: %f\n", p_sim_params->P_LL); printf("p_sim_params->P_LH: %f\n", p_sim_params->P_LH); printf("p_sim_params->P_HL: %f\n", p_sim_params->P_HL); printf("p_sim_params->gamma_hi: %f\n", p_sim_params->gamma_hi); printf("p_sim_params->gamma_lo: %f\n", p_sim_params->gamma_lo); } resetSAWHeapsCurrent(p_sard_state, p_saw_data, p_in_model, p_sim_params); }
double gmm_pdf_log(const gmm_t* gmm, const gsl_vector* x) { gsl_vector* p = gsl_vector_alloc(gmm->k); size_t i; for (i = 0; i < p->size; i++) { gsl_vector_set(p, i, DEBUG_LOG(gsl_vector_get(gmm->weight, i)) + gaussian_pdf_log(gmm->comp[i], x)); } double result = log_sum_exp(p); gsl_vector_free(p); return result; }
void PathTrie::iterate_to_vec(std::vector<PathTrie*>& output) { if (exists_) { log_prob_b_prev = log_prob_b_cur; log_prob_nb_prev = log_prob_nb_cur; log_prob_b_cur = -NUM_FLT_INF; log_prob_nb_cur = -NUM_FLT_INF; score = log_sum_exp(log_prob_b_prev, log_prob_nb_prev); output.push_back(this); } for (auto child : children_) { child.second->iterate_to_vec(output); } }
typename boost::math::tools::promote_args<T_prob>::type categorical_logit_log(int n, const Eigen::Matrix<T_prob, Eigen::Dynamic, 1>& beta) { static const char* function("categorical_logit_log"); check_bounded(function, "categorical outcome out of support", n, 1, beta.size()); check_finite(function, "log odds parameter", beta); if (!include_summand<propto, T_prob>::value) return 0.0; // FIXME: wasteful vs. creating term (n-1) if not vectorized return beta(n-1) - log_sum_exp(beta); // == log_softmax(beta)(n-1); }
/* >>> start tutorial code >>> */ int main( ){ USING_NAMESPACE_ACADO int i; // DEFINE VALRIABLES: // --------------------------- Matrix A(3,3); Vector b(3); DifferentialState x(3); DifferentialState y; Function f[7]; // DEFINE THE VECTOR AND MATRIX ENTRIES: // ------------------------------------- A.setZero() ; A(0,0) = 1.0; A(1,1) = 2.0; A(2,2) = 3.0; b(0) = 1.0; b(1) = 1.0; b(2) = 1.0; // DEFINE TEST FUNCTIONS: // ----------------------- f[0] << A*x + b; f[1] << y + euclidean_norm(A*x + b); f[2] << y*y; f[3] << square(y); f[4] << 5.0*log_sum_exp( x ); // f[5] << entropy( y ); f[6] << -sum_square( x ); for( i = 0; i < 7; i++ ){ if( f[i].isConvex() == BT_TRUE ) printf("f[%d] is convex. \n", i ); else{ if( f[i].isConcave() == BT_TRUE ) printf("f[%d] is concave. \n", i ); else printf("f[%d] is neither convex nor concave. \n", i ); } } return 0; }
std::string BaseQuality::average_base_qualities(std::vector<const std::string*> qualities){ assert(qualities.size() > 0); // Check that all base quality strings are of the same length for (unsigned int i = 0; i < qualities.size(); i++){ if (qualities[i]->size() != qualities[0]->size()) printErrorAndDie("All base quality strings must be of the same length when averaging probabilities"); } // Average raw error probabilities for each base and convert // to the closest quality score std::string avg_qualities('N', qualities[0]->size()); std::vector<double> log_probs(qualities.size()); for (unsigned int i = 0; i < qualities[0]->size(); i++){ for (unsigned int j = 0; j < qualities.size(); j++) log_probs[j] = log_prob_error(qualities[j]->at(i)); double log_mean_prob = log_sum_exp(log_probs) - log(qualities.size()); avg_qualities[i] = closest_char(log_mean_prob); } return avg_qualities; }
// A stupid, basic and crappy linear search-based sampling algorithm. int sample_from_discrete_log_pd(double *log_pd, int log_pd_size) { double log_x = log(genrand_real2()); double log_F = log(DBL_MIN); int i = 0; int sampled_idx = -1; for (i = 0; i < log_pd_size; ++i) { log_F = log_sum_exp(log_F, log_pd[i]); if (log_F >= log_x) { sampled_idx = i; break; } } if (sampled_idx < 0) { if (exp(log_F) < 1) { // This is due to rounding errors resulting in log_pd not // log-exp-summing up to exactly 1.0, so allocate that round-off // error to the last element in the multinomial pd. return log_pd_size - 1; } else { // OMG WTF this is badness. // Should really be throwing an exception, but whatevs. return -1; } } return sampled_idx; }
std::vector<double> CanonicalAverager::calculate_weights(const std::vector<double> &energies, const Binner &binner, const DArray &lnG, const BArray &lnG_support, double beta) { // Assert the arrays got same shape and are one dimensional assert(lnG.same_shape(lnG_support)); assert(lnG.get_shape().size()==1); unsigned int nbins = lnG.get_shape(0); // First make a histogram of the energies given as argument UArray histogram(nbins); for(std::vector<double>::const_iterator it=energies.begin(); it < energies.end(); it++) { int bin = binner.calc_bin(*it); if (0 <= bin && bin < static_cast<int>(nbins)) { histogram(bin)++; } } // Calculate the support for this histogram BArray histogram_support = histogram > 0; // Calculate the normalization constant for the canonical distribution, // by summing over the area with both the histogram and the estimated // entropy (lnG) has support. The normalization constant is given by // // lnZ_beta = log(Z_beta) = log[ sum_E exp( S(E) - beta*E ) ] // // To calculate this we use the log-sum-exp trick BArray support = histogram_support && lnG_support; DArray binning = binner.get_binning_centered(); DArray summands(nbins); for (BArray::constwheretrueiterator it = support.get_constwheretrueiterator(); it(); ++it) { summands(it) = lnG(it) - beta*binning(it); } double lnZ_beta = log_sum_exp(summands, support); // Now calculate the probability for each bin according to the canonical ensemble DArray P_beta(nbins); for (BArray::constwheretrueiterator it = support.get_constwheretrueiterator(); it(); ++it) { P_beta(it) = exp(-beta*binning(it) + lnG(it) - lnZ_beta); } // Calculate the weight for each energy in the energy vector std::vector<double> weights; for(std::vector<double>::const_iterator it=energies.begin(); it < energies.end(); it++) { int bin = binner.calc_bin(*it); if (0 <= bin && bin < static_cast<int>(nbins)) { double weight = 1.0/static_cast<double>(histogram(bin)) * P_beta(bin); weights.push_back(weight); } else { weights.push_back(0); } } return weights; }
void sampleSARD_unif(const SARDInputModel* p_in_model, SARDSimParams* p_sim_params, SARDMCMCDiagnostics* p_out_data, return_sample_fn_t return_sample_fn, double P_LL, double P_HL, size_t strategy) { SAWData* p_saw_data = (SAWData*)malloc(sizeof(SAWData)); SARDState* p_sard_state = (SARDState*)malloc(sizeof(SARDState)); initSARDState(p_sard_state, p_in_model, p_sim_params); // Set up the heaps, etc. initSAWData(p_saw_data, p_in_model, p_sim_params); int nruns_until_next_param_update = 0; if (strategy == 1) { p_sim_params->SAW_length_min = \ p_sim_params->min_SAW_length_bound_min ; p_sim_params->SAW_length_max = p_sim_params->max_SAW_length_bound_min; p_sim_params->P_LL = P_LL; p_sim_params->P_LH = 1.0 - P_LL- P_HL; p_sim_params->P_HL = P_HL; // Pick iters_per_move, gamma_hi and gamma_lo. p_sim_params->iters_per_move = p_sim_params->iters_per_move_min; p_sim_params->gamma_hi = p_sim_params->gamma_hi_min; p_sim_params->gamma_lo = p_sim_params->gamma_lo_min; int debug = 1; if (debug) { printf("iters_per_move: %d\n", (int)round(p_sim_params->iters_per_move)); printf("length_min: %d\n", p_sim_params->SAW_length_min); printf("length_max: %d\n", p_sim_params->SAW_length_max); printf("p_sim_params->P_LL: %f\n", p_sim_params->P_LL); printf("p_sim_params->P_LH: %f\n", p_sim_params->P_LH); printf("p_sim_params->P_HL: %f\n", p_sim_params->P_HL); printf("p_sim_params->gamma_hi: %f\n", p_sim_params->gamma_hi); printf("p_sim_params->gamma_lo: %f\n", p_sim_params->gamma_lo); } resetSAWHeaps(p_saw_data, p_in_model, p_sim_params); } for (int curr_move=0; curr_move<p_sim_params->n_moves; curr_move++) { if (nruns_until_next_param_update <= 0 && strategy == 0) { nruns_until_next_param_update = p_sim_params->nruns_per_param_update; // Pick SAW_length_min and SAW_length_max, satisfying the // constraint that SAW_length_max >= SAW_length_min. p_sim_params->SAW_length_min = \ p_sim_params->min_SAW_length_bound_min + (int) (genrand_real2() * (p_sim_params->min_SAW_length_bound_max - p_sim_params->min_SAW_length_bound_min + 1)); int SAW_length_max_lb = \ max(p_sim_params->SAW_length_min, p_sim_params->max_SAW_length_bound_min); p_sim_params->SAW_length_max = \ SAW_length_max_lb + (int) (genrand_real2() * (p_sim_params->max_SAW_length_bound_max - SAW_length_max_lb + 1)); // Pick P_LL, P_LH and P_HL, satisfying the constraint that // P_LL + P_LH + P_HL = 1 by normalizing. p_sim_params->P_LL = genrand_real1(); p_sim_params->P_LH = genrand_real1(); p_sim_params->P_HL = genrand_real1(); double mix_Z = \ exp(log_sum_exp(log_sum_exp(log(p_sim_params->P_LL), log(p_sim_params->P_HL)), log(p_sim_params->P_LH))); p_sim_params->P_LL /= mix_Z; p_sim_params->P_LH /= mix_Z; p_sim_params->P_HL /= mix_Z; // Pick iters_per_move, gamma_hi and gamma_lo. p_sim_params->iters_per_move = p_sim_params->iters_per_move_min + (int) (genrand_real2() * (p_sim_params->iters_per_move_max - p_sim_params->iters_per_move_min + 1)); p_sim_params->gamma_hi = p_sim_params->gamma_hi_min + (genrand_real1() * (p_sim_params->gamma_hi_max - p_sim_params->gamma_hi_min)); p_sim_params->gamma_lo = p_sim_params->gamma_lo_min + (genrand_real1() * (p_sim_params->gamma_lo_max - p_sim_params->gamma_lo_min)); resetSAWHeaps(p_saw_data, p_in_model, p_sim_params); } --nruns_until_next_param_update; double log_f_fwd, log_f_rev, MH_ratio; double E_initial= p_sard_state->E; // Select move type: { double R=genrand_real2(); if (R <= p_sim_params->P_LL) { p_saw_data->move_type=LL; } else if (R <= p_sim_params->P_LL+p_sim_params->P_LH) { p_saw_data->move_type=LH; } else { p_saw_data->move_type=HL; } } // printf("Just before SAW_move\n"); proposeSAWMove(p_saw_data, p_sard_state, p_in_model, p_sim_params); // printf("Just after SAW_move\n"); evalLogFs(&log_f_fwd, &log_f_rev, p_saw_data, p_sim_params); MH_ratio = p_sim_params->beta_true*(E_initial - p_sard_state->E); MH_ratio += (log_f_rev - log_f_fwd); MH_ratio = exp(MH_ratio); MH_ratio = MH_ratio >1.0 ? 1.0 : MH_ratio; double reward = 0.0; storeDiagnosticsData(p_out_data, p_sim_params, curr_move, E_initial, p_sard_state->E, log_f_fwd, log_f_rev, MH_ratio, (int)p_saw_data->move_type, p_saw_data->sigma_lengths, p_saw_data->rho_lengths, p_sim_params->iters_per_move, p_sim_params->gamma_hi, p_sim_params->gamma_lo, p_sim_params->P_LL, p_sim_params->P_LH, p_sim_params->P_HL, reward); // If rejection, restore state: if (genrand_real2() > MH_ratio) { undoSAWMove(p_saw_data, p_sard_state, p_in_model, p_sim_params); } return_sample_fn(p_sard_state->S, p_in_model->num_nodes); if ((curr_move+1)%1000 == 0) { printf("Iteration: %d has finished.\n", curr_move+1); } } // end moves loop storeEndState(p_out_data, p_sard_state->S, p_in_model->num_nodes); freeSARDState(p_sard_state, p_in_model, p_sim_params); freeSAWData(p_saw_data, p_in_model, p_sim_params); free(p_sard_state); free(p_saw_data); }
void backward() { cout << "\tbackward called" << endl; double* likelihood_t = new double[T]; // B-step int p_count = 0; for (map< int, vector<int> >::iterator map_it = users_time.begin(); map_it != users_time.end(); map_it++) { // if (p_count % 10 == 0) cout << p_count << endl; // p_count++; int old_id = map_it->first; // cout << "\n" << old_id << endl; vector<int> ts = map_it->second; // timestamps for (int offset = 0; offset < ts.size(); offset++) { int t = ts[ts.size()-1] - offset; // t should be decreasing // cout << " t = " << t << endl; if (t == ts[ts.size()-1]) { // t = T-1 int i = G[t].u_map[old_id]; for (int k = 0; k < K; k++) { double p0 = exp(G[t].log_pt_tik[i][k][0]); double random = rand() / (double)RAND_MAX; //cout << "i = " << i << ", t = " << t << ", k = " << k << " p0 = " << p0 << endl; if (random < p0) { G[t].X[i][k] = -1; } else { G[t].X[i][k] = 1; } } } else { // t < T-1 int i = G[t].u_map[old_id]; int next_i = G[t+1].u_map[old_id]; for (int k = 0; k < K; k++) { int cord = ((int)G[t+1].X[next_i][k] == 1) ? 1 : 0; // double log_row_sum = log_sum_exp(G[t+1].log_pt[next_i][k], G[t+1].X[next_i][k], 2*2, 2); double log_col_sum = log_sum_exp(G[t+1].log_pt[next_i][k], cord, 2*2, 2); // should normalize over column: X(t+1) double p0 = exp(G[t+1].log_pt[next_i][k][2*0+cord] - log_col_sum); //cout << "i = " << i << ", t = " << t << ", k = " << k << " p0 = " << p0 << endl; double random = rand() / (double)RAND_MAX; if (random < p0) { G[t].X[i][k] = -1; } else { G[t].X[i][k] = 1; } } } } } // update Sigma for (int t = start_T; t < T; t++) { int n = G[t].n_users; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) { if (i != j) { vector<double> xi = G[t].X[i]; vector<double> xj = G[t].X[j]; G[t].Sigma[i][j] = sigmoid(xi, xj); } } } }