Esempio n. 1
0
        /// <summary>
        /// Adds a child node holding a pronunciation 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="pronunciation">the pronunciation to add</param>
        /// <param name="probability"></param>
        /// <returns>the node that holds the pronunciation (new or old)</returns>
        public WordNode AddSuccessor(Pronunciation pronunciation, float probability, HashMap <Pronunciation, WordNode> wordNodeMap)
        {
            WordNode child         = null;
            WordNode matchingChild = (WordNode)GetSuccessor(pronunciation);

            if (matchingChild == null)
            {
                child = wordNodeMap.Get(pronunciation);
                if (child == null)
                {
                    child = new WordNode(pronunciation, probability);
                    wordNodeMap.Put(pronunciation, child);
                }
                PutSuccessor(pronunciation, child);
            }
            else
            {
                if (matchingChild.UnigramProbability < probability)
                {
                    matchingChild.UnigramProbability = probability;
                }
                child = matchingChild;
            }
            return(child);
        }
Esempio n. 2
0
        /**
         * /// Gets the  set of hmm nodes associated with the given end node
         *
         * /// @param endNode the end node
         * /// @return an array of associated hmm nodes
         */
        public HMMNode[] GetHMMNodes(EndNode endNode)
        {
            HMMNode[] results = _endNodeMap.Get(endNode.Key);
            if (results == null)
            {
                // System.out.println("Filling cache for " + endNode.getKey()
                //        + " size " + endNodeMap.size());
                HashMap <IHMM, HMMNode> resultMap = new HashMap <IHMM, HMMNode>();
                Unit baseUnit = endNode.BaseUnit;
                Unit lc       = endNode.LeftContext;
                foreach (Unit rc in EntryPoints)
                {
                    IHMM    hmm     = HMMPool.GetHMM(baseUnit, lc, rc, HMMPosition.End);
                    HMMNode hmmNode = resultMap.Get(hmm);
                    if (hmmNode == null)
                    {
                        hmmNode = new HMMNode(hmm, LogMath.LogOne);
                        resultMap.Add(hmm, hmmNode);
                    }
                    hmmNode.AddRC(rc);
                    foreach (Node node in endNode.GetSuccessors())
                    {
                        WordNode wordNode = (WordNode)node;
                        hmmNode.AddSuccessor(wordNode);
                    }
                }

                // cache it
                results = resultMap.Values.ToArray();
                _endNodeMap.Add(endNode.Key, results);
            }

            // System.out.println("GHN: " + endNode + " " + results.length);
            return(results);
        }
Esempio n. 3
0
        /**
         * /// Adds the given pronunciation to the lex tree
         *
         * /// @param pronunciation the pronunciation
         * /// @param probability   the unigram probability
         */
        private void AddPronunciation(Pronunciation pronunciation, float probability)
        {
            Unit     baseUnit;
            Unit     lc;
            Unit     rc;
            Node     curNode;
            WordNode wordNode;

            Unit[] units = pronunciation.Units;
            baseUnit = units[0];
            EntryPoint ep = _entryPointTable.GetEntryPoint(baseUnit);

            ep.AddProbability(probability);

            if (units.Length > 1)
            {
                curNode = ep.Node;
                lc      = baseUnit;
                for (int i = 1; i < units.Length - 1; i++)
                {
                    baseUnit = units[i];
                    rc       = units[i + 1];
                    IHMM hmm = HMMPool.GetHMM(baseUnit, lc, rc, HMMPosition.Internal);
                    if (hmm == null)
                    {
                        if (_debug)
                        {
                            Trace.TraceError("Missing HMM for unit " + baseUnit.Name + " with lc=" + lc.Name + " rc=" + rc.Name);
                        }
                    }
                    else
                    {
                        curNode = curNode.AddSuccessor(hmm, probability);
                    }
                    lc = baseUnit;          // next lc is this baseUnit
                }

                // now add the last unit as an end unit
                baseUnit = units[units.Length - 1];
                EndNode endNode = new EndNode(baseUnit, lc, probability);
                curNode  = curNode.AddSuccessor(endNode, probability);
                wordNode = curNode.AddSuccessor(pronunciation, probability, WordNodeMap);
                if (wordNode.GetWord().IsSentenceEndWord)
                {
                    sentenceEndWordNode = wordNode;
                }
            }
            else
            {
                ep.AddSingleUnitWord(pronunciation);
            }
        }
Esempio n. 4
0
 /**
  * /// 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!");
     //}
 }
Esempio n. 5
0
        /**
         * /// Returns the list of successors to this state
         *
         * /// @return a list of SearchState objects
         */

        public override ISearchStateArc[] GetSuccessors()
        {
            ISearchStateArc[] arcs = GetCachedArcs();
            if (arcs == null)
            {
                arcs = LexTreeLinguist.EmptyArc;
                WordNode wordNode = (WordNode)GetNode();

                if (wordNode.GetWord() != Parent.SentenceEndWord)
                {
                    int         index = 0;
                    List <Node> list  = new List <Node>();
                    Unit[]      rc    = _lastNode.GetRC();
                    Unit        left  = wordNode.LastUnit;

                    foreach (Unit unit in rc)
                    {
                        Node[] epList = Parent.HMMTree.GetEntryPoint(left, unit);
                        foreach (Node n in epList)
                        {
                            list.Add(n);
                        }
                    }

                    //this.LogDebug("NodeList: {0}",list.Count);

                    //    add a link to every possible entry point as well
                    //    as link to the </s> node
                    arcs = new ISearchStateArc[list.Count + 1];
                    foreach (Node node in list)
                    {
                        arcs[index++] = CreateUnitStateArc((HMMNode)node, this);
                    }

                    //    now add the link to the end of sentence arc:

                    arcs[index++] = CreateWordStateArc(Parent.HMMTree.SentenceEndWordNode, _lastNode, this);
                }
                PutCachedArcs(arcs);
            }
            return(arcs);
        }
Esempio n. 6
0
        /**
         * /// 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));
        }
Esempio n. 7
0
 /// <summary>
 /// add a WordNode succesor
 /// </summary>
 /// <param name="wordNode"></param>
 public void AddSuccessor(WordNode wordNode)
 {
     PutSuccessor(wordNode, wordNode);
 }