Comparison.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Incremental Model Selection\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from dask_ml.datasets import make_classification\n",
    "from dask_ml.model_selection._incremental import fit\n",
    "from sklearn.datasets import fetch_20newsgroups_vectorized, load_digits\n",
    "import dask.array as da\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from dask_ml.model_selection._incremental import fit\n",
    "from dask_ml.model_selection import train_test_split\n",
    "from sklearn.model_selection import ParameterSampler\n",
    "import dask.array as da\n",
    "import dask\n",
    "from dask.distributed import Client\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from model_selection_algs import stop_on_plateau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table style=\"border: 2px solid white;\">\n",
       "<tr>\n",
       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
       "<h3>Client</h3>\n",
       "<ul>\n",
       "  <li><b>Scheduler: </b>tcp://127.0.0.1:56024\n",
       "  <li><b>Dashboard: </b><a href='http://127.0.0.1:8787/status' target='_blank'>http://127.0.0.1:8787/status</a>\n",
       "</ul>\n",
       "</td>\n",
       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
       "<h3>Cluster</h3>\n",
       "<ul>\n",
       "  <li><b>Workers: </b>8</li>\n",
       "  <li><b>Cores: </b>8</li>\n",
       "  <li><b>Memory: </b>17.18 GB</li>\n",
       "</ul>\n",
       "</td>\n",
       "</tr>\n",
       "</table>"
      ],
      "text/plain": [
       "<Client: scheduler='tcp://127.0.0.1:56024' processes=8 cores=8>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client = Client(processes=True)\n",
    "client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = load_digits()\n",
    "_X = data.data\n",
    "_y = data.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(dask.array<array, shape=(1797, 64), dtype=float64, chunksize=(1198, 64)>,\n",
       " dask.array<array, shape=(1797,), dtype=int64, chunksize=(1198,)>)"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n, d = _X.shape\n",
    "X = da.from_array(_X, chunks=(n // 10, d))\n",
    "y = da.from_array(_y, chunks=n // 10)\n",
    "X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = MLPClassifier()\n",
    "params = {'activation': ['logistic', 'tanh', 'relu'],\n",
    "          'solver': ['adam', 'sgd'],\n",
    "          'alpha': np.logspace(-6, -2, num=1000),\n",
    "          'batch_size': 2**np.arange(5, 8 + 1),\n",
    "          'learning_rate': ['constant', 'invscaling', 'adaptive'],\n",
    "          'learning_rate_init': np.logspace(-4, -1, num=1000),\n",
    "          'power_t': np.linspace(0.1, 0.75),\n",
    "          'momentum': np.linspace(0, 1, num=1000),\n",
    "          'beta_1': np.linspace(0.8, 0.99),\n",
    "          'beta_2': 1 - np.logspace(-5, -2)}\n",
    "classes = da.unique(y).compute()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Successive halving"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_history = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(81.0, 3.0), (34.0, 9.0), (15.0, 27.0), (8.0, 81.0), (5.0, 243.0)]"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "R = 81 * 3\n",
    "eta = 3.0\n",
    "s_max = math.floor(math.log(R, eta))\n",
    "B = (s_max + 1) * R\n",
    "# for s in [...]:\n",
    "s = np.arange(s_max + 1)\n",
    "s = s_max - s  # pick the most exploratory bracket\n",
    "n = np.ceil(B / R * eta**s / (s + 1))\n",
    "r = np.floor(R * eta**-s)\n",
    "list(zip(n, r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 4.0 27.0\n",
      "1 6.0 9.0\n",
      "2 12.0 3.0\n",
      "3 27.0 1.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "distributed.nanny - WARNING - Restarting worker\n",
      "distributed.nanny - WARNING - Restarting worker\n",
      "distributed.nanny - WARNING - Restarting worker\n",
      "distributed.nanny - WARNING - Restarting worker\n",
      "distributed.nanny - WARNING - Restarting worker\n",
      "distributed.nanny - WARNING - Restarting worker\n",
      "distributed.nanny - WARNING - Restarting worker\n",
      "distributed.nanny - WARNING - Restarting worker\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import ParameterSampler\n",
    "from model_selection_algs import SHA\n",
    "import math\n",
    "\n",
    "def test_sha(s=0, eta=3, n=81, r=5, repeat=0):\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
    "    \n",
    "    alg = SHA(n, r)\n",
    "    params_list = list(ParameterSampler(params, n))\n",
    "\n",
    "    info, models, history = fit(model, params_list, X_train, y_train, X_test, y_test,\n",
    "                                alg.fit, {'classes': classes})\n",
    "    history = [{'alg': f'sh-{s}', 'repeat': repeat, 'bracket': s, **h} for h in history]\n",
    "    return history\n",
    "\n",
    "for s, (ni, ri) in enumerate(reversed(list(zip(n, r)))):\n",
    "    print(s, ni, ri)\n",
    "    all_history[f'sh-{s}'] = [test_sha(repeat=repeat, n=ni, r=ri, s=s) for repeat in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from toolz import partial\n",
    "\n",
    "def test_rand(i=0, n=5, r=81):\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
    "    classes = da.unique(y).compute()\n",
    "\n",
    "    params_list = list(ParameterSampler(params, n))\n",
    "\n",
    "    fn = partial(stop_on_plateau, max_iter=r)\n",
    "    info, models, history = fit(model, params_list, X_train, y_train, X_test, y_test, fn,\n",
    "                                {'classes': classes})\n",
    "    history = [{'alg': 'random sampling', 'repeat': i, 'n': n, 'r': r, **h}\n",
    "               for h in history]\n",
    "    return history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3613, 243)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from toolz import concat\n",
    "from pprint import pprint\n",
    "\n",
    "def get_total_calls(history):\n",
    "    total_calls = {}\n",
    "    for item in history:\n",
    "        if total_calls.get(item['model_id'], 0) < item['partial_fit_calls']:\n",
    "            total_calls[item['model_id']] = item['partial_fit_calls']\n",
    "    return sum(total_calls.values()), max(total_calls.values())\n",
    "\n",
    "max_calls = 0\n",
    "total_calls = 0\n",
    "for key, runs in all_history.items():\n",
    "    run = runs[0]\n",
    "    calls, most_calls = get_total_calls(run)\n",
    "    if most_calls > max_calls:\n",
    "        max_calls = most_calls\n",
    "    total_calls += calls\n",
    "    \n",
    "total_calls, max_calls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = max_calls\n",
    "n = int(total_calls / max_calls)\n",
    "all_history['random'] = [test_rand(n=n, r=r, i=i) for i in range(20)]\n",
    "all_history['random-2n'] = [test_rand(n=2*n, r=r, i=i) for i in range(20)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['sh-0', 'sh-1', 'sh-2', 'sh-3', 'sh-4', 'random', 'random-2n'])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_history.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes from the profile dashboard for all of hyperband:\n",
    "\n",
    "* partial_fit: 163s (84%)\n",
    "    * copy: 15s (9% of fit)\n",
    "* score: 30s (15%)\n",
    "\n",
    "Random sample profile:\n",
    "\n",
    "* partial_fit: 174s (91%)\n",
    "    * copy: 14s (8% of fit)\n",
    "* score: 16s (8%)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pprint import pprint\n",
    "out = []\n",
    "for alg, hist in all_history.items():\n",
    "    for repeat, batch in enumerate(hist):\n",
    "        best_score = -np.inf\n",
    "        calls = {}\n",
    "        skips = 0\n",
    "        for k, item in enumerate(batch):\n",
    "            if 'score' not in item:\n",
    "                continue\n",
    "            calls[item['model_id']] = item['partial_fit_calls']\n",
    "            total_calls = sum(calls.values())\n",
    "            best_score = item['score'] if item['score'] > best_score else best_score\n",
    "            if 'random' in alg or alg == 'sh-0':\n",
    "                adaptive = False\n",
    "                bracket = 0\n",
    "            else:\n",
    "                adaptive = True\n",
    "                bracket = int(alg.split('-')[-1])\n",
    "\n",
    "            out += [{'best_score': best_score,\n",
    "                     'total_partial_fit_calls': total_calls,\n",
    "                     'alg': alg,\n",
    "                     'epoch': total_calls / n,\n",
    "                     'adaptive': adaptive,\n",
    "                     'bracket': bracket,\n",
    "                     'repeat': repeat}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>bracket</th>\n",
       "      <th>alg</th>\n",
       "      <th>score</th>\n",
       "      <th>model_id</th>\n",
       "      <th>partial_fit_calls</th>\n",
       "      <th>i</th>\n",
       "      <th>adaptive</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>sh-0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>sh-0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>sh-0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.0</td>\n",
       "      <td>sh-0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>sh-0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   bracket   alg  score  model_id  partial_fit_calls    i  adaptive\n",
       "0      0.0  sh-0    0.0         2                  0  0.1       0.1\n",
       "1      0.0  sh-0    0.0         1                  0  0.1       0.1\n",
       "2      0.0  sh-0    0.0         3                  0  0.1       0.1\n",
       "3      0.0  sh-0    0.0         0                  0  0.1       0.1\n",
       "4      0.0  sh-0    0.0         4                  0  0.1       0.1"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import altair as alt\n",
    "hist = pd.DataFrame(sum(sum(all_history.values(), []), []),\n",
    "                    columns=['bracket', 'alg', 'score', 'model_id',\n",
    "                             'partial_fit_calls', 'i', 'adaptive'])\n",
    "hist = hist.fillna(0.1)\n",
    "hist.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>adaptive</th>\n",
       "      <th>alg</th>\n",
       "      <th>best_score</th>\n",
       "      <th>bracket</th>\n",
       "      <th>epoch</th>\n",
       "      <th>repeat</th>\n",
       "      <th>total_partial_fit_calls</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>False</td>\n",
       "      <td>sh-0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>False</td>\n",
       "      <td>sh-0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>False</td>\n",
       "      <td>sh-0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>False</td>\n",
       "      <td>sh-0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>False</td>\n",
       "      <td>sh-0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   adaptive   alg  best_score  bracket  epoch  repeat  total_partial_fit_calls\n",
       "0     False  sh-0         0.0        0    0.0       0                        0\n",
       "1     False  sh-0         0.0        0    0.0       0                        0\n",
       "2     False  sh-0         0.0        0    0.0       0                        0\n",
       "3     False  sh-0         0.0        0    0.0       0                        0\n",
       "4     False  sh-0         0.0        0    0.0       0                        0"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "df = pd.DataFrame(out)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "today = datetime.now().isoformat()[:10]\n",
    "# df.to_parquet(today + '-df-even.parquet')\n",
    "# hist.to_parquet(today + '-show-even.parquet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def get(df, key):\n",
    "    values = df[key].unique()\n",
    "    assert len(values) == 1\n",
    "    return values[0]\n",
    "\n",
    "\n",
    "plt.style.use('bmh')\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "import matplotlib\n",
    "cmap = matplotlib.cm.get_cmap('plasma')\n",
    "n = len(df.bracket.unique())\n",
    "colors = [cmap(i / n) for i in range(n)]\n",
    "\n",
    "labels = []\n",
    "for alg in df.alg.unique():\n",
    "    show = df[df.alg == alg]\n",
    "    bracket = get(show, 'bracket')\n",
    "    adaptive = get(show, 'adaptive')\n",
    "    show = show.pivot_table(values='best_score',\n",
    "                            index='total_partial_fit_calls',\n",
    "                            aggfunc=np.mean)\n",
    "    alpha = 1\n",
    "    if 'random' in alg:\n",
    "        color = 'black'\n",
    "        alpha = 0.50\n",
    "        if '2n' in alg:\n",
    "            alpha = 0.5\n",
    "            continue\n",
    "    else:\n",
    "        color = colors[bracket]\n",
    "    show.plot(ax=ax, color=color,\n",
    "              style='-.' if not adaptive else '-',\n",
    "              legend=False, alpha=alpha)\n",
    "    if 'sh' in alg:\n",
    "        bracket = alg.split('-')[-1]\n",
    "        label = f'succ-halv {bracket}'\n",
    "    else:\n",
    "        label = alg\n",
    "    labels += [label]\n",
    "plt.legend(labels, loc='best')\n",
    "plt.ylim(0.70, 1)\n",
    "plt.ylabel('score')\n",
    "# plt.grid()\n",
    "plt.savefig('2018-08-01-even-243.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}

model_selection_algs.py

import math
import toolz
import numpy as np


def stop_on_plateau(info, patience=10, tol=0.001, max_iter=None):
    out = {}
    for ident, records in info.items():
        if max_iter is not None and len(records) > max_iter:
            out[ident] = 0

        elif len(records) > patience:
            old = records[-patience]['score']
            if all(d['score'] < old + tol for d in records[-patience:]):
                out[ident] = 0
            else:
                out[ident] = 1
        else:
            out[ident] = 1
    return out


class SHA:
    def __init__(self, n, r, eta=3):
        self.steps = 0
        self.n = n
        self.r = r
        self.eta = eta

    def fit(self, info):
        n, r, eta = self.n, self.r, self.eta
        n_i = math.floor(n * eta ** -self.steps)
        r_i = r * eta**self.steps

        if self.steps == 0:
            self.steps = 1
            assert len(info) == self.n
            self.to_reach = {k: r_i for k in info}
            return {k: 1 for k in info}

        keep_training = stop_on_plateau(info)
        if sum(keep_training.values()) == 0:
            return keep_training
        iteration_increase = len(info) / sum(keep_training.values())
        info = {k: info[k] for k in keep_training}

        calls = {k: record[-1]['partial_fit_calls']
                 for k, record in info.items()}
        if calls != self.to_reach:
            return {k: 1 for k in info}

        best = toolz.topk(n_i, info, key=lambda k: info[k][-1]['score'])

        if 1 <= len(best) < eta:
            self._best_arm = max(best, key=lambda k: info[k][-1]['score'])
        if len(best) in {0, 1}:
            best = self._best_arm
            return {best: 0}

        to_reach = {k: r_i - info[k][-1]['partial_fit_calls']
                    for k in best}
        self.to_reach = {k: int(v * iteration_increase) for k, v in to_reach.items()}

        self.steps += 1
        return {k: 1 for k in to_reach}