JSTAT:Java Statistical Analysis Tool

相似文件 换一批

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

Java Statistical Analysis Tool

JSAT is a library for quickly getting started with Machine Learning problems. It is developed in my free time, and made available for use under the GPL 3. Part of the library is for self education, as such - all code is self contained. JSAT has no external dependencies, and is pure Java. I also aim to make the library suitably fast for small to medium size problems. As such, much of the code supports parallel execution.

Get JSAT

You can download JSAT from maven central, add the below to your pom file

<dependencies>  <dependency>    <groupId>com.edwardraff</groupId>    <artifactId>JSAT</artifactId>    <version>0.0.5</version>  </dependency></dependencies>

I will also host a snapshot directory, to access it - change "maven-repo" to "maven-snapshot-repo" for the "<url>" tag.

Why use JSAT?

For reasarch and specialized needs, JSAT has one of the largest collections of algorithms available in any framework. See an incomplete list here.

Additional, there are unfortunately not as many ML tools for Java as there are for other lanagues. Compared to Weka, JSAT is usually faster.

If you want to use JSAT and the GPL is not something that will work for you, let me know and we can discuss the issue.

See the wiki for more information as well as some examples on how to use JSAT.

Note

Updates to JSAT may be slowed as I begin a PhD program in Computer Science. The project isn’t abandoned! I just have limited free time, and will be balancing my PhD work with a full time job. If you discover more hours in the day, please let me know!

本帖隐藏的内容

JSAT-master.zip (1.48 MB)

2016-6-27 01:59:01 上传

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：Statistical statistica statistic Analysis Analysi framework execution available developed education

1. package jsat.classifiers.bayesian;
   
2. 
   
3. import static java.lang.Math.exp;
   
4. import java.util.Arrays;
   
5. import java.util.List;
   
6. import java.util.concurrent.ExecutorService;
   
7. import jsat.classifiers.*;
   
8. import jsat.exceptions.FailedToFitException;
   
9. import jsat.exceptions.UntrainedModelException;
   
10. import jsat.linear.IndexValue;
    
11. import jsat.linear.Vec;
    
12. import jsat.math.MathTricks;
    
13. import jsat.parameters.Parameter;
    
14. import jsat.parameters.Parameterized;
    
15. 
    
16. /**
    
17. * An implementation of the Multinomial Naive Bayes model (MNB). In this model,
    
18. * vectors are implicitly assumed to be sparse and that zero values can be
    
19. * skipped. This model requires that all numeric features be non negative, any
    
20. * negative value will be treated as a zero. <br>
    
21. * <br>Note: the is no reason to ever use more than one
    
22. * {@link #setEpochs(int) epoch} for MNB<br>
    
23. * <br>MNB requires taking the log probabilities to perform predictions, which
    
24. * created a trade off. Updating the classifier requires the non log form, but
    
25. * updates require the log form, making classification take considerably longer
    
26. * to take the logs of the probabilities. This can be reduced by
    
27. * {@link #finalizeModel() finalizing} the model. This prevents the model from
    
28. * being updated further, but reduces classification time. By default, this will
    
29. * be done after a call to
    
30. * {@link #trainC(jsat.classifiers.ClassificationDataSet) } but not after
    
31. * {@link #update(jsat.classifiers.DataPoint, int) }
    
32. *
    
33. * @author Edward Raff
    
34. */
    
35. public class MultinomialNaiveBayes extends BaseUpdateableClassifier implements Parameterized
    
36. {
    
37. 
    
38.         private static final long serialVersionUID = -469977945722725478L;
    
39.         private double[][][] apriori;
    
40.     private double[][] wordCounts;
    
41.     private double[] totalWords;
    
42.    
    
43.     private double priorSum = 0;
    
44.     private double[] priors;
    
45.     /**
    
46.      * Smoothing correction.
    
47.      * Added in classification instead of addition
    
48.      */
    
49.     private double smoothing;
    
50.    
    
51.     private boolean finalizeAfterTraining = true;
    
52.     /**
    
53.      * No more training
    
54.      */
    
55.     private boolean finalized;
    
56. 
    
57.     /**
    
58.      * Creates a new Multinomial model with laplace smoothing
    
59.      */
    
60.     public MultinomialNaiveBayes()
    
61.     {
    
62.         this(1.0);
    
63.     }
    
64.    
    
65.     /**
    
66.      * Creates a new Multinomial model with the given amount of smoothing
    
67.      * @param smoothing the amount of smoothing to apply
    
68.      */
    
69.     public MultinomialNaiveBayes(double smoothing)
    
70.     {
    
71.         setSmoothing(smoothing);
    
72.         setEpochs(1);
    
73.     }
    
74. 
    
75.     /**
    
76.      * Copy constructor
    
77.      * @param other the one to copy
    
78.      */
    
79.     protected MultinomialNaiveBayes(MultinomialNaiveBayes other)
    
80.     {
    
81.         this(other.smoothing);
    
82.         if(other.apriori != null)
    
83.         {
    
84.             this.apriori = new double[other.apriori.length][][];
    
85.             this.wordCounts = new double[other.wordCounts.length][];
    
86.             this.totalWords = Arrays.copyOf(other.totalWords, other.totalWords.length);
    
87.             this.priors = Arrays.copyOf(other.priors, other.priors.length);
    
88.             this.priorSum = other.priorSum;
    
89. 
    
90.             
    
91.             for(int c = 0; c < other.apriori.length; c++)
    
92.             {
    
93.                 this.apriori[c] = new double[other.apriori[c].length][];
    
94.                 for(int j = 0; j < other.apriori[c].length; j++)
    
95.                     this.apriori[c][j] = Arrays.copyOf(other.apriori[c][j],
    
96.                             other.apriori[c][j].length);
    
97.                 this.wordCounts[c] = Arrays.copyOf(other.wordCounts[c], other.wordCounts[c].length);
    
98.             }
    
99.             
    
100.             this.priorSum = other.priorSum;
     
101.             this.priors = Arrays.copyOf(other.priors, other.priors.length);
     
102.         }
     
103.         this.finalizeAfterTraining = other.finalizeAfterTraining;
     
104.         this.finalized = other.finalized;
     
105.     }
     
106. 
     
107.     /**
     
108.      * Sets the amount of smoothing applied to the model. <br>
     
109.      * Using a value of 1.0 is equivalent to laplace smoothing
     
110.      * <br><br>
     
111.      * The smoothing can be changed after the model has already been trained
     
112.      * without needed to re-train the model for the change to take effect.
     
113.      *
     
114.      * @param smoothing the positive smoothing constant
     
115.      */
     
116.     public void setSmoothing(double smoothing)
     
117.     {
     
118.         if(Double.isNaN(smoothing) || Double.isInfinite(smoothing) || smoothing <= 0)
     
119.             throw new IllegalArgumentException("Smoothing constant must be in range (0,Inf), not " + smoothing);
     
120.         this.smoothing = smoothing;
     
121.     }
     
122. 
     
123.     /**
     
124.      *
     
125.      * @return the smoothing applied to categorical counts
     
126.      */
     
127.     public double getSmoothing()
     
128.     {
     
129.         return smoothing;
     
130.     }
     
131. 
     
132.     /**
     
133.      * If set {@code true}, the model will be finalized after a call to
     
134.      * {@link #trainC(jsat.classifiers.ClassificationDataSet) }. This prevents
     
135.      * the model from being updated in an online fashion for an reduction in
     
136.      * classification time.
     
137.      *
     
138.      * @param finalizeAfterTraining {@code true} to finalize after a call to
     
139.      * train, {@code false} to keep the model updatable.
     
140.      */
     
141.     public void setFinalizeAfterTraining(boolean finalizeAfterTraining)
     
142.     {
     
143.         this.finalizeAfterTraining = finalizeAfterTraining;
     
144.     }
     
145. 
     
146.     /**
     
147.      * Returns {@code true} if the model will be finalized after batch training.
     
148.      * {@code false} if it will be left in an updatable state.
     
149.      * @return {@code true} if the model will be finalized after batch training.
     
150.      */
     
151.     public boolean isFinalizeAfterTraining()
     
152.     {
     
153.         return finalizeAfterTraining;
     
154.     }
     
155.    
     
156.     @Override
     
157.     public MultinomialNaiveBayes clone()
     
158.     {
     
159.         return new MultinomialNaiveBayes(this);
     
160.     }
     
161. 
     
162.     @Override
     
163.     public void trainC(ClassificationDataSet dataSet, ExecutorService threadPool)
     
164.     {
     
165.         super.trainC(dataSet, threadPool);
     
166.         if(finalizeAfterTraining)
     
167.             finalizeModel();
     
168.     }
     
169.    
     
170.     @Override
     
171.     public void trainC(ClassificationDataSet dataSet)
     
172.     {
     
173.         super.trainC(dataSet);
     
174.         if(finalizeAfterTraining)
     
175.             finalizeModel();
     
176.     }
     
177. 
     
178.     /**
     
179.      * Finalizes the current model. This prevents the model from being updated
     
180.      * further, causing {@link #update(jsat.classifiers.DataPoint, int) } to
     
181.      * throw an exception. This finalization reduces the cost of calling
     
182.      * {@link #classify(jsat.classifiers.DataPoint) }
     
183.      */
     
184.     public void finalizeModel()
     
185.     {
     
186.         if(finalized)
     
187.             return;
     
188.         final double priorSumSmooth = priorSum + priors.length * smoothing;
     
189. 
     
190.         for (int c = 0; c < priors.length; c++)
     
191.         {
     
192.             double logProb = Math.log((priors[c] + smoothing) / priorSumSmooth);
     
193.             priors[c] = logProb;
     
194. 
     
195.             double[] counts = wordCounts[c];
     
196.             double logTotalCounts = Math.log(totalWords[c] + smoothing * counts.length);
     
197. 
     
198.             for(int i = 0; i < counts.length; i++)
     
199.             {
     
200.                 //(n/N)^obv
     
201.                 counts[i] = Math.log(counts[i] + smoothing) - logTotalCounts;
     
202.             }
     
203. 
     
204.             for (int j = 0; j < apriori[c].length; j++)
     
205.             {
     
206.                 double sum = 0;
     
207.                 for (int z = 0; z < apriori[c][j].length; z++)
     
208.                     sum += apriori[c][j][z] + smoothing;
     
209.                 for (int z = 0; z < apriori[c][j].length; z++)
     
210.                     apriori[c][j][z] = Math.log( (apriori[c][j][z]+smoothing)/sum);
     
211.             }
     
212.         }
     
213.         finalized = true;
     
214.     }
     
215.    
     
216.    
     
217.     @Override
     
218.     public void setUp(CategoricalData[] categoricalAttributes, int numericAttributes, CategoricalData predicting)
     
219.     {
     
220.         final int nCat = predicting.getNumOfCategories();
     
221.         apriori = new double[nCat][categoricalAttributes.length][];
     
222.         wordCounts = new double[nCat][numericAttributes];
     
223.         totalWords = new double[nCat];
     
224.         priors = new double[nCat];
     
225.         priorSum = 0.0;
     
226.         
     
227.         for (int i = 0; i < nCat; i++)
     
228.             for (int j = 0; j < categoricalAttributes.length; j++)
     
229.                 apriori[i][j] = new double[categoricalAttributes[j].getNumOfCategories()];
     
230.         finalized = false;
     
231.     }
     
232. 
     
233.     @Override
     
234.     public void update(DataPoint dataPoint, int targetClass)
     
235.     {
     
236.         if(finalized)
     
237.             throw new FailedToFitException("Model has already been finalized, and can no longer be updated");
     
238.         final double weight = dataPoint.getWeight();
     
239.         final Vec x = dataPoint.getNumericalValues();
     
240.         
     
241.         //Categorical value updates
     
242.         int[] catValues = dataPoint.getCategoricalValues();
     
243.         for(int j = 0; j < apriori[targetClass].length; j++)
     
244.             apriori[targetClass][j][catValues[j]]+=weight;
     
245.         double localCountsAdded = 0;
     
246.         for(IndexValue iv : x)
     
247.         {
     
248.             final double v = iv.getValue();
     
249.             if(v < 0)
     
250.                 continue;
     
251.             wordCounts[targetClass][iv.getIndex()] += v*weight;
     
252.             localCountsAdded += v*weight;
     
253.         }
     
254.         totalWords[targetClass] += localCountsAdded;
     
255.         priors[targetClass] += weight;
     
256.         priorSum += weight;
     
257.     }
     
258. 
     
259.     @Override
     
260.     public CategoricalResults classify(DataPoint data)
     
261.     {
     
262.         if(apriori == null)
     
263.             throw new UntrainedModelException("Model has not been intialized");
     
264.         CategoricalResults results = new CategoricalResults(apriori.length);
     
265.         double[] logProbs = new double[apriori.length];
     
266.         double maxLogProg = Double.NEGATIVE_INFINITY;
     
267.         Vec numVals = data.getNumericalValues();
     
268.         if(finalized)
     
269.         {
     
270.             for(int c = 0; c < priors.length; c++)
     
271.             {
     
272.                 double logProb = priors[c];
     
273. 
     
274.                 double[] counts = wordCounts[c];
     
275. 
     
276.                 for (IndexValue iv : numVals)
     
277.                 {
     
278.                     //(n/N)^obv
     
279.                     logProb += iv.getValue() * counts[iv.getIndex()];
     
280.                 }
     
281. 
     
282.                 for (int j = 0; j < apriori[c].length; j++)
     
283.                 {
     
284.                     logProb += apriori[c][j][data.getCategoricalValue(j)];
     
285.                 }
     
286. 
     
287.                 logProbs[c] = logProb;
     
288.                 maxLogProg = Math.max(maxLogProg, logProb);
     
289.             }
     
290.         }
     
291.         else
     
292.         {
     
293.             final double priorSumSmooth = priorSum+logProbs.length*smoothing;
     
294.             for(int c = 0; c < priors.length; c++)
     
295.             {
     
296.                 double logProb = Math.log((priors[c]+smoothing)/priorSumSmooth);
     
297. 
     
298.                 double[] counts = wordCounts[c];
     
299.                 double logTotalCounts = Math.log(totalWords[c]+smoothing*counts.length);
     
300. 
     
301.                 for (IndexValue iv : numVals)
     
302.                 {
     
303.                     //(n/N)^obv
     
304.                     logProb += iv.getValue() * (Math.log(counts[iv.getIndex()]+smoothing) - logTotalCounts);
     
305.                 }
     
306. 
     
307.                 for (int j = 0; j < apriori[c].length; j++)
     
308.                 {
     
309.                     double sum = 0;
     
310.                     for (int z = 0; z < apriori[c][j].length; z++)
     
311.                         sum += apriori[c][j][z]+smoothing;
     
312.                     double p = apriori[c][j][data.getCategoricalValue(j)]+smoothing;
     
313.                     logProb += Math.log(p / sum);
     
314.                 }
     
315. 
     
316.                 logProbs[c] = logProb;
     
317.                 maxLogProg = Math.max(maxLogProg, logProb);
     
318.             }
     
319.         }
     
320.         double denom = MathTricks.logSumExp(logProbs, maxLogProg);
     
321. 
     
322.         for (int i = 0; i < results.size(); i++)
     
323.             results.setProb(i, exp(logProbs[i] - denom));
     
324.         results.normalize();
     
325.         return results;
     
326.     }
     
327. 
     
328.     @Override
     
329.     public boolean supportsWeightedData()
     
330.     {
     
331.         return true;
     
332.     }
     
333. 
     
334.     @Override
     
335.     public List<Parameter> getParameters()
     
336.     {
     
337.         return Parameter.getParamsFromMethods(this);
     
338.     }
     
339. 
     
340.     @Override
     
341.     public Parameter getParameter(String paramName)
     
342.     {
     
343.         return Parameter.toParameterMap(getParameters()).get(paramName);
     
344.     }
     
345.    
     
346. }

复制代码

thanks for sharing