double likelihood_DIRalpha() {
/*
* Dirichlet for topics
*/
int i,t;
double likelihood = 0;
for (i=0; i<ddN.DT; i++) {
for (t=0; t<ddN.T; t++) {
if ( ddS.Ndt[i][t]>0 ) {
#ifdef L_CACHE
if ( ddP.alphac>0 )
likelihood += gcache_value(&ddC.lgalphac, (int)ddS.Ndt[i][t]);
else
#endif
likelihood += gammadiff((int)ddS.Ndt[i][t], ddP.alphapr[t], 0.0);
}
}
#ifdef L_CACHE
likelihood -= gcache_value(&ddC.lgalphatot, (int)ddS.NdT[i]);
#else
likelihood -= gammadiff((int)ddS.NdT[i], ddP.alphatot, 0.0);
#endif
}
//yap_infinite(likelihood);
return likelihood;
}
double likelihood_DIRbeta() {
int j,t;
double likelihood = 0;
double val = 0;
for (t=0; t<ddN.T; t++) {
for (j=0; j<ddN.W; j++) {
if ( ddS.Nwt[j][t]>0 ) {
assert(ddP.betapr[j]>0);
#ifdef L_CACHE
if ( ddP.betac>0 )
val += gcache_value(&ddC.lgbetac, (int)ddS.Nwt[j][t]);
else
#endif
val += gammadiff((int)ddS.Nwt[j][t], ddP.betapr[j], 0.0);
}
}
#ifdef L_CACHE
val -= gcache_value(&ddC.lgbetatot, (int)ddS.NWt[t]);
#else
val -= gammadiff((int)ddS.NWt[t], ddP.betatot, 0.0);
#endif
}
likelihood += val;
//yap_infinite(likelihood);
return likelihood;
}
double likemerge_DIRalpha(k1,k2) {
/*
* Dirichlet for topics
*/
int i,t;
double likelihood = 0;
for (i=0; i<ddN.DT; i++) {
if ( ddS.Ndt[i][k2]>0 ) {
likelihood +=
gammadiff((int)ddS.Ndt[i][k1]+ddS.Ndt[i][k2], ddP.alphapr[k1], 0.0)
- gammadiff((int)ddS.Ndt[i][k1], ddP.alphapr[k1], 0.0)
- gammadiff((int)ddS.Ndt[i][k2], ddP.alphapr[k2], 0.0);
}
}
yap_infinite(likelihood);
return likelihood;
}
double likelihood_PYalpha_HDP() {
/*
* the DP prior, a0==0, its a Dirichlet
*/
int t;
double likelihood = 0;
assert(ddP.a0==0);
for (t=0; t<ddN.T; t++) {
if ( ddS.TDt[t]>0 ) {
likelihood += gammadiff((int)ddS.TDt[t], ddP.b0*ddP.alphapr[t], 0.0);
}
}
likelihood -= lgamma(ddP.b0+ddS.TDT) - lgamma(ddP.b0);
//yap_infinite(likelihood);
return likelihood;
}
double likelihood_PYbeta_HDP() {
/*
* the DP prior, aw0==0, its a Dirichlet
*/
int j;
double likelihood = 0;
assert(ddP.aw0==0);
for (j=0; j<ddN.W; j++) {
if ( ddS.TwT[j]>0 ) {
double p0 = ddP.bw0*ddP.betapr[j];
assert(p0>0);
likelihood += gammadiff((int)ddS.TwT[j],p0,0.0);
}
}
likelihood += pctl_gammaprior(ddP.bw0);
likelihood -= lgamma(ddP.bw0+ddS.TWT) - lgamma(ddP.bw0);
//yap_infinite(likelihood);
return likelihood;
}
double likelihood_NGalpha() {
int i,t;
double likelihood = 0;
for (i=0; i<ddN.DT; i++) {
if ( ddS.NdT[i]==0 ) continue;
for (t=0; t<ddN.T; t++) {
int n=ddS.Ndt[i][t];
if ( n>0 )
likelihood += gammadiff(n, ddP.NGalpha[t], 0.0);
likelihood += ddP.NGalpha[t]*log(ddP.NGbeta[t])
- (n+ddP.NGalpha[t])*log(ddP.NGbeta[t]+ddS.UN[i]);
}
likelihood += (ddS.NdT[i]-1)*log(ddS.UN[i]) - lgamma(ddS.NdT[i]);
}
//yap_infinite(likelihood);
for (t=0; t<ddN.T; t++) {
likelihood += pctl_gammaprior(ddP.NGbeta[t]);
likelihood += pctl_gammaprior(ddP.NGalpha[t]);
}
return likelihood;
}
// likelihood_DIRbeta()
static double likemerge_DIRbeta(int k1, int k2) {
int j;
double val = 0;
for (j=0; j<ddN.W; j++) {
if ( ddS.Nwt[j][k2]>0 ) {
assert(ddP.betapr[j]>0);
val += (gammadiff((int)ddS.Nwt[j][k1]+ddS.Nwt[j][k2], ddP.betapr[j], 0.0)
- gammadiff((int)ddS.Nwt[j][k1], ddP.betapr[j], 0.0)
- gammadiff((int)ddS.Nwt[j][k2], ddP.betapr[j], 0.0));
}
}
val -= (gammadiff((int)ddS.NWt[k1]+ddS.NWt[k2], ddP.betatot, 0.0)
- gammadiff((int)ddS.NWt[k1], ddP.betatot, 0.0)
- gammadiff((int)ddS.NWt[k2], ddP.betatot, 0.0));
yap_infinite(val);
return val;
}
static double alphaterms(double alphatot, void *mydata) {
int t,s;
double val = 0;
double tot;
double lga = lgamma(alphatot/ddN.T);
double lgat = lgamma(alphatot);
#ifdef A_DEBUG
double like;
#endif
#ifdef CONJPRIOR
val += ddN.T*(lgamma((alphatot+1.0)/ddN.T) - lga);
val -= lgamma(alphatot+1.0) - lgamma(alphatot);
#endif
for (s=0; s<ddN.DT; s++) {
tot = 0;
for (t=0; t<ddN.T; t++) {
tot += alphatot/ddN.T+ddS.Ndt[s][t];
val += gammadiff(ddS.Ndt[s][t],alphatot/ddN.T,lga);
}
val -= lgamma(tot) - lgat;
}
myarms_evals++;
myarms_last = alphatot;
#ifdef A_DEBUG
yap_message("Eval alphaterms(%lf) = %lf\n", alphatot, val);
ddP.alphatot = alphatot;
cache_update("alpha");
like = likelihood();
if ( last_val != 0 ) {
yap_message(", lp=%lf diffs=%lf vs %lf\n", like,
val-last_val, like-last_like);
}
last_like = like;
last_val = val;
#endif
return val;
}
double likemerge_DIRbeta(k1,k2) {
int j,t;
double likelihood = 0;
double val = 0;
for (j=0; j<ddN.W; j++) {
if ( ddS.Nwt[j][k2]>0 ) {
assert(ddP.betapr[j]>0);
val += gammadiff((int)ddS.Nwt[j][k1]+ddS.Nwt[j][k2], ddP.betapr[j], 0.0)
- gammadiff((int)ddS.Nwt[j][k1], ddP.betapr[j], 0.0)
- gammadiff((int)ddS.Nwt[j][k2], ddP.betapr[j], 0.0);
}
}
val -= gammadiff((int)ddS.NWt[k1]+ddS.NWt[k2], ddP.betatot, 0.0)
- gammadiff((int)ddS.NWt[k1], ddP.betatot, 0.0)
- gammadiff((int)ddS.NWt[k2], ddP.betatot, 0.0);
likelihood += val;
yap_infinite(likelihood);
return likelihood;
}
double likelihood_PYbeta() {
int i,t;
double likelihood = 0;
double lbw = log(ddP.bwpar);
double law = log(ddP.awpar);
likelihood += pctl_gammaprior(ddP.bwpar);
/*
* term for k-th node
*/
#ifdef BWPAR0
for (t=1; t<ddN.T; t++) {
#else
for (t=0; t<ddN.T; t++) {
#endif
uint32_t Tw_ = 0;
for (i=0; i<ddN.W; i++) {
int tt = ddS.Twt[i][t];
int nn = ddS.Nwt[i][t];
if ( nn>0 ) {
Tw_ += tt;
likelihood += S_S(ddC.SY,nn,tt);
#if 1
if ( !finite(likelihood) || isinf(likelihood) || isnan(likelihood) )
yap_quit("Like=%lf: Nwt[%d][%d]=%d Twt[i][t]=%d S.M=%d S.N=%d\n",
likelihood,
i, t, (int)ddS.Nwt[i][t],(int)ddS.Twt[i][t],ddC.SY->usedM, ddC.SY->usedN);
#endif
}
}
yap_infinite(likelihood);
if ( ddP.awpar==0 ) {
likelihood += Tw_*lbw;
} else {
#ifdef L_CACHE
likelihood += Tw_*law + gcache_value(&ddC.lgbaw, (int)Tw_);
#else
likelihood += Tw_*law + gammadiff((int)Tw_, ddP.bwpar/ddP.awpar, 0.0);
#endif
}
#ifdef L_CACHE
likelihood -= gcache_value(&ddC.lgbw, (int)ddS.NWt[t]);
#else
likelihood -= gammadiff((int)ddS.NWt[t], ddP.bwpar, 0.0);
#endif
yap_infinite(likelihood);
}
yap_infinite(likelihood);
return likelihood;
}
double likelihood_PYbeta_PDP() {
/*
* the constant prior
*/
int j;
double likelihood = 0;
for (j=0; j<ddN.W; j++) {
if ( ddS.TwT[j]>0 ) {
likelihood += ddS.TwT[j]*log(ddP.betapr[j]);
}
}
//yap_infinite(likelihood);
return likelihood;
}
/*
* compute likelihood ratio difference based on *M
*/
static double merge_like_Tdt_sum(int k1, int k2, merge_alpha_t *M) {
double *val;
int d;
val = dvec(ddN.DT);
for (d=0; d<ddN.DT; d++) {
}
#endif
static double merge_like_Tdt(int k1, int k2, merge_alpha_t *M) {
int d;
double la = 0;
double lb = log(ddP.bpar);
int TD_diff = 0;
double likelihood = 0;
if ( ddP.apar>0 ) la = log(ddP.apar);
for (d=0; d<ddN.DT; d++) {
int Td_diff; /* total change in T for doc */
if ( M->Ndt[d]>1 ) {
likelihood -= S_S(ddC.SX,ddS.Ndt[d][k2],ddS.Tdt[d][k2]);
likelihood -= S_S(ddC.SX,ddS.Ndt[d][k1],ddS.Tdt[d][k1]);
likelihood += S_S(ddC.SX,M->Ndt[d],M->Tdt[d]);
assert(M->Tdt[d]>=1);
assert(M->Tdt[d]<=M->Ndt[d]);
assert(ddS.Ndt[d][k2]==0 || ddS.Tdt[d][k2]>0);
assert(ddS.Ndt[d][k1]==0 || ddS.Tdt[d][k1]>0);
}
yap_infinite(likelihood);
TD_diff += Td_diff = (M->Tdt[d]-ddS.Tdt[d][k2]-ddS.Tdt[d][k1]);
if ( Td_diff==0 )
continue;
if ( ddP.apar==0 ) {
likelihood += Td_diff*lb;
} else {
likelihood += Td_diff*la;
if ( Td_diff<0 )
likelihood -=
gammadiff(-Td_diff,M->TdT[d]+ddP.bpar/ddP.apar, 0.0);
else
likelihood +=
gammadiff(Td_diff, M->TdT[d]-Td_diff+ddP.bpar/ddP.apar, 0.0);
}
yap_infinite(likelihood);
}
if ( ddP.PYalpha==H_PDP ) {
likelihood += (M->TDt-ddS.TDt[k1])*log(ddP.alphapr[k1])
- ddS.TDt[k2]*log(ddP.alphapr[k2]);
} else if ( ddP.PYalpha==H_HDP ) {
likelihood += lgamma(M->TDTm+M->TDt-TD_diff+ddP.b0)
- lgamma(M->TDTm+M->TDt+ddP.b0);
likelihood -= gammadiff(ddS.TDt[k1], ddP.b0*ddP.alphapr[k1], 0.0);
likelihood -= gammadiff(ddS.TDt[k2], ddP.b0*ddP.alphapr[k2], 0.0);
likelihood += gammadiff(M->TDt, ddP.b0*ddP.alphapr[k1], 0.0);
} else {
double lga0 = lgamma(1-ddP.a0);
likelihood += lgamma(M->TDTm+M->TDt-TD_diff+ddP.b0)
- lgamma(M->TDTm+M->TDt+ddP.b0);
/* because k2 gone to zero, so one less topic */
likelihood -= log(ddP.b0+ddP.a0*(ddS.TDTnz-1));
if ( ddS.TDt[k2]>1 )
likelihood -= lgamma(ddS.TDt[k2]-ddP.a0) - lga0;
if ( ddS.TDt[k1]>1 )
likelihood -= lgamma(ddS.TDt[k1]-ddP.a0) - lga0;
likelihood += lgamma(M->TDt-ddP.a0) - lga0;
}
yap_infinite(likelihood);
return likelihood;
}
/*
* compute likelihood ratio difference based on *M
*/
static double merge_like_Twt(int k1, int k2, merge_beta_t *M) {
int i, w;
double likelihood = 0;
#ifndef BWPAR0
double lbw = log(ddP.bwpar);
#endif
double law = log(ddP.awpar);
double TW_diff = 0;
#ifdef BWPAR0
yap_quit("BWPAR0 unimpleented in merge\n");
#endif
for (i=0; i<ddN.W; i++) {
likelihood -= S_S(ddC.SY,ddS.Nwt[i][k1],ddS.Twt[i][k2]);
likelihood -= S_S(ddC.SY,ddS.Nwt[i][k1],ddS.Twt[i][k2]);
likelihood += S_S(ddC.SY,M->Nwt[i],M->Twt[i]);
}
if ( ddP.awpar==0 ) {
#ifdef BWPAR0
likelihood += M->TWt-ddS.TWt[k1]*log(ddP_bwpar(k1))
-ddS.TWt[k2]*log(ddP_bwpar(k2));
#else
likelihood += (M->TWt-ddS.TWt[k1]-ddS.TWt[k2])*lbw;
#endif
} else {
likelihood += (M->TWt-ddS.TWt[k1]-ddS.TWt[k2])*law
+ gammadiff((int)M->TWt, ddP.bwpar/ddP.awpar, 0.0)
- gammadiff((int)ddS.TWt[k1], ddP_bwpar(k1)/ddP.awpar, 0.0)
- gammadiff((int)ddS.TWt[k2], ddP_bwpar(k2)/ddP.awpar, 0.0);
}
likelihood += gammadiff((int)ddS.NWt[k1], ddP_bwpar(k1), 0.0);
likelihood += gammadiff((int)ddS.NWt[k2], ddP_bwpar(k2), 0.0);
likelihood -= gammadiff((int)M->NWt, ddP.bwpar, 0.0);
yap_infinite(likelihood);
if ( ddP.PYbeta==H_PDP ) {
for (w=0; w<ddN.W; w++) {
if ( ddS.TwT[w]>0 ) {
// ???????????????
likelihood += ddS.TwT[w]*log(ddP.betapr[w]);
}
}
} else if ( ddP.PYbeta==H_HDP ) {
yap_quit("merge with PYbeta unimplemented\n");
likelihood += lgamma(M->TWTm+M->TWt-TW_diff+ddP.bw0)
- lgamma(M->TWTm+M->TWt+ddP.bw0);
for (w=0; w<ddN.W; w++) {
// ???????????
likelihood -= gammadiff(ddS.TWt[k1], ddP.bw0*ddP.betapr[k1], 0.0);
likelihood -= gammadiff(ddS.TWt[k2], ddP.bw0*ddP.betapr[k2], 0.0);
likelihood += gammadiff(M->TWt, ddP.bw0*ddP.betapr[k1], 0.0);
}
} else {
double lgaw0 = lgamma(1-ddP.aw0);
likelihood += lgamma(M->TWTm+M->TWt-TW_diff+ddP.bw0)
- lgamma(M->TWTm+M->TWt+ddP.bw0);
/* because k2 gone to zero, so one less topic */
likelihood -= log(ddP.bw0+ddP.aw0*(ddS.TWTnz-1));
if ( ddS.TWt[k2]>1 )
likelihood -= lgamma(ddS.TWt[k2]-ddP.aw0) - lgaw0;
if ( ddS.TWt[k1]>1 )
likelihood -= lgamma(ddS.TWt[k1]-ddP.aw0) - lgaw0;
likelihood += lgamma(M->TWt-ddP.aw0) - lgaw0;
}
yap_infinite(likelihood);
return likelihood;
}
