static int
normalize()
{
char file_name[MAXPATHLEN+1];
float32 ***mixw_acc = NULL;
float32 ***in_mixw = NULL;
float64 s;
uint32 n_mixw;
uint32 n_stream;
uint32 n_mllr_class;
uint32 n_density;
float32 ***tmat_acc = NULL;
uint32 n_tmat;
uint32 n_state_pm;
uint32 i, j, k;
vector_t ***in_mean = NULL;
vector_t ***wt_mean = NULL;
vector_t ***in_var = NULL;
vector_t ***wt_var = NULL;
vector_t ****in_fullvar = NULL;
vector_t ****wt_fullvar = NULL;
int32 pass2var = FALSE;
int32 var_is_full = FALSE;
float32 ***dnom = NULL;
uint32 n_mgau;
uint32 n_gau_stream;
uint32 n_gau_density;
const uint32 *veclen = NULL;
const char **accum_dir;
const char *oaccum_dir;
const char *in_mixw_fn;
const char *out_mixw_fn;
const char *out_tmat_fn;
const char *in_mean_fn;
const char *out_mean_fn;
const char *in_var_fn;
const char *out_var_fn;
const char *out_dcount_fn;
int err;
uint32 mllr_mult;
uint32 mllr_add;
float32 *****regl = NULL;
float32 ****regr = NULL;
uint32 no_retries=0;
accum_dir = cmd_ln_str_list("-accumdir");
oaccum_dir = cmd_ln_str("-oaccumdir");
out_mixw_fn = cmd_ln_str("-mixwfn");
out_tmat_fn = cmd_ln_str("-tmatfn");
out_mean_fn = cmd_ln_str("-meanfn");
out_var_fn = cmd_ln_str("-varfn");
in_mixw_fn = cmd_ln_str("-inmixwfn");
in_mean_fn = cmd_ln_str("-inmeanfn");
in_var_fn = cmd_ln_str("-invarfn");
out_dcount_fn = cmd_ln_str("-dcountfn");
var_is_full = cmd_ln_int32("-fullvar");
/* must be at least one accum dir */
assert(accum_dir[0] != NULL);
if (out_mixw_fn == NULL) {
E_INFO("No -mixwfn specified, will skip if any\n");
}
if (out_tmat_fn == NULL) {
E_INFO("No -tmatfn specified, will skip if any\n");
}
if (out_mean_fn == NULL) {
E_INFO("No -meanfn specified, will skip if any\n");
}
if (out_var_fn == NULL) {
E_INFO("No -varfn specified, will skip if any\n");
}
if (in_mixw_fn != NULL) {
E_INFO("Selecting unseen mixing weight parameters from %s\n",
in_mixw_fn);
}
if (in_mean_fn != NULL) {
E_INFO("Selecting unseen density mean parameters from %s\n",
in_mean_fn);
if (s3gau_read(in_mean_fn,
&in_mean,
&n_mgau,
&n_gau_stream,
&n_gau_density,
&veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_mean_fn);
}
ckd_free((void *)veclen);
veclen = NULL;
}
if (in_var_fn != NULL) {
E_INFO("Selecting unseen density variance parameters from %s\n",
in_var_fn);
if (var_is_full) {
if (s3gau_read_full(in_var_fn,
&in_fullvar,
&n_mgau,
&n_gau_stream,
&n_gau_density,
&veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_var_fn);
}
}
else {
if (s3gau_read(in_var_fn,
&in_var,
&n_mgau,
&n_gau_stream,
&n_gau_density,
&veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_var_fn);
}
}
ckd_free((void *)veclen);
veclen = NULL;
}
n_stream = 0;
for (i = 0; accum_dir[i]; i++) {
E_INFO("Reading and accumulating counts from %s\n", accum_dir[i]);
if (out_mixw_fn) {
rdacc_mixw(accum_dir[i],
&mixw_acc, &n_mixw, &n_stream, &n_density);
}
if (out_tmat_fn) {
rdacc_tmat(accum_dir[i],
&tmat_acc, &n_tmat, &n_state_pm);
}
if (out_mean_fn || out_var_fn) {
if (var_is_full)
rdacc_den_full(accum_dir[i],
&wt_mean,
&wt_fullvar,
&pass2var,
&dnom,
&n_mgau,
&n_gau_stream,
&n_gau_density,
&veclen);
else
rdacc_den(accum_dir[i],
&wt_mean,
&wt_var,
&pass2var,
&dnom,
&n_mgau,
&n_gau_stream,
&n_gau_density,
&veclen);
if (out_mixw_fn) {
if (n_stream != n_gau_stream) {
E_ERROR("mixw inconsistent w/ densities WRT # "
"streams (%u != %u)\n",
n_stream, n_gau_stream);
}
if (n_density != n_gau_density) {
E_ERROR("mixw inconsistent w/ densities WRT # "
"den/mix (%u != %u)\n",
n_density, n_gau_density);
}
}
else {
n_stream = n_gau_stream;
n_density = n_gau_density;
}
}
}
if (oaccum_dir && mixw_acc) {
/* write the total mixing weight reest. accumulators */
err = 0;
sprintf(file_name, "%s/mixw_counts", oaccum_dir);
if (in_mixw_fn) {
if (s3mixw_read(in_mixw_fn,
&in_mixw,
&i,
&j,
&k) != S3_SUCCESS) {
E_FATAL_SYSTEM("Unable to read %s", in_mixw_fn);
}
if (i != n_mixw) {
E_FATAL("# mixw in input mixw file != # mixw in output mixw file\n");
}
if (j != n_stream) {
E_FATAL("# stream in input mixw file != # stream in output mixw file\n");
}
if (k != n_density) {
E_FATAL("# density in input mixw file != # density in output mixw file\n");
}
for (i = 0; i < n_mixw; i++) {
for (j = 0; j < n_stream; j++) {
for (k = 0, s = 0; k < n_density; k++) {
s += mixw_acc[i][j][k];
}
if ((s == 0) && in_mixw) {
for (k = 0, s = 0; k < n_density; k++) {
mixw_acc[i][j][k] = in_mixw[i][j][k];
}
E_INFO("set mixw %u stream %u to input mixw value\n", i, j);
}
}
}
}
do {
/* Write out the accumulated reestimation sums */
if (s3mixw_write(file_name,
mixw_acc,
n_mixw,
n_stream,
n_density) != S3_SUCCESS) {
if (err == 0) {
E_ERROR("Unable to write %s; Retrying...\n", file_name);
}
++err;
sleep(3);
no_retries++;
if(no_retries>10){
E_FATAL("Failed to get the files after 10 retries(about 30 seconds).\n ");
}
}
} while (err > 1);
}
if (pass2var)
E_INFO("-2passvar yes\n");
if (oaccum_dir && (wt_mean || wt_var || wt_fullvar)) {
/* write the total mixing Gau. den reest. accumulators */
err = 0;
sprintf(file_name, "%s/gauden_counts", oaccum_dir);
do {
int32 rv;
if (var_is_full)
rv = s3gaucnt_write_full(file_name,
wt_mean,
wt_fullvar,
pass2var,
dnom,
n_mgau,
n_gau_stream,
n_gau_density,
veclen);
else
rv = s3gaucnt_write(file_name,
wt_mean,
wt_var,
pass2var,
dnom,
n_mgau,
n_gau_stream,
n_gau_density,
veclen);
if (rv != S3_SUCCESS) {
if (err == 0) {
E_ERROR("Unable to write %s; Retrying...\n", file_name);
}
++err;
sleep(3);
no_retries++;
if(no_retries>10){
E_FATAL("Failed to get the files after 10 retries(about 5 minutes).\n ");
}
}
} while (err > 1);
}
if (oaccum_dir && tmat_acc) {
/* write the total transition matrix reest. accumulators */
err = 0;
sprintf(file_name, "%s/tmat_counts", oaccum_dir);
do {
if (s3tmat_write(file_name,
tmat_acc,
n_tmat,
n_state_pm) != S3_SUCCESS) {
if (err == 0) {
E_ERROR("Unable to write %s; Retrying...\n", file_name);
}
++err;
sleep(3);
no_retries++;
if(no_retries>10){
E_FATAL("Failed to get the files after 10 retries(about 5 minutes).\n ");
}
}
} while (err > 1);
}
if (oaccum_dir && regr && regl) {
/* write the total MLLR regression matrix accumulators */
err = 0;
sprintf(file_name, "%s/regmat_counts", oaccum_dir);
do {
if (s3regmatcnt_write(file_name,
regr,
regl,
n_mllr_class,
n_stream,
veclen,
mllr_mult,
mllr_add) != S3_SUCCESS) {
if (err == 0) {
E_ERROR("Unable to write %s; Retrying...\n", file_name);
}
++err;
sleep(3);
no_retries++;
if(no_retries>10){
E_FATAL("Failed to get the files after 10 retries(about 5 minutes).\n ");
}
}
} while (err > 1);
}
if (wt_mean || wt_var || wt_fullvar) {
if (out_mean_fn) {
E_INFO("Normalizing mean for n_mgau= %u, n_stream= %u, n_density= %u\n",
n_mgau, n_stream, n_density);
gauden_norm_wt_mean(in_mean, wt_mean, dnom,
n_mgau, n_stream, n_density, veclen);
}
else {
if (wt_mean) {
E_INFO("Ignoring means since -meanfn not specified\n");
}
}
if (out_var_fn) {
if (var_is_full) {
if (wt_fullvar) {
E_INFO("Normalizing fullvar\n");
gauden_norm_wt_fullvar(in_fullvar, wt_fullvar, pass2var, dnom,
wt_mean, /* wt_mean now just mean */
n_mgau, n_stream, n_density, veclen,
cmd_ln_boolean("-tiedvar"));
}
}
else {
if (wt_var) {
E_INFO("Normalizing var\n");
gauden_norm_wt_var(in_var, wt_var, pass2var, dnom,
wt_mean, /* wt_mean now just mean */
n_mgau, n_stream, n_density, veclen,
cmd_ln_boolean("-tiedvar"));
}
}
}
else {
if (wt_var || wt_fullvar) {
E_INFO("Ignoring variances since -varfn not specified\n");
}
}
}
else {
E_INFO("No means or variances to normalize\n");
}
/*
* Write the parameters to files
*/
if (out_mixw_fn) {
if (mixw_acc) {
if (s3mixw_write(out_mixw_fn,
mixw_acc,
n_mixw,
n_stream,
n_density) != S3_SUCCESS) {
return S3_ERROR;
}
}
else {
E_WARN("NO mixing weight accumulators seen, but -mixwfn specified.\n");
}
}
else {
if (mixw_acc) {
E_INFO("Mixing weight accumulators seen, but -mixwfn NOT specified.\n");
}
}
if (out_tmat_fn) {
if (tmat_acc) {
if (s3tmat_write(out_tmat_fn,
tmat_acc,
n_tmat,
n_state_pm) != S3_SUCCESS) {
return S3_ERROR;
}
}
else {
E_WARN("NO transition matrix accumulators seen, but -tmatfn specified.\n");
}
}
else {
if (tmat_acc)
E_INFO("Transition matrix accumulators seen, but -tmatfn NOT specified\n");
}
if (out_mean_fn) {
if (wt_mean) {
if (s3gau_write(out_mean_fn,
(const vector_t ***)wt_mean,
n_mgau,
n_stream,
n_density,
veclen) != S3_SUCCESS)
return S3_ERROR;
if (out_dcount_fn) {
if (s3gaudnom_write(out_dcount_fn,
dnom,
n_mgau,
n_stream,
n_density) != S3_SUCCESS)
return S3_ERROR;
}
}
else
E_WARN("NO reestimated means seen, but -meanfn specified\n");
}
else {
if (wt_mean) {
E_INFO("Reestimated means seen, but -meanfn NOT specified\n");
}
}
if (out_var_fn) {
if (var_is_full) {
if (wt_fullvar) {
if (s3gau_write_full(out_var_fn,
(const vector_t ****)wt_fullvar,
n_mgau,
n_stream,
n_density,
veclen) != S3_SUCCESS)
return S3_ERROR;
}
else
E_WARN("NO reestimated variances seen, but -varfn specified\n");
}
else {
if (wt_var) {
if (s3gau_write(out_var_fn,
(const vector_t ***)wt_var,
n_mgau,
n_stream,
n_density,
veclen) != S3_SUCCESS)
return S3_ERROR;
}
else
E_WARN("NO reestimated variances seen, but -varfn specified\n");
}
}
else {
if (wt_var) {
E_INFO("Reestimated variances seen, but -varfn NOT specified\n");
}
}
if (veclen)
ckd_free((void *)veclen);
return S3_SUCCESS;
}
int main(int argc, char *argv[])
{
const char *out_mllr_fn;
const char **accum_dir;
const char *mean_fn;
const char *var_fn;
const char *cb2mllrfn;
const char *moddeffn;
uint32 cdonly;
uint32 mllr_mult; /* option 0 or 1 */
uint32 mllr_add; /* option 0 or 1 */
float32 varfloor;
vector_t ***mean = NULL; /* baseline mean */
vector_t ***wt_mean = NULL; /* read from bw accum */
float32 ***wt_dcount = NULL; /* read from bw accum */
vector_t ***wt_var = NULL; /* not used */
int32 pass2var; /* not used */
uint32 n_mgau;
uint32 n_stream;
uint32 n_density;
uint32 n_mllr_class;
uint32 n_mgau_rd;
uint32 n_stream_rd;
uint32 n_density_rd;
uint32 *veclen = NULL;
uint32 *veclen_rd = NULL;
float32 ****A = NULL; /* Output mllr: A */
float32 ***B = NULL; /* Output mllr: B */
int32 *cb2mllr = NULL;
/* int32 **mllr2cb = NULL;
int32 *n_mllr2cb = NULL;*/
model_def_t *mdef;
uint32 gau_begin;
uint32 i,s ;
if (initialize(argc, argv) != S3_SUCCESS) {
E_FATAL("errors initializing.\n");
}
out_mllr_fn = cmd_ln_str("-outmllrfn");
accum_dir = cmd_ln_str_list("-accumdir");
mean_fn = cmd_ln_str("-meanfn");
var_fn = cmd_ln_str("-varfn");
cb2mllrfn = cmd_ln_str("-cb2mllrfn");
cdonly = cmd_ln_int32("-cdonly");
moddeffn = cmd_ln_str("-moddeffn");
mllr_mult = cmd_ln_int32("-mllrmult");
mllr_add = cmd_ln_int32("-mllradd");
varfloor = cmd_ln_float32("-varfloor");
assert(accum_dir[0] != NULL); /* must be at least one accum dir */
if (! (out_mllr_fn && accum_dir && mean_fn)) {
E_FATAL("Some of options are missing.\n");
}
if (varfloor < 0.) {
E_FATAL("varfloor is negative (%e)\n",varfloor);
}
if (cb2mllrfn && strcmp(cb2mllrfn,"NO") == 0) {
cb2mllrfn = NULL;
}
if (moddeffn && strcmp(moddeffn,"NO") == 0) {
moddeffn = NULL;
}
/*--------------------------------------------------------------------*/
fprintf(stderr,"\n");
E_INFO("-- 1. Read input mean, (var) and accumulation.\n");
/*--------------------------------------------------------------------*/
/*-------------- Read baseline mean --------------*/
if (s3gau_read(mean_fn,
&mean,
&n_mgau,
&n_stream,
&n_density,
&veclen) != S3_SUCCESS) {
E_FATAL("Couldn't read %s", mean_fn);
}
/*-------- Read accum_dir (accumulation from bw) --------*/
for (i = 0; accum_dir[i]; i++) {
E_INFO("Reading and accumulating counts from %s\n", accum_dir[i]);
if (rdacc_den(accum_dir[i],
&wt_mean,
&wt_var,
&pass2var,
&wt_dcount,
&n_mgau_rd,
&n_stream_rd,
&n_density_rd,
&veclen_rd) != S3_SUCCESS) {
E_FATAL("Error in reading %s\n", accum_dir[i]);
}
}
if (n_mgau != n_mgau_rd) {
E_FATAL("n_mgau mismatch (%u : %u)\n",n_mgau,n_mgau_rd);
}
if (n_stream != n_stream_rd) {
E_FATAL("n_stream mismatch (%u : %u)\n",n_stream,n_stream_rd);
}
if (n_density != n_density_rd) {
E_FATAL("n_density mismatch (%u : %u)\n",n_density,n_density_rd);
}
for (s = 0; s < n_stream; s++) {
if (veclen[s] != veclen_rd[s]) {
E_FATAL("vector length of stream %u (== %u) "
"!= prior length (== %u)\n",
s, veclen_rd[s], veclen[s]);
}
}
ckd_free((void *)veclen_rd);
veclen_rd = NULL;
if (wt_var) { /* We don't use 'wt_var' in this program. */
gauden_free_param(wt_var);
wt_var = NULL;
}
/*--------------------------------------------------------------------*/
fprintf(stderr,"\n");
E_INFO("-- 2. Read cb2mllrfn\n");
/*--------------------------------------------------------------------*/
if (strcmp(cb2mllrfn, ".1cls.") == 0) {
n_mllr_class = 1;
cb2mllr = (int32 *) ckd_calloc(n_mgau, sizeof(int32));
}
else {
if (s3cb2mllr_read(cb2mllrfn,
&cb2mllr,
&n_mgau_rd,
&n_mllr_class) != S3_SUCCESS) {
E_FATAL("Unable to read %s\n",cb2mllrfn);
}
if (n_mgau_rd != n_mgau) {
E_FATAL("cb2mllr maps %u cb, but read %u cb from files\n",
n_mgau_rd, n_mgau);
}
}
E_INFO("n_mllr_class = %d\n", n_mllr_class);
gau_begin = 0;
if (cdonly) {
if (! moddeffn) {
E_FATAL("-moddeffn is not given.\n");
}
else if (model_def_read(&mdef, moddeffn) != S3_SUCCESS) {
E_FATAL("Can not read model definition file %s\n", moddeffn);
}
gau_begin = mdef->n_tied_ci_state;
for (i=0; i<gau_begin; i++) {
cb2mllr[i] = -1; /* skip CI senones */
}
E_INFO("Use CD senones only. (index >= %d)\n",mdef->n_tied_ci_state);
}
/*--------------------------------------------------------------------*/
fprintf(stderr,"\n");
E_INFO("-- 3. Calculate mllr matrices\n");
/*--------------------------------------------------------------------*/
mllr_mat(&A,
&B,
var_fn,
mean,
wt_mean,
wt_dcount,
gau_begin,
cb2mllr,
mllr_mult,
mllr_add,
varfloor,
n_mgau,
n_stream,
n_density,
n_mllr_class,
veclen);
/*--------------------------------------------------------------------*/
fprintf(stderr,"\n");
E_INFO("-- 4. Store mllr matrices (A,B) to %s\n", out_mllr_fn);
fflush(stderr);
/*--------------------------------------------------------------------*/
if(store_reg_mat(out_mllr_fn,
veclen,
n_mllr_class,
n_stream,
A,
B) != S3_SUCCESS) {
E_FATAL("Unable to write %s\n", out_mllr_fn);
}
ckd_free((void *)veclen);
free_mllr_A(A, n_mllr_class, n_stream);
free_mllr_B(B, n_mllr_class, n_stream);
return 0 ;
}
