msb-public
/
PaddleSpeech
mirror of https://github.com/PaddlePaddle/PaddleSpeech
1
0
Code Issues Projects Releases Wiki Activity

streamline source code

Browse Source
pull/2/head
Yibing Liu 7 years ago
parent 8ff6221d00
commit 9a79b41bcd
6 changed files with 92 additions and 122 deletions
Show Stats Download Patch File Download Diff File

39
deploy/ctc_decoders.cpp
Unescape View File

@ -10,8 +10,6 @@
#include "path_trie.h"
#include "ThreadPool.h"
typedef float log_prob_type;
std::string ctc_best_path_decoder(std::vector<std::vector<double> > probs_seq,
std::vector<std::string> vocabulary)
{
@ -86,19 +84,14 @@ std::vector<std::pair<double, std::string> >
std::vector<std::string>::iterator it = std::find(vocabulary.begin(),
vocabulary.end(), " ");
int space_id = it - vocabulary.begin();
// if no space in vocabulary
if(space_id >= vocabulary.size()) {
std::cout << " The character space is not in the vocabulary!"<<std::endl;
exit(1);
space_id = -2;
}
static log_prob_type POS_INF = std::numeric_limits<log_prob_type>::max();
static log_prob_type NEG_INF = -POS_INF;
static log_prob_type NUM_MIN = std::numeric_limits<log_prob_type>::min();
// init
PathTrie root;
root._log_prob_b_prev = 0.0;
root._score = 0.0;
root._score = root._log_prob_b_prev = 0.0;
std::vector<PathTrie*> prefixes;
prefixes.push_back(&root);
@ -140,17 +133,17 @@ std::vector<std::pair<double, std::string> >
prob_idx.begin() + cutoff_len);
}
std::vector<std::pair<int, log_prob_type> > log_prob_idx;
std::vector<std::pair<int, float> > log_prob_idx;
for (int i = 0; i < cutoff_len; i++) {
log_prob_idx.push_back(std::pair<int, log_prob_type>
(prob_idx[i].first, log(prob_idx[i].second + NUM_MIN)));
log_prob_idx.push_back(std::pair<int, float>
(prob_idx[i].first, log(prob_idx[i].second + NUM_FLT_MIN)));
}
// loop over chars
for (int index = 0; index < log_prob_idx.size(); index++) {
auto c = log_prob_idx[index].first;
log_prob_type log_prob_c = log_prob_idx[index].second;
//log_prob_type log_probs_prev;
float log_prob_c = log_prob_idx[index].second;
//float log_probs_prev;
for (int i = 0; i < prefixes.size() && i<beam_size; i++) {
auto prefix = prefixes[i];
@ -165,17 +158,16 @@ std::vector<std::pair<double, std::string> >
if (c == prefix->_character) {
prefix->_log_prob_nb_cur = log_sum_exp(
prefix->_log_prob_nb_cur,
log_prob_c + prefix->_log_prob_nb_prev
);
log_prob_c + prefix->_log_prob_nb_prev);
}
// get new prefix
auto prefix_new = prefix->get_path_trie(c);
if (prefix_new != nullptr) {
float log_p = NEG_INF;
float log_p = -NUM_FLT_INF;
if (c == prefix->_character
&& prefix->_log_prob_b_prev > NEG_INF) {
&& prefix->_log_prob_b_prev > -NUM_FLT_INF) {
log_p = log_prob_c + prefix->_log_prob_b_prev;
} else if (c != prefix->_character) {
log_p = log_prob_c + prefix->_score;
@ -201,7 +193,6 @@ std::vector<std::pair<double, std::string> >
log_p += score;
log_p += ext_scorer->beta;
}
prefix_new->_log_prob_nb_cur = log_sum_exp(
prefix_new->_log_prob_nb_cur, log_p);
@ -292,13 +283,13 @@ std::vector<std::vector<std::pair<double, std::string>>>
// number of samples
int batch_size = probs_split.size();
// dictionary init
if ( ext_scorer != nullptr) {
if (ext_scorer->_dictionary == nullptr) {
// TODO: init dictionary
if ( ext_scorer != nullptr
&& !ext_scorer->is_character_based()
&& ext_scorer->_dictionary == nullptr) {
// init dictionary
ext_scorer->set_char_map(vocabulary);
ext_scorer->fill_dictionary(true);
}
}
// enqueue the tasks of decoding
std::vector<std::future<std::vector<std::pair<double, std::string>>>> res;
for (int i = 0; i < batch_size; i++) {

27
deploy/decoder_utils.cpp
Unescape View File

@ -15,7 +15,7 @@ size_t get_utf8_str_len(const std::string& str) {
//Splits string into vector of strings representing
//UTF-8 characters (not same as chars)
//------------------------------------------------------
std::vector<std::string> UTF8_split(const std::string& str)
std::vector<std::string> split_utf8_str(const std::string& str)
{
std::vector<std::string> result;
std::string out_str;
@ -37,6 +37,29 @@ std::vector<std::string> UTF8_split(const std::string& str)
return result;
}
// Split a string into a list of strings on a given string
// delimiter. NB: delimiters on beginning / end of string are
// trimmed. Eg, "FooBarFoo" split on "Foo" returns ["Bar"].
std::vector<std::string> split_str(const std::string &s,
const std::string &delim) {
std::vector<std::string> result;
std::size_t start = 0, delim_len = delim.size();
while (true) {
std::size_t end = s.find(delim, start);
if (end == std::string::npos) {
if (start < s.size()) {
result.push_back(s.substr(start));
}
break;
}
if (end > start) {
result.push_back(s.substr(start, end - start));
}
start = end + delim_len;
}
return result;
}
//-------------------------------------------------------
// Overriding less than operator for sorting
//-------------------------------------------------------
@ -80,7 +103,7 @@ bool add_word_to_dictionary(const std::string& word,
bool add_space,
int SPACE,
fst::StdVectorFst* dictionary) {
auto characters = UTF8_split(word);
auto characters = split_utf8_str(word);
std::vector<int> int_word;

19
deploy/decoder_utils.h
Unescape View File

@ -4,14 +4,19 @@
#include <utility>
#include "path_trie.h"
const float NUM_FLT_INF = std::numeric_limits<float>::max();
const float NUM_FLT_MIN = std::numeric_limits<float>::min();
template <typename T1, typename T2>
bool pair_comp_first_rev(const std::pair<T1, T2> &a, const std::pair<T1, T2> &b)
bool pair_comp_first_rev(const std::pair<T1, T2> &a,
const std::pair<T1, T2> &b)
{
return a.first > b.first;
}
template <typename T1, typename T2>
bool pair_comp_second_rev(const std::pair<T1, T2> &a, const std::pair<T1, T2> &b)
bool pair_comp_second_rev(const std::pair<T1, T2> &a,
const std::pair<T1, T2> &b)
{
return a.second > b.second;
}
@ -26,16 +31,18 @@ T log_sum_exp(const T &x, const T &y)
return std::log(std::exp(x-xmax) + std::exp(y-xmax)) + xmax;
}
//-------------------------------------------------------
// Overriding less than operator for sorting
//-------------------------------------------------------
// Functor for prefix comparsion
bool prefix_compare(const PathTrie* x, const PathTrie* y);
// Get length of utf8 encoding string
// See: http://stackoverflow.com/a/4063229
size_t get_utf8_str_len(const std::string& str);
std::vector<std::string> UTF8_split(const std::string &str);
std::vector<std::string> split_str(const std::string &s,
const std::string &delim);
std::vector<std::string> split_utf8_str(const std::string &str);
void add_word_to_fst(const std::vector<int>& word,
fst::StdVectorFst* dictionary);

27
deploy/path_trie.cpp
Unescape View File

@ -8,12 +8,11 @@
#include "decoder_utils.h"
PathTrie::PathTrie() {
float lowest = -1.0*std::numeric_limits<float>::max();
_log_prob_b_prev = lowest;
_log_prob_nb_prev = lowest;
_log_prob_b_cur = lowest;
_log_prob_nb_cur = lowest;
_score = lowest;
_log_prob_b_prev = -NUM_FLT_INF;
_log_prob_nb_prev = -NUM_FLT_INF;
_log_prob_b_cur = -NUM_FLT_INF;
_log_prob_nb_cur = -NUM_FLT_INF;
_score = -NUM_FLT_INF;
_ROOT = -1;
_character = _ROOT;
@ -41,11 +40,10 @@ PathTrie* PathTrie::get_path_trie(int new_char, bool reset) {
if ( child != _children.end() ) {
if (!child->second->_exists) {
child->second->_exists = true;
float lowest = -1.0*std::numeric_limits<float>::max();
child->second->_log_prob_b_prev = lowest;
child->second->_log_prob_nb_prev = lowest;
child->second->_log_prob_b_cur = lowest;
child->second->_log_prob_nb_cur = lowest;
child->second->_log_prob_b_prev = -NUM_FLT_INF;
child->second->_log_prob_nb_prev = -NUM_FLT_INF;
child->second->_log_prob_b_cur = -NUM_FLT_INF;
child->second->_log_prob_nb_cur = -NUM_FLT_INF;
}
return (child->second);
} else {
@ -106,8 +104,8 @@ void PathTrie::iterate_to_vec(
_log_prob_b_prev = _log_prob_b_cur;
_log_prob_nb_prev = _log_prob_nb_cur;
_log_prob_b_cur = -1.0 * std::numeric_limits<float>::max();
_log_prob_nb_cur = -1.0 * std::numeric_limits<float>::max();
_log_prob_b_cur = -NUM_FLT_INF;
_log_prob_nb_cur = -NUM_FLT_INF;
_score = log_sum_exp(_log_prob_b_prev, _log_prob_nb_prev);
output.push_back(this);
@ -117,9 +115,6 @@ void PathTrie::iterate_to_vec(
}
}
//-------------------------------------------------------
// Effectively removes node
//-------------------------------------------------------
void PathTrie::remove() {
_exists = false;

65
deploy/scorer.cpp
Unescape View File

@ -17,7 +17,7 @@ Scorer::Scorer(double alpha, double beta, const std::string& lm_path) {
_language_model = nullptr;
_dictionary = nullptr;
_max_order = 0;
_SPACE = -1;
_SPACE_ID = -1;
// load language model
load_LM(lm_path.c_str());
}
@ -61,7 +61,7 @@ double Scorer::get_log_cond_prob(const std::vector<std::string>& words) {
lm::WordIndex word_index = model->BaseVocabulary().Index(words[i]);
// encounter OOV
if (word_index == 0) {
return OOV_SCOER;
return OOV_SCORE;
}
cond_prob = model->BaseScore(&state, word_index, &out_state);
tmp_state = state;
@ -197,64 +197,27 @@ Scorer::split_labels(const std::vector<int> &labels) {
std::string s = vec2str(labels);
std::vector<std::string> words;
if (_is_character_based) {
words = UTF8_split(s);
words = split_utf8_str(s);
} else {
words = split_str(s, " ");
}
return words;
}
// Split a string into a list of strings on a given string
// delimiter. NB: delimiters on beginning / end of string are
// trimmed. Eg, "FooBarFoo" split on "Foo" returns ["Bar"].
std::vector<std::string> Scorer::split_str(const std::string &s,
const std::string &delim) {
std::vector<std::string> result;
std::size_t start = 0, delim_len = delim.size();
while (true) {
std::size_t end = s.find(delim, start);
if (end == std::string::npos) {
if (start < s.size()) {
result.push_back(s.substr(start));
}
break;
}
if (end > start) {
result.push_back(s.substr(start, end - start));
}
start = end + delim_len;
}
return result;
}
//---------------------------------------------------
// Add index to char list for searching language model
//---------------------------------------------------
void Scorer::set_char_map(std::vector<std::string> char_list) {
_char_list = char_list;
std::string _SPACE_STR = " ";
for (unsigned int i = 0; i < _char_list.size(); i++) {
// if (_char_list[i] == _BLANK_STR) {
// _BLANK = i;
// } else
if (_char_list[i] == _SPACE_STR) {
_SPACE = i;
}
}
_char_map.clear();
for(unsigned int i = 0; i < _char_list.size(); i++)
{
if(i == (unsigned int)_SPACE){
if (_char_list[i] == " ") {
_SPACE_ID = i;
_char_map[' '] = i;
}
else if(_char_list[i].size() == 1){
} else if(_char_list[i].size() == 1){
_char_map[_char_list[i][0]] = i;
}
}
} //------------- End of set_char_map ----------------
}
std::vector<std::string> Scorer::make_ngram(PathTrie* prefix) {
std::vector<std::string> ngram;
@ -265,10 +228,10 @@ std::vector<std::string> Scorer::make_ngram(PathTrie* prefix) {
std::vector<int> prefix_vec;
if (_is_character_based) {
new_node = current_node->get_path_vec(prefix_vec, _SPACE, 1);
new_node = current_node->get_path_vec(prefix_vec, _SPACE_ID, 1);
current_node = new_node;
} else {
new_node = current_node->get_path_vec(prefix_vec, _SPACE);
new_node = current_node->get_path_vec(prefix_vec, _SPACE_ID);
current_node = new_node->_parent; // Skipping spaces
}
@ -279,7 +242,7 @@ std::vector<std::string> Scorer::make_ngram(PathTrie* prefix) {
if (new_node->_character == -1) {
// No more spaces, but still need order
for (int i = 0; i < _max_order - order - 1; i++) {
ngram.push_back("<s>");
ngram.push_back(START_TOKEN);
}
break;
}
@ -288,10 +251,6 @@ std::vector<std::string> Scorer::make_ngram(PathTrie* prefix) {
return ngram;
}
//---------------------------------------------------------
// Helper function to populate Trie with a vocab using the
// char_list for maping from string to int
//---------------------------------------------------------
void Scorer::fill_dictionary(bool add_space) {
fst::StdVectorFst dictionary;
@ -307,7 +266,7 @@ void Scorer::fill_dictionary(bool add_space) {
bool added = add_word_to_dictionary(word,
char_map,
add_space,
_SPACE,
_SPACE_ID,
&dictionary);
vocab_size += added ? 1 : 0;
}

9
deploy/scorer.h
Unescape View File

@ -11,7 +11,7 @@
#include "util/string_piece.hh"
#include "path_trie.h"
const double OOV_SCOER = -1000.0;
const double OOV_SCORE = -1000.0;
const std::string START_TOKEN = "<s>";
const std::string UNK_TOKEN = "<unk>";
const std::string END_TOKEN = "</s>";
@ -68,18 +68,13 @@ protected:
double get_log_prob(const std::vector<std::string>& words);
std::string vec2str(const std::vector<int> &input);
std::vector<std::string> split_labels(const std::vector<int> &labels);
std::vector<std::string> split_str(const std::string &s,
const std::string &delim);
private:
void _init_char_list();
void _init_char_map();
void* _language_model;
bool _is_character_based;
size_t _max_order;
unsigned int _SPACE;
int _SPACE_ID;
std::vector<std::string> _char_list;
std::unordered_map<char, int> _char_map;

Write Preview
Loading…
Cancel
Save