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