/// <summary> /// Puts the probability into the map. /// </summary> /// <param name="wordSequence">The tag for the prob.</param> /// <param name="logProb">The probability in log math base.</param> /// <param name="logBackoff">The backoff probability in log math base.</param> private void Put(WordSequence wordSequence, float logProb, float logBackoff) { // System.out.println("Putting " + wordSequence + " p " + logProb // + " b " + logBackoff); Java.Put(_map, wordSequence, new Probability(logProb, logBackoff)); Java.Add(_tokens, wordSequence); }
/** * Returns the NGrams of the given word sequence * * @param wordSequence the word sequence from which to get the buffer * @return the NGramBuffer of the word sequence */ private NGramBuffer GetNGramBuffer(WordSequence wordSequence) { NGramBuffer nGramBuffer = null; var order = wordSequence.Size; if (order > 1) { nGramBuffer = _loadedNGramBuffers[order - 1].Get(wordSequence); // better } // when // using // containsKey if (nGramBuffer == null) { nGramBuffer = LoadNGramBuffer(wordSequence); if (nGramBuffer != null) { Java.Put(_loadedNGramBuffers[order - 1], wordSequence, nGramBuffer); // optimizable } // by // adding // an // 'empty' // nGramBuffer } return(nGramBuffer); }
/** * /// Create the entry point table give the set of all possible entry point units * * /// @param entryPointCollection the set of possible entry points */ public EntryPointTable(IEnumerable <Unit> entryPointCollection, HMMTree parent) { _entryPoints = new Dictionary <Unit, EntryPoint>(); foreach (var unit in entryPointCollection) { Java.Put(_entryPoints, unit, new EntryPoint(unit, parent)); } }
/// <summary> /// Add a word hypothesis to this confusion set. /// </summary> /// <param name="word">The hypothesis to add.</param> public void AddWordHypothesis(WordResult word) { var wordSet = GetWordSet(word.GetConfidence()); if (wordSet == null) { wordSet = new HashSet <WordResult>(); Java.Put(this, word.GetConfidence(), wordSet); } wordSet.Add(word); }
/// <summary> ///Purge all but max number of alternate preceding token hypotheses. /// </summary> public void Purge() { int max = _maxEdges - 1; foreach (var entry in _viterbiLoserMap.ToList()) { List <Token> list = entry.Value; list.Sort(new ScoreableComparator()); List <Token> newList = list.GetRange(0, list.Count > max ? max : list.Count); Java.Put(_viterbiLoserMap, entry.Key, newList); } }
/// <summary> /// A version of createEntryPointMap that compresses common hmms across all entry points. /// </summary> public void CreateEntryPointMap() { Dictionary <IHMM, Node> map = new Dictionary <IHMM, Node>(); Dictionary <IHMM, HMMNode> singleUnitMap = new Dictionary <IHMM, HMMNode>(); foreach (Unit lc in _parent.ExitPoints) { Node epNode = new Node(LogMath.LogZero); foreach (Unit rc in GetEntryPointRC()) { IHMM hmm = _parent.HMMPool.GetHMM(BaseUnit, lc, rc, HMMPosition.Begin); if (hmm == null) { continue; } Node addedNode = null; if (map.ContainsKey(hmm)) { addedNode = map[hmm]; } if (addedNode == null) { addedNode = epNode.AddSuccessor(hmm, Probability); map.Add(hmm, addedNode); } else { epNode.PutSuccessor(hmm, addedNode); } nodeCount++; ConnectEntryPointNode(addedNode, rc); } ConnectSingleUnitWords(lc, epNode, singleUnitMap); Java.Put(UnitToEntryPointMap, lc, epNode); } }
/// <summary> /// Returns the next Data object, which is usually a window of the input Data, with the windowing function applied to /// it. /// </summary> /// <returns>the next available Data object, returns null if no Data object is available</returns> public override IData GetData() { if (_outputQueue.Count == 0) { var input = Predecessor.GetData(); if (input != null) { if (input is DoubleData) { var data = (DoubleData)input; // System.err.print("to windower: "); // System.err.println(Arrays.toString(data.getValues())); if (_currentFirstSampleNumber == -1) { _currentFirstSampleNumber = data.FirstSampleNumber; } // should not be necessary if all DataProcessor would forward Signals. Unfortunately this // is currently not the case. CreateWindow(data.SampleRate); // process the Data, and output the windows Process(data); } else { if (input is DataStartSignal) { var startSignal = (DataStartSignal)input; CreateWindow(startSignal.SampleRate); // attach the frame-length and the shift-length to the start-signal to allow // detection of incorrect frontend settings var props = startSignal.GetProps(); Java.Put(props, WindowShiftSamples, _windowShift); Java.Put(props, WindowSizeSamples, _cosineWindow.Length); // reset the current first sample number _currentFirstSampleNumber = -1; } else if (input is SpeechStartSignal) { // reset the current first sample number _currentFirstSampleNumber = -1; } else if (input is DataEndSignal || input is SpeechEndSignal) { // end of utterance handling ProcessUtteranceEnd(); } _outputQueue.Add(input); } } } if (_outputQueue.Count != 0) { var output = _outputQueue[0]; _outputQueue.RemoveAt(0); if (output is DoubleData) { Debug.Assert(((DoubleData)output).Values.Length == _cosineWindow.Length); } return(output); } return(null); }
public static void TagAsVadStream(DataStartSignal dsSignal) { Java.Put(dsSignal.GetProps(), SpeechTaggedFeatureStream, true); //dsSignal.getProps().Add(, true); }
/** Add a new RuleGrammar comment. */ public void AddRuleDocComment(String rname, String comment) { Java.Put(_ruleDocComments, rname, comment); }
/** Add a new import comment. */ public void AddImportDocComment(JSGFRuleName imp, String comment) { Java.Put(_importDocComments, imp.ToString(), comment); }
/// <summary> /// Initializes a new instance of the <see cref="HMMPool"/> class. /// </summary> /// <param name="model">The model to use for the pool</param> /// <param name="unitManager">The unit manager.</param> /// <exception cref="System.Exception"> /// LexTreeLinguist: Unsupported left context size /// or /// LexTreeLinguist: Unsupported right context size /// </exception> public HMMPool(AcousticModel model, UnitManager unitManager) { var maxCiUnits = 0; this.Model = model; this._unitManager = unitManager; TimerPool.GetTimer(this, "Build HMM Pool").Start(); if (model.GetLeftContextSize() != 1) { throw new Exception("LexTreeLinguist: Unsupported left context size"); } if (model.GetRightContextSize() != 1) { throw new Exception("LexTreeLinguist: Unsupported right context size"); } // count CI units: var i = model.GetContextIndependentUnitIterator(); while (i.MoveNext()) { var unit = i.Current; //this.LogInfo("CI unit " + unit); if (unit.BaseID > maxCiUnits) { maxCiUnits = unit.BaseID; } } NumCiUnits = maxCiUnits + 1; _unitTable = new Unit[NumCiUnits * NumCiUnits * NumCiUnits]; var iHMM = model.GetHMMIterator(); while (iHMM.MoveNext()) { var hmm = iHMM.Current; var unit = hmm.Unit; var id = GetId(unit); _unitTable[id] = unit; //this.LogInfo("Unit " + unit + " id " + id); } // build up the hmm table to allow quick access to the hmms _hmmTable = new Dictionary <HMMPosition, IHMM[]>(); foreach (HMMPosition position in Enum.GetValues(typeof(HMMPosition))) { var hmms = new IHMM[_unitTable.Length]; Java.Put(_hmmTable, position, hmms); //hmmTable.Put(position, hmms); for (var j = 1; j < _unitTable.Length; j++) { var unit = _unitTable[j]; if (unit == null) { unit = SynthesizeUnit(j); } if (unit != null) { hmms[j] = model.LookupNearestHMM(unit, position, false); Debug.Assert(hmms[j] != null); } } } TimerPool.GetTimer(this, "Build HMM Pool").Stop(); }