int
rd_gau(const char *fn, uint32 n_o)
{
if (s3gau_read(fn,
&igau,
&n_cb_i,
&n_stream,
&n_density,
&veclen) != S3_SUCCESS)
return S3_ERROR;
n_cb_o = n_o;
ogau = (vector_t ***)gauden_alloc_param(n_cb_o,
n_stream,
n_density,
veclen);
return S3_SUCCESS;
}
int
main(int argc, char *argv[])
{
vector_t ***mean;
vector_t ***var = NULL;
vector_t ****fullvar = NULL;
vector_t ***new_mean;
vector_t ***new_var = NULL;
vector_t ****new_fullvar = NULL;
float32 ***dnom;
float32 ***mixw;
float32 ***new_mixw;
uint32 n_mixw;
uint32 n_mgau;
uint32 n_dnom;
uint32 n_feat;
uint32 n_density;
uint32 n_inc;
uint32 *veclen;
int32 var_is_full;
parse_cmd_ln(argc, argv);
E_INFO("Reading mixing weight file %s.\n",
cmd_ln_str("-inmixwfn"));
if (s3mixw_read(cmd_ln_str("-inmixwfn"),
&mixw,
&n_mixw,
&n_feat,
&n_density) != S3_SUCCESS) {
return 1;
}
n_inc = cmd_ln_int32("-ninc");
if (n_inc > n_density) {
E_WARN("# of densities to split (== %u) > total # of densities/mixture (== %u); # split <- %u # den/mix\n",
n_inc, n_density, n_density);
n_inc = n_density;
}
if (s3gau_read(cmd_ln_str("-inmeanfn"),
&mean,
&n_mgau,
&n_feat,
&n_density,
&veclen) != S3_SUCCESS) {
return 1;
}
var_is_full = cmd_ln_int32("-fullvar");
if (var_is_full) {
if (s3gau_read_full(cmd_ln_str("-invarfn"),
&fullvar,
&n_mgau,
&n_feat,
&n_density,
&veclen) != S3_SUCCESS) {
return 1;
}
}
else {
if (s3gau_read(cmd_ln_str("-invarfn"),
&var,
&n_mgau,
&n_feat,
&n_density,
&veclen) != S3_SUCCESS) {
return 1;
}
}
if (s3gaudnom_read(cmd_ln_str("-dcountfn"),
&dnom,
&n_dnom,
&n_feat,
&n_density) != S3_SUCCESS) {
return 1;
}
new_mean = gauden_alloc_param(n_mgau, n_feat, n_density+n_inc, veclen);
if (var_is_full)
new_fullvar = gauden_alloc_param_full(n_mgau, n_feat, n_density+n_inc, veclen);
else
new_var = gauden_alloc_param(n_mgau, n_feat, n_density+n_inc, veclen);
new_mixw = (float32 ***)ckd_calloc_3d(n_mixw, n_feat, n_density+n_inc,
sizeof(float32));
E_INFO("output n_density == %u\n", n_density+n_inc);
inc_densities(new_mixw,
new_mean,
new_var,
new_fullvar,
mixw,
mean,
var,
fullvar,
dnom,
n_mixw,
n_mgau,
n_dnom,
n_feat,
n_density,
veclen,
n_inc);
if (cmd_ln_str("-outmixwfn") != NULL) {
if (s3mixw_write(cmd_ln_str("-outmixwfn"),
new_mixw,
n_mixw,
n_feat,
n_density+n_inc) != S3_SUCCESS) {
return 1;
}
}
else {
E_FATAL("You must use the -outmixwfn argument\n");
}
if (cmd_ln_str("-outmeanfn") != NULL) {
if (s3gau_write(cmd_ln_str("-outmeanfn"),
(const vector_t ***)new_mean,
n_mgau,
n_feat,
n_density+n_inc,
veclen) != S3_SUCCESS) {
return 1;
}
}
else {
E_FATAL("You must use the -outmeanfn argument\n");
}
if (cmd_ln_str("-outvarfn") != NULL) {
if (var_is_full) {
if (s3gau_write_full(cmd_ln_str("-outvarfn"),
(const vector_t ****)new_fullvar,
n_mgau,
n_feat,
n_density+n_inc,
veclen) != S3_SUCCESS) {
return 1;
}
}
else {
if (s3gau_write(cmd_ln_str("-outvarfn"),
(const vector_t ***)new_var,
n_mgau,
n_feat,
n_density+n_inc,
veclen) != S3_SUCCESS) {
return 1;
}
}
}
else {
E_FATAL("You must use the -outvarfn argument\n");
}
return 0;
}
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;
}
/* the following function is used for MMIE training
lqin 2010-03 */
static int
mmi_normalize()
{
uint32 i;
uint32 n_mgau;
uint32 n_stream;
uint32 n_density;
vector_t ***in_mean = NULL;
vector_t ***in_var = NULL;
vector_t ***wt_mean = NULL;
vector_t ***wt_var = NULL;
const uint32 *veclen = NULL;
const char **accum_dir;
const char *in_mean_fn;
const char *out_mean_fn;
const char *in_var_fn;
const char *out_var_fn;
vector_t ***wt_num_mean = NULL;
vector_t ***wt_den_mean = NULL;
vector_t ***wt_num_var = NULL;
vector_t ***wt_den_var = NULL;
float32 ***num_dnom = NULL;
float32 ***den_dnom = NULL;
uint32 n_num_mgau;
uint32 n_den_mgau;
uint32 n_num_stream;
uint32 n_den_stream;
uint32 n_num_density;
uint32 n_den_density;
float32 constE;
uint32 n_temp_mgau;
uint32 n_temp_stream;
uint32 n_temp_density;
const uint32 *temp_veclen = NULL;
accum_dir = cmd_ln_str_list("-accumdir");
/* the following variables are used for mmie training */
out_mean_fn = cmd_ln_str("-meanfn");
out_var_fn = cmd_ln_str("-varfn");
in_mean_fn = cmd_ln_str("-inmeanfn");
in_var_fn = cmd_ln_str("-invarfn");
constE = cmd_ln_float32("-constE");
/* get rid of some unnecessary parameters */
if (cmd_ln_int32("-fullvar")) {
E_FATAL("Current MMIE training can not be done for full variance, set -fulllvar as no\n");
}
if (cmd_ln_int32("-tiedvar")) {
E_FATAL("Current MMIE training can not be done for tied variance, set -tiedvar as no\n");
}
if (cmd_ln_str("-mixwfn")) {
E_FATAL("Current MMIE training does not support mixture weight update, remove -mixwfn \n");
}
if (cmd_ln_str("-inmixwfn")) {
E_FATAL("Current MMIE training does not support mixture weight update, remove -inmixwfn \n");
}
if (cmd_ln_str("-tmatfn")) {
E_FATAL("Current MMIE training does not support transition matrix update, remove -tmatfn \n");
}
if (cmd_ln_str("-regmatfn")) {
E_FATAL("Using norm for computing regression matrix is obsolete, please use mllr_transform \n");
}
/* must be at least one accum dir */
if (accum_dir[0] == NULL) {
E_FATAL("No accumulated reestimation path is specified, use -accumdir \n");
}
/* at least update mean or variance parameters */
if (out_mean_fn == NULL && out_var_fn == NULL) {
E_FATAL("Neither -meanfn nor -varfn is specified, at least do mean or variance update \n");
}
else if (out_mean_fn == NULL) {
E_INFO("No -meanfn specified, will skip if any\n");
}
else if (out_var_fn == NULL) {
E_INFO("No -varfn specified, will skip if any\n");
}
/* read input mean */
if (in_mean_fn != NULL) {
E_INFO("read original density mean parameters from %s\n", in_mean_fn);
if (s3gau_read(in_mean_fn,
&in_mean,
&n_mgau,
&n_stream,
&n_density,
&veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_mean_fn);
}
ckd_free((void *)veclen);
veclen = NULL;
}
/* read input variance */
if (in_var_fn != NULL) {
E_INFO("read original density variance parameters from %s\n", in_var_fn);
if (s3gau_read(in_var_fn,
&in_var,
&n_mgau,
&n_stream,
&n_density,
&veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_var_fn);
}
ckd_free((void *)veclen);
veclen = NULL;
}
/* read accumulated numerator and denominator counts */
for (i = 0; accum_dir[i]; i++) {
E_INFO("Reading and accumulating counts from %s\n", accum_dir[i]);
rdacc_mmie_den(accum_dir[i],
"numlat",
&wt_num_mean,
&wt_num_var,
&num_dnom,
&n_num_mgau,
&n_num_stream,
&n_num_density,
&veclen);
rdacc_mmie_den(accum_dir[i],
"denlat",
&wt_den_mean,
&wt_den_var,
&den_dnom,
&n_den_mgau,
&n_den_stream,
&n_den_density,
&veclen);
if (n_num_mgau != n_den_mgau)
E_FATAL("number of gaussians inconsistent between num and den lattice\n");
else if (n_num_mgau != n_mgau)
E_FATAL("number of gaussians inconsistent between imput model and accumulator (%u != %u)\n", n_mgau, n_num_mgau);
if (n_num_stream != n_den_stream)
E_FATAL("number of gaussian streams inconsistent between num and den lattice\n");
else if (n_num_stream != n_stream)
E_FATAL("number of gaussian streams inconsistent between imput model and accumulator (%u != %u)\n", n_stream, n_num_stream);
if (n_num_density != n_den_density)
E_FATAL("number of gaussian densities inconsistent between num and den lattice\n");
else if (n_num_density != n_density)
E_FATAL("number of gaussian densities inconsistent between imput model and accumulator (%u != %u)\n", n_density, n_num_density);
}
/* initialize update parameters as the input parameters */
if (out_mean_fn) {
if (s3gau_read(in_mean_fn,
&wt_mean,
&n_temp_mgau,
&n_temp_stream,
&n_temp_density,
&temp_veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_mean_fn);
}
ckd_free((void *)temp_veclen);
temp_veclen = NULL;
}
if (out_var_fn) {
if (s3gau_read(in_var_fn,
&wt_var,
&n_temp_mgau,
&n_temp_stream,
&n_temp_density,
&temp_veclen) != S3_SUCCESS) {
E_FATAL_SYSTEM("Couldn't read %s", in_var_fn);
}
ckd_free((void *)temp_veclen);
temp_veclen = NULL;
}
/* update mean parameters */
if (wt_mean) {
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_mmie_mean(in_mean, wt_mean, wt_num_mean, wt_den_mean,
in_var, wt_num_var, wt_den_var, num_dnom, den_dnom,
n_mgau, n_stream, n_density, veclen, constE);
}
else {
E_INFO("Ignoring means since -meanfn not specified\n");
}
}
else {
E_INFO("No means to normalize\n");
}
/* update variance parameters */
if (wt_var) {
if (out_var_fn) {
E_INFO("Normalizing variance for n_mgau= %u, n_stream= %u, n_density= %u\n",
n_mgau, n_stream, n_density);
gauden_norm_wt_mmie_var(in_var, wt_var, wt_num_var, wt_den_var, num_dnom, den_dnom,
in_mean, wt_mean, wt_num_mean, wt_den_mean,
n_mgau, n_stream, n_density, veclen, constE);
}
else {
E_INFO("Ignoring variances since -varfn not specified\n");
}
}
else {
E_INFO("No variances to normalize\n");
}
/* write the updated mean parameters to files */
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;
}
}
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");
}
}
/* write the updated variance parameters to files */
if (out_var_fn) {
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);
if (temp_veclen)
ckd_free((void *)temp_veclen);
return S3_SUCCESS;
}
static int
init_mixw()
{
model_def_t *src_mdef;
float32 ***src_mixw;
vector_t ***src_mean;
vector_t ***src_var = NULL;
vector_t ****src_fullvar = NULL;
float32 ***src_tmat;
model_def_t *dest_mdef;
float32 ***dest_mixw;
vector_t ***dest_mean;
vector_t ***dest_var = NULL;
vector_t ****dest_fullvar = NULL;
float32 ***dest_tmat;
uint32 n_mixw_src;
uint32 n_mixw_dest;
uint32 n_feat;
uint32 tmp_n_feat;
uint32 n_gau;
uint32 tmp_n_gau;
uint32 n_cb_src;
uint32 n_cb_dest;
uint32 n_state_pm;
uint32 n_tmat_src;
uint32 n_tmat_dest;
uint32 *veclen;
uint32 *tmp_veclen;
uint32 m;
uint32 dest_m;
uint32 dest_m_base;
uint32 src_m;
acmod_id_t src_m_base;
const char *dest_m_name;
const char *dest_m_base_name;
uint32 i;
uint32 n_ts;
uint32 n_cb;
const char *ts2cbfn;
E_INFO("Reading src %s\n", cmd_ln_str("-src_moddeffn"));
/* read in the source model definition file */
if (model_def_read(&src_mdef,
cmd_ln_str("-src_moddeffn")) != S3_SUCCESS) {
return S3_ERROR;
}
ts2cbfn = cmd_ln_str("-src_ts2cbfn");
if (strcmp(SEMI_LABEL, ts2cbfn) == 0) {
E_INFO("Generating semi-continous ts2cb mapping\n");
src_mdef->cb = semi_ts2cb(src_mdef->n_tied_state);
n_ts = src_mdef->n_tied_state;
n_cb = 1;
}
else if (strcmp(CONT_LABEL, ts2cbfn) == 0) {
E_INFO("Generating continous ts2cb mapping\n");
src_mdef->cb = cont_ts2cb(src_mdef->n_tied_state);
n_ts = src_mdef->n_tied_state;
n_cb = src_mdef->n_tied_state;
}
else if (strcmp(PTM_LABEL, ts2cbfn) == 0) {
E_INFO("Generating phonetically tied ts2cb mapping\n");
src_mdef->cb = ptm_ts2cb(src_mdef);
n_ts = src_mdef->n_tied_state;
n_cb = src_mdef->acmod_set->n_ci;
}
else {
E_INFO("Reading src %s\n", cmd_ln_str("-src_ts2cbfn"));
if (s3ts2cb_read(ts2cbfn,
&src_mdef->cb,
&n_ts,
&n_cb) != S3_SUCCESS) {
return S3_ERROR;
}
}
E_INFO("Reading src %s\n", cmd_ln_str("-src_mixwfn"));
/* read in the source mixing weight parameter file */
if (s3mixw_read(cmd_ln_str("-src_mixwfn"),
&src_mixw, &n_mixw_src, &n_feat, &n_gau) != S3_SUCCESS) {
return S3_ERROR;
}
E_INFO("Reading src %s\n",
cmd_ln_str("-src_tmatfn"));
if (s3tmat_read(cmd_ln_str("-src_tmatfn"),
&src_tmat,
&n_tmat_src,
&n_state_pm) != S3_SUCCESS) {
return S3_ERROR;
}
E_INFO("Reading src %s\n", cmd_ln_str("-src_meanfn"));
if (s3gau_read(cmd_ln_str("-src_meanfn"),
&src_mean,
&n_cb_src,
&tmp_n_feat,
&tmp_n_gau,
&veclen) != S3_SUCCESS) {
return S3_ERROR;
}
if (tmp_n_feat != n_feat) {
E_FATAL("src mean n_feat (== %u) != prior value (== %u)\n",
tmp_n_feat, n_feat);
}
if (tmp_n_gau != n_gau) {
E_FATAL("src mean n_gau (== %u) != prior value (== %u)\n",
tmp_n_gau, n_gau);
}
if (n_cb_src != n_cb) {
E_FATAL("src mean n_cb (== %u) is inconsistent with ts2cb mapping %u. Most probably phoneset has duplicated phones\n",
n_cb_src, n_cb);
}
E_INFO("Reading src %s\n", cmd_ln_str("-src_varfn"));
if (cmd_ln_int32("-fullvar")) {
if (s3gau_read_full(cmd_ln_str("-src_varfn"),
&src_fullvar,
&n_cb_src,
&tmp_n_feat,
&tmp_n_gau,
&tmp_veclen) != S3_SUCCESS) {
return S3_ERROR;
}
}
else {
if (s3gau_read(cmd_ln_str("-src_varfn"),
&src_var,
&n_cb_src,
&tmp_n_feat,
&tmp_n_gau,
&tmp_veclen) != S3_SUCCESS) {
return S3_ERROR;
}
}
if (tmp_n_feat != n_feat) {
E_FATAL("src var n_feat (== %u) != prior value (== %u)\n",
tmp_n_feat, n_feat);
}
if (tmp_n_gau != n_gau) {
E_FATAL("src var n_gau (== %u) != prior value (== %u)\n",
tmp_n_gau, n_gau);
}
if (n_cb_src != n_cb) {
E_FATAL("src var n_cb (== %u) inconsistent w/ ts2cb mapping %u\n",
n_cb_src, n_cb);
}
if (n_mixw_src < src_mdef->n_tied_state) {
E_FATAL("Too few source mixing weights, %u, for the # of tied states, %u\n",
n_mixw_src, src_mdef->n_tied_state);
}
for (i = 0; i < n_feat; i++) {
if (veclen[i] != tmp_veclen[i]) {
E_FATAL("src var veclen[%u] (== %u) != prior value (== %u)\n",
i, tmp_veclen[i], veclen[i]);
}
}
ckd_free(tmp_veclen);
E_INFO("Reading dest %s\n",
cmd_ln_str("-dest_moddeffn"));
/* read in the destination model definition file */
if (model_def_read(&dest_mdef,
cmd_ln_str("-dest_moddeffn")) < S3_SUCCESS) {
return S3_ERROR;
}
ts2cbfn = cmd_ln_str("-dest_ts2cbfn");
if (strcmp(SEMI_LABEL, ts2cbfn) == 0) {
E_INFO("Generating semi-continous ts2cb mapping\n");
dest_mdef->cb = semi_ts2cb(dest_mdef->n_tied_state);
n_ts = dest_mdef->n_tied_state;
n_cb = 1;
}
else if (strcmp(CONT_LABEL, ts2cbfn) == 0) {
E_INFO("Generating continous ts2cb mapping\n");
dest_mdef->cb = cont_ts2cb(dest_mdef->n_tied_state);
n_ts = dest_mdef->n_tied_state;
n_cb = dest_mdef->n_tied_state;
}
else if (strcmp(PTM_LABEL, ts2cbfn) == 0) {
E_INFO("Generating phonetically tied ts2cb mapping\n");
dest_mdef->cb = ptm_ts2cb(dest_mdef);
n_ts = dest_mdef->n_tied_state;
n_cb = dest_mdef->acmod_set->n_ci;
}
else {
E_INFO("Reading dest %s\n",
cmd_ln_str("-dest_ts2cbfn"));
if (s3ts2cb_read(ts2cbfn,
&dest_mdef->cb,
&n_ts,
&n_cb) != S3_SUCCESS) {
return S3_ERROR;
}
}
E_INFO("Calculating initial model parameters\n");
n_tmat_dest = dest_mdef->n_tied_tmat;
tmat_dest_list = init_was_added(n_tmat_dest);
E_INFO("Alloc %ux%ux%u dest tmat\n",
n_tmat_dest,
n_state_pm-1,
n_state_pm);
dest_tmat = (float32 ***)ckd_calloc_3d(n_tmat_dest,
n_state_pm-1,
n_state_pm,
sizeof(float32));
n_mixw_dest = dest_mdef->n_tied_state;
mixw_dest_list = init_was_added(n_mixw_dest);
E_INFO("Alloc %ux%ux%u dest mixw\n",
n_mixw_dest, n_feat, n_gau);
dest_mixw = (float32 ***)ckd_calloc_3d(n_mixw_dest, n_feat, n_gau, sizeof(float32));
for (i = 0, n_cb_dest = 0; i < n_mixw_dest; i++) {
if (dest_mdef->cb[i] > n_cb_dest) {
n_cb_dest = dest_mdef->cb[i];
}
}
++n_cb_dest;
cb_dest_list = init_was_added(n_cb_dest);
E_INFO("Alloc %ux%ux%u dest mean and var\n",
n_cb_dest, n_feat, n_gau);
dest_mean = gauden_alloc_param(n_cb_dest, n_feat, n_gau, veclen);
if (src_var)
dest_var = gauden_alloc_param(n_cb_dest, n_feat, n_gau, veclen);
else if (src_fullvar)
dest_fullvar = gauden_alloc_param_full(n_cb_dest, n_feat, n_gau, veclen);
for (dest_m = 0; dest_m < dest_mdef->n_defn; dest_m++) {
dest_m_name = acmod_set_id2name(dest_mdef->acmod_set, dest_m);
src_m = acmod_set_name2id(src_mdef->acmod_set, dest_m_name);
if (src_m == NO_ACMOD) {
/* No corresponding phone model in the source set */
/* See if there is a source base phone corresponding to this destination model
base phone */
dest_m_base = acmod_set_base_phone(dest_mdef->acmod_set, dest_m);
dest_m_base_name = acmod_set_id2name(dest_mdef->acmod_set, dest_m_base);
src_m_base = acmod_set_name2id(src_mdef->acmod_set, dest_m_base_name);
if (src_m_base == NO_ACMOD) {
/* No corresponding model or base model found. Use uniform distribution */
E_INFO("No source base phone %s found. Initializing %s using uniform distribution\n",
dest_m_base_name, dest_m_name);
if (src_tmat) {
E_INFO("Uniform initialization of tmat not supported\n");
}
init_uniform(dest_mixw, &dest_mdef->defn[dest_m], n_feat, n_gau);
}
else {
/* No corresponding model, but a base model was found. Use base distribution. */
init_model(dest_mixw, dest_mean, dest_var, dest_fullvar, dest_tmat,
&dest_mdef->defn[dest_m], dest_mdef->cb, dest_mdef->acmod_set,
src_mixw, src_mean, src_var, src_fullvar, src_tmat,
&src_mdef->defn[src_m_base], src_mdef->cb, src_mdef->acmod_set,
n_feat, n_gau, n_state_pm, veclen);
}
}
else {
/* Found a corresponding model in the source set, so use source distributions to init
the destination */
init_model(dest_mixw, dest_mean, dest_var, dest_fullvar, dest_tmat,
&dest_mdef->defn[dest_m], dest_mdef->cb, dest_mdef->acmod_set,
src_mixw, src_mean, src_var, src_fullvar, src_tmat,
&src_mdef->defn[src_m], src_mdef->cb, src_mdef->acmod_set,
n_feat, n_gau, n_state_pm, veclen);
}
}
for (m = 0; m < n_mixw_dest; m++) {
if (mixw_dest_list[m] == NULL) {
E_WARN("Destination state %u has not been initialized!\n", m);
}
}
for (m = 0; m < n_cb_dest; m++) {
if (cb_dest_list[m] == NULL) {
E_WARN("Destination cb %u has not been initialized!\n", m);
}
else if (cb_dest_list[m]->next != NULL) {
E_WARN("dest cb %u has > 1 corresponding source cb\n", m);
}
}
E_INFO("Writing dest %s\n",
cmd_ln_str("-dest_tmatfn"));
if (s3tmat_write(cmd_ln_str("-dest_tmatfn"),
dest_tmat,
n_tmat_dest,
n_state_pm) != S3_SUCCESS) {
return S3_ERROR;
}
E_INFO("Writing dest %s\n",
cmd_ln_str("-dest_mixwfn"));
if (s3mixw_write(cmd_ln_str("-dest_mixwfn"),
dest_mixw,
dest_mdef->n_tied_state, n_feat, n_gau) < S3_SUCCESS) {
return S3_ERROR;
}
E_INFO("Writing dest %s\n",
cmd_ln_str("-dest_meanfn"));
if (s3gau_write(cmd_ln_str("-dest_meanfn"),
(const vector_t ***)dest_mean,
n_cb_dest,
n_feat,
n_gau,
veclen) != S3_SUCCESS) {
return S3_ERROR;
}
E_INFO("Writing dest %s\n",
cmd_ln_str("-dest_varfn"));
if (cmd_ln_int32("-fullvar")) {
if (s3gau_write_full(cmd_ln_str("-dest_varfn"),
(const vector_t ****)dest_fullvar,
n_cb_dest,
n_feat,
n_gau,
veclen) != S3_SUCCESS) {
return S3_ERROR;
}
}
else {
if (s3gau_write(cmd_ln_str("-dest_varfn"),
(const vector_t ***)dest_var,
n_cb_dest,
n_feat,
n_gau,
veclen) != S3_SUCCESS) {
return S3_ERROR;
}
}
ckd_free(veclen);
return S3_SUCCESS;
}
/********************************************************************
* Make MLLR matrix A and B using conventional MLLR method
********************************************************************/
int
mllr_mat(float32 *****out_A,
float32 ****out_B,
const char *var_fn,
vector_t ***mean,
vector_t ***wt_mean, /* read from bw accum */
float32 ***wt_dcount, /* read from bw accum */
uint32 gau_begin,
int32 *cb2mllr,
uint32 mllr_mult,
uint32 mllr_add,
float32 varfloor,
uint32 n_mgau,
uint32 n_stream,
uint32 n_density,
uint32 n_mllr_class,
const uint32 *veclen)
{
vector_t ***var = NULL;
float32 ****A = NULL;
float32 ***B = NULL;
float32 *****regl = NULL;
float32 ****regr = NULL;
float32 wt_mean_var;
float32 wt_dcount_var;
float32 wt_dcount_var_mean;
float32 *tmean = NULL;
uint32 n_mgau_rd;
uint32 n_stream_rd;
uint32 n_density_rd;
uint32 *veclen_rd = NULL;
uint32 i, j, k, l, s, p , q;
int32 m, mc;
int32 len=0;
/* uint32 i, j, k, l, p, q, s;
int32 m, mc, mi; */
E_INFO("\n");
E_INFO(" ---- mllr_solve(): Conventional MLLR method\n");
if (cmd_ln_int32("-fullvar")) {
/* Extract diagonals to solve MLLR (we are not doing
variance adaptation, yet) */
vector_t ****fullvar;
uint32 i, j, k, l;
if (s3gau_read_full(var_fn,
&fullvar,
&n_mgau_rd,
&n_stream_rd,
&n_density_rd,
&veclen_rd) != S3_SUCCESS) {
E_FATAL("Couldn't read %s", var_fn);
}
var = gauden_alloc_param(n_mgau_rd,
n_stream_rd,
n_density_rd,
veclen_rd);
for (i = 0; i < n_mgau_rd; ++i)
for (j = 0; j < n_stream_rd; ++j)
for (k = 0; k < n_density_rd; ++k)
for (l = 0; l < veclen_rd[j]; ++l)
var[i][j][k][l] =
fullvar[i][j][k][l][l];
gauden_free_param_full(fullvar);
}
else {
if (s3gau_read(var_fn,
&var,
&n_mgau_rd,
&n_stream_rd,
&n_density_rd,
&veclen_rd) != S3_SUCCESS) {
E_FATAL("Couldn't read %s", var_fn);
}
}
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;
/* Invert variances. */
for (i = 0; i < n_mgau; i++) {
for (j = 0; j < n_stream; j++) {
for (k = 0; k < n_density; k++) {
for (l = 0; l < veclen[j]; l++) {
if (var[i][j][k][l] <= 0.) {
var[i][j][k][l] = VAR_CONST;
}
else if (var[i][j][k][l] < varfloor) {
var[i][j][k][l] = 1. / varfloor;
}
else {
var[i][j][k][l] = 1. / var[i][j][k][l];
}
}
}
}
}
fprintf(stderr,"\n");
E_INFO(" ---- A. Accum regl, regr\n");
E_INFO(" No classes %d, no. stream %d\n",n_mllr_class,n_stream);
/* Legetter's set of G matrices, one per dimension per class. */
regl = (float32 *****)ckd_calloc_2d(n_mllr_class, n_stream, sizeof(float32 ***));
/* Legetter's Z matrices, one per class. */
regr = (float32 ****) ckd_calloc_2d(n_mllr_class, n_stream, sizeof(float32 **));
for (i = 0; i < n_mllr_class; i++) {
for (j = 0; j < n_stream; j++) {
len = veclen[j];
regl[i][j] = (float32 ***)ckd_calloc_3d(len, len+1, len+1, sizeof(float32));
regr[i][j] = (float32 **) ckd_calloc_2d(len, len+1, sizeof(float32));
}
}
/* E_INFO(" Checking\n");*/
for (i = gau_begin; i < n_mgau; i++) {
mc = cb2mllr[i];
if (mc < 0) continue; /* skip */
for (j = 0; j < n_stream; j++) {
len=veclen[j];
for (k = 0; k < n_density; k++) {
if (wt_dcount[i][j][k] > 0.) {
tmean = mean[i][j][k];
for (l = 0; l < len; l++) {
wt_mean_var = wt_mean[i][j][k][l] * var[i][j][k][l];
wt_dcount_var = wt_dcount[i][j][k] * var[i][j][k][l];
for (p = 0; p < len; p++) {
wt_dcount_var_mean = wt_dcount_var * tmean[p];
for (q = p; q < len; q++) {
/* This is g(l)_{pq} = sum_r(v_{ii}(r) d_{pq}(r))*/
/* or in other words sum(likelihood * invvar * outer(mean, mean)) */
regl[mc][j][l][p][q] += (float32) (wt_dcount_var_mean * tmean[q]);
}
/* G corresponding to extended element of q. */
regl[mc][j][l][p][len] += (float32)(wt_dcount_var_mean);
/* This is z_{lp} = sum(likelihood * invvar * obs * mean_p) */
regr[mc][j][l][p] += (float32)(wt_mean_var * tmean[p]);
}
/* G corresponding to extended element of p and q. */
/* Question: what about regl[mc][j][l][len][0..len]? */
/* Answer: G(l) is symmetric, so we already calculated them. */
regl[mc][j][l][len][len] += (float32)wt_dcount_var;
/* Z corresponding to extended element of p. */
regr[mc][j][l][len] += (float32)(wt_mean_var);
}
}
}
}
}
gauden_free_param(mean);
gauden_free_param(wt_mean);
ckd_free_3d((void ***)wt_dcount);
/* Fill in the lower triangular part of regl. */
for (m = 0; m < n_mllr_class; m++) {
for (j = 0; j < n_stream; j++) {
for (l = 0; l < veclen[j]; l++) {
for (p = 0; p <= veclen[j]; p++) {
for (q = p+1; q <= veclen[j]; q++) {
regl[m][j][l][q][p] = regl[m][j][l][p][q];
}
}
}
}
}
E_INFO(" ---- B. Compute MLLR matrices (A,B)\n");
if(compute_mllr(regl,
regr,
veclen,
n_mllr_class,
n_stream,
mllr_mult,
mllr_add,
&A,
&B) != S3_SUCCESS) {
E_FATAL("MLLR computation failed\n");
}
free_mllr_reg(regl,regr, n_mllr_class, n_stream);
*out_A = A;
*out_B = B;
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 ;
}
