static YAP_Bool EM(void) {
YAP_Term arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, out1, out2, out3,
nodesTerm, ruleTerm, tail, pair, compoundTerm;
DdNode *node1, **nodes_ex;
int r, lenNodes, i, iter;
long iter1;
double CLL0 = -2.2 * pow(10, 10); //-inf
double CLL1 = -1.7 * pow(10, 8); //+inf
double p, p0, **eta_rule, ea, er;
double ratio, diff;
arg1 = YAP_ARG1;
arg2 = YAP_ARG2;
arg3 = YAP_ARG3;
arg4 = YAP_ARG4;
arg5 = YAP_ARG5;
arg6 = YAP_ARG6;
arg7 = YAP_ARG7;
arg8 = YAP_ARG8;
nodesTerm = arg1;
ea = YAP_FloatOfTerm(arg2);
er = YAP_FloatOfTerm(arg3);
lenNodes = YAP_IntOfTerm(arg4);
iter = YAP_IntOfTerm(arg5);
nodes_ex = (DdNode **)malloc(lenNodes * sizeof(DdNode *));
nodes_probs_ex = (double *)malloc(lenNodes * sizeof(double));
example_prob = (double *)malloc(lenNodes * sizeof(double));
for (i = 0; i < lenNodes; i++) {
pair = YAP_HeadOfTerm(nodesTerm);
node1 = (DdNode *)YAP_IntOfTerm(YAP_HeadOfTerm(pair));
nodes_ex[i] = node1;
pair = YAP_TailOfTerm(pair);
example_prob[i] = YAP_FloatOfTerm(YAP_HeadOfTerm(pair));
nodesTerm = YAP_TailOfTerm(nodesTerm);
}
diff = CLL1 - CLL0;
ratio = diff / fabs(CLL0);
if (iter == -1)
iter1 = 2147000000;
else
iter1 = iter;
while ((diff > ea) && (ratio > er) && (cycle < iter1)) {
cycle++;
for (r = 0; r < nRules; r++) {
for (i = 0; i < rules[r] - 1; i++) {
eta_rule = eta[r];
eta_rule[i][0] = 0;
eta_rule[i][1] = 0;
}
}
CLL0 = CLL1;
CLL1 = Expectation(nodes_ex, lenNodes);
Maximization();
diff = CLL1 - CLL0;
ratio = diff / fabs(CLL0);
}
out2 = YAP_TermNil();
for (r = 0; r < nRules; r++) {
tail = YAP_TermNil();
p0 = 1;
for (i = 0; i < rules[r] - 1; i++) {
p = arrayprob[r][i] * p0;
tail = YAP_MkPairTerm(YAP_MkFloatTerm(p), tail);
p0 = p0 * (1 - arrayprob[r][i]);
}
tail = YAP_MkPairTerm(YAP_MkFloatTerm(p0), tail);
ruleTerm = YAP_MkIntTerm(r);
compoundTerm =
YAP_MkPairTerm(ruleTerm, YAP_MkPairTerm(tail, YAP_TermNil()));
out2 = YAP_MkPairTerm(compoundTerm, out2);
}
out3 = YAP_TermNil();
for (i = 0; i < lenNodes; i++) {
out3 = YAP_MkPairTerm(YAP_MkFloatTerm(nodes_probs_ex[i]), out3);
}
YAP_Unify(out3, arg8);
out1 = YAP_MkFloatTerm(CLL1);
YAP_Unify(out1, arg6);
free(nodes_ex);
free(example_prob);
free(nodes_probs_ex);
return (YAP_Unify(out2, arg7));
}
double SpeechKMeans::Run(int rounds) {
vector<vector<vector<DataPoint> > > phoneme_states(num_types_);
int num_modes = cluster_problems_.num_modes();
vector<vector<DataPoint> > center_estimators(num_modes);
vector<vector<double> > center_counts(num_modes);
if (use_unsupervised_ && !unsup_initialized_) {
vector<double> weights;
vector<DataPoint> points;
for (int utterance_index = 0;
utterance_index < problems_.utterance_size();
++utterance_index) {
ClusterSegmentsExpectation(utterance_index, &points, &weights);
}
ClusterSegmentsMaximization(&points, &weights);
unsup_initialized_ = true;
}
double round_score = 0.0;
for (int round = 0; round < rounds; ++round) {
if (use_gmm_) {
for (int mode = 0; mode < num_modes; ++mode) {
center_estimators[mode].resize(num_types_);
center_counts[mode].resize(num_types_);
for (int type = 0; type < num_types_; ++type) {
center_estimators[mode][type].resize(problems_.num_features(), 0.0);
for (int feat = 0; feat < problems_.num_features(); ++feat) {
center_estimators[mode][type][feat] = 0.0;
}
center_counts[mode][type] = 0.0;
}
}
}
round_score = 0.0;
int total_correctness = 0;
for (int utterance_index = 0;
utterance_index < problems_.utterance_size();
++utterance_index) {
int correctness;
if (use_unsupervised_) {
round_score += UnsupExpectation(utterance_index, &correctness, &phoneme_states);
total_correctness += correctness;
} else if (!use_gmm_) {
round_score += Expectation(utterance_index, &correctness, &phoneme_states);
total_correctness += correctness;
} else {
round_score += GMMExpectation(utterance_index, center_estimators, center_counts);
Expectation(utterance_index, &correctness, &phoneme_states);
total_correctness += correctness;
}
}
if (use_unsupervised_) {
UnsupMaximization(phoneme_states);
} else if (!use_gmm_) {
Maximization(phoneme_states);
} else {
GMMMaximization(center_estimators, center_counts);
}
cerr << "SCORE: Round score: " << round << " " << round_score << " " << total_correctness << endl;
}
return round_score;
}
