scikit_train_5labels.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:8ed1433e6c7c3973b3fb696e2f5957a828a80a3834de4d99cfb3012302eb95f3"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%matplotlib inline\n",
      "import matplotlib.pyplot as plt\n",
      "import numpy as np\n",
      "import story_teller\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "These are my modules. This is inspired by classification example from scikit learn \n",
      "\n",
      "http://scikit-learn.org/stable/auto_examples/text/document_classification_20newsgroups.html#example-text-document-classification-20newsgroups-py\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import print_function\n",
      "from sklearn.feature_extraction.text import TfidfVectorizer\n",
      "from sklearn.feature_extraction.text import HashingVectorizer\n",
      "from sklearn.feature_selection import SelectKBest, chi2\n",
      "from sklearn.linear_model import RidgeClassifier\n",
      "from sklearn.pipeline import Pipeline\n",
      "from sklearn.svm import LinearSVC\n",
      "from sklearn.linear_model import SGDClassifier\n",
      "from sklearn.linear_model import Perceptron\n",
      "from sklearn.linear_model import PassiveAggressiveClassifier\n",
      "from sklearn.naive_bayes import BernoulliNB, MultinomialNB\n",
      "from sklearn.neighbors import KNeighborsClassifier\n",
      "from sklearn.neighbors import NearestCentroid\n",
      "from sklearn.ensemble import RandomForestClassifier\n",
      "from sklearn.utils.extmath import density\n",
      "from sklearn import metrics\n",
      "import logging\n",
      "from time import time\n",
      "# Display progress logs on stdout\n",
      "logging.basicConfig(level=logging.INFO,\n",
      "                    format='%(asctime)s %(levelname)s %(message)s')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Fill the data below in order to use the subsequence script, use small amount of sample to test if it works first"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# training data -> this is the text, goes into X_train\n",
      "class DataContainer(object):\n",
      "    def __init__(self, starter):\n",
      "        self.data = starter\n",
      "        \n",
      "        \n",
      "trainingData = story_teller.trainingData(10)\n",
      "data_train = DataContainer(trainingData['data'])\n",
      "# training label, aligned with data_train.data\n",
      "y_train = trainingData['targets']\n",
      "# test data, goes into X_test\n",
      "testData = story_teller.testingData(10)\n",
      "data_test = DataContainer(testData['data'])\n",
      "# test label\n",
      "y_test = testData['targets']\n",
      "categories = story_teller.getCategories()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Feature extraction with tfidf"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def size_mb(docs):\n",
      "    return sum(len(s) for s in docs) / 1e6\n",
      "\n",
      "data_train_size_mb = size_mb(data_train.data)\n",
      "data_test_size_mb = size_mb(data_test.data)\n",
      "\n",
      "print(\"%d documents - %0.3fMB (training set)\" % (\n",
      "    len(data_train.data), data_train_size_mb))\n",
      "print(\"%d documents - %0.3fMB (test set)\" % (\n",
      "    len(data_test.data), data_test_size_mb))\n",
      "print(\"%d categories\" % len(categories))\n",
      "\n",
      "print(\"Extracting features from the training data using a sparse vectorizer\")\n",
      "t0 = time()\n",
      "\n",
      "vectorizer = TfidfVectorizer(sublinear_tf=True, max_df=0.5,\n",
      "                                 stop_words='english')\n",
      "X_train = vectorizer.fit_transform(data_train.data)\n",
      "duration = time() - t0\n",
      "print(\"done in %fs at %0.3fMB/s\" % (duration, data_train_size_mb / duration))\n",
      "print(\"n_samples: %d, n_features: %d\" % X_train.shape)\n",
      "print()\n",
      "\n",
      "print(\"Extracting features from the test data using the same vectorizer\")\n",
      "t0 = time()\n",
      "X_test = vectorizer.transform(data_test.data)\n",
      "duration = time() - t0\n",
      "print(\"done in %fs at %0.3fMB/s\" % (duration, data_test_size_mb / duration))\n",
      "print(\"n_samples: %d, n_features: %d\" % X_test.shape)\n",
      "print()\n",
      "\n",
      "# mapping from integer feature name to original token string\n",
      "feature_names = vectorizer.get_feature_names()\n",
      "if feature_names:\n",
      "    feature_names = np.asarray(feature_names)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "50 documents - 0.308MB (training set)\n",
        "50 documents - 0.470MB (test set)\n",
        "5 categories\n",
        "Extracting features from the training data using a sparse vectorizer\n",
        "done in 0.068730s at 4.478MB/s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "n_samples: 50, n_features: 6842\n",
        "\n",
        "Extracting features from the test data using the same vectorizer\n",
        "done in 0.067676s at 6.952MB/s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "n_samples: 50, n_features: 6842\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def trim(s):\n",
      "    \"\"\"Trim string to fit on terminal (assuming 80-column display)\"\"\"\n",
      "    return s if len(s) <= 80 else s[:77] + \"...\"\n",
      "\n",
      "\n",
      "###############################################################################\n",
      "# Benchmark classifiers\n",
      "def benchmark(clf):\n",
      "    print('_' * 80)\n",
      "    print(\"Training: \")\n",
      "    print(clf)\n",
      "    t0 = time()\n",
      "    clf.fit(X_train, y_train)\n",
      "    train_time = time() - t0\n",
      "    print(\"train time: %0.3fs\" % train_time)\n",
      "\n",
      "    t0 = time()\n",
      "    pred = clf.predict(X_test)\n",
      "    test_time = time() - t0\n",
      "    print(\"test time:  %0.3fs\" % test_time)\n",
      "\n",
      "    score = metrics.accuracy_score(y_test, pred)\n",
      "    print(\"accuracy:   %0.3f\" % score)\n",
      "\n",
      "    # XXX some printing options\n",
      "    if (False) :\n",
      "        if hasattr(clf, 'coef_'):\n",
      "            print(\"dimensionality: %d\" % clf.coef_.shape[1])\n",
      "            print(\"density: %f\" % density(clf.coef_))\n",
      "\n",
      "            if feature_names is not None:\n",
      "                print(\"top 10 keywords per class:\")\n",
      "                for i, category in enumerate(categories):\n",
      "                    top10 = np.argsort(clf.coef_[i])[-10:]\n",
      "                    print(trim(\"%s: %s\"\n",
      "                          % (category, \" \".join(feature_names[top10]))))\n",
      "            print()\n",
      "\n",
      "        print(\"classification report:\")\n",
      "        print(metrics.classification_report(y_test, pred,\n",
      "                                                target_names=categories))\n",
      "\n",
      "        print(\"confusion matrix:\")\n",
      "        print(metrics.confusion_matrix(y_test, pred))\n",
      "\n",
      "    print()\n",
      "    clf_descr = str(clf).split('(')[0]\n",
      "    return clf_descr, score, train_time, test_time\n",
      "\n",
      "print(\"start training\")\n",
      "results = []\n",
      "for clf, name in (\n",
      "        (RidgeClassifier(tol=1e-2, solver=\"lsqr\"), \"Ridge Classifier\"),\n",
      "        (Perceptron(n_iter=50), \"Perceptron\"),\n",
      "        (PassiveAggressiveClassifier(n_iter=50), \"Passive-Aggressive\"),\n",
      "        (KNeighborsClassifier(n_neighbors=10), \"kNN\"),\n",
      "        (RandomForestClassifier(n_estimators=100), \"Random forest\")):\n",
      "    print('=' * 80)\n",
      "    print(name)\n",
      "    results.append(benchmark(clf))\n",
      "\n",
      "for penalty in [\"l2\", \"l1\"]:\n",
      "    print('=' * 80)\n",
      "    print(\"%s penalty\" % penalty.upper())\n",
      "    # Train Liblinear model\n",
      "    results.append(benchmark(LinearSVC(loss='l2', penalty=penalty,\n",
      "                                            dual=False, tol=1e-3)))\n",
      "\n",
      "    # Train SGD model\n",
      "    results.append(benchmark(SGDClassifier(alpha=.0001, n_iter=50,\n",
      "                                           penalty=penalty)))\n",
      "\n",
      "# Train SGD with Elastic Net penalty\n",
      "print('=' * 80)\n",
      "print(\"Elastic-Net penalty\")\n",
      "results.append(benchmark(SGDClassifier(alpha=.0001, n_iter=50,\n",
      "                                       penalty=\"elasticnet\")))\n",
      "\n",
      "# Train NearestCentroid without threshold\n",
      "print('=' * 80)\n",
      "print(\"NearestCentroid (aka Rocchio classifier)\")\n",
      "results.append(benchmark(NearestCentroid()))\n",
      "\n",
      "# Train sparse Naive Bayes classifiers\n",
      "print('=' * 80)\n",
      "print(\"Naive Bayes\")\n",
      "results.append(benchmark(MultinomialNB(alpha=.01)))\n",
      "results.append(benchmark(BernoulliNB(alpha=.01)))\n",
      "\n",
      "print('=' * 80)\n",
      "print(\"LinearSVC with L1-based feature selection\")\n",
      "# The smaller C, the stronger the regularization.\n",
      "# The more regularization, the more sparsity.\n",
      "results.append(benchmark(Pipeline([\n",
      "  ('feature_selection', LinearSVC(penalty=\"l1\", dual=False, tol=1e-3)),\n",
      "  ('classification', LinearSVC())\n",
      "])))\n",
      "\n",
      "# make some plots\n",
      "\n",
      "indices = np.arange(len(results))\n",
      "\n",
      "results = [[x[i] for x in results] for i in range(4)]\n",
      "\n",
      "clf_names, score, training_time, test_time = results\n",
      "training_time = np.array(training_time) / np.max(training_time)\n",
      "test_time = np.array(test_time) / np.max(test_time)\n",
      "\n",
      "plt.figure(figsize=(12, 8))\n",
      "plt.title(\"Score\")\n",
      "plt.barh(indices, score, .2, label=\"score\", color='r')\n",
      "plt.barh(indices + .3, training_time, .2, label=\"training time\", color='g')\n",
      "plt.barh(indices + .6, test_time, .2, label=\"test time\", color='b')\n",
      "plt.yticks(())\n",
      "plt.legend(loc='best')\n",
      "plt.subplots_adjust(left=.25)\n",
      "plt.subplots_adjust(top=.95)\n",
      "plt.subplots_adjust(bottom=.05)\n",
      "\n",
      "for i, c in zip(indices, clf_names):\n",
      "    plt.text(-.3, i, c)\n",
      "\n",
      "plt.show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "start training\n",
        "================================================================================\n",
        "Ridge Classifier\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "RidgeClassifier(alpha=1.0, class_weight=None, copy_X=True, fit_intercept=True,\n",
        "        max_iter=None, normalize=False, solver='lsqr', tol=0.01)\n",
        "train time: 0.012s\n",
        "test time:  0.000s\n",
        "accuracy:   0.160\n",
        "\n",
        "================================================================================\n",
        "Perceptron\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "Perceptron(alpha=0.0001, class_weight=None, eta0=1.0, fit_intercept=True,\n",
        "      n_iter=50, n_jobs=1, penalty=None, random_state=0, shuffle=True,\n",
        "      verbose=0, warm_start=False)\n",
        "train time: 0.011s\n",
        "test time:  0.000s\n",
        "accuracy:   0.260\n",
        "\n",
        "================================================================================\n",
        "Passive-Aggressive\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "PassiveAggressiveClassifier(C=1.0, fit_intercept=True, loss='hinge',\n",
        "              n_iter=50, n_jobs=1, random_state=None, shuffle=True,\n",
        "              verbose=0, warm_start=False)\n",
        "train time: 0.014s\n",
        "test time:  0.001s\n",
        "accuracy:   0.160\n",
        "\n",
        "================================================================================\n",
        "kNN\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
        "           metric_params=None, n_neighbors=10, p=2, weights='uniform')\n",
        "train time: 0.000s\n",
        "test time:  0.002s\n",
        "accuracy:   0.200\n",
        "\n",
        "================================================================================\n",
        "Random forest\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
        "            max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
        "            min_samples_leaf=1, min_samples_split=2,\n",
        "            min_weight_fraction_leaf=0.0, n_estimators=100, n_jobs=1,\n",
        "            oob_score=False, random_state=None, verbose=0,\n",
        "            warm_start=False)\n",
        "train time: 0.096s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.014s\n",
        "accuracy:   0.120\n",
        "\n",
        "================================================================================\n",
        "L2 penalty\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "LinearSVC(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
        "     intercept_scaling=1, loss='l2', max_iter=1000, multi_class='ovr',\n",
        "     penalty='l2', random_state=None, tol=0.001, verbose=0)\n",
        "train time: 0.013s\n",
        "test time:  0.000s\n",
        "accuracy:   0.180\n",
        "\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
        "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
        "       learning_rate='optimal', loss='hinge', n_iter=50, n_jobs=1,\n",
        "       penalty='l2', power_t=0.5, random_state=None, shuffle=True,\n",
        "       verbose=0, warm_start=False)\n",
        "train time: 0.011s\n",
        "test time:  0.000s\n",
        "accuracy:   0.260\n",
        "\n",
        "================================================================================\n",
        "L1 penalty\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "LinearSVC(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
        "     intercept_scaling=1, loss='l2', max_iter=1000, multi_class='ovr',\n",
        "     penalty='l1', random_state=None, tol=0.001, verbose=0)\n",
        "train time: 0.010s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.000s\n",
        "accuracy:   0.260\n",
        "\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
        "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
        "       learning_rate='optimal', loss='hinge', n_iter=50, n_jobs=1,\n",
        "       penalty='l1', power_t=0.5, random_state=None, shuffle=True,\n",
        "       verbose=0, warm_start=False)\n",
        "train time: 0.032s\n",
        "test time:  0.000s\n",
        "accuracy:   0.240\n",
        "\n",
        "================================================================================\n",
        "Elastic-Net penalty\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
        "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
        "       learning_rate='optimal', loss='hinge', n_iter=50, n_jobs=1,\n",
        "       penalty='elasticnet', power_t=0.5, random_state=None, shuffle=True,\n",
        "       verbose=0, warm_start=False)\n",
        "train time: 0.035s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.000s\n",
        "accuracy:   0.160\n",
        "\n",
        "================================================================================\n",
        "NearestCentroid (aka Rocchio classifier)\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "NearestCentroid(metric='euclidean', shrink_threshold=None)\n",
        "train time: 0.005s\n",
        "test time:  0.001s\n",
        "accuracy:   0.180\n",
        "\n",
        "================================================================================\n",
        "Naive Bayes\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "MultinomialNB(alpha=0.01, class_prior=None, fit_prior=True)\n",
        "train time: 0.003s\n",
        "test time:  0.000s\n",
        "accuracy:   0.200\n",
        "\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "BernoulliNB(alpha=0.01, binarize=0.0, class_prior=None, fit_prior=True)\n",
        "train time: 0.003s\n",
        "test time:  0.002s\n",
        "accuracy:   0.180\n",
        "\n",
        "================================================================================\n",
        "LinearSVC with L1-based feature selection\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "Pipeline(steps=[('feature_selection', LinearSVC(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
        "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
        "     multi_class='ovr', penalty='l1', random_state=None, tol=0.001,\n",
        "     verbose=0)), ('classification', LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,\n",
        "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
        "     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,\n",
        "     verbose=0))])\n",
        "train time: 0.013s\n",
        "test time:  0.002s\n",
        "accuracy:   0.220\n",
        "\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": [
        "/home/wzheng02/workspace/py_ml/py29/lib/python2.7/site-packages/sklearn/svm/classes.py:192: DeprecationWarning: loss='l2' has been deprecated in favor of loss='squared_hinge' as of 0.16. Backward compatibility for the loss='l2' will be removed in 1.0\n",
        "  DeprecationWarning)\n",
        "/home/wzheng02/workspace/py_ml/py29/lib/python2.7/site-packages/sklearn/svm/classes.py:192: DeprecationWarning: loss='l2' has been deprecated in favor of loss='squared_hinge' as of 0.16. Backward compatibility for the loss='l2' will be removed in 1.0\n",
        "  DeprecationWarning)\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAu8AAAIxCAYAAAD9t1YOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/w87oZrcr963VAAAAABJRU5ErkJggg==\n",
       "text": [
        "<matplotlib.figure.Figure at 0x7fa743cd61d0>"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "with 50 training sample:\n",
      "RandomForestClassifier takes a lot longer than the other ones, killing it. rerun with slightly larger data;\n",
      "with 250 training sample:\n",
      "some improvement across the board, tied\n",
      "\n",
      "with 500 sample\n",
      "linear svc with L1 stayed below 0.2 accuracy, throw it away\n",
      "K neighbours takes a bit long, SGD classifier is slow as well\n",
      "================================================================================\n",
      "Ridge Classifier\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "RidgeClassifier(alpha=1.0, class_weight=None, copy_X=True, fit_intercept=True,\n",
      "        max_iter=None, normalize=False, solver='lsqr', tol=0.01)\n",
      "train time: 0.034s\n",
      "test time:  0.001s\n",
      "accuracy:   0.300\n",
      "\n",
      "================================================================================\n",
      "Perceptron\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "Perceptron(alpha=0.0001, class_weight=None, eta0=1.0, fit_intercept=True,\n",
      "      n_iter=50, n_jobs=1, penalty=None, random_state=0, shuffle=True,\n",
      "      verbose=0, warm_start=False)\n",
      "train time: 0.115s\n",
      "test time:  0.001s\n",
      "accuracy:   0.233\n",
      "\n",
      "================================================================================\n",
      "Passive-Aggressive\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "PassiveAggressiveClassifier(C=1.0, fit_intercept=True, loss='hinge',\n",
      "              n_iter=50, n_jobs=1, random_state=None, shuffle=True,\n",
      "              verbose=0, warm_start=False)\n",
      "train time: 0.150s\n",
      "test time:  0.001s\n",
      "accuracy:   0.267\n",
      "\n",
      "================================================================================\n",
      "kNN\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
      "           metric_params=None, n_neighbors=10, p=2, weights='uniform')\n",
      "train time: 0.001s\n",
      "test time:  0.018s\n",
      "accuracy:   0.200\n",
      "\n",
      "================================================================================\n",
      "L2 penalty\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "LinearSVC(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='l2', max_iter=1000, multi_class='ovr',\n",
      "     penalty='l2', random_state=None, tol=0.001, verbose=0)\n",
      "train time: 0.168s\n",
      "test time:  0.001s\n",
      "accuracy:   0.287\n",
      "\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
      "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
      "       learning_rate='optimal', loss='hinge', n_iter=50, n_jobs=1,\n",
      "       penalty='l2', power_t=0.5, random_state=None, shuffle=True,\n",
      "       verbose=0, warm_start=False)\n",
      "train time: 0.104s\n",
      "test time:  0.001s\n",
      "accuracy:   0.247\n",
      "\n",
      "================================================================================\n",
      "Elastic-Net penalty\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
      "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
      "       learning_rate='optimal', loss='hinge', n_iter=50, n_jobs=1,\n",
      "       penalty='elasticnet', power_t=0.5, random_state=None, shuffle=True,\n",
      "       verbose=0, warm_start=False)\n",
      "train time: 0.576s\n",
      "test time:  0.001s\n",
      "accuracy:   0.240\n",
      "\n",
      "================================================================================\n",
      "NearestCentroid (aka Rocchio classifier)\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "NearestCentroid(metric='euclidean', shrink_threshold=None)\n",
      "train time: 0.010s\n",
      "test time:  0.002s\n",
      "accuracy:   0.287\n",
      "\n",
      "================================================================================\n",
      "Naive Bayes\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "MultinomialNB(alpha=0.01, class_prior=None, fit_prior=True)\n",
      "train time: 0.010s\n",
      "test time:  0.001s\n",
      "accuracy:   0.227\n",
      "\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "BernoulliNB(alpha=0.01, binarize=0.0, class_prior=None, fit_prior=True)\n",
      "train time: 0.011s\n",
      "test time:  0.010s\n",
      "accuracy:   0.260\n",
      "\n",
      "================================================================================\n",
      "LinearSVC with L1-based feature selection\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "Pipeline(steps=[('feature_selection', LinearSVC(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
      "     multi_class='ovr', penalty='l1', random_state=None, tol=0.001,\n",
      "     verbose=0)), ('classification', LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
      "     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,\n",
      "     verbose=0))])\n",
      "train time: 0.124s\n",
      "test time:  0.004s\n",
      "accuracy:   0.233"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "with 2500 samples\n",
      "accuracy dropped?\n",
      "```\n",
      "================================================================================\n",
      "Ridge Classifier\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "RidgeClassifier(alpha=1.0, class_weight=None, copy_X=True, fit_intercept=True,\n",
      "        max_iter=None, normalize=False, solver='lsqr', tol=0.01)\n",
      "train time: 0.286s\n",
      "test time:  0.003s\n",
      "accuracy:   0.216\n",
      "\n",
      "================================================================================\n",
      "Perceptron\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "Perceptron(alpha=0.0001, class_weight=None, eta0=1.0, fit_intercept=True,\n",
      "      n_iter=50, n_jobs=1, penalty=None, random_state=0, shuffle=True,\n",
      "      verbose=0, warm_start=False)\n",
      "train time: 0.546s\n",
      "test time:  0.006s\n",
      "accuracy:   0.202\n",
      "\n",
      "================================================================================\n",
      "Passive-Aggressive\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "PassiveAggressiveClassifier(C=1.0, fit_intercept=True, loss='hinge',\n",
      "              n_iter=50, n_jobs=1, random_state=None, shuffle=True,\n",
      "              verbose=0, warm_start=False)\n",
      "train time: 0.828s\n",
      "test time:  0.006s\n",
      "accuracy:   0.224\n",
      "\n",
      "================================================================================\n",
      "kNN\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
      "           metric_params=None, n_neighbors=10, p=2, weights='uniform')\n",
      "train time: 0.016s\n",
      "test time:  0.233s\n",
      "accuracy:   0.184\n",
      "\n",
      "================================================================================\n",
      "L2 penalty\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "LinearSVC(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='l2', max_iter=1000, multi_class='ovr',\n",
      "     penalty='l2', random_state=None, tol=0.001, verbose=0)\n",
      "train time: 1.113s\n",
      "test time:  0.002s\n",
      "accuracy:   0.212\n",
      "\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
      "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
      "       learning_rate='optimal', loss='hinge', n_iter=50, n_jobs=1,\n",
      "       penalty='l2', power_t=0.5, random_state=None, shuffle=True,\n",
      "       verbose=0, warm_start=False)\n",
      "train time: 0.658s\n",
      "test time:  0.003s\n",
      "accuracy:   0.218\n",
      "\n",
      "================================================================================\n",
      "Elastic-Net penalty\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
      "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
      "       learning_rate='optimal', loss='hinge', n_iter=50, n_jobs=1,\n",
      "       penalty='elasticnet', power_t=0.5, random_state=None, shuffle=True,\n",
      "       verbose=0, warm_start=False)\n",
      "train time: 3.345s\n",
      "test time:  0.003s\n",
      "accuracy:   0.210\n",
      "\n",
      "================================================================================\n",
      "NearestCentroid (aka Rocchio classifier)\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "NearestCentroid(metric='euclidean', shrink_threshold=None)\n",
      "train time: 0.042s\n",
      "test time:  0.005s\n",
      "accuracy:   0.230\n",
      "\n",
      "================================================================================\n",
      "Naive Bayes\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "MultinomialNB(alpha=0.01, class_prior=None, fit_prior=True)\n",
      "train time: 0.037s\n",
      "test time:  0.003s\n",
      "accuracy:   0.206\n",
      "\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "BernoulliNB(alpha=0.01, binarize=0.0, class_prior=None, fit_prior=True)\n",
      "train time: 0.045s\n",
      "test time:  0.033s\n",
      "accuracy:   0.244\n",
      "\n",
      "================================================================================\n",
      "LinearSVC with L1-based feature selection\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "Pipeline(steps=[('feature_selection', LinearSVC(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
      "     multi_class='ovr', penalty='l1', random_state=None, tol=0.001,\n",
      "     verbose=0)), ('classification', LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
      "     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,\n",
      "     verbose=0))])\n",
      "train time: 1.103s\n",
      "test time:  0.012s\n",
      "accuracy:   0.220\n",
      "```"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "With 3000 samples, kernal just died on passive-aggresive\n",
      "throw that away, we were able to run, but no improvements\n",
      "```\n",
      "================================================================================\n",
      "Ridge Classifier\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "RidgeClassifier(alpha=1.0, class_weight=None, copy_X=True, fit_intercept=True,\n",
      "        max_iter=None, normalize=False, solver='lsqr', tol=0.01)\n",
      "train time: 0.355s\n",
      "test time:  0.004s\n",
      "accuracy:   0.229\n",
      "\n",
      "================================================================================\n",
      "Perceptron\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "Perceptron(alpha=0.0001, class_weight=None, eta0=1.0, fit_intercept=True,\n",
      "      n_iter=50, n_jobs=1, penalty=None, random_state=0, shuffle=True,\n",
      "      verbose=0, warm_start=False)\n",
      "train time: 0.688s\n",
      "test time:  0.007s\n",
      "accuracy:   0.216\n",
      "\n",
      "================================================================================\n",
      "kNN\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
      "           metric_params=None, n_neighbors=10, p=2, weights='uniform')\n",
      "train time: 0.020s\n",
      "test time:  0.434s\n",
      "accuracy:   0.225\n",
      "\n",
      "================================================================================\n",
      "L2 penalty\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "LinearSVC(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='l2', max_iter=1000, multi_class='ovr',\n",
      "     penalty='l2', random_state=None, tol=0.001, verbose=0)\n",
      "train time: 1.612s\n",
      "test time:  0.003s\n",
      "accuracy:   0.224\n",
      "\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
      "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
      "       learning_rate='optimal', loss='hinge', n_iter=50, n_jobs=1,\n",
      "       penalty='l2', power_t=0.5, random_state=None, shuffle=True,\n",
      "       verbose=0, warm_start=False)\n",
      "train time: 0.828s\n",
      "test time:  0.005s\n",
      "accuracy:   0.223\n",
      "\n",
      "================================================================================\n",
      "Elastic-Net penalty\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
      "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
      "       learning_rate='optimal', loss='hinge', n_iter=50, n_jobs=1,\n",
      "       penalty='elasticnet', power_t=0.5, random_state=None, shuffle=True,\n",
      "       verbose=0, warm_start=False)\n",
      "train time: 4.213s\n",
      "test time:  0.004s\n",
      "accuracy:   0.219\n",
      "\n",
      "================================================================================\n",
      "NearestCentroid (aka Rocchio classifier)\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "NearestCentroid(metric='euclidean', shrink_threshold=None)\n",
      "train time: 0.053s\n",
      "test time:  0.006s\n",
      "accuracy:   0.240\n",
      "\n",
      "================================================================================\n",
      "Naive Bayes\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "MultinomialNB(alpha=0.01, class_prior=None, fit_prior=True)\n",
      "train time: 0.045s\n",
      "test time:  0.004s\n",
      "accuracy:   0.236\n",
      "\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "BernoulliNB(alpha=0.01, binarize=0.0, class_prior=None, fit_prior=True)\n",
      "train time: 0.052s\n",
      "test time:  0.037s\n",
      "accuracy:   0.240\n",
      "\n",
      "================================================================================\n",
      "LinearSVC with L1-based feature selection\n",
      "________________________________________________________________________________\n",
      "Training: \n",
      "Pipeline(steps=[('feature_selection', LinearSVC(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
      "     multi_class='ovr', penalty='l1', random_state=None, tol=0.001,\n",
      "     verbose=0)), ('classification', LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,\n",
      "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
      "     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,\n",
      "     verbose=0))])\n",
      "train time: 1.493s\n",
      "test time:  0.018s\n",
      "accuracy:   0.216\n",
      "```\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "trainingData = story_teller.trainingData(600)\n",
      "data_train = DataContainer(trainingData['data'])\n",
      "# training label, aligned with data_train.data\n",
      "y_train = trainingData['targets']\n",
      "# test data, goes into X_test\n",
      "testData = story_teller.testingData(150)\n",
      "data_test = DataContainer(testData['data'])\n",
      "# test label\n",
      "y_test = testData['targets']\n",
      "categories = story_teller.getCategories()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "data_train_size_mb = size_mb(data_train.data)\n",
      "data_test_size_mb = size_mb(data_test.data)\n",
      "\n",
      "print(\"%d documents - %0.3fMB (training set)\" % (\n",
      "    len(data_train.data), data_train_size_mb))\n",
      "print(\"%d documents - %0.3fMB (test set)\" % (\n",
      "    len(data_test.data), data_test_size_mb))\n",
      "print(\"%d categories\" % len(categories))\n",
      "\n",
      "print(\"Extracting features from the training data using a sparse vectorizer\")\n",
      "t0 = time()\n",
      "\n",
      "vectorizer = TfidfVectorizer(sublinear_tf=True, max_df=0.5,\n",
      "                                 stop_words='english')\n",
      "X_train = vectorizer.fit_transform(data_train.data)\n",
      "duration = time() - t0\n",
      "print(\"done in %fs at %0.3fMB/s\" % (duration, data_train_size_mb / duration))\n",
      "print(\"n_samples: %d, n_features: %d\" % X_train.shape)\n",
      "print()\n",
      "\n",
      "print(\"Extracting features from the test data using the same vectorizer\")\n",
      "t0 = time()\n",
      "X_test = vectorizer.transform(data_test.data)\n",
      "duration = time() - t0\n",
      "print(\"done in %fs at %0.3fMB/s\" % (duration, data_test_size_mb / duration))\n",
      "print(\"n_samples: %d, n_features: %d\" % X_test.shape)\n",
      "print()\n",
      "\n",
      "# mapping from integer feature name to original token string\n",
      "feature_names = vectorizer.get_feature_names()\n",
      "if feature_names:\n",
      "    feature_names = np.asarray(feature_names)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "3000 documents - 26.278MB (training set)\n",
        "750 documents - 6.090MB (test set)\n",
        "5 categories\n",
        "Extracting features from the training data using a sparse vectorizer\n",
        "done in 4.080520s at 6.440MB/s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "n_samples: 3000, n_features: 111001\n",
        "\n",
        "Extracting features from the test data using the same vectorizer\n",
        "done in 0.882762s at 6.899MB/s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "n_samples: 750, n_features: 111001\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "###############################################################################\n",
      "# Benchmark classifiers\n",
      "\n",
      "print(\"start training\")\n",
      "results = []\n",
      "for clf, name in (\n",
      "        (RidgeClassifier(tol=1e-2, solver=\"lsqr\"), \"Ridge Classifier\"),\n",
      "        (Perceptron(n_iter=50), \"Perceptron\"),\n",
      "        (KNeighborsClassifier(n_neighbors=10), \"kNN\")):\n",
      "    print('=' * 80)\n",
      "    print(name)\n",
      "    results.append(benchmark(clf))\n",
      "\n",
      "for penalty in [\"l2\"]:\n",
      "    print('=' * 80)\n",
      "    print(\"%s penalty\" % penalty.upper())\n",
      "    # Train Liblinear model\n",
      "    results.append(benchmark(LinearSVC(loss='l2', penalty=penalty,\n",
      "                                            dual=False, tol=1e-3)))\n",
      "\n",
      "    # Train SGD model\n",
      "    results.append(benchmark(SGDClassifier(alpha=.0001, n_iter=50,\n",
      "                                           penalty=penalty)))\n",
      "\n",
      "# Train SGD with Elastic Net penalty\n",
      "print('=' * 80)\n",
      "print(\"Elastic-Net penalty\")\n",
      "results.append(benchmark(SGDClassifier(alpha=.0001, n_iter=50,\n",
      "                                       penalty=\"elasticnet\")))\n",
      "\n",
      "# Train NearestCentroid without threshold\n",
      "print('=' * 80)\n",
      "print(\"NearestCentroid (aka Rocchio classifier)\")\n",
      "results.append(benchmark(NearestCentroid()))\n",
      "\n",
      "# Train sparse Naive Bayes classifiers\n",
      "print('=' * 80)\n",
      "print(\"Naive Bayes\")\n",
      "results.append(benchmark(MultinomialNB(alpha=.01)))\n",
      "results.append(benchmark(BernoulliNB(alpha=.01)))\n",
      "\n",
      "print('=' * 80)\n",
      "print(\"LinearSVC with L1-based feature selection\")\n",
      "# The smaller C, the stronger the regularization.\n",
      "# The more regularization, the more sparsity.\n",
      "results.append(benchmark(Pipeline([\n",
      "  ('feature_selection', LinearSVC(penalty=\"l1\", dual=False, tol=1e-3)),\n",
      "  ('classification', LinearSVC())\n",
      "])))\n",
      "\n",
      "# make some plots\n",
      "\n",
      "indices = np.arange(len(results))\n",
      "\n",
      "results = [[x[i] for x in results] for i in range(4)]\n",
      "\n",
      "clf_names, score, training_time, test_time = results\n",
      "training_time = np.array(training_time) / np.max(training_time)\n",
      "test_time = np.array(test_time) / np.max(test_time)\n",
      "\n",
      "plt.figure(figsize=(12, 8))\n",
      "plt.title(\"Score\")\n",
      "plt.barh(indices, score, .2, label=\"score\", color='r')\n",
      "plt.barh(indices + .3, training_time, .2, label=\"training time\", color='g')\n",
      "plt.barh(indices + .6, test_time, .2, label=\"test time\", color='b')\n",
      "plt.yticks(())\n",
      "plt.legend(loc='best')\n",
      "plt.subplots_adjust(left=.25)\n",
      "plt.subplots_adjust(top=.95)\n",
      "plt.subplots_adjust(bottom=.05)\n",
      "\n",
      "for i, c in zip(indices, clf_names):\n",
      "    plt.text(-.3, i, c)\n",
      "\n",
      "plt.show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "start training\n",
        "================================================================================\n",
        "Ridge Classifier\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "RidgeClassifier(alpha=1.0, class_weight=None, copy_X=True, fit_intercept=True,\n",
        "        max_iter=None, normalize=False, solver='lsqr', tol=0.01)\n",
        "train time: 0.355s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.004s\n",
        "accuracy:   0.229\n",
        "\n",
        "================================================================================\n",
        "Perceptron\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "Perceptron(alpha=0.0001, class_weight=None, eta0=1.0, fit_intercept=True,\n",
        "      n_iter=50, n_jobs=1, penalty=None, random_state=0, shuffle=True,\n",
        "      verbose=0, warm_start=False)\n",
        "train time: 0.688s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.007s\n",
        "accuracy:   0.216\n",
        "\n",
        "================================================================================\n",
        "kNN\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
        "           metric_params=None, n_neighbors=10, p=2, weights='uniform')\n",
        "train time: 0.020s\n",
        "test time:  0.434s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "accuracy:   0.225\n",
        "\n",
        "================================================================================\n",
        "L2 penalty\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "LinearSVC(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
        "     intercept_scaling=1, loss='l2', max_iter=1000, multi_class='ovr',\n",
        "     penalty='l2', random_state=None, tol=0.001, verbose=0)\n",
        "train time: 1.612s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.003s\n",
        "accuracy:   0.224\n",
        "\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
        "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
        "       learning_rate='optimal', loss='hinge', n_iter=50, n_jobs=1,\n",
        "       penalty='l2', power_t=0.5, random_state=None, shuffle=True,\n",
        "       verbose=0, warm_start=False)\n",
        "train time: 0.828s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.005s\n",
        "accuracy:   0.223\n",
        "\n",
        "================================================================================\n",
        "Elastic-Net penalty\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "SGDClassifier(alpha=0.0001, average=False, class_weight=None, epsilon=0.1,\n",
        "       eta0=0.0, fit_intercept=True, l1_ratio=0.15,\n",
        "       learning_rate='optimal', loss='hinge', n_iter=50, n_jobs=1,\n",
        "       penalty='elasticnet', power_t=0.5, random_state=None, shuffle=True,\n",
        "       verbose=0, warm_start=False)\n",
        "train time: 4.213s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.004s\n",
        "accuracy:   0.219\n",
        "\n",
        "================================================================================\n",
        "NearestCentroid (aka Rocchio classifier)\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "NearestCentroid(metric='euclidean', shrink_threshold=None)\n",
        "train time: 0.053s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.006s\n",
        "accuracy:   0.240\n",
        "\n",
        "================================================================================\n",
        "Naive Bayes\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "MultinomialNB(alpha=0.01, class_prior=None, fit_prior=True)\n",
        "train time: 0.045s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.004s\n",
        "accuracy:   0.236\n",
        "\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "BernoulliNB(alpha=0.01, binarize=0.0, class_prior=None, fit_prior=True)\n",
        "train time: 0.052s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.037s\n",
        "accuracy:   0.240\n",
        "\n",
        "================================================================================\n",
        "LinearSVC with L1-based feature selection\n",
        "________________________________________________________________________________\n",
        "Training: \n",
        "Pipeline(steps=[('feature_selection', LinearSVC(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
        "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
        "     multi_class='ovr', penalty='l1', random_state=None, tol=0.001,\n",
        "     verbose=0)), ('classification', LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,\n",
        "     intercept_scaling=1, loss='squared_hinge', max_iter=1000,\n",
        "     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,\n",
        "     verbose=0))])\n",
        "train time: 1.493s"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "test time:  0.018s\n",
        "accuracy:   0.216\n",
        "\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": [
        "/home/wzheng02/workspace/py_ml/py29/lib/python2.7/site-packages/sklearn/svm/classes.py:192: DeprecationWarning: loss='l2' has been deprecated in favor of loss='squared_hinge' as of 0.16. Backward compatibility for the loss='l2' will be removed in 1.0\n",
        "  DeprecationWarning)\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAu8AAAIxCAYAAAD9t1YOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n",
       "text": [
        "<matplotlib.figure.Figure at 0x7fa76a944f90>"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "ridgeClassifier and linearSVC results didn't improve much, kill them and train with an even larger sample"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}