Pushing the docs to dev/ for branch: master, commit ae4f7104d65cecef11c26208bb15266b43ddc0a2

Author: sklearn-ci

dev/_downloads/auto_examples_jupyter.zip

@@ -0,0 +1,54 @@
+{
+  "nbformat_minor": 0, 
+  "nbformat": 4, 
+  "cells": [
+    {
+      "execution_count": null, 
+      "cell_type": "code", 
+      "source": [
+        "%matplotlib inline"
+      ], 
+      "outputs": [], 
+      "metadata": {
+        "collapsed": false
+      }
+    }, 
+    {
+      "source": [
+        "\n# Beta-divergence loss functions\n\n\nA plot that compares the various Beta-divergence loss functions supported by\nthe Multiplicative-Update ('mu') solver in :class:`sklearn.decomposition.NMF`.\n\n"
+      ], 
+      "cell_type": "markdown", 
+      "metadata": {}
+    }, 
+    {
+      "execution_count": null, 
+      "cell_type": "code", 
+      "source": [
+        "import numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.decomposition.nmf import _beta_divergence\n\nprint(__doc__)\n\nx = np.linspace(0.001, 4, 1000)\ny = np.zeros(x.shape)\n\ncolors = 'mbgyr'\nfor j, beta in enumerate((0., 0.5, 1., 1.5, 2.)):\n    for i, xi in enumerate(x):\n        y[i] = _beta_divergence(1, xi, 1, beta)\n    name = \"beta = %1.1f\" % beta\n    plt.plot(x, y, label=name, color=colors[j])\n\nplt.xlabel(\"x\")\nplt.title(\"beta-divergence(1, x)\")\nplt.legend(loc=0)\nplt.axis([0, 4, 0, 3])\nplt.show()"
+      ], 
+      "outputs": [], 
+      "metadata": {
+        "collapsed": false
+      }
+    }
+  ], 
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 2", 
+      "name": "python2", 
+      "language": "python"
+    }, 
+    "language_info": {
+      "mimetype": "text/x-python", 
+      "nbconvert_exporter": "python", 
+      "name": "python", 
+      "file_extension": ".py", 
+      "version": "2.7.12", 
+      "pygments_lexer": "ipython2", 
+      "codemirror_mode": {
+        "version": 2, 
+        "name": "ipython"
+      }
+    }
+  }
+}

dev/_downloads/auto_examples_python.zip

@@ -0,0 +1,29 @@
+"""
+==============================
+Beta-divergence loss functions
+==============================
+
+A plot that compares the various Beta-divergence loss functions supported by
+the Multiplicative-Update ('mu') solver in :class:`sklearn.decomposition.NMF`.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.decomposition.nmf import _beta_divergence
+
+print(__doc__)
+
+x = np.linspace(0.001, 4, 1000)
+y = np.zeros(x.shape)
+
+colors = 'mbgyr'
+for j, beta in enumerate((0., 0.5, 1., 1.5, 2.)):
+    for i, xi in enumerate(x):
+        y[i] = _beta_divergence(1, xi, 1, beta)
+    name = "beta = %1.1f" % beta
+    plt.plot(x, y, label=name, color=colors[j])
+
+plt.xlabel("x")
+plt.title("beta-divergence(1, x)")
+plt.legend(loc=0)
+plt.axis([0, 4, 0, 3])
+plt.show()

dev/_downloads/plot_beta_divergence.ipynb

@@ -15,7 +15,7 @@
     }, 
     {
       "source": [
-        "\n# Topic extraction with Non-negative Matrix Factorization and Latent Dirichlet Allocation\n\n\nThis is an example of applying :class:`sklearn.decomposition.NMF`\nand :class:`sklearn.decomposition.LatentDirichletAllocation` on a corpus of documents and\nextract additive models of the topic structure of the corpus.\nThe output is a list of topics, each represented as a list of terms\n(weights are not shown).\n\nThe default parameters (n_samples / n_features / n_topics) should make\nthe example runnable in a couple of tens of seconds. You can try to\nincrease the dimensions of the problem, but be aware that the time\ncomplexity is polynomial in NMF. In LDA, the time complexity is\nproportional to (n_samples * iterations).\n\n"
+        "\n# Topic extraction with Non-negative Matrix Factorization and Latent Dirichlet Allocation\n\n\nThis is an example of applying :class:`sklearn.decomposition.NMF`\nand :class:`sklearn.decomposition.LatentDirichletAllocation` on a corpus of documents and\nextract additive models of the topic structure of the corpus.\nThe output is a list of topics, each represented as a list of terms\n(weights are not shown).\n\nNon-negative Matrix Factorization is applied with two different objective\nfunctions: the Frobenius norm, and the generalized Kullback-Leibler divergence.\nThe latter is equivalent to Probabilistic Latent Semantic Indexing.\n\nThe default parameters (n_samples / n_features / n_topics) should make\nthe example runnable in a couple of tens of seconds. You can try to\nincrease the dimensions of the problem, but be aware that the time\ncomplexity is polynomial in NMF. In LDA, the time complexity is\nproportional to (n_samples * iterations).\n\n"
       ], 
       "cell_type": "markdown", 
       "metadata": {}
@@ -24,7 +24,7 @@
       "execution_count": null, 
       "cell_type": "code", 
       "source": [
-        "# Author: Olivier Grisel <[email protected]>\n#         Lars Buitinck\n#         Chyi-Kwei Yau <[email protected]>\n# License: BSD 3 clause\n\nfrom __future__ import print_function\nfrom time import time\n\nfrom sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer\nfrom sklearn.decomposition import NMF, LatentDirichletAllocation\nfrom sklearn.datasets import fetch_20newsgroups\n\nn_samples = 2000\nn_features = 1000\nn_topics = 10\nn_top_words = 20\n\n\ndef print_top_words(model, feature_names, n_top_words):\n    for topic_idx, topic in enumerate(model.components_):\n        print(\"Topic #%d:\" % topic_idx)\n        print(\" \".join([feature_names[i]\n                        for i in topic.argsort()[:-n_top_words - 1:-1]]))\n    print()\n\n\n# Load the 20 newsgroups dataset and vectorize it. We use a few heuristics\n# to filter out useless terms early on: the posts are stripped of headers,\n# footers and quoted replies, and common English words, words occurring in\n# only one document or in at least 95% of the documents are removed.\n\nprint(\"Loading dataset...\")\nt0 = time()\ndataset = fetch_20newsgroups(shuffle=True, random_state=1,\n                             remove=('headers', 'footers', 'quotes'))\ndata_samples = dataset.data[:n_samples]\nprint(\"done in %0.3fs.\" % (time() - t0))\n\n# Use tf-idf features for NMF.\nprint(\"Extracting tf-idf features for NMF...\")\ntfidf_vectorizer = TfidfVectorizer(max_df=0.95, min_df=2,\n                                   max_features=n_features,\n                                   stop_words='english')\nt0 = time()\ntfidf = tfidf_vectorizer.fit_transform(data_samples)\nprint(\"done in %0.3fs.\" % (time() - t0))\n\n# Use tf (raw term count) features for LDA.\nprint(\"Extracting tf features for LDA...\")\ntf_vectorizer = CountVectorizer(max_df=0.95, min_df=2,\n                                max_features=n_features,\n                                stop_words='english')\nt0 = time()\ntf = tf_vectorizer.fit_transform(data_samples)\nprint(\"done in %0.3fs.\" % (time() - t0))\n\n# Fit the NMF model\nprint(\"Fitting the NMF model with tf-idf features, \"\n      \"n_samples=%d and n_features=%d...\"\n      % (n_samples, n_features))\nt0 = time()\nnmf = NMF(n_components=n_topics, random_state=1,\n          alpha=.1, l1_ratio=.5).fit(tfidf)\nprint(\"done in %0.3fs.\" % (time() - t0))\n\nprint(\"\\nTopics in NMF model:\")\ntfidf_feature_names = tfidf_vectorizer.get_feature_names()\nprint_top_words(nmf, tfidf_feature_names, n_top_words)\n\nprint(\"Fitting LDA models with tf features, \"\n      \"n_samples=%d and n_features=%d...\"\n      % (n_samples, n_features))\nlda = LatentDirichletAllocation(n_topics=n_topics, max_iter=5,\n                                learning_method='online',\n                                learning_offset=50.,\n                                random_state=0)\nt0 = time()\nlda.fit(tf)\nprint(\"done in %0.3fs.\" % (time() - t0))\n\nprint(\"\\nTopics in LDA model:\")\ntf_feature_names = tf_vectorizer.get_feature_names()\nprint_top_words(lda, tf_feature_names, n_top_words)"
+        "# Author: Olivier Grisel <[email protected]>\n#         Lars Buitinck\n#         Chyi-Kwei Yau <[email protected]>\n# License: BSD 3 clause\n\nfrom __future__ import print_function\nfrom time import time\n\nfrom sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer\nfrom sklearn.decomposition import NMF, LatentDirichletAllocation\nfrom sklearn.datasets import fetch_20newsgroups\n\nn_samples = 2000\nn_features = 1000\nn_topics = 10\nn_top_words = 20\n\n\ndef print_top_words(model, feature_names, n_top_words):\n    for topic_idx, topic in enumerate(model.components_):\n        message = \"Topic #%d: \" % topic_idx\n        message += \" \".join([feature_names[i]\n                             for i in topic.argsort()[:-n_top_words - 1:-1]])\n        print(message)\n    print()\n\n\n# Load the 20 newsgroups dataset and vectorize it. We use a few heuristics\n# to filter out useless terms early on: the posts are stripped of headers,\n# footers and quoted replies, and common English words, words occurring in\n# only one document or in at least 95% of the documents are removed.\n\nprint(\"Loading dataset...\")\nt0 = time()\ndataset = fetch_20newsgroups(shuffle=True, random_state=1,\n                             remove=('headers', 'footers', 'quotes'))\ndata_samples = dataset.data[:n_samples]\nprint(\"done in %0.3fs.\" % (time() - t0))\n\n# Use tf-idf features for NMF.\nprint(\"Extracting tf-idf features for NMF...\")\ntfidf_vectorizer = TfidfVectorizer(max_df=0.95, min_df=2,\n                                   max_features=n_features,\n                                   stop_words='english')\nt0 = time()\ntfidf = tfidf_vectorizer.fit_transform(data_samples)\nprint(\"done in %0.3fs.\" % (time() - t0))\n\n# Use tf (raw term count) features for LDA.\nprint(\"Extracting tf features for LDA...\")\ntf_vectorizer = CountVectorizer(max_df=0.95, min_df=2,\n                                max_features=n_features,\n                                stop_words='english')\nt0 = time()\ntf = tf_vectorizer.fit_transform(data_samples)\nprint(\"done in %0.3fs.\" % (time() - t0))\nprint()\n\n# Fit the NMF model\nprint(\"Fitting the NMF model (Frobenius norm) with tf-idf features, \"\n      \"n_samples=%d and n_features=%d...\"\n      % (n_samples, n_features))\nt0 = time()\nnmf = NMF(n_components=n_topics, random_state=1,\n          alpha=.1, l1_ratio=.5).fit(tfidf)\nprint(\"done in %0.3fs.\" % (time() - t0))\n\nprint(\"\\nTopics in NMF model (Frobenius norm):\")\ntfidf_feature_names = tfidf_vectorizer.get_feature_names()\nprint_top_words(nmf, tfidf_feature_names, n_top_words)\n\n# Fit the NMF model\nprint(\"Fitting the NMF model (generalized Kullback-Leibler divergence) with \"\n      \"tf-idf features, n_samples=%d and n_features=%d...\"\n      % (n_samples, n_features))\nt0 = time()\nnmf = NMF(n_components=n_topics, random_state=1, beta_loss='kullback-leibler',\n          solver='mu', max_iter=1000, alpha=.1, l1_ratio=.5).fit(tfidf)\nprint(\"done in %0.3fs.\" % (time() - t0))\n\nprint(\"\\nTopics in NMF model (generalized Kullback-Leibler divergence):\")\ntfidf_feature_names = tfidf_vectorizer.get_feature_names()\nprint_top_words(nmf, tfidf_feature_names, n_top_words)\n\nprint(\"Fitting LDA models with tf features, \"\n      \"n_samples=%d and n_features=%d...\"\n      % (n_samples, n_features))\nlda = LatentDirichletAllocation(n_topics=n_topics, max_iter=5,\n                                learning_method='online',\n                                learning_offset=50.,\n                                random_state=0)\nt0 = time()\nlda.fit(tf)\nprint(\"done in %0.3fs.\" % (time() - t0))\n\nprint(\"\\nTopics in LDA model:\")\ntf_feature_names = tf_vectorizer.get_feature_names()\nprint_top_words(lda, tf_feature_names, n_top_words)"
       ], 
       "outputs": [], 
       "metadata": {

dev/_downloads/plot_beta_divergence.py

@@ -9,6 +9,10 @@
 The output is a list of topics, each represented as a list of terms
 (weights are not shown).
 
+Non-negative Matrix Factorization is applied with two different objective
+functions: the Frobenius norm, and the generalized Kullback-Leibler divergence.
+The latter is equivalent to Probabilistic Latent Semantic Indexing.
+
 The default parameters (n_samples / n_features / n_topics) should make
 the example runnable in a couple of tens of seconds. You can try to
 increase the dimensions of the problem, but be aware that the time
@@ -36,9 +40,10 @@
 
 def print_top_words(model, feature_names, n_top_words):
     for topic_idx, topic in enumerate(model.components_):
-        print("Topic #%d:" % topic_idx)
-        print(" ".join([feature_names[i]
-                        for i in topic.argsort()[:-n_top_words - 1:-1]]))
+        message = "Topic #%d: " % topic_idx
+        message += " ".join([feature_names[i]
+                             for i in topic.argsort()[:-n_top_words - 1:-1]])
+        print(message)
     print()
 
 
@@ -71,17 +76,31 @@ def print_top_words(model, feature_names, n_top_words):
 t0 = time()
 tf = tf_vectorizer.fit_transform(data_samples)
 print("done in %0.3fs." % (time() - t0))
+print()
 
 # Fit the NMF model
-print("Fitting the NMF model with tf-idf features, "
+print("Fitting the NMF model (Frobenius norm) with tf-idf features, "
       "n_samples=%d and n_features=%d..."
       % (n_samples, n_features))
 t0 = time()
 nmf = NMF(n_components=n_topics, random_state=1,
           alpha=.1, l1_ratio=.5).fit(tfidf)
 print("done in %0.3fs." % (time() - t0))
 
-print("\nTopics in NMF model:")
+print("\nTopics in NMF model (Frobenius norm):")
+tfidf_feature_names = tfidf_vectorizer.get_feature_names()
+print_top_words(nmf, tfidf_feature_names, n_top_words)
+
+# Fit the NMF model
+print("Fitting the NMF model (generalized Kullback-Leibler divergence) with "
+      "tf-idf features, n_samples=%d and n_features=%d..."
+      % (n_samples, n_features))
+t0 = time()
+nmf = NMF(n_components=n_topics, random_state=1, beta_loss='kullback-leibler',
+          solver='mu', max_iter=1000, alpha=.1, l1_ratio=.5).fit(tfidf)
+print("done in %0.3fs." % (time() - t0))
+
+print("\nTopics in NMF model (generalized Kullback-Leibler divergence):")
 tfidf_feature_names = tfidf_vectorizer.get_feature_names()
 print_top_words(nmf, tfidf_feature_names, n_top_words)