| /*---------------------------------------------------------------------------* |
| * srec_initialize.c * |
| * * |
| * Copyright 2007, 2008 Nuance Communciations, Inc. * |
| * * |
| * 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 * |
| * * |
| * Unless required by applicable law or agreed to in writing, software * |
| * distributed under the License is distributed on an 'AS IS' BASIS, * |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * |
| * See the License for the specific language governing permissions and * |
| * limitations under the License. * |
| * * |
| *---------------------------------------------------------------------------*/ |
| |
| #ifndef _RTT |
| #include "pstdio.h" |
| #endif |
| #include <stdlib.h> |
| #include <string.h> |
| #include <math.h> |
| #include "passert.h" |
| |
| #include "portable.h" |
| |
| #include "hmm_desc.h" |
| #include "utteranc.h" |
| #include "hmmlib.h" |
| |
| #include "srec_sizes.h" |
| #include "srec.h" |
| #include "word_lattice.h" |
| #include "swimodel.h" |
| |
| #include "c42mul.h" |
| |
| /*this file contains code which handles the initialization of the srec data structures*/ |
| |
| /*allocates an srec - |
| |
| input args come from config and are: |
| |
| int viterbi_prune_thresh; score-based pruning threshold - only keep paths within this delta of best cost |
| |
| int max_hmm_tokens; controls the maximum number of HMM's alive in any frame. If number |
| exceeded, pruning gets tightened. So, this threshold can be used |
| to tradeoff accuracy for computation an memory |
| int max_fsmnode_tokens; controls the maximum number of FSMs alive in any frame. If number, |
| exceeded, pruning gets tightened. So, this threshold can be used |
| to tradeoff accuracy for computation an memory |
| int max_word_tokens; controls the maximum number of word tokens kept in the word lattice. |
| if number exceeded, the word lattice is pruned more tightly (less word |
| ends per frame |
| |
| int max_altword_tokens; controls the maximum number of alternative paths to propagate for proper nbest |
| |
| int num_wordends_per_frame; controls the size of the word lattice - the number of word ends to |
| keep at each time frame |
| int max_fsm_nodes; allocation size of a few arrays in the search - needs to be big enough |
| to handle any grammar that the search needs to run. Initialization fails |
| if num exceeded |
| int max_fsm_arcs; allocation size of a few arrays in the search - needs to be big enough |
| to handle any grammar that the search needs to run. Initialization fails |
| if num exceeded |
| |
| */ |
| |
| static void allocate_recognition1(srec *rec, |
| int viterbi_prune_thresh, /*score-based pruning threshold - only keep paths within this delta of best cost*/ |
| int max_hmm_tokens, |
| int max_fsmnode_tokens, |
| int max_word_tokens, |
| int max_altword_tokens, |
| int num_wordends_per_frame, |
| int max_frames, |
| int max_model_states) |
| { |
| #ifdef SREC_ENGINE_VERBOSE_LOGGING |
| PLogMessage("allocating recognition arrays2 prune %d max_hmm_tokens %d max_fsmnode_tokens %d max_word_tokens %d max_altword_tokens %d max_wordends_per_frame %d\n", |
| viterbi_prune_thresh, |
| max_hmm_tokens, |
| max_fsmnode_tokens, |
| max_word_tokens, |
| max_altword_tokens, |
| num_wordends_per_frame); |
| #endif |
| rec->current_model_scores = (costdata*) CALLOC_CLR(max_model_states, sizeof(costdata), "search.srec.current_model_scores"); /*FIX - either get NUM_MODELS from acoustic models, or check this someplace to make sure we have enough room*/ |
| rec->num_model_slots_allocated = (modelID)max_model_states; |
| |
| rec->fsmarc_token_array_size = (stokenID)max_hmm_tokens; |
| |
| rec->fsmarc_token_array = (fsmarc_token*) CALLOC_CLR(rec->fsmarc_token_array_size , sizeof(fsmarc_token), "search.srec.fsmarc_token_array"); |
| rec->max_new_states = (stokenID)max_hmm_tokens; |
| |
| rec->word_token_array = (word_token*) CALLOC_CLR(max_word_tokens, sizeof(word_token), "search.srec.word_token_array"); |
| rec->word_token_array_size = (wtokenID)max_word_tokens; |
| /* todo: change this to a bit array later */ |
| rec->word_token_array_flags = (asr_int16_t*) CALLOC_CLR(max_word_tokens, sizeof(asr_int16_t), "search.srec.word_token_array_flags"); |
| |
| rec->fsmnode_token_array = (fsmnode_token*) CALLOC_CLR(max_fsmnode_tokens, sizeof(fsmnode_token), "search.srec.fsmnode_token_array"); |
| rec->fsmnode_token_array_size = (ftokenID)max_fsmnode_tokens; |
| |
| rec->altword_token_array = (altword_token*) CALLOC_CLR(max_altword_tokens, sizeof(altword_token), "search.srec.altword_token_array"); |
| rec->altword_token_array_size = (wtokenID)max_altword_tokens; |
| |
| rec->prune_delta = (costdata)viterbi_prune_thresh; |
| |
| rec->max_frames = (frameID)max_frames; |
| rec->best_model_cost_for_frame = (costdata*)CALLOC_CLR(max_frames, sizeof(costdata), "search.srec.best_model_cost_for_frame"); |
| rec->word_lattice = allocate_word_lattice((frameID)max_frames); |
| |
| rec->word_priority_q = allocate_priority_q(num_wordends_per_frame); |
| rec->best_fsmarc_token = MAXstokenID; |
| |
| #define ASTAR_NBEST_LEN 10 |
| rec->astar_stack = astar_stack_make(rec, ASTAR_NBEST_LEN); |
| rec->context = NULL; |
| } |
| |
| static int check_parameter_range(int parval, int parmin, int parmax, const char* parname) |
| { |
| if (parval > parmax) |
| { |
| log_report("Error: %s value %d is out-of-range [%d,%d]\n", parname, |
| parval, parmin, parmax); |
| return 1; |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| int allocate_recognition(multi_srec *rec, |
| int viterbi_prune_thresh, /*score-based pruning threshold - only keep paths within this delta of best cost*/ |
| int max_hmm_tokens, |
| int max_fsmnode_tokens, |
| int max_word_tokens, |
| int max_altword_tokens, |
| int num_wordends_per_frame, |
| int max_fsm_nodes, |
| int max_fsm_arcs, |
| int max_frames, |
| int max_model_states, |
| int max_searches) |
| { |
| int i; |
| |
| if (check_parameter_range(max_fsm_nodes, 1, MAXnodeID, "max_fsm_nodes")) |
| return 1; |
| if (check_parameter_range(max_fsm_arcs, 1, MAXarcID, "max_fsm_arcs")) |
| return 1; |
| if (check_parameter_range(max_frames, 1, MAXframeID, "max_frames")) |
| return 1; |
| if (check_parameter_range(max_model_states, 1, MAXmodelID, "max_model_states")) |
| return 1; |
| if (check_parameter_range(max_hmm_tokens, 1, MAXstokenID, "max_hmm_tokens")) |
| return 1; |
| if (check_parameter_range(max_fsmnode_tokens, 1, MAXftokenID, "max_fsmnode_tokens")) |
| return 1; |
| if (check_parameter_range(viterbi_prune_thresh, 1, MAXcostdata, "viterbi_prune_thresh")) |
| return 1; |
| if (check_parameter_range(max_altword_tokens, 0, MAXftokenID, "max_altword_tokens")) |
| return 1; |
| if (check_parameter_range(max_searches, 1, 2, "max_searches")) |
| return 1; |
| |
| rec->rec = (srec*)CALLOC_CLR(max_searches, sizeof(srec), "search.srec.base"); |
| rec->num_allocated_recs = max_searches; |
| rec->num_swimodels = 0; |
| |
| /* best_token_for_arc and best_token_for_node are shared across |
| multiple searches */ |
| rec->best_token_for_arc = (stokenID*)CALLOC_CLR(max_fsm_arcs, sizeof(stokenID), "search.srec.best_token_for_arc"); |
| rec->max_fsm_arcs = (arcID)max_fsm_arcs; |
| |
| rec->best_token_for_node = (ftokenID*)CALLOC_CLR(max_fsm_nodes, sizeof(ftokenID), "search.srec.best_token_for_node"); |
| rec->max_fsm_nodes = (nodeID)max_fsm_nodes; |
| |
| /* cost offsets and accumulated cost offsets are pooled for all |
| different searches, this saves memory and enables each search |
| to know it's total scores */ |
| rec->cost_offset_for_frame = (costdata*)CALLOC_CLR(max_frames, sizeof(costdata), "search.srec.current_best_costs"); |
| rec->accumulated_cost_offset = (bigcostdata*)CALLOC_CLR(max_frames, sizeof(bigcostdata), "search.srec.accumulated_cost_offset"); |
| rec->max_frames = (frameID)max_frames; |
| for (i = 0; i < max_frames; i++) |
| rec->accumulated_cost_offset[i] = 0; |
| |
| /* now copy the shared data down to individual recogs */ |
| for (i = 0; i < rec->num_allocated_recs; i++) |
| { |
| allocate_recognition1(&rec->rec[i], viterbi_prune_thresh, max_hmm_tokens, max_fsmnode_tokens, max_word_tokens, max_altword_tokens, num_wordends_per_frame, max_frames, max_model_states); |
| rec->rec[i].best_token_for_node = rec->best_token_for_node; |
| rec->rec[i].max_fsm_nodes = rec->max_fsm_nodes; |
| rec->rec[i].best_token_for_arc = rec->best_token_for_arc; |
| rec->rec[i].max_fsm_arcs = rec->max_fsm_arcs; |
| rec->rec[i].max_frames = rec->max_frames; |
| rec->rec[i].cost_offset_for_frame = rec->cost_offset_for_frame; |
| rec->rec[i].accumulated_cost_offset = rec->accumulated_cost_offset; |
| rec->rec[i].id = (asr_int16_t)i; |
| } |
| rec->eos_status = VALID_SPEECH_NOT_YET_DETECTED; |
| return 0; |
| } |
| |
| |
| static void free_recognition1(srec *rec) |
| { |
| FREE(rec->current_model_scores); |
| FREE(rec->fsmarc_token_array); |
| FREE(rec->word_token_array); |
| FREE(rec->word_token_array_flags); |
| FREE(rec->fsmnode_token_array); |
| FREE(rec->altword_token_array); |
| FREE(rec->best_model_cost_for_frame); |
| destroy_word_lattice(rec->word_lattice); |
| free_priority_q(rec->word_priority_q); |
| astar_stack_destroy(rec); |
| } |
| |
| void free_recognition(multi_srec *rec) |
| { |
| int i; |
| for (i = 0; i < rec->num_allocated_recs; i++) |
| free_recognition1(&rec->rec[i]); |
| FREE(rec->accumulated_cost_offset); |
| FREE(rec->cost_offset_for_frame); |
| FREE(rec->best_token_for_node); |
| FREE(rec->best_token_for_arc); |
| FREE(rec->rec); |
| } |
| |
