julius/gmm.c

Go to the documentation of this file.

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

#include <julius.h>

#undef MES

static LOGPROB *gmm_score;      
static int framecount;          


static LOGPROB *OP_calced_score; 
static int *OP_calced_id; 
static int OP_calced_num; 
static int OP_calced_maxnum; 
static int OP_gprune_num; 
static VECT *OP_vec;            
static short OP_veclen;         

static int
gmm_find_insert_point(LOGPROB score, int len)
{
  /* binary search on score */
  int left = 0;
  int right = len - 1;
  int mid;

  while (left < right) {
    mid = (left + right) / 2;
    if (OP_calced_score[mid] > score) {
      left = mid + 1;
    } else {
      right = mid;
    }
  }
  return(left);
}

static int
gmm_cache_push(int id, LOGPROB score, int len)
{
  int insertp;

  if (len == 0) {               /* first one */
    OP_calced_score[0] = score;
    OP_calced_id[0] = id;
    return(1);
  }
  if (OP_calced_score[len-1] >= score) { /* bottom */
    if (len < OP_gprune_num) {          /* append to bottom */
      OP_calced_score[len] = score;
      OP_calced_id[len] = id;
      len++;
    }
    return len;
  }
  if (OP_calced_score[0] < score) {
    insertp = 0;
  } else {
    insertp = gmm_find_insert_point(score, len);
  }
  if (len < OP_gprune_num) {
    memmove(&(OP_calced_score[insertp+1]), &(OP_calced_score[insertp]), sizeof(LOGPROB)*(len - insertp));
    memmove(&(OP_calced_id[insertp+1]), &(OP_calced_id[insertp]), sizeof(int)*(len - insertp));    
  } else if (insertp < len - 1) {
    memmove(&(OP_calced_score[insertp+1]), &(OP_calced_score[insertp]), sizeof(LOGPROB)*(len - insertp - 1));
    memmove(&(OP_calced_id[insertp+1]), &(OP_calced_id[insertp]), sizeof(int)*(len - insertp - 1));
  }
  OP_calced_score[insertp] = score;
  OP_calced_id[insertp] = id;
  if (len < OP_gprune_num) len++;
  return(len);
}

static LOGPROB
gmm_compute_g_base(HTK_HMM_Dens *binfo)
{
  VECT tmp, x;
  VECT *mean;
  VECT *var;
  VECT *vec = OP_vec;
  short veclen = OP_veclen;

  if (binfo == NULL) return(LOG_ZERO);
  mean = binfo->mean;
  var = binfo->var->vec;
  tmp = 0.0;
  for (; veclen > 0; veclen--) {
    x = *(vec++) - *(mean++);
    tmp += x * x * *(var++);
  }
  return((tmp + binfo->gconst) * -0.5);
}

static LOGPROB
gmm_compute_g_safe(HTK_HMM_Dens *binfo, LOGPROB thres)
{
  VECT tmp, x;
  VECT *mean;
  VECT *var;
  VECT *vec = OP_vec;
  short veclen = OP_veclen;
  VECT fthres = thres * (-2.0);

  if (binfo == NULL) return(LOG_ZERO);
  mean = binfo->mean;
  var = binfo->var->vec;
  tmp = binfo->gconst;
  for (; veclen > 0; veclen--) {
    x = *(vec++) - *(mean++);
    tmp += x * x * *(var++);
    if (tmp > fthres)  return LOG_ZERO;
  }
  return(tmp * -0.5);
}

static void
gmm_gprune_safe_init(HTK_HMM_INFO *hmminfo, int prune_num)
{
  /* store the pruning num to local area */
  OP_gprune_num = prune_num;
  /* maximum Gaussian set size = maximum mixture size */
  OP_calced_maxnum = hmminfo->maxmixturenum;
  /* allocate memory for storing list of currently computed Gaussian in a frame */
  OP_calced_score = (LOGPROB *)mymalloc(sizeof(LOGPROB) * OP_gprune_num);
  OP_calced_id = (int *)mymalloc(sizeof(int) * OP_gprune_num);
}

static void
gmm_gprune_safe(HTK_HMM_Dens **g, int gnum)
{
  int i, num = 0;
  LOGPROB score, thres;

  thres = LOG_ZERO;
  for (i = 0; i < gnum; i++) {
    if (num < OP_gprune_num) {
      score = gmm_compute_g_base(g[i]);
    } else {
      score = gmm_compute_g_safe(g[i], thres);
      if (score <= thres) continue;
    }
    num = gmm_cache_push(i, score, num);
    thres = OP_calced_score[num-1];
  }
  OP_calced_num = num;
}


static LOGPROB
gmm_calc_mix(HTK_HMM_State *s)
{
  int i;
  LOGPROB logprob = LOG_ZERO;

  /* compute Gaussian set */
  gmm_gprune_safe(s->b, s->mix_num);
  /* computed Gaussians will be set in:
     score ... OP_calced_score[0..OP_calced_num]
     id    ... OP_calced_id[0..OP_calced_num] */
  
  /* sum */
  for(i=0;i<OP_calced_num;i++) {
    OP_calced_score[i] += s->bweight[OP_calced_id[i]];
  }
  logprob = addlog_array(OP_calced_score, OP_calced_num);
  if (logprob <= LOG_ZERO) return LOG_ZERO;
  return (logprob * INV_LOG_TEN);
}

static LOGPROB
outprob_state_nocache(int t, HTK_HMM_State *stateinfo, HTK_Param *param)
{
  /* set global values for outprob functions to access them */
  OP_vec = param->parvec[t];
  OP_veclen = param->veclen;
  return(gmm_calc_mix(stateinfo));
}


/************************************************************************/
/* global functions */

void
gmm_init(HTK_HMM_INFO *gmm, int gmm_prune_num)
{
  HTK_HMM_Data *d;

  /* check GMM format */
  /* tied-mixture GMM is not supported */
  if (gmm->is_tied_mixture) {
    j_exit("Error: mixture-tying GMM is not supported yet.\n");
  }
  /* assume 3 state GMM (only one output state) */
  for(d=gmm->start;d;d=d->next) {
    if (d->state_num > 3) {
      j_exit("Error: GMM has more than 1 output state! [%s]\n", d->name);
    }
  }

  /* check if CMN needed */
  
  /* allocate score buffer */
  gmm_score = (LOGPROB *)mymalloc(sizeof(LOGPROB) * gmm->totalhmmnum);

  /* initialize work area */
  gmm_gprune_safe_init(gmm, gmm_prune_num);

  /* check if variances are inversed */
  if (!gmm->variance_inversed) {
    /* here, inverse all variance values for faster computation */
    htk_hmm_inverse_variances(gmm);
    gmm->variance_inversed = TRUE;
  }

}

void
gmm_prepare(HTK_HMM_INFO *gmm)
{
  HTK_HMM_Data *d;
  int i;

  /* initialize score buffer and frame count */
  i = 0;
  for(d=gmm->start;d;d=d->next) {
    gmm_score[i] = 0.0;
    i++;
  }
  framecount = 0;
}

void
gmm_proceed(HTK_HMM_INFO *gmm, HTK_Param *param, int t)
{
  HTK_HMM_Data *d;
  int i;

  framecount++;
  i = 0;
  for(d=gmm->start;d;d=d->next) {
    gmm_score[i] += outprob_state_nocache(t, d->s[1], param);
#ifdef MES
    printf("[%d:total=%f avg=%f]\n", i, gmm_score[i], gmm_score[i] / (float)framecount);
#endif
    i++;
  }
}

static HTK_HMM_Data *max_d;     
#ifdef CONFIDENCE_MEASURE
static LOGPROB gmm_max_cm;      
#endif
static HTK_HMM_INFO *gmm_local; 

void
gmm_end(HTK_HMM_INFO *gmm)
{
  HTK_HMM_Data *d;
  LOGPROB maxprob, sum;
  int i;

  /* get max score */
  i = 0;
  maxprob = LOG_ZERO;
  for(d=gmm->start;d;d=d->next) {
    if (maxprob < gmm_score[i]) {
      max_d = d;
      maxprob = gmm_score[i];
    }
    i++;
  }
#ifdef CONFIDENCE_MEASURE
  /* compute CM */
  sum = 0.0;
  i = 0;
  for(d=gmm->start;d;d=d->next) {
    sum += pow(10, cm_alpha * (gmm_score[i] - maxprob));
    i++;
  }
  gmm_max_cm = 1.0 / sum;
#endif
  
  /* output result */
  gmm_local = gmm;
  result_gmm();
}

boolean
gmm_valid_input()
{
  if (max_d == NULL) return FALSE;
  if (strstr(gmm_reject_cmn_string, max_d->name)) {
    return FALSE;
  }
  return TRUE;
}

/*********************************************************************/
/********************* RESULT OUTPUT FOR GMM *************************/
/*********************************************************************/
void
ttyout_gmm(){
  HTK_HMM_Data *d;
  int i;

  if (debug2_flag) {
    j_printf("--- GMM result begin ---\n");
    i = 0;
    for(d=gmm_local->start;d;d=d->next) {
      j_printf("  [%8s: total=%f avg=%f]\n", d->name, gmm_score[i], gmm_score[i] / (float)framecount);
      i++;
    }
    j_printf("  max = \"%s\"", max_d->name);
#ifdef CONFIDENCE_MEASURE
    j_printf(" (CM: %f)", gmm_max_cm);
#endif
    j_printf("\n");
    j_printf("--- GMM result end ---\n");
  } else if (verbose_flag) {
    j_printf("GMM: max = \"%s\"", max_d->name);
#ifdef CONFIDENCE_MEASURE
    j_printf(" (CM: %f)", gmm_max_cm);
#endif
    j_printf("\n");
  } else {
    j_printf("[GMM: %s]\n", max_d->name);
  }
}

void
msock_gmm()
{
  module_send(module_sd, "<GMM RESULT=\"%s\"", max_d->name);
#ifdef CONFIDENCE_MEASURE
  module_send(module_sd, " CMSCORE=\"%f\"", gmm_max_cm);
#endif
  module_send(module_sd, "/>\n.\n");
}

---