/** * /// Replaces an old token with a new token * * /// @param oldToken the token to replace (or null in which case, replace works like add). * /// @param newToken the new token to be placed in the list. */ //public override void replace(Token oldToken, Token newToken) //{ // ActiveList activeList = findListFor(oldToken); // Debug.Assert(activeList != null); // activeList.replace(oldToken, newToken); //} /** * /// Returns the emitting ActiveList from the manager * * /// @return the emitting ActiveList */ public override ActiveList GetEmittingList() { ActiveList list = CurrentActiveLists[CurrentActiveLists.Length - 1]; this.LogDebug("Returning a list of size :{0}", list.Size); return(list); }
/** * /// Performs the recognition for the given number of frames. * * /// @param nFrames the number of frames to recognize * /// @return the current result or null if there is no Result (due to the lack of frames to recognize) */ public override Result Recognize(int nFrames) { bool done = false; Result result = null; StreamEnd = false; for (int i = 0; i < nFrames && !done; i++) { done = Recognize(); } // generate a new temporary result if the current token is based on a final search state // remark: the first check for not null is necessary in cases that the search space does not contain scoreable tokens. if (ActiveList.GetBestToken() != null) { // to make the current result as correct as possible we undo the last search graph expansion here ActiveList fixedList = UndoLastGrowStep(); // Now create the result using the fixed active-list. if (!StreamEnd) { result = new Result(fixedList, ResultList, CurrentFrameNumber, done, false); } } if (_showTokenCount) { ShowTokenCount(); } return(result); }
/// <summary> /// Keeps track of and reports all of the active word histories for the given active list. /// </summary> /// <param name="activeList">The active list to track.</param> private void MonitorWords(ActiveList activeList) { // WordTracker tracker1 = new WordTracker(currentFrameNumber); // // for (Token t : activeList) { // tracker1.add(t); // } // tracker1.dump(); // // TokenTracker tracker2 = new TokenTracker(); // // for (Token t : activeList) { // tracker2.add(t); // } // tracker2.dumpSummary(); // tracker2.dumpDetails(); // // TokenTypeTracker tracker3 = new TokenTypeTracker(); // // for (Token t : activeList) { // tracker3.add(t); // } // tracker3.dump(); // StateHistoryTracker tracker4 = new StateHistoryTracker(currentFrameNumber); // for (Token t : activeList) { // tracker4.add(t); // } // tracker4.dump(); }
/// <summary> /// Calculate the acoustic scores for the active list. The active list should contain only emitting tokens. /// </summary> /// <returns><code>true</code> if there are more frames to score, otherwise, false</returns> protected bool ScoreTokens() { ScoreTimer.Start(); var data = Scorer.CalculateScores(ActiveList.GetTokens()); this.LogDebug("Scored Data: {0}", data); ScoreTimer.Stop(); Token bestToken = null; if (data is Token) { bestToken = (Token)data; } else if (data == null) { StreamEnd = true; } var moreTokens = (bestToken != null); ActiveList.SetBestToken(bestToken); //monitorWords(activeList); MonitorStates(ActiveList); this.LogDebug("bestToken: {0}", bestToken); CurTokensScored.Value += ActiveList.Size; TotalTokensScored.Value += ActiveList.Size; return(moreTokens); }
/// <summary> /// Goes through the active list of tokens and expands each token, /// finding the set of successor tokens until all the successor tokens are emitting tokens. /// </summary> protected void GrowBranches() { GrowTimer.Start(); var relativeBeamThreshold = ActiveList.GetBeamThreshold(); //this.LogInfo("Frame: " + currentFrameNumber // + " thresh : " + relativeBeamThreshold + " bs " // + activeList.getBestScore() + " tok " // + activeList.getBestToken()); this.LogDebug("RelativeBeamThreshold: {0}", relativeBeamThreshold.ToString("R")); var tokenList = ActiveList; foreach (var token in tokenList) { if (token == null) { break; } if (token.Score >= relativeBeamThreshold && AllowExpansion(token)) { CollectSuccessorTokens(token); } } //this.LogDebug(string.Format("ActiveList:{0} ",activeList.Count())); GrowTimer.Stop(); }
/// <summary> /// Gets the initial grammar node from the linguist and creates a GrammarNodeToken. /// </summary> protected virtual void LocalStart() { var searchGraph = Linguist.SearchGraph; CurrentFrameNumber = 0; CurTokensScored.Value = 0; _numStateOrder = searchGraph.NumStateOrder; _activeListManager.SetNumStateOrder(_numStateOrder); if (BuildWordLattice) { LoserManager = new AlternateHypothesisManager(_maxLatticeEdges); } var state = searchGraph.InitialState; ActiveList = _activeListManager.GetEmittingList(); ActiveList.Add(new Token(state, CurrentFrameNumber)); ClearCollectors(); GrowBranches(); GrowNonEmittingBranches(); // tokenTracker.setEnabled(false); // tokenTracker.startUtterance(); }
/// <summary> /// Removes unpromising branches from the active list. /// </summary> protected void PruneBranches() { int startSize = ActiveList.Size; _pruneTimer.Start(); ActiveList = _pruner.Prune(ActiveList); _beamPruned.Value += startSize - ActiveList.Size; _pruneTimer.Stop(); }
/// <summary> /// Keeps track of and reports statistics about the number of active states. /// </summary> /// <param name="activeList">The active list of states.</param> protected void MonitorStates(ActiveList activeList) { _tokenSum += activeList.Size; _tokenCount++; if ((_tokenCount % 1000) == 0) { this.LogInfo("Average Tokens/State: " + (_tokenSum / _tokenCount)); } }
/// <summary> /// Gets the initial grammar node from the linguist and creates a GrammarNodeToken. /// </summary> protected void LocalStart() { CurrentFrameNumber = 0; _curTokensScored.Value = 0; ActiveList newActiveList = ActiveListFactory.NewInstance(); ISearchState state = Linguist.SearchGraph.InitialState; newActiveList.Add(new Token(state, CurrentFrameNumber)); ActiveList = newActiveList; GrowBranches(); }
/** * /// Adds the given token to the list * * /// @param token the token to add */ public override void Add(Token token) { ActiveList activeList = FindListFor(token); if (activeList == null) { throw new Exception("Cannot find ActiveList for " + token.SearchState.GetType().Name); } //this.LogDebug("Token '{0}' to activeList of Size {1}", token, activeList.size()); activeList.Add(token); }
/// <summary> /// Gets the initial grammar node from the linguist and creates a GrammarNodeToken /// </summary> protected override void LocalStart() { _currentFastMatchFrameNumber = 0; if (_loader is Sphinx3Loader && ((Sphinx3Loader)_loader).HasTiedMixtures()) { ((Sphinx3Loader)_loader).ClearGauScores(); } // prepare fast match active list FastmatchActiveList = _fastmatchActiveListFactory.NewInstance(); var fmInitState = _fastmatchLinguist.SearchGraph.InitialState; FastmatchActiveList.Add(new Token(fmInitState, _currentFastMatchFrameNumber)); CreateFastMatchBestTokenMap(); GrowFastmatchBranches(); _fastmatchStreamEnd = false; for (var i = 0; (i < _lookaheadWindow - 1) && !_fastmatchStreamEnd; i++) { FastMatchRecognize(); } base.LocalStart(); }
/// <summary> /// Goes through the fast match active list of tokens and expands each token, /// finding the set of successor tokens until all the successor tokens are emitting tokens. /// </summary> protected void GrowFastmatchBranches() { GrowTimer.Start(); var oldActiveList = FastmatchActiveList; FastmatchActiveList = _fastmatchActiveListFactory.NewInstance(); var fastmathThreshold = oldActiveList.GetBeamThreshold(); // TODO more precise range of baseIds, remove magic number var frameCiScores = new float[100]; Arrays.Fill(frameCiScores, -Float.MAX_VALUE); var frameMaxCiScore = -Float.MAX_VALUE; foreach (var token in oldActiveList) { var tokenScore = token.Score; if (tokenScore < fastmathThreshold) { continue; } // filling max ci scores array that will be used in general search // token score composing if (token.SearchState is PhoneHmmSearchState) { var baseId = ((PhoneHmmSearchState)token.SearchState).GetBaseId(); if (frameCiScores[baseId] < tokenScore) { frameCiScores[baseId] = tokenScore; } if (frameMaxCiScore < tokenScore) { frameMaxCiScore = tokenScore; } } CollectFastMatchSuccessorTokens(token); } _ciScores.Add(new FrameCiScores(frameCiScores, frameMaxCiScore)); GrowTimer.Stop(); }
/** * /// Goes through the active list of tokens and expands each token, finding the set of successor tokens until all the * /// successor tokens are emitting tokens. */ protected void GrowBranches() { int mapSize = ActiveList.Size * 10; if (mapSize == 0) { mapSize = 1; } GrowTimer.Start(); BestTokenMap = new HashMap <ISearchState, Token>(mapSize); ActiveList oldActiveList = ActiveList; ResultList = new List <Token>(); ActiveList = ActiveListFactory.NewInstance(); _threshold = oldActiveList.GetBeamThreshold(); _wordThreshold = oldActiveList.GetBestScore() + _logRelativeWordBeamWidth; foreach (Token token in oldActiveList) { CollectSuccessorTokens(token); } GrowTimer.Stop(); }
/// <summary> /// Collects the next set of emitting tokens from a token and accumulates them in the active or result lists /// </summary> /// <param name="token">The token to collect successors from be immediately expanded are placed. Null if we should always expand all nodes.</param> protected override void CollectSuccessorTokens(Token token) { // tokenTracker.add(token); // tokenTypeTracker.add(token); // If this is a final state, add it to the final list if (token.IsFinal) { ResultList.Add(GetResultListPredecessor(token)); return; } // if this is a non-emitting token and we've already // visited the same state during this frame, then we // are in a grammar loop, so we don't continue to expand. // This check only works properly if we have kept all of the // tokens (instead of skipping the non-word tokens). // Note that certain linguists will never generate grammar loops // (lextree linguist for example). For these cases, it is perfectly // fine to disable this check by setting keepAllTokens to false if (!token.IsEmitting && (KeepAllTokens && IsVisited(token))) { return; } var state = token.SearchState; var arcs = state.GetSuccessors(); var predecessor = GetResultListPredecessor(token); // For each successor // calculate the entry score for the token based upon the // predecessor token score and the transition probabilities // if the score is better than the best score encountered for // the SearchState and frame then create a new token, add // it to the lattice and the SearchState. // If the token is an emitting token add it to the list, // otherwise recursively collect the new tokens successors. var tokenScore = token.Score; var beamThreshold = ActiveList.GetBeamThreshold(); var stateProducesPhoneHmms = state is LexTreeNonEmittingHMMState || state is LexTreeWordState || state is LexTreeEndUnitState; foreach (var arc in arcs) { var nextState = arc.State; // prune states using lookahead heuristics if (stateProducesPhoneHmms) { if (nextState is LexTreeHmmState) { Float penalty; var baseId = ((LexTreeHmmState)nextState).HmmState.HMM.BaseUnit.BaseID; if ((penalty = _penalties.Get(baseId)) == null) { penalty = UpdateLookaheadPenalty(baseId); } if ((tokenScore + _lookaheadWeight * penalty) < beamThreshold) { continue; } } } if (_checkStateOrder) { CheckStateOrder(state, nextState); } // We're actually multiplying the variables, but since // these come in log(), multiply gets converted to add var logEntryScore = tokenScore + arc.GetProbability(); var bestToken = GetBestToken(nextState); if (bestToken == null) { var newBestToken = new Token(predecessor, nextState, logEntryScore, arc.InsertionProbability, arc.LanguageProbability, CurrentFrameNumber); TokensCreated.Value++; SetBestToken(newBestToken, nextState); ActiveListAdd(newBestToken); } else if (bestToken.Score < logEntryScore) { // System.out.println("Updating " + bestToken + " with " + // newBestToken); var oldPredecessor = bestToken.Predecessor; bestToken.Update(predecessor, nextState, logEntryScore, arc.InsertionProbability, arc.LanguageProbability, CurrentFrameNumber); if (BuildWordLattice && nextState is IWordSearchState) { LoserManager.AddAlternatePredecessor(bestToken, oldPredecessor); } } else if (BuildWordLattice && nextState is IWordSearchState) { if (predecessor != null) { LoserManager.AddAlternatePredecessor(bestToken, predecessor); } } } }
/** * /// Dumps out debugging info for the given active list * * /// @param al the active list to dump */ private void DumpList(ActiveList al) { this.LogInfo("Size: " + al.Size + " Best token: " + al.GetBestToken()); }
/** * /// Clears emitting list in manager */ public override void ClearEmittingList() { ActiveList list = CurrentActiveLists[CurrentActiveLists.Length - 1]; CurrentActiveLists[CurrentActiveLists.Length - 1] = list.NewInstance(); }
/// <summary> /// Removes unpromising branches from the fast match active list. /// </summary> protected void PruneFastMatchBranches() { PruneTimer.Start(); FastmatchActiveList = Pruner.Prune(FastmatchActiveList); PruneTimer.Stop(); }