Pushing the docs to 0.20/ for branch: 0.20.X, commit c40726e91e9a49f233318541366835adfb72d576

Author: sklearn-ci

0.20/.buildinfo

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 7ec53ea0763238f487c61d94c6d77d05
+tags: 645f666f9bcd5a90fca523b33c5a78b7

0.20/_downloads/auto_examples_jupyter.zip

@@ -0,0 +1,54 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "%matplotlib inline"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n# Sample pipeline for text feature extraction and evaluation\n\n\nThe dataset used in this example is the 20 newsgroups dataset which will be\nautomatically downloaded and then cached and reused for the document\nclassification example.\n\nYou can adjust the number of categories by giving their names to the dataset\nloader or setting them to None to get the 20 of them.\n\nHere is a sample output of a run on a quad-core machine::\n\n  Loading 20 newsgroups dataset for categories:\n  ['alt.atheism', 'talk.religion.misc']\n  1427 documents\n  2 categories\n\n  Performing grid search...\n  pipeline: ['vect', 'tfidf', 'clf']\n  parameters:\n  {'clf__alpha': (1.0000000000000001e-05, 9.9999999999999995e-07),\n   'clf__max_iter': (10, 50, 80),\n   'clf__penalty': ('l2', 'elasticnet'),\n   'tfidf__use_idf': (True, False),\n   'vect__max_n': (1, 2),\n   'vect__max_df': (0.5, 0.75, 1.0),\n   'vect__max_features': (None, 5000, 10000, 50000)}\n  done in 1737.030s\n\n  Best score: 0.940\n  Best parameters set:\n      clf__alpha: 9.9999999999999995e-07\n      clf__max_iter: 50\n      clf__penalty: 'elasticnet'\n      tfidf__use_idf: True\n      vect__max_n: 2\n      vect__max_df: 0.75\n      vect__max_features: 50000\n\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "# Author: Olivier Grisel <[email protected]>\n#         Peter Prettenhofer <[email protected]>\n#         Mathieu Blondel <[email protected]>\n# License: BSD 3 clause\n\nfrom __future__ import print_function\n\nfrom pprint import pprint\nfrom time import time\nimport logging\n\nfrom sklearn.datasets import fetch_20newsgroups\nfrom sklearn.feature_extraction.text import CountVectorizer\nfrom sklearn.feature_extraction.text import TfidfTransformer\nfrom sklearn.linear_model import SGDClassifier\nfrom sklearn.model_selection import GridSearchCV\nfrom sklearn.pipeline import Pipeline\n\nprint(__doc__)\n\n# Display progress logs on stdout\nlogging.basicConfig(level=logging.INFO,\n                    format='%(asctime)s %(levelname)s %(message)s')\n\n\n# #############################################################################\n# Load some categories from the training set\ncategories = [\n    'alt.atheism',\n    'talk.religion.misc',\n]\n# Uncomment the following to do the analysis on all the categories\n#categories = None\n\nprint(\"Loading 20 newsgroups dataset for categories:\")\nprint(categories)\n\ndata = fetch_20newsgroups(subset='train', categories=categories)\nprint(\"%d documents\" % len(data.filenames))\nprint(\"%d categories\" % len(data.target_names))\nprint()\n\n# #############################################################################\n# Define a pipeline combining a text feature extractor with a simple\n# classifier\npipeline = Pipeline([\n    ('vect', CountVectorizer()),\n    ('tfidf', TfidfTransformer()),\n    ('clf', SGDClassifier()),\n])\n\n# uncommenting more parameters will give better exploring power but will\n# increase processing time in a combinatorial way\nparameters = {\n    'vect__max_df': (0.5, 0.75, 1.0),\n    # 'vect__max_features': (None, 5000, 10000, 50000),\n    'vect__ngram_range': ((1, 1), (1, 2)),  # unigrams or bigrams\n    # 'tfidf__use_idf': (True, False),\n    # 'tfidf__norm': ('l1', 'l2'),\n    'clf__max_iter': (5,),\n    'clf__alpha': (0.00001, 0.000001),\n    'clf__penalty': ('l2', 'elasticnet'),\n    # 'clf__max_iter': (10, 50, 80),\n}\n\nif __name__ == \"__main__\":\n    # multiprocessing requires the fork to happen in a __main__ protected\n    # block\n\n    # find the best parameters for both the feature extraction and the\n    # classifier\n    grid_search = GridSearchCV(pipeline, parameters, cv=5,\n                               n_jobs=-1, verbose=1)\n\n    print(\"Performing grid search...\")\n    print(\"pipeline:\", [name for name, _ in pipeline.steps])\n    print(\"parameters:\")\n    pprint(parameters)\n    t0 = time()\n    grid_search.fit(data.data, data.target)\n    print(\"done in %0.3fs\" % (time() - t0))\n    print()\n\n    print(\"Best score: %0.3f\" % grid_search.best_score_)\n    print(\"Best parameters set:\")\n    best_parameters = grid_search.best_estimator_.get_params()\n    for param_name in sorted(parameters.keys()):\n        print(\"\\t%s: %r\" % (param_name, best_parameters[param_name]))"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.6.6"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

0.20/_downloads/auto_examples_python.zip

@@ -0,0 +1,132 @@
+
+"""
+==========================================================
+Sample pipeline for text feature extraction and evaluation
+==========================================================
+
+The dataset used in this example is the 20 newsgroups dataset which will be
+automatically downloaded and then cached and reused for the document
+classification example.
+
+You can adjust the number of categories by giving their names to the dataset
+loader or setting them to None to get the 20 of them.
+
+Here is a sample output of a run on a quad-core machine::
+
+  Loading 20 newsgroups dataset for categories:
+  ['alt.atheism', 'talk.religion.misc']
+  1427 documents
+  2 categories
+
+  Performing grid search...
+  pipeline: ['vect', 'tfidf', 'clf']
+  parameters:
+  {'clf__alpha': (1.0000000000000001e-05, 9.9999999999999995e-07),
+   'clf__max_iter': (10, 50, 80),
+   'clf__penalty': ('l2', 'elasticnet'),
+   'tfidf__use_idf': (True, False),
+   'vect__max_n': (1, 2),
+   'vect__max_df': (0.5, 0.75, 1.0),
+   'vect__max_features': (None, 5000, 10000, 50000)}
+  done in 1737.030s
+
+  Best score: 0.940
+  Best parameters set:
+      clf__alpha: 9.9999999999999995e-07
+      clf__max_iter: 50
+      clf__penalty: 'elasticnet'
+      tfidf__use_idf: True
+      vect__max_n: 2
+      vect__max_df: 0.75
+      vect__max_features: 50000
+
+"""
+
+# Author: Olivier Grisel <[email protected]>
+#         Peter Prettenhofer <[email protected]>
+#         Mathieu Blondel <[email protected]>
+# License: BSD 3 clause
+
+from __future__ import print_function
+
+from pprint import pprint
+from time import time
+import logging
+
+from sklearn.datasets import fetch_20newsgroups
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.feature_extraction.text import TfidfTransformer
+from sklearn.linear_model import SGDClassifier
+from sklearn.model_selection import GridSearchCV
+from sklearn.pipeline import Pipeline
+
+print(__doc__)
+
+# Display progress logs on stdout
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s %(levelname)s %(message)s')
+
+
+# #############################################################################
+# Load some categories from the training set
+categories = [
+    'alt.atheism',
+    'talk.religion.misc',
+]
+# Uncomment the following to do the analysis on all the categories
+#categories = None
+
+print("Loading 20 newsgroups dataset for categories:")
+print(categories)
+
+data = fetch_20newsgroups(subset='train', categories=categories)
+print("%d documents" % len(data.filenames))
+print("%d categories" % len(data.target_names))
+print()
+
+# #############################################################################
+# Define a pipeline combining a text feature extractor with a simple
+# classifier
+pipeline = Pipeline([
+    ('vect', CountVectorizer()),
+    ('tfidf', TfidfTransformer()),
+    ('clf', SGDClassifier()),
+])
+
+# uncommenting more parameters will give better exploring power but will
+# increase processing time in a combinatorial way
+parameters = {
+    'vect__max_df': (0.5, 0.75, 1.0),
+    # 'vect__max_features': (None, 5000, 10000, 50000),
+    'vect__ngram_range': ((1, 1), (1, 2)),  # unigrams or bigrams
+    # 'tfidf__use_idf': (True, False),
+    # 'tfidf__norm': ('l1', 'l2'),
+    'clf__max_iter': (5,),
+    'clf__alpha': (0.00001, 0.000001),
+    'clf__penalty': ('l2', 'elasticnet'),
+    # 'clf__max_iter': (10, 50, 80),
+}
+
+if __name__ == "__main__":
+    # multiprocessing requires the fork to happen in a __main__ protected
+    # block
+
+    # find the best parameters for both the feature extraction and the
+    # classifier
+    grid_search = GridSearchCV(pipeline, parameters, cv=5,
+                               n_jobs=-1, verbose=1)
+
+    print("Performing grid search...")
+    print("pipeline:", [name for name, _ in pipeline.steps])
+    print("parameters:")
+    pprint(parameters)
+    t0 = time()
+    grid_search.fit(data.data, data.target)
+    print("done in %0.3fs" % (time() - t0))
+    print()
+
+    print("Best score: %0.3f" % grid_search.best_score_)
+    print("Best parameters set:")
+    best_parameters = grid_search.best_estimator_.get_params()
+    for param_name in sorted(parameters.keys()):
+        print("\t%s: %r" % (param_name, best_parameters[param_name]))

0.20/_downloads/grid_search_text_feature_extraction.ipynb

@@ -0,0 +1,54 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "%matplotlib inline"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n# Discrete versus Real AdaBoost\n\n\nThis example is based on Figure 10.2 from Hastie et al 2009 [1]_ and\nillustrates the difference in performance between the discrete SAMME [2]_\nboosting algorithm and real SAMME.R boosting algorithm. Both algorithms are\nevaluated on a binary classification task where the target Y is a non-linear\nfunction of 10 input features.\n\nDiscrete SAMME AdaBoost adapts based on errors in predicted class labels\nwhereas real SAMME.R uses the predicted class probabilities.\n\n.. [1] T. Hastie, R. Tibshirani and J. Friedman, \"Elements of Statistical\n    Learning Ed. 2\", Springer, 2009.\n\n.. [2] J. Zhu, H. Zou, S. Rosset, T. Hastie, \"Multi-class AdaBoost\", 2009.\n\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "print(__doc__)\n\n# Author: Peter Prettenhofer <[email protected]>,\n#         Noel Dawe <[email protected]>\n#\n# License: BSD 3 clause\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom sklearn import datasets\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.metrics import zero_one_loss\nfrom sklearn.ensemble import AdaBoostClassifier\n\n\nn_estimators = 400\n# A learning rate of 1. may not be optimal for both SAMME and SAMME.R\nlearning_rate = 1.\n\nX, y = datasets.make_hastie_10_2(n_samples=12000, random_state=1)\n\nX_test, y_test = X[2000:], y[2000:]\nX_train, y_train = X[:2000], y[:2000]\n\ndt_stump = DecisionTreeClassifier(max_depth=1)\ndt_stump.fit(X_train, y_train)\ndt_stump_err = 1.0 - dt_stump.score(X_test, y_test)\n\ndt = DecisionTreeClassifier(max_depth=9)\ndt.fit(X_train, y_train)\ndt_err = 1.0 - dt.score(X_test, y_test)\n\nada_discrete = AdaBoostClassifier(\n    base_estimator=dt_stump,\n    learning_rate=learning_rate,\n    n_estimators=n_estimators,\n    algorithm=\"SAMME\")\nada_discrete.fit(X_train, y_train)\n\nada_real = AdaBoostClassifier(\n    base_estimator=dt_stump,\n    learning_rate=learning_rate,\n    n_estimators=n_estimators,\n    algorithm=\"SAMME.R\")\nada_real.fit(X_train, y_train)\n\nfig = plt.figure()\nax = fig.add_subplot(111)\n\nax.plot([1, n_estimators], [dt_stump_err] * 2, 'k-',\n        label='Decision Stump Error')\nax.plot([1, n_estimators], [dt_err] * 2, 'k--',\n        label='Decision Tree Error')\n\nada_discrete_err = np.zeros((n_estimators,))\nfor i, y_pred in enumerate(ada_discrete.staged_predict(X_test)):\n    ada_discrete_err[i] = zero_one_loss(y_pred, y_test)\n\nada_discrete_err_train = np.zeros((n_estimators,))\nfor i, y_pred in enumerate(ada_discrete.staged_predict(X_train)):\n    ada_discrete_err_train[i] = zero_one_loss(y_pred, y_train)\n\nada_real_err = np.zeros((n_estimators,))\nfor i, y_pred in enumerate(ada_real.staged_predict(X_test)):\n    ada_real_err[i] = zero_one_loss(y_pred, y_test)\n\nada_real_err_train = np.zeros((n_estimators,))\nfor i, y_pred in enumerate(ada_real.staged_predict(X_train)):\n    ada_real_err_train[i] = zero_one_loss(y_pred, y_train)\n\nax.plot(np.arange(n_estimators) + 1, ada_discrete_err,\n        label='Discrete AdaBoost Test Error',\n        color='red')\nax.plot(np.arange(n_estimators) + 1, ada_discrete_err_train,\n        label='Discrete AdaBoost Train Error',\n        color='blue')\nax.plot(np.arange(n_estimators) + 1, ada_real_err,\n        label='Real AdaBoost Test Error',\n        color='orange')\nax.plot(np.arange(n_estimators) + 1, ada_real_err_train,\n        label='Real AdaBoost Train Error',\n        color='green')\n\nax.set_ylim((0.0, 0.5))\nax.set_xlabel('n_estimators')\nax.set_ylabel('error rate')\n\nleg = ax.legend(loc='upper right', fancybox=True)\nleg.get_frame().set_alpha(0.7)\n\nplt.show()"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.6.6"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

0.20/_downloads/grid_search_text_feature_extraction.py

@@ -0,0 +1,112 @@
+"""
+=============================
+Discrete versus Real AdaBoost
+=============================
+
+This example is based on Figure 10.2 from Hastie et al 2009 [1]_ and
+illustrates the difference in performance between the discrete SAMME [2]_
+boosting algorithm and real SAMME.R boosting algorithm. Both algorithms are
+evaluated on a binary classification task where the target Y is a non-linear
+function of 10 input features.
+
+Discrete SAMME AdaBoost adapts based on errors in predicted class labels
+whereas real SAMME.R uses the predicted class probabilities.
+
+.. [1] T. Hastie, R. Tibshirani and J. Friedman, "Elements of Statistical
+    Learning Ed. 2", Springer, 2009.
+
+.. [2] J. Zhu, H. Zou, S. Rosset, T. Hastie, "Multi-class AdaBoost", 2009.
+
+"""
+print(__doc__)
+
+# Author: Peter Prettenhofer <[email protected]>,
+#         Noel Dawe <[email protected]>
+#
+# License: BSD 3 clause
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from sklearn import datasets
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import zero_one_loss
+from sklearn.ensemble import AdaBoostClassifier
+
+
+n_estimators = 400
+# A learning rate of 1. may not be optimal for both SAMME and SAMME.R
+learning_rate = 1.
+
+X, y = datasets.make_hastie_10_2(n_samples=12000, random_state=1)
+
+X_test, y_test = X[2000:], y[2000:]
+X_train, y_train = X[:2000], y[:2000]
+
+dt_stump = DecisionTreeClassifier(max_depth=1)
+dt_stump.fit(X_train, y_train)
+dt_stump_err = 1.0 - dt_stump.score(X_test, y_test)
+
+dt = DecisionTreeClassifier(max_depth=9)
+dt.fit(X_train, y_train)
+dt_err = 1.0 - dt.score(X_test, y_test)
+
+ada_discrete = AdaBoostClassifier(
+    base_estimator=dt_stump,
+    learning_rate=learning_rate,
+    n_estimators=n_estimators,
+    algorithm="SAMME")
+ada_discrete.fit(X_train, y_train)
+
+ada_real = AdaBoostClassifier(
+    base_estimator=dt_stump,
+    learning_rate=learning_rate,
+    n_estimators=n_estimators,
+    algorithm="SAMME.R")
+ada_real.fit(X_train, y_train)
+
+fig = plt.figure()
+ax = fig.add_subplot(111)
+
+ax.plot([1, n_estimators], [dt_stump_err] * 2, 'k-',
+        label='Decision Stump Error')
+ax.plot([1, n_estimators], [dt_err] * 2, 'k--',
+        label='Decision Tree Error')
+
+ada_discrete_err = np.zeros((n_estimators,))
+for i, y_pred in enumerate(ada_discrete.staged_predict(X_test)):
+    ada_discrete_err[i] = zero_one_loss(y_pred, y_test)
+
+ada_discrete_err_train = np.zeros((n_estimators,))
+for i, y_pred in enumerate(ada_discrete.staged_predict(X_train)):
+    ada_discrete_err_train[i] = zero_one_loss(y_pred, y_train)
+
+ada_real_err = np.zeros((n_estimators,))
+for i, y_pred in enumerate(ada_real.staged_predict(X_test)):
+    ada_real_err[i] = zero_one_loss(y_pred, y_test)
+
+ada_real_err_train = np.zeros((n_estimators,))
+for i, y_pred in enumerate(ada_real.staged_predict(X_train)):
+    ada_real_err_train[i] = zero_one_loss(y_pred, y_train)
+
+ax.plot(np.arange(n_estimators) + 1, ada_discrete_err,
+        label='Discrete AdaBoost Test Error',
+        color='red')
+ax.plot(np.arange(n_estimators) + 1, ada_discrete_err_train,
+        label='Discrete AdaBoost Train Error',
+        color='blue')
+ax.plot(np.arange(n_estimators) + 1, ada_real_err,
+        label='Real AdaBoost Test Error',
+        color='orange')
+ax.plot(np.arange(n_estimators) + 1, ada_real_err_train,
+        label='Real AdaBoost Train Error',
+        color='green')
+
+ax.set_ylim((0.0, 0.5))
+ax.set_xlabel('n_estimators')
+ax.set_ylabel('error rate')
+
+leg = ax.legend(loc='upper right', fancybox=True)
+leg.get_frame().set_alpha(0.7)
+
+plt.show()