nltk 3.2__zip → 3.3__zip

{nltk-3.2 → nltk-3.3}/nltk/classify/scikitlearn.py

@@ -1,151 +1,153 @@
-# Natural Language Toolkit: Interface to scikit-learn classifiers
-#
-# Author: Lars Buitinck <L.J.Buitinck@uva.nl>
-# URL: <http://nltk.org/>
-# For license information, see LICENSE.TXT
-"""
-scikit-learn (http://scikit-learn.org) is a machine learning library for
-Python. It supports many classification algorithms, including SVMs,
-Naive Bayes, logistic regression (MaxEnt) and decision trees.
-
-This package implement a wrapper around scikit-learn classifiers. To use this
-wrapper, construct a scikit-learn estimator object, then use that to construct
-a SklearnClassifier. E.g., to wrap a linear SVM with default settings:
-
->>> from sklearn.svm import LinearSVC
->>> from nltk.classify.scikitlearn import SklearnClassifier
->>> classif = SklearnClassifier(LinearSVC())
-
-A scikit-learn classifier may include preprocessing steps when it's wrapped
-in a Pipeline object. The following constructs and wraps a Naive Bayes text
-classifier with tf-idf weighting and chi-square feature selection to get the
-best 1000 features:
-
->>> from sklearn.feature_extraction.text import TfidfTransformer
->>> from sklearn.feature_selection import SelectKBest, chi2
->>> from sklearn.naive_bayes import MultinomialNB
->>> from sklearn.pipeline import Pipeline
->>> pipeline = Pipeline([('tfidf', TfidfTransformer()),
-...                      ('chi2', SelectKBest(chi2, k=1000)),
-...                      ('nb', MultinomialNB())])
->>> classif = SklearnClassifier(pipeline)
-"""
-from __future__ import print_function, unicode_literals
-
-from nltk.classify.api import ClassifierI
-from nltk.probability import DictionaryProbDist
-from nltk import compat
-
-try:
-    from sklearn.feature_extraction import DictVectorizer
-    from sklearn.preprocessing import LabelEncoder
-except ImportError:
-    pass
-
-__all__ = ['SklearnClassifier']
-
-
-@compat.python_2_unicode_compatible
-class SklearnClassifier(ClassifierI):
-    """Wrapper for scikit-learn classifiers."""
-
-    def __init__(self, estimator, dtype=float, sparse=True):
-        """
-        :param estimator: scikit-learn classifier object.
-
-        :param dtype: data type used when building feature array.
-            scikit-learn estimators work exclusively on numeric data. The
-            default value should be fine for almost all situations.
-
-        :param sparse: Whether to use sparse matrices internally.
-            The estimator must support these; not all scikit-learn classifiers
-            do (see their respective documentation and look for "sparse
-            matrix"). The default value is True, since most NLP problems
-            involve sparse feature sets. Setting this to False may take a
-            great amount of memory.
-        :type sparse: boolean.
-        """
-        self._clf = estimator
-        self._encoder = LabelEncoder()
-        self._vectorizer = DictVectorizer(dtype=dtype, sparse=sparse)
-
-    def __repr__(self):
-        return "<SklearnClassifier(%r)>" % self._clf
-
-    def classify_many(self, featuresets):
-        """Classify a batch of samples.
-
-        :param featuresets: An iterable over featuresets, each a dict mapping
-            strings to either numbers, booleans or strings.
-        :return: The predicted class label for each input sample.
-        :rtype: list
-        """
-        X = self._vectorizer.transform(featuresets)
-        classes = self._encoder.classes_
-        return [classes[i] for i in self._clf.predict(X)]
-
-    def prob_classify_many(self, featuresets):
-        """Compute per-class probabilities for a batch of samples.
-
-        :param featuresets: An iterable over featuresets, each a dict mapping
-            strings to either numbers, booleans or strings.
-        :rtype: list of ``ProbDistI``
-        """
-        X = self._vectorizer.transform(featuresets)
-        y_proba_list = self._clf.predict_proba(X)
-        return [self._make_probdist(y_proba) for y_proba in y_proba_list]
-
-    def labels(self):
-        """The class labels used by this classifier.
-
-        :rtype: list
-        """
-        return list(self._encoder.classes_)
-
-    def train(self, labeled_featuresets):
-        """
-        Train (fit) the scikit-learn estimator.
-
-        :param labeled_featuresets: A list of ``(featureset, label)``
-            where each ``featureset`` is a dict mapping strings to either
-            numbers, booleans or strings.
-        """
-
-        X, y = list(compat.izip(*labeled_featuresets))
-        X = self._vectorizer.fit_transform(X)
-        y = self._encoder.fit_transform(y)
-        self._clf.fit(X, y)
-
-        return self
-
-    def _make_probdist(self, y_proba):
-        classes = self._encoder.classes_
-        return DictionaryProbDist(dict((classes[i], p)
-                                       for i, p in enumerate(y_proba)))
-
-
-# skip doctests if scikit-learn is not installed
-def setup_module(module):
-    from nose import SkipTest
-    try:
-        import sklearn
-    except ImportError:
-        raise SkipTest("scikit-learn is not installed")
-
-
-if __name__ == "__main__":
-    from nltk.classify.util import names_demo, names_demo_features
-    from sklearn.linear_model import LogisticRegression
-    from sklearn.naive_bayes import BernoulliNB
-
-    # Bernoulli Naive Bayes is designed for binary classification. We set the
-    # binarize option to False since we know we're passing boolean features.
-    print("scikit-learn Naive Bayes:")
-    names_demo(SklearnClassifier(BernoulliNB(binarize=False)).train,
-               features=names_demo_features)
-
-    # The C parameter on logistic regression (MaxEnt) controls regularization.
-    # The higher it's set, the less regularized the classifier is.
-    print("\n\nscikit-learn logistic regression:")
-    names_demo(SklearnClassifier(LogisticRegression(C=1000)).train,
-               features=names_demo_features)
+# Natural Language Toolkit: Interface to scikit-learn classifiers
+#
+# Author: Lars Buitinck <L.J.Buitinck@uva.nl>
+# URL: <http://nltk.org/>
+# For license information, see LICENSE.TXT
+"""
+scikit-learn (http://scikit-learn.org) is a machine learning library for
+Python. It supports many classification algorithms, including SVMs,
+Naive Bayes, logistic regression (MaxEnt) and decision trees.
+
+This package implements a wrapper around scikit-learn classifiers. To use this
+wrapper, construct a scikit-learn estimator object, then use that to construct
+a SklearnClassifier. E.g., to wrap a linear SVM with default settings:
+
+>>> from sklearn.svm import LinearSVC
+>>> from nltk.classify.scikitlearn import SklearnClassifier
+>>> classif = SklearnClassifier(LinearSVC())
+
+A scikit-learn classifier may include preprocessing steps when it's wrapped
+in a Pipeline object. The following constructs and wraps a Naive Bayes text
+classifier with tf-idf weighting and chi-square feature selection to get the
+best 1000 features:
+
+>>> from sklearn.feature_extraction.text import TfidfTransformer
+>>> from sklearn.feature_selection import SelectKBest, chi2
+>>> from sklearn.naive_bayes import MultinomialNB
+>>> from sklearn.pipeline import Pipeline
+>>> pipeline = Pipeline([('tfidf', TfidfTransformer()),
+...                      ('chi2', SelectKBest(chi2, k=1000)),
+...                      ('nb', MultinomialNB())])
+>>> classif = SklearnClassifier(pipeline)
+"""
+from __future__ import print_function, unicode_literals
+
+from six.moves import zip
+
+from nltk.classify.api import ClassifierI
+from nltk.probability import DictionaryProbDist
+from nltk import compat
+
+try:
+    from sklearn.feature_extraction import DictVectorizer
+    from sklearn.preprocessing import LabelEncoder
+except ImportError:
+    pass
+
+__all__ = ['SklearnClassifier']
+
+
+@compat.python_2_unicode_compatible
+class SklearnClassifier(ClassifierI):
+    """Wrapper for scikit-learn classifiers."""
+
+    def __init__(self, estimator, dtype=float, sparse=True):
+        """
+        :param estimator: scikit-learn classifier object.
+
+        :param dtype: data type used when building feature array.
+            scikit-learn estimators work exclusively on numeric data. The
+            default value should be fine for almost all situations.
+
+        :param sparse: Whether to use sparse matrices internally.
+            The estimator must support these; not all scikit-learn classifiers
+            do (see their respective documentation and look for "sparse
+            matrix"). The default value is True, since most NLP problems
+            involve sparse feature sets. Setting this to False may take a
+            great amount of memory.
+        :type sparse: boolean.
+        """
+        self._clf = estimator
+        self._encoder = LabelEncoder()
+        self._vectorizer = DictVectorizer(dtype=dtype, sparse=sparse)
+
+    def __repr__(self):
+        return "<SklearnClassifier(%r)>" % self._clf
+
+    def classify_many(self, featuresets):
+        """Classify a batch of samples.
+
+        :param featuresets: An iterable over featuresets, each a dict mapping
+            strings to either numbers, booleans or strings.
+        :return: The predicted class label for each input sample.
+        :rtype: list
+        """
+        X = self._vectorizer.transform(featuresets)
+        classes = self._encoder.classes_
+        return [classes[i] for i in self._clf.predict(X)]
+
+    def prob_classify_many(self, featuresets):
+        """Compute per-class probabilities for a batch of samples.
+
+        :param featuresets: An iterable over featuresets, each a dict mapping
+            strings to either numbers, booleans or strings.
+        :rtype: list of ``ProbDistI``
+        """
+        X = self._vectorizer.transform(featuresets)
+        y_proba_list = self._clf.predict_proba(X)
+        return [self._make_probdist(y_proba) for y_proba in y_proba_list]
+
+    def labels(self):
+        """The class labels used by this classifier.
+
+        :rtype: list
+        """
+        return list(self._encoder.classes_)
+
+    def train(self, labeled_featuresets):
+        """
+        Train (fit) the scikit-learn estimator.
+
+        :param labeled_featuresets: A list of ``(featureset, label)``
+            where each ``featureset`` is a dict mapping strings to either
+            numbers, booleans or strings.
+        """
+
+        X, y = list(zip(*labeled_featuresets))
+        X = self._vectorizer.fit_transform(X)
+        y = self._encoder.fit_transform(y)
+        self._clf.fit(X, y)
+
+        return self
+
+    def _make_probdist(self, y_proba):
+        classes = self._encoder.classes_
+        return DictionaryProbDist(dict((classes[i], p)
+                                       for i, p in enumerate(y_proba)))
+
+
+# skip doctests if scikit-learn is not installed
+def setup_module(module):
+    from nose import SkipTest
+    try:
+        import sklearn
+    except ImportError:
+        raise SkipTest("scikit-learn is not installed")
+
+
+if __name__ == "__main__":
+    from nltk.classify.util import names_demo, names_demo_features
+    from sklearn.linear_model import LogisticRegression
+    from sklearn.naive_bayes import BernoulliNB
+
+    # Bernoulli Naive Bayes is designed for binary classification. We set the
+    # binarize option to False since we know we're passing boolean features.
+    print("scikit-learn Naive Bayes:")
+    names_demo(SklearnClassifier(BernoulliNB(binarize=False)).train,
+               features=names_demo_features)
+
+    # The C parameter on logistic regression (MaxEnt) controls regularization.
+    # The higher it's set, the less regularized the classifier is.
+    print("\n\nscikit-learn logistic regression:")
+    names_demo(SklearnClassifier(LogisticRegression(C=1000)).train,
+               features=names_demo_features)