notebooks/train-lightgbm-local.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train with LightGBM in an Interactive Run\n",
    "\n",
    "description: use mlflow for tracking local notebook experimentation in the cloud"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pip install packages\n",
    "\n",
    "When developing in a notebook, it is common to install packages. You can do this directly in a notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install --upgrade numpy pandas scikit-learn lightgbm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup cloud tracking\n",
    "\n",
    "[Mlflow](https://github.com/mlflow/mlflow) is a great tool for local ML experimentation tracking. However, using it alone is like using git without GitHub. Your Azure Machine Learning workspace can easily be used to setup a remote tracking URI for mlflow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mlflow\n",
    "from azureml.core import Workspace\n",
    "\n",
    "ws = Workspace.from_config()\n",
    "mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())\n",
    "mlflow.set_experiment(\"lightgbm-iris-local-example\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data\n",
    "\n",
    "You can read directly from public URIs into Pandas. For private Blob or ADLS data, you can use built in Azure data protocols and pass in `storage_options` for credentials."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_uri = \"https://azuremlexamples.blob.core.windows.net/datasets/iris.csv\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv(data_uri)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Write functions\n",
    "\n",
    "After some experimentation, you may refactor your code into a few functions for logical steps in the ML training process:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import time\n",
    "\n",
    "import lightgbm as lgb\n",
    "\n",
    "from sklearn.metrics import log_loss, accuracy_score\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# define functions\n",
    "def preprocess_data(df):\n",
    "    X = df.drop([\"species\"], axis=1)\n",
    "    y = df[\"species\"]\n",
    "\n",
    "    enc = LabelEncoder()\n",
    "    y = enc.fit_transform(y)\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X, y, test_size=0.2, random_state=42\n",
    "    )\n",
    "\n",
    "    return X_train, X_test, y_train, y_test, enc\n",
    "\n",
    "\n",
    "def train_model(params, num_boost_round, X_train, X_test, y_train, y_test):\n",
    "    t1 = time.time()\n",
    "    train_data = lgb.Dataset(X_train, label=y_train)\n",
    "    test_data = lgb.Dataset(X_test, label=y_test)\n",
    "    model = lgb.train(\n",
    "        params,\n",
    "        train_data,\n",
    "        num_boost_round=num_boost_round,\n",
    "        valid_sets=[test_data],\n",
    "        valid_names=[\"test\"],\n",
    "    )\n",
    "    t2 = time.time()\n",
    "\n",
    "    return model, t2 - t1\n",
    "\n",
    "\n",
    "def evaluate_model(model, X_test, y_test):\n",
    "    y_proba = model.predict(X_test)\n",
    "    y_pred = y_proba.argmax(axis=1)\n",
    "    loss = log_loss(y_test, y_proba)\n",
    "    acc = accuracy_score(y_test, y_pred)\n",
    "\n",
    "    return loss, acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run a trial\n",
    "\n",
    "Now, you can easily run local trials, editing the parameters and seeing how the model performs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score, log_loss\n",
    "\n",
    "# preprocess data\n",
    "X_train, X_test, y_train, y_test, enc = preprocess_data(df)\n",
    "\n",
    "# set training parameters\n",
    "params = {\n",
    "    \"objective\": \"multiclass\",\n",
    "    \"num_class\": 3,\n",
    "    \"learning_rate\": 0.1,\n",
    "    \"metric\": \"multi_logloss\",\n",
    "    \"colsample_bytree\": 1.0,\n",
    "    \"subsample\": 1.0,\n",
    "    \"seed\": 42,\n",
    "}\n",
    "\n",
    "num_boost_round = 32\n",
    "\n",
    "# start run\n",
    "run = mlflow.start_run()\n",
    "\n",
    "# enable automatic logging\n",
    "mlflow.lightgbm.autolog()\n",
    "\n",
    "# train model\n",
    "model, train_time = train_model(\n",
    "    params, num_boost_round, X_train, X_test, y_train, y_test\n",
    ")\n",
    "mlflow.log_metric(\"training_time\", train_time)\n",
    "\n",
    "# evaluate model\n",
    "loss, acc = evaluate_model(model, X_test, y_test)\n",
    "mlflow.log_metrics({\"loss\": loss, \"accuracy\": acc})\n",
    "\n",
    "# end run\n",
    "mlflow.end_run()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8",
   "language": "python",
   "name": "python3.8"
  },
  "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.8.5-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}