00_only_continuous.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f5cdfe9c-5e31-4574-89eb-d0c6b0155cd8",
   "metadata": {},
   "source": [
    "# Scikit-learn pipelines examples for only continuous variables\n",
    "* Round 1 - Round 5 of Pydata Talk\n",
    "* Toy example generated with https://guoguibing.github.io/librec/datagen.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e1eb6fb-93ba-4578-81db-cadc568c988c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pickle\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50fd7212-489b-403f-868e-c18f26e637d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"toy_example.csv\")\n",
    "data.iloc[[10,48,61], 0] = np.nan\n",
    "data.iloc[[22, 34], 1] = np.nan\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c3839b4-bf4a-4ca3-948d-533afcaf9746",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fdee3a1-f185-4a62-9ed0-b44d0ce5c882",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.scatterplot(data = data, x='tenure', y='avg_products', hue='nonpayment')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eeeb663-3655-44c7-9234-3fb24e293e3c",
   "metadata": {},
   "source": [
    "## Round 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "911378d3-4fa8-479b-8bd3-f236232319c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X = data.drop(columns='nonpayment').copy()\n",
    "y = data['nonpayment'].copy()\n",
    "\n",
    "# SET a random_state to make your pipeline reproducible!\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4edc08f-f8d2-4f55-9895-7cbe20aaa245",
   "metadata": {},
   "source": [
    "### TRAIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1d7e177-90c9-4c79-95c5-e432fcb15c18",
   "metadata": {},
   "outputs": [],
   "source": [
    "## TRAIN\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "ss = StandardScaler(with_mean=True, with_std=True)\n",
    "X_train_transform_ss = ss.fit_transform(X_train)\n",
    "\n",
    "si = SimpleImputer(strategy='mean')\n",
    "X_train_transform_ss_si = si.fit_transform(X_train_transform_ss)\n",
    "\n",
    "clf = KNeighborsClassifier(n_neighbors=1)\n",
    "\n",
    "clf.fit(X_train_transform_ss_si, y_train)\n",
    "\n",
    "print(\"Accuracy in train: \", accuracy_score(y_train, clf.predict(X_train_transform_ss_si)))\n",
    "\n",
    "\n",
    "# DISCLAIMER: model registry\n",
    "with open(os.path.join('pkl','round_1','standard_scaler.pkl'),'wb') as f:\n",
    "    pickle.dump(ss,f)\n",
    "\n",
    "with open(os.path.join('pkl','round_1','simple_imputer.pkl'),'wb') as f:\n",
    "    pickle.dump(si,f)\n",
    "\n",
    "with open(os.path.join('pkl','round_1','knn.pkl'),'wb') as f:\n",
    "    pickle.dump(clf,f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5532efdd-7611-420a-aada-afe96514fdb2",
   "metadata": {},
   "source": [
    "### PREDICT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9697f20e-6214-4c8d-be85-a1ba057e87f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# load\n",
    "with open(os.path.join('pkl','round_1','standard_scaler.pkl'), 'rb') as f:\n",
    "    ss = pickle.load(f)\n",
    "\n",
    "with open(os.path.join('pkl','round_1','simple_imputer.pkl'), 'rb') as f:\n",
    "    si = pickle.load(f)\n",
    "\n",
    "with open(os.path.join('pkl','round_1','knn.pkl'), 'rb') as f:\n",
    "    clf = pickle.load(f)\n",
    "\n",
    "X_test_transf_ss = ss.transform(X_test)\n",
    "X_test_transf_ss_si = si.transform(X_test_transf_ss)\n",
    "prediction = clf.predict(X_test_transf_ss_si)\n",
    "\n",
    "print(\"Accuracy in test: \", accuracy_score(y_test, prediction))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a06faf1-8dd6-48fe-b3de-a2ec2a692792",
   "metadata": {},
   "source": [
    "## Round 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6350b80-7c56-438a-9b94-5f9bfa471722",
   "metadata": {},
   "source": [
    "### TRAIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "656011de-3c0a-4adb-96fd-018b3ac2279b",
   "metadata": {},
   "outputs": [],
   "source": [
    "ss = StandardScaler(with_mean=True, with_std=True)\n",
    "X_train_transform_ss = ss.fit_transform(X_train)\n",
    "\n",
    "si = SimpleImputer(strategy='mean')\n",
    "X_train_transform_ss_si = si.fit_transform(X_train_transform_ss)\n",
    "\n",
    "clf_1 = KNeighborsClassifier(n_neighbors=1)\n",
    "clf_1.fit(X_train_transform_ss_si, y_train)\n",
    "\n",
    "clf_3 = KNeighborsClassifier(n_neighbors=3)\n",
    "clf_3.fit(X_train_transform_ss_si, y_train)\n",
    "\n",
    "print(\"Accuracy in train k=1: \", \n",
    "      accuracy_score(y_train, clf_1.predict(X_train_transform_ss_si)))\n",
    "print(\"Accuracy in train k=3: \", \n",
    "      accuracy_score(y_train, clf_3.predict(X_train_transform_ss_si)))\n",
    "\n",
    "\n",
    "# save: DISCLAIMER: model registry\n",
    "with open(os.path.join('pkl','round_2','standard_scaler.pkl'),'wb') as f:\n",
    "    pickle.dump(ss,f)\n",
    "\n",
    "with open(os.path.join('pkl','round_2','simple_imputer.pkl'),'wb') as f:\n",
    "    pickle.dump(si,f)\n",
    "\n",
    "with open(os.path.join('pkl','round_2','knn_1.pkl'),'wb') as f:\n",
    "    pickle.dump(clf_1,f)\n",
    "\n",
    "with open(os.path.join('pkl','round_2','knn_3.pkl'),'wb') as f:\n",
    "    pickle.dump(clf_3,f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42f9fc2d-1d99-4674-a916-48cc5c73a398",
   "metadata": {},
   "source": [
    "### PREDICT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dadc73cc-604d-437d-a1b2-4085e81482e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join('pkl','round_2','standard_scaler.pkl'), 'rb') as f:\n",
    "    ss = pickle.load(f)\n",
    "\n",
    "with open(os.path.join('pkl','round_2','simple_imputer.pkl'), 'rb') as f:\n",
    "    si = pickle.load(f)\n",
    "\n",
    "with open(os.path.join('pkl','round_2','knn_1.pkl'), 'rb') as f:\n",
    "    clf_1 = pickle.load(f)\n",
    "\n",
    "with open(os.path.join('pkl','round_2','knn_3.pkl'), 'rb') as f:\n",
    "    clf_3 = pickle.load(f)\n",
    "\n",
    "X_test_transf_ss = ss.transform(X_test)\n",
    "X_test_transf_ss_si = si.transform(X_test_transf_ss)\n",
    "\n",
    "print(\"Accuracy in test: \", accuracy_score(y_test, clf_1.predict(X_test_transf_ss_si)))\n",
    "print(\"Accuracy in test: \", accuracy_score(y_test, clf_3.predict(X_test_transf_ss_si)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5216fddc-cc7e-43e4-b35b-90320c5c2b53",
   "metadata": {},
   "source": [
    "## Round 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1a80917-ffad-457c-881a-d8fe8f6d01b5",
   "metadata": {},
   "source": [
    "### TRAIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb0e6d99-9f58-42c4-938a-cdc0a015c690",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "ss = StandardScaler(with_mean=True, with_std=True)\n",
    "X_train_transform_ss = ss.fit_transform(X_train)\n",
    "\n",
    "si = SimpleImputer(strategy='mean')\n",
    "X_train_transform_ss_si = si.fit_transform(X_train_transform_ss)\n",
    "\n",
    "clf = KNeighborsClassifier()\n",
    "\n",
    "# Puedes poner tu propia métrica\n",
    "cv = GridSearchCV(clf, \n",
    "                  param_grid = {'n_neighbors': [1, 3, 5]},\n",
    "                  scoring = 'accuracy', refit = True,\n",
    "                  cv = 3,\n",
    "                 return_train_score=True)\n",
    "\n",
    "cv.fit(X_train_transform_ss_si, y_train)\n",
    "                  \n",
    "\n",
    "cv_results = pd.DataFrame(cv.cv_results_)\n",
    "display(cv_results[['param_n_neighbors', 'mean_train_score', 'mean_test_score', 'rank_test_score']])\n",
    "\n",
    "display(cv.best_estimator_.get_params())\n",
    "\n",
    "# save: DISCLAIMER: model registry\n",
    "with open(os.path.join('pkl','round_3','standard_scaler.pkl'),'wb') as f:\n",
    "    pickle.dump(ss,f)\n",
    "\n",
    "with open(os.path.join('pkl','round_3','simple_imputer.pkl'),'wb') as f:\n",
    "    pickle.dump(si,f)\n",
    "\n",
    "# WATCH OUT!\n",
    "with open(os.path.join('pkl','round_3','knn.pkl'),'wb') as f:\n",
    "    pickle.dump(cv.best_estimator_,f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fbe8edd-3063-47ae-8f8e-6636f62f8068",
   "metadata": {},
   "source": [
    "### PREDICT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a7209e1-810b-45da-b637-2c9b408da3e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join('pkl','round_3','standard_scaler.pkl'), 'rb') as f:\n",
    "    ss = pickle.load(f)\n",
    "\n",
    "with open(os.path.join('pkl','round_3','simple_imputer.pkl'), 'rb') as f:\n",
    "    si = pickle.load(f)\n",
    "\n",
    "with open(os.path.join('pkl','round_3','knn.pkl'), 'rb') as f:\n",
    "    clf = pickle.load(f)\n",
    "\n",
    "\n",
    "X_test_transf_ss = ss.transform(X_test)\n",
    "X_test_transf_ss_si = si.transform(X_test_transf_ss)\n",
    "\n",
    "print(\"Accuracy in test: \", accuracy_score(y_test, clf.predict(X_test_transf_ss_si)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "441d3e32-14ae-44eb-870e-322e9ba9d8ce",
   "metadata": {},
   "source": [
    "## Round 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7edbbff3-581b-4654-bb66-f4ea508c6bf1",
   "metadata": {},
   "source": [
    "### TRAIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2dedd598-aac3-4cb8-85a4-805374735e90",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.feature_selection import SelectKBest, f_classif \n",
    "from sklearn import set_config\n",
    "\n",
    "set_config(display=\"diagram\")\n",
    "\n",
    "pl=Pipeline([\n",
    "    ('scaler', StandardScaler()),\n",
    "    ('imputer', SimpleImputer()),\n",
    "    ('feature_selection', SelectKBest(score_func=f_classif)),\n",
    "    ('classifier',KNeighborsClassifier())\n",
    "])\n",
    "\n",
    "my_param_grid = [\n",
    "    {\n",
    "     'imputer__strategy': ['mean', 'median'],\n",
    "     'feature_selection__k': [1,2],\n",
    "     'classifier__n_neighbors': [1, 3, 5],\n",
    "    }\n",
    "]\n",
    "\n",
    "cv = GridSearchCV(pl, \n",
    "                  param_grid = my_param_grid,\n",
    "                  scoring = 'accuracy', refit = True,\n",
    "                  cv = 3,\n",
    "                 return_train_score=True)\n",
    "\n",
    "cv.fit(X_train,y_train)\n",
    "\n",
    "cv_results = pd.DataFrame(cv.cv_results_).sort_values(by=\"rank_test_score\")\n",
    "display(cv_results[['param_imputer__strategy','param_feature_selection__k','param_classifier__n_neighbors', \n",
    "                    'mean_train_score', 'mean_test_score', 'rank_test_score']])\n",
    "print(cv.best_estimator_.get_params())\n",
    "\n",
    "# WATCH OUT!\n",
    "with open(os.path.join('pkl','round_4','pipeline.pkl'),'wb') as f:\n",
    "    pickle.dump(cv.best_estimator_,f)\n",
    "\n",
    "cv"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71e5c565-fada-4614-8c38-05d226b56150",
   "metadata": {},
   "source": [
    "### PREDICT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d69872cb-4e6c-4eeb-b8b8-c8e534f178d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join('pkl','round_4','pipeline.pkl'), 'rb') as f:\n",
    "    pipe = pickle.load(f)\n",
    "\n",
    "print(\"Accuracy in test: \", accuracy_score(y_test, pipe.predict(X_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3455892f-6e0d-4520-8262-34f19f676c89",
   "metadata": {},
   "source": [
    "## Round 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "890e8616-8940-4da4-8fc8-4cb2d57d5549",
   "metadata": {},
   "source": [
    "### TRAIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "820a92c8-1c61-4879-a1c9-17c1ab2fab59",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "pl=Pipeline([\n",
    "    ('scaler', StandardScaler()),\n",
    "    ('imputer', SimpleImputer()),\n",
    "    ('feature_selection', SelectKBest(score_func=f_classif)),\n",
    "    ('classifier',KNeighborsClassifier())\n",
    "])\n",
    "\n",
    "my_param_grid = [\n",
    "    {\n",
    "     'imputer__strategy': ['mean', 'median'],\n",
    "     'feature_selection__k': [1,2],\n",
    "     'classifier': [KNeighborsClassifier()],\n",
    "     'classifier__n_neighbors': [1, 3, 5],\n",
    "    },\n",
    "    {\n",
    "     'imputer__strategy': ['mean', 'median'],\n",
    "     'feature_selection__k': [1,2],\n",
    "     'classifier': [LogisticRegression(random_state=42)],\n",
    "     'classifier__C': [0.01, 0.1, 1.0, 10.0, 100.0]\n",
    "    }\n",
    "]\n",
    "\n",
    "cv = GridSearchCV(pl, \n",
    "                  param_grid = my_param_grid,\n",
    "                  scoring = 'accuracy', refit = True,\n",
    "                  cv = 3,\n",
    "                 return_train_score=True)\n",
    "\n",
    "cv.fit(X_train,y_train)\n",
    "\n",
    "cv_results = pd.DataFrame(cv.cv_results_).sort_values(by=\"rank_test_score\")\n",
    "display(cv_results[['param_imputer__strategy','param_feature_selection__k',\n",
    "                    'param_classifier','param_classifier__n_neighbors', 'param_classifier__C', \n",
    "                    'mean_train_score', 'mean_test_score', 'rank_test_score']])\n",
    "print(cv.best_estimator_.get_params())\n",
    "\n",
    "# WATCH OUT!\n",
    "with open(os.path.join('pkl','round_5','pipeline.pkl'),'wb') as f:\n",
    "    pickle.dump(cv.best_estimator_,f)\n",
    "\n",
    "cv"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93d94ebb-79f3-46ba-b57f-2411e3342d28",
   "metadata": {},
   "source": [
    "### PREDICT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1bd83508-05c0-44bf-b0ea-3b425726c561",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join('pkl','round_5','pipeline.pkl'), 'rb') as f:\n",
    "    pipe = pickle.load(f)\n",
    "\n",
    "print(\"Accuracy in test: \", accuracy_score(y_test, pipe.predict(X_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62ffd6f0-70b4-4fe7-baf7-8e3a813d3c4b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}