03_GettingStartedWithClassification_code.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setup\n",
    "from mlwpy import *\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = datasets.load_iris()\n",
    "\n",
    "iris_df = pd.DataFrame(iris.data, \n",
    "                       columns=iris.feature_names)\n",
    "iris_df['target'] = iris.target\n",
    "display(pd.concat([iris_df.head(3),\n",
    "                   iris_df.tail(3)]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.pairplot(iris_df, hue='target', height=1.5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('targets: {}'.format(iris.target_names),\n",
    "      iris.target_names[0], sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simple train/test split\n",
    "(iris_train_ftrs, iris_test_ftrs, \n",
    " iris_train_tgt,  iris_test_tgt) = skms.train_test_split(iris.data,\n",
    "                                                         iris.target, \n",
    "                                                         test_size=.25)\n",
    "print(\"Train features shape:\", iris_train_ftrs.shape)\n",
    "print(\"Test features shape:\",  iris_test_ftrs.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer_key = np.array([True, True, False, True])\n",
    "student_answers = np.array([True, True, True, True]) # desperate student!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct = answer_key == student_answers\n",
    "num_correct = correct.sum() # True == 1, add them up\n",
    "print(\"manual accuracy:\", num_correct / len(answer_key))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"sklearn accuracy:\", \n",
    "      metrics.accuracy_score(answer_key, \n",
    "                             student_answers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default n_neighbors = 5\n",
    "knn   = neighbors.KNeighborsClassifier(n_neighbors=3)\n",
    "fit   = knn.fit(iris_train_ftrs, iris_train_tgt)\n",
    "preds = fit.predict(iris_test_ftrs)\n",
    "\n",
    "# evaluate our predictions against the held-back testing targets\n",
    "print(\"3NN accuracy:\", \n",
    "      metrics.accuracy_score(iris_test_tgt, preds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb    = naive_bayes.GaussianNB()\n",
    "fit   = nb.fit(iris_train_ftrs, iris_train_tgt)\n",
    "preds = fit.predict(iris_test_ftrs)\n",
    "\n",
    "print(\"NB accuracy:\", \n",
    "      metrics.accuracy_score(iris_test_tgt, preds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stand alone code\n",
    "from sklearn import (datasets, metrics, \n",
    "                     model_selection as skms,\n",
    "                     naive_bayes, neighbors)\n",
    "\n",
    "# we set random_state so the results are reproducable\n",
    "# otherwise, we get different training and testing sets\n",
    "# more details in Chapter 5\n",
    "iris = datasets.load_iris()\n",
    "(iris_train_ftrs, iris_test_ftrs, \n",
    " iris_train_tgt, iris_test_tgt) = skms.train_test_split(iris.data,\n",
    "                                                        iris.target, \n",
    "                                                        test_size=.90,\n",
    "                                                        random_state=42) \n",
    "\n",
    "models = {'kNN': neighbors.KNeighborsClassifier(n_neighbors=3),\n",
    "          'NB' : naive_bayes.GaussianNB()}\n",
    "\n",
    "for name, model in models.items():\n",
    "    fit = model.fit(iris_train_ftrs, iris_train_tgt)\n",
    "    predictions = fit.predict(iris_test_ftrs)\n",
    "    \n",
    "    score = metrics.accuracy_score(iris_test_tgt, predictions)\n",
    "    print(\"{:>3s}: {:0.2f}\".format(name,score))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit -r1 datasets.load_iris()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -r1 -n1\n",
    "(iris_train_ftrs, iris_test_ftrs, \n",
    " iris_train_tgt,  iris_test_tgt) = skms.train_test_split(iris.data,\n",
    "                                                         iris.target, \n",
    "                                                         test_size=.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -r1\n",
    "\n",
    "nb    = naive_bayes.GaussianNB()\n",
    "fit   = nb.fit(iris_train_ftrs, iris_train_tgt)\n",
    "preds = fit.predict(iris_test_ftrs)\n",
    "\n",
    "metrics.accuracy_score(iris_test_tgt, preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -r1\n",
    "\n",
    "knn   = neighbors.KNeighborsClassifier(n_neighbors=3)\n",
    "fit   = knn.fit(iris_train_ftrs, iris_train_tgt)\n",
    "preds = fit.predict(iris_test_ftrs)\n",
    "\n",
    "metrics.accuracy_score(iris_test_tgt, preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fitting\n",
    "nb = naive_bayes.GaussianNB()\n",
    "%timeit -r1 fit   = nb.fit(iris_train_ftrs, iris_train_tgt)\n",
    "\n",
    "knn = neighbors.KNeighborsClassifier(n_neighbors=3)\n",
    "%timeit -r1 fit = knn.fit(iris_train_ftrs, iris_train_tgt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predicting\n",
    "nb    = naive_bayes.GaussianNB()\n",
    "fit   = nb.fit(iris_train_ftrs, iris_train_tgt)\n",
    "%timeit -r1 preds = fit.predict(iris_test_ftrs)\n",
    "\n",
    "knn   = neighbors.KNeighborsClassifier(n_neighbors=3)\n",
    "fit   = knn.fit(iris_train_ftrs, iris_train_tgt)\n",
    "%timeit -r1 preds = fit.predict(iris_test_ftrs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext memory_profiler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%memit\n",
    "nb    = naive_bayes.GaussianNB()\n",
    "fit   = nb.fit(iris_train_ftrs, iris_train_tgt)\n",
    "preds = fit.predict(iris_test_ftrs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%memit\n",
    "knn   = neighbors.KNeighborsClassifier(n_neighbors=3)\n",
    "fit   = knn.fit(iris_train_ftrs, iris_train_tgt)\n",
    "preds = fit.predict(iris_test_ftrs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat scripts/knn_memtest.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python scripts/knn_memtest.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools as ft\n",
    "import memory_profiler\n",
    "from mlwpy import *\n",
    "\n",
    "def nb_go(train_ftrs, test_ftrs, train_tgt):\n",
    "    nb    = naive_bayes.GaussianNB()\n",
    "    fit   = nb.fit(train_ftrs, train_tgt)\n",
    "    preds = fit.predict(test_ftrs)\n",
    "\n",
    "def split_data(dataset):\n",
    "    split = skms.train_test_split(dataset.data,\n",
    "                                  dataset.target,\n",
    "                                  test_size=.25)\n",
    "    return split[:-1] # don't need test tgt\n",
    "\n",
    "def msr_mem(go, args):\n",
    "    base = memory_profiler.memory_usage()[0]\n",
    "    mu = memory_profiler.memory_usage((go, args), max_usage=True)\n",
    "    print(\"{:<3}: ~{:.4f} MiB\".format(go.__name__, mu-base))\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    msr = msr_mem\n",
    "    go = nb_go\n",
    "\n",
    "    sd = split_data(datasets.load_iris())\n",
    "    msr(go, sd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat scripts/perf_01.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python scripts/perf_01.py mem nb\n",
    "!python scripts/perf_01.py time nb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python scripts/perf_01.py mem knn\n",
    "!python scripts/perf_01.py time knn"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 2
}