void vector_gautbl_var_floor (vector_gautbl_t *gautbl, float64 floor)
{
int32 g;
for (g = 0; g < gautbl->n_gau; g++)
vector_floor (gautbl->var[g], gautbl->veclen, floor);
}
static int32
senone_mixw_read(senone_t * s, char const *file_name, logmath_t *lmath)
{
char eofchk;
FILE *fp;
int32 byteswap, chksum_present;
uint32 chksum;
float32 *pdf;
int32 i, f, c, p, n_err;
char **argname, **argval;
E_INFO("Reading senone mixture weights: %s\n", file_name);
if ((fp = fopen(file_name, "rb")) == NULL)
E_FATAL_SYSTEM("Failed to open mixture weights file '%s' for reading", file_name);
/* Read header, including argument-value info and 32-bit byteorder magic */
if (bio_readhdr(fp, &argname, &argval, &byteswap) < 0)
E_FATAL("Failed to read header from file '%s'\n", file_name);
/* Parse argument-value list */
chksum_present = 0;
for (i = 0; argname[i]; i++) {
if (strcmp(argname[i], "version") == 0) {
if (strcmp(argval[i], MIXW_PARAM_VERSION) != 0)
E_WARN("Version mismatch(%s): %s, expecting %s\n",
file_name, argval[i], MIXW_PARAM_VERSION);
}
else if (strcmp(argname[i], "chksum0") == 0) {
chksum_present = 1; /* Ignore the associated value */
}
}
bio_hdrarg_free(argname, argval);
argname = argval = NULL;
chksum = 0;
/* Read #senones, #features, #codewords, arraysize */
if ((bio_fread(&(s->n_sen), sizeof(int32), 1, fp, byteswap, &chksum) !=
1)
||
(bio_fread(&(s->n_feat), sizeof(int32), 1, fp, byteswap, &chksum)
!= 1)
|| (bio_fread(&(s->n_cw), sizeof(int32), 1, fp, byteswap, &chksum)
!= 1)
|| (bio_fread(&i, sizeof(int32), 1, fp, byteswap, &chksum) != 1)) {
E_FATAL("bio_fread(%s) (arraysize) failed\n", file_name);
}
if (i != s->n_sen * s->n_feat * s->n_cw) {
E_FATAL
("%s: #float32s(%d) doesn't match dimensions: %d x %d x %d\n",
file_name, i, s->n_sen, s->n_feat, s->n_cw);
}
/*
* Compute #LSB bits to be dropped to represent mixwfloor with 8 bits.
* All PDF values will be truncated (in the LSB positions) by these many bits.
*/
if ((s->mixwfloor <= 0.0) || (s->mixwfloor >= 1.0))
E_FATAL("mixwfloor (%e) not in range (0, 1)\n", s->mixwfloor);
/* Use a fixed shift for compatibility with everything else. */
E_INFO("Truncating senone logs3(pdf) values by %d bits\n", SENSCR_SHIFT);
/*
* Allocate memory for senone PDF data. Organize normally or transposed depending on
* s->n_gauden.
*/
if (s->n_gauden > 1) {
E_INFO("Not transposing mixture weights in memory\n");
s->pdf =
(senprob_t ***) ckd_calloc_3d(s->n_sen, s->n_feat, s->n_cw,
sizeof(senprob_t));
}
else {
E_INFO("Transposing mixture weights in memory\n");
s->pdf =
(senprob_t ***) ckd_calloc_3d(s->n_feat, s->n_cw, s->n_sen,
sizeof(senprob_t));
}
/* Temporary structure to read in floats */
pdf = (float32 *) ckd_calloc(s->n_cw, sizeof(float32));
/* Read senone probs data, normalize, floor, convert to logs3, truncate to 8 bits */
n_err = 0;
for (i = 0; i < s->n_sen; i++) {
for (f = 0; f < s->n_feat; f++) {
if (bio_fread
((void *) pdf, sizeof(float32), s->n_cw, fp, byteswap,
&chksum)
!= s->n_cw) {
E_FATAL("bio_fread(%s) (arraydata) failed\n", file_name);
}
/* Normalize and floor */
if (vector_sum_norm(pdf, s->n_cw) <= 0.0)
n_err++;
vector_floor(pdf, s->n_cw, s->mixwfloor);
vector_sum_norm(pdf, s->n_cw);
/* Convert to logs3, truncate to 8 bits, and store in s->pdf */
for (c = 0; c < s->n_cw; c++) {
p = -(logmath_log(lmath, pdf[c]));
p += (1 << (SENSCR_SHIFT - 1)) - 1; /* Rounding before truncation */
if (s->n_gauden > 1)
s->pdf[i][f][c] =
(p < (255 << SENSCR_SHIFT)) ? (p >> SENSCR_SHIFT) : 255;
else
s->pdf[f][c][i] =
(p < (255 << SENSCR_SHIFT)) ? (p >> SENSCR_SHIFT) : 255;
}
}
}
static int32 senone_mixw_read(logmath_t * logmath, senone_t *s, const char *file_name, float64 mixwfloor)
{
FILE *fp;
char **argname, **argval;
int32 byteswap, chksum_present;
uint32 chksum;
float32 *pdf;
int32 i, j, f, m, c, p, n_sen, n_err, n_cw, nval;
char eofchk;
mixw_t *fw;
E_INFO("Reading senone mixture weights: %s\n", file_name);
if ((fp = fopen(file_name, "rb")) == NULL)
E_FATAL_SYSTEM("fopen(%s,rb) failed\n", file_name);
/* Read header, including argument-value info and 32-bit byteorder magic */
if (bio_readhdr (fp, &argname, &argval, &byteswap) < 0)
E_FATAL("bio_readhdr(%s) failed\n", file_name);
/* Parse argument-value list */
chksum_present = 0;
for (i = 0; argname[i]; i++) {
if (strcmp (argname[i], "version") == 0) {
if (strcmp(argval[i], MIXW_PARAM_VERSION) != 0)
E_WARN("Version mismatch(%s): %s, expecting %s\n",
file_name, argval[i], MIXW_PARAM_VERSION);
} else if (strcmp (argname[i], "chksum0") == 0) {
chksum_present = 1; /* Ignore the associated value */
}
}
bio_hdrarg_free (argname, argval);
argname = argval = NULL;
chksum = 0;
/* Read #senones, #features, #codewords, arraysize */
n_sen = s->n_sen;
if ((bio_fread (&(s->n_sen), sizeof(int32), 1, fp, byteswap, &chksum) != 1) ||
(bio_fread (&(s->n_feat), sizeof(int32), 1, fp, byteswap, &chksum) != 1) ||
(bio_fread (&(n_cw), sizeof(int32), 1, fp, byteswap, &chksum) != 1) ||
(bio_fread (&nval, sizeof(int32), 1, fp, byteswap, &chksum) != 1)) {
E_FATAL("bio_fread(%s) (arraysize) failed\n", file_name);
}
if ((n_sen != 0) && (s->n_sen != n_sen))
E_FATAL("#senones(%d) conflict with mapping file(%d)\n", s->n_sen, n_sen);
if (s->n_sen >= MAX_SENID)
E_FATAL("%s: #senones (%d) exceeds limit (%d)\n", file_name, s->n_sen, MAX_SENID);
if (s->n_feat <= 0)
E_FATAL("Bad #features: %d\n", s->n_feat);
if (n_cw <= 0)
E_FATAL("Bad #mixing-wts/senone: %d\n", n_cw);
/* Allocate sen2mgau map if not yet done so (i.e. no explicit mapping file given */
if (! s->sen2mgau) {
assert ((s->n_mgau == 0) || (s->n_mgau == 1));
s->sen2mgau = (uint32 *) ckd_calloc (s->n_sen, sizeof(int32));
if (s->n_mgau == 1) {
/* Semicontinuous mode; all senones map to single, shared gaussian: 0 */
for (i = 0; i < s->n_sen; i++)
s->sen2mgau[i] = 0;
} else {
/* Fully continuous mode; each senone maps to own parent gaussian */
s->n_mgau = s->n_sen;
for (i = 0; i < s->n_sen; i++)
s->sen2mgau[i] = i;
}
} else
assert (s->n_mgau != 0);
if (s->n_mgau >= MAX_MGAUID)
E_FATAL("%s: #gauden (%d) exceeds limit (%d)\n", file_name, s->n_mgau, MAX_MGAUID);
if (nval != s->n_sen * s->n_feat * n_cw) {
E_FATAL("%s: #float32 values(%d) doesn't match dimensions: %d x %d x %d\n",
file_name, nval, s->n_sen, s->n_feat, n_cw);
}
/*
* Compute #LSB bits to be dropped to represent mixwfloor with 8 bits.
* All PDF values will be truncated (in the LSB positions) by these many bits.
*/
if ((mixwfloor <= 0.0) || (mixwfloor >= 1.0))
E_FATAL("mixwfloor (%e) not in range (0, 1)\n", mixwfloor);
/* Allocate memory for s->mgau2sen and senone PDF data */
build_mgau2sen (s, n_cw);
/* Temporary structure to read in floats */
pdf = (float32 *) ckd_calloc (n_cw, sizeof(float32));
/* Read senone probs data, normalize, floor, convert to logs3, truncate to 8 bits */
n_err = 0;
for (i = 0; i < s->n_sen; i++) {
m = s->sen2mgau[i]; /* Parent mgau */
j = s->mgau2sen_idx[i]; /* Index of senone i within list of senones for mgau m */
fw = s->mgau2sen[m].feat_mixw;
for (f = 0; f < s->n_feat; f++) {
if (bio_fread((void *)pdf, sizeof(float32), n_cw, fp, byteswap, &chksum)
!= n_cw) {
E_FATAL("bio_fread(%s) (arraydata) failed\n", file_name);
}
/* Normalize and floor */
if (vector_sum_norm (pdf, n_cw) == 0.0)
n_err++;
vector_floor (pdf, n_cw, mixwfloor);
vector_sum_norm (pdf, n_cw);
/* Convert to logs3, truncate to 8 bits, and store in s->pdf */
for (c = 0; c < n_cw; c++) {
p = -logmath_log(logmath, pdf[c]);
printf ("%f %d\n", pdf[c], p);
fw[f].prob[j][c] = p;
}
}
}
if (n_err > 0)
E_WARN("Weight normalization failed for %d senones\n", n_err);
ckd_free (pdf);
if (chksum_present)
bio_verify_chksum (fp, byteswap, chksum);
if (fread (&eofchk, 1, 1, fp) == 1)
E_FATAL("More data than expected in %s\n", file_name);
fclose(fp);
E_INFO("Read mixture weights for %d senones: %d features x %d codewords\n",
s->n_sen, s->n_feat, n_cw);
return 0;
}
static int32
read_mixw(s2_semi_mgau_t * s, char const *file_name, double SmoothMin)
{
char **argname, **argval;
char eofchk;
FILE *fp;
int32 byteswap, chksum_present;
uint32 chksum;
float32 *pdf;
int32 i, f, c, n;
int32 n_sen;
int32 n_feat;
int32 n_comp;
int32 n_err;
E_INFO("Reading mixture weights file '%s'\n", file_name);
if ((fp = fopen(file_name, "rb")) == NULL)
E_FATAL("fopen(%s,rb) failed\n", file_name);
/* Read header, including argument-value info and 32-bit byteorder magic */
if (bio_readhdr(fp, &argname, &argval, &byteswap) < 0)
E_FATAL("bio_readhdr(%s) failed\n", file_name);
/* Parse argument-value list */
chksum_present = 0;
for (i = 0; argname[i]; i++) {
if (strcmp(argname[i], "version") == 0) {
if (strcmp(argval[i], MGAU_MIXW_VERSION) != 0)
E_WARN("Version mismatch(%s): %s, expecting %s\n",
file_name, argval[i], MGAU_MIXW_VERSION);
}
else if (strcmp(argname[i], "chksum0") == 0) {
chksum_present = 1; /* Ignore the associated value */
}
}
bio_hdrarg_free(argname, argval);
argname = argval = NULL;
chksum = 0;
/* Read #senones, #features, #codewords, arraysize */
if ((bio_fread(&n_sen, sizeof(int32), 1, fp, byteswap, &chksum) != 1)
|| (bio_fread(&n_feat, sizeof(int32), 1, fp, byteswap, &chksum) !=
1)
|| (bio_fread(&n_comp, sizeof(int32), 1, fp, byteswap, &chksum) !=
1)
|| (bio_fread(&n, sizeof(int32), 1, fp, byteswap, &chksum) != 1)) {
E_FATAL("bio_fread(%s) (arraysize) failed\n", file_name);
}
if (n_feat != s->n_feat)
E_FATAL("#Features streams(%d) != %d\n", n_feat, s->n_feat);
if (n != n_sen * n_feat * n_comp) {
E_FATAL
("%s: #float32s(%d) doesn't match header dimensions: %d x %d x %d\n",
file_name, i, n_sen, n_feat, n_comp);
}
/* n_sen = number of mixture weights per codeword, which is
* fixed at the number of senones since we have only one codebook.
*/
s->n_sen = n_sen;
/* Quantized mixture weight arrays. */
s->mixw = ckd_calloc_3d(s->n_feat, s->n_density, n_sen, sizeof(***s->mixw));
/* Temporary structure to read in floats before conversion to (int32) logs3 */
pdf = (float32 *) ckd_calloc(n_comp, sizeof(float32));
/* Read senone probs data, normalize, floor, convert to logs3, truncate to 8 bits */
n_err = 0;
for (i = 0; i < n_sen; i++) {
for (f = 0; f < n_feat; f++) {
if (bio_fread((void *) pdf, sizeof(float32),
n_comp, fp, byteswap, &chksum) != n_comp) {
E_FATAL("bio_fread(%s) (arraydata) failed\n", file_name);
}
/* Normalize and floor */
if (vector_sum_norm(pdf, n_comp) <= 0.0)
n_err++;
vector_floor(pdf, n_comp, SmoothMin);
vector_sum_norm(pdf, n_comp);
/* Convert to LOG, quantize, and transpose */
for (c = 0; c < n_comp; c++) {
int32 qscr;
qscr = -logmath_log(s->lmath_8b, pdf[c]);
if ((qscr > MAX_NEG_MIXW) || (qscr < 0))
qscr = MAX_NEG_MIXW;
s->mixw[f][c][i] = qscr;
}
}
}
if (n_err > 0)
E_WARN("Weight normalization failed for %d senones\n", n_err);
ckd_free(pdf);
if (chksum_present)
bio_verify_chksum(fp, byteswap, chksum);
if (fread(&eofchk, 1, 1, fp) == 1)
E_FATAL("More data than expected in %s\n", file_name);
fclose(fp);
E_INFO("Read %d x %d x %d mixture weights\n", n_sen, n_feat, n_comp);
return n_sen;
}
static void
exp_norm_floor_mixw(float32 ***out, /* the mixture weight matrix for all shared states */
float32 weight_floor, /* smoothing floor for mixture weights */
int32 **in, /* mixture weights for states in a given CI phone */
uint32 ci_id, /* the CI phone associated with the input weights */
uint32 ci_only, /* Do CI initialization of non-CI mixture weights */
uint32 *cluster_offset, /* mixture weight array offsets */
uint32 *state_of) /* the model state associated with each senone. Used only
* for CI initialization of CD weights. */
{
uint32 cd_n_seno; /* # of context dependent senones */
uint32 s_out_org; /* the first weight id under this CI_ID in the output matrix */
uint32 s_out_next; /* the first weight id of the next ci in the output matrix */
uint32 s_out_ci_begin; /* the first CI weight of this CI_ID in the output matrix */
uint32 s_out_ci_next; /* the next CI weight after the last CI weight for this CI_ID */
uint32 s_in_ci_org; /* the first weight id of the ci weights in the input matrix */
uint32 f; /* a feature stream id */
uint32 s_in; /* a weight id in the input matrix */
uint32 s_out; /* a weight id in the output matrix */
uint32 cw; /* a codeword index */
s_out_org = cluster_offset[ci_id];
s_out_next = cluster_offset[ci_id+1];
if (!ci_only)
cd_n_seno = s_out_next - s_out_org;
else
cd_n_seno = 0;
s_in_ci_org = cd_n_seno;
s_out_ci_begin = ci_id * (S2_N_STATE-1);
s_out_ci_next = s_out_ci_begin + (S2_N_STATE-1);
E_INFO("converting log(weights) to weights\n");
for (f = 0; f < S2_N_FEATURE; f++) {
for (s_out = s_out_ci_begin, s_in = s_in_ci_org;
s_out < s_out_ci_next; s_out++, s_in++) {
printf("%d %d :\n", f, s_in);
for (cw = 0; cw < S2_N_CODEWORD; cw++) {
out[s_out][f][cw] = EXP(in[f][s_in*S2_N_CODEWORD + cw]);
printf("%f %.4e ", out[s_out][f][cw], EXP(in[f][s_in*S2_N_CODEWORD + cw]));
}
printf("\n");
vector_normalize(out[s_out][f], S2_N_CODEWORD);
vector_floor(out[s_out][f], S2_N_CODEWORD, weight_floor);
vector_normalize(out[s_out][f], S2_N_CODEWORD);
}
if (ci_only) {
/* clone the CD mixture weights from the CI ones */
for (s_out = s_out_org; s_out < s_out_next; s_out++) {
/* figure out which CI weights we need */
s_in = s_out_ci_begin + state_of[s_out];
for (cw = 0; cw < S2_N_CODEWORD; cw++) {
out[s_out][f][cw] = out[s_in][f][cw];
}
}
}
else {
for (s_out = s_out_org, s_in = 0;
s_in < cd_n_seno; s_in++, s_out++) {
for (cw = 0; cw < S2_N_CODEWORD; cw++) {
out[s_out][f][cw] = EXP(in[f][s_in * S2_N_CODEWORD + cw]);
}
vector_normalize(out[s_out][f], S2_N_CODEWORD);
vector_floor(out[s_out][f], S2_N_CODEWORD, weight_floor);
vector_normalize(out[s_out][f], S2_N_CODEWORD);
}
}
}
}