tutorial/model_drift/tutorial01-modeldrift.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d3a55be4",
   "metadata": {},
   "source": [
    "# Modeldrift with Eurybia\n",
    "<b>With this tutorial you:</b><br />\n",
    "Understand how to use Eurybia to detect model drift\n",
    "\n",
    "Contents:\n",
    "- Detect data drift  \n",
    "- Display model drift over years\n",
    "\n",
    "This tutorial contains only additional features of model drift.\n",
    "For more detailed information on data drift, you can consult these tutorials :\n",
    "(https://github.com/MAIF/eurybia/tree/master/tutorial/data_drift)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dab5e19",
   "metadata": {},
   "source": [
    "**Requirements notice** : the following tutorial may use third party modules not included in Eurybia.  \n",
    "You can find them all in one file [on our Github repository](https://github.com/MAIF/eurybia/blob/master/requirements.dev.txt) or you can manually install those you are missing, if any."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ba3029c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from category_encoders import OrdinalEncoder\n",
    "from lightgbm import LGBMRegressor\n",
    "from eurybia import SmartDrift\n",
    "from eurybia.data.data_loader import data_loading\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import mean_squared_log_error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a37f9001",
   "metadata": {},
   "source": [
    "## Import Dataset and split in training and production dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5e301c02",
   "metadata": {},
   "outputs": [],
   "source": [
    "house_df, house_dict = data_loading('house_prices')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fd3a5e27",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let us consider that the column \"YrSold\" corresponds to the reference date. \n",
    "#In 2006, a model was trained using data. And in 2007, we want to detect data drift on new data in production to predict\n",
    "#house price\n",
    "house_df_learning = house_df.loc[house_df['YrSold'] == 2006]\n",
    "house_df_2007 = house_df.loc[house_df['YrSold'] == 2007]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d747da67",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_df_learning=house_df_learning['SalePrice'].to_frame()\n",
    "X_df_learning=house_df_learning[house_df_learning.columns.difference(['SalePrice','YrSold'])]\n",
    "\n",
    "y_df_2007=house_df_2007['SalePrice'].to_frame()\n",
    "X_df_2007=house_df_2007[house_df_2007.columns.difference(['SalePrice','YrSold'])]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f280f685",
   "metadata": {},
   "source": [
    "## Building Supervized Model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c9af09e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from category_encoders import OrdinalEncoder\n",
    "\n",
    "categorical_features = [col for col in X_df_learning.columns if X_df_learning[col].dtype == 'object']\n",
    "\n",
    "encoder = OrdinalEncoder(\n",
    "    cols=categorical_features,\n",
    "    handle_unknown='ignore',\n",
    "    return_df=True).fit(X_df_learning)\n",
    "\n",
    "X_df_learning_encoded=encoder.transform(X_df_learning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ec4277c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "Xtrain, Xtest, ytrain, ytest = train_test_split(X_df_learning_encoded, y_df_learning, train_size=0.75, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d3f7cc5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "regressor = LGBMRegressor(n_estimators=200).fit(Xtrain,ytrain)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "086c7e3d",
   "metadata": {},
   "source": [
    "## Use Eurybia for data drift"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5bd64f9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "SD = SmartDrift(df_current=X_df_2007,\n",
    "                df_baseline=X_df_learning,\n",
    "                deployed_model=regressor, # Optional: put in perspective result with importance on deployed model\n",
    "                encoding=encoder # Optional: if deployed_model and encoder to use this model\n",
    "               )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bead8a97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 9 µs, sys: 0 ns, total: 9 µs\n",
      "Wall time: 30 µs\n",
      "The variable BsmtCond has mismatching unique values:\n",
      "['Poor -Severe cracking, settling, or wetness'] | []\n",
      "\n",
      "The variable Condition2 has mismatching unique values:\n",
      "['Near positive off-site feature--park, greenbelt, etc.', 'Adjacent to North-South Railroad', 'Adjacent to East-West Railroad'] | ['Adjacent to feeder street']\n",
      "\n",
      "The variable Electrical has mismatching unique values:\n",
      "['Mixed'] | ['60 AMP Fuse Box and mostly knob & tube wiring (poor)']\n",
      "\n",
      "The variable ExterQual has mismatching unique values:\n",
      "['Fair'] | []\n",
      "\n",
      "The variable Exterior1st has mismatching unique values:\n",
      "[] | ['Stone', 'Imitation Stucco']\n",
      "\n",
      "The variable Exterior2nd has mismatching unique values:\n",
      "['Asphalt Shingles', 'Brick Common'] | ['Other']\n",
      "\n",
      "The variable Foundation has mismatching unique values:\n",
      "[] | ['Stone', 'Wood']\n",
      "\n",
      "The variable Functional has mismatching unique values:\n",
      "['Major Deductions 2', 'Severely Damaged'] | ['Moderate Deductions']\n",
      "\n",
      "The variable GarageQual has mismatching unique values:\n",
      "[] | ['Excellent']\n",
      "\n",
      "The variable Heating has mismatching unique values:\n",
      "[] | ['Wall furnace']\n",
      "\n",
      "The variable HeatingQC has mismatching unique values:\n",
      "['Poor'] | []\n",
      "\n",
      "The variable LotConfig has mismatching unique values:\n",
      "[] | ['Frontage on 3 sides of property']\n",
      "\n",
      "The variable MSSubClass has mismatching unique values:\n",
      "['1-Story w/Finished Attic All Ages'] | []\n",
      "\n",
      "The variable Neighborhood has mismatching unique values:\n",
      "['Northpark Villa'] | []\n",
      "\n",
      "The variable RoofMatl has mismatching unique values:\n",
      "['Roll'] | ['Metal']\n",
      "\n",
      "The variable RoofStyle has mismatching unique values:\n",
      "['Mansard', 'Shed'] | []\n",
      "\n",
      "The variable SaleType has mismatching unique values:\n",
      "['Warranty Deed - Cash'] | ['Contract Low Interest', 'Contract Low Down', 'Contract Low Down payment and low interest']\n",
      "\n",
      "The variable Street has mismatching unique values:\n",
      "['Gravel'] | []\n",
      "\n",
      "The computed AUC on the X_test used to build datadrift_classifier is equal to: 0.626082251082251\n"
     ]
    }
   ],
   "source": [
    "%time \n",
    "SD.compile(full_validation=True, # Optional: to save time, leave the default False value. If True, analyze consistency on modalities between columns.\n",
    "           date_compile_auc = '01/01/2007', # Optional: useful when computing the drift for a time that is not now\n",
    "           datadrift_file = \"house_price_auc.csv\" # Optional: name of the csv file that contains the performance history of data drift\n",
    "          )\n",
    "                 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "625d0912",
   "metadata": {},
   "source": [
    "As soon as compile() method, Eurybia displays default consistency checks as warnings.<br />\n",
    "If some modalities are not present during training and are in production dataset, the deployed model will consider them wrongly.<br />\n",
    "Inversely, if some modalities are present during training and are not in production dataset, it means that some profiles are missing."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8ad7820",
   "metadata": {},
   "source": [
    "## Add model drift in report"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e39dc67c",
   "metadata": {},
   "source": [
    "For the moment, the model drift part of eurybia only consists of displaying performance of deployed model. \n",
    "(We hope to bring new features in the future on this part)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82d0de33",
   "metadata": {},
   "source": [
    "### Put model performance in DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "79ae3c07",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = regressor.predict(Xtest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "28635fd0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.031487"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performance_test = mean_squared_log_error(ytest, y_pred).round(6)\n",
    "performance_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c12a14e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create Dataframe to track performance over the years\n",
    "df_performance = pd.DataFrame({'annee': [2006], 'mois':[1], 'performance': [performance_test]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4f164198",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03309"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_2007_encode=encoder.transform(X_df_2007)\n",
    "y_pred_2007 = regressor.predict(df_2007_encode)\n",
    "performance_2007 = mean_squared_log_error(y_df_2007, y_pred_2007).round(6)\n",
    "performance_2007"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd9fe858",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_performance = df_performance.append({'annee': 2007, 'mois':1, 'performance': performance_2007}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52912cfe",
   "metadata": {},
   "source": [
    "### Add performance Dataframe in Smartdrift"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f0e96f82",
   "metadata": {},
   "outputs": [],
   "source": [
    "SD.add_data_modeldrift(dataset=df_performance,metric='performance') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ef937e7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Report saved to ./report_house_price_modeldrift_2007.html. To upload and share your report, create a free Datapane account by running `!datapane signup`."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "SD.generate_report(    \n",
    "    output_file='report_house_price_modeldrift_2007.html',    \n",
    "    title_story=\"Data drift\",\n",
    "    title_description=\"\"\"House price model drift 2007\"\"\", # Optional: add a subtitle to describe report\n",
    "    project_info_file=\"../../eurybia/data/project_info_house_price.yml\" # Optional: add information on report\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84c8883b",
   "metadata": {},
   "source": [
    "Eurybia is designed to generate an HTML report for analysis, and less for use in notebook mode. \n",
    "However, to illustrate functionalities, we will detail results with notebook mode analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4add0130",
   "metadata": {},
   "source": [
    "This tutorial contains only anlysis on additional features of model drift. For more detailed information on data drift, you can consult these tutorials : (https://github.com/MAIF/eurybia/tree/master/tutorial/data_drift)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88cfeb49",
   "metadata": {},
   "source": [
    "### Display model drift"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6d33cabf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "SD.plot.generate_modeldrift_data() # works if date_compile_auc and/or datadrift_file are filled"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f1241e2",
   "metadata": {},
   "source": [
    "### Display model drift with multiple indicators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08d89b46",
   "metadata": {},
   "source": [
    "If you have several metrics or indicators for performance monitoring, it is possible to have reference columns.\n",
    "Let's create a dummy performance table to show the use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e5dff49d",
   "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>indicator</th>\n",
       "      <th>level_1</th>\n",
       "      <th>annee</th>\n",
       "      <th>mois</th>\n",
       "      <th>performance</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>rmse</td>\n",
       "      <td>0</td>\n",
       "      <td>2006.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.031487</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>rmse</td>\n",
       "      <td>1</td>\n",
       "      <td>2007.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.033090</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>mse</td>\n",
       "      <td>0</td>\n",
       "      <td>2006.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.031988</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>mse</td>\n",
       "      <td>1</td>\n",
       "      <td>2007.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.033644</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  indicator  level_1   annee  mois  performance\n",
       "0      rmse        0  2006.0   1.0     0.031487\n",
       "1      rmse        1  2007.0   1.0     0.033090\n",
       "2       mse        0  2006.0   1.0     1.031988\n",
       "3       mse        1  2007.0   1.0     1.033644"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_performance_mse = df_performance.copy()\n",
    "df_performance_mse['performance']= np.exp(df_performance_mse['performance'])\n",
    "df_performance2 = pd.concat([df_performance, df_performance_mse], keys=[\"rmse\", \"mse\"]).reset_index().rename(columns={\"level_0\": \"indicator\"})\n",
    "df_performance2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d38140b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "SD.add_data_modeldrift(dataset=df_performance2,metric='performance',reference_columns=['indicator']) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f55d65b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Report saved to ./report_house_price_modeldrift_2007.html. To upload and share your report, create a free Datapane account by running `!datapane signup`."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "SD.generate_report(    \n",
    "    output_file='report_house_price_modeldrift_2007.html',    \n",
    "    title_story=\"Data drift\",\n",
    "    title_description=\"\"\"House price model drift 2007\"\"\", # Optional: add a subtitle to describe report\n",
    "    project_info_file=\"../../eurybia/data/project_info_house_price.yml\" # Optional: add information on report  \n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "745f1602",
   "metadata": {},
   "source": [
    "## Compile Drift over years"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "836e07cc",
   "metadata": {},
   "source": [
    "### Compile Drift et generate report for Year 2008"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4b495e2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "house_df_2008 = house_df.loc[house_df['YrSold'] == 2008]\n",
    "\n",
    "y_df_2008=house_df_2008['SalePrice'].to_frame()\n",
    "X_df_2008=house_df_2008[house_df_2008.columns.difference(['SalePrice','YrSold'])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a0afc6d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.028883"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_2008_encode=encoder.transform(X_df_2008)\n",
    "y_pred_2008 = regressor.predict(df_2008_encode)\n",
    "performance_2008 = mean_squared_log_error(y_df_2008, y_pred_2008).round(6)\n",
    "performance_2008"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2eb05bf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_performance = df_performance.append({'annee': 2008, 'mois':1, 'performance': performance_2008}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "25926a75",
   "metadata": {},
   "outputs": [],
   "source": [
    "SD = SmartDrift(df_current=X_df_2008,\n",
    "                df_baseline=X_df_learning,\n",
    "                deployed_model=regressor, # Optional: put in perspective result with importance on deployed model\n",
    "                encoding=encoder # Optional: if deployed_model and encoder to use this model\n",
    "               )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "aba273ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The variable Condition1 has mismatching unique values:\n",
      "[\"Within 200' of East-West Railroad\"] | []\n",
      "\n",
      "The variable Condition2 has mismatching unique values:\n",
      "['Adjacent to arterial street', \"Within 200' of North-South Railroad\", 'Adjacent to postive off-site feature', 'Near positive off-site feature--park, greenbelt, etc.'] | []\n",
      "\n",
      "The variable Electrical has mismatching unique values:\n",
      "['Mixed'] | []\n",
      "\n",
      "The variable ExterCond has mismatching unique values:\n",
      "['Excellent'] | []\n",
      "\n",
      "The variable ExterQual has mismatching unique values:\n",
      "['Fair'] | []\n",
      "\n",
      "The variable Exterior1st has mismatching unique values:\n",
      "[] | ['Imitation Stucco']\n",
      "\n",
      "The variable Exterior2nd has mismatching unique values:\n",
      "[] | ['Other', 'Stone']\n",
      "\n",
      "The variable Foundation has mismatching unique values:\n",
      "[] | ['Slab', 'Wood']\n",
      "\n",
      "The variable Functional has mismatching unique values:\n",
      "['Major Deductions 2'] | []\n",
      "\n",
      "The variable GarageCond has mismatching unique values:\n",
      "['Excellent'] | ['Poor']\n",
      "\n",
      "The variable GarageQual has mismatching unique values:\n",
      "[] | ['Poor']\n",
      "\n",
      "The variable GarageType has mismatching unique values:\n",
      "[] | ['More than one type of garage']\n",
      "\n",
      "The variable Heating has mismatching unique values:\n",
      "['Hot water or steam heat other than gas', 'Floor Furnace'] | ['Wall furnace']\n",
      "\n",
      "The variable MSSubClass has mismatching unique values:\n",
      "['1-Story w/Finished Attic All Ages'] | []\n",
      "\n",
      "The variable Neighborhood has mismatching unique values:\n",
      "['Northpark Villa', 'Bluestem'] | []\n",
      "\n",
      "The variable RoofMatl has mismatching unique values:\n",
      "['Membrane', 'Clay or Tile'] | ['Metal']\n",
      "\n",
      "The variable SaleCondition has mismatching unique values:\n",
      "[] | ['Sale between family members']\n",
      "\n",
      "The variable SaleType has mismatching unique values:\n",
      "['Contract 15% Down payment regular terms', 'Warranty Deed - Cash'] | ['Contract Low Interest', 'Other']\n",
      "\n",
      "The variable Street has mismatching unique values:\n",
      "['Gravel'] | []\n",
      "\n",
      "The computed AUC on the X_test used to build datadrift_classifier is equal to: 0.6877714667557634\n"
     ]
    }
   ],
   "source": [
    "SD.compile(full_validation=True, # Optional: to save time, leave the default False value. If True, analyze consistency on modalities between columns.\n",
    "           date_compile_auc = '01/01/2008', # Optional: useful when computing the drift for a time that is not now\n",
    "           datadrift_file = \"house_price_auc.csv\" # Optional: name of the csv file that contains the performance history of data drift\n",
    "          )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6868d560",
   "metadata": {},
   "outputs": [],
   "source": [
    "SD.add_data_modeldrift(dataset=df_performance,metric='performance') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "46ad3795",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Report saved to ./report_house_price_modeldrift_2008.html. To upload and share your report, create a free Datapane account by running `!datapane signup`."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "SD.generate_report(    \n",
    "    output_file='report_house_price_modeldrift_2008.html',    \n",
    "    title_story=\"Model drift\",\n",
    "    title_description=\"\"\"House price model drift 2008\"\"\", # Optional: add a subtitle to describe report\n",
    "    project_info_file=\"../../eurybia/data/project_info_house_price.yml\" # Optional: add information on report\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78b3758e",
   "metadata": {},
   "source": [
    "### Compile Drift et generate report for Year 2009"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c782c7de",
   "metadata": {},
   "outputs": [],
   "source": [
    "house_df_2009 = house_df.loc[house_df['YrSold'] == 2009]\n",
    "\n",
    "y_df_2009=house_df_2009['SalePrice'].to_frame()\n",
    "X_df_2009=house_df_2009[house_df_2009.columns.difference(['SalePrice','YrSold'])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "854430e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.031778"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_2009_encode=encoder.transform(X_df_2009)\n",
    "y_pred_2009 = regressor.predict(df_2009_encode)\n",
    "performance_2009 = mean_squared_log_error(y_df_2009, y_pred_2009).round(6)\n",
    "performance_2009"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f4d82f70",
   "metadata": {},
   "outputs": [],
   "source": [
    "SD = SmartDrift(df_current=X_df_2009,\n",
    "                df_baseline=X_df_learning,\n",
    "                deployed_model=regressor, # Optional: put in perspective result with importance on deployed model\n",
    "                encoding=encoder # Optional: if deployed_model and encoder to use this model\n",
    "               )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "be02b63f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The variable BsmtCond has mismatching unique values:\n",
      "['Poor -Severe cracking, settling, or wetness'] | []\n",
      "\n",
      "The variable Condition1 has mismatching unique values:\n",
      "[] | ['Adjacent to East-West Railroad']\n",
      "\n",
      "The variable Condition2 has mismatching unique values:\n",
      "['Adjacent to arterial street'] | []\n",
      "\n",
      "The variable Electrical has mismatching unique values:\n",
      "[] | ['60 AMP Fuse Box and mostly knob & tube wiring (poor)']\n",
      "\n",
      "The variable ExterCond has mismatching unique values:\n",
      "['Excellent'] | []\n",
      "\n",
      "The variable ExterQual has mismatching unique values:\n",
      "['Fair'] | []\n",
      "\n",
      "The variable Exterior1st has mismatching unique values:\n",
      "['Brick Common', 'Cinder Block'] | ['Stone', 'Imitation Stucco']\n",
      "\n",
      "The variable Exterior2nd has mismatching unique values:\n",
      "['Brick Common', 'Cinder Block'] | ['Other']\n",
      "\n",
      "The variable Functional has mismatching unique values:\n",
      "['Major Deductions 2'] | []\n",
      "\n",
      "The variable GarageCond has mismatching unique values:\n",
      "['Excellent'] | ['Good']\n",
      "\n",
      "The variable GarageQual has mismatching unique values:\n",
      "[] | ['Poor']\n",
      "\n",
      "The variable GarageType has mismatching unique values:\n",
      "[] | ['More than one type of garage']\n",
      "\n",
      "The variable LotConfig has mismatching unique values:\n",
      "[] | ['Frontage on 3 sides of property']\n",
      "\n",
      "The variable MSSubClass has mismatching unique values:\n",
      "['1-Story w/Finished Attic All Ages'] | []\n",
      "\n",
      "The variable Neighborhood has mismatching unique values:\n",
      "['Northpark Villa', 'Bluestem'] | ['Veenker']\n",
      "\n",
      "The variable RoofMatl has mismatching unique values:\n",
      "[] | ['Metal', 'Wood Shakes']\n",
      "\n",
      "The variable RoofStyle has mismatching unique values:\n",
      "['Mansard'] | []\n",
      "\n",
      "The variable SaleCondition has mismatching unique values:\n",
      "[] | ['Adjoining Land Purchase']\n",
      "\n",
      "The variable SaleType has mismatching unique values:\n",
      "[] | ['Other']\n",
      "\n",
      "The variable Utilities has mismatching unique values:\n",
      "['Electricity and Gas Only'] | []\n",
      "\n",
      "The computed AUC on the X_test used to build datadrift_classifier is equal to: 0.5405695039804042\n"
     ]
    }
   ],
   "source": [
    "SD.compile(full_validation=True, # Optional: to save time, leave the default False value. If True, analyze consistency on modalities between columns.\n",
    "           date_compile_auc = '01/01/2009', # Optional: useful when computing the drift for a time that is not now\n",
    "           datadrift_file = \"house_price_auc.csv\" # Optional: name of the csv file that contains the performance history of data drift\n",
    "          )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f58ca3b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_performance = df_performance.append({'annee': 2009, 'mois':1, 'performance': performance_2009}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "a14df209",
   "metadata": {},
   "outputs": [],
   "source": [
    "SD.add_data_modeldrift(dataset=df_performance,metric='performance') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c54b73eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Report saved to ./report_house_price_modeldrift_2009.html. To upload and share your report, create a free Datapane account by running `!datapane signup`."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "SD.generate_report(    \n",
    "    output_file='report_house_price_modeldrift_2009.html',    \n",
    "    title_story=\"Model drift\",\n",
    "    title_description=\"\"\"House price model drift 2009\"\"\", # Optional: add a subtitle to describe report\n",
    "    project_info_file=\"../../eurybia/data/project_info_house_price.yml\" # Optional: add information on report  \n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7701d3d9",
   "metadata": {},
   "source": [
    "### Compile Drift et generate report for Year 2010"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "32b79b14",
   "metadata": {},
   "outputs": [],
   "source": [
    "house_df_2010 = house_df.loc[house_df['YrSold'] == 2010]\n",
    "\n",
    "y_df_2010=house_df_2010['SalePrice'].to_frame()\n",
    "X_df_2010=house_df_2010[house_df_2010.columns.difference(['SalePrice','YrSold'])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "78d982b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.023441"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_2010_encode=encoder.transform(X_df_2010)\n",
    "y_pred_2010 = regressor.predict(df_2010_encode)\n",
    "performance_2010 = mean_squared_log_error(y_df_2010, y_pred_2010).round(6)\n",
    "performance_2010"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3edb53b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_performance = df_performance.append({'annee': 2010, 'mois':1, 'performance': performance_2010}, ignore_index=True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "13d0e1c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "SD = SmartDrift(df_current=X_df_2010,\n",
    "                df_baseline=X_df_learning,\n",
    "                deployed_model=regressor, # Optional: put in perspective result with importance on deployed model\n",
    "                encoding=encoder # Optional: if deployed_model and encoder to use this model\n",
    "               )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "1157cabb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The variable Condition1 has mismatching unique values:\n",
      "[\"Within 200' of East-West Railroad\"] | []\n",
      "\n",
      "The variable Electrical has mismatching unique values:\n",
      "[] | ['60 AMP Fuse Box and mostly knob & tube wiring (poor)']\n",
      "\n",
      "The variable ExterCond has mismatching unique values:\n",
      "['Poor'] | []\n",
      "\n",
      "The variable ExterQual has mismatching unique values:\n",
      "['Fair'] | []\n",
      "\n",
      "The variable Exterior1st has mismatching unique values:\n",
      "['Asphalt Shingles'] | ['Stone', 'Imitation Stucco']\n",
      "\n",
      "The variable Exterior2nd has mismatching unique values:\n",
      "['Asphalt Shingles', 'Brick Common'] | ['Other', 'Stone']\n",
      "\n",
      "The variable Functional has mismatching unique values:\n",
      "[] | ['Major Deductions 1']\n",
      "\n",
      "The variable GarageCond has mismatching unique values:\n",
      "[] | ['Poor', 'Good']\n",
      "\n",
      "The variable GarageQual has mismatching unique values:\n",
      "[] | ['Good', 'Excellent', 'Poor']\n",
      "\n",
      "The variable GarageType has mismatching unique values:\n",
      "[] | ['More than one type of garage']\n",
      "\n",
      "The variable Heating has mismatching unique values:\n",
      "[] | ['Gas hot water or steam heat', 'Wall furnace']\n",
      "\n",
      "The variable HouseStyle has mismatching unique values:\n",
      "[] | ['Two and one-half story: 2nd level finished', 'One and one-half story: 2nd level unfinished', 'Two and one-half story: 2nd level unfinished']\n",
      "\n",
      "The variable LotConfig has mismatching unique values:\n",
      "[] | ['Frontage on 3 sides of property']\n",
      "\n",
      "The variable LotShape has mismatching unique values:\n",
      "[] | ['Irregular']\n",
      "\n",
      "The variable MSSubClass has mismatching unique values:\n",
      "['1-Story w/Finished Attic All Ages'] | ['2-1/2 Story All Ages', '1-1/2 Story - Unfinished All Ages']\n",
      "\n",
      "The variable MSZoning has mismatching unique values:\n",
      "[] | ['Residential High Density']\n",
      "\n",
      "The variable Neighborhood has mismatching unique values:\n",
      "['Northpark Villa'] | ['Veenker']\n",
      "\n",
      "The variable RoofMatl has mismatching unique values:\n",
      "[] | ['Wood Shingles', 'Metal', 'Gravel & Tar']\n",
      "\n",
      "The variable RoofStyle has mismatching unique values:\n",
      "['Mansard', 'Shed'] | ['Flat']\n",
      "\n",
      "The variable SaleCondition has mismatching unique values:\n",
      "[] | ['Adjoining Land Purchase']\n",
      "\n",
      "The variable SaleType has mismatching unique values:\n",
      "['Contract 15% Down payment regular terms'] | ['Contract Low Down', 'Contract Low Down payment and low interest', 'Other']\n",
      "\n",
      "The variable Street has mismatching unique values:\n",
      "['Gravel'] | []\n",
      "\n",
      "The computed AUC on the X_test used to build datadrift_classifier is equal to: 0.6978632478632478\n"
     ]
    }
   ],
   "source": [
    "SD.compile(full_validation=True, # Optional: to save time, leave the default False value. If True, analyze consistency on modalities between columns.\n",
    "           date_compile_auc = '01/01/2010', # Optional: useful when computing the drift for a time that is not now\n",
    "           datadrift_file = \"house_price_auc.csv\" # Optional: name of the csv file that contains the performance history of data drift\n",
    "          )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "a2c985d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "SD.add_data_modeldrift(dataset=df_performance,metric='performance') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "5651d11a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Report saved to ./report_house_price_modeldrift_2010.html. To upload and share your report, create a free Datapane account by running `!datapane signup`."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "SD.generate_report(    \n",
    "    output_file='report_house_price_modeldrift_2010.html',    \n",
    "    title_story=\"Model drift\",\n",
    "    title_description=\"\"\"House price model drift 2010\"\"\",\n",
    "    project_info_file=\"../../eurybia/data/project_info_house_price.yml\"  \n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "c143a5a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "SD.plot.generate_modeldrift_data() # works if add_data_modeldrift used before  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bb69515",
   "metadata": {},
   "source": [
    "----"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "d08e6294e2d60f50397263035a337d71f3055486232bc02b45ce2785f62e7d8b"
  },
  "kernelspec": {
   "display_name": "dev_eurybia",
   "language": "python",
   "name": "dev_eurybia"
  },
  "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.9.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}