index.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple Pipeline Example\n",
    "\n",
    "### The Dataset\n",
    "\n",
    "Info provided when I [downloaded it](https://college.cengage.com/mathematics/brase/understandable_statistics/7e/students/datasets/mlr/frames/frame.html) was:\n",
    "\n",
    "Thunder Basin Antelope Study\n",
    "\n",
    "The data (X1, X2, X3, X4) are for each year.\n",
    "\n",
    " - X1 = spring fawn count/100\n",
    " - X2 = size of adult antelope population/100\n",
    " - X3 = annual precipitation (inches)\n",
    " - X4 = winter severity index (1=mild, 5=severe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from sklearn.base import BaseEstimator\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "from sklearn.linear_model import LinearRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "antelope_df = pd.read_csv(\"antelope.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>spring_fawn_count</th>\n",
       "      <th>adult_antelope_population</th>\n",
       "      <th>annual_precipitation</th>\n",
       "      <th>winter_severity_index</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2.9</td>\n",
       "      <td>9.2</td>\n",
       "      <td>13.2</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.4</td>\n",
       "      <td>8.7</td>\n",
       "      <td>11.5</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.0</td>\n",
       "      <td>7.2</td>\n",
       "      <td>10.8</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.3</td>\n",
       "      <td>8.5</td>\n",
       "      <td>12.3</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3.2</td>\n",
       "      <td>9.6</td>\n",
       "      <td>12.6</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1.9</td>\n",
       "      <td>6.8</td>\n",
       "      <td>10.6</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>3.4</td>\n",
       "      <td>9.7</td>\n",
       "      <td>14.1</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>2.1</td>\n",
       "      <td>7.9</td>\n",
       "      <td>11.2</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   spring_fawn_count  adult_antelope_population  annual_precipitation  \\\n",
       "0                2.9                        9.2                  13.2   \n",
       "1                2.4                        8.7                  11.5   \n",
       "2                2.0                        7.2                  10.8   \n",
       "3                2.3                        8.5                  12.3   \n",
       "4                3.2                        9.6                  12.6   \n",
       "5                1.9                        6.8                  10.6   \n",
       "6                3.4                        9.7                  14.1   \n",
       "7                2.1                        7.9                  11.2   \n",
       "\n",
       "   winter_severity_index  \n",
       "0                    2.0  \n",
       "1                    3.0  \n",
       "2                    4.0  \n",
       "3                    2.0  \n",
       "4                    3.0  \n",
       "5                    5.0  \n",
       "6                    1.0  \n",
       "7                    3.0  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "antelope_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = antelope_df.drop(\"spring_fawn_count\", axis=1)\n",
    "y = antelope_df[\"spring_fawn_count\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code without a Pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the sake of example, let's say we want to replace the `annual_precipitation` column with a binary column `low_precipitation`, which indicates whether the annual precipitation was below 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PrecipitationTransformer(BaseEstimator):\n",
    "    \"\"\"Replaces the annual_precipitation column with a binary low_precipitation column\n",
    "    \n",
    "    Note: this class will be used inside a scikit-learn Pipeline\n",
    "    \n",
    "    Attributes:\n",
    "        verbose: if True, prints out when fitting or transforming is happening\n",
    "        \n",
    "    Methods:\n",
    "        _is_low(): returns 1 if record has precipitation below 12; 0 if else\n",
    "        \n",
    "        fit(): fit all the transformers one after the other \n",
    "               then fit the transformed data using the final estimator\n",
    "               \n",
    "        transform(): apply transformers, and transform with the final estimator\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, verbose=False):\n",
    "        self.verbose = verbose\n",
    "    \n",
    "    def fit(self, X, y=None):\n",
    "        if self.verbose:\n",
    "            print(\"fitting (PrecipitationTransformer)\")\n",
    "        return self\n",
    "    \n",
    "    \n",
    "    def _is_low(self, annual_precipitation):\n",
    "        \"\"\"Flag if precipitation is less than 12\"\"\"\n",
    "        if annual_precipitation < 12:\n",
    "            return 1\n",
    "        else:\n",
    "            return 0\n",
    "    \n",
    "    \n",
    "    def transform(self, X, y=None):\n",
    "        \"\"\"Copies X and modifies it before returning X_new\"\"\"\n",
    "        if self.verbose:\n",
    "            print(\"transforming (PrecipitationTransformer)\")\n",
    "        X_new = X.copy()\n",
    "        X_new[\"low_precipitation\"] = X_new[\"annual_precipitation\"].apply(self._is_low)\n",
    "        \n",
    "        return X_new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could use this custom transformer by itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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>adult_antelope_population</th>\n",
       "      <th>annual_precipitation</th>\n",
       "      <th>winter_severity_index</th>\n",
       "      <th>low_precipitation</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>7.9</td>\n",
       "      <td>11.2</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>7.2</td>\n",
       "      <td>10.8</td>\n",
       "      <td>4.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>9.6</td>\n",
       "      <td>12.6</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>8.5</td>\n",
       "      <td>12.3</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>9.7</td>\n",
       "      <td>14.1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   adult_antelope_population  annual_precipitation  winter_severity_index  \\\n",
       "7                        7.9                  11.2                    3.0   \n",
       "2                        7.2                  10.8                    4.0   \n",
       "4                        9.6                  12.6                    3.0   \n",
       "3                        8.5                  12.3                    2.0   \n",
       "6                        9.7                  14.1                    1.0   \n",
       "\n",
       "   low_precipitation  \n",
       "7                  1  \n",
       "2                  1  \n",
       "4                  0  \n",
       "3                  0  \n",
       "6                  0  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precip_transformer = PrecipitationTransformer()\n",
    "precip_transformer.fit(X_train)\n",
    "X_train_precip_transformed = precip_transformer.transform(X_train)\n",
    "X_train_precip_transformed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also could use a OneHotEncoder without a pipeline:\n",
    "\n",
    "(`winter_severity_index` appears numeric but the data dictionary indicates that it's categorical)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>adult_antelope_population</th>\n",
       "      <th>annual_precipitation</th>\n",
       "      <th>low_precipitation</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.9</td>\n",
       "      <td>11.2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>7.2</td>\n",
       "      <td>10.8</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>9.6</td>\n",
       "      <td>12.6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>8.5</td>\n",
       "      <td>12.3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>9.7</td>\n",
       "      <td>14.1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1    2    3  adult_antelope_population  annual_precipitation  \\\n",
       "7  0.0  0.0  1.0  0.0                        7.9                  11.2   \n",
       "2  0.0  0.0  0.0  1.0                        7.2                  10.8   \n",
       "4  0.0  0.0  1.0  0.0                        9.6                  12.6   \n",
       "3  0.0  1.0  0.0  0.0                        8.5                  12.3   \n",
       "6  1.0  0.0  0.0  0.0                        9.7                  14.1   \n",
       "\n",
       "   low_precipitation  \n",
       "7                  1  \n",
       "2                  1  \n",
       "4                  0  \n",
       "3                  0  \n",
       "6                  0  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ohe = OneHotEncoder(sparse=False, handle_unknown=\"ignore\")\n",
    "ohe.fit(X_train_precip_transformed[[\"winter_severity_index\"]])\n",
    "winter_severity_encoded = pd.DataFrame(ohe.transform(X_train_precip_transformed[[\"winter_severity_index\"]]), index=X_train_precip_transformed.index)\n",
    "X_train_winter_transformed = pd.concat([winter_severity_encoded, X_train_precip_transformed], axis=1)\n",
    "X_train_winter_transformed.drop(\"winter_severity_index\", axis=1, inplace=True)\n",
    "X_train_winter_transformed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we could fit a model on the training set and evaluate it on the test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4748448011930302"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# instantiate model\n",
    "model = LinearRegression()\n",
    "\n",
    "# fit on training data\n",
    "model.fit(X_train_winter_transformed, y_train)\n",
    "\n",
    "# transform test data\n",
    "X_test_precip_transformed = precip_transformer.transform(X_test)\n",
    "test_winter_severity_encoded = pd.DataFrame(\n",
    "    ohe.transform(X_test_precip_transformed[[\"winter_severity_index\"]]), index=X_test_precip_transformed.index)\n",
    "X_test_winter_transformed = pd.concat([test_winter_severity_encoded, X_test_precip_transformed], axis=1)\n",
    "X_test_winter_transformed.drop(\"winter_severity_index\", axis=1, inplace=True)\n",
    "\n",
    "# evaluate on test data\n",
    "model.score(X_test_winter_transformed, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not a very good score!  But this is basically fake data anyway\n",
    "\n",
    "Let's show that same logic with a pipeline instead\n",
    "\n",
    "## Code with a Pipeline\n",
    "\n",
    "Let's add the steps one at a time\n",
    "\n",
    "First, just the custom transformer.  Let's use `verbose=True` so we can see when it is fitting and transforming:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipe1 = Pipeline(steps=[\n",
    "    (\"transform_precip\", PrecipitationTransformer(verbose=True))\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fitting (PrecipitationTransformer)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "         steps=[('transform_precip', PrecipitationTransformer(verbose=True))],\n",
       "         verbose=False)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe1.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transforming (PrecipitationTransformer)\n"
     ]
    },
    {
     "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>adult_antelope_population</th>\n",
       "      <th>annual_precipitation</th>\n",
       "      <th>winter_severity_index</th>\n",
       "      <th>low_precipitation</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>7.9</td>\n",
       "      <td>11.2</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>7.2</td>\n",
       "      <td>10.8</td>\n",
       "      <td>4.0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>9.6</td>\n",
       "      <td>12.6</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>8.5</td>\n",
       "      <td>12.3</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>9.7</td>\n",
       "      <td>14.1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   adult_antelope_population  annual_precipitation  winter_severity_index  \\\n",
       "7                        7.9                  11.2                    3.0   \n",
       "2                        7.2                  10.8                    4.0   \n",
       "4                        9.6                  12.6                    3.0   \n",
       "3                        8.5                  12.3                    2.0   \n",
       "6                        9.7                  14.1                    1.0   \n",
       "\n",
       "   low_precipitation  \n",
       "7                  1  \n",
       "2                  1  \n",
       "4                  0  \n",
       "3                  0  \n",
       "6                  0  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe1.transform(X_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now add the `OneHotEncoder`.  We have to wrap it inside a `ColumnTransformer` because it only applies to certain columns (we don't want to one-hot encode the entire dataframe)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipe2 = Pipeline(steps=[\n",
    "    (\"transform_precip\", PrecipitationTransformer(verbose=True)),\n",
    "    (\"encode_winter\", ColumnTransformer(transformers=[\n",
    "        (\"ohe\", OneHotEncoder(sparse=False, handle_unknown=\"ignore\"), [\"winter_severity_index\"])], remainder=\"passthrough\"))\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fitting (PrecipitationTransformer)\n",
      "transforming (PrecipitationTransformer)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "         steps=[('transform_precip', PrecipitationTransformer(verbose=True)),\n",
       "                ('encode_winter',\n",
       "                 ColumnTransformer(n_jobs=None, remainder='passthrough',\n",
       "                                   sparse_threshold=0.3,\n",
       "                                   transformer_weights=None,\n",
       "                                   transformers=[('ohe',\n",
       "                                                  OneHotEncoder(categories='auto',\n",
       "                                                                drop=None,\n",
       "                                                                dtype=<class 'numpy.float64'>,\n",
       "                                                                handle_unknown='ignore',\n",
       "                                                                sparse=False),\n",
       "                                                  ['winter_severity_index'])],\n",
       "                                   verbose=False))],\n",
       "         verbose=False)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe2.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that it actually calls `transform` on the `PrecipitationTransformer` this time, in case the next step (OHE) is dependent on that, even though it didn't call `transform` on the OHE yet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transforming (PrecipitationTransformer)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0.        ,  0.        ,  1.        ,  0.        ,  7.9000001 ,\n",
       "        11.19999981,  1.        ],\n",
       "       [ 0.        ,  0.        ,  0.        ,  1.        ,  7.19999981,\n",
       "        10.80000019,  1.        ],\n",
       "       [ 0.        ,  0.        ,  1.        ,  0.        ,  9.6       ,\n",
       "        12.60000038,  0.        ],\n",
       "       [ 0.        ,  1.        ,  0.        ,  0.        ,  8.5       ,\n",
       "        12.30000019,  0.        ],\n",
       "       [ 1.        ,  0.        ,  0.        ,  0.        ,  9.69999981,\n",
       "        14.10000038,  0.        ]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe2.transform(X_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have lost the column labels at this point, and it decided to put things a different order, but these are the same 7 columns we had at this point without the pipeline\n",
    "\n",
    "We could stop right here and use the pipeline for preprocessing, but leave the model out of the pipeline:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transforming (PrecipitationTransformer)\n",
      "transforming (PrecipitationTransformer)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.4748448011930302"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = LinearRegression()\n",
    "model.fit(pipe2.transform(X_train), y_train)\n",
    "model.score(pipe2.transform(X_test), y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or we could go one step further and add the model to the pipeline:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipe3 = Pipeline(steps=[\n",
    "    (\"transform_precip\", PrecipitationTransformer(verbose=True)),\n",
    "    (\"encode_winter\", ColumnTransformer(transformers=[\n",
    "        (\"ohe\", OneHotEncoder(sparse=False, handle_unknown=\"ignore\"), [\"winter_severity_index\"])], remainder=\"passthrough\")),\n",
    "    (\"linreg_model\", LinearRegression())\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fitting (PrecipitationTransformer)\n",
      "transforming (PrecipitationTransformer)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Pipeline(memory=None,\n",
       "         steps=[('transform_precip', PrecipitationTransformer(verbose=True)),\n",
       "                ('encode_winter',\n",
       "                 ColumnTransformer(n_jobs=None, remainder='passthrough',\n",
       "                                   sparse_threshold=0.3,\n",
       "                                   transformer_weights=None,\n",
       "                                   transformers=[('ohe',\n",
       "                                                  OneHotEncoder(categories='auto',\n",
       "                                                                drop=None,\n",
       "                                                                dtype=<class 'numpy.float64'>,\n",
       "                                                                handle_unknown='ignore',\n",
       "                                                                sparse=False),\n",
       "                                                  ['winter_severity_index'])],\n",
       "                                   verbose=False)),\n",
       "                ('linreg_model',\n",
       "                 LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None,\n",
       "                                  normalize=False))],\n",
       "         verbose=False)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe3.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transforming (PrecipitationTransformer)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.4748448011930302"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe3.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (prework-labs)",
   "language": "python",
   "name": "prework-labs"
  },
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}