libsent/src/anlz/paramselect.c

説明を見る。

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

#include <sent/stddefs.h>
#include <sent/htk_param.h>
#include <sent/htk_hmm.h>


static void
mark_exclude_vector(int loc, int len, int *vmark, int vlen)
{
  int i;
#ifdef DEBUG
  printf("delmark: %d-%d\n",loc, loc+len-1);
#endif
  for (i=0;i<len;i++) {
#ifdef DEBUG
    if (loc + i >= vlen) {
      printf("delmark buffer exceeded!!\n");
      exit(0);
    }
#endif
    vmark[loc+i] = 1;
  }
#ifdef DEBUG
  printf("now :");
  for (i=0;i<vlen;i++) {
    if (vmark[i] == 1) {
      printf("-");
    } else {
      printf("O");
    }
  }
  printf("\n");
#endif
}

static void
exec_exclude_vectors(HTK_Param *p, int *vmark)
{
  int src, dst;
  unsigned int t;

  /* shrink */
  for(t = 0; t < p->samplenum; t++) {
    dst = 0;
    for (src = 0; src < p->veclen; src++) {
      if (vmark[src] == 0) {
        if (dst != src) p->parvec[t][dst] = p->parvec[t][src];
        dst++;
      }
    }
  }
  p->veclen = dst;
#ifdef DEBUG
  printf("new length = %d\n", p->veclen);
#endif
}


int
guess_basenum(HTK_Param *p, short qualtype)
{
  int size;
  int compnum;
  
  compnum = 1 + ((qualtype & F_DELTA) ? 1 : 0) + ((qualtype & F_ACCL) ? 1 : 0);
  
  size = p->veclen;
  if (p->header.samptype & F_ENERGY_SUP) size += 1;
  if ((size % compnum) != 0) {
    jlog("Error: paramselect: illegal vector length (should not happen)\n");
    return -1;
  }
  size /= compnum;
  if (p->header.samptype & F_ENERGY) size -= 1;
  if (p->header.samptype & F_ZEROTH) size -= 1;

  return(size);
}

/* can add: _N */
/* can sub: _E_D_A_0 */

static boolean
select_param_vmark(HTK_Param *src, short dst_type_arg, int *vmark, int vlen, short *new_type)
{
  short dst_type;
  short del_type, add_type;
  int basenum, pb[3],pe[3],p0[3]; /* location */
  int i, len;
  char srcstr[80], dststr[80], buf[80];
  short src_type;

  src_type = src->header.samptype & ~(F_COMPRESS | F_CHECKSUM);
  src_type &= ~(F_BASEMASK);    /* only qualifier code needed */
  srcstr[0] = '\0';
  param_qualcode2str(srcstr, src_type, FALSE);
  dst_type = dst_type_arg & ~(F_COMPRESS | F_CHECKSUM);
  dst_type &= ~(F_BASEMASK);    /* only qualifier code needed */
  dststr[0] = '\0';
  param_qualcode2str(dststr, dst_type, FALSE);

#ifdef DEBUG
  printf("try to select qualifiers: %s -> %s\n", srcstr, dststr);
#endif

  if (dst_type == F_ERR_INVALID) {
    jlog("Error: paramselect: unknown parameter kind for selection: %s\n", dststr);
    return(FALSE);
  }
  
  /* guess base coefficient num */
  basenum = guess_basenum(src, src_type);
  if (basenum < 0) {            /* error */
    return(FALSE);
  }
#ifdef DEBUG
  printf("base num = %d\n", basenum);
#endif

  /* determine which component to use */
  del_type = src_type & (~(dst_type));
  add_type = (~(src_type)) & dst_type;

  /* vector layout for exclusion*/
  pb[0] = 0;
  if ((src_type & F_ENERGY) && (src_type & F_ZEROTH)){
    p0[0] = basenum;
    pe[0] = basenum + 1;
    len = basenum + 2;
  } else if ((src_type & F_ENERGY) || (src_type & F_ZEROTH)){
    p0[0] = pe[0] = basenum;
    len = basenum + 1;
  } else {
    p0[0] = pe[0] = 0;
    len = basenum;
  }
  for (i=1;i<3;i++) {
    pb[i] = pb[i-1] + len;
    pe[i] = pe[i-1] + len;
    p0[i] = p0[i-1] + len;
  }
  if (src_type & F_ENERGY_SUP) {
    pe[0] = 0;
    for (i=1;i<3;i++) {
      pb[i]--;
      pe[i]--;
      p0[i]--;
    }
  }
  
  /* modification begin */
  /* qualifier addition: "_N" */
#ifdef DEBUG
  buf[0] = '\0';
  printf("try to add: %s\n", param_qualcode2str(buf, add_type, FALSE));
#endif
  
  if (add_type & F_ENERGY_SUP) {
    if (src_type & F_ENERGY) {
      mark_exclude_vector(pe[0], 1, vmark, vlen);
      src_type = src_type | F_ENERGY_SUP;
    } else if (src_type & F_ZEROTH) {
      mark_exclude_vector(p0[0], 1, vmark, vlen);
      src_type = src_type | F_ENERGY_SUP;
    } else {
      jlog("Warning: paramselect: \"_N\" needs \"_E\" or \"_0\". ignored\n");
    }
    add_type = add_type & (~(F_ENERGY_SUP)); /* set to 0 */
  }
  if (add_type != 0) {          /* others left */
    buf[0] = '\0';
    jlog("Warning: paramselect: can do only parameter exclusion. qualifiers %s ignored\n", param_qualcode2str(buf, add_type, FALSE));
  }
  
  /* qualifier excludeion: "_D","_A","_0","_E" */
#ifdef DEBUG
  buf[0] = '\0';
  printf("try to del: %s\n", param_qualcode2str(buf, del_type, FALSE));
#endif

  if (del_type & F_DELTA) del_type |= F_ACCL;
  /* mark delete vector */
  if (del_type & F_ACCL) {
    mark_exclude_vector(pb[2], len, vmark, vlen);
    src_type &= ~(F_ACCL);
    del_type &= ~(F_ACCL);
  }
  if (del_type & F_DELTA) {
    mark_exclude_vector(pb[1], len, vmark, vlen);
    src_type &= ~(F_DELTA);
    del_type &= ~(F_DELTA);
  }
  
  if (del_type & F_ENERGY) {
    mark_exclude_vector(pe[2], 1, vmark, vlen);
    mark_exclude_vector(pe[1], 1, vmark, vlen);
    if (!(src_type & F_ENERGY_SUP)) {
      mark_exclude_vector(pe[0], 1, vmark, vlen);
    }
    src_type &= ~(F_ENERGY | F_ENERGY_SUP);
    del_type &= ~(F_ENERGY | F_ENERGY_SUP);
  }
  if (del_type & F_ZEROTH) {
    mark_exclude_vector(p0[2], 1, vmark, vlen);
    mark_exclude_vector(p0[1], 1, vmark, vlen);
    if (!(src_type & F_ENERGY_SUP)) {
      mark_exclude_vector(p0[0], 1, vmark, vlen);
    }
    src_type &= ~(F_ZEROTH | F_ENERGY_SUP);
    del_type &= ~(F_ZEROTH | F_ENERGY_SUP);
  }
  
  if (del_type != 0) {          /* left */
    buf[0] = '\0';
    jlog("Warning: paramselect: cannot exclude qualifiers %s. selection ignored\n", param_qualcode2str(buf, del_type, FALSE));
  }


  *new_type = src_type;

  return(TRUE);
}


static boolean
select_param_kind(HTK_Param *p, short dst_type_arg)
{
  int *vmark;
  int vlen;
  int i;
  short new_type;

  /* prepare work area */
  vmark = (int *)mymalloc(sizeof(int) * p->veclen);
  vlen = p->veclen;
  for (i=0;i<vlen;i++) {
    vmark[i] = 0;
  }

  /* mark to determine operation */
  if (select_param_vmark(p, dst_type_arg, vmark, vlen, &new_type) == FALSE) return(FALSE);
  /* execute deletion (copy needed to new param)*/
  exec_exclude_vectors(p, vmark);
  
  /* copy & set header info */
  p->header.sampsize = p->veclen * sizeof(VECT);
  p->header.samptype = new_type | (p->header.samptype & F_BASEMASK);
  
#ifdef DEBUG
 {
   char pbuf[80];
   printf("new param made: %s\n", param_code2str(pbuf, p->header.samptype, FALSE));
 }
#endif
  
  /* free work area */
  free(vmark);

  return(TRUE);
}

int
param_check_and_adjust(HTK_HMM_INFO *hmminfo, HTK_Param *param, boolean vflag)
{
  char pbuf[80],hbuf[80];
  
  param_code2str(pbuf, (short)(param->header.samptype & ~(F_COMPRESS | F_CHECKSUM)), FALSE);
  param_code2str(hbuf, hmminfo->opt.param_type, FALSE);  
  if (!check_param_basetype(hmminfo, param)) {
    /* error if base type not match */
    jlog("Error: paramselect: incompatible parameter type\n");
    jlog("Error: paramselect:  HMM   trained   by  %s(%d)\n", hbuf, hmminfo->opt.vec_size);
    jlog("Error: paramselect:  input parameter is  %s(%d)\n", pbuf, param->veclen);
    return -1;
  }
  if (!check_param_coherence(hmminfo, param)) {
    /* try to select needed parameter vector */
    if (vflag) jlog("Stat: paramselect: attaching %s\n", pbuf);
    if (select_param_kind(param, hmminfo->opt.param_type) == FALSE) {
      if (vflag) jlog("Error: paramselect: failed to attach to %s\n", hbuf);

      jlog("Error: paramselect: incompatible parameter type\n");
      jlog("Error: paramselect:  HMM   trained   by  %s(%d)\n", hbuf, hmminfo->opt.vec_size);
      jlog("Error: paramselect:  input parameter is  %s(%d)\n", pbuf, param->veclen);
      return -1;
    }
    param_code2str(pbuf, param->header.samptype, FALSE);
    if (vflag) jlog("Stat: paramselect: attached to %s\n", pbuf);
    return(1);
  }
  return(0);
}