alpha

doc.c:13:    int depth = d->path[0]->tr->depth;
doc.c:18:        gsl_permutation* p = rpermutation(d->levels->size);
doc.c:19:        iv_permute_from_perm(d->levels, p);
doc.c:20:        iv_permute_from_perm(d->word, p);
doc.c:26:    for (i = 0; i < d->word->size; i++)
doc.c:28:        int w = ivget(d->word, i);
doc.c:31:            int l = ivget(d->levels, i);
doc.c:32:            doc_update_level(d, l, -1.0);
doc.c:33:            topic_update_word(d->path[l], w, -1.0);
doc.c:39:        compute_log_p_level(d, *(d->gem_mean), *(d->gem_scale));
doc.c:43:                 vget(d->log_p_level, k) +
doc.c:44:                 vget(d->path[k]->log_prob_w, w));
doc.c:50:        topic_update_word(d->path[new_l], w, 1.0);
doc.c:51:        ivset(d->levels, i, new_l);
doc.c:69:    double levels_sum = sum(d->tot_levels);
doc.c:73:    for (i = 0; i < d->tot_levels->size; i++)
doc.c:76:            ((1 - gem_mean) * gem_scale + vget(d->tot_levels, i)) /
doc.c:77:            (gem_scale + vget(d->tot_levels, i) + levels_sum);
doc.c:79:        vset(d->log_p_level,
doc.c:83:        levels_sum -= vget(d->tot_levels, i);
doc.c:84:        sum_log_prob += log(1 - expected_stick_len);
doc.c:95:    vinc(d->tot_levels, l, update);
doc.c:111:    c->nterms = 0;
doc.c:112:    c->ndoc = 0;
doc.c:118:        c->ndoc = c->ndoc + 1;
doc.c:120:        if ((c->ndoc % 10) == 0) outlog("read doc %d", c->ndoc);
doc.c:122:        c->doc = (doc**) realloc(c->doc, sizeof(doc*) * c->ndoc);
doc.c:123:        c->doc[c->ndoc-1] = malloc(sizeof(doc));
doc.c:124:        d = c->doc[c->ndoc-1];
doc.c:125:        d->id = c->ndoc-1;
doc.c:126:        d->word = new_int_vector(0);
doc.c:134:            word = word - OFFSET;
doc.c:137:            if (word >= c->nterms)
doc.c:139:                c->nterms = word + 1;
doc.c:143:                ivappend(d->word, word);
doc.c:149:        d->levels      = new_int_vector(d->word->size);
doc.c:150:        d->path        = malloc(sizeof(topic*) * depth);
doc.c:151:        d->tot_levels  = gsl_vector_calloc(depth);
doc.c:152:        d->log_p_level = gsl_vector_calloc(depth);
doc.c:153:        d->gem_mean    = &(c->gem_mean);
doc.c:154:        d->gem_scale   = &(c->gem_scale);
doc.c:156:        for (n = 0; n < d->levels->size; n++)
doc.c:157:            ivset(d->levels, n, -1);
doc.c:161:    outlog("number of docs    : %d", c->ndoc);
doc.c:162:    outlog("number of words   : %d", c->nterms);
doc.c:176:    c->gem_mean = gem_mean;
doc.c:177:    c->gem_scale = gem_scale;
doc.c:178:    c->ndoc = 0;
doc.c:179:    c->doc = malloc(sizeof(doc*) * c->ndoc);
doc.c:186: * - each line contains a space delimited list of topic IDs
doc.c:193:    int depth = corp->doc[0]->path[0]->tr->depth;
doc.c:194:    for (d = 0; d < corp->ndoc; d++)
doc.c:196:        fprintf(file, "%d", corp->doc[d]->id);
doc.c:197:        fprintf(file, " %1.9e", corp->doc[d]->score);
doc.c:200:            fprintf(file, " %d", corp->doc[d]->path[l]->id);
doc.c:215:    int depth = corp->doc[0]->path[0]->tr->depth;
doc.c:216:    double prior_a = (1 - corp->gem_mean) * corp->gem_scale;
doc.c:217:    double prior_b = corp->gem_mean * corp->gem_scale;
doc.c:219:    for (i = 0; i < corp->ndoc; i++)
doc.c:221:        doc* curr_doc = corp->doc[i];
doc.c:222:        curr_doc->score = 0;
doc.c:227:            double count = vget(curr_doc->tot_levels, l);
doc.c:236:            double a = vget(curr_doc->tot_levels, l) + prior_a;
doc.c:238:            curr_doc->score +=
doc.c:239:                lgamma(a) + lgamma(b) - lgamma(a + b) -
doc.c:240:                lgamma(prior_b) - lgamma(prior_a) +
doc.c:243:        score += curr_doc->score;
doc.c:245:    // exponential 1 prior: log(1) - 1 * s
doc.c:246:    score += -corp->gem_scale;
doc.c:260:    gsl_vector* alpha = corp->alpha;
doc.c:262:    int depth = corp->doc[0]->path[0]->tr->depth;
doc.c:264:    for (i = 0; i < corp->ndoc; i++)
doc.c:266:        doc* curr_doc = corp->doc[i];
doc.c:269:            score += lgamma(ivget(curr_doc->levels, l) + vget(alpha, l));
doc.c:271:        score -= lgamma(alphatot + curr_doc->word->size);
doc.c:286:    gsl_vector* alpha = corp->alpha;
doc.c:289:    int accept[alpha->size];
doc.c:292:    for (l = 0; l < alpha->size; l++) accept[l] = 0;
doc.c:295:        for (l = 0; l < alpha->size; l++)
doc.c:305:                if (r > exp(new_score - current_score))
doc.c:329:        double old_mean = corp->gem_mean;
doc.c:330:        double old_scale = corp->gem_scale;
doc.c:331:        double old_alpha = corp->gem_mean * corp->gem_scale;
doc.c:338:            corp->gem_mean = new_mean;
doc.c:339:            corp->gem_scale = new_scale;
doc.c:342:            if (r > exp(new_score - current_score))
doc.c:344:                corp->gem_mean = old_mean;
doc.c:345:                corp->gem_scale = old_scale;
doc.c:355:           accept, corp->gem_mean * corp->gem_scale);
doc.c:368:        double old_mean = corp->gem_mean;
doc.c:373:            corp->gem_mean = new_mean;
doc.c:376:            if (r > exp(new_score - current_score))
doc.c:378:                corp->gem_mean = old_mean;
doc.c:387:    printf("ACCEPTED %d; GEM MEAN = %5.3f\n", accept, corp->gem_mean);
doc.c:399:        double old_scale = corp->gem_scale;
doc.c:404:            corp->gem_scale = new_scale;
doc.c:407:            if (r > exp(new_score - current_score))
doc.c:409:                corp->gem_scale = old_scale;
doc.c:418:    // printf("ACCEPTED %d; GEM SCALE = %5.3f\n", accept, corp->gem_scale);
doc.c.~1.33.~:13:    int depth = d->path[0]->tr->depth;
doc.c.~1.33.~:18:        gsl_permutation* p = rpermutation(d->levels->size);
doc.c.~1.33.~:19:        iv_permute_from_perm(d->levels, p);
doc.c.~1.33.~:20:        iv_permute_from_perm(d->word, p);
doc.c.~1.33.~:26:    for (i = 0; i < d->word->size; i++)
doc.c.~1.33.~:28:        int w = ivget(d->word, i);
doc.c.~1.33.~:31:            int l = ivget(d->levels, i);
doc.c.~1.33.~:32:            doc_update_level(d, l, -1.0);
doc.c.~1.33.~:33:            topic_update_word(d->path[l], w, -1.0);
doc.c.~1.33.~:39:        compute_log_p_level(d, *(d->gem_mean), *(d->gem_scale));
doc.c.~1.33.~:43:                 vget(d->log_p_level, k) +
doc.c.~1.33.~:44:                 vget(d->path[k]->log_prob_w, w));
doc.c.~1.33.~:50:        topic_update_word(d->path[new_l], w, 1.0);
doc.c.~1.33.~:51:        ivset(d->levels, i, new_l);
doc.c.~1.33.~:69:    double levels_sum = sum(d->tot_levels);
doc.c.~1.33.~:73:    for (i = 0; i < d->tot_levels->size; i++)
doc.c.~1.33.~:76:            ((1 - gem_mean) * gem_scale + vget(d->tot_levels, i)) /
doc.c.~1.33.~:77:            (gem_scale + vget(d->tot_levels, i) + levels_sum);
doc.c.~1.33.~:79:        vset(d->log_p_level,
doc.c.~1.33.~:83:        // sum += vget(d->tot_levels, i);
doc.c.~1.33.~:85:        levels_sum -= vget(d->tot_levels, i);
doc.c.~1.33.~:86:        sum_log_prob += log(1 - expected_stick_len);
doc.c.~1.33.~:97:    vinc(d->tot_levels, l, update);
doc.c.~1.33.~:113:    c->nterms = 0;
doc.c.~1.33.~:114:    c->ndoc = 0;
doc.c.~1.33.~:120:        c->ndoc = c->ndoc + 1;
doc.c.~1.33.~:122:        if ((c->ndoc % 10) == 0) outlog("read doc %d", c->ndoc);
doc.c.~1.33.~:124:        c->doc = (doc**) realloc(c->doc, sizeof(doc*) * c->ndoc);
doc.c.~1.33.~:125:        c->doc[c->ndoc-1] = malloc(sizeof(doc));
doc.c.~1.33.~:126:        d = c->doc[c->ndoc-1];
doc.c.~1.33.~:127:        d->id = c->ndoc-1;
doc.c.~1.33.~:128:        d->word = new_int_vector(0);
doc.c.~1.33.~:136:            word = word - OFFSET;
doc.c.~1.33.~:139:            if (word >= c->nterms)
doc.c.~1.33.~:141:                c->nterms = word + 1;
doc.c.~1.33.~:145:                ivappend(d->word, word);
doc.c.~1.33.~:151:        d->levels      = new_int_vector(d->word->size);
doc.c.~1.33.~:152:        d->path        = malloc(sizeof(topic*) * depth);
doc.c.~1.33.~:153:        d->tot_levels  = gsl_vector_calloc(depth);
doc.c.~1.33.~:154:        d->log_p_level = gsl_vector_calloc(depth);
doc.c.~1.33.~:155:        d->gem_mean    = &(c->gem_mean);
doc.c.~1.33.~:156:        d->gem_scale   = &(c->gem_scale);
doc.c.~1.33.~:158:        for (n = 0; n < d->levels->size; n++)
doc.c.~1.33.~:159:            ivset(d->levels, n, -1);
doc.c.~1.33.~:163:    outlog("number of docs    : %d", c->ndoc);
doc.c.~1.33.~:164:    outlog("number of words   : %d", c->nterms);
doc.c.~1.33.~:178:    c->gem_mean = gem_mean;
doc.c.~1.33.~:179:    c->gem_scale = gem_scale;
doc.c.~1.33.~:180:    c->ndoc = 0;
doc.c.~1.33.~:181:    c->doc = malloc(sizeof(doc*) * c->ndoc);
doc.c.~1.33.~:188: * - each line contains a space delimited list of topic IDs
doc.c.~1.33.~:195:    int depth = corp->doc[0]->path[0]->tr->depth;
doc.c.~1.33.~:196:    for (d = 0; d < corp->ndoc; d++)
doc.c.~1.33.~:198:        fprintf(file, "%d", corp->doc[d]->id);
doc.c.~1.33.~:199:        fprintf(file, " %1.9e", corp->doc[d]->score);
doc.c.~1.33.~:202:            fprintf(file, " %d", corp->doc[d]->path[l]->id);
doc.c.~1.33.~:217:    int depth = corp->doc[0]->path[0]->tr->depth;
doc.c.~1.33.~:218:    double prior_a = (1 - corp->gem_mean) * corp->gem_scale;
doc.c.~1.33.~:219:    double prior_b = corp->gem_mean * corp->gem_scale;
doc.c.~1.33.~:221:    for (i = 0; i < corp->ndoc; i++)
doc.c.~1.33.~:223:        doc* curr_doc = corp->doc[i];
doc.c.~1.33.~:224:        curr_doc->score = 0;
doc.c.~1.33.~:229:            double count = vget(curr_doc->tot_levels, l);
doc.c.~1.33.~:238:            double a = vget(curr_doc->tot_levels, l) + prior_a;
doc.c.~1.33.~:240:            curr_doc->score +=
doc.c.~1.33.~:241:                lgamma(a) + lgamma(b) - lgamma(a + b) -
doc.c.~1.33.~:242:                lgamma(prior_b) - lgamma(prior_a) +
doc.c.~1.33.~:245:        score += curr_doc->score;
doc.c.~1.33.~:247:    // exponential 1 prior: log(1) - 1 * s
doc.c.~1.33.~:248:    score += -corp->gem_scale;
doc.c.~1.33.~:262:    gsl_vector* alpha = corp->alpha;
doc.c.~1.33.~:264:    int depth = corp->doc[0]->path[0]->tr->depth;
doc.c.~1.33.~:266:    for (i = 0; i < corp->ndoc; i++)
doc.c.~1.33.~:268:        doc* curr_doc = corp->doc[i];
doc.c.~1.33.~:271:            score += lgamma(ivget(curr_doc->levels, l) + vget(alpha, l));
doc.c.~1.33.~:273:        score -= lgamma(alphatot + curr_doc->word->size);
doc.c.~1.33.~:288:    gsl_vector* alpha = corp->alpha;
doc.c.~1.33.~:291:    int accept[alpha->size];
doc.c.~1.33.~:294:    for (l = 0; l < alpha->size; l++) accept[l] = 0;
doc.c.~1.33.~:297:        for (l = 0; l < alpha->size; l++)
doc.c.~1.33.~:307:                if (r > exp(new_score - current_score))
doc.c.~1.33.~:331:        double old_mean = corp->gem_mean;
doc.c.~1.33.~:332:        double old_scale = corp->gem_scale;
doc.c.~1.33.~:333:        double old_alpha = corp->gem_mean * corp->gem_scale;
doc.c.~1.33.~:340:            corp->gem_mean = new_mean;
doc.c.~1.33.~:341:            corp->gem_scale = new_scale;
doc.c.~1.33.~:344:            if (r > exp(new_score - current_score))
doc.c.~1.33.~:346:                corp->gem_mean = old_mean;
doc.c.~1.33.~:347:                corp->gem_scale = old_scale;
doc.c.~1.33.~:357:           accept, corp->gem_mean * corp->gem_scale);
doc.c.~1.33.~:370:        double old_mean = corp->gem_mean;
doc.c.~1.33.~:375:            corp->gem_mean = new_mean;
doc.c.~1.33.~:378:            if (r > exp(new_score - current_score))
doc.c.~1.33.~:380:                corp->gem_mean = old_mean;
doc.c.~1.33.~:389:    printf("ACCEPTED %d; GEM MEAN = %5.3f\n", accept, corp->gem_mean);
doc.c.~1.33.~:401:        double old_scale = corp->gem_scale;
doc.c.~1.33.~:406:            corp->gem_scale = new_scale;
doc.c.~1.33.~:409:            if (r > exp(new_score - current_score))
doc.c.~1.33.~:411:                corp->gem_scale = old_scale;
doc.c.~1.33.~:420:    // printf("ACCEPTED %d; GEM SCALE = %5.3f\n", accept, corp->gem_scale);
Binary file doc.o matches
funs.R:1:plot.scores <- function(filename, ...)
funs.R:3:    x <- read.table(filename);
funs.R:12:plot.score <- function(v, title)
funs.R:20:monitor.scores <- function(filename, lag = 15)
funs.R:31:compute.gamma <- function(n, k.1, k.2)
funs.R:33:    gam.1 <- k.1 / log(n);
funs.R:34:    gam.2 <- k.2 / (log(n) - log(gam.1) - log(log(n)))
gibbs.c:9:    tree * tr = state->tr;
gibbs.c:10:    corpus * corp = state->corp;
gibbs.c:11:    double score = state->score;
gibbs.c:16:    write_vect(tr->eta, "ETA", file);
gibbs.c:17:    write_vect(tr->gam, "GAMMA", file);
gibbs.c:18:    write_double(corp->gem_mean, "GEM_MEAN", file);
gibbs.c:19:    write_double(corp->gem_scale, "GEM_SCALE", file);
gibbs.c:20:    write_double(tr->scaling_shape, "SCALING_SHAPE", file);
gibbs.c:21:    write_double(tr->scaling_scale, "SCALING_SCALE", file);
gibbs.c:36:    FILE* score_f = state->score_log;
gibbs.c:37:    corpus * corp = state->corp;
gibbs.c:38:    tree * tr = state->tr;
gibbs.c:39:    int depth = tr->depth;
gibbs.c:43:        fprintf(state->score_log,
gibbs.c:45:                state->iter, state->gem_score, state->eta_score,
gibbs.c:46:                state->gamma_score, state->score,
gibbs.c:47:                corp->gem_mean, corp->gem_scale);
gibbs.c:49:        for (l = 0; l < depth - 1; l++)
gibbs.c:51:            fprintf(state->score_log, " %7.4e", vget(tr->gam,l));
gibbs.c:55:            fprintf(state->score_log, " %7.4e", vget(tr->eta,l));
gibbs.c:58:        fprintf(state->score_log, "\n");
gibbs.c:59:        fflush(state->score_log);
gibbs.c:61:    if (state->tree_structure_log != NULL)
gibbs.c:63:        write_tree_levels(tr, state->tree_structure_log);
gibbs.c:65:    if (state->run_dir != NULL)
gibbs.c:68:        if ((state->output_lag > 0) &&
gibbs.c:69:            (state->iter % state->output_lag) == 0)
gibbs.c:71:            sprintf(filename, "%s/iter=%06d", state->run_dir, state->iter);
gibbs.c:74:        if (state->score == state->max_score)
gibbs.c:76:            outlog("mode at iteration %04d", state->iter);
gibbs.c:77:            sprintf(filename, "%s/mode", state->run_dir);
gibbs.c:85:    tree * tr = state->tr;
gibbs.c:86:    corpus * corp = state->corp;
gibbs.c:88:    state->gem_score = gem_score(corp);
gibbs.c:89:    state->eta_score = eta_score(tr->root);
gibbs.c:90:    state->gamma_score = gamma_score(tr->root);
gibbs.c:91:    state->score = state->gem_score + state->eta_score + state->gamma_score;
gibbs.c:92:    if ((state->score > state->max_score) || (state->iter == 0))
gibbs.c:94:        state->max_score = state->score;
gibbs.c:100:    tree* tr = state->tr;
gibbs.c:101:    corpus* corp = state->corp;
gibbs.c:102:    state->iter = state->iter + 1;
gibbs.c:103:    int iter = state->iter;
gibbs.c:105:    // set up the sampling level (or fix at the depth - 1)
gibbs.c:107:    if (state->level_lag == -1)
gibbs.c:109:        sampling_level = tr->depth - 1;
gibbs.c:111:    else if ((iter % state->level_lag) == 0)
gibbs.c:113:        int level_inc = iter / state->level_lag;
gibbs.c:114:        sampling_level = level_inc % (tr->depth - 1);
gibbs.c:118:    if (state->shuffle_lag > 0)
gibbs.c:120:       do_shuffle = 1 - (iter % state->shuffle_lag);
gibbs.c:124:        gsl_ran_shuffle(RANDNUMGEN, corp->doc, corp->ndoc, sizeof(doc*));
gibbs.c:128:    for (d = 0; d < corp->ndoc; d++)
gibbs.c:130:        tree_sample_doc_path(tr, corp->doc[d], 1, sampling_level);
gibbs.c:132:    for (d = 0; d < corp->ndoc; d++)
gibbs.c:134:        doc_sample_levels(corp->doc[d], do_shuffle, 1);
gibbs.c:136:    // sample hyper-parameters
gibbs.c:137:    if ((state->hyper_lag > 0) && (iter % state->hyper_lag) == 0)
gibbs.c:141:        // !!! FOR NOW, ALL HYPER-PARAMETER LEARNING IS OFF
gibbs.c:142:        // dfs_sample_scaling(tr->root);
gibbs.c:153:    tree * tr = state->tr;
gibbs.c:154:    corpus * corp = state->corp;
gibbs.c:156:    gsl_ran_shuffle(RANDNUMGEN, corp->doc, corp->ndoc, sizeof(doc*));
gibbs.c:157:    int depth = tr->depth;
gibbs.c:159:    for (i = 0; i < corp->ndoc; i++)
gibbs.c:161:        doc* d = corp->doc[i];
gibbs.c:162:        gsl_vector_set_zero(d->tot_levels);
gibbs.c:163:        gsl_vector_set_zero(d->log_p_level);
gibbs.c:164:        iv_permute(d->word);
gibbs.c:165:        d->path[depth - 1] = tree_fill(tr->root);
gibbs.c:166:        topic_update_doc_cnt(d->path[depth - 1], 1.0);
gibbs.c:167:        for (j = depth - 2; j >= 0; j--)
gibbs.c:169:            d->path[j] = d->path[j+1]->parent;
gibbs.c:170:            topic_update_doc_cnt(d->path[j], 1.0);
gibbs.c:177:    if (state->run_dir != NULL)
gibbs.c:180:        sprintf(filename, "%s/initial", state->run_dir);
gibbs.c:182:        sprintf(filename, "%s/mode", state->run_dir);
gibbs.c:198:    gsl_vector* gam = read_vect("GAM", depth - 1, init);
gibbs.c:205:    state->iter = 0;
gibbs.c:206:    state->corp = corpus_new(gem_mean, gem_scale);
gibbs.c:207:    read_corpus(corpus, state->corp, depth);
gibbs.c:208:    state->tr = tree_new(depth, state->corp->nterms,
gibbs.c:214:    state->shuffle_lag = DEFAULT_SHUFFLE_LAG;
gibbs.c:215:    state->hyper_lag   = DEFAULT_HYPER_LAG;
gibbs.c:216:    state->level_lag   = DEFAULT_LEVEL_LAG;
gibbs.c:217:    state->output_lag  = DEFAULT_OUTPUT_LAG;
gibbs.c:218:    state->run_dir = NULL;
gibbs.c:222:        state->run_dir = malloc(sizeof(char) * 100);
gibbs.c:225:        sprintf(state->run_dir, "%s/run%03d", out_dir, id);
gibbs.c:226:        while (directory_exist(state->run_dir))
gibbs.c:229:            sprintf(state->run_dir, "%s/run%03d", out_dir, id);
gibbs.c:231:        mkdir(state->run_dir, S_IRUSR|S_IWUSR|S_IXUSR);
gibbs.c:234:        sprintf(filename, "%s/tree.log", state->run_dir);
gibbs.c:235:        state->tree_structure_log = fopen(filename, "w");
gibbs.c:236:        sprintf(filename, "%s/score.log", state->run_dir);
gibbs.c:237:        state->score_log = fopen(filename, "w");
gibbs.c:245:    state->corp = corp;
gibbs.c:246:    state->tr = copy_tree(orig->tr);
gibbs.c:248:    state->run_dir = NULL;
gibbs.c:249:    state->score_log = NULL;
gibbs.c:250:    state->tree_structure_log = NULL;
gibbs.c:252:    state->shuffle_lag = orig->shuffle_lag;
gibbs.c:253:    state->hyper_lag = -1;
gibbs.c:254:    state->level_lag = orig->level_lag;
gibbs.c:255:    state->output_lag = -1;
gibbs.c:276:        if ((iter % 100) == 0) outlog("held-out iter %04d", iter);
gibbs.c:280:            double this_score = state->score - orig->score;
gibbs.c:286:    outlog("mean held-out score = %7.3f (%d samples)", score, nsamples);
gibbs.c:287:    free_tree(state->tr);
hyperparameter.c:12:  where \pi/(1-\pi) = a+k-1 / n(b-log(\eta))
hyperparameter.c:15:        sample \alpha' ~ G(a + k, b - log(\eta))
hyperparameter.c:17:        sample \alpha' ~ G(a + k - 1, b - log(\eta))
hyperparameter.c:31:    double pi = shape + k - 1;
hyperparameter.c:32:    double rate = 1.0/scale - log(eta);
hyperparameter.c:39:        alpha_new = rgamma(shape + k - 1, 1.0/rate);
hyperparameter.c:46:    printf("-----\nnew alpha=%g\n-----\n", alpha_new);
Binary file hyperparameter.o matches
main.c:43:    corpus* heldout_corp = corpus_new(state->corp->gem_mean,
main.c:44:                                      state->corp->gem_scale);
main.c:45:    read_corpus(test, heldout_corp, state->tr->depth);
main.c:48:    sprintf(filename, "%s/test.dat", state->run_dir);
main.c:54:               iter, ntopics_in_tree(state->tr));
main.c:56:        if ((state->iter % TEST_LAG) == 0)
main.c:61:                    state->iter, score, ntopics_in_tree(state->tr));
Binary file main.o matches
notes.txt:14:       - distribution over words
notes.txt:15:       - scaling parameter
notes.txt:19:       - tree of topics
notes.txt:20:       - gem mean and scaling
notes.txt:21:       - eta for each level
notes.txt:22:       - gamma can be left over
notes.txt:23:       - hyperparameters for scaling
notes.txt:29:    - for each document
notes.txt:30:      - sample the z's
notes.txt:31:      - sample the path
notes.txt:33:    - for each tree node
notes.txt:34:      - sample gamma
notes.txt:36:    - sample other hyperparameters (maybe)
notes.txt:46:new design: - permute docs if score goes down (is this a proper MC?)
notes.txt:47:            - never permute words
notes.txt:48:            - always sample words as a block
notes.txt:59:       - always permute documents
notes.txt:60:       - always permute document words and sample as a block
notes.txt:61:       - sometimes resample the tree
notes.txt:62:       - sometimes don't sample the tree
notes.txt:63:       - sometimes don't sample the levels
notes.txt:64:       - rarely, completely restart
notes.txt:72:to-do
notes.txt:74:- make everthing a parameter to be read:
notes.txt:75:  - in main.c, topics.h, ... grep "#define"
notes.txt:76:- print code and organize it
notes.txt:77:- make the MH code more general by passing in a score function
notes.txt:78:- no need to recurse always in computing the scores (?)
notes.txt:80:longer term to-do
notes.txt:82:- "warm" start from states
notes.txt:86:- add number of words and total words to corpus structure
notes.txt:87:- add an environment variable and corresponding code for priority of verbosity
notes.txt:88:- make alpha like eta, gamma: point documents back to the corpus to get it
notes.txt:89:- divide up the main function
notes.txt:93:pseudo-code
notes.txt:122:    level[i,d] = -1 for all i, d
notes.txt:132:---
notes.txt:141:- tree
notes.txt:142:- corpus
notes.txt:143:- eta, alpha, gamma
notes.txt:146:- depth
notes.txt:147:- root
notes.txt:148:- eta*
notes.txt:149:- gamma*
notes.txt:150:- total_doc_count
notes.txt:153:- doc_count
notes.txt:154:- word_count
notes.txt:155:- word_total
notes.txt:156:- log_word_prob
notes.txt:157:- nchild
notes.txt:158:- child*[1..nchild]
notes.txt:159:- parent*
notes.txt:160:- prob
notes.txt:161:- eta*
notes.txt:162:- total_doc_count*
notes.txt:165:- words
notes.txt:166:- levels
notes.txt:167:- path[1..L]
notes.txt:168:- tree*
notes.txt:171:- ndoc
notes.txt:172:- doc
notes.txt:173:- alpha*
notes.txt:176:- size
notes.txt:177:- int[]
notes.txt:180:- size
notes.txt:181:- double[]
notes.txt:186:- update word in word_count
notes.txt:187:- update word in word_total
notes.txt:188:- change log_word_prob
notes.txt:191:- populate probabilities [eta, gamma]
notes.txt:192:- sample probability
notes.txt:193:- fill in tree
notes.txt:194:- populate path of the document
notes.txt:195:- (do not update!)
notes.txt:198:- for each document
notes.txt:199:  - sample path
notes.txt:200:  - sample levels
notes.txt:203:- write log probabilities on a line
notes.txt:206:- DFS through topics
notes.txt:207:  - write level and log probabilities
notes.txt:211:    - for each word
notes.txt:212:      - if not init remove word from the topic
notes.txt:213:      - sample level [alpha]
notes.txt:214:      - add word to the topic
notes.txt:219:    - if not init, update document along path (doc, -1.0)
notes.txt:220:    - tree_sample_doc_path(tree, doc)
notes.txt:221:    - update document along path(doc, +1.0)
topic.c:10:    vinc(t->w_cnt, w, update);
topic.c:11:    t->w_tot += update;
topic.c:15:    double eta = vget(t->tr->eta, t->level);
topic.c:16:    vset(t->log_prob_w, w,
topic.c:17:         log(vget(t->w_cnt, w) + eta) -
topic.c:18:         log(t->w_tot + t->w_cnt->size * eta));
topic.c:20:    vset(t->lgam_w_plus_eta, w, lgam(vget(t->w_cnt, w) + eta));
topic.c:32:    t->doc_tot += update;
topic.c:33:    t->log_doc_tot = log(t->doc_tot);
topic.c:46:    int nwords = t->w_cnt->size;
topic.c:47:    double eta = vget(t->tr->eta, t->level);
topic.c:49:    score = lgam(nwords * eta) - nwords * lgam(eta);
topic.c:53:	// score += lgam(vget(t->w_cnt, w) + eta);
topic.c:54:        score += vget(t->lgam_w_plus_eta, w);
topic.c:57:    score -= lgam(t->w_tot + nwords * eta);
topic.c:58:    // exponential(1) prior: log(1) - 1 * eta
topic.c:59:    score -= eta;
topic.c:61:    for (c = 0; c < t->nchild; c++)
topic.c:63:        score += eta_score(t->child[c]);
topic.c:71:    gsl_vector* vect = tr->eta;
topic.c:72:    int depth = vect->size;
topic.c:80:        double current_score = eta_score(tr->root);
topic.c:89:                double new_score = eta_score(tr->root);
topic.c:91:                if (r > exp(new_score - current_score))
topic.c:113:    int depth = d->path[0]->tr->depth;
topic.c:114:    int nword = d->word->size;
topic.c:119:        int level = ivget(d->levels, n);
topic.c:121:            topic_update_word(d->path[level], ivget(d->word, n), update);
topic.c:125:        topic_update_doc_cnt(d->path[n], update);
topic.c:139:    tree_update_from_doc(d, -1.0, root_level);
topic.c:140:    tree_prune(d->path[tr->depth - 1]);
topic.c:148:    int depth = node->tr->depth;
topic.c:149:    int l = depth-1;
topic.c:152:        d->path[l] = node;
topic.c:153:        node = node->parent;
topic.c:154:        l--;
topic.c:184:    double path_prob[tr->depth];
topic.c:185:    populate_prob_dfs(d->path[root_level], d, &logsum, path_prob, root_level);
topic.c:189:    topic* node = tree_sample_path(d->path[root_level], logsum);
topic.c:208:    int nterms = t->log_prob_w->size;
topic.c:209:    int nword = d->word->size;
topic.c:215:	count[ivget(d->word, n)] = 0;
topic.c:219:	if (ivget(d->levels, n) == level)
topic.c:221:	    count[ivget(d->word, n)]++;
topic.c:225:    double eta = vget(t->tr->eta, t->level);
topic.c:226:    result = lgam(t->w_tot + nterms * eta); // !!! this should be precomputed
topic.c:227:    result -= lgam(t->w_tot + vget(d->tot_levels, level) + nterms * eta);
topic.c:231:        int wd = ivget(d->word, n);
topic.c:234:            // result -= vget(t->lgam_w_plus_eta, wd);
topic.c:235:            result -= lgam(vget(t->w_cnt, wd) + eta); // !!! this should be precomputed
topic.c:236:            result += lgam(vget(t->w_cnt, wd) + count[wd] + eta);
topic.c:248:    int nword = d->word->size;
topic.c:252:	count[ivget(d->word, n)] = 0;
topic.c:256:	if (ivget(d->levels, n) == level)
topic.c:257:	    count[ivget(d->word, n)]++;
topic.c:260:    result -= lgam(vget(d->tot_levels, level) + nterms * eta);
topic.c:264:	int wd = ivget(d->word, n);
topic.c:267:	    result -= lgam(eta);
topic.c:283:    int level = node->level;
topic.c:284:    int depth = node->tr->depth;
topic.c:293:        denom = log(node->parent->doc_tot + node->parent->scaling);
topic.c:295:        // denom = log(node->parent->doc_tot + node->parent->nchild * (level - 1) * 0.01 + vget(node->tr->gam, level - 1));
topic.c:297:        // pprob[level] += node->log_doc_tot - denom;
topic.c:298:        pprob[level] += log(node->doc_tot) - denom;
topic.c:303:    if (level < depth - 1)
topic.c:305:        int nterms = node->log_prob_w->size;
topic.c:308:            double eta = vget(node->tr->eta, l);
topic.c:312:        // double gam = vget(node->tr->gam, level) + node->nchild * level * 0.01;
topic.c:315:        pprob[level+1] += log(node->scaling);
topic.c:316:        pprob[level+1] -= log(node->doc_tot + node->scaling);
topic.c:320:    node->prob = 0;
topic.c:321:    for (l = root_level; l < depth; l++) node->prob += pprob[l];
topic.c:325:        *logsum = node->prob;
topic.c:327:        *logsum = log_sum(*logsum, node->prob);
topic.c:330:    for (c = 0; c < node->nchild; c++)
topic.c:331:        populate_prob_dfs(node->child[c], d, logsum, pprob, root_level);
topic.c:343:    topic* parent = t->parent;
topic.c:344:    if (t->doc_tot == 0)
topic.c:365:    for (c = 0; c < t->nchild; c++)
topic.c:367:	delete_node(t->child[c]);
topic.c:371:    int nc = t->parent->nchild;
topic.c:374:	if (t->parent->child[c] == t)
topic.c:376:	    t->parent->child[c] = t->parent->child[nc - 1];
topic.c:377:	    t->parent->nchild--;
topic.c:382:    gsl_vector_free(t->w_cnt);
topic.c:383:    gsl_vector_free(t->log_prob_w);
topic.c:384:    gsl_vector_free(t->lgam_w_plus_eta);
topic.c:385:    free(t->child);
topic.c:397:    if (t->level < t->tr->depth-1)
topic.c:417:    t->nchild++;
topic.c:419:    t->child = (topic**) realloc(t->child, sizeof(topic*) * t->nchild);
topic.c:420:    t->child[t->nchild - 1] = topic_new(t->w_cnt->size, t->level+1, t, t->tr);
topic.c:422:    return(t->child[t->nchild - 1]);
topic.c:435:    t->w_tot = 0;
topic.c:436:    t->w_cnt = gsl_vector_calloc(nwords);
topic.c:437:    t->log_prob_w = gsl_vector_calloc(nwords);
topic.c:438:    t->lgam_w_plus_eta = gsl_vector_calloc(nwords);
topic.c:439:    t->log_doc_tot = 0; // !!! make this a NAN?
topic.c:440:    t->doc_tot = 0;
topic.c:441:    t->level = level;
topic.c:442:    t->nchild = 0;
topic.c:443:    t->child = NULL;
topic.c:444:    t->parent = parent;
topic.c:445:    t->tr = tr;
topic.c:446:    t->id = tr->next_id++;
topic.c:449:    // t->scaling = rgamma(tr->scaling_shape, tr->scaling_scale);
topic.c:450:    t->scaling = t->tr->scaling_shape * t->tr->scaling_scale;
topic.c:454:    double eta = vget(t->tr->eta, t->level);
topic.c:455:    double log_p_w = log(eta) - log(eta * nwords);
topic.c:456:    gsl_vector_set_all(t->log_prob_w, log_p_w);
topic.c:483: * sum     : pointer to running sum -- updated at each call
topic.c:489:    *sum = *sum + exp(node->prob - logsum);
topic.c:497:	for (i = 0; i < node->nchild; i++)
topic.c:499:	    topic* val = tree_sample_dfs(r, node->child[i], sum, logsum);
topic.c:521:    if (t->nchild > 0)
topic.c:523:        score += log_dgamma(t->scaling,
topic.c:524:                            t->tr->scaling_shape,
topic.c:525:                            t->tr->scaling_scale);
topic.c:526:        score += log(t->scaling) * t->nchild;
topic.c:527:        score -= lgam(t->scaling + t->doc_tot);
topic.c:528:        for (c = 0; c < t->nchild; c++)
topic.c:530:            score += lgam(t->scaling + t->child[c]->doc_tot);
topic.c:531:            score += gamma_score(t->child[c]);
topic.c:545:    if (t->nchild > 0)
topic.c:547:        t->scaling = gibbs_sample_DP_scaling(t->scaling,
topic.c:548:                                             t->tr->scaling_shape,
topic.c:549:                                             t->tr->scaling_scale,
topic.c:550:                                             t->nchild,
topic.c:551:                                             t->doc_tot);
topic.c:554:    for (c = 0; c < t->nchild; c++)
topic.c:556:        dfs_sample_scaling(t->child[c]);
topic.c:576:    tr->depth   = depth;
topic.c:577:    tr->eta     = eta;
topic.c:578:    tr->gam     = gam;
topic.c:579:    tr->next_id = 0;
topic.c:580:    tr->scaling_shape = scaling_shape;
topic.c:581:    tr->scaling_scale = scaling_scale;
topic.c:583:    tr->root = topic_new(nwords, 0, NULL, tr);
topic.c:598:    fprintf(file, "%-6d", root_topic->id);
topic.c:600:    if (root_topic->parent != NULL)
topic.c:601:        fprintf(file, " %-6d", root_topic->parent->id);
topic.c:603:        fprintf(file, " %-6d", -1);
topic.c:605:    fprintf(file, " %06.0f", root_topic->doc_tot);
topic.c:606:    fprintf(file, " %06.0f", root_topic->w_tot);
topic.c:607:    fprintf(file, " %06.3e", root_topic->scaling);
topic.c:609:    for (i = 0; i < root_topic->w_cnt->size; i++)
topic.c:611:        fprintf(file, " %6.0f", vget(root_topic->w_cnt, i));
topic.c:615:    for (i = 0; i < root_topic->nchild; i++)
topic.c:617:        write_tree_topics_dfs(root_topic->child[i], file);
topic.c:628:    return(ntopics_in_tree_dfs(tr->root));
topic.c:635:    for (c = 0; c < t->nchild; c++)
topic.c:637:        topics_below += ntopics_in_tree_dfs(t->child[c]);
topic.c:639:    return(t->nchild + topics_below);
topic.c:650:    free_tree_dfs(tr->root);
topic.c:656:    gsl_vector_free(t->w_cnt);
topic.c:657:    gsl_vector_free(t->log_prob_w);
topic.c:658:    gsl_vector_free(t->lgam_w_plus_eta);
topic.c:660:    for (c = 0; c < t->nchild; c++)
topic.c:661:        free_tree_dfs(t->child[c]);
topic.c:672:    tree* tree_copy = tree_new(tr->depth,
topic.c:673:                               tr->root->w_cnt->size,
topic.c:674:                               tr->eta,
topic.c:675:                               tr->gam,
topic.c:676:                               tr->scaling_shape,
topic.c:677:                               tr->scaling_scale);
topic.c:679:    copy_tree_dfs(tr->root, tree_copy->root);
topic.c:689:    for (c = 0; c < src->nchild; c++)
topic.c:692:        child->parent = dest;
topic.c:693:        copy_tree_dfs(src->child[c], child);
topic.c:699:    dest->w_tot = src->w_tot;
topic.c:700:    gsl_vector_memcpy(dest->w_cnt, src->w_cnt);
topic.c:701:    gsl_vector_memcpy(dest->log_prob_w, src->log_prob_w);
topic.c:702:    gsl_vector_memcpy(dest->lgam_w_plus_eta, src->lgam_w_plus_eta);
topic.c:703:    dest->doc_tot = src->doc_tot;
topic.c:704:    dest->log_doc_tot = src->log_doc_tot;
topic.c:705:    dest->id = src->id;
topic.c:706:    dest->level = src->level;
topic.c:707:    dest->nchild = 0; // children get added separately
topic.c:708:    dest->scaling = src->scaling;
topic.c:709:    dest->prob = src->prob;
topic.c:720:    write_tree_level_dfs(tr->root, file);
topic.c:730:    if (root_topic->parent == NULL)
topic.c:732:        fprintf(file, "%d", root_topic->level);
topic.c:736:        fprintf(file, " %d", root_topic->level);
topic.c:738:    for (i = 0; i < root_topic->nchild; i++)
topic.c:740:        write_tree_level_dfs(root_topic->child[i], file);
topic.c:747:    fprintf(file, "%-6s %-6s %-6s %-6s  %-9s %-6s\n",
topic.c:749:    write_tree_topics_dfs(tf->root, file);
topic.c.~1.17.~:10:    vinc(t->w_cnt, w, update);
topic.c.~1.17.~:11:    t->w_tot += update;
topic.c.~1.17.~:15:    double eta = vget(t->tr->eta, t->level);
topic.c.~1.17.~:16:    vset(t->log_prob_w, w,
topic.c.~1.17.~:17:         log(vget(t->w_cnt, w) + eta) -
topic.c.~1.17.~:18:         log(t->w_tot + t->w_cnt->size * eta));
topic.c.~1.17.~:20:    vset(t->lgam_w_plus_eta, w, lgam(vget(t->w_cnt, w) + eta));
topic.c.~1.17.~:32:    t->doc_tot += update;
topic.c.~1.17.~:33:    t->log_doc_tot = log(t->doc_tot);
topic.c.~1.17.~:46:    int nwords = t->w_cnt->size;
topic.c.~1.17.~:47:    double eta = vget(t->tr->eta, t->level);
topic.c.~1.17.~:49:    score = lgam(nwords * eta) - nwords * lgam(eta);
topic.c.~1.17.~:53:	// score += lgam(vget(t->w_cnt, w) + eta);
topic.c.~1.17.~:54:        score += vget(t->lgam_w_plus_eta, w);
topic.c.~1.17.~:57:    score -= lgam(t->w_tot + nwords * eta);
topic.c.~1.17.~:58:    // exponential(1) prior: log(1) - 1 * eta
topic.c.~1.17.~:59:    score -= eta;
topic.c.~1.17.~:61:    for (c = 0; c < t->nchild; c++)
topic.c.~1.17.~:63:        score += eta_score(t->child[c]);
topic.c.~1.17.~:71:    gsl_vector* vect = tr->eta;
topic.c.~1.17.~:72:    int depth = vect->size;
topic.c.~1.17.~:80:        double current_score = eta_score(tr->root);
topic.c.~1.17.~:89:                double new_score = eta_score(tr->root);
topic.c.~1.17.~:91:                if (r > exp(new_score - current_score))
topic.c.~1.17.~:113:    int depth = d->path[0]->tr->depth;
topic.c.~1.17.~:114:    int nword = d->word->size;
topic.c.~1.17.~:119:        int level = ivget(d->levels, n);
topic.c.~1.17.~:121:            topic_update_word(d->path[level], ivget(d->word, n), update);
topic.c.~1.17.~:125:        topic_update_doc_cnt(d->path[n], update);
topic.c.~1.17.~:139:    tree_update_from_doc(d, -1.0, root_level);
topic.c.~1.17.~:140:    tree_prune(d->path[tr->depth - 1]);
topic.c.~1.17.~:148:    int depth = node->tr->depth;
topic.c.~1.17.~:149:    int l = depth-1;
topic.c.~1.17.~:152:        d->path[l] = node;
topic.c.~1.17.~:153:        node = node->parent;
topic.c.~1.17.~:154:        l--;
topic.c.~1.17.~:167:    for (n = 1; n < corp->ndoc; n++)
topic.c.~1.17.~:169:        doc* d = corp->doc[n];
topic.c.~1.17.~:172:    for (n = 1; n < corp->ndoc; n++)
topic.c.~1.17.~:174:        tree_sample_doc_path(tr, corp->doc[n], 0, 0);
topic.c.~1.17.~:199:    double path_prob[tr->depth];
topic.c.~1.17.~:200:    populate_prob_dfs(d->path[root_level], d, &logsum, path_prob, root_level);
topic.c.~1.17.~:204:    topic* node = tree_sample_path(d->path[root_level], logsum);
topic.c.~1.17.~:223:    int nterms = t->log_prob_w->size;
topic.c.~1.17.~:224:    int nword = d->word->size;
topic.c.~1.17.~:230:	count[ivget(d->word, n)] = 0;
topic.c.~1.17.~:234:	if (ivget(d->levels, n) == level)
topic.c.~1.17.~:236:	    count[ivget(d->word, n)]++;
topic.c.~1.17.~:240:    double eta = vget(t->tr->eta, t->level);
topic.c.~1.17.~:241:    result = lgam(t->w_tot + nterms * eta); // !!! this should be precomputed
topic.c.~1.17.~:242:    result -= lgam(t->w_tot + vget(d->tot_levels, level) + nterms * eta);
topic.c.~1.17.~:246:        int wd = ivget(d->word, n);
topic.c.~1.17.~:249:            // result -= vget(t->lgam_w_plus_eta, wd);
topic.c.~1.17.~:250:            result -= lgam(vget(t->w_cnt, wd) + eta); // !!! this should be precomputed
topic.c.~1.17.~:251:            result += lgam(vget(t->w_cnt, wd) + count[wd] + eta);
topic.c.~1.17.~:263:    int nword = d->word->size;
topic.c.~1.17.~:267:	count[ivget(d->word, n)] = 0;
topic.c.~1.17.~:271:	if (ivget(d->levels, n) == level)
topic.c.~1.17.~:272:	    count[ivget(d->word, n)]++;
topic.c.~1.17.~:275:    result -= lgam(vget(d->tot_levels, level) + nterms * eta);
topic.c.~1.17.~:279:	int wd = ivget(d->word, n);
topic.c.~1.17.~:282:	    result -= lgam(eta);
topic.c.~1.17.~:298:    int level = node->level;
topic.c.~1.17.~:299:    int depth = node->tr->depth;
topic.c.~1.17.~:308:        denom = log(node->parent->doc_tot + node->parent->scaling);
topic.c.~1.17.~:310:        // denom = log(node->parent->doc_tot + node->parent->nchild * (level - 1) * 0.01 + vget(node->tr->gam, level - 1));
topic.c.~1.17.~:312:        // pprob[level] += node->log_doc_tot - denom;
topic.c.~1.17.~:313:        pprob[level] += log(node->doc_tot) - denom;
topic.c.~1.17.~:318:    if (level < depth - 1)
topic.c.~1.17.~:320:        int nterms = node->log_prob_w->size;
topic.c.~1.17.~:323:            double eta = vget(node->tr->eta, l);
topic.c.~1.17.~:327:        // double gam = vget(node->tr->gam, level) + node->nchild * level * 0.01;
topic.c.~1.17.~:330:        pprob[level+1] += log(node->scaling);
topic.c.~1.17.~:331:        pprob[level+1] -= log(node->doc_tot + node->scaling);
topic.c.~1.17.~:335:    node->prob = 0;
topic.c.~1.17.~:336:    for (l = root_level; l < depth; l++) node->prob += pprob[l];
topic.c.~1.17.~:340:        *logsum = node->prob;
topic.c.~1.17.~:342:        *logsum = log_sum(*logsum, node->prob);
topic.c.~1.17.~:345:    for (c = 0; c < node->nchild; c++)
topic.c.~1.17.~:346:        populate_prob_dfs(node->child[c], d, logsum, pprob, root_level);
topic.c.~1.17.~:358:    topic* parent = t->parent;
topic.c.~1.17.~:359:    if (t->doc_tot == 0)
topic.c.~1.17.~:380:    for (c = 0; c < t->nchild; c++)
topic.c.~1.17.~:382:	delete_node(t->child[c]);
topic.c.~1.17.~:386:    int nc = t->parent->nchild;
topic.c.~1.17.~:389:	if (t->parent->child[c] == t)
topic.c.~1.17.~:391:	    t->parent->child[c] = t->parent->child[nc - 1];
topic.c.~1.17.~:392:	    t->parent->nchild--;
topic.c.~1.17.~:397:    gsl_vector_free(t->w_cnt);
topic.c.~1.17.~:398:    gsl_vector_free(t->log_prob_w);
topic.c.~1.17.~:399:    gsl_vector_free(t->lgam_w_plus_eta);
topic.c.~1.17.~:400:    free(t->child);
topic.c.~1.17.~:412:    if (t->level < t->tr->depth-1)
topic.c.~1.17.~:432:    t->nchild++;
topic.c.~1.17.~:434:    t->child = (topic**) realloc(t->child, sizeof(topic*) * t->nchild);
topic.c.~1.17.~:435:    t->child[t->nchild - 1] = topic_new(t->w_cnt->size, t->level+1, t, t->tr);
topic.c.~1.17.~:437:    return(t->child[t->nchild - 1]);
topic.c.~1.17.~:450:    t->w_tot = 0;
topic.c.~1.17.~:451:    t->w_cnt = gsl_vector_calloc(nwords);
topic.c.~1.17.~:452:    t->log_prob_w = gsl_vector_calloc(nwords);
topic.c.~1.17.~:453:    t->lgam_w_plus_eta = gsl_vector_calloc(nwords);
topic.c.~1.17.~:454:    t->log_doc_tot = 0; // !!! make this a NAN?
topic.c.~1.17.~:455:    t->doc_tot = 0;
topic.c.~1.17.~:456:    t->level = level;
topic.c.~1.17.~:457:    t->nchild = 0;
topic.c.~1.17.~:458:    t->child = NULL;
topic.c.~1.17.~:459:    t->parent = parent;
topic.c.~1.17.~:460:    t->tr = tr;
topic.c.~1.17.~:461:    t->id = tr->next_id++;
topic.c.~1.17.~:464:    // t->scaling = rgamma(tr->scaling_shape, tr->scaling_scale);
topic.c.~1.17.~:465:    t->scaling = t->tr->scaling_shape * t->tr->scaling_scale;
topic.c.~1.17.~:469:    double eta = vget(t->tr->eta, t->level);
topic.c.~1.17.~:470:    double log_p_w = log(eta) - log(eta * nwords);
topic.c.~1.17.~:471:    gsl_vector_set_all(t->log_prob_w, log_p_w);
topic.c.~1.17.~:498: * sum     : pointer to running sum -- updated at each call
topic.c.~1.17.~:504:    *sum = *sum + exp(node->prob - logsum);
topic.c.~1.17.~:512:	for (i = 0; i < node->nchild; i++)
topic.c.~1.17.~:514:	    topic* val = tree_sample_dfs(r, node->child[i], sum, logsum);
topic.c.~1.17.~:536:    if (t->nchild > 0)
topic.c.~1.17.~:538:        score += log_dgamma(t->scaling,
topic.c.~1.17.~:539:                            t->tr->scaling_shape,
topic.c.~1.17.~:540:                            t->tr->scaling_scale);
topic.c.~1.17.~:541:        score += log(t->scaling) * t->nchild;
topic.c.~1.17.~:542:        score -= lgam(t->scaling + t->doc_tot);
topic.c.~1.17.~:543:        for (c = 0; c < t->nchild; c++)
topic.c.~1.17.~:545:            score += lgam(t->scaling + t->child[c]->doc_tot);
topic.c.~1.17.~:546:            score += gamma_score(t->child[c]);
topic.c.~1.17.~:560:    if (t->nchild > 0)
topic.c.~1.17.~:562:        t->scaling = gibbs_sample_DP_scaling(t->scaling,
topic.c.~1.17.~:563:                                             t->tr->scaling_shape,
topic.c.~1.17.~:564:                                             t->tr->scaling_scale,
topic.c.~1.17.~:565:                                             t->nchild,
topic.c.~1.17.~:566:                                             t->doc_tot);
topic.c.~1.17.~:569:    for (c = 0; c < t->nchild; c++)
topic.c.~1.17.~:571:        dfs_sample_scaling(t->child[c]);
topic.c.~1.17.~:591:    tr->depth   = depth;
topic.c.~1.17.~:592:    tr->eta     = eta;
topic.c.~1.17.~:593:    tr->gam     = gam;
topic.c.~1.17.~:594:    tr->next_id = 0;
topic.c.~1.17.~:595:    tr->scaling_shape = scaling_shape;
topic.c.~1.17.~:596:    tr->scaling_scale = scaling_scale;
topic.c.~1.17.~:598:    tr->root = topic_new(nwords, 0, NULL, tr);
topic.c.~1.17.~:613:    fprintf(file, "%-6d", root_topic->id);
topic.c.~1.17.~:615:    if (root_topic->parent != NULL)
topic.c.~1.17.~:616:        fprintf(file, " %-6d", root_topic->parent->id);
topic.c.~1.17.~:618:        fprintf(file, " %-6d", -1);
topic.c.~1.17.~:620:    fprintf(file, " %06.0f", root_topic->doc_tot);
topic.c.~1.17.~:621:    fprintf(file, " %06.0f", root_topic->w_tot);
topic.c.~1.17.~:622:    fprintf(file, " %06.3e", root_topic->scaling);
topic.c.~1.17.~:624:    for (i = 0; i < root_topic->w_cnt->size; i++)
topic.c.~1.17.~:626:        fprintf(file, " %6.0f", vget(root_topic->w_cnt, i));
topic.c.~1.17.~:630:    for (i = 0; i < root_topic->nchild; i++)
topic.c.~1.17.~:632:        write_tree_topics_dfs(root_topic->child[i], file);
topic.c.~1.17.~:643:    return(ntopics_in_tree_dfs(tr->root));
topic.c.~1.17.~:650:    for (c = 0; c < t->nchild; c++)
topic.c.~1.17.~:652:        topics_below += ntopics_in_tree_dfs(t->child[c]);
topic.c.~1.17.~:654:    return(t->nchild + topics_below);
topic.c.~1.17.~:665:    free_tree_dfs(tr->root);
topic.c.~1.17.~:671:    gsl_vector_free(t->w_cnt);
topic.c.~1.17.~:672:    gsl_vector_free(t->log_prob_w);
topic.c.~1.17.~:673:    gsl_vector_free(t->lgam_w_plus_eta);
topic.c.~1.17.~:675:    for (c = 0; c < t->nchild; c++)
topic.c.~1.17.~:676:        free_tree_dfs(t->child[c]);
topic.c.~1.17.~:687:    tree* tree_copy = tree_new(tr->depth,
topic.c.~1.17.~:688:                               tr->root->w_cnt->size,
topic.c.~1.17.~:689:                               tr->eta,
topic.c.~1.17.~:690:                               tr->gam,
topic.c.~1.17.~:691:                               tr->scaling_shape,
topic.c.~1.17.~:692:                               tr->scaling_scale);
topic.c.~1.17.~:694:    copy_tree_dfs(tr->root, tree_copy->root);
topic.c.~1.17.~:704:    for (c = 0; c < src->nchild; c++)
topic.c.~1.17.~:707:        child->parent = dest;
topic.c.~1.17.~:708:        copy_tree_dfs(src->child[c], child);
topic.c.~1.17.~:714:    dest->w_tot = src->w_tot;
topic.c.~1.17.~:715:    gsl_vector_memcpy(dest->w_cnt, src->w_cnt);
topic.c.~1.17.~:716:    gsl_vector_memcpy(dest->log_prob_w, src->log_prob_w);
topic.c.~1.17.~:717:    gsl_vector_memcpy(dest->lgam_w_plus_eta, src->lgam_w_plus_eta);
topic.c.~1.17.~:718:    dest->doc_tot = src->doc_tot;
topic.c.~1.17.~:719:    dest->log_doc_tot = src->log_doc_tot;
topic.c.~1.17.~:720:    dest->id = src->id;
topic.c.~1.17.~:721:    dest->level = src->level;
topic.c.~1.17.~:722:    dest->nchild = 0; // children get added separately
topic.c.~1.17.~:723:    dest->scaling = src->scaling;
topic.c.~1.17.~:724:    dest->prob = src->prob;
topic.c.~1.17.~:735:    write_tree_level_dfs(tr->root, file);
topic.c.~1.17.~:745:    if (root_topic->parent == NULL)
topic.c.~1.17.~:747:        fprintf(file, "%d", root_topic->level);
topic.c.~1.17.~:751:        fprintf(file, " %d", root_topic->level);
topic.c.~1.17.~:753:    for (i = 0; i < root_topic->nchild; i++)
topic.c.~1.17.~:755:        write_tree_level_dfs(root_topic->child[i], file);
topic.c.~1.17.~:762:    fprintf(file, "%-6s %-6s %-6s %-6s  %-9s %-6s\n",
topic.c.~1.17.~:764:    write_tree_topics_dfs(tf->root, file);
Binary file topic.o matches
Binary file tree.pyc matches
typedefs.h:18:    double doc_tot;         // total number of doc-level instances
unused-code.C:1:--- to permute the words before resampling them ---
unused-code.C:5:    gsl_permutation* perm = rpermutation(d->word->size);
unused-code.C:6:    int temp1[d->word->size];
unused-code.C:7:    int temp2[d->word->size];
unused-code.C:8:    for (i = 0; i < d->word->size; i++)
unused-code.C:10:        temp1[i] = d->word->val[perm->data[i]];
unused-code.C:11:        temp2[i] = d->levels->val[perm->data[i]];
unused-code.C:13:    for (i = 0; i < d->word->size; i++)
unused-code.C:15:        d->word->val[i] = temp1[i];
unused-code.C:16:        d->levels->val[i] = temp2[i];
unused-code.C:21:--- MH sampling of level gammas ---
unused-code.C:27:    outlog(stderr, "%-10s updating gam", "[TOPIC]");
unused-code.C:28:    gsl_vector* vect = tr->gam;
unused-code.C:29:    int depth = vect->size;
unused-code.C:30:    double current_score = gamma_score(tr->root);
unused-code.C:47:                double new_score = gamma_score(tr->root);
unused-code.C:49:                if (r > exp(new_score - current_score))
unused-code.C:67:-- PY score --
unused-code.C:73:    double gam = vget(t->tr->gam, t->level) + gam_add;
unused-code.C:75:    if (t->nchild > 0)
unused-code.C:77:        score = log(gam) * t->nchild;
unused-code.C:78:        score -= lgam(gam + t->doc_tot);
unused-code.C:79:        for (c = 0; c < t->nchild; c++)
unused-code.C:81:            score += gamma_score_PY(t->child[c], (double) c * t->level * 0.01);
unused-code.C:99:/*     gsl_vector* log_prob = gsl_vector_alloc(d->path[0]->tr->depth); */
unused-code.C:103:/*     for (i = 0; i < d->word->size; i++) */
unused-code.C:105:/*         l = ivget(d->levels, i); */
unused-code.C:106:/*         doc_update_level(d, l, -1.0); */
unused-code.C:107:/*         topic_update_word(d->path[l], ivget(d->word, i), -1.0); */
unused-code.C:110:/*     if (do_permute == 1) iv_permute(d->word); */
unused-code.C:112:/*     for (i = 0; i < d->word->size; i++) */
unused-code.C:114:/*         w = ivget(d->word, i); */
unused-code.C:119:/*                  vget(d->log_p_level, k) + vget(d->path[k]->log_prob_w, w)); */
unused-code.C:125:/*         topic_update_word(d->path[new_l], w, 1.0); */
unused-code.C:126:/*         ivset(d->levels, i, new_l); */
unused-code.C:144:    int depth = tr->depth;
unused-code.C:147:    for (i = 0; i < c->ndoc; i++)
unused-code.C:149:        doc* d = c->doc[i];
unused-code.C:150:        iv_permute(d->word);
unused-code.C:154:            d->path[depth - 1] = tree_fill(tr->root);
unused-code.C:155:            topic_update_doc_cnt(d->path[depth - 1], 1.0);
unused-code.C:156:            for (j = depth - 2; j >= 0; j--)
unused-code.C:158:                d->path[j] = d->path[j+1]->parent;
unused-code.C:159:                topic_update_doc_cnt(d->path[j], 1.0);
unused-code.C:164:            d->path[0] = tr->root;
unused-code.C:169:    for (i = 0; i < c->ndoc; i++)
unused-code.C:171:        doc* d = c->doc[i];
unused-code.C:182:    int depth = tr->depth;
unused-code.C:184:    for (n = 1; n < corp->ndoc; n++)
unused-code.C:186:        doc* d = corp->doc[n];
unused-code.C:187:        d->path[depth - 1] = tree_fill(tr->root);
unused-code.C:188:        topic_update_doc_cnt(d->path[depth - 1], 1.0);
unused-code.C:190:        for (j = depth - 2; j >= 0; j--)
unused-code.C:192:            d->path[j] = d->path[j+1]->parent;
unused-code.C:193:            topic_update_doc_cnt(d->path[j], 1.0);
unused-code.C:205:    int depth = d->path[0]->tr->depth;
unused-code.C:207:    for (i = 0; i < d->word->size; i++)
unused-code.C:209:        int w = ivget(d->word, i);
unused-code.C:212:        int new_l = depth - 1;
unused-code.C:213:        topic_update_word(d->path[new_l], w, 1.0);
unused-code.C:214:        ivset(d->levels, i, new_l);
unused-code.C:225:    for (n = 1; n < corp->ndoc; n++)
unused-code.C:227:        doc* d = corp->doc[n];
unused-code.C:228:        tree_remove_doc_from_path(tr, d, -1);
unused-code.C:231:        for (i = 0; i < d->word->size; i++)
unused-code.C:233:            int l = ivget(d->levels, i);
unused-code.C:234:            ivset(d->levels, i, -1);
unused-code.C:235:            doc_update_level(d, l, -1.0);
unused-code.C:244:    for (n = 1; n < corp->ndoc; n++)
unused-code.C:246:        doc* d = corp->doc[n];
unused-code.C:249:    for (n = 1; n < corp->ndoc; n++)
unused-code.C:251:        tree_sample_doc_path(tr, corp->doc[n], 0, 0);
unused-code.C.~1.4.~:1:--- to permute the words before resampling them ---
unused-code.C.~1.4.~:5:    gsl_permutation* perm = rpermutation(d->word->size);
unused-code.C.~1.4.~:6:    int temp1[d->word->size];
unused-code.C.~1.4.~:7:    int temp2[d->word->size];
unused-code.C.~1.4.~:8:    for (i = 0; i < d->word->size; i++)
unused-code.C.~1.4.~:10:        temp1[i] = d->word->val[perm->data[i]];
unused-code.C.~1.4.~:11:        temp2[i] = d->levels->val[perm->data[i]];
unused-code.C.~1.4.~:13:    for (i = 0; i < d->word->size; i++)
unused-code.C.~1.4.~:15:        d->word->val[i] = temp1[i];
unused-code.C.~1.4.~:16:        d->levels->val[i] = temp2[i];
unused-code.C.~1.4.~:21:--- MH sampling of level gammas ---
unused-code.C.~1.4.~:27:    outlog(stderr, "%-10s updating gam", "[TOPIC]");
unused-code.C.~1.4.~:28:    gsl_vector* vect = tr->gam;
unused-code.C.~1.4.~:29:    int depth = vect->size;
unused-code.C.~1.4.~:30:    double current_score = gamma_score(tr->root);
unused-code.C.~1.4.~:47:                double new_score = gamma_score(tr->root);
unused-code.C.~1.4.~:49:                if (r > exp(new_score - current_score))
unused-code.C.~1.4.~:67:-- PY score --
unused-code.C.~1.4.~:73:    double gam = vget(t->tr->gam, t->level) + gam_add;
unused-code.C.~1.4.~:75:    if (t->nchild > 0)
unused-code.C.~1.4.~:77:        score = log(gam) * t->nchild;
unused-code.C.~1.4.~:78:        score -= lgam(gam + t->doc_tot);
unused-code.C.~1.4.~:79:        for (c = 0; c < t->nchild; c++)
unused-code.C.~1.4.~:81:            score += gamma_score_PY(t->child[c], (double) c * t->level * 0.01);
unused-code.C.~1.4.~:99:/*     gsl_vector* log_prob = gsl_vector_alloc(d->path[0]->tr->depth); */
unused-code.C.~1.4.~:103:/*     for (i = 0; i < d->word->size; i++) */
unused-code.C.~1.4.~:105:/*         l = ivget(d->levels, i); */
unused-code.C.~1.4.~:106:/*         doc_update_level(d, l, -1.0); */
unused-code.C.~1.4.~:107:/*         topic_update_word(d->path[l], ivget(d->word, i), -1.0); */
unused-code.C.~1.4.~:110:/*     if (do_permute == 1) iv_permute(d->word); */
unused-code.C.~1.4.~:112:/*     for (i = 0; i < d->word->size; i++) */
unused-code.C.~1.4.~:114:/*         w = ivget(d->word, i); */
unused-code.C.~1.4.~:119:/*                  vget(d->log_p_level, k) + vget(d->path[k]->log_prob_w, w)); */
unused-code.C.~1.4.~:125:/*         topic_update_word(d->path[new_l], w, 1.0); */
unused-code.C.~1.4.~:126:/*         ivset(d->levels, i, new_l); */
unused-code.C.~1.4.~:144:    int depth = tr->depth;
unused-code.C.~1.4.~:147:    for (i = 0; i < c->ndoc; i++)
unused-code.C.~1.4.~:149:        doc* d = c->doc[i];
unused-code.C.~1.4.~:150:        iv_permute(d->word);
unused-code.C.~1.4.~:154:            d->path[depth - 1] = tree_fill(tr->root);
unused-code.C.~1.4.~:155:            topic_update_doc_cnt(d->path[depth - 1], 1.0);
unused-code.C.~1.4.~:156:            for (j = depth - 2; j >= 0; j--)
unused-code.C.~1.4.~:158:                d->path[j] = d->path[j+1]->parent;
unused-code.C.~1.4.~:159:                topic_update_doc_cnt(d->path[j], 1.0);
unused-code.C.~1.4.~:164:            d->path[0] = tr->root;
unused-code.C.~1.4.~:169:    for (i = 0; i < c->ndoc; i++)
unused-code.C.~1.4.~:171:        doc* d = c->doc[i];
unused-code.C.~1.4.~:182:    int depth = tr->depth;
unused-code.C.~1.4.~:184:    for (n = 1; n < corp->ndoc; n++)
unused-code.C.~1.4.~:186:        doc* d = corp->doc[n];
unused-code.C.~1.4.~:187:        d->path[depth - 1] = tree_fill(tr->root);
unused-code.C.~1.4.~:188:        topic_update_doc_cnt(d->path[depth - 1], 1.0);
unused-code.C.~1.4.~:190:        for (j = depth - 2; j >= 0; j--)
unused-code.C.~1.4.~:192:            d->path[j] = d->path[j+1]->parent;
unused-code.C.~1.4.~:193:            topic_update_doc_cnt(d->path[j], 1.0);
unused-code.C.~1.4.~:205:    int depth = d->path[0]->tr->depth;
unused-code.C.~1.4.~:207:    for (i = 0; i < d->word->size; i++)
unused-code.C.~1.4.~:209:        int w = ivget(d->word, i);
unused-code.C.~1.4.~:212:        int new_l = depth - 1;
unused-code.C.~1.4.~:213:        topic_update_word(d->path[new_l], w, 1.0);
unused-code.C.~1.4.~:214:        ivset(d->levels, i, new_l);
unused-code.C.~1.4.~:225:    for (n = 1; n < corp->ndoc; n++)
unused-code.C.~1.4.~:227:        doc* d = corp->doc[n];
unused-code.C.~1.4.~:228:        tree_remove_doc_from_path(tr, d, -1);
unused-code.C.~1.4.~:231:        for (i = 0; i < d->word->size; i++)
unused-code.C.~1.4.~:233:            int l = ivget(d->levels, i);
unused-code.C.~1.4.~:234:            ivset(d->levels, i, -1);
unused-code.C.~1.4.~:235:            doc_update_level(d, l, -1.0);
utils.c:67:    for (i = 1; i < log_prob->size; i++)
utils.c:74:    double rolling_sum = exp(vget(log_prob, 0) - logsum);
utils.c:79:        rolling_sum += exp(vget(log_prob, result) - logsum);
utils.c:95:    iv->size = size;
utils.c:96:    iv->val = malloc(sizeof(int) * iv->size);
utils.c:98:    for (i = 0; i < iv->size; i++)
utils.c:106:    free(iv->val);
utils.c:118:    iv->size += 1;
utils.c:119:    iv->val = (int*) realloc(iv->val, sizeof(int) * (iv->size));
utils.c:120:    iv->val[iv->size - 1] = val;
utils.c:131:    outlog("reading %ld vector from %s", v->size, filename);
utils.c:146:    ivc->size = iv->size;
utils.c:147:    ivc->val = malloc(sizeof(int) * ivc->size);
utils.c:150:    for (i = 0; i < ivc->size; i++)
utils.c:151:        ivc->val[i] = iv->val[i];
utils.c:165:                    iv->val,
utils.c:166:                    iv->size,
utils.c:172:    assert(iv->size == p->size);
utils.c:175:    for (i = 0; i < p->size; i++)
utils.c:177:        ivset(iv, i, ivget(ivc, p->data[i]));
utils.c:192:                    perm->data, size, sizeof(size_t));
utils.c:227:    // f(x)= - a * log(s) + log_gamma(a) + (a-1) * log(x) - x/s
utils.c:229:    double v = - shape*log(scale)+lgam(shape)+(shape-1)*log(x)-x/scale;
utils.c:256:    for (i = 0; i < v->size; i++)
utils.c:271:    for (i = 0; i < v->size; i++)
utils.c:286:    fprintf(file, "%-10s", name);
utils.c:287:    for (i = 0; i < vect->size; i++)
utils.c:297:    outlog("reading %d-vector %s", size, name);
utils.c:304:    for (i = 0; i < ret->size; i++)
utils.h:34:{ return(v->val[n]); };
utils.h:37:{ v->val[n] = val; };
utils.h:51:      return(log_b+log(1 + exp(log_a-log_b)));
utils.h:53:      return(log_a+log(1 + exp(log_b-log_a)));
Binary file utils.o matches