Scala/Java Machine Learning Library:Nak

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

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

立即领取

感谢您参与论坛问题回答

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

+2 论坛币

Nak

Nak is a Scala/Java library for machine learning and related tasks, with a focus on having an easy to use API for some standard algorithms. It is formed from Breeze, Liblinear Java, and Scalabha. It is currently undergoing a pretty massive evolution, so be prepared for quite big changes in the API for this and probably several future versions.

We'd love to have some more contributors: if you are interested in helping out, please see the #helpwanted issues or suggest your own ideas.

本帖隐藏的内容

https://github.com/scalanlp/nak/tree/master/src/main

扫码加我 拉你入群

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

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

分享0 收藏0 回帖

关键词：Learning earning Library machine BRARY interested currently learning prepared standard

1. Example
   
2. 
   
3. Here's an example of how easy it is to train and evaluate a text classifier using Nak. See TwentyNewsGroups.scala for more details.
   
4. 
   
5. def main(args: Array[String]) {
   
6.   val newsgroupsDir = new File(args(0))
   
7.   implicit val isoCodec = scala.io.Codec("ISO-8859-1")
   
8.   val stopwords = Set("the","a","an","of","in","for","by","on")
   
9. 
   
10.   val trainDir = new File(newsgroupsDir, "20news-bydate-train")
    
11.   val trainingExamples = fromLabeledDirs(trainDir).toList
    
12.   val config = LiblinearConfig(cost=5.0)
    
13.   val featurizer = new BowFeaturizer(stopwords)
    
14.   val classifier = trainClassifier(config, featurizer, trainingExamples)
    
15. 
    
16.   val evalDir = new File(newsgroupsDir, "20news-bydate-test")
    
17.   val maxLabelNews = maxLabel(classifier.labels) _
    
18.   val comparisons = for (ex <- fromLabeledDirs(evalDir).toList) yield
    
19.     (ex.label, maxLabelNews(classifier.evalRaw(ex.features)), ex.features)
    
20.   val (goldLabels, predictions, inputs) = comparisons.unzip3
    
21.   println(ConfusionMatrix(goldLabels, predictions, inputs))
    
22. }

复制代码

1. package nak.liblinear;
   
2. 
   
3. 
   
4. final class ArraySorter {
   
5. 
   
6.     /**
   
7.      * <p>Sorts the specified array of doubles into <b>descending</b> order.</p>
   
8.      *
   
9.      * <em>This code is borrowed from Sun's JDK 1.6.0.07</em>
   
10.      */
    
11.     public static void reversedMergesort(double[] a) {
    
12.         reversedMergesort(a, 0, a.length);
    
13.     }
    
14. 
    
15.     private static void reversedMergesort(double x[], int off, int len) {
    
16.         // Insertion sort on smallest arrays
    
17.         if (len < 7) {
    
18.             for (int i = off; i < len + off; i++)
    
19.                 for (int j = i; j > off && x[j - 1] < x[j]; j--)
    
20.                     swap(x, j, j - 1);
    
21.             return;
    
22.         }
    
23. 
    
24.         // Choose a partition element, v
    
25.         int m = off + (len >> 1); // Small arrays, middle element
    
26.         if (len > 7) {
    
27.             int l = off;
    
28.             int n = off + len - 1;
    
29.             if (len > 40) { // Big arrays, pseudomedian of 9
    
30.                 int s = len / 8;
    
31.                 l = med3(x, l, l + s, l + 2 * s);
    
32.                 m = med3(x, m - s, m, m + s);
    
33.                 n = med3(x, n - 2 * s, n - s, n);
    
34.             }
    
35.             m = med3(x, l, m, n); // Mid-size, med of 3
    
36.         }
    
37.         double v = x[m];
    
38. 
    
39.         // Establish Invariant: v* (<v)* (>v)* v*
    
40.         int a = off, b = a, c = off + len - 1, d = c;
    
41.         while (true) {
    
42.             while (b <= c && x[b] >= v) {
    
43.                 if (x[b] == v) swap(x, a++, b);
    
44.                 b++;
    
45.             }
    
46.             while (c >= b && x[c] <= v) {
    
47.                 if (x[c] == v) swap(x, c, d--);
    
48.                 c--;
    
49.             }
    
50.             if (b > c) break;
    
51.             swap(x, b++, c--);
    
52.         }
    
53. 
    
54.         // Swap partition elements back to middle
    
55.         int s, n = off + len;
    
56.         s = Math.min(a - off, b - a);
    
57.         vecswap(x, off, b - s, s);
    
58.         s = Math.min(d - c, n - d - 1);
    
59.         vecswap(x, b, n - s, s);
    
60. 
    
61.         // Recursively sort non-partition-elements
    
62.         if ((s = b - a) > 1) reversedMergesort(x, off, s);
    
63.         if ((s = d - c) > 1) reversedMergesort(x, n - s, s);
    
64.     }
    
65. 
    
66.     /**
    
67.      * Swaps x[a] with x[b].
    
68.      */
    
69.     private static void swap(double x[], int a, int b) {
    
70.         double t = x[a];
    
71.         x[a] = x[b];
    
72.         x[b] = t;
    
73.     }
    
74. 
    
75.     /**
    
76.      * Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)].
    
77.      */
    
78.     private static void vecswap(double x[], int a, int b, int n) {
    
79.         for (int i = 0; i < n; i++, a++, b++)
    
80.             swap(x, a, b);
    
81.     }
    
82. 
    
83.     /**
    
84.      * Returns the index of the median of the three indexed doubles.
    
85.      */
    
86.     private static int med3(double x[], int a, int b, int c) {
    
87.         return (x[a] < x[b] ? (x[b] < x[c] ? b : x[a] < x[c] ? c : a) : (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
    
88.     }
    
89. 
    
90. 
    
91. }

复制代码

1. package nak.liblinear;
   
2. 
   
3. 
   
4. final class DoubleArrayPointer {
   
5. 
   
6.     private final double[] _array;
   
7.     private int            _offset;
   
8. 
   
9. 
   
10.     public void setOffset(int offset) {
    
11.         if (offset < 0 || offset >= _array.length) throw new IllegalArgumentException("offset must be between 0 and the length of the array");
    
12.         _offset = offset;
    
13.     }
    
14. 
    
15.     public DoubleArrayPointer( final double[] array, final int offset ) {
    
16.         _array = array;
    
17.         setOffset(offset);
    
18.     }
    
19. 
    
20.     public double get(final int index) {
    
21.         return _array[_offset + index];
    
22.     }
    
23. 
    
24.     public void set(final int index, final double value) {
    
25.         _array[_offset + index] = value;
    
26.     }
    
27. }

复制代码

1. package nak.liblinear;
   
2. 
   
3. /**
   
4. * @since 1.9
   
5. */
   
6. public interface Feature {
   
7. 
   
8.     int getIndex();
   
9. 
   
10.     double getValue();
    
11. 
    
12.     void setValue(double value);
    
13. }

复制代码

1. package nak.classify
   
2. 
   
3. /*
   
4. Copyright 2009 David Hall, Daniel Ramage
   
5. 
   
6. Licensed under the Apache License, Version 2.0 (the "License");
   
7. you may not use this file except in compliance with the License.
   
8. You may obtain a copy of the License at
   
9. 
   
10. http://www.apache.org/licenses/LICENSE-2.0
    
11. 
    
12. Unless required by applicable law or agreed to in writing, software
    
13. distributed under the License is distributed on an "AS IS" BASIS,
    
14. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    
15. See the License for the specific language governing permissions and
    
16. limitations under the License.
    
17. */
    
18. 
    
19. 
    
20. import nak.data._
    
21. import breeze.linalg._
    
22. 
    
23. /**
    
24. * Represents a classifier from observations of type T to labels of type L.
    
25. * Implementers should only need to implement score.
    
26. *
    
27. * @author dlwh
    
28. */
    
29. trait Classifier[L, -T] extends (T => L) {  outer =>
    
30.   /** Return the most likely label */
    
31.   def apply(o: T) = classify(o)
    
32. 
    
33.   /** Return the most likely label */
    
34.   def classify(o: T) = scores(o).argmax
    
35. 
    
36.   /** For the observation, return the score for each label that has a nonzero
    
37.     * score.
    
38.     */
    
39.   def scores(o: T): Counter[L, Double]
    
40. 
    
41.   /**
    
42.    * Transforms output labels L=>M. if f(x) is not one-to-one then the max of score
    
43.    * from the L's are used.
    
44.    */
    
45.   def map[M](f: L => M): Classifier[M, T] = new Classifier[M, T] {
    
46.     def scores(o: T): Counter[M, Double] = {
    
47.       val ctr = Counter[M, Double]()
    
48.       val otherCtr = outer.scores(o)
    
49.       for (x <- otherCtr.keysIterator) {
    
50.         val y = f(x)
    
51.         ctr(y) = ctr(y) max otherCtr(x)
    
52.       }
    
53.       ctr;
    
54.     }
    
55.   }
    
56. }
    
57. 
    
58. 
    
59. 
    
60. object Classifier {
    
61. 
    
62.   trait Trainer[L, T] {
    
63.     type MyClassifier <: Classifier[L, T]
    
64. 
    
65.     def train(data: Iterable[Example[L, T]]): MyClassifier;
    
66.   }
    
67. 
    
68. }

复制代码

1. package nak.classify
   
2. /*
   
3. Copyright 2010 David Hall, Daniel Ramage
   
4. Licensed under the Apache License, Version 2.0 (the "License")
   
5. you may not use this file except in compliance with the License.
   
6. You may obtain a copy of the License at
   
7. http://www.apache.org/licenses/LICENSE-2.0
   
8. Unless required by applicable law or agreed to in writing, software
   
9. distributed under the License is distributed on an "AS IS" BASIS,
   
10. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    
11. See the License for the specific language governing permissions and
    
12. limitations under the License.
    
13. */
    
14. 
    
15. 
    
16. 
    
17. import nak.serialization.DataSerialization.ReadWritable
    
18. import nak.serialization.DataSerialization
    
19. import breeze.linalg._
    
20. import breeze.linalg.operators._
    
21. import breeze.math.{MutableTensorField, VectorField}
    
22. 
    
23. /**
    
24. * A LinearClassifier is a multi-class classifier with decision
    
25. * function:
    
26. * <code>
    
27. * \hat y_i = \arg\max_y w_y^T x_i + b_y
    
28. * </code>
    
29. *
    
30. * @author dlwh
    
31. *
    
32. */
    
33. @SerialVersionUID(1L)
    
34. class LinearClassifier[L,TW, TL, TF]
    
35.     (val featureWeights: TW, val intercepts: TL)
    
36.     (implicit viewT2 : TW<:<NumericOps[TW], vspace: MutableTensorField[TL, L, Double],
    
37.      mulTensors : OpMulMatrix.Impl2[TW, TF, TL]) extends Classifier[L,TF] with Serializable {
    
38.   import vspace._
    
39.   def scores(o: TF) = {
    
40.     val r = (featureWeights * o) + intercepts
    
41.     val ctr = Counter[L, Double]()
    
42.     for((l, v) <- r.iterator) {
    
43.       ctr(l) = v
    
44.     }
    
45.     ctr
    
46.   }
    
47. }
    
48. 
    
49. object LinearClassifier {
    
50.   implicit def linearClassifierReadWritable[L, T2, TL, TF](implicit viewT2 : T2<:<NumericOps[T2], vspace: MutableTensorField[TL, L, Double],
    
51.                                                            mulTensors : OpMulMatrix.Impl2[T2, TF, TL],
    
52.                                                         view: TL <:< Tensor[L, Double],
    
53.                                                         tfW: DataSerialization.ReadWritable[T2],
    
54.                                                         tlW: DataSerialization.ReadWritable[TL]) = {
    
55.     new ReadWritable[LinearClassifier[L,T2,TL,TF]] {
    
56.       def write(sink: DataSerialization.Output, what: LinearClassifier[L,T2,TL,TF]) = {
    
57.         tfW.write(sink,what.featureWeights)
    
58.         tlW.write(sink,what.intercepts)
    
59.       }
    
60. 
    
61.       def read(source: DataSerialization.Input) = {
    
62.         val t2 = tfW.read(source)
    
63.         val tl = tlW.read(source)
    
64.         new LinearClassifier(t2,tl)
    
65.       }
    
66.     }
    
67.   }
    
68. }

复制代码

great! too good.