6.3.1-Tuning-SKlearn-Model-with-Custom-KT-Tuner.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "!pip install -r https://raw.githubusercontent.com/datamllab/automl-in-action-notebooks/master/requirements.txt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import keras_tuner as kt\n",
    "\n",
    "\n",
    "class MyTuner(kt.RandomSearch):\n",
    "    def run_trial(self, trial, *args, **kwargs):\n",
    "        hp = trial.hyperparameters\n",
    "        x = hp.Float(\"x\", -1.0, 1.0)\n",
    "        return x * x + 1\n",
    "\n",
    "\n",
    "tuner = MyTuner(max_trials=20)\n",
    "tuner.search()\n",
    "tuner.results_summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import pickle\n",
    "import tensorflow as tf\n",
    "import kerastuner as kt\n",
    "\n",
    "\n",
    "class ShallowTuner(kt.Tuner):\n",
    "    def __init__(self, oracle, hypermodel, **kwargs):\n",
    "        super(ShallowTuner, self).__init__(\n",
    "            oracle=oracle, hypermodel=hypermodel, **kwargs\n",
    "        )\n",
    "\n",
    "    def search(self, X, y, validation_data):\n",
    "        \"\"\"performs hyperparameter search.\"\"\"\n",
    "        return super(ShallowTuner, self).search(X, y, validation_data)\n",
    "\n",
    "    def run_trial(self, trial, X, y, validation_data):\n",
    "        model = self.hypermodel.build(trial.hyperparameters)  # build the model\n",
    "        model.fit(X, y)  # fit the model\n",
    "        X_val, y_val = validation_data  # get the validation data\n",
    "        eval_score = model.score(X_val, y_val)  # evaluate the model\n",
    "        self.save_model(trial.trial_id, model)  # save the model to disk\n",
    "        return {\"score\": eval_score}\n",
    "\n",
    "    def save_model(self, trial_id, model, step=0):\n",
    "        \"\"\"save the model with pickle\"\"\"\n",
    "        fname = os.path.join(self.get_trial_dir(trial_id), \"model.pickle\")\n",
    "        with tf.io.gfile.GFile(fname, \"wb\") as f:\n",
    "            pickle.dump(model, f)\n",
    "\n",
    "    def load_model(self, trial):\n",
    "        \"\"\"load the model with pickle\"\"\"\n",
    "        fname = os.path.join(self.get_trial_dir(trial.trial_id), \"model.pickle\")\n",
    "        with tf.io.gfile.GFile(fname, \"rb\") as f:\n",
    "            return pickle.load(f)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_digits\n",
    "\n",
    "# Load the hand-written digits dataset\n",
    "digits = load_digits()\n",
    "\n",
    "# Get the images and corresponding labels\n",
    "images, labels = digits.images, digits.target\n",
    "images.shape, labels.shape\n",
    "\n",
    "# reshape images to vectors\n",
    "n_samples = len(images)\n",
    "X = images.reshape((n_samples, -1))\n",
    "\n",
    "# Split data into train and test subsets\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X, labels, test_size=0.2, shuffle=False\n",
    ")\n",
    "X_train, X_val, y_train, y_val = train_test_split(\n",
    "    X_train, y_train, test_size=0.2, shuffle=False\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from kerastuner.engine import hyperparameters as hp\n",
    "\n",
    "\n",
    "def build_model(hp):\n",
    "    model_type = hp.Choice(\"model_type\", [\"svm\", \"random_forest\"])\n",
    "    if model_type == \"svm\":\n",
    "        with hp.conditional_scope(\"model_type\", \"svm\"):\n",
    "            model = SVC(\n",
    "                C=hp.Float(\"C\", 1e-3, 10, sampling=\"linear\", default=1),\n",
    "                kernel=hp.Choice(\"kernel_type\", [\"linear\", \"rbf\"], default=\"linear\"),\n",
    "                random_state=42,\n",
    "            )\n",
    "    elif model_type == \"random_forest\":\n",
    "        with hp.conditional_scope(\"model_type\", \"random_forest\"):\n",
    "            model = RandomForestClassifier(\n",
    "                n_estimators=hp.Int(\"n_estimators\", 10, 200, step=10),\n",
    "                max_depth=hp.Int(\"max_depth\", 3, 10),\n",
    "            )\n",
    "    else:\n",
    "        raise ValueError(\"Unrecognized model_type\")\n",
    "    return model\n",
    "\n",
    "\n",
    "my_sklearn_tuner = ShallowTuner(\n",
    "    oracle=kt.oracles.RandomSearch(\n",
    "        objective=kt.Objective(\"score\", \"max\"), max_trials=10, seed=42\n",
    "    ),\n",
    "    hypermodel=build_model,\n",
    "    overwrite=True,\n",
    "    project_name=\"my_sklearn_tuner\",\n",
    ")\n",
    "\n",
    "my_sklearn_tuner.search(X_train, y_train, validation_data=(X_val, y_val))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "# Evaluate the best discovered model\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "best_model = my_sklearn_tuner.get_best_models(1)[0]\n",
    "best_model.fit(X_train, y_train)\n",
    "y_pred_test = best_model.predict(X_test)\n",
    "test_acc = accuracy_score(y_test, y_pred_test)\n",
    "print(\"The prediction accuracy on test set: {:.2f} %\".format(test_acc * 100))\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "6.3.1-Tuning-SKlearn-Model-with-Custom-KT-Tuner",
   "private_outputs": false,
   "provenance": [],
   "toc_visible": true
  },
  "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}