int32
main(int32 argc, char *argv[])
{
kb_t kb;
stat_t *st;
cmd_ln_t *config;
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", arg);
unlimit();
config = cmd_ln_get();
kb_init(&kb, config);
st = kb.stat;
fprintf(stdout, "\n");
if (cmd_ln_str_r(config, "-ctl")) {
/* When -ctlfile is speicified, corpus.c will look at -ctl_lm and
-ctl_mllr to get the corresponding LM and MLLR for the utterance */
st->tm = ctl_process(cmd_ln_str_r(config, "-ctl"),
cmd_ln_str_r(config, "-ctl_lm"),
cmd_ln_str_r(config, "-ctl_mllr"),
cmd_ln_int32_r(config, "-ctloffset"),
cmd_ln_int32_r(config, "-ctlcount"), utt_decode, &kb);
}
else if (cmd_ln_str_r(config, "-utt")) {
/* When -utt is specified, corpus.c will wait for the utterance to
change */
st->tm = ctl_process_utt(cmd_ln_str_r(config, "-utt"),
cmd_ln_int32_r(config, "-ctlcount"),
utt_decode, &kb);
}
else {
/* Is error checking good enough?" */
E_FATAL("Both -utt and -ctl are not specified.\n");
}
if (kb.matchsegfp)
fclose(kb.matchsegfp);
if (kb.matchfp)
fclose(kb.matchfp);
stat_report_corpus(kb.stat);
kb_free(&kb);
#if (! WIN32)
#if defined(_SUN4)
system("ps -el | grep sphinx3_decode");
#else
system("ps aguxwww | grep sphinx3_decode");
#endif
#endif
cmd_ln_free_r(config);
exit(0);
}
int
main(int argc, char *argv[])
{
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", defn);
unlimit();
config = cmd_ln_get();
logmath = logs3_init(cmd_ln_float64_r(config, "-logbase"), 1,
cmd_ln_int32_r(config, "-log3table"));
E_INFO("Value of base %f \n", cmd_ln_float32_r(config, "-logbase"));
models_init();
ptmr_init(&tm_utt);
if ((inmatchsegfp = fopen(cmd_ln_str_r(config, "-inhypseg"), "r")) == NULL)
E_ERROR("fopen(%s,r) failed\n", cmd_ln_str_r(config, "-inhypseg"));
if ((outconfmatchsegfp = fopen(cmd_ln_str_r(config, "-output"), "w")) == NULL)
E_ERROR("fopen(%s,w) failed\n", cmd_ln_str_r(config, "-output"));
if (cmd_ln_str_r(config, "-ctl")) {
ctl_process(cmd_ln_str_r(config, "-ctl"),
cmd_ln_str_r(config, "-ctl_lm"),
NULL,
cmd_ln_int32_r(config, "-ctloffset"),
cmd_ln_int32_r(config, "-ctlcount"), utt_confidence, NULL);
}
else {
E_FATAL("-ctl is not specified\n");
}
#if (! WIN32)
system("ps auxwww | grep s3dag");
#endif
fclose(outconfmatchsegfp);
fclose(inmatchsegfp);
models_free();
logmath_free(logmath);
cmd_ln_free_r(config);
return 0;
}
int
main(int32 argc, char *argv[])
{
/* kb_t kb;
ptmr_t tm; */
cmd_ln_appl_enter(argc, argv, "default.arg", defn);
config = cmd_ln_get();
logmath = logs3_init(cmd_ln_float64_r(config, "-logbase"), 1,
cmd_ln_int32_r(config, "-log3table"));
/* Read in input databases */
models_init();
ptmr_init(&tm_utt);
nbestdir = cmd_ln_str_r(config, "-nbestdir");
if (cmd_ln_str_r(config, "-ctl")) {
ctl_process(cmd_ln_str_r(config, "-ctl"),
cmd_ln_str_r(config, "-ctl_lm"),
NULL,
cmd_ln_int32_r(config, "-ctloffset"),
cmd_ln_int32_r(config, "-ctlcount"), utt_astar, NULL);
}
else {
E_FATAL("-ctl is not specified\n");
}
models_free();
logmath_free(logmath);
#if (! WIN32)
system("ps aguxwww | grep s3astar");
#endif
cmd_ln_free_r(config);
return 0;
}
int
main(int argc, char *argv[])
{
int i, j, offset;
int32 noframe, vsize, dsize, column;
int32 frm_begin, frm_end;
int is_header, is_describe;
float *z, **cep;
char const *cepfile;
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", arg);
vsize = cmd_ln_int32("-i");
dsize = cmd_ln_int32("-d");
frm_begin = cmd_ln_int32("-b");
frm_end = cmd_ln_int32("-e");
is_header = cmd_ln_int32("-header");
is_describe = cmd_ln_int32("-describe");
if (vsize < 0)
E_FATAL("-i : Input vector size should be larger than 0.\n");
if (dsize < 0)
E_FATAL("-d : Column size should be larger than 0\n");
if (frm_begin < 0)
E_FATAL("-b : Beginning frame should be larger than 0\n");
/* The following condition is redundant
* if (frm_end < 0) E_FATAL("-e : Ending frame should be larger than 0\n");
*/
if (frm_begin >= frm_end)
E_FATAL
("Ending frame (-e) should be larger than beginning frame (-b).\n");
if ((cepfile = cmd_ln_str("-f")) == NULL) {
E_FATAL("Input file was not specified with (-f)\n");
}
if (read_cep(cepfile, &cep, &noframe, vsize) == IO_ERR)
E_FATAL("ERROR opening %s for reading\n", cepfile);
z = cep[0];
offset = 0;
column = (vsize > dsize) ? dsize : vsize;
frm_end = (frm_end > noframe) ? noframe : frm_end;
E_INFO("Displaying %d out of %d columns per frame\n", column, vsize);
E_INFO("Total %d frames\n\n", noframe);
/* This part should be moved to a special library if this file is
longer than 300 lines. */
if (is_header) {
if (is_describe) {
printf("\n%6s", "frame#:");
}
for (j = 0; j < column; ++j) {
printf("%3s%3d%s ", "c[", j, "]");
}
printf("\n");
}
offset += frm_begin * vsize;
for (i = frm_begin; i < frm_end; ++i) {
if (is_describe) {
printf("%6d:", i);
}
for (j = 0; j < column; ++j)
printf("%7.3f ", z[offset + j]);
printf("\n");
offset += vsize;
}
fflush(stdout);
cmd_ln_appl_exit();
ckd_free_2d(cep);
return (IO_SUCCESS);
}
int32
main(int32 argc, char *argv[])
{
FILE *fpout;
mgau_model_t *mgau;
int32 **subvec;
int32 max_datarows, datarows, datacols, svqrows, svqcols;
float32 **data, **vqmean;
int32 *datamap, *vqmap;
float64 sqerr;
int32 stdev;
int32 i, j, v, m, c;
cmd_ln_t *config;
logmath_t *logmath;
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", arg);
unlimit();
config = cmd_ln_get();
logmath = logs3_init(cmd_ln_float64_r(config, "-logbase"), 1, cmd_ln_int32_r(config, "-log3table")); /*Report Progress, use log table */
/* Load means/vars but DO NOT precompute variance inverses or determinants */
mgau = mgau_init(cmd_ln_str_r(config, "-mean"),
cmd_ln_str_r(config, "-var"), 0.0 /* no varfloor */ ,
cmd_ln_str_r(config, "-mixw"), cmd_ln_float32_r(config, "-mixwfloor"), FALSE, /* No precomputation */
".cont.", MIX_INT_FLOAT_COMP, logmath);
/* Parse subvector spec argument; subvec is null terminated; subvec[x] is -1 terminated */
subvec = parse_subvecs(cmd_ln_str_r(config, "-svspec"));
if (cmd_ln_str_r(config, "-subvq")) {
if ((fpout = fopen(cmd_ln_str_r(config, "-subvq"), "w")) == NULL) {
E_ERROR_SYSTEM("Failed to open output file '%s'", fpout);
return 1;
}
}
else
fpout = stdout;
/* Echo command line to output file */
for (i = 0; i < argc - 1; i++)
fprintf(fpout, "# %s \\\n", argv[i]);
fprintf(fpout, "# %s\n#\n", argv[argc - 1]);
/* Print input and output configurations to output file */
for (v = 0; subvec[v]; v++); /* No. of subvectors */
svqrows = cmd_ln_int32_r(config, "-svqrows");
fprintf(fpout, "VQParam %d %d -> %d %d\n",
mgau_n_mgau(mgau), mgau_max_comp(mgau), v, svqrows);
for (v = 0; subvec[v]; v++) {
for (i = 0; subvec[v][i] >= 0; i++);
fprintf(fpout, "Subvector %d length %d ", v, i);
for (i = 0; subvec[v][i] >= 0; i++)
fprintf(fpout, " %2d", subvec[v][i]);
fprintf(fpout, "\n");
}
fflush(fpout);
/*
* datamap[] for identifying non-0 input vectors that take part in the clustering process:
* datamap[m*max_mean + c] = row index of data[][] containing the copy.
* vqmap[] for mapping vq input data to vq output.
*/
max_datarows = mgau_n_mgau(mgau) * mgau_max_comp(mgau);
datamap = (int32 *) ckd_calloc(max_datarows, sizeof(int32));
vqmap = (int32 *) ckd_calloc(max_datarows, sizeof(int32));
stdev = cmd_ln_int32_r(config, "-stdev");
/* Copy and cluster each subvector */
for (v = 0; subvec[v]; v++) {
E_INFO("Clustering subvector %d\n", v);
for (datacols = 0; subvec[v][datacols] >= 0; datacols++); /* Input subvec length */
svqcols = datacols * 2; /* subvec length after concatenating mean + var */
/* Allocate input/output data areas */
data =
(float32 **) ckd_calloc_2d(max_datarows, svqcols,
sizeof(float32));
vqmean =
(float32 **) ckd_calloc_2d(svqrows, svqcols, sizeof(float32));
/* Make a copy of the subvectors from the input data, and initialize maps */
for (i = 0; i < max_datarows; i++)
datamap[i] = -1;
datarows = 0;
for (m = 0; m < mgau_n_mgau(mgau); m++) { /* For each mixture m */
for (c = 0; c < mgau_n_comp(mgau, m); c++) { /* For each component c in m */
if (vector_is_zero
(mgau_var(mgau, m, c), mgau_veclen(mgau))) {
E_INFO("Skipping mgau %d comp %d\n", m, c);
continue;
}
for (i = 0; i < datacols; i++) { /* Copy specified dimensions, mean+var */
data[datarows][i * 2] =
mgau->mgau[m].mean[c][subvec[v][i]];
data[datarows][i * 2 + 1] =
(!stdev) ? mgau->mgau[m].
var[c][subvec[v][i]] : sqrt(mgau->mgau[m].
var[c][subvec[v][i]]);
}
datamap[m * mgau_max_comp(mgau) + c] = datarows++;
}
}
E_INFO("Sanity check: input data[0]:\n");
vector_print(stderr, data[0], svqcols);
for (i = 0; i < max_datarows; i++)
vqmap[i] = -1;
#if 0
{
int32 **in;
printf("Input data: %d x %d\n", datarows, svqcols);
in = (int32 **) data;
for (i = 0; i < datarows; i++) {
printf("%8d:", i);
for (j = 0; j < svqcols; j++)
printf(" %08x", in[i][j]);
printf("\n");
}
for (i = 0; i < datarows; i++) {
printf("%15d:", i);
for (j = 0; j < svqcols; j++)
printf(" %15.7e", data[i][j]);
printf("\n");
}
fflush(stdout);
}
#endif
/* VQ the subvector copy built above */
sqerr = vector_vqgen(data, datarows, svqcols, svqrows,
cmd_ln_float64_r(config, "-eps"), cmd_ln_int32_r(config, "-iter"),
vqmean, vqmap, cmd_ln_int32_r(config, "-seed"));
/* Output VQ */
fprintf(fpout, "Codebook %d Sqerr %e\n", v, sqerr);
for (i = 0; i < svqrows; i++) {
if (stdev) {
/* Convert clustered stdev back to var */
for (j = 1; j < svqcols; j += 2)
vqmean[i][j] *= vqmean[i][j];
}
vector_print(fpout, vqmean[i], svqcols);
}
fprintf(fpout, "Map %d\n", v);
for (i = 0; i < max_datarows; i += mgau_max_comp(mgau)) {
for (j = 0; j < mgau_max_comp(mgau); j++) {
if (datamap[i + j] < 0)
fprintf(fpout, " -1");
else
fprintf(fpout, " %d", vqmap[datamap[i + j]]);
}
fprintf(fpout, "\n");
}
fflush(fpout);
/* Cleanup */
ckd_free_2d((void **) data);
ckd_free_2d((void **) vqmean);
}
subvecs_free(subvec);
ckd_free(datamap);
ckd_free(vqmap);
mgau_free(mgau);
fprintf(fpout, "End\n");
fclose(fpout);
logmath_free(logmath);
cmd_ln_free_r(config);
exit(0);
}
int
main(int32 argc, char *argv[])
{
char sent[16384];
cmd_ln_t *config;
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", defn);
unlimit();
config = cmd_ln_get();
ctloffset = cmd_ln_int32_r(config, "-ctloffset");
sentfile = cmd_ln_str_r(config, "-insent");
if ((sentfp = fopen(sentfile, "r")) == NULL)
E_FATAL_SYSTEM("Failed to open file %s for reading", sentfile);
/* Note various output directories */
if (cmd_ln_str_r(config, "-s2stsegdir") != NULL)
s2stsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-s2stsegdir"));
if (cmd_ln_str_r(config, "-stsegdir") != NULL)
stsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-stsegdir"));
if (cmd_ln_str_r(config, "-phsegdir") != NULL)
phsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-phsegdir"));
if (cmd_ln_str_r(config, "-phlabdir") != NULL)
phlabdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-phlabdir"));
if (cmd_ln_str_r(config, "-wdsegdir") != NULL)
wdsegdir = (char *) ckd_salloc(cmd_ln_str_r(config, "-wdsegdir"));
/* HACK! Pre-read insent without checking whether ctl could also
be read. In general, this is caused by the fact that we used
multiple files to specify resource in sphinx III. This is easy
to solve but currently I just to remove process_ctl because it
duplicates badly with ctl_process.
The call back function will take care of matching the uttfile
names. We don't need to worry too much about inconsistency.
*/
while (ctloffset > 0) {
if (fgets(sent, sizeof(sent), sentfp) == NULL) {
E_ERROR("EOF(%s)\n", sentfile);
break;
}
--ctloffset;
}
if ((outsentfile = cmd_ln_str_r(config, "-outsent")) != NULL) {
if ((outsentfp = fopen(outsentfile, "w")) == NULL)
E_FATAL_SYSTEM("Failed to open file %s for writing", outsentfile);
}
if ((outctlfile = cmd_ln_str_r(config, "-outctl")) != NULL) {
if ((outctlfp = fopen(outctlfile, "w")) == NULL)
E_FATAL_SYSTEM("Failed top open file %s for writing", outctlfile);
}
if ((cmd_ln_str_r(config, "-s2stsegdir") == NULL) &&
(cmd_ln_str_r(config, "-stsegdir") == NULL) &&
(cmd_ln_str_r(config, "-phlabdir") == NULL) &&
(cmd_ln_str_r(config, "-phsegdir") == NULL) &&
(cmd_ln_str_r(config, "-wdsegdir") == NULL) &&
(cmd_ln_str_r(config, "-outsent") == NULL))
E_FATAL("Missing output file/directory argument(s)\n");
/* Read in input databases */
models_init(config);
if (!feat)
feat = feat_array_alloc(kbcore_fcb(kbc), S3_MAX_FRAMES);
timers[tmr_utt].name = "U";
timers[tmr_gauden].name = "G";
timers[tmr_senone].name = "S";
timers[tmr_align].name = "A";
/* Initialize align module */
align_init(kbc->mdef, kbc->tmat, dict, config, kbc->logmath);
printf("\n");
if (cmd_ln_str_r(config, "-mllr") != NULL) {
if (kbc->mgau)
adapt_set_mllr(adapt_am, kbc->mgau, cmd_ln_str_r(config, "-mllr"), NULL,
kbc->mdef, config);
else if (kbc->ms_mgau)
model_set_mllr(kbc->ms_mgau, cmd_ln_str_r(config, "-mllr"), NULL, kbcore_fcb(kbc),
kbc->mdef, config);
else
E_WARN("Can't use MLLR matrices with .s2semi. yet\n");
}
tot_nfr = 0;
/* process_ctlfile (); */
if (cmd_ln_str_r(config, "-ctl")) {
/* When -ctlfile is speicified, corpus.c will look at -ctl_mllr to get
the corresponding MLLR for the utterance */
ctl_process(cmd_ln_str_r(config, "-ctl"),
NULL,
cmd_ln_str_r(config, "-ctl_mllr"),
cmd_ln_int32_r(config, "-ctloffset"),
cmd_ln_int32_r(config, "-ctlcount"),
utt_align, config);
}
else {
E_FATAL(" -ctl are not specified.\n");
}
if (tot_nfr > 0) {
printf("\n");
printf("TOTAL FRAMES: %8d\n", tot_nfr);
printf("TOTAL CPU TIME: %11.2f sec, %7.2f xRT\n",
tm_utt.t_tot_cpu, tm_utt.t_tot_cpu / (tot_nfr * 0.01));
printf("TOTAL ELAPSED TIME: %11.2f sec, %7.2f xRT\n",
tm_utt.t_tot_elapsed,
tm_utt.t_tot_elapsed / (tot_nfr * 0.01));
}
if (outsentfp)
fclose(outsentfp);
if (outctlfp)
fclose(outctlfp);
if (sentfp)
fclose(sentfp);
ckd_free(s2stsegdir);
ckd_free(stsegdir);
ckd_free(phsegdir);
ckd_free(wdsegdir);
feat_array_free(feat);
align_free();
models_free();
#if (! WIN32)
system("ps aguxwww | grep s3align");
#endif
cmd_ln_free_r(config);
return 0;
}
int
main(int argc, char *argv[])
{
const char *inputfn;
const char *outputfn;
char *local_outputfn;
const char *inputfmt;
const char *outputfmt;
const char *inputenc;
const char *outputenc;
const char *outputdir;
char *outputpath;
int outputfnfree = FALSE;
lm_t *lm;
char separator[2];
cmd_ln_t *config;
print_appl_info(argv[0]);
cmd_ln_appl_enter(argc, argv, "default.arg", arg);
config = cmd_ln_get();
inputfn = NULL;
outputfn = local_outputfn = NULL;
inputfmt = NULL;
outputfmt = NULL;
outputdir = NULL;
inputfn = cmd_ln_str_r(config, "-i");
outputfn = cmd_ln_str_r(config, "-o");
inputfmt = cmd_ln_str_r(config, "-ifmt");
outputfmt = cmd_ln_str_r(config, "-ofmt");
inputenc = cmd_ln_str_r(config, "-ienc");
outputenc = cmd_ln_str_r(config, "-oenc");
outputdir = cmd_ln_str_r(config, "-odir");
if (!strcmp(inputfmt, outputfmt) && !strcmp(inputenc, outputenc))
E_FATAL
("Input and Output file formats and encodings are the same (%s, %s). Do nothing\n",
inputfmt, inputenc);
if (!encoding_resolve
(cmd_ln_str_r(config, "-ienc"), cmd_ln_str_r(config, "-oenc")))
E_FATAL
("Input and output encoding types is either not compatible or the conversion is not supported. Forced exit\n");
/* Read LM */
if ((lm =
lm_read_advance2(inputfn, "default", 1.0, 0.1, 1.0, 0, inputfmt,
0, 1, NULL, FALSE, FALSE)) == NULL)
E_FATAL("Fail to read inputfn %s in inputfmt %s\n", inputfn,
inputfmt);
if (outputfn == NULL) {
/* Length = strlen(inputfn) + 1 + strlen(outputfmt) + 5 (For safety) */
outputfn = local_outputfn = (char *) ckd_calloc(strlen(inputfn) + strlen(outputfmt) + 5, sizeof(char));
sprintf(local_outputfn, "%s.%s", inputfn, outputfmt);
outputfnfree = TRUE;
}
/* Outputpath = outputdir . "/" (or "\" in windows). outputfn; */
/* Length = strlen(outputdir) + 1 + strlen(outputfn) + 5 (For safety) */
outputpath =
(char *) ckd_calloc(strlen(outputdir) + strlen(outputfn) + 6, sizeof(char));
#if WIN32
strcpy(separator, "\\");
#else
strcpy(separator, "/");
#endif
sprintf(outputpath, "%s%s%s", outputdir, separator, outputfn);
lm_write(lm, outputpath, inputfn, outputfmt);
if (local_outputfn) {
ckd_free(local_outputfn);
}
ckd_free(outputpath);
lm_free(lm);
cmd_ln_free_r(config);
return 0;
}
