week_5_notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 5 Notes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.1 [Intro / Session overview](https://github.com/DataTalksClub/machine-learning-zoomcamp/blob/master/05-deployment/01-intro.md)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This week we will take the churn prediction model from week 4 that we have inside a Jupyter notebook and deploy it. We will save the model and use it.\n",
    "\n",
    "We have the Jupter notebook with the model. The model is saved. We will create a churn service with the model. The model can be served in a web service and interacted with. \n",
    "\n",
    "The churn prediction model will be saved and be put inside a web service using Flask (framework for creating a web framework in Python). We will isolate the dependencies for this web service so they do not interfere with other services on our machine. To this end we'll create a special environment for Python dependencies using Pipenv. Then we add another layer on top with system dependencies, using Docker. This is then deployed in the cloud (AWS Elastic Beanstalk)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=architecture.png width=600>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 5.2 [Saving and loading the model](https://github.com/DataTalksClub/machine-learning-zoomcamp/blob/master/05-deployment/02-pickle.md)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the code from the last week. Right now, it lives in this Jupyter Notebook and we cannot put it in a web service."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "from sklearn.model_selection import train_test_split, KFold\n",
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import roc_auc_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"data-week-3.csv\")\n",
    "\n",
    "df.columns = df.columns.str.lower().str.replace(\" \", \"_\")\n",
    "\n",
    "categorical_columns = list(df.dtypes[df.dtypes == \"object\"].index)\n",
    "\n",
    "for c in categorical_columns:\n",
    "    df[c] = df[c].str.lower().str.replace(\" \", \"_\")\n",
    "\n",
    "df.totalcharges = pd.to_numeric(df.totalcharges, errors=\"coerce\")\n",
    "df.totalcharges = df.totalcharges.fillna(0)\n",
    "\n",
    "df.churn = (df.churn == \"yes\").astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_full_train, df_test = train_test_split(df, test_size=0.2, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "numerical = [\"tenure\", \"monthlycharges\", \"totalcharges\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "categorical = [\n",
    "    'gender',\n",
    "    \"seniorcitizen\",\n",
    "    'partner',\n",
    "    'dependents',\n",
    "    'phoneservice',\n",
    "    'multiplelines',\n",
    "    'internetservice',\n",
    "    'onlinesecurity',\n",
    "    'onlinebackup',\n",
    "    'deviceprotection',\n",
    "    'techsupport',\n",
    "    'streamingtv',\n",
    "    'streamingmovies',\n",
    "    'contract',\n",
    "    'paperlessbilling',\n",
    "    'paymentmethod',\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(df_train, y_train, C=1.0):\n",
    "    dicts = df_train[categorical + numerical].to_dict(orient=\"records\")\n",
    "    \n",
    "    dv = DictVectorizer(sparse=False)\n",
    "    X_train = dv.fit_transform(dicts)\n",
    "    \n",
    "    model = LogisticRegression(C=C, max_iter=1000)\n",
    "    model.fit(X_train, y_train)\n",
    "\n",
    "    return dv, model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(df, dv, model):\n",
    "    dicts = df[categorical + numerical].to_dict(orient=\"records\")\n",
    "\n",
    "    X = dv.transform(dicts)\n",
    "    y_pred = model.predict_proba(X)[:, 1]\n",
    "\n",
    "    return y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = 1.0\n",
    "n_splits = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/kd/mambaforge/envs/ml-zoomcamp-py313/lib/python3.13/site-packages/sklearn/linear_model/_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/home/kd/mambaforge/envs/ml-zoomcamp-py313/lib/python3.13/site-packages/sklearn/linear_model/_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/home/kd/mambaforge/envs/ml-zoomcamp-py313/lib/python3.13/site-packages/sklearn/linear_model/_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/home/kd/mambaforge/envs/ml-zoomcamp-py313/lib/python3.13/site-packages/sklearn/linear_model/_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C=1.0 0.842 += 0.007\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/kd/mambaforge/envs/ml-zoomcamp-py313/lib/python3.13/site-packages/sklearn/linear_model/_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    }
   ],
   "source": [
    "kfold = KFold(n_splits=n_splits, shuffle=True, random_state=1)\n",
    "\n",
    "scores = []\n",
    "\n",
    "for train_idx, val_idx in kfold.split(df_full_train):\n",
    "    df_train = df_full_train.iloc[train_idx]\n",
    "    df_val = df_full_train.iloc[val_idx]\n",
    "\n",
    "    y_train = df_train.churn.values\n",
    "    y_val = df_val.churn.values\n",
    "\n",
    "    dv, model = train(df_train, y_train, C=C)\n",
    "    y_pred = predict(df_val, dv, model)\n",
    "\n",
    "    auc = roc_auc_score(y_val, y_pred)\n",
    "    scores.append(auc)\n",
    "\n",
    "print(f\"C={C} {np.mean(scores):.3f} += {np.std(scores):.3f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[np.float64(0.8446632807655171),\n",
       " np.float64(0.8452295225797907),\n",
       " np.float64(0.833257074051776),\n",
       " np.float64(0.8346889588795804),\n",
       " np.float64(0.8517617897147877)]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will save the model using `pickle`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_file = f\"model_C={C}.bin\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_out = open(output_file, \"wb\")\n",
    "pickle.dump((dv, model), f_out)\n",
    "f_out.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(output_file, \"wb\") as f_out:\n",
    "    pickle.dump((dv, model), f_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how we can load the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_file = \"model_C=1.0.bin\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(output_file, \"rb\") as f_in:\n",
    "    dv, model = pickle.load(f_in)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-4 {\n",
       "  /* Definition of color scheme common for light and dark mode */\n",
       "  --sklearn-color-text: black;\n",
       "  --sklearn-color-line: gray;\n",
       "  /* Definition of color scheme for unfitted estimators */\n",
       "  --sklearn-color-unfitted-level-0: #fff5e6;\n",
       "  --sklearn-color-unfitted-level-1: #f6e4d2;\n",
       "  --sklearn-color-unfitted-level-2: #ffe0b3;\n",
       "  --sklearn-color-unfitted-level-3: chocolate;\n",
       "  /* Definition of color scheme for fitted estimators */\n",
       "  --sklearn-color-fitted-level-0: #f0f8ff;\n",
       "  --sklearn-color-fitted-level-1: #d4ebff;\n",
       "  --sklearn-color-fitted-level-2: #b3dbfd;\n",
       "  --sklearn-color-fitted-level-3: cornflowerblue;\n",
       "\n",
       "  /* Specific color for light theme */\n",
       "  --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
       "  --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, white)));\n",
       "  --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
       "  --sklearn-color-icon: #696969;\n",
       "\n",
       "  @media (prefers-color-scheme: dark) {\n",
       "    /* Redefinition of color scheme for dark theme */\n",
       "    --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
       "    --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, #111)));\n",
       "    --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
       "    --sklearn-color-icon: #878787;\n",
       "  }\n",
       "}\n",
       "\n",
       "#sk-container-id-4 {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 pre {\n",
       "  padding: 0;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 input.sk-hidden--visually {\n",
       "  border: 0;\n",
       "  clip: rect(1px 1px 1px 1px);\n",
       "  clip: rect(1px, 1px, 1px, 1px);\n",
       "  height: 1px;\n",
       "  margin: -1px;\n",
       "  overflow: hidden;\n",
       "  padding: 0;\n",
       "  position: absolute;\n",
       "  width: 1px;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-dashed-wrapped {\n",
       "  border: 1px dashed var(--sklearn-color-line);\n",
       "  margin: 0 0.4em 0.5em 0.4em;\n",
       "  box-sizing: border-box;\n",
       "  padding-bottom: 0.4em;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-container {\n",
       "  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n",
       "     but bootstrap.min.css set `[hidden] { display: none !important; }`\n",
       "     so we also need the `!important` here to be able to override the\n",
       "     default hidden behavior on the sphinx rendered scikit-learn.org.\n",
       "     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n",
       "  display: inline-block !important;\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-text-repr-fallback {\n",
       "  display: none;\n",
       "}\n",
       "\n",
       "div.sk-parallel-item,\n",
       "div.sk-serial,\n",
       "div.sk-item {\n",
       "  /* draw centered vertical line to link estimators */\n",
       "  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n",
       "  background-size: 2px 100%;\n",
       "  background-repeat: no-repeat;\n",
       "  background-position: center center;\n",
       "}\n",
       "\n",
       "/* Parallel-specific style estimator block */\n",
       "\n",
       "#sk-container-id-4 div.sk-parallel-item::after {\n",
       "  content: \"\";\n",
       "  width: 100%;\n",
       "  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n",
       "  flex-grow: 1;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-parallel {\n",
       "  display: flex;\n",
       "  align-items: stretch;\n",
       "  justify-content: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-parallel-item {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-parallel-item:first-child::after {\n",
       "  align-self: flex-end;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-parallel-item:last-child::after {\n",
       "  align-self: flex-start;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-parallel-item:only-child::after {\n",
       "  width: 0;\n",
       "}\n",
       "\n",
       "/* Serial-specific style estimator block */\n",
       "\n",
       "#sk-container-id-4 div.sk-serial {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "  align-items: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  padding-right: 1em;\n",
       "  padding-left: 1em;\n",
       "}\n",
       "\n",
       "\n",
       "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n",
       "clickable and can be expanded/collapsed.\n",
       "- Pipeline and ColumnTransformer use this feature and define the default style\n",
       "- Estimators will overwrite some part of the style using the `sk-estimator` class\n",
       "*/\n",
       "\n",
       "/* Pipeline and ColumnTransformer style (default) */\n",
       "\n",
       "#sk-container-id-4 div.sk-toggleable {\n",
       "  /* Default theme specific background. It is overwritten whether we have a\n",
       "  specific estimator or a Pipeline/ColumnTransformer */\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "/* Toggleable label */\n",
       "#sk-container-id-4 label.sk-toggleable__label {\n",
       "  cursor: pointer;\n",
       "  display: block;\n",
       "  width: 100%;\n",
       "  margin-bottom: 0;\n",
       "  padding: 0.5em;\n",
       "  box-sizing: border-box;\n",
       "  text-align: center;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 label.sk-toggleable__label-arrow:before {\n",
       "  /* Arrow on the left of the label */\n",
       "  content: \"▸\";\n",
       "  float: left;\n",
       "  margin-right: 0.25em;\n",
       "  color: var(--sklearn-color-icon);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 label.sk-toggleable__label-arrow:hover:before {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "/* Toggleable content - dropdown */\n",
       "\n",
       "#sk-container-id-4 div.sk-toggleable__content {\n",
       "  max-height: 0;\n",
       "  max-width: 0;\n",
       "  overflow: hidden;\n",
       "  text-align: left;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-toggleable__content.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-toggleable__content pre {\n",
       "  margin: 0.2em;\n",
       "  border-radius: 0.25em;\n",
       "  color: var(--sklearn-color-text);\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-toggleable__content.fitted pre {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n",
       "  /* Expand drop-down */\n",
       "  max-height: 200px;\n",
       "  max-width: 100%;\n",
       "  overflow: auto;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n",
       "  content: \"▾\";\n",
       "}\n",
       "\n",
       "/* Pipeline/ColumnTransformer-specific style */\n",
       "\n",
       "#sk-container-id-4 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator-specific style */\n",
       "\n",
       "/* Colorize estimator box */\n",
       "#sk-container-id-4 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-label label.sk-toggleable__label,\n",
       "#sk-container-id-4 div.sk-label label {\n",
       "  /* The background is the default theme color */\n",
       "  color: var(--sklearn-color-text-on-default-background);\n",
       "}\n",
       "\n",
       "/* On hover, darken the color of the background */\n",
       "#sk-container-id-4 div.sk-label:hover label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "/* Label box, darken color on hover, fitted */\n",
       "#sk-container-id-4 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator label */\n",
       "\n",
       "#sk-container-id-4 div.sk-label label {\n",
       "  font-family: monospace;\n",
       "  font-weight: bold;\n",
       "  display: inline-block;\n",
       "  line-height: 1.2em;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-label-container {\n",
       "  text-align: center;\n",
       "}\n",
       "\n",
       "/* Estimator-specific */\n",
       "#sk-container-id-4 div.sk-estimator {\n",
       "  font-family: monospace;\n",
       "  border: 1px dotted var(--sklearn-color-border-box);\n",
       "  border-radius: 0.25em;\n",
       "  box-sizing: border-box;\n",
       "  margin-bottom: 0.5em;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-estimator.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "/* on hover */\n",
       "#sk-container-id-4 div.sk-estimator:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-4 div.sk-estimator.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n",
       "\n",
       "/* Common style for \"i\" and \"?\" */\n",
       "\n",
       ".sk-estimator-doc-link,\n",
       "a:link.sk-estimator-doc-link,\n",
       "a:visited.sk-estimator-doc-link {\n",
       "  float: right;\n",
       "  font-size: smaller;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  border-radius: 1em;\n",
       "  height: 1em;\n",
       "  width: 1em;\n",
       "  text-decoration: none !important;\n",
       "  margin-left: 1ex;\n",
       "  /* unfitted */\n",
       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-unfitted-level-1);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted,\n",
       "a:link.sk-estimator-doc-link.fitted,\n",
       "a:visited.sk-estimator-doc-link.fitted {\n",
       "  /* fitted */\n",
       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-1);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "/* Span, style for the box shown on hovering the info icon */\n",
       ".sk-estimator-doc-link span {\n",
       "  display: none;\n",
       "  z-index: 9999;\n",
       "  position: relative;\n",
       "  font-weight: normal;\n",
       "  right: .2ex;\n",
       "  padding: .5ex;\n",
       "  margin: .5ex;\n",
       "  width: min-content;\n",
       "  min-width: 20ex;\n",
       "  max-width: 50ex;\n",
       "  color: var(--sklearn-color-text);\n",
       "  box-shadow: 2pt 2pt 4pt #999;\n",
       "  /* unfitted */\n",
       "  background: var(--sklearn-color-unfitted-level-0);\n",
       "  border: .5pt solid var(--sklearn-color-unfitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted span {\n",
       "  /* fitted */\n",
       "  background: var(--sklearn-color-fitted-level-0);\n",
       "  border: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link:hover span {\n",
       "  display: block;\n",
       "}\n",
       "\n",
       "/* \"?\"-specific style due to the `<a>` HTML tag */\n",
       "\n",
       "#sk-container-id-4 a.estimator_doc_link {\n",
       "  float: right;\n",
       "  font-size: 1rem;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  border-radius: 1rem;\n",
       "  height: 1rem;\n",
       "  width: 1rem;\n",
       "  text-decoration: none;\n",
       "  /* unfitted */\n",
       "  color: var(--sklearn-color-unfitted-level-1);\n",
       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 a.estimator_doc_link.fitted {\n",
       "  /* fitted */\n",
       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-1);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "#sk-container-id-4 a.estimator_doc_link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "#sk-container-id-4 a.estimator_doc_link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "</style><div id=\"sk-container-id-4\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LogisticRegression(max_iter=1000)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" checked><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow fitted\">&nbsp;&nbsp;LogisticRegression<a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.5/modules/generated/sklearn.linear_model.LogisticRegression.html\">?<span>Documentation for LogisticRegression</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></label><div class=\"sk-toggleable__content fitted\"><pre>LogisticRegression(max_iter=1000)</pre></div> </div></div></div></div>"
      ],
      "text/plain": [
       "LogisticRegression(max_iter=1000)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's say we have this customer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "customer = {\n",
    "    'gender': 'male',\n",
    "    'seniorcitizen': 0,\n",
    "    'partner': 'yes',\n",
    "    'dependents': 'yes',\n",
    "    'phoneservice': 'yes',\n",
    "    'multiplelines': 'no',\n",
    "    'internetservice': 'no',\n",
    "    'onlinesecurity': 'no_internet_service',\n",
    "    'onlinebackup': 'no_internet_service',\n",
    "    'deviceprotection': 'no_internet_service',\n",
    "    'techsupport': 'no_internet_service',\n",
    "    'streamingtv': 'no_internet_service',\n",
    "    'streamingmovies': 'no_internet_service',\n",
    "    'contract': 'two_year',\n",
    "    'paperlessbilling': 'no',\n",
    "    'paymentmethod': 'mailed_check',\n",
    "    'tenure': 12,\n",
    "    'monthlycharges': 19.7,\n",
    "    'totalcharges': 258.35\n",
    " }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can predict churn as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(0.02597332043593159)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = dv.transform([customer])\n",
    "model.predict_proba(X)[0, 1]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now we can save a model, load it, use it. But we want to have it in a separate python file. We can create [train.py](train.py) and [predict.py](predict.py) and run them with Python. Next we will create a web service which uses these files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 5.3 [Web services: introduction to Flask](https://github.com/DataTalksClub/machine-learning-zoomcamp/blob/master/05-deployment/03-flask-intro.md)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Flask is a Python framework for creating web services. We want to encapsulate our model inside a web service called 'churn service'. \n",
    "\n",
    "Web service is a method for 2 devices to communicate over a network. Some information is sent to the web service with a request, then information is sent back by the web service. So we will send information on a customer and the web service will return a churn prediction.\n",
    "\n",
    "We can create a file called `ping.py`:\n",
    "\n",
    "```python\n",
    "from flask import Flask\n",
    "\n",
    "app = Flask(\"ping\")\n",
    "\n",
    "@app.route(\"/ping\", methods=[\"GET\"])\n",
    "def ping():\n",
    "    return \"PONG\"\n",
    "\n",
    "if __name__==\"__main__\":\n",
    "    app.run(debug=True, host=\"0.0.0.0\", port=\"9696\")\n",
    "```\n",
    "\n",
    "If we run this file, we can go to the browser or cmd with curl and type `127.0.0.1:9696/ping` or `localhost:9696/ping` and it will return `\"PONG\"`. This is a minimal example of creating a web service using Flask.\n",
    "\n",
    "We can also use FastAPI as follows:\n",
    "```python\n",
    "from fastapi import FastAPI\n",
    "\n",
    "app = FastAPI()\n",
    "\n",
    "@app.get(\"/ping\")\n",
    "async def ping():\n",
    "    return \"PONG\"\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    import uvicorn\n",
    "    uvicorn.run(app, host=\"0.0.0.0\", port=9696)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 5.4 [Serving the churn model with Flask](https://github.com/DataTalksClub/machine-learning-zoomcamp/blob/master/05-deployment/04-flask-deployment.md)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This lesson we will take the `predict.py` script and turn it into a web service using Flask. This script is saved here: [week_5/predict.py](predict.py). I have commented the code. If we run `predict.py`, a web server will be started and we can send a post request to it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'churn': False, 'churn_probability': 0.03231290082794979}"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import requests\n",
    "\n",
    "url = \"http://localhost:9696/predict\"\n",
    "\n",
    "requests.post(url, json=customer).json()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This runs a Flask development server. Although this makes it easier to debug by allowing for automatic reload and providing error messages, it is not scalable, performant, and secure. Therefore we need a production server instead (e.g. `gunicorn`). We can pip install it and then run it as follows from the command line:\n",
    "```bash\n",
    "gunicorn --bind 0.0.0.0:9696 predict:app\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 5.5 [Python virtual environment: Pipenv](https://github.com/DataTalksClub/machine-learning-zoomcamp/blob/master/05-deployment/05-pipenv.md)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have multiple services running side-by-side, they may require different versions of a library. This is not possible within one environment. To address this, we can use `pipenv`, which makes use of virtual environments. These are isolated environments with their own version of pip and python.\n",
    "\n",
    "There are different ways of managing virtual environments:\n",
    "- `virtualenv` / `venv` (recommended)\n",
    "- `conda`\n",
    "- `pipenv`\n",
    "- `poetry`\n",
    "\n",
    "We will use pipenv in this lesson."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting pipenv\n",
      "  Downloading pipenv-2024.2.0-py3-none-any.whl.metadata (19 kB)\n",
      "Requirement already satisfied: certifi in /home/kd/mambaforge/envs/ml-zoomcamp-py313/lib/python3.13/site-packages (from pipenv) (2024.8.30)\n",
      "Requirement already satisfied: packaging>=22 in /home/kd/mambaforge/envs/ml-zoomcamp-py313/lib/python3.13/site-packages (from pipenv) (24.1)\n",
      "Requirement already satisfied: setuptools>=67 in /home/kd/mambaforge/envs/ml-zoomcamp-py313/lib/python3.13/site-packages (from pipenv) (75.1.0)\n",
      "Collecting virtualenv>=20.24.2 (from pipenv)\n",
      "  Downloading virtualenv-20.27.0-py3-none-any.whl.metadata (4.5 kB)\n",
      "Collecting distlib<1,>=0.3.7 (from virtualenv>=20.24.2->pipenv)\n",
      "  Downloading distlib-0.3.9-py2.py3-none-any.whl.metadata (5.2 kB)\n",
      "Collecting filelock<4,>=3.12.2 (from virtualenv>=20.24.2->pipenv)\n",
      "  Downloading filelock-3.16.1-py3-none-any.whl.metadata (2.9 kB)\n",
      "Requirement already satisfied: platformdirs<5,>=3.9.1 in /home/kd/mambaforge/envs/ml-zoomcamp-py313/lib/python3.13/site-packages (from virtualenv>=20.24.2->pipenv) (4.3.6)\n",
      "Downloading pipenv-2024.2.0-py3-none-any.whl (3.0 MB)\n",
      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.0/3.0 MB\u001b[0m \u001b[31m5.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
      "\u001b[?25hDownloading virtualenv-20.27.0-py3-none-any.whl (3.1 MB)\n",
      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m5.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
      "\u001b[?25hDownloading distlib-0.3.9-py2.py3-none-any.whl (468 kB)\n",
      "Downloading filelock-3.16.1-py3-none-any.whl (16 kB)\n",
      "Installing collected packages: distlib, filelock, virtualenv, pipenv\n",
      "Successfully installed distlib-0.3.9 filelock-3.16.1 pipenv-2024.2.0 virtualenv-20.27.0\n"
     ]
    }
   ],
   "source": [
    "!pip install pipenv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the command line we can use pipenv to install the packages we need:\n",
    "```bash\n",
    "pipenv install numpy scikit-learn==1.5.2 flask\n",
    "```\n",
    "\n",
    "This creates a Pipfile and Pipfile.lock. The Pipfile contains an overview of the packages and the versions (similar to requirements.txt) and Pipfile.lock gives an overview of all dependencies and sub-dependencies, making the environment exactly reproducible. If we install gunicorn now, the files are updates:\n",
    "```bash\n",
    "pipenv install gunicorn\n",
    "```\n",
    "\n",
    "Let's say this repo is cloned to another computer later. The only thing to do is ```pipenv install``` and all the dependencies will be installed.\n",
    "\n",
    "If we type `pipenv shell` in the command line, it will start a shell for the virtual environment we created. Then we can run the command:\n",
    "```bash\n",
    "gunicorn --bind 0.0.0.0:9696 predict:app\n",
    "```\n",
    "\n",
    "Alternatively, we can run:\n",
    "```bash\n",
    "pipenv run gunicorn --bind 0.0.0.0:9696 predict:app\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.6 [Environment management: Docker](https://github.com/DataTalksClub/machine-learning-zoomcamp/blob/master/05-deployment/06-docker.md)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why we need Docker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Virtual environments can isolate dependencies. But Docker can isolate an application entirely from the rest of the computer using containers. Each container can use different versions of everything, not just python dependencies.\n",
    "\n",
    "<img src=docker.png width=600>\n",
    "\n",
    "It's also easy to deploy Docker containers to the cloud."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to run Docker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can run docker in interactive mode my:\n",
    "\n",
    "```bash\n",
    "docker run --platform linux/amd64 -it --rm python:3.8.12-slim\n",
    "```\n",
    "\n",
    "Let's break it down:\n",
    "- `3.8.12-slim` is a tag. We can find vaious Docker images in Docker Hub.\n",
    "- `--platform linux/amd64` is to specify the platform. It wasn't working otherwise.\n",
    "- `-it` indicates we want it in interactive mode, such that we can play around with it (otherwise it immediately closes).\n",
    "- `--rm` indicates we want to get rid of the image afterwards.\n",
    "\n",
    "This starts the container and runs python. We can change the default entrypoint:\n",
    "```bash\n",
    "docker run --platform linux/amd64 -it --rm --entrypoint=bash python:3.8.12-slim\n",
    "```\n",
    "\n",
    "This runs the bash shell and we can then install things. We can create a Dockerfile to do this in an automated way:\n",
    "\n",
    "```Dockerfile\n",
    "FROM python:3.13-slim\n",
    "\n",
    "RUN pip install pipenv\n",
    "\n",
    "WORKDIR /app\n",
    "COPY [\"Pipfile\", \"Pipfile.lock\", \"./\"]\n",
    "```\n",
    "\n",
    "Let's break this down:\n",
    "- `FROM` indicates the base image we want to use\n",
    "- `RUN` can run commands, such as pip install\n",
    "- `WORKDIR` will create a directory and cd into it\n",
    "- `COPY` will copy files to the directory at the end of the list (`\"./\"` is the current directory)\n",
    "\n",
    "We can build the Docker image using with the Dockerfile using:\n",
    "\n",
    "```bash\n",
    "docker build -t zoomcamp-test .\n",
    "```\n",
    "\n",
    "`-t zoomcamp-test` is to specify the tag\n",
    "`.` is to run the Dockerfile from the current directory\n",
    "\n",
    "Then we can run the docker image:\n",
    "\n",
    "```bash\n",
    "docker run -it --rm --entrypoint=bash zoomcamp-test\n",
    "```\n",
    "\n",
    "We will be in the directory `app` and the files we copies over will be in there:\n",
    "\n",
    "```bash\n",
    "root@6a94c5952cae:/app# ls\n",
    "Pipfile  Pipfile.lock\n",
    "```\n",
    "\n",
    "We can install all dependencies now with `pipenv install`.\n",
    "\n",
    "We don't need to manually run pipenv install. We can update the Dockerfile:\n",
    "\n",
    "```Dockerfile\n",
    "FROM python:3.13-slim\n",
    "\n",
    "RUN pip install pipenv\n",
    "\n",
    "WORKDIR /app\n",
    "COPY [\"Pipfile\", \"Pipfile.lock\", \"./\"]\n",
    "\n",
    "RUN pipenv install\n",
    "```\n",
    "\n",
    "However, this will create a virtual environment inside the Docker image, which is already isolated. We just want the dependencies installed (why not use `requirements.txt` then though?). So we can update the Dockerfile with `--system --deploy`:\n",
    "\n",
    "```Dockerfile\n",
    "FROM python:3.13-slim\n",
    "\n",
    "RUN pip install pipenv\n",
    "\n",
    "WORKDIR /app\n",
    "COPY [\"Pipfile\", \"Pipfile.lock\", \"./\"]\n",
    "\n",
    "RUN pipenv install --system --deploy\n",
    "```\n",
    "\n",
    "Next, let's copy `predict.py` and the model:\n",
    "\n",
    "```Dockerfile\n",
    "FROM python:3.13-slim\n",
    "\n",
    "RUN pip install pipenv\n",
    "\n",
    "WORKDIR /app\n",
    "COPY [\"Pipfile\", \"Pipfile.lock\", \"./\"]\n",
    "\n",
    "RUN pipenv install --system --deploy\n",
    "\n",
    "COPY [\"predict.py\", \"model_C=1.0.bin\", \"./\"]\n",
    "```\n",
    "\n",
    "We can build the Dockerfile again and run the image. Then we run gunicorn:\n",
    "\n",
    "```bash\n",
    "gunicorn --bind=0.0.0.0:9696 predict:app\n",
    "```\n",
    "\n",
    "However, we cannot access it yet. We need to expose port 9696 of the container and map it to a port on the host machine. Also we change the entrypoint to run the `predict.py` app with `gunicorn`: \n",
    "\n",
    "```Dockerfile\n",
    "FROM python:3.13-slim\n",
    "\n",
    "RUN pip install pipenv\n",
    "\n",
    "WORKDIR /app\n",
    "COPY [\"Pipfile\", \"Pipfile.lock\", \"./\"]\n",
    "\n",
    "RUN pipenv install --system --deploy\n",
    "\n",
    "COPY [\"predict.py\", \"model_C=1.0.bin\", \"./\"]\n",
    "\n",
    "EXPOSE 9696\n",
    "\n",
    "ENTRYPOINT [\"gunicorn\", \"--bind=0.0.0.0:9696\", \"predict:app\"]\n",
    "```\n",
    "\n",
    "Finally, when running Docker, we need to map the ports as follows:\n",
    "\n",
    "```bash\n",
    "docker run -it --rm -p 9696:9696 zoomcamp-test\n",
    "```\n",
    "\n",
    "Now we can run `predict-test.py` or `curl` and get the prediction from `predict.py` as a web service from a Docker container.\n",
    "\n",
    "The next step is to deploy this container to the cloud, which is what we'll do in Lesson 5.7."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 5.7 [Deployment to the cloud: AWS Elastic Beanstalk (optional)](https://github.com/DataTalksClub/machine-learning-zoomcamp/blob/master/05-deployment/07-aws-eb.md)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we want to deploy the Docker image to the cloud. We will use AWS Elastic Beanstalk.\n",
    "\n",
    "Elastic Beanstalk can automatically scale up an down as well as balance load.\n",
    "\n",
    "We need to install awsebcli. In the folder with our `predict.py` and `train.py` files, we can run:\n",
    "\n",
    "```bash\n",
    "pipenv install awsebcli --dev\n",
    "```\n",
    "\n",
    "`--dev` ensures it's designated as only to be used for development, not production.\n",
    "\n",
    "Then we go to the shell:\n",
    "\n",
    "```bash\n",
    "pipenv shell\n",
    "eb\n",
    "```\n",
    "\n",
    "Now we initialize the service:\n",
    "\n",
    "```bash\n",
    "eb init -p docker -r eu-west-1 churn-serving\n",
    "```\n",
    "\n",
    "- `-p docker` specifies the platform (in this case, Docker)\n",
    "- `-r eu-west-1` specifies the region to deploy the application\n",
    "- `churn-serving` specifies the name of the Elastic Beanstalk application.\n",
    "\n",
    "This should create a folder called `.elasticbeanstalk`\n",
    "\n",
    "We can check locally with EB if it works:\n",
    "\n",
    "```bash\n",
    "eb local run --port 9696\n",
    "```\n",
    "\n",
    "Note that initially I got this error:\n",
    "\n",
    "```bash\n",
    "ERROR: NotSupportedError - You can use \"eb local\" only with preconfigured, generic and multicontainer Docker platforms.\n",
    "```\n",
    "\n",
    "I resolved it by following a solution in the FAQ:\n",
    "\n",
    "```bash\n",
    "eb init -i\n",
    "```\n",
    "\n",
    "And then selecing: `Docker running on 64bit Amazon Linux 2023`\n",
    "\n",
    "After doing this, the `eb local run --port 9696` runs OK and the churn service is up.\n",
    "\n",
    "Now that it's confirmed to work, we will deploy the application to the cloud:\n",
    "\n",
    "```bash\n",
    "eb create churn-serving-env\n",
    "```\n",
    "\n",
    "I got this error:\n",
    "\n",
    "```bash\n",
    "2024-10-30 06:16:10    ERROR   Creating Auto Scaling launch configuration failed Reason: Resource handler returned message: \"The Launch Configuration creation operation is not available in your account. Use launch templates to create configuration templates for your Auto Scaling groups. (Service: AutoScaling, Status Code: 400, Request ID: c47ea712-2979-46bd-b44c-59362b37f48e)\" (RequestToken: d75111ee-1af1-d748-ed7d-c4a4de863b56, HandlerErrorCode: GeneralServiceException)\n",
    "```\n",
    "\n",
    "This one is also covered in the FAQ. The solution is to just run `eb create` and selecting `classic` load balancer type. See details in FAQ.\n",
    "\n",
    "Now the application is in the cloud. In `predict-test.py` we can adjust the post request by replacing `localhost:9696` with the host from the EB environment and use the web service.\n",
    "\n",
    "Finally, we terminate the web service:\n",
    "\n",
    "```bash\n",
    "eb terminate churn-serving-env\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 5.8 [Summary](https://github.com/DataTalksClub/machine-learning-zoomcamp/blob/master/05-deployment/08-summary.md)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No notes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 5.9 [Explore more](https://github.com/DataTalksClub/machine-learning-zoomcamp/blob/master/05-deployment/09-explore-more.md)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No notes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 5.10 [Homework](https://github.com/DataTalksClub/machine-learning-zoomcamp/blob/master/05-deployment/homework.md)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Go to [week_5_homework.ipynb](week_5_homework/week_5_homework.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ml-zoomcamp-py313",
   "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.13.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}