outprob.c

Go to the documentation of this file.

/*
 * Copyright (c) 1991-2006 Kawahara Lab., Kyoto University
 * Copyright (c) 2000-2005 Shikano Lab., Nara Institute of Science and Technology
 * Copyright (c) 2005-2006 Julius project team, Nagoya Institute of Technology, Nagoya Institute of Technology
 * All rights reserved
 */

#include <sent/stddefs.h>
#include <sent/speech.h>
#include <sent/htk_hmm.h>
#include <sent/htk_param.h>
#include <sent/hmm.h>
#include <sent/gprune.h>
#include "globalvars.h"


/* cache */
static int statenum;            
static LOGPROB **outprob_cache = NULL; 
static int allocframenum;       
static int allocblock;          
static LOGPROB *last_cache;     
#define LOG_UNDEF (LOG_ZERO - 1) 


boolean
outprob_cache_init()
{
  statenum = OP_hmminfo->totalstatenum;
  outprob_cache = NULL;
  allocframenum = 0;
  allocblock = OUTPROB_CACHE_PERIOD;
  OP_time = -1;
  return TRUE;
}

boolean
outprob_cache_prepare()
{
  int s,t;

  /* clear already allocated area */
  for (t = 0; t < allocframenum; t++) {
    for (s = 0; s < statenum; s++) {
      outprob_cache[t][s] = LOG_UNDEF;
    }
  }
  
  return TRUE;
}

static void
outprob_cache_extend(int reqframe)
{
  int newnum;
  int size;
  int t, s;
  LOGPROB *tmpp;

  /* if enough length are already allocated, return immediately */
  if (reqframe < allocframenum) return;

  /* allocate per certain period */
  newnum = reqframe + 1;
  if (newnum < allocframenum + allocblock) newnum = allocframenum + allocblock;
  size = (newnum - allocframenum) * statenum;
  
  /* allocate */
  if (outprob_cache == NULL) {
    outprob_cache = (LOGPROB **)mymalloc(sizeof(LOGPROB *) * newnum);
  } else {
    outprob_cache = (LOGPROB **)myrealloc(outprob_cache, sizeof(LOGPROB *) * newnum);
  }
  tmpp = (LOGPROB *)mymalloc(sizeof(LOGPROB) * size);
  /* clear the new part */
  for(t = allocframenum; t < newnum; t++) {
    outprob_cache[t] = &(tmpp[(t - allocframenum) * statenum]);
    for (s = 0; s < statenum; s++) {
      outprob_cache[t][s] = LOG_UNDEF;
    }
  }

  /*j_printf("outprob cache: %d->%d\n", allocframenum, newnum);*/
  allocframenum = newnum;
}


LOGPROB
outprob_state(
     int t,                     /* time frame */
     HTK_HMM_State *stateinfo,  /* state info */
     HTK_Param *param)          /* parameter */
{
  LOGPROB outp;
  
  /* set global values for outprob functions to access them */
  OP_state = stateinfo;
  OP_state_id = stateinfo->id;
  OP_param = param;
  if (OP_time != t) {
    OP_last_time = OP_time;
    OP_time = t;
    OP_vec = param->parvec[t];
    OP_veclen = param->veclen;

    outprob_cache_extend(t);    /* extend cache if needed */
    last_cache = outprob_cache[t]; /* reduce 2-d array access */
  }
  
  /* consult cache */
  if ((outp = last_cache[OP_state_id]) == LOG_UNDEF) {
    outp = last_cache[OP_state_id] = calc_outprob_state();
  }
  return(outp);
}

static LOGPROB *maxprobs;       
static int maxn;                

void
outprob_cd_nbest_init(int num)
{
  maxprobs = (LOGPROB *)mymalloc(sizeof(LOGPROB) * num);
  maxn = num;
}
  
static LOGPROB
outprob_cd_nbest(int t, CD_State_Set *lset, HTK_Param *param)
{
  LOGPROB prob;
  int i, k, n;

  n = 0;
  for(i=0;i<lset->num;i++) {
    prob = outprob_state(t, lset->s[i], param);
    /*printf("\t\t%d:%f\n", i, prob);*/
    if (prob <= LOG_ZERO) continue;
    if (n == 0 || prob <= maxprobs[n-1]) {
      if (n == maxn) continue;
      maxprobs[n] = prob;
      n++;
    } else {
      for(k=0; k<n; k++) {
        if (prob > maxprobs[k]) {
          memmove(&(maxprobs[k+1]), &(maxprobs[k]),
                  sizeof(LOGPROB) * (n - k - ( (n == maxn) ? 1 : 0)));
          maxprobs[k] = prob;
          break;
        }
      }
      if (n < maxn) n++;
    }
  }
  prob = 0.0;
  for(i=0;i<n;i++) {
    /*printf("\t\t\t- %d: %f\n", i, maxprobs[i]);*/
    prob += maxprobs[i];
  }
  return(prob/(float)n);
}
  
static LOGPROB
outprob_cd_max(int t, CD_State_Set *lset, HTK_Param *param)
{
  LOGPROB maxprob, prob;
  int i;
  maxprob = LOG_ZERO;
  for(i=0;i<lset->num;i++) {
    prob = outprob_state(t, lset->s[i], param);
    if (maxprob < prob) maxprob = prob;
  }
  return(maxprob);
}

static LOGPROB
outprob_cd_avg(int t, CD_State_Set *lset, HTK_Param *param)
{
  LOGPROB sum, p;
  int i,j;
  sum = 0.0;
  j = 0;
  for(i=0;i<lset->num;i++) {
    p = outprob_state(t, lset->s[i], param);
    if (p > LOG_ZERO) {
      sum += p;
      j++;
    }
  }
  return(sum/(float)j);
}

LOGPROB
outprob_cd(int t, CD_State_Set *lset, HTK_Param *param)
{
  LOGPROB ret;

  /* select computation method */
  switch(OP_hmminfo->cdset_method) {
  case IWCD_AVG:
    ret = outprob_cd_avg(t, lset, param);
    break;
  case IWCD_MAX:
    ret = outprob_cd_max(t, lset, param);
    break;
  case IWCD_NBEST:
    ret = outprob_cd_nbest(t, lset, param);
    break;
  default:
    j_error("unknown cdhmm method!\n");
    ret = 0;
    break;
  }
  return(ret);
}
  

LOGPROB
outprob(int t, HMM_STATE *hmmstate, HTK_Param *param)
{
  if (hmmstate->is_pseudo_state) {
    return(outprob_cd(t, hmmstate->out.cdset, param));
  } else {
    return(outprob_state(t, hmmstate->out.state, param));
  }
}

---