internal void logAccumulate(float[] array, float num, LogMath logMath) { if (!Buffer.assertionsDisabled && this.numerator == null) { throw new AssertionError(); } if (!Buffer.assertionsDisabled && array == null) { throw new AssertionError(); } if (!Buffer.assertionsDisabled && this.numerator.Length != array.Length) { throw new AssertionError(); } if (!Buffer.assertionsDisabled && !this.isLog) { throw new AssertionError(); } for (int i = 0; i < this.numerator.Length; i++) { this.numerator[i] = (double)logMath.addAsLinear((float)this.numerator[i], array[i]); } this.denominator = (double)logMath.addAsLinear((float)this.denominator, num); this._wasUsed = true; }
internal void logAccumulate(float num, int num2, LogMath logMath) { if (!Buffer.assertionsDisabled && this.numerator == null) { throw new AssertionError(); } if (!Buffer.assertionsDisabled && !this.isLog) { throw new AssertionError(); } this.numerator[num2] = (double)logMath.addAsLinear((float)this.numerator[num2], num); this.denominator = (double)logMath.addAsLinear((float)this.denominator, num); this._wasUsed = true; }
internal void logNormalizeToSum(LogMath logMath) { if (!Buffer.assertionsDisabled && !this.isLog) { throw new AssertionError(); } float minValue = float.MinValue; float num = minValue; double[] array = this.numerator; int num2 = array.Length; for (int i = 0; i < num2; i++) { double num3 = array[i]; if (num3 != (double)minValue) { num = logMath.addAsLinear(num, (float)num3); } } for (int j = 0; j < this.numerator.Length; j++) { if (this.numerator[j] != (double)minValue) { double[] array2 = this.numerator; int num4 = j; double[] array3 = array2; array3[num4] -= (double)num; } } this.denominator = (double)0f; }
/** * Calculate the sum of posteriors in this cluster. * * @param cluster the cluster to sum over * @return the probability sum */ protected double clusterProbability(LinkedList <Node> cluster) { float p = LogMath.LOG_ZERO; LogMath logMath = LogMath.getLogMath(); foreach (Node node in cluster) { p = logMath.addAsLinear(p, (float)node.getPosterior()); } return(p); }
protected internal override float calculateScore(Data data) { float num = float.MinValue; LogMath logMath = LogMath.getLogMath(); float[] array = this.calculateComponentScore(data); int num2 = array.Length; for (int i = 0; i < num2; i++) { Float @float = Float.valueOf(array[i]); num = logMath.addAsLinear(num, @float.floatValue()); } return(num); }
/** * Calculate the distance between two clusters * * @param c1 the first cluster * @param c2 the second cluster * @return the inter cluster similarity, or Double.NEGATIVE_INFINITY if these clusters should never be clustered * together. */ protected double interClusterDistance(Cluster c1, Cluster c2) { if (areClustersInRelation(c1, c2)) { return(Double.NegativeInfinity); } float totalSim = LogMath.LOG_ZERO; float wordPairCount = (float)0.0; HashSet <String> wordsSeen1 = new HashSet <String>(); LogMath logMath = LogMath.getLogMath(); foreach (Node node1 in c1.getElements()) { String word1 = node1.getWord().getSpelling(); if (wordsSeen1.Contains(word1)) { continue; } wordsSeen1.Add(word1); HashSet <String> wordsSeen2 = new HashSet <String>(); foreach (Node node2 in c2.getElements()) { String word2 = node2.getWord().getSpelling(); if (wordsSeen2.Contains(word2)) { continue; } wordsSeen2.Add(word2); float sim = (float)computePhoneticSimilarity(node1, node2); sim = logMath.linearToLog(sim); sim += (float)wordSubClusterProbability(c1, word1); sim += (float)wordSubClusterProbability(c2, word2); totalSim = logMath.addAsLinear(totalSim, sim); wordPairCount++; } } return(totalSim - logMath.logToLinear(wordPairCount)); }
public override void allocate() { this.vocabulary.clear(); this.logProbs.clear(); this.logBackoffs.clear(); HashMap hashMap = new HashMap(); HashMap hashMap2 = new HashMap(); HashMap hashMap3 = new HashMap(); int num = 0; Iterator iterator = this.sentences.iterator(); while (iterator.hasNext()) { string text = (string)iterator.next(); string[] array = String.instancehelper_split(text, "\\s+"); ArrayList arrayList = new ArrayList(); arrayList.add(this.dictionary.getSentenceStartWord()); string[] array2 = array; int num2 = array2.Length; for (int i = 0; i < num2; i++) { string text2 = array2[i]; if (String.instancehelper_length(text2) != 0) { this.vocabulary.add(text2); Word word = this.dictionary.getWord(text2); if (word == null) { arrayList.add(Word.__UNKNOWN); } else { arrayList.add(word); } } } arrayList.add(this.dictionary.getSentenceEndWord()); if (arrayList.size() > 0) { HashMap hashMap4 = hashMap; this.addSequence(hashMap4, new WordSequence(new Word[] { (Word)arrayList.get(0) })); num++; } if (arrayList.size() > 1) { num++; HashMap hashMap5 = hashMap; this.addSequence(hashMap5, new WordSequence(new Word[] { (Word)arrayList.get(1) })); HashMap hashMap6 = hashMap2; this.addSequence(hashMap6, new WordSequence(new Word[] { (Word)arrayList.get(0), (Word)arrayList.get(1) })); } for (int j = 2; j < arrayList.size(); j++) { num++; HashMap hashMap7 = hashMap; this.addSequence(hashMap7, new WordSequence(new Word[] { (Word)arrayList.get(j) })); HashMap hashMap8 = hashMap2; this.addSequence(hashMap8, new WordSequence(new Word[] { (Word)arrayList.get(j - 1), (Word)arrayList.get(j) })); HashMap hashMap9 = hashMap3; this.addSequence(hashMap9, new WordSequence(new Word[] { (Word)arrayList.get(j - 2), (Word)arrayList.get(j - 1), (Word)arrayList.get(j) })); } } float num3 = 0.5f; float num4 = 1f - num3; HashMap hashMap10 = new HashMap(); Iterator iterator2 = hashMap.entrySet().iterator(); while (iterator2.hasNext()) { Map.Entry entry = (Map.Entry)iterator2.next(); hashMap10.put(entry.getKey(), Float.valueOf((float)((Integer)entry.getValue()).intValue() * num4 / (float)num)); } LogMath logMath = LogMath.getLogMath(); float num5 = logMath.linearToLog((double)this.unigramWeight); float num6 = logMath.linearToLog((double)(1f - this.unigramWeight)); float num7 = -logMath.linearToLog((double)hashMap10.size()); TreeSet treeSet = new TreeSet(hashMap.keySet()); Iterator iterator3 = new TreeSet(hashMap2.keySet()).iterator(); WordSequence wordSequence = (!iterator3.hasNext()) ? null : ((WordSequence)iterator3.next()); Iterator iterator4 = treeSet.iterator(); while (iterator4.hasNext()) { WordSequence wordSequence2 = (WordSequence)iterator4.next(); float num8 = logMath.linearToLog((double)((Float)hashMap10.get(wordSequence2)).floatValue()); num8 += num5; num8 = logMath.addAsLinear(num8, num7 + num6); this.logProbs.put(wordSequence2, Float.valueOf(num8)); float num9 = 0f; while (wordSequence != null) { int num10 = wordSequence.getOldest().compareTo(wordSequence2); if (num10 > 0) { break; } if (num10 == 0) { num9 += ((Float)hashMap10.get(wordSequence.getNewest())).floatValue(); } wordSequence = ((!iterator3.hasNext()) ? null : ((WordSequence)iterator3.next())); } this.logBackoffs.put(wordSequence2, Float.valueOf(logMath.linearToLog((double)(num3 / (1f - num9))))); } HashMap hashMap11 = new HashMap(); Iterator iterator5 = hashMap2.entrySet().iterator(); while (iterator5.hasNext()) { Map.Entry entry2 = (Map.Entry)iterator5.next(); int num11 = ((Integer)hashMap.get(((WordSequence)entry2.getKey()).getOldest())).intValue(); hashMap11.put(entry2.getKey(), Float.valueOf((float)((Integer)entry2.getValue()).intValue() * num4 / (float)num11)); } TreeSet treeSet2 = new TreeSet(hashMap2.keySet()); iterator3 = new TreeSet(hashMap3.keySet()).iterator(); wordSequence = ((!iterator3.hasNext()) ? null : ((WordSequence)iterator3.next())); Iterator iterator6 = treeSet2.iterator(); while (iterator6.hasNext()) { WordSequence wordSequence3 = (WordSequence)iterator6.next(); this.logProbs.put(wordSequence3, Float.valueOf(logMath.linearToLog((double)((Float)hashMap11.get(wordSequence3)).floatValue()))); float num12 = 0f; while (wordSequence != null) { int num13 = wordSequence.getOldest().compareTo(wordSequence3); if (num13 > 0) { break; } if (num13 == 0) { num12 += ((Float)hashMap11.get(wordSequence.getNewest())).floatValue(); } wordSequence = ((!iterator3.hasNext()) ? null : ((WordSequence)iterator3.next())); } this.logBackoffs.put(wordSequence3, Float.valueOf(logMath.linearToLog((double)(num3 / (1f - num12))))); } iterator6 = hashMap3.entrySet().iterator(); while (iterator6.hasNext()) { Map.Entry entry3 = (Map.Entry)iterator6.next(); float num12 = (float)((Integer)entry3.getValue()).intValue() * num4; num12 /= (float)((Integer)hashMap2.get(((WordSequence)entry3.getKey()).getOldest())).intValue(); this.logProbs.put(entry3.getKey(), Float.valueOf(logMath.linearToLog((double)num12))); } }
/** * /// Compute the utterance-level posterior for every node in the lattice, i.e. the probability that this node occurs * /// on any path through the lattice. Uses a forward-backward algorithm specific to the nature of non-looping * /// left-to-right lattice structures. * /// <p/> * /// Node posteriors can be retrieved by calling getPosterior() on Node objects. * * /// @param languageModelWeightAdjustment the weight multiplier that will be applied to language score already scaled by language weight * /// @param useAcousticScoresOnly use only the acoustic scores to compute the posteriors, ignore the language weight * /// and scores */ public void computeNodePosteriors(float languageModelWeightAdjustment, Boolean useAcousticScoresOnly) { if (initialNode == null) { return; } //forward initialNode.setForwardScore(LogMath.LOG_ONE); initialNode.setViterbiScore(LogMath.LOG_ONE); List <Node> sortedNodes = sortNodes(); Trace.Assert(sortedNodes[0] == initialNode); foreach (Node currentNode in sortedNodes) { foreach (Edge edge in currentNode.getLeavingEdges()) { double forwardProb = edge.getFromNode().getForwardScore(); double edgeScore = computeEdgeScore (edge, languageModelWeightAdjustment, useAcousticScoresOnly); forwardProb += edgeScore; edge.getToNode().setForwardScore (logMath.addAsLinear ((float)forwardProb, (float)edge.getToNode().getForwardScore())); double vs = edge.getFromNode().getViterbiScore() + edgeScore; if (edge.getToNode().getBestPredecessor() == null || vs > edge.getToNode().getViterbiScore()) { edge.getToNode().setBestPredecessor(currentNode); edge.getToNode().setViterbiScore(vs); } } } //backward terminalNode.setBackwardScore(LogMath.LOG_ONE); Trace.Assert(sortedNodes[sortedNodes.Count - 1] == terminalNode); int n = sortedNodes.Count - 1; while (n > 0) { Node currentNode = sortedNodes[n - 1]; List <Edge> currentEdges = currentNode.getLeavingEdges(); foreach (Edge edge in currentEdges) { double backwardProb = edge.getToNode().getBackwardScore(); backwardProb += computeEdgeScore (edge, languageModelWeightAdjustment, useAcousticScoresOnly); edge.getFromNode().setBackwardScore (logMath.addAsLinear((float)backwardProb, (float)edge.getFromNode().getBackwardScore())); } } //inner double normalizationFactor = terminalNode.getForwardScore(); foreach (Node node in nodes.Values) { node.setPosterior((node.getForwardScore() + node.getBackwardScore()) - normalizationFactor); } }