int main(int argc, char **argv) { FILE *files[64]; int numFiles = 0; for(int i = 2; i < argc; i++){ files[numFiles] = fopen(argv[i], "r"); numFiles++; } if(argv[1][0] == 'q'){ fvec centroids[3]; fvec variances; quantize(numFiles, files, 3, centroids, variances); cout<<variances(0); for(int i = 1; i < F0_FEATURES; i++) cout<<","<<variances(i); cout<<endl; for(int j = 0; j < 3; j++){ cout<<centroids[j](0); for(int i = 1; i < F0_FEATURES; i++) cout<<","<<centroids[j](i); cout<<endl; } } else if(argv[1][0] == 't'){ cout<<"decided on "<<test(files[0], numFiles - 1, &files[1])<<endl; } for(int i = 0; i < numFiles; i++) fclose(files[i]); }
const blitz::Array<double,2> bob::learn::em::GMMMachine::getVariances() const{ blitz::Array<double,2> variances(m_n_gaussians,m_n_inputs); for(size_t i=0; i<m_n_gaussians; ++i) variances(i,blitz::Range::all()) = m_gaussians[i]->getVariance(); return variances; }
std::pair< double, double > gaussian_process::evaluate( const Eigen::MatrixXd& domain ) const { if( domain.rows() != 1 ) { COMMA_THROW( comma::exception, "expected 1 row in domain, got " << domain.rows() << " rows" ); } Eigen::VectorXd means( 1 ); Eigen::VectorXd variances( 1 ); evaluate( domain, means, variances ); return std::make_pair( means( 0 ), variances( 0 ) ); }
void estimator_decorrelator_vector<T>::out(const string &filename) { int i,j,l; ofstream f; variances(); // set the variances for the objects check_variances(); f.open((filename + ".vars.dat").c_str()); l=depth[vec_max_int(depth)]; //for(i=0;i<depth.size();i++) // { // cout<<depth[i]<<" "; // } //cout<<endl; for(i=0;i<l;i++) { for(j=0;j<depth.size();j++) { if (i>=depth[j] -5) { f<<0<<" "; } else { f<< vars[j][i] << " "; } } f<<endl; } f.close(); }
std::vector<float> DestinNetworkAlt::getLayersVariances() { std::vector<float> variances(destin->nLayers); for (int i = 0; i < destin->nLayers; i++) { variances[i] = getVar(i); } return variances; }
// "rotations" msg // --------------------------------------------------------------------------- void gvf_rotations(t_gvf *x,const t_symbol *sss, int argc, t_atom *argv) { int rotationDimension = x->bubi->getRotationsVariance().size(); if (argc == rotationDimension) { vector<float> variances(rotationDimension,0.0001); for (int k=0; k< argc; k++) variances[k] = sqrt(atom_getfloat(&argv[k])); x->bubi->setRotationsVariance(variances); } if (argc == 1) { x->bubi->setRotationsVariance(sqrt(atom_getfloat(argv))); } }
/** * Check whether any column in the data completely separates the response variable. * If so, return the index. */ int LogisticRegression::dataIsSeparable(const vector<vector<double> > &data, const vector<double> &response){ vector<double> covariance(data.size(), 0); vector<double> means(data.size(), 0); vector<double> variances(data.size(), 0); double varResponse = vecops::vecVariance(response); double meanResponse = vecops::vecCumSum(response); meanResponse /= response.size(); for (unsigned int i=0; i < data.size(); i++){ means[i] = vecops::vecCumSum(data[i]); variances[i] = vecops::vecVariance(data[i]); } vecops::vecDiv<double>(means, data[0].size()); // Now compute E[XY] for (unsigned int i=0; i < data.size(); i++){ for (unsigned int j=0; j < data[i].size(); j++){ covariance[i] += data[i][j] * response[j]; } } vecops::vecDiv<double>(covariance, data[0].size()); for (unsigned int i=0; i < data.size(); i++){ covariance[i] -= (means[i]*meanResponse); covariance[i] = abs(covariance[i]); } for (unsigned int i=0; i < data.size(); i++){ covariance[i] /= ( sqrt(varResponse * variances[i] )); } double mx = -1.0; int mxLocation = -1; for (unsigned int i=0; i < covariance.size(); i++){ if (covariance[i] > mx){ mx = covariance[i]; mxLocation = i; } } if (mx >LogisticRegression::SEPARABLE_THRESHOLD) return mxLocation; return -1; }
void estimator_decorrelator<T>::out(const string &filename) { int i; ofstream f; variances(); // set the variances for the objects check_variances(); //cout<<endl; if (vars.size() > 5) { f.open((filename + ".vars.dat").c_str()); for(i=0;i<(vars.size()-5);i++) { f<< i << " "<< (vars[i]) << endl; } f.close(); } }
static int init_state(const char *obsdmp, const char *obsidx, uint32 n_density, uint32 n_stream, const uint32 *veclen, int reest, const char *mixwfn, const char *meanfn, const char *varfn, uint32 ts_off, uint32 ts_cnt, uint32 n_ts, uint32 n_d_ts) { uint32 blksz; vector_t ***mean; vector_t ***var = NULL; vector_t ****fullvar = NULL; float32 ***mixw = NULL; uint32 n_frame; uint32 ignore = 0; codew_t *label; uint32 n_corpus = 0; float64 sqerr; float64 tot_sqerr; segdmp_type_t t; uint32 i, j, ts, n; timing_t *km_timer; timing_t *var_timer; timing_t *em_timer; int32 full_covar; km_timer = timing_get("km"); var_timer = timing_get("var"); em_timer = timing_get("em"); blksz = feat_blksize(); full_covar = cmd_ln_int32("-fullvar"); /* fully-continuous for now */ mean = gauden_alloc_param(ts_cnt, n_stream, n_density, veclen); if (full_covar) fullvar = gauden_alloc_param_full(ts_cnt, n_stream, n_density, veclen); else var = gauden_alloc_param(ts_cnt, n_stream, n_density, veclen); if (mixwfn) mixw = (float32 ***)ckd_calloc_3d(ts_cnt, n_stream, n_density, sizeof(float32)); if ((const char *)cmd_ln_access("-segidxfn")) { E_INFO("Multi-class dump\n"); if (segdmp_open_read((const char **)cmd_ln_access("-segdmpdirs"), (const char *)cmd_ln_access("-segdmpfn"), (const char *)cmd_ln_access("-segidxfn"), &n, &t) != S3_SUCCESS) { E_FATAL("Unable to open dumps\n"); } if (n != n_d_ts) { E_FATAL("Expected %u tied-states in dump, but apparently %u\n", n_d_ts, n); } if (t != SEGDMP_TYPE_FEAT) { E_FATAL("Expected feature dump, but instead saw %u\n", t); } multiclass = TRUE; } else { E_INFO("1-class dump file\n"); multiclass = FALSE; dmp_fp = s3open((const char *)cmd_ln_access("-segdmpfn"), "rb", &dmp_swp); if (dmp_fp == NULL) { E_ERROR_SYSTEM("Unable to open dump file %s for reading\n", (const char *)cmd_ln_access("-segdmpfn")); return S3_ERROR; } if (s3read(&n_frame, sizeof(uint32), 1, dmp_fp, dmp_swp, &ignore) != 1) { E_ERROR_SYSTEM("Unable to open dump file %s for reading\n", (const char *)cmd_ln_access("-segdmpfn")); return S3_ERROR; } data_offset = ftell(dmp_fp); } tot_sqerr = 0; for (i = 0; i < ts_cnt; i++) { ts = ts_off + i; /* stride not accounted for yet */ if (o2d == NULL) { if (multiclass) n_frame = segdmp_n_seg(ts); } else { for (j = 0, n_frame = 0; j < n_o2d[ts]; j++) { n_frame += segdmp_n_seg(o2d[ts][j]); } } E_INFO("Corpus %u: sz==%u frames%s\n", ts, n_frame, (n_frame > *(uint32 *)cmd_ln_access("-vartiethr") ? "" : " tied var")); if (n_frame == 0) { continue; } E_INFO("Convergence ratios are abs(cur - prior) / abs(prior)\n"); /* Do some variety of k-means clustering */ if (km_timer) timing_start(km_timer); sqerr = cluster(ts, n_stream, n_frame, veclen, mean[i], n_density, &label); if (km_timer) timing_stop(km_timer); if (sqerr < 0) { E_ERROR("Unable to do k-means for state %u; skipping...\n", ts); continue; } /* Given the k-means and assuming equal prior liklihoods * compute the variances */ if (var_timer) timing_start(var_timer); if (full_covar) full_variances(ts, mean[i], fullvar[i], n_density, veclen, n_frame, n_stream, label); else variances(ts, mean[i], var[i], n_density, veclen, n_frame, n_stream, label); if (var_timer) timing_stop(var_timer); if (mixwfn) { /* initialize the mixing weights by counting # of occurrances * of the top codeword over the corpus and normalizing */ init_mixw(mixw[i], mean[i], n_density, veclen, n_frame, n_stream, label); ckd_free(label); if (reest == TRUE && full_covar) E_ERROR("EM re-estimation is not yet supported for full covariances\n"); else if (reest == TRUE) { if (em_timer) timing_start(em_timer); /* Do iterations of EM to estimate the mixture densities */ reest_sum(ts, mean[i], var[i], mixw[i], n_density, n_stream, n_frame, veclen, *(uint32 *)cmd_ln_access("-niter"), FALSE, *(uint32 *)cmd_ln_access("-vartiethr")); if (em_timer) timing_stop(em_timer); } } ++n_corpus; tot_sqerr += sqerr; E_INFO("sqerr [%u] == %e\n", ts, sqerr); } if (n_corpus > 0) { E_INFO("sqerr = %e tot %e rms\n", tot_sqerr, sqrt(tot_sqerr/n_corpus)); } if (!multiclass) s3close(dmp_fp); if (meanfn) { if (s3gau_write(meanfn, (const vector_t ***)mean, ts_cnt, n_stream, n_density, veclen) != S3_SUCCESS) { return S3_ERROR; } } else { E_INFO("No mean file given; none written\n"); } if (varfn) { if (full_covar) { if (s3gau_write_full(varfn, (const vector_t ****)fullvar, ts_cnt, n_stream, n_density, veclen) != S3_SUCCESS) return S3_ERROR; } else { if (s3gau_write(varfn, (const vector_t ***)var, ts_cnt, n_stream, n_density, veclen) != S3_SUCCESS) return S3_ERROR; } } else { E_INFO("No variance file given; none written\n"); } if (mixwfn) { if (s3mixw_write(mixwfn, mixw, ts_cnt, n_stream, n_density) != S3_SUCCESS) { return S3_ERROR; } } else { E_INFO("No mixing weight file given; none written\n"); } return S3_SUCCESS; }
/** * This function trains one of the classes of the given machine with the given data. * It computes either BIC projection matrices, or IEC mean and variance. * * @param clazz false for the intrapersonal class, true for the extrapersonal one. * @param machine The machine to be trained. * @param differences A set of (intra/extra)-personal difference vectors that should be trained. */ void bob::learn::em::BICTrainer::train_single(bool clazz, bob::learn::em::BICMachine& machine, const blitz::Array<double,2>& differences) const { int subspace_dim = clazz ? m_M_E : m_M_I; int input_dim = differences.extent(1); int data_count = differences.extent(0); blitz::Range a = blitz::Range::all(); if (subspace_dim){ // train the class using BIC // Compute PCA on the given dataset bob::learn::linear::PCATrainer trainer; const int n_eigs = trainer.output_size(differences); bob::learn::linear::Machine pca(input_dim, n_eigs); blitz::Array<double,1> variances(n_eigs); trainer.train(pca, variances, differences); // compute rho double rho = 0.; int non_zero_eigenvalues = std::min(input_dim, data_count-1); // assert that the number of kept eigenvalues is not chosen to big if (subspace_dim >= non_zero_eigenvalues) throw std::runtime_error((boost::format("The chosen subspace dimension %d is larger than the theoretical number of nonzero eigenvalues %d")%subspace_dim%non_zero_eigenvalues).str()); // compute the average of the reminding eigenvalues for (int i = subspace_dim; i < non_zero_eigenvalues; ++i){ rho += variances(i); } rho /= non_zero_eigenvalues - subspace_dim; // limit dimensionalities pca.resize(input_dim, subspace_dim); variances.resizeAndPreserve(subspace_dim); // check that all variances are meaningful for (int i = 0; i < subspace_dim; ++i){ if (variances(i) < 1e-12) throw std::runtime_error((boost::format("The chosen subspace dimension is %d, but the %dth eigenvalue is already to small")%subspace_dim%i).str()); } // initialize the machine blitz::Array<double, 2> projection = pca.getWeights(); blitz::Array<double, 1> mean = pca.getInputSubtraction(); machine.setBIC(clazz, mean, variances, projection, rho); } else { // train the class using IEC // => compute mean and variance only blitz::Array<double,1> mean(input_dim), variance(input_dim); // compute mean and variance mean = 0.; variance = 0.; for (int n = data_count; n--;){ const blitz::Array<double,1>& diff = differences(n,a); assert(diff.shape()[0] == input_dim); for (int i = input_dim; i--;){ mean(i) += diff(i); variance(i) += sqr(diff(i)); } } // normalize mean and variances for (int i = 0; i < input_dim; ++i){ // intrapersonal variance(i) = (variance(i) - sqr(mean(i)) / data_count) / (data_count - 1.); mean(i) /= data_count; if (variance(i) < 1e-12) throw std::runtime_error((boost::format("The variance of the %dth dimension is too small. Check your data!")%i).str()); } // set the results to the machine machine.setIEC(clazz, mean, variance); } }
void MatchingSegmentClassifier::mostSimilarSegmentLabels(const vector<vector<VectorXd> > &lLabels, const vector<vector<VectorXd> > &sLabels, vector<std::tuple<int, int, double> > &matching, int lNbSeg, int sNbSeg) { int startSeg = ignoreFirst ? 1 : 0; // evaluate similarity for all pairs vector<std::tuple<int, int, double> > allPairsSimilarity; allPairsSimilarity.reserve((lNbSeg - startSeg) * (sNbSeg - startSeg)); //cout<<"computing euclid distances"<<endl; vector<MatrixXd> euclidDistances(this->features.size()); // first evaluate euclidean distances for automatic sigma determination for (int k = 0; k < (int)this->features.size(); k++) { euclidDistances[k] = MatrixXd::Zero(lNbSeg, sNbSeg); for (int i = startSeg; i < lNbSeg; i++) { for (int j = startSeg; j < sNbSeg; j++) { euclidDistances[k](i,j) = (lLabels[k][i] - sLabels[k][j]).norm(); } } } //cout<<"computing variance for each feature"<<endl; // evaluate sigma^2 as the variance of the euclid distances for the feature vector<double> variances(this->features.size(), 0); for (int k = 0; k < (int)this->features.size(); k++) { double mean = euclidDistances[k].mean(); for (int i = startSeg; i < lNbSeg; i++) { for (int j = startSeg; j < sNbSeg; j++) { variances[k] += pow(euclidDistances[k](i,j), 2); } } variances[k] = variances[k] / (double)((lNbSeg - startSeg) * (sNbSeg - startSeg)); variances[k] -= pow(mean, 2); } //cout<<"computing similarity"<<endl; for (int i = startSeg; i < lNbSeg; i++) { for (int j = startSeg; j < sNbSeg; j++) { // evaluate similarity for each features individually for (int k = 0; k < (int)features.size(); k++) { fl::scalar sim = exp(- pow(euclidDistances[k](i,j), 2) / variances[k]); //cout<<"feature "<<k<<" has similarity "<<sim<<endl<<get<1>(this->features[k])->fuzzify(sim)<<endl; get<1>(this->features[k])->setInput(sim); } // run fuzzy similarity engine this->similarity->process(); fl::scalar resultSimilarity = this->similarityOutput->defuzzify(); //cout<<"similarity = "<<this->similarityOutput->fuzzify(resultSimilarity)<<endl; allPairsSimilarity.push_back(std::tuple<int,int,double>(i,j,resultSimilarity)); } } // sort the pairs by similarity, and add them from most to least similar matching.clear(); matching.reserve((lNbSeg - startSeg) * (sNbSeg - startSeg)); sort(allPairsSimilarity.begin(), allPairsSimilarity.end(), compareSim); vector<bool> lAdded(lNbSeg, false); vector<bool> sAdded(sNbSeg, false); for (int i = 0; i < (int)allPairsSimilarity.size(); i++) { std::tuple<int,int,double> edge = allPairsSimilarity[i]; if (!lAdded[get<0>(edge)] && !sAdded[get<1>(edge)]) { matching.push_back(edge); lAdded[get<0>(edge)] = true; sAdded[get<1>(edge)] = true; } } }
Real PiecewiseConstantVariance::totalVariance(Size i) const { QL_REQUIRE(i<variances().size(), "invalid step index"); return std::accumulate(variances().begin(), variances().begin()+i+1, Real(0.0)); }
Real PiecewiseConstantVariance::variance(Size i) const { QL_REQUIRE(i<variances().size(), "invalid step index"); return variances()[i]; }