NOTES 05.03 - MODEL SELECTION.ipynb

{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# 05.03 - MODEL SELECTION"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["!wget --no-cache -O init.py -q https://raw.githubusercontent.com/rramosp/20201.xai4eng/master/content/init.py\n", "import init; init.init(force_download=False); init.get_weblink()"]}, {"cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": ["import numpy as np\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "import local.lib.timeseries as ts\n", "%matplotlib inline"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## <font color=\"red\"> RULE: we cannot use the same data to BOTH make choices on our precessing pipeline AND report performance</font>"]}, {"cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["(1000, 5) (1000,)\n"]}], "source": ["dataset = pd.read_csv(\"local/data/cal_housing.data\")\n", "dataset = dataset.sample(len(dataset))\n", "\n", "d = dataset.iloc[:10000].sample(1000)\n", "X = d.values[:,:-1]\n", "y = d[\"medianHouseValue\"].values\n", "print (X.shape, y.shape)"]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": ["from sklearn.linear_model import LinearRegression\n", "from sklearn.svm import SVR\n", "from sklearn.ensemble import RandomForestRegressor\n", "from sklearn.tree import DecisionTreeRegressor\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import median_absolute_error, r2_score, mean_squared_error"]}, {"cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": ["def rel_mrae(estimator, X, y):\n", "    preds = estimator.predict(X)\n", "    return np.mean(np.abs(preds-y)/y)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Let's consider we are choosing between different models with any crossval technique\n", "\n", "We start by using a regular train/test split with resampling"]}, {"cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": ["from sklearn.model_selection import cross_validate, ShuffleSplit"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### MODEL 1"]}, {"cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": ["estimator1 = DecisionTreeRegressor(max_depth=5)\n", "z1 = cross_validate(estimator1, X, y, return_train_score=True, return_estimator=True,\n", "                    scoring=rel_mrae, cv=ShuffleSplit(n_splits=10, test_size=0.1))"]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"data": {"text/plain": ["{'fit_time': array([0.0026865 , 0.00383544, 0.0037663 , 0.00304556, 0.00305915,\n", "        0.00277185, 0.00263572, 0.00275302, 0.00315762, 0.00289965]),\n", " 'score_time': array([0.00101566, 0.00098491, 0.00112557, 0.00090575, 0.00094485,\n", "        0.00083876, 0.00069666, 0.00081682, 0.00074935, 0.00079894]),\n", " 'estimator': (DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=5,\n", "                        max_features=None, max_leaf_nodes=None,\n", "                        min_impurity_decrease=0.0, min_impurity_split=None,\n", "                        min_samples_leaf=1, min_samples_split=2,\n", "                        min_weight_fraction_leaf=0.0, presort='deprecated',\n", "                        random_state=None, splitter='best'),\n", "  DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=5,\n", "                        max_features=None, max_leaf_nodes=None,\n", "                        min_impurity_decrease=0.0, min_impurity_split=None,\n", "                        min_samples_leaf=1, min_samples_split=2,\n", "                        min_weight_fraction_leaf=0.0, presort='deprecated',\n", "                        random_state=None, splitter='best'),\n", "  DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=5,\n", "                        max_features=None, max_leaf_nodes=None,\n", "                        min_impurity_decrease=0.0, min_impurity_split=None,\n", "                        min_samples_leaf=1, min_samples_split=2,\n", "                        min_weight_fraction_leaf=0.0, presort='deprecated',\n", "                        random_state=None, splitter='best'),\n", "  DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=5,\n", "                        max_features=None, max_leaf_nodes=None,\n", "                        min_impurity_decrease=0.0, min_impurity_split=None,\n", "                        min_samples_leaf=1, min_samples_split=2,\n", "                        min_weight_fraction_leaf=0.0, presort='deprecated',\n", "                        random_state=None, splitter='best'),\n", "  DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=5,\n", "                        max_features=None, max_leaf_nodes=None,\n", "                        min_impurity_decrease=0.0, min_impurity_split=None,\n", "                        min_samples_leaf=1, min_samples_split=2,\n", "                        min_weight_fraction_leaf=0.0, presort='deprecated',\n", "                        random_state=None, splitter='best'),\n", "  DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=5,\n", "                        max_features=None, max_leaf_nodes=None,\n", "                        min_impurity_decrease=0.0, min_impurity_split=None,\n", "                        min_samples_leaf=1, min_samples_split=2,\n", "                        min_weight_fraction_leaf=0.0, presort='deprecated',\n", "                        random_state=None, splitter='best'),\n", "  DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=5,\n", "                        max_features=None, max_leaf_nodes=None,\n", "                        min_impurity_decrease=0.0, min_impurity_split=None,\n", "                        min_samples_leaf=1, min_samples_split=2,\n", "                        min_weight_fraction_leaf=0.0, presort='deprecated',\n", "                        random_state=None, splitter='best'),\n", "  DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=5,\n", "                        max_features=None, max_leaf_nodes=None,\n", "                        min_impurity_decrease=0.0, min_impurity_split=None,\n", "                        min_samples_leaf=1, min_samples_split=2,\n", "                        min_weight_fraction_leaf=0.0, presort='deprecated',\n", "                        random_state=None, splitter='best'),\n", "  DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=5,\n", "                        max_features=None, max_leaf_nodes=None,\n", "                        min_impurity_decrease=0.0, min_impurity_split=None,\n", "                        min_samples_leaf=1, min_samples_split=2,\n", "                        min_weight_fraction_leaf=0.0, presort='deprecated',\n", "                        random_state=None, splitter='best'),\n", "  DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=5,\n", "                        max_features=None, max_leaf_nodes=None,\n", "                        min_impurity_decrease=0.0, min_impurity_split=None,\n", "                        min_samples_leaf=1, min_samples_split=2,\n", "                        min_weight_fraction_leaf=0.0, presort='deprecated',\n", "                        random_state=None, splitter='best')),\n", " 'test_score': array([0.37247763, 0.40161065, 0.42150456, 0.47736097, 0.42858179,\n", "        0.36527219, 0.38721038, 0.34214222, 0.31086012, 0.33274428]),\n", " 'train_score': array([0.34318495, 0.32977355, 0.32523023, 0.33635713, 0.32606125,\n", "        0.32962278, 0.34875038, 0.34060793, 0.3374607 , 0.34459654])}"]}, "execution_count": 9, "metadata": {}, "output_type": "execute_result"}], "source": ["z1"]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["test score   0.384 (\u00b10.0476) with 10 splits\n", "train score  0.336 (\u00b10.0078) with 10 splits\n"]}], "source": ["def report_cv_score(z):\n", "    print (\"test score   %.3f (\u00b1%.4f) with %d splits\"%(np.mean(z[\"test_score\"]), np.std(z[\"test_score\"]), len(z[\"test_score\"])))\n", "    print (\"train score  %.3f (\u00b1%.4f) with %d splits\"%(np.mean(z[\"train_score\"]), np.std(z[\"train_score\"]), len(z[\"train_score\"])))\n", "    \n", "report_cv_score(z1)    "]}, {"cell_type": "markdown", "metadata": {}, "source": ["### MODEL 2"]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["test score   0.367 (\u00b10.0383) with 10 splits\n", "train score  0.111 (\u00b10.0113) with 10 splits\n"]}], "source": ["from sklearn.ensemble import RandomForestRegressor\n", "estimator2 = DecisionTreeRegressor(max_depth=10)\n", "z2 = cross_validate(estimator2, X, y, return_train_score=True, return_estimator=True,\n", "                    scoring=rel_mrae, cv=ShuffleSplit(n_splits=10, test_size=0.1))  \n", "report_cv_score(z2)    "]}, {"cell_type": "markdown", "metadata": {}, "source": ["### MODEL 3"]}, {"cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["test score   0.455 (\u00b10.0233) with 10 splits\n", "train score  0.431 (\u00b10.0060) with 10 splits\n"]}], "source": ["from sklearn.linear_model import LinearRegression\n", "estimator3 = LinearRegression()\n", "z3 = cross_validate(estimator3, X, y, return_train_score=True, return_estimator=True,\n", "                    scoring=rel_mrae, cv=ShuffleSplit(n_splits=10, test_size=0.1))\n", "report_cv_score(z3)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## Some questions:\n", "\n", "- **what would be our model of choice**: probably estimator2. **CORRECT**\n", "- **what is the performance associated with our choice**: the test score reported by estimator2. **INCORRECT**\n", "- we need to **physically** deliver our trained model to the appropriate business area, but we trained several models for statistical stability. **Which model shall we hand over?**\n", "\n", "\n", "we **cannot** use the same data to make a choice AND report a result.\n", "\n", "observe the performance measured with the models we trained before on **new production** data"]}, {"cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["(1000, 5) (1000,)\n"]}], "source": ["ed = dataset[10000:].sample(1000)\n", "eX = ed.values[:,:-1]\n", "ey = ed[\"medianHouseValue\"].values\n", "print (eX.shape, ey.shape)"]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["scores [0.34704496772017795, 0.35181627445650004, 0.3780380631512966, 0.3473043719704006, 0.3303955214044563, 0.4078152917670846, 0.3454037329742688, 0.34298337274978824, 0.3505249600341739, 0.3482397402889321]\n", "mean score 0.355 (\u00b10.0209) with 10 splits\n"]}], "source": ["scores = [rel_mrae(estimator, eX, ey) for estimator in z2[\"estimator\"]]\n", "print (\"scores\", scores)\n", "print (\"mean score %.3f (\u00b1%.4f) with %d splits\"%(np.mean(scores), np.std(scores), len(scores)))\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": []}, {"cell_type": "markdown", "metadata": {}, "source": ["### use train/val/test splits\n", "\n", "- use train/val to train and select model\n", "- use test split ONLY to measure performance of the selected model\n", "\n", "literature and resources use `test`/`val` interchangeably, or sometimes `dev` instead of `val`\n", "\n", "observe how we:\n", "\n", "- do a first split with 10% for test and 90% for train/val\n", "- adjust val size so that when selecting x% of 90% train/val, ends up having the same number of elements as in test"]}, {"cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["(1000, 5) (1000,)\n", "test size 0.30\n", "val size is 0.43 (relative to 0.70) \n", "(700, 5) (300, 5)\n"]}], "source": ["from sklearn.model_selection import train_test_split\n", "\n", "test_size = 0.3\n", "number_of_houses_for_trainval = 1000\n", "\n", "val_size  = test_size/(1-test_size) # so that the have the same number of elements\n", "\n", "assert number_of_houses_for_trainval<10000, \"too many houses for trainval\"\n", "\n", "\n", "d = dataset.iloc[:10000].sample(number_of_houses_for_trainval)\n", "X = d.values[:,:-1]\n", "y = d[\"medianHouseValue\"].values\n", "print (X.shape, y.shape)\n", "\n", "print (\"test size %.2f\"%test_size)\n", "print (\"val size is %.2f (relative to %.2f) \"%(val_size, 1-test_size))\n", "\n", "Xtv, Xts, ytv, yts = train_test_split(X, y, test_size=test_size)\n", "print (Xtv.shape, Xts.shape)"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": []}, {"cell_type": "markdown", "metadata": {}, "source": ["**PART 1**: we **AUTOMATE** the model selection process"]}, {"cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["--\n", "test score   0.473 (\u00b10.0475) with 10 splits\n", "train score  0.347 (\u00b10.0423) with 10 splits\n", "--\n", "test score   0.416 (\u00b10.0335) with 10 splits\n", "train score  0.092 (\u00b10.0213) with 10 splits\n", "--\n", "test score   0.486 (\u00b10.0305) with 10 splits\n", "train score  0.483 (\u00b10.0167) with 10 splits\n", "selecting  1\n", "\n", "selected model\n", "DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=10,\n", "                      max_features=None, max_leaf_nodes=None,\n", "                      min_impurity_decrease=0.0, min_impurity_split=None,\n", "                      min_samples_leaf=1, min_samples_split=2,\n", "                      min_weight_fraction_leaf=0.0, presort='deprecated',\n", "                      random_state=None, splitter='best')\n"]}], "source": ["zscores = []\n", "estimators = [estimator1, estimator2, estimator3]\n", "for estimator in estimators:\n", "    print(\"--\")\n", "    z = cross_validate(estimator, Xtv, ytv, return_train_score=True, return_estimator=False,\n", "                       scoring=rel_mrae, cv=ShuffleSplit(n_splits=10, test_size=val_size))\n", "    report_cv_score(z)\n", "    zscores.append(np.mean(z[\"test_score\"]))\n", "best = np.argmin(zscores)\n", "print (\"selecting \", best)\n", "best_estimator = estimators[best]\n", "print (\"\\nselected model\")\n", "print (best_estimator)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["**PART 2**: train selected estimator on train/val, report performance on est"]}, {"cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["reported performance of selectd model 0.395\n"]}], "source": ["best_estimator.fit(Xtv,ytv)\n", "reported_performance = rel_mrae(best_estimator, Xts, yts)\n", "print (\"reported performance of selectd model %.3f\"%reported_performance)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## monitor production\n", "\n", "observe that even when showing **NEW** data to our selected model, performance still varies.\n", "\n", "as we have more data kept in this dataset we **SIMULATE** we get new data batches from production.\n", "\n", "in **SMALL DATA** performance biases are **DIFFICULT** to overcome in practice and must be monitored!!!\n", "\n", "how much data is __small data__ depends on your problem.\n", "\n"]}, {"cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [], "source": ["er = []\n", "sizes = []\n", "for _ in range(100):\n", "    size = len(Xts)+np.random.randint(len(Xts))-len(Xts)//2\n", "    ed = dataset.iloc[10000:].sample(size)\n", "    eX = ed.values[:,:-1]\n", "    ey = ed[\"medianHouseValue\"].values\n", "    er.append(rel_mrae(best_estimator, eX, ey))\n", "    sizes.append(size)"]}, {"cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [{"data": {"image/png": "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\n", "text/plain": ["<Figure size 432x288 with 1 Axes>"]}, "metadata": {"needs_background": "light"}, "output_type": "display_data"}], "source": ["plt.scatter(sizes, er)\n", "plt.xlabel(\"production dataset size\")\n", "plt.ylabel(\"rel mrae\")\n", "plt.title(\"performance of observed data batches in production\")\n", "plt.axhline(reported_performance, color=\"red\", ls=\"--\", label=\"reported performance\")\n", "plt.axhline(zscores[best], color=\"green\", ls=\"--\", label=\"val performance of selected model\")\n", "plt.axhline(np.mean(er), color=\"black\", ls=\"--\", label=\"mean performance of production data batches\")\n", "plt.axvline(len(Xts), color=\"black\", alpha=.5, ls=\":\", label=\"test size when reporting performance\")\n", "plt.grid(); plt.legend(loc='center left', bbox_to_anchor=(1, 0.5));\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["## suggested experiment\n", "\n", "### change `test_size`  and `number_of_houses_for_trainval` when using train/val/test splits above\n", "\n", "larger values might yield better stability of results\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": []}], "metadata": {"kernelspec": {"display_name": "p38", "language": "python", "name": "p38"}, "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.3"}}, "nbformat": 4, "nbformat_minor": 2}