libjulius/src/outprob_style.c

Go to the documentation of this file.

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

#include <julius/julius.h>

#ifdef PASS1_IWCD

void
outprob_style_cache_init(WCHMM_INFO *wchmm)
{
  int n;
  for(n=0;n<wchmm->n;n++) {
    if (wchmm->state[n].out.state == NULL) continue;
    if (wchmm->outstyle[n] == AS_RSET) {
      (wchmm->state[n].out.rset)->cache.state = NULL;
    } else if (wchmm->outstyle[n] == AS_LRSET) {
      (wchmm->state[n].out.lrset)->cache.state = NULL;
    }
  }
}

/**********************************************************************/

static char lccbuf[MAX_HMMNAME_LEN+7]; 
static char lccbuf2[MAX_HMMNAME_LEN+7]; 

CD_Set *
lcdset_lookup_with_category(WCHMM_INFO *wchmm, HMM_Logical *hmm, WORD_ID category)
{
  CD_Set *cd;

  leftcenter_name(hmm->name, lccbuf);
  sprintf(lccbuf2, "%s::%04d", lccbuf, category);
  if (wchmm->lcdset_category_root != NULL) {
    cd = aptree_search_data(lccbuf2, wchmm->lcdset_category_root);
    if (cd == NULL) return NULL;
    if (strmatch(lccbuf2, cd->name)) {
      return cd;
    }
  }
  return NULL;
}

static void
lcdset_register_with_category(WCHMM_INFO *wchmm, HMM_Logical *hmm, WORD_ID category)
{
  WORD_ID c2, i, w;
  HMM_Logical *ltmp;

  int cnt_c, cnt_w, cnt_p;

  if (lcdset_lookup_with_category(wchmm, hmm, category) == NULL) {
    leftcenter_name(hmm->name, lccbuf);
    sprintf(lccbuf2, "%s::%04d", lccbuf, category);
    if (debug2_flag) {
      jlog("DEBUG: category-aware lcdset {%s}...", lccbuf2);
    }
    cnt_c = cnt_w = cnt_p = 0;
    /* search for category that can connect after this category */
    for(c2=0;c2<wchmm->dfa->term_num;c2++) {
      if (! dfa_cp(wchmm->dfa, category, c2)) continue;
      /* for each word in the category, register triphone whose right context
         is the beginning phones  */
      for(i=0;i<wchmm->dfa->term.wnum[c2];i++) {
        w = wchmm->dfa->term.tw[c2][i];
        ltmp = get_right_context_HMM(hmm, wchmm->winfo->wseq[w][0]->name, wchmm->hmminfo);
        if (ltmp == NULL) {
          ltmp = hmm;
          if (ltmp->is_pseudo) {
            error_missing_right_triphone(hmm, wchmm->winfo->wseq[w][0]->name);
          }
        }
        if (! ltmp->is_pseudo) {
          if (regist_cdset(&(wchmm->lcdset_category_root), ltmp->body.defined, lccbuf2)) {
            cnt_p++;
          }
        }
      }
      cnt_c++;
      cnt_w += wchmm->dfa->term.wnum[c2];
    }
    if (debug2_flag) {
      jlog("%d categories (%d words) can follow, %d HMMs registered\n", cnt_c, cnt_w, cnt_p);
    }
  }
}

void
lcdset_register_with_category_all(WCHMM_INFO *wchmm)
{
  WORD_INFO *winfo;
  WORD_ID c1, w, w_prev;
  int i;
  HMM_Logical *ltmp;

  winfo = wchmm->winfo;

  /* (1) ñ¸ì½ªÃ¼¤Î²»ÁǤˤĤ¤¤Æ */
  /*     word end phone */
  for(w=0;w<winfo->num;w++) {
    ltmp = winfo->wseq[w][winfo->wlen[w]-1];
    lcdset_register_with_category(wchmm, ltmp, winfo->wton[w]);
  }
  /* (2)£±²»ÁÇñ¸ì¤Î¾ì¹ç, Àè¹Ô¤·¤¦¤ëñ¸ì¤Î½ªÃ¼²»ÁǤò¹Íθ */
  /*    for one-phoneme word, possible left context should be also considered */
  for(w=0;w<winfo->num;w++) {
    if (winfo->wlen[w] > 1) continue;
    for(c1=0;c1<wchmm->dfa->term_num;c1++) {
      if (! dfa_cp(wchmm->dfa, c1, winfo->wton[w])) continue;
      for(i=0;i<wchmm->dfa->term.wnum[c1];i++) {
        w_prev = wchmm->dfa->term.tw[c1][i];
        ltmp = get_left_context_HMM(winfo->wseq[w][0], winfo->wseq[w_prev][winfo->wlen[w_prev]-1]->name, wchmm->hmminfo);
        if (ltmp == NULL) continue; /* 1²»ÁǼ«¿È¤Îlcd_set¤Ï(1)¤ÇºîÀ®ºÑ */
        if (ltmp->is_pseudo) continue; /* pseudo phone ¤Ê¤élcd_set¤Ï¤¤¤é¤Ê¤¤ */
        lcdset_register_with_category(wchmm, ltmp, winfo->wton[w]);
      }
    }
  }
}

void
lcdset_remove_with_category_all(WCHMM_INFO *wchmm)
{
  free_cdset(&(wchmm->lcdset_category_root));
}

#endif /* PASS1_IWCD */

LOGPROB
outprob_style(WCHMM_INFO *wchmm, int node, int last_wid, int t, HTK_Param *param)
{
  static char rbuf[MAX_HMMNAME_LEN]; 

#ifndef PASS1_IWCD
  
  /* if cross-word triphone handling is disabled, we simply compute the
     output prob of the state */
  return(outprob_state(wchmm->hmmwrk, t, wchmm->state[node].out, param));
  
#else  /* PASS1_IWCD */

  /* state type and context cache is considered */
  HMM_Logical *ohmm, *rhmm;
  RC_INFO *rset;
  LRC_INFO *lrset;
  CD_Set *lcd;
  WORD_INFO *winfo = wchmm->winfo;
  HTK_HMM_INFO *hmminfo = wchmm->hmminfo;

  /* the actual computation is different according to their context dependency
     handling */
  switch(wchmm->outstyle[node]) {
  case AS_STATE:
    /* normal state (word-internal or context-independent )*/
    /* compute as usual */
    return(outprob_state(wchmm->hmmwrk, t, wchmm->state[node].out.state, param));
  case AS_LSET:
    /* node in word end phone */
    /* compute approximated value using the state set in pseudo phone */
    return(outprob_cd(wchmm->hmmwrk, t, wchmm->state[node].out.lset, param));
  case AS_RSET:
    /* note in the beginning phone of word */
    /* depends on the last word hypothesis to compute the actual triphone */
    rset = wchmm->state[node].out.rset;
    /* consult cache */
    if (rset->cache.state == NULL || rset->lastwid_cache != last_wid) {
      /* cache miss...calculate */
      /* rset contains either defined biphone or pseudo biphone */
      if (last_wid != WORD_INVALID) {
        /* lookup triphone with left-context (= last phoneme) */
        if ((ohmm = get_left_context_HMM(rset->hmm, (winfo->wseq[last_wid][winfo->wlen[last_wid]-1])->name, hmminfo)) != NULL) {
          rhmm = ohmm;
        } else {
          /* if triphone not found, try to use the bi-phone itself */
          rhmm = rset->hmm;
          /* If the bi-phone is explicitly specified in hmmdefs/HMMList,
             use it.  if both triphone and biphone not found in user-given
             hmmdefs/HMMList, use "pseudo" phone, as same as the end of word */
          if (debug2_flag) {
            if (rhmm->is_pseudo) {
            error_missing_left_triphone(rset->hmm, (winfo->wseq[last_wid][winfo->wlen[last_wid]-1])->name);
            }
          }
        }
      } else {
        /* if last word is WORD_INVALID try to use the bi-phone itself */
        rhmm = rset->hmm;
        /* If the bi-phone is explicitly specified in hmmdefs/HMMList,
           use it.  if not, use "pseudo" phone, as same as the end of word */
        if (debug2_flag) {
          if (rhmm->is_pseudo) {
            error_missing_left_triphone(rset->hmm, (winfo->wseq[last_wid][winfo->wlen[last_wid]-1])->name);
          }
        }
      }
      /* rhmm may be a pseudo phone */
      /* store to cache */
      if (rhmm->is_pseudo) {
        rset->last_is_lset  = TRUE;
        rset->cache.lset    = &(rhmm->body.pseudo->stateset[rset->state_loc]);
      } else {
        rset->last_is_lset  = FALSE;
        rset->cache.state   = rhmm->body.defined->s[rset->state_loc];
      }
      rset->lastwid_cache = last_wid;
    }
    /* calculate outprob and return */
    if (rset->last_is_lset) {
      return(outprob_cd(wchmm->hmmwrk, t, rset->cache.lset, param));
    } else {
      return(outprob_state(wchmm->hmmwrk, t, rset->cache.state, param));
    }
  case AS_LRSET:
    /* node in word with only one phoneme --- both beginning and end */
    lrset = wchmm->state[node].out.lrset;
    if (lrset->cache.state == NULL || lrset->lastwid_cache != last_wid) {
      /* cache miss...calculate */
      rhmm = lrset->hmm;
      /* lookup cdset for given left context (= last phoneme) */
      strcpy(rbuf, rhmm->name);
      if (last_wid != WORD_INVALID) {
        add_left_context(rbuf, (winfo->wseq[last_wid][winfo->wlen[last_wid]-1])->name);
      }
      if (wchmm->category_tree) {
#ifdef USE_OLD_IWCD
        lcd = lcdset_lookup_by_hmmname(hmminfo, rbuf);
#else
        /* use category-indexed cdset */
        if (last_wid != WORD_INVALID &&
            (ohmm = get_left_context_HMM(rhmm, (winfo->wseq[last_wid][winfo->wlen[last_wid]-1])->name, hmminfo)) != NULL) {
          lcd = lcdset_lookup_with_category(wchmm, ohmm, lrset->category);
        } else {
          lcd = lcdset_lookup_with_category(wchmm, rhmm, lrset->category);
        }
#endif
      } else {
        lcd = lcdset_lookup_by_hmmname(hmminfo, rbuf);
      }
      if (lcd != NULL) {        /* found, set to cache */
        lrset->last_is_lset  = TRUE;
        lrset->cache.lset    = &(lcd->stateset[lrset->state_loc]);
        lrset->lastwid_cache = last_wid;
      } else {
        /* no relating lcdset found, falling to normal state */
        if (rhmm->is_pseudo) {
          lrset->last_is_lset  = TRUE;
          lrset->cache.lset    = &(rhmm->body.pseudo->stateset[lrset->state_loc]);
          lrset->lastwid_cache = last_wid;
        } else {
          lrset->last_is_lset  = FALSE;
          lrset->cache.state   = rhmm->body.defined->s[lrset->state_loc];
          lrset->lastwid_cache = last_wid;
        }
      }
      /*printf("[%s->%s]\n", lrset->hmm->name, rhmm->name);*/
    }
    /* calculate outprob and return */
    if (lrset->last_is_lset) {
      return(outprob_cd(wchmm->hmmwrk, t, lrset->cache.lset, param));
    } else {
      return(outprob_state(wchmm->hmmwrk, t, lrset->cache.state, param));
    }
  default:
    /* should not happen */
    j_internal_error("outprob_style: no outprob style??\n");
    return(LOG_ZERO);
  }

#endif  /* PASS1_IWCD */

}

void
error_missing_right_triphone(HMM_Logical *base, char *rc_name)
{
  static char rbuf[MAX_HMMNAME_LEN]; 
  /* only output message */
  strcpy(rbuf, base->name);
  add_right_context(rbuf, rc_name);
  jlog("WARNING: IW-triphone for word end \"%s\" not found, fallback to pseudo {%s}\n", rbuf, base->name);
}

void
error_missing_left_triphone(HMM_Logical *base, char *lc_name)
{
  static char rbuf[MAX_HMMNAME_LEN]; 
  /* only output message */
  strcpy(rbuf, base->name);
  add_left_context(rbuf, lc_name);
  jlog("WARNING: IW-triphone for word head \"%s\" not found, fallback to pseudo {%s}\n", rbuf, base->name);
}

/* end of file */

---