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];
}
