private int expandWordNodes(int num) { Collection collection = this.nodes.values(); string[][] alts = new string[][] { new string[] { "<sil>" } }; Iterator iterator = collection.iterator(); while (iterator.hasNext()) { GrammarNode grammarNode = (GrammarNode)iterator.next(); if (grammarNode.getNumAlternatives() > 0) { num++; GrammarNode node = this.createGrammarNode(num, false); grammarNode.add(node, 0f); if (this.addOptionalSilence) { num++; GrammarNode grammarNode2 = this.createGrammarNode(num, alts); grammarNode.add(grammarNode2, 0f); grammarNode2.add(node, 0f); } this.expandedNodes.add(grammarNode); } } return(num); }
protected internal override GrammarNode createGrammar() { ExtendedStreamTokenizer extendedStreamTokenizer = new ExtendedStreamTokenizer(this.path, true); GrammarNode grammarNode = this.createGrammarNode("<sil>"); GrammarNode grammarNode2 = this.createGrammarNode(false); GrammarNode grammarNode3 = this.createGrammarNode("<sil>"); grammarNode3.setFinalNode(true); LinkedList linkedList = new LinkedList(); while (!extendedStreamTokenizer.isEOF()) { string @string; while ((@string = extendedStreamTokenizer.getString()) != null) { GrammarNode grammarNode4 = this.createGrammarNode(@string); linkedList.add(grammarNode4); } } grammarNode.add(grammarNode2, 0f); float logProbability = this.logMath.linearToLog((double)1f / (double)linkedList.size()); Iterator iterator = linkedList.iterator(); while (iterator.hasNext()) { GrammarNode grammarNode5 = (GrammarNode)iterator.next(); grammarNode2.add(grammarNode5, logProbability); grammarNode5.add(grammarNode3, 0f); if (this.isLooping) { grammarNode5.add(grammarNode2, 0f); } } return(grammarNode); }
private void addFillerWords() { HashSet hashSet = new HashSet(this.getGrammarNodes()); Word[] interWordFillers = this.getInterWordFillers(); if (interWordFillers.Length == 0) { return; } Iterator iterator = hashSet.iterator(); while (iterator.hasNext()) { GrammarNode grammarNode = (GrammarNode)iterator.next(); if (!grammarNode.isEmpty() && !grammarNode.getWord().isFiller()) { GrammarNode grammarNode2 = grammarNode.splitNode(this.maxIdentity + 1); this.add(grammarNode2); GrammarNode grammarNode3 = this.createGrammarNode(false); GrammarNode grammarNode4 = this.createGrammarNode(false); grammarNode4.add(grammarNode3, 0f); grammarNode4.add(grammarNode2, 0f); grammarNode.add(grammarNode3, 0f); Word[] array = interWordFillers; int num = array.Length; for (int i = 0; i < num; i++) { Word word = array[i]; GrammarNode grammarNode5 = this.createGrammarNode(this.maxIdentity + 1, word.getSpelling()); grammarNode3.add(grammarNode5, 0f); grammarNode5.add(grammarNode4, 0f); } } } }
private void addSilenceWords() { HashSet hashSet = new HashSet(this.getGrammarNodes()); Iterator iterator = hashSet.iterator(); while (iterator.hasNext()) { GrammarNode grammarNode = (GrammarNode)iterator.next(); if (!grammarNode.isEmpty() && !grammarNode.getWord().isFiller()) { GrammarNode grammarNode2 = this.createGrammarNode(this.maxIdentity + 1, this.dictionary.getSilenceWord().getSpelling()); GrammarNode grammarNode3 = grammarNode.splitNode(this.maxIdentity + 1); this.add(grammarNode3); grammarNode.add(grammarNode2, 0f); grammarNode2.add(grammarNode3, 0f); grammarNode2.add(grammarNode2, 0f); } } }
protected internal override GrammarNode createGrammar() { this.logger.info("Making Grammar"); this.initialNode = this.createGrammarNode("<sil>"); this.finalNode = this.createGrammarNode(true); GrammarNode grammarNode = this.initialNode; Iterator iterator = this.tokens.iterator(); while (iterator.hasNext()) { string word = (string)iterator.next(); GrammarNode grammarNode2 = this.createGrammarNode(word); GrammarNode grammarNode3 = this.createGrammarNode(false); GrammarNode grammarNode4 = this.createGrammarNode(false); grammarNode.add(grammarNode2, 0f); grammarNode.add(grammarNode3, 0f); grammarNode2.add(grammarNode4, 0f); grammarNode3.add(grammarNode4, 0f); grammarNode = grammarNode4; } grammarNode.add(this.finalNode, 0f); this.logger.info("Done making Grammar"); return(this.initialNode); }
protected internal override GrammarNode createGrammar() { if (this.lattice == null) { return(this.createGrammarNode("<s>")); } GrammarNode grammarNode = null; HashMap hashMap = new HashMap(); Iterator iterator = this.lattice.getNodes().iterator(); while (iterator.hasNext()) { Node node = (Node)iterator.next(); string word = node.getWord().toString(); GrammarNode grammarNode2 = this.createGrammarNode(word); if (node.equals(this.lattice.getInitialNode())) { grammarNode = grammarNode2; } if (node.equals(this.lattice.getTerminalNode())) { grammarNode2.setFinalNode(true); } hashMap.put(node, grammarNode2); } if (grammarNode == null) { string text = "No lattice start found"; throw new Error(text); } iterator = this.lattice.getEdges().iterator(); while (iterator.hasNext()) { Edge edge = (Edge)iterator.next(); float logProbability = (float)edge.getLMScore(); GrammarNode grammarNode2 = (GrammarNode)hashMap.get(edge.getFromNode()); GrammarNode node2 = (GrammarNode)hashMap.get(edge.getToNode()); grammarNode2.add(node2, logProbability); } return(grammarNode); }
protected internal virtual GrammarNode createForcedAlignerGrammar(GrammarNode iNode, GrammarNode fNode, string transcript) { StringTokenizer stringTokenizer = new StringTokenizer(transcript); GrammarNode grammarNode = null; GrammarNode grammarNode2 = null; while (stringTokenizer.hasMoreTokens()) { string word = stringTokenizer.nextToken(); GrammarNode grammarNode3 = grammarNode2; grammarNode2 = this.createGrammarNode(word); if (grammarNode == null) { grammarNode = grammarNode2; } if (grammarNode3 != null) { grammarNode3.add(grammarNode2, 0f); } } iNode.add(grammarNode, 0f); grammarNode2.add(fNode, 0f); return(grammarNode); }
protected internal override GrammarNode createGrammar() { GrammarNode grammarNode = null; int num = this.createNodes(this.path); num++; GrammarNode grammarNode2 = this.createGrammarNode(num, "<sil>"); grammarNode2.setFinalNode(true); num = this.expandWordNodes(num); ExtendedStreamTokenizer extendedStreamTokenizer = new ExtendedStreamTokenizer(this.path, true); while (!extendedStreamTokenizer.isEOF()) { extendedStreamTokenizer.skipwhite(); string @string = extendedStreamTokenizer.getString(); if (@string == null) { break; } if (String.instancehelper_equals(@string, "I")) { if (!FSTGrammar.assertionsDisabled && grammarNode != null) { throw new AssertionError(); } int @int = extendedStreamTokenizer.getInt("initial ID"); string text = new StringBuilder().append("G").append(@int).toString(); grammarNode = this.createGrammarNode(@int, "<sil>"); this.nodes.put(text, grammarNode); if (this.addInitialSilenceNode) { num++; GrammarNode grammarNode3 = this.createGrammarNode(num, "<sil>"); grammarNode.add(grammarNode3, 0f); grammarNode3.add(grammarNode, 0f); } } else if (String.instancehelper_equals(@string, "T")) { int @int = extendedStreamTokenizer.getInt("this id"); int int2 = extendedStreamTokenizer.getInt("next id"); GrammarNode grammarNode3 = this.get(@int); GrammarNode grammarNode4 = this.get(int2); if (this.hasEndNode(grammarNode3)) { grammarNode3 = this.getEndNode(grammarNode3); } float num2 = 0f; string string2 = extendedStreamTokenizer.getString(); if (string2 == null || String.instancehelper_equals(string2, ",")) { if (string2 != null && String.instancehelper_equals(string2, ",")) { extendedStreamTokenizer.getString(); num2 = extendedStreamTokenizer.getFloat("probability"); } if (this.hasEndNode(grammarNode4)) { grammarNode4 = this.getEndNode(grammarNode4); } } else { string string3 = extendedStreamTokenizer.getString(); num2 = extendedStreamTokenizer.getFloat("probability"); if (String.instancehelper_equals(string3, "<unknown>")) { continue; } if (!FSTGrammar.assertionsDisabled && !this.hasWord(grammarNode4)) { throw new AssertionError(); } } grammarNode3.add(grammarNode4, this.convertProbability(num2)); } else if (String.instancehelper_equals(@string, "F")) { int @int = extendedStreamTokenizer.getInt("this id"); float @float = extendedStreamTokenizer.getFloat("probability"); GrammarNode grammarNode3 = this.get(@int); GrammarNode grammarNode4 = grammarNode2; if (this.hasEndNode(grammarNode3)) { grammarNode3 = this.getEndNode(grammarNode3); } grammarNode3.add(grammarNode4, this.convertProbability(@float)); } } extendedStreamTokenizer.close(); if (!FSTGrammar.assertionsDisabled && grammarNode == null) { throw new AssertionError(); } return(grammarNode); }
protected internal override GrammarNode createGrammar() { this.languageModel.allocate(); TimerPool.getTimer(this, "LMGrammar.create").start(); GrammarNode grammarNode = null; if (this.languageModel.getMaxDepth() > 2) { [email protected]("Warning: LMGrammar limited to bigrams"); } ArrayList arrayList = new ArrayList(); Set vocabulary = this.languageModel.getVocabulary(); Iterator iterator = vocabulary.iterator(); while (iterator.hasNext()) { string word = (string)iterator.next(); GrammarNode grammarNode2 = this.createGrammarNode(word); if (grammarNode2 != null && !grammarNode2.isEmpty()) { if (grammarNode2.getWord().equals(this.getDictionary().getSentenceStartWord())) { grammarNode = grammarNode2; } else if (grammarNode2.getWord().equals(this.getDictionary().getSentenceEndWord())) { grammarNode2.setFinalNode(true); } arrayList.add(grammarNode2); } } if (grammarNode == null) { string text = "No sentence start found in language model"; throw new Error(text); } iterator = arrayList.iterator(); while (iterator.hasNext()) { GrammarNode grammarNode3 = (GrammarNode)iterator.next(); if (!grammarNode3.isFinalNode()) { Iterator iterator2 = arrayList.iterator(); while (iterator2.hasNext()) { GrammarNode grammarNode4 = (GrammarNode)iterator2.next(); string spelling = grammarNode3.getWord().getSpelling(); string spelling2 = grammarNode4.getWord().getSpelling(); Word[] words = new Word[] { this.getDictionary().getWord(spelling), this.getDictionary().getWord(spelling2) }; float probability = this.languageModel.getProbability(new WordSequence(words)); grammarNode3.add(grammarNode4, probability); } } } TimerPool.getTimer(this, "LMGrammar.create").stop(); this.languageModel.deallocate(); return(grammarNode); }