/** * /// Constructs a LexTreeUnitState * * /// @param wordSequence the history of words */ public LexTreeUnitState(HMMNode hmmNode, WordSequence wordSequence, float smearTerm, float smearProb, float languageProbability, float insertionProbability, Node parentNode, LexTreeLinguist parent) : base(hmmNode, wordSequence, smearTerm, smearProb, parent) { _logInsertionProbability = insertionProbability; _logLanguageProbability = languageProbability; _parentNode = parentNode; _parent = parent; }
/** * /// Constructs a LexTreeWordState * * /// @param wordNode the word node * /// @param wordSequence the sequence of words triphone context * /// @param languageProbability the probability of this word */ public LexTreeWordState(WordNode wordNode, HMMNode lastNode, WordSequence wordSequence, float smearTerm, float smearProb, float languageProbability, LexTreeLinguist _parent) : base(wordNode, wordSequence, smearTerm, smearProb, _parent) { // Trace.WriteLine(string.Format("LexTreeWordState Created with values wordNode: {0}, lastNode: {1}, wordSequence: {2}, smearTerm: {3}, smearProb: {4}, languageProbability: {5}", // wordNode, lastNode, wordSequence, smearTerm, smearProb, languageProbability)); this._lastNode = lastNode; _logLanguageProbability = languageProbability; //if (wordNode.ToString().Contains("NSN")) //{ // this.LogInfo("FOUND NOISE!"); //} }
/// <summary> /// Connects the single unit words associated with this entry point. The singleUnitWords list contains all /// single unit pronunciations that have as their sole unit, the unit associated with this entry point. Entry /// points for these words are added to the epNode for all possible left (exit) and right (entry) contexts. /// </summary> /// <param name="lc">the left context</param> /// <param name="epNode">the entry point node</param> /// <param name="map"></param> private void ConnectSingleUnitWords(Unit lc, Node epNode, Dictionary <IHMM, HMMNode> map) { if (!_singleUnitWords.IsEmpty()) { foreach (Unit rc in _parent.EntryPoints) { IHMM hmm = _parent.HMMPool.GetHMM(BaseUnit, lc, rc, HMMPosition.Single); if (hmm == null) { continue; } HMMNode tailNode = null; if (hmm != null && map.ContainsKey(hmm)) { tailNode = map[hmm]; } if (tailNode == null) { tailNode = (HMMNode)epNode.AddSuccessor(hmm, Probability); map.Add(hmm, tailNode); } else { epNode.PutSuccessor(hmm, tailNode); } WordNode wordNode; tailNode.AddRC(rc); nodeCount++; foreach (Pronunciation p in _singleUnitWords) { if (p.Word == _parent.Dictionary.GetSentenceStartWord()) { _parent.InitialNode = new InitialWordNode(p, tailNode); } else { float prob = _parent.GetWordUnigramProbability(p.Word); wordNode = tailNode.AddSuccessor(p, prob, _parent.WordNodeMap); if (p.Word == _parent.Dictionary.GetSentenceEndWord()) { _parent.sentenceEndWordNode = wordNode; } } nodeCount++; } } } }
/** * /// Creates a word search state for the given word node * * /// @param wordNode the wordNode * * * /// @return the search state for the wordNode */ protected ISearchStateArc CreateWordStateArc(WordNode wordNode, HMMNode lastUnit, LexTreeState previous) { //TODO: UNCOMMENT DURING RELEASE //this.LogInfo("CWSA " + wordNode + " fup " /*+ fixupProb*/); float languageProbability = Parent.LogOne; Word nextWord = wordNode.GetWord(); float smearTerm = previous.SmearTerm; if (nextWord.IsFiller && !Equals(nextWord, Parent.SentenceEndWord)) { return(new LexTreeWordState(wordNode, lastUnit, _wordSequence, smearTerm, Parent.LogOne, languageProbability, Parent)); } WordSequence nextWordSequence = _wordSequence.AddWord(nextWord, Parent.MaxDepth); float probability = Parent.LanguageModel.GetProbability(nextWordSequence) * Parent.LanguageWeight; smearTerm = Parent.GetSmearTermFromLanguageModel(nextWordSequence); //this.LogInfo("LP " + nextWordSequence + " " /*+ logProbability*/); // subtract off the previously applied smear probability languageProbability = probability - previous.SmearProb; //Boolean collapse = (probability.depth < parent.maxDepth - 1) || !parent.fullWordHistories; if (Equals(nextWord, Parent.SentenceEndWord)) { return(new LexTreeEndWordState(wordNode, lastUnit, nextWordSequence.Trim(Parent.MaxDepth - 1), smearTerm, Parent.LogOne, languageProbability, Parent)); } return(new LexTreeWordState(wordNode, lastUnit, nextWordSequence.Trim(Parent.MaxDepth - 1), smearTerm, Parent.LogOne, languageProbability, Parent)); }
/** * /// Creates a unit search state for the given unit node * * /// @param hmmNode the unit node * * /// @return the search state */ public ISearchStateArc CreateUnitStateArc(HMMNode hmmNode, LexTreeState previous) { ISearchStateArc arc; float insertionProbability = Parent.CalculateInsertionProbability(hmmNode); float smearProbability = Parent.GetUnigramSmear(hmmNode) + previous.SmearTerm; float languageProbability = smearProbability - previous.SmearProb; //if we want a unit state create it, otherwise //get the first hmm state of the unit if (Parent.GenerateUnitStates) { arc = new LexTreeUnitState(hmmNode, WordHistory, previous.SmearTerm, smearProbability, languageProbability, insertionProbability, Parent); } else { IHMM hmm = hmmNode.HMM; arc = new LexTreeHmmState(hmmNode, WordHistory, previous.SmearTerm, smearProbability, hmm.GetInitialState(), languageProbability, insertionProbability, null, Parent); } return(arc); }
/// <summary> /// Adds a child node holding an hmm to the successor. If a node similar to the child has already been added, we use /// the previously added node, otherwise we add this. Also, we record the base unit of the child in the set of right /// context /// </summary> /// <param name="hmm">the hmm to add</param> /// <param name="probability"></param> /// <returns>the node that holds the hmm (new or old)</returns> public Node AddSuccessor(IHMM hmm, float probability) { if (hmm == null) { return(null); } Node child = null; Node matchingChild = GetSuccessor(hmm); if (matchingChild == null) { child = new HMMNode(hmm, probability); PutSuccessor(hmm, child); } else { if (matchingChild.UnigramProbability < probability) { matchingChild.UnigramProbability = probability; } child = matchingChild; } return(child); }
/// <summary> /// Creates an InitialWordNode /// </summary> /// <param name="pronunciation">the pronunciation</param> /// <param name="parent">the parent node</param> public InitialWordNode(Pronunciation pronunciation, HMMNode parent) : base(pronunciation, LogMath.LogOne) { _parent = parent; }