// bin/convert-ali.cc

// Copyright 2009-2011 Microsoft Corporation

// 2013 Johns Hopkins University (author: Daniel Povey)

// See ../../COPYING for clarification regarding multiple authors

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED

// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,

// MERCHANTABLITY OR NON-INFRINGEMENT.

// See the Apache 2 License for the specific language governing permissions and

// limitations under the License.

#include "base/kaldi-common.h"

#include "util/common-utils.h"

#include "gmm/am-diag-gmm.h"

#include "hmm/transition-model.h"

#include "hmm/hmm-utils.h"

#include "hmm/tree-accu.h" // for ReadPhoneMap

int main(int argc, char *argv[]) {

using namespace kaldi;

typedef kaldi::int32 int32;

try {

const char *usage =

"Convert alignments from one decision-tree/model to another\n"

"Usage: convert-ali [options] <old-model> <new-model> <new-tree> "

"<old-alignments-rspecifier> <new-alignments-wspecifier>\n"

"e.g.: \n"

" convert-ali old/final.mdl new/0.mdl new/tree ark:old/ali.1 ark:new/ali.1\n";

int32 frame_subsampling_factor = 1;

bool reorder = true;

bool repeat_frames = false;

std::string phone_map_rxfilename;

ParseOptions po(usage);

po.Register("phone-map", &phone_map_rxfilename,

"File name containing old->new phone mapping (each line is: "

"old-integer-id new-integer-id)");

po.Register("reorder", &reorder,

"True if you want the converted alignments to be 'reordered' "

"versus the way they appear in the HmmTopology object");

po.Register("repeat-frames", &repeat_frames,

"Only relevant when frame-subsampling-factor != 1. If true, "

"repeat frames of alignment by 'frame-subsampling-factor' "

"after alignment conversion, to keep the alignment the same "

"length as the input alignment.");

po.Register("frame-subsampling-factor", &frame_subsampling_factor,

"Can be used in converting alignments to reduced frame rates.");

po.Read(argc, argv);

if (po.NumArgs() != 5) {

po.PrintUsage();

exit(1);

}

std::string old_model_filename = po.GetArg(1);

std::string new_model_filename = po.GetArg(2);

std::string new_tree_filename = po.GetArg(3);

std::string old_alignments_rspecifier = po.GetArg(4);

std::string new_alignments_wspecifier = po.GetArg(5);

std::vector<int32> phone_map;

if (phone_map_rxfilename != "") { // read phone map.

ReadPhoneMap(phone_map_rxfilename,

&phone_map);

}

SequentialInt32VectorReader alignment_reader(old_alignments_rspecifier);

Int32VectorWriter alignment_writer(new_alignments_wspecifier);

TransitionModel old_trans_model;

ReadKaldiObject(old_model_filename, &old_trans_model);

TransitionModel new_trans_model;

ReadKaldiObject(new_model_filename, &new_trans_model);

if (!(old_trans_model.GetTopo() == new_trans_model.GetTopo()))

KALDI_WARN << "Toplogies of models are not equal: "

<< "conversion may not be correct or may fail.";

ContextDependency new_ctx_dep; // the tree.

ReadKaldiObject(new_tree_filename, &new_ctx_dep);

int num_success = 0, num_fail = 0;

for (; !alignment_reader.Done(); alignment_reader.Next()) {

std::string key = alignment_reader.Key();

const std::vector<int32> &old_alignment = alignment_reader.Value();

std::vector<int32> new_alignment;

if (ConvertAlignment(old_trans_model,

new_trans_model,

new_ctx_dep,

old_alignment,

frame_subsampling_factor,

repeat_frames,

reorder,

(phone_map_rxfilename != "" ? &phone_map : NULL),

&new_alignment)) {

alignment_writer.Write(key, new_alignment);

num_success++;

} else {

KALDI_WARN << "Could not convert alignment for key " << key

<<" (possibly truncated alignment?)";

num_fail++;

}

}

KALDI_LOG << "Succeeded converting alignments for " << num_success

<< " files, failed for " << num_fail;

if (num_success != 0) return 0;

else return 1;

} catch(const std::exception &e) {

std::cerr << e.what();

return -1;

}

}