public void testMultinomial () { double[] c = new double[] {.2, .3, .1, .4}; Multinomial m = new Multinomial (c); assertTrue (m.probability (0) == .2); }
public Dirichlet estimate () { Dirichlet d = new Dirichlet (((Multinomial)multinomials.get(0)).size()); for (int i = 1; i < multinomials.size(); i++) ((Multinomial)multinomials.get(i)).addProbabilitiesTo(d.alphas); double alphaSum = 0; for (int i = 0; i < d.alphas.length; i++) alphaSum += d.alphas[i]; for (int i = 0; i < d.alphas.length; i++) d.alphas[i] /= alphaSum; // xxx Fix this to set sum by variance matching throw new UnsupportedOperationException ("Not yet implemented."); //return d; }
public Estimator (ArrayList multinomials) { this.multinomials = multinomials; for (int i = 1; i < multinomials.size(); i++) if (((Multinomial)multinomials.get(i-1)).size() != ((Multinomial)multinomials.get(i)).size() || ((Multinomial)multinomials.get(i-1)).getAlphabet() != ((Multinomial)multinomials.get(i)).getAlphabet()) throw new IllegalArgumentException ("All multinomials must have same size and Alphabet."); }
public void testEstimating () { Alphabet dict = new Alphabet (); Multinomial.Estimator e = new Multinomial.LaplaceEstimator (dict); FeatureSequence fs = new FeatureSequence (dict); fs.add (dict.lookupIndex ("a")); fs.add (dict.lookupIndex ("n")); fs.add (dict.lookupIndex ("d")); fs.add (dict.lookupIndex ("r")); fs.add (dict.lookupIndex ("e")); fs.add (dict.lookupIndex ("w")); fs.add (dict.lookupIndex ("m")); fs.add (dict.lookupIndex ("c")); fs.add (dict.lookupIndex ("c")); fs.add (dict.lookupIndex ("a")); fs.add (dict.lookupIndex ("l")); fs.add (dict.lookupIndex ("l")); fs.add (dict.lookupIndex ("u")); fs.add (dict.lookupIndex ("m")); //System.out.println (fs.toString()); e.increment (fs); assertTrue (e.size() == 10); Multinomial m = e.estimate (); assertTrue (m.size() == 10); assertTrue (m.probability (dict.lookupIndex ("a")) == (2.0+1)/(14.0+10)); assertTrue (m.probability ("w") == (1.0+1)/(14.0+10)); Multinomial.Logged ml = new Multinomial.Logged (m); assertTrue (m.logProbability ("w") == ml.logProbability ("w")); }
emissionEstimator[i] = new Multinomial.LaplaceEstimator(inputAlphabet); transitionEstimator[i] = new Multinomial.LaplaceEstimator(transitionAlphabet); emissionMultinomial[i] = new Multinomial (getUniformArray (inputAlphabet.size()), inputAlphabet); transitionMultinomial[i] = new Multinomial (getUniformArray (transitionAlphabet.size()), transitionAlphabet); emissionMultinomial[i] = emissionEstimator[i].estimate(); transitionMultinomial[i] = transitionEstimator[i].estimate(); getState (i).setInitialCost (-initialMultinomial.logProbability (getState(i).getName()));
public double logProbability (Object key) { if (dictionary == null) throw new IllegalStateException ("This Multinomial has no dictionary."); return logProbability (dictionary.lookupIndex (key)); }
public Multinomial randomMultinomial (Random r) { return new Multinomial (randomRawMultinomial(r), dict, alphas.length, false, false); }
public Object randomObject (Random r) { if (dictionary == null) throw new IllegalStateException ("This Multinomial has no dictionary."); return dictionary.lookupObject (randomIndex (r)); }
public FeatureSequence randomFeatureSequence (Random r, int length) { Multinomial m = randomMultinomial (r); return m.randomFeatureSequence (r, length); }
protected Multinomial (double[] probabilities, Alphabet dictionary, int size, boolean copy, boolean checkSum) { super (dictionary, getValues(probabilities, dictionary, size, copy, checkSum)); }
public double probability (Object key) { if (dictionary == null) throw new IllegalStateException ("This Multinomial has no dictionary."); return probability (dictionary.lookupIndex (key)); }
public void print () { StringBuffer sb = new StringBuffer(); for (int i = 0; i < numStates(); i++) { State s = (State) getState (i); sb.append ("STATE NAME=\""); sb.append (s.name); sb.append ("\" ("); sb.append (s.destinations.length); sb.append (" outgoing transitions)\n"); sb.append (" "); sb.append ("initialCost = "); sb.append (s.initialCost); sb.append ('\n'); sb.append (" "); sb.append ("finalCost = "); sb.append (s.finalCost); sb.append ('\n'); sb.append ("Emission distribution:\n" + emissionMultinomial[i] + "\n\n"); sb.append ("Transition distribution:\n" + transitionMultinomial[i].toString()); } System.out.println (sb.toString()); }
private void estimate () { if (transitionCounts == null) throw new IllegalStateException ("Transducer is not currently trainable."); Multinomial transitionDistribution = transitionCounts.estimate (); for (int i = 0; i < transitions.length; i++) transitions[i].cost = - transitionDistribution.logProbability (i); } }
public Multinomial estimate () { double[] pr = new double[dictionary==null ? size : dictionary.size()]; if (dictionary != null){ ensureCapacity(dictionary.size() -1 ); //side effect: updates size member } double sum = 0; for (int i = 0; i < pr.length; i++) { pr[i] = counts[i] + m; sum += pr[i]; } for (int i = 0; i < pr.length; i++) pr[i] /= sum; return new Multinomial (pr, dictionary, size, false, false); }
public FeatureSequence randomFeatureSequence (Random r, int length) { if (! (dictionary instanceof Alphabet)) throw new UnsupportedOperationException ("Multinomial's dictionary must be a Alphabet"); FeatureSequence fs = new FeatureSequence ((Alphabet)dictionary, length); while (length-- > 0) fs.add (randomIndex (r)); return fs; }
public FeatureVector randomFeatureVector (Random r, int size) { return new FeatureVector (randomFeatureSequence (r, size)); }
public void estimate () { if (initialStateCounts == null || finalStateCounts == null) throw new IllegalStateException ("This transducer not currently trainable."); Multinomial initialStateDistribution = initialStateCounts.estimate (); Multinomial finalStateDistribution = finalStateCounts.estimate (); for (int i = 0; i < states.size(); i++) { State s = (State) states.get (i); s.initialCost = - initialStateDistribution.logProbability (i); s.finalCost = - finalStateDistribution.logProbability (i); s.estimate (); } }
ldict.stopGrowth (); System.out.println ("ldict.size="+ldict.size()); Multinomial prior = new Multinomial (new double[] {.5, .5}, ldict);
public TransitionIterator (State source, FeatureSequence inputSeq, int inputPosition, String output, HMM hmm) { this.source = source; this.hmm = hmm; this.input = inputSeq; this.inputPos = inputPosition; this.costs = new double[source.destinations.length]; for (int transIndex = 0; transIndex < source.destinations.length; transIndex++) { if (output == null || output.equals(source.labels[transIndex])) { costs[transIndex] = 0; // xxx should this be emission of the _next_ observation? // double logEmissionProb = hmm.emissionMultinomial[source.getIndex()].logProbability (inputSeq.get (inputPosition)); double logEmissionProb = hmm.emissionMultinomial[transIndex].logProbability (inputSeq.get (inputPosition)); double logTransitionProb = hmm.transitionMultinomial[source.getIndex()].logProbability (source.destinationNames[transIndex]); // cost = -logProbability costs[transIndex] -= (logEmissionProb + logTransitionProb); assert (!Double.isNaN(costs[transIndex])); } else costs[transIndex] = INFINITE_COST; } nextIndex = 0; while (nextIndex < source.destinations.length && costs[nextIndex] == INFINITE_COST) nextIndex++; }