s09_t02_Regression_Models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "857001a9",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "# IT Academy - Data Science Itinerary\n",
    "\n",
    "\n",
    "\n",
    "$~$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad6e86cc",
   "metadata": {},
   "source": [
    "## S9 T2: Regression Models\n",
    "___\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "343f71ef",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:29:56.935181Z",
     "start_time": "2022-04-18T19:29:56.128291Z"
    }
   },
   "outputs": [],
   "source": [
    "#importing libraries\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import seaborn as sns\n",
    "from sklearn.model_selection import train_test_split, cross_val_score\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder, PowerTransformer,MinMaxScaler\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.linear_model import LinearRegression, Ridge, Lasso\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.linear_model import Lasso\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "sns.set_context(\"talk\")\n",
    "plt.style.use('ggplot')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7557656a",
   "metadata": {},
   "source": [
    "$~$\n",
    "___\n",
    "#### preprocesing the data:\n",
    "\n",
    "$~$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8629c2e",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "+ As we do [before](https://github.com/Pevicsanch/train_test_sklearn) we are going to download the [dataset](https://www.kaggle.com/datasets/giovamata/airlinedelaycauses) from Kaggle and pre processing it.\n",
    "\n",
    "$~$\n",
    "\n",
    "+ let's remember, this dataset is composd by the following variables:\n",
    "\n",
    "\n",
    "   1. **Year** = 2008\n",
    "   2. **Month** = 1-12\n",
    "   3. **DayofMonth** = 1-31\n",
    "   4.\t**DayOfWeek** = 1 (Monday) - 7 (Sunday)\n",
    "   5.\t**DepTime** = actual departure time (local, hhmm)\n",
    "   6.\t**CRSDepTime** = scheduled departure time (local, hhmm)\n",
    "   7.\t**ArrTime** = actual arrival time (local, hhmm)\n",
    "   8.\t**CRSArrTime** = scheduled arrival time (local, hhmm)\n",
    "   9.\t**UniqueCarrier** = unique carrier code\n",
    "   10.\t**FlightNum** = flight number\n",
    "   11.\t**TailNum** = plane tail number: aircraft registration, unique aircraft identifier\n",
    "   12.\t**ActualElapsedTime** = in minutes\n",
    "   13.\t**CRSElapsedTime** = in minutes\n",
    "   14.\t**AirTime** = in minutes\n",
    "   15.\t**ArrDelay** = arrival delay, in minutes: A flight is counted as \"on time\" if it operated less than 15 minutes later the scheduled time shown in the carriers' Computerized Reservations Systems (CRS).\n",
    "   16.\t**DepDelay** = departure delay, in minutes\n",
    "   17.\t**Origin** = origin IATA airport code\n",
    "   18.\t**Dest** = destination IATA airport code\n",
    "   19.\t**Distance** = in miles\n",
    "   20.\t**TaxiIn** = taxi in time, in minutes\n",
    "   21.\t**TaxiOut** = taxi out time in minutes\n",
    "   22.\t**Cancelled** = *was the flight cancelled\n",
    "   23.\t**CancellationCode** = reason for cancellation (A = carrier, B = weather, C = NAS, D = security)\n",
    "   24.\t**Diverted** = 1 = yes, 0 = no\n",
    "   25.\t**CarrierDelay** = in minutes: Carrier delay is within the control of the air carrier. Examples of occurrences that may determine carrier delay are: aircraft cleaning, aircraft damage, awaiting the arrival of connecting passengers or crew, baggage, bird strike, cargo loading, catering, computer, outage-carrier equipment, crew legality (pilot or attendant rest), damage by hazardous goods, engineering inspection, fueling, handling disabled passengers, late crew, lavatory servicing, maintenance, oversales, potable water servicing, removal of unruly passenger, slow boarding or seating, stowing carry-on baggage, weight and balance delays.\n",
    "   26.\t**WeatherDelay** = in minutes: Weather delay is caused by extreme or hazardous weather conditions that are forecasted or manifest themselves on point of departure, enroute, or on point of arrival.\n",
    "   27.\t**NASDelay**  = in minutes: Delay that is within the control of the National Airspace System (NAS) may include: non-extreme weather conditions, airport operations, heavy traffic volume, air traffic control, etc.\n",
    "   28.\t**SecurityDelay** = in minutes: Security delay is caused by evacuation of a terminal or concourse, re-boarding of aircraft because of security breach, inoperative screening equipment and/or long lines in excess of 29 minutes at screening areas.\n",
    "   29.\t**LateAircraftDelay** = in minutes: Arrival delay at an airport due to the late arrival of the same aircraft at a previous airport. The ripple effect of an earlier delay at downstream airports is referred to as delay propagation.\n",
    "\n",
    "   $~$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "339133dd",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:29:59.237200Z",
     "start_time": "2022-04-18T19:29:56.936029Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./data/st99_d00.shp\n",
      "./data/st99_d00.shx\n",
      "./data/st99_d00.dbf\n",
      "./data/DelayedFlights.csv\n"
     ]
    }
   ],
   "source": [
    "PATH = \"./data\"\n",
    "#downloanding the data set:\n",
    "if not os.path.exists(PATH):\n",
    "    os.makedirs(PATH)\n",
    "if not os.listdir(PATH):\n",
    "    !kaggle datasets download -d \"giovamata/airlinedelaycauses\" --unzip  -p $PATH  \n",
    "\n",
    "# check the files:\n",
    "files = [os.path.join(PATH, f) for f in os.listdir(PATH)]\n",
    "for f in files:\n",
    "    print(f)\n",
    "\n",
    "# load the dataset into a pandas dataframe:\n",
    "df = pd.read_csv(files[3], index_col=[0])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13ba5f27",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "+ About the pre-processing process:\n",
    "\n",
    "    +  Since our target variable will be **\"ArrDelay\"** (*for this exercise we specifically propose to know which flights arrived delayed ( or not) and analyze what variables influence it*), the first thing to keep in mind is that if a flight has been canceled it is impossible for it to reach its destination, so we will not consider those flights for our analysis on delay.\n",
    "\n",
    "    +  Morever when **\"Arrival Delay\"** is longer than 15 minutes there's data about what caused the delay. Arrival Delay is the sum of CarrierDelay, WeatherDelay, NASDelay and LateAircraftDelay.\n",
    "\n",
    "    +  As our target variable is \"ArrDelay\" it also makes no sense to leave the variable \"Security Delay\" as it only has values when there is a delay. So, we are able to drop this variable too\n",
    "    \n",
    "    + Notice that our target variable (ArrDelay) has negative values . For this exercise, we will consider these values (values equal to or less than zero) as an indicate for those flights arrived on time.\n",
    "\n",
    "    + \"Year\", which only has a value of \"2018\", does not make sense to keep within our set of independent variables.\n",
    "\n",
    "    +  we are going to change type from \"int64\" and \"object\" to \"categorical\": \n",
    "\n",
    "        + Month, DayofMonth, DayOfWeek, Diverted, and FlightNum: these variables are really categorical, and in the case of month and days, they are ordinal. And for \"flight number\", although it is a number, it is really a label that is repeated\n",
    "        \n",
    "       + Same for Origin,Dest,TailNum, UniqueCarrier,Diverted are categorical\n",
    "    \n",
    "    + For the missing values in \"TailNum\" we are going to delete it. Since if we cannot identify the flight, there is little we can do with those values\n",
    "\n",
    "    + for the other missing/null values convert the NaN values to the mean\n",
    "\n",
    "\n",
    "\n",
    "$~$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d8c4c1c7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:29:59.928190Z",
     "start_time": "2022-04-18T19:29:59.238605Z"
    }
   },
   "outputs": [],
   "source": [
    "# keep values cancelled ==1 (flights cancelled) in a diferent dataframe.\n",
    "df_cancelled = df.loc[df['Cancelled'] == 1]\n",
    "\n",
    "\n",
    "# New dataframe with out cancelled values\n",
    "df_analisys = df.loc[df['Cancelled'] == 0].copy()\n",
    "\n",
    "# As we aren't going to use it, we can drop \"Cacelled\" and \"CancellationCode\" columns from our new dataframe\n",
    "df_analisys.drop(columns=[\"Cancelled\", \"CancellationCode\"], inplace=True)\n",
    "\n",
    "# copy variables which described caused of the delay into a diferent dataframe to evaluate multicollinearity\n",
    "df_cause_delay = df_analisys[[\n",
    "    \"CarrierDelay\", \"WeatherDelay\", \"NASDelay\", \"LateAircraftDelay\"]].copy()\n",
    "\n",
    "# keep non necessary variables in a df_non_necessary_\n",
    "df_non_necessary = df_analisys[[\"CarrierDelay\",\n",
    "                                \"WeatherDelay\", \"NASDelay\", \"LateAircraftDelay\"]]\n",
    "\n",
    "# drop non necessary variables from our df_analisys dataframe\n",
    "df_analisys.drop(columns=[\"CarrierDelay\", \"WeatherDelay\",\n",
    "                 \"NASDelay\", \"LateAircraftDelay\"], inplace=True)\n",
    "\n",
    "df_analisys.drop(columns=[\"SecurityDelay\"], inplace=True)\n",
    "\n",
    "# where 0 = delayed & 1 = on time\n",
    "df_analisys['with_delay'] = np.where(df_analisys['ArrDelay'] <= 0, 1, 0)\n",
    "\n",
    "# drop Year from the set of independent variables.\n",
    "df_analisys.drop(['Year'], axis=1, inplace=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "648d0d66",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:00.305588Z",
     "start_time": "2022-04-18T19:29:59.929108Z"
    }
   },
   "outputs": [],
   "source": [
    "# changing types:\n",
    "to_change = [\"Month\", \"DayofMonth\", \"DayOfWeek\", \"Diverted\",\n",
    "             \"FlightNum\", \"Origin\", \"Dest\", \"TailNum\", \"UniqueCarrier\",\n",
    "             \"Diverted\"]\n",
    "\n",
    "for x in to_change:\n",
    "    df_analisys[x] = df_analisys[x].astype(\"category\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "64a433a7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.050833Z",
     "start_time": "2022-04-18T19:30:00.306313Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "duplicated values:  2\n"
     ]
    }
   ],
   "source": [
    "# check for duplicates\n",
    "print(\"duplicated values: \", sum(df_analisys.duplicated()))\n",
    "\n",
    "# drop duplicates\n",
    "df_analisys.drop_duplicates(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6ece85e6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.097951Z",
     "start_time": "2022-04-18T19:30:02.051606Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Month                   0\n",
       "DayofMonth              0\n",
       "DayOfWeek               0\n",
       "DepTime                 0\n",
       "CRSDepTime              0\n",
       "ArrTime              6477\n",
       "CRSArrTime              0\n",
       "UniqueCarrier           0\n",
       "FlightNum               0\n",
       "TailNum                 5\n",
       "ActualElapsedTime    7754\n",
       "CRSElapsedTime        198\n",
       "AirTime              7754\n",
       "ArrDelay             7754\n",
       "DepDelay                0\n",
       "Origin                  0\n",
       "Dest                    0\n",
       "Distance                0\n",
       "TaxiIn               6477\n",
       "TaxiOut                 0\n",
       "Diverted                0\n",
       "with_delay              0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check for the Missing values by column:\n",
    "df_analisys.isnull().sum()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fb05fbd4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.184438Z",
     "start_time": "2022-04-18T19:30:02.098947Z"
    }
   },
   "outputs": [],
   "source": [
    "#delete null values in \"TailNum\"\n",
    "df_analisys.dropna(subset=['TailNum'], inplace=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b4099e35",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.200048Z",
     "start_time": "2022-04-18T19:30:02.185141Z"
    }
   },
   "outputs": [],
   "source": [
    "#filter columns with null values\n",
    "columns_null= df_analisys.columns[df_analisys.isna().any()].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "95b6c138",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.404663Z",
     "start_time": "2022-04-18T19:30:02.202041Z"
    }
   },
   "outputs": [],
   "source": [
    "#imputing missing data, convert the NaN values to the mean.\n",
    "\n",
    "imp = SimpleImputer (missing_values=np.nan, strategy=\"mean\")\n",
    "imp.fit(df_analisys[columns_null])\n",
    "df_analisys[columns_null] = imp.transform(df_analisys[columns_null])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ea9ff52e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.453577Z",
     "start_time": "2022-04-18T19:30:02.405444Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Month                0\n",
      "DayofMonth           0\n",
      "DayOfWeek            0\n",
      "DepTime              0\n",
      "CRSDepTime           0\n",
      "ArrTime              0\n",
      "CRSArrTime           0\n",
      "UniqueCarrier        0\n",
      "FlightNum            0\n",
      "TailNum              0\n",
      "ActualElapsedTime    0\n",
      "CRSElapsedTime       0\n",
      "AirTime              0\n",
      "ArrDelay             0\n",
      "DepDelay             0\n",
      "Origin               0\n",
      "Dest                 0\n",
      "Distance             0\n",
      "TaxiIn               0\n",
      "TaxiOut              0\n",
      "Diverted             0\n",
      "with_delay           0\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(df_analisys.isnull().sum())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3e67431",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "As the dataset is large, we are going to perform a sampling of 1% the dataset\n",
    "\n",
    "$~$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ddb9c410",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.528251Z",
     "start_time": "2022-04-18T19:30:02.454414Z"
    }
   },
   "outputs": [],
   "source": [
    "#performing a sample \n",
    "df_analisys_sample = df_analisys.sample(frac=0.01, random_state=42)\n",
    "\n",
    "#cleaning the memory\n",
    "del df_analisys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "43044d9a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.531459Z",
     "start_time": "2022-04-18T19:30:02.529076Z"
    }
   },
   "outputs": [],
   "source": [
    "# dependent variables\n",
    "y = df_analisys_sample[[\"ArrDelay\"]]\n",
    "\n",
    "# independent variables\n",
    "X = df_analisys_sample.drop([\"ArrDelay\", \"with_delay\"], axis=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "cb42b5e4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.592093Z",
     "start_time": "2022-04-18T19:30:02.532591Z"
    }
   },
   "outputs": [],
   "source": [
    "#filter categorical variables\n",
    "X_cat = X.select_dtypes(include=[\"category\"])\n",
    "\n",
    "#\"Month\",\"DayofMonth\",\"DayOfWeek\" are already label\n",
    "X_label= X_cat[[\"Month\",\"DayofMonth\",\"DayOfWeek\"]]\n",
    "\n",
    "X_cat = X_cat.drop ([\"Month\",\"DayofMonth\",\"DayOfWeek\"], axis=1)\n",
    "\n",
    "#filter numerical variables\n",
    "\n",
    "X_num= X.select_dtypes(include=[\"int64\",\"float64\"])\n",
    "\n",
    "#encoding dummy variables\n",
    "coder = OneHotEncoder(handle_unknown=\"ignore\",drop='if_binary') #drop binary to avoid multicollinarity \n",
    "result = coder.fit_transform(X_cat)\n",
    "X_cat_encoder = pd.DataFrame.sparse.from_spmatrix(result)\n",
    "X_cat_encoder.columns = coder.get_feature_names_out()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9584daa2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.712326Z",
     "start_time": "2022-04-18T19:30:02.592844Z"
    }
   },
   "outputs": [],
   "source": [
    "#prepare the explanatory variable\n",
    "X_label_ =  X_label.reset_index(drop=True)\n",
    "X_num_ = X_num.reset_index(drop=True)\n",
    "X_cat_encoder = X_cat_encoder.reset_index(drop=True)\n",
    "\n",
    "frames = [X_label_, X_cat_encoder, X_num_]\n",
    "\n",
    "\n",
    "X = pd.concat(frames, axis=1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba3a85db",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "+ check if our independent variables present multicollinearity:\n",
    "\n",
    "$~$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f6b42f79",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.902606Z",
     "start_time": "2022-04-18T19:30:02.713304Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Correlation matrix\n",
    "fig, ax = plt.subplots(figsize=(15, 10))\n",
    "corr = X_num.corr()\n",
    "sns.set_theme(style=\"white\")\n",
    "cmap = sns.diverging_palette(230, 20, as_cmap=True)\n",
    "\n",
    "matrix = np.triu(corr)\n",
    "sns.heatmap(corr, annot=True, mask=matrix, cmap=cmap)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42c31538",
   "metadata": {},
   "source": [
    "$~$\n",
    "___\n",
    "####  Exercise 1\n",
    "\n",
    "$~$\n",
    "\n",
    "Create at least three different regression models to try to predict DelayedFlights.csv's flight delay (ArrDelay) as best you can. \n",
    "\n",
    "$~$\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d45be8e6",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "We are going to performace 3 regressions:\n",
    "\n",
    "+   Linear regression (using numeric features)\n",
    "+   Ridge regression (using all features)\n",
    "+   Lasso regression (using all features)\n",
    "\n",
    "$~$\n",
    "\n",
    "##### Linear regression\n",
    "\n",
    "$~$\n",
    "\n",
    "+ as the first task, let's performing a linear regression  using numeric features\n",
    "\n",
    "$~$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bbd0cd8e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:02.919673Z",
     "start_time": "2022-04-18T19:30:02.903506Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R^2: 0.9827848567809067\n",
      "Root Mean Squared Error: 7.481332662040825\n"
     ]
    }
   ],
   "source": [
    "#creating feature and target arrays\n",
    "\n",
    "# X_reg = X_num.values\n",
    "# y_reg = y[\"ArrDelay\"].values\n",
    "\n",
    "\n",
    "# # Create training and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_num_,\n",
    "y, test_size = 0.3, random_state=42)\n",
    "\n",
    "#  # Create the regressor: reg_all\n",
    "reg_all = LinearRegression()\n",
    "\n",
    "# # Fit the regressor to the training data\n",
    "reg_all.fit(X_train,y_train)\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = reg_all.predict(X_test)\n",
    "\n",
    "# # Compute and print R^2 and RMSE\n",
    "r2_reg = reg_all.score(X_test, y_test)\n",
    "print(\"R^2: {}\".format(r2_reg))\n",
    "\n",
    "rmse_reg = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_reg))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecb25f18",
   "metadata": {},
   "source": [
    "The predictions of the final model are on average 7.48 min away from the real value.\n",
    "\n",
    "$~$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e0c227e",
   "metadata": {},
   "source": [
    "##### Ridge regression: Regression with all features\n",
    "\n",
    "$~$\n",
    "\n",
    "+  let's try using all features\n",
    "\n",
    "$~$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "95783720",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:20.852882Z",
     "start_time": "2022-04-18T19:30:02.921900Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R^2: 0.9736701121574977\n",
      "Root Mean Squared Error: 9.2522668679228\n"
     ]
    }
   ],
   "source": [
    "# Create training and test sets\n",
    "# X_ridge = X.values\n",
    "# y_ridge = y[\"ArrDelay\"].values\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y,\n",
    "test_size = 0.3, random_state=42)\n",
    "\n",
    "# Create the regressor: ridge\n",
    "ridge =Ridge()\n",
    "\n",
    "# Fit the regressor to the training data\n",
    "ridge.fit(X_train,y_train)\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = ridge.predict(X_test)\n",
    "\n",
    "# # Compute and print R^2 and RMSE\n",
    "r2_ridge = ridge.score(X_test, y_test)\n",
    "print(\"R^2: {}\".format(r2_ridge))\n",
    "rmse_ridge = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_ridge))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "250eb0e4",
   "metadata": {},
   "source": [
    "The predictions of the final model are on average 9.25 min away from the real value.\n",
    "\n",
    "$~$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27b27efa",
   "metadata": {},
   "source": [
    "#####  Lassso Regression: Regression with all features\n",
    "\n",
    "$~$\n",
    "\n",
    "+  let's try using all features, and check how many features will the model select to use\n",
    "\n",
    "$~$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "787c9523",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:21.863449Z",
     "start_time": "2022-04-18T19:30:20.879643Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R^2: 0.9827777098609054\n",
      "Root Mean Squared Error: 7.482885450103868\n",
      "Number of features used: 11\n"
     ]
    }
   ],
   "source": [
    "# Create training and test sets\n",
    "# X_lasso = X.values\n",
    "# y_lasso = y[\"ArrDelay\"].values\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_num, y,\n",
    "test_size = 0.3, random_state=42)\n",
    "\n",
    "# Create the regressor: lasso\n",
    "lasso =Lasso()\n",
    "\n",
    "# Fit the regressor to the training data\n",
    "lasso.fit(X_train,y_train)\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = lasso.predict(X_test)\n",
    "\n",
    "# # Compute and print R^2 and RMSE\n",
    "r2_lasso = lasso.score(X_test, y_test)\n",
    "print(\"R^2: {}\".format(r2_lasso))\n",
    "\n",
    "rmse_lasso = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_lasso))\n",
    "print(\"Number of features used: {}\".format(np.sum(lasso.coef_ != 0)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a5904fe",
   "metadata": {},
   "source": [
    "The predictions of the final model are on average 7.48 min away from the real value. In addition, the number of variables chosen by the model coincides with the number of variables that we use in the linear regression model (11 features).\n",
    "\n",
    "$~$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "214112c9",
   "metadata": {},
   "source": [
    "$~$\n",
    "___\n",
    "####  Exercise 2\n",
    "\n",
    "$~$\n",
    "\n",
    "Compare them based on MSE and R2.\n",
    "\n",
    "$~$\n",
    "___"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "df9c3695",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:21.929953Z",
     "start_time": "2022-04-18T19:30:21.868716Z"
    }
   },
   "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>R^2</th>\n",
       "      <th>RMSE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Linear_regression</th>\n",
       "      <td>0.982785</td>\n",
       "      <td>7.481333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ridge_regression</th>\n",
       "      <td>0.973670</td>\n",
       "      <td>9.252267</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lasso_regression</th>\n",
       "      <td>0.982778</td>\n",
       "      <td>7.482885</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                        R^2      RMSE\n",
       "Linear_regression  0.982785  7.481333\n",
       "Ridge_regression   0.973670  9.252267\n",
       "Lasso_regression   0.982778  7.482885"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# assign data of lists.  \n",
    "data = {'R^2':[r2_reg,r2_ridge,r2_lasso], 'RMSE':[rmse_reg,rmse_ridge,rmse_lasso]}  \n",
    "  \n",
    "# Creates pandas DataFrame.  \n",
    "df = pd.DataFrame(data, index =['Linear_regression', 'Ridge_regression', 'Lasso_regression'])  \n",
    "  \n",
    "# print the dataframe\n",
    "df\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38d91d67",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    " + In the table below shows:\n",
    " \n",
    "    + The  score of Ridge regression is lower than for LinearRegression. This is consistent with our expectation. With linear regression, we were overfitting our data. Ridge is a more restricted model, so we are less likely to overfit. \n",
    "\n",
    "    + Lasso regression not only selects the most significant variables (in this case 11 and that coincide with the number of variables of the linear regression) it also gives us values close to those of the linear regression\n",
    "$~$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7caa1ff",
   "metadata": {},
   "source": [
    "$~$\n",
    "___\n",
    "####  Exercise 3\n",
    "\n",
    "$~$\n",
    "\n",
    "Train them using the different parameters they support.\n",
    "\n",
    "$~$\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd8db8af",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "Although it is possible to optimize the hyperparameters of the models using Random Search and Grid Search, for this exercise we will use only Grid search.\n",
    "\n",
    "$~$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a41ed57e",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "+ Linear regression: \n",
    "\n",
    "$~$\n",
    "\n",
    "\n",
    "Even though the linear regression model does not have hyperparameters that can be tuned. Let's try using Gridsearch to fit some atributes of the model values:\n",
    "\n",
    "$~$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b0fe42e7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:30:22.591227Z",
     "start_time": "2022-04-18T19:30:21.937162Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuned lineal Regression Parameters: {'copy_X': True, 'fit_intercept': True, 'normalize': True, 'positive': False}\n",
      "Best score is 0.9796286966783908\n",
      "Root Mean Squared Error: 7.481332662040825\n"
     ]
    }
   ],
   "source": [
    "# # Create training and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_num_, y,\n",
    "    test_size=0.3,random_state =42 )\n",
    "\n",
    "# Setup the hyperparameter grid\n",
    "parameters = {'fit_intercept':[True,False], 'normalize':[True,False],\n",
    " 'copy_X':[True, False], \"positive\": [True,False]}\n",
    "# Instantiate a linear regression:\n",
    "reg_all = LinearRegression()\n",
    "\n",
    "#instantiate the GridSearchCV object: reg_grid\n",
    "\n",
    "reg_grid = GridSearchCV(reg_all,parameters, cv=3)\n",
    "\n",
    "# Fit it to the data\n",
    "\n",
    "reg_grid.fit(X_train,y_train)\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = reg_grid.predict(X_test)\n",
    "\n",
    "\n",
    "\n",
    "# Print the tuned parameters and score\n",
    "\n",
    "print(\"Tuned lineal Regression Parameters: {}\".format(reg_grid.best_params_)) \n",
    "\n",
    "r2_reg_grid = reg_grid.best_score_\n",
    "\n",
    "print(\"Best score is {}\".format(r2_reg_grid))\n",
    "\n",
    "rmse_reg_grid = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_reg))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1e8d26",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "+ ridge regression: \n",
    "\n",
    "$~$\n",
    "\n",
    "We are going to use Gridsearch to find the best alpha parameter for the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9cb9e968",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:37:01.028826Z",
     "start_time": "2022-04-18T19:30:22.593743Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuned lineal Regression Parameters: {'alpha': 1}\n",
      "Best score is 0.9762650824872631\n",
      "Root Mean Squared Error: 9.2522668679228\n"
     ]
    }
   ],
   "source": [
    "# # Create training and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y,\n",
    "test_size = 0.3, random_state=42)\n",
    "\n",
    "# Setup the hyperparameter grid\n",
    "\n",
    "params_Ridge = {'alpha': [1,0.1,0.01,0] }\n",
    "\n",
    "# Create the regressor: ridge\n",
    "ridge =Ridge()\n",
    "\n",
    "#instantiate the GridSearchCV object: rigde_grid\n",
    "\n",
    "rigde_grid = GridSearchCV(ridge,params_Ridge, cv=3)\n",
    "# Fit it to the data\n",
    "\n",
    "rigde_grid.fit(X_train,y_train)\n",
    "\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = rigde_grid.predict(X_test)\n",
    "\n",
    "\n",
    "# Print the tuned parameters and score\n",
    "print(\"Tuned lineal Regression Parameters: {}\".format(rigde_grid.best_params_)) \n",
    "\n",
    "r2_ridge_grid = rigde_grid.best_score_\n",
    "\n",
    "print(\"Best score is {}\".format(r2_ridge_grid))\n",
    "\n",
    "rmse_rigde_grid = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_rigde_grid))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e945f3d3",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "+ Lasso regression: \n",
    "\n",
    "$~$\n",
    "\n",
    "We are going to use Gridsearch to find the best alpha parameter for the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "dee65b0c",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:48:49.623569Z",
     "start_time": "2022-04-18T19:37:01.039258Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuned lineal Regression Parameters: {'alpha': 1}\n",
      "Best score is 0.9796894226109717\n",
      "Root Mean Squared Error: 7.482885325672634\n"
     ]
    }
   ],
   "source": [
    "# # Create training and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y,\n",
    "test_size = 0.3, random_state=42)\n",
    "# Setup the hyperparameter grid\n",
    "\n",
    "params = {'alpha': [1,0.1,0.01,0]}\n",
    "lasso = Lasso()\n",
    "\n",
    "# instantiate the GridSearchCV object: lasso_grid\n",
    "\n",
    "lasso_grid = GridSearchCV(lasso, params, cv = 3)\n",
    "\n",
    "# Fit it to the data\n",
    "lasso_grid.fit(X_train, y_train)\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = lasso_grid.predict(X_test)\n",
    "\n",
    "\n",
    "# Print the tuned parameters and score\n",
    "print(\"Tuned lineal Regression Parameters: {}\".format(lasso_grid.best_params_)) \n",
    "\n",
    "r2_lasso_grid = lasso_grid.best_score_\n",
    "print(\"Best score is {}\".format(r2_lasso_grid))\n",
    "\n",
    "rmse_lasso_grid = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_lasso_grid))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84b4ec26",
   "metadata": {},
   "source": [
    "$~$\n",
    "___\n",
    "####  Exercise 4\n",
    "\n",
    "$~$\n",
    "\n",
    "Compare your performance using the train / test approach or using all data (internal validation)\n",
    "\n",
    "$~$\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba05d359",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "Let's try our models using Cross validation:\n",
    "\n",
    "$~$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59ed0bfd",
   "metadata": {},
   "source": [
    "+ linear regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3b3080d5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:56:32.959632Z",
     "start_time": "2022-04-18T19:56:32.811004Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.99442803 0.97181074 0.97888641 0.97393024 0.98506255]\n",
      "Average 5-Fold CV Score: 0.9808235943683543\n"
     ]
    }
   ],
   "source": [
    "# Create a linear regression object: reg\n",
    "\n",
    "reg = LinearRegression()\n",
    "\n",
    "# Compute 5-fold cross-validation scores: cv_scores\n",
    "cv_scores = cross_val_score(reg,X_num_,y,cv=5) \n",
    "\n",
    "# Print the 5-fold cross-validation scores\n",
    "print(cv_scores)\n",
    "\n",
    "print(\"Average 5-Fold CV Score: {}\".format(np.mean(cv_scores)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b84769e6",
   "metadata": {},
   "source": [
    "+ ridge regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "c0e2c4f0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T19:58:08.090677Z",
     "start_time": "2022-04-18T19:56:32.976128Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.98826807 0.96951569 0.97489098 0.96723647 0.9781799 ]\n",
      "Average 5-Fold CV Score: 0.9756182219538576\n"
     ]
    }
   ],
   "source": [
    "# Instantiate a ridge regressor: ridge\n",
    "ridge = Ridge()\n",
    "\n",
    "# Perform -fold cross-validation: ridge_cv\n",
    "ridge_cv = cross_val_score(ridge,X,y,cv=5)\n",
    "\n",
    "# Print the cross-validated scores\n",
    "print(ridge_cv)\n",
    "\n",
    "print(\"Average 5-Fold CV Score: {}\".format(np.mean(ridge_cv)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ff76dc4",
   "metadata": {},
   "source": [
    "+ lasso regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "875418be",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T20:05:13.153648Z",
     "start_time": "2022-04-18T19:58:08.105921Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.99441804 0.97190085 0.97882321 0.97388444 0.98504906]\n",
      "Average 5-Fold CV Score: 0.9808151201402062\n"
     ]
    }
   ],
   "source": [
    "# Instantiate a lasso regressor: lasso\n",
    "lasso = Lasso()\n",
    "\n",
    "# Perform 5-fold cross-validation: lasso_cv\n",
    "lasso_cv = cross_val_score(lasso,X,y,cv=5)\n",
    "\n",
    "# Print the cross-validated scores\n",
    "print(lasso_cv)\n",
    "\n",
    "print(\"Average 5-Fold CV Score: {}\".format(np.mean(lasso_cv)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fd8e697",
   "metadata": {},
   "source": [
    "$~$\n",
    "___\n",
    "####  Exercise 5\n",
    "\n",
    "$~$\n",
    "\n",
    "Perform some variable engineering process to improve prediction\n",
    "\n",
    "$~$\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1738e76",
   "metadata": {},
   "source": [
    "$~$\n",
    "\n",
    "in order to improve the model we are going to normalize the numerical variables (we are going to use [MinMaxScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html) \n",
    "$~$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec8be04b",
   "metadata": {},
   "source": [
    "+ linear regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c102592b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T20:05:13.248036Z",
     "start_time": "2022-04-18T20:05:13.192349Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuned lineal regression R squared: 0.9827848567809067\n",
      "Root Mean Squared Error: 7.4813326620408365\n"
     ]
    }
   ],
   "source": [
    "#copy_X': True, 'fit_intercept': True, 'normalize': True, 'positive': False\n",
    "\n",
    "# Setup the pipeline steps: steps\n",
    "steps = [ (\"normalizer\", MinMaxScaler()),\n",
    "            (\"reg\", LinearRegression(normalize=False,copy_X=True,fit_intercept=True,positive=False))]\n",
    "\n",
    "# Create the pipeline: pipeline \n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "# Specify the parameters space\n",
    "parameters = {'fit_intercept':[True,False]}\n",
    "\n",
    " # Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_num_, y,\n",
    "    test_size=0.3,random_state =42)\n",
    "\n",
    "# Fit the pipeline to the training set\n",
    "\n",
    "reg_norm = pipeline.fit(X_train,y_train)\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = reg_norm.predict(X_test)\n",
    "\n",
    "# Compute and print the metrics\n",
    "r2_reg_norm = reg_norm.score(X_test, y_test)\n",
    "rmse_reg_nom = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "\n",
    "\n",
    "print(\"Tuned lineal regression R squared: {}\".format(r2_reg_norm))\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_reg_nom))\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41806d0a",
   "metadata": {},
   "source": [
    "+ ridge regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "328aa0ec",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T20:05:34.286364Z",
     "start_time": "2022-04-18T20:05:13.269600Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuned Ridge R squared: 0.9673314208639724\n",
      "Root Mean Squared Error: 10.305967516818944\n"
     ]
    }
   ],
   "source": [
    "# Setup the pipeline steps: steps\n",
    "steps = [ (\"normalizer\", MinMaxScaler()),\n",
    "            (\"ridge\", Ridge(normalize=False,solver=\"saga\",max_iter=2,positive=False,))]\n",
    "\n",
    "# Create the pipeline: pipeline \n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.3, random_state=42)\n",
    "\n",
    "# Fit the pipeline to the training set\n",
    "\n",
    "ridge_norm = pipeline.fit(X_train,y_train)\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = ridge_norm.predict(X_test)\n",
    "\n",
    "# Compute and print the metrics\n",
    "r2_ridge_norm= ridge_norm.score(X_test, y_test)\n",
    "print(\"Tuned Ridge R squared: {}\".format(r2_ridge_norm))\n",
    "rmse_ridge_norm = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_ridge_norm))\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3b68a7f",
   "metadata": {},
   "source": [
    "+ lasso regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "4f42d8f3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T20:05:42.410495Z",
     "start_time": "2022-04-18T20:05:34.317477Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuned lasso R squared: 0.7890651197160649\n",
      "Root Mean Squared Error: 26.18772952163165\n"
     ]
    }
   ],
   "source": [
    "# Setup the pipeline steps: steps\n",
    "steps = [ (\"normalizer\", MinMaxScaler()),\n",
    "            (\"lasso\", Lasso(warm_start=True,normalize=False, positive=True,fit_intercept=True))]\n",
    "\n",
    "# Create the pipeline: pipeline \n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "# Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.3, random_state=42)\n",
    "\n",
    "# Fit the pipeline to the training set\n",
    "\n",
    "lasso_norm = pipeline.fit(X_train,y_train)\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = lasso_norm.predict(X_test)\n",
    "\n",
    "# Compute and print the metrics\n",
    "r2_lasso_norm= lasso_norm.score(X_test, y_test)\n",
    "print(\"Tuned lasso R squared: {}\".format(r2_lasso_norm))\n",
    "rmse_lasso_norm = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_lasso_norm))\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ade88084",
   "metadata": {},
   "source": [
    "$~$\n",
    "___\n",
    "####  Exercise 6\n",
    "\n",
    "$~$\n",
    "\n",
    "Do not use the DepDelay variable when making predictions\n",
    "\n",
    "\n",
    "$~$\n",
    "___"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "3ea60296",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T20:05:42.627490Z",
     "start_time": "2022-04-18T20:05:42.446567Z"
    }
   },
   "outputs": [],
   "source": [
    "#drop DepDelay \n",
    "X = X.drop([\"DepDelay\"],axis=1)\n",
    "X_num = X_num.drop([\"DepDelay\"], axis=1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec754831",
   "metadata": {},
   "source": [
    "+ linear regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "53cf713a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T20:05:42.648665Z",
     "start_time": "2022-04-18T20:05:42.628539Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuned lineal regression R squared: 0.1425497342553621\n",
      "Root Mean Squared Error: 52.79929405798076\n"
     ]
    }
   ],
   "source": [
    "#creating feature and target arrays without \"DepDelay\"\n",
    "\n",
    "# X_reg = X_num.values\n",
    "# y_reg = y[\"ArrDelay\"].values\n",
    "\n",
    "# Setup the pipeline steps: steps\n",
    "steps = [ (\"normalizer\", MinMaxScaler()),\n",
    "            (\"reg\", LinearRegression(copy_X= True, fit_intercept= True))]\n",
    "\n",
    "# Create the pipeline: pipeline \n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "\n",
    " # Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_num, y,\n",
    "    test_size=0.3,random_state =42 )\n",
    "\n",
    "# Fit the pipeline to the training set\n",
    "\n",
    "reg_norm_without = pipeline.fit(X_train,y_train)\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = reg_norm_without.predict(X_test)\n",
    "\n",
    "# Compute and print the metrics\n",
    "r2_reg_norm_without = reg_norm_without.score(X_test, y_test)\n",
    "rmse_reg_nom_without = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "\n",
    "\n",
    "print(\"Tuned lineal regression R squared: {}\".format(r2_reg_norm_without))\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_reg_nom_without))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb96d3b6",
   "metadata": {},
   "source": [
    "+ ridge regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "b92c8fe0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T20:11:31.004544Z",
     "start_time": "2022-04-18T20:11:21.786011Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuned lineal regression R squared: 0.044352154863894544\n",
      "Root Mean Squared Error: 55.74072186678194\n"
     ]
    }
   ],
   "source": [
    "#creating feature and target arrays without \"DepDelay\"\n",
    "\n",
    "# X_ridge = X\n",
    "# y_ridge = y[\"ArrDelay\"].values\n",
    "\n",
    "# Setup the pipeline steps: steps\n",
    "steps = [ (\"normalizer\", MinMaxScaler()),\n",
    "            (\"ridge\", Ridge(normalize=False,solver=\"saga\",max_iter=2,positive=False,))]\n",
    "\n",
    "# Create the pipeline: pipeline \n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "\n",
    " # Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y,\n",
    "    test_size=0.3,random_state =42 )\n",
    "\n",
    "# Fit the pipeline to the training set\n",
    "\n",
    "ridge_norm_without = pipeline.fit(X_train,y_train)\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = ridge_norm_without.predict(X_test)\n",
    "\n",
    "# Compute and print the metrics\n",
    "r2_ridge_norm_without = ridge_norm_without.score(X_test, y_test)\n",
    "rmse_ridge_nom_without = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "\n",
    "\n",
    "print(\"Tuned lineal regression R squared: {}\".format(r2_ridge_norm_without))\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_ridge_nom_without))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be310d9a",
   "metadata": {},
   "source": [
    "+ lasso regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "4b5d964f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T20:12:53.283617Z",
     "start_time": "2022-04-18T20:12:45.402453Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuned lineal regression R squared: 0.012177624620871574\n",
      "Root Mean Squared Error: 56.671287047222044\n"
     ]
    }
   ],
   "source": [
    "#creating feature and target arrays without \"DepDelay\"\n",
    "\n",
    "# X_lasso = X\n",
    "# y_lasso = y[\"ArrDelay\"].values\n",
    "\n",
    "# Setup the pipeline steps: steps\n",
    "steps = [(\"normalizer\", MinMaxScaler()),\n",
    "(\"y_lasso\", Lasso(alpha=1, fit_intercept=True))]\n",
    "\n",
    "# Create the pipeline: pipeline \n",
    "pipeline = Pipeline(steps)\n",
    "\n",
    "\n",
    " # Create train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,random_state =42 )\n",
    "\n",
    "# Fit the pipeline to the training set\n",
    "\n",
    "y_lasso_norm_without = pipeline.fit(X_train,y_train)\n",
    "\n",
    "# # Predict on the test data: y_pred\n",
    "y_pred = y_lasso_norm_without.predict(X_test)\n",
    "\n",
    "# Compute and print the metrics\n",
    "r2_y_lasso_norm_without = y_lasso_norm_without.score(X_test, y_test)\n",
    "rmse_y_lasso_nom_without = np.sqrt(mean_squared_error(y_test,y_pred))\n",
    "\n",
    "\n",
    "print(\"Tuned lineal regression R squared: {}\".format(r2_y_lasso_norm_without))\n",
    "print(\"Root Mean Squared Error: {}\".format(rmse_y_lasso_nom_without))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56c717bf",
   "metadata": {},
   "source": [
    "\n",
    "#### Compare all MSE and R2.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "2ab5397e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-18T20:12:53.319999Z",
     "start_time": "2022-04-18T20:12:53.289767Z"
    }
   },
   "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>R^2</th>\n",
       "      <th>RMSE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Linear_regression</th>\n",
       "      <td>0.982785</td>\n",
       "      <td>7.481333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ridge_regression</th>\n",
       "      <td>0.973670</td>\n",
       "      <td>9.252267</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lasso_regression</th>\n",
       "      <td>0.982778</td>\n",
       "      <td>7.482885</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Linear_regression_gridsearch</th>\n",
       "      <td>0.979629</td>\n",
       "      <td>7.481333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ridge_regression_gridsearch</th>\n",
       "      <td>0.976265</td>\n",
       "      <td>9.252267</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lasso_regression_gridsearch</th>\n",
       "      <td>0.979689</td>\n",
       "      <td>7.482885</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Linear_regression_normalized</th>\n",
       "      <td>0.982785</td>\n",
       "      <td>7.481333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ridge_regression_normalized</th>\n",
       "      <td>0.967331</td>\n",
       "      <td>10.305968</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lasso_regression_normalized</th>\n",
       "      <td>0.789065</td>\n",
       "      <td>26.187730</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Linear_regression_non_Depdelay</th>\n",
       "      <td>0.142550</td>\n",
       "      <td>52.799294</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ridge_regression__non_Depdelay</th>\n",
       "      <td>0.044352</td>\n",
       "      <td>55.740722</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lasso_regression__non_Depdelay</th>\n",
       "      <td>0.012178</td>\n",
       "      <td>56.671287</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                     R^2       RMSE\n",
       "Linear_regression               0.982785   7.481333\n",
       "Ridge_regression                0.973670   9.252267\n",
       "Lasso_regression                0.982778   7.482885\n",
       "Linear_regression_gridsearch    0.979629   7.481333\n",
       "Ridge_regression_gridsearch     0.976265   9.252267\n",
       "Lasso_regression_gridsearch     0.979689   7.482885\n",
       "Linear_regression_normalized    0.982785   7.481333\n",
       "Ridge_regression_normalized     0.967331  10.305968\n",
       "Lasso_regression_normalized     0.789065  26.187730\n",
       "Linear_regression_non_Depdelay  0.142550  52.799294\n",
       "Ridge_regression__non_Depdelay  0.044352  55.740722\n",
       "Lasso_regression__non_Depdelay  0.012178  56.671287"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# assign data of lists.\n",
    "data = {'R^2': [r2_reg, r2_ridge, r2_lasso, r2_reg_grid, r2_ridge_grid,\n",
    "                r2_lasso_grid, r2_reg_norm, r2_ridge_norm, r2_lasso_norm,r2_reg_norm_without,\n",
    "                r2_ridge_norm_without,r2_y_lasso_norm_without],\n",
    "        'RMSE': [rmse_reg, rmse_ridge, rmse_lasso, rmse_reg_grid, rmse_rigde_grid,\n",
    "                 rmse_lasso_grid, rmse_reg_nom, rmse_ridge_norm, rmse_lasso_norm,rmse_reg_nom_without,\n",
    "                 rmse_ridge_nom_without,rmse_y_lasso_nom_without]}\n",
    "\n",
    "# Creates pandas DataFrame\n",
    "df = pd.DataFrame(data, index=['Linear_regression',\n",
    "                               'Ridge_regression', 'Lasso_regression', \"Linear_regression_gridsearch\",\n",
    "                               \"Ridge_regression_gridsearch\", \"Lasso_regression_gridsearch\", \"Linear_regression_normalized\", \n",
    "                               \"Ridge_regression_normalized\", \"Lasso_regression_normalized\",\"Linear_regression_non_Depdelay\",\n",
    "                               \"Ridge_regression__non_Depdelay\",\"Lasso_regression__non_Depdelay\"])\n",
    "\n",
    "# print the dataframe\n",
    "df\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dca1eb0c",
   "metadata": {},
   "source": [
    "$~$\n",
    "___\n",
    "####  Conclusions\n",
    "\n",
    "$~$\n",
    "\n",
    "+ Some considerations about the size of the data:\n",
    "\n",
    "    + to generate the models, I had to take a sample of 1% of the data. Despite this, the execution time of the models has been quite high. to generate the models, I had to take a sample of 1% of the data. Despite this, the execution time of the models has been quite high. Especially for the execution of the Gridsearch. where I have only been able to find the best alpha, when there are certainly other hyperparameters that could be improved\n",
    "\n",
    "+ This can be seen in all the models we have generated. The linear regression model may, due to the scores, be better, however, it must be taken into account how general it is. In fact, this is the reason why for the linear regression model I have used only the numerical variables. If we compare the scores of the linear regression (which only receives numerical variables) with the other two regressions, we see that the scores are relatively close. This, in other words, shows us that the algorithm of the ridge and lasso regressions discriminate the insignificant independent variables.\n",
    "\n",
    "+ In the case with Cross Validation, there is no improvement with respect to the models, so we can say that the models could be improved and that the first models have a bias to improve.\n",
    "\n",
    "+ To improve the models we can adjust the hyperparameters. we could have chosen between grind-search or random-search to do it. I chose grind-search, knowing that this method has a very high computational cost. Precisely to test my computer. In this case I have only evaluated the alpha value in the models, however, there are many more hyperameters that can be evaluated.\n",
    "\n",
    "+ Since there are outliers in the dataframe, I have chosen to normalize the data using the MinMaxScaler method. \n",
    "\n",
    "    +   it performance doesn't affect the lineal regression model.\n",
    "    +  however, the normalization process does affect the lasso and ridge models. Lasso regression puts constraints on the size of the coefficients associated to each variable. However, this value will depend on the magnitude of each variable. The result of centering the variables means that there is no longer an intercept. This applies equally to ridge regression.\n",
    "\n",
    "\n",
    "+ After removing the variable \"DepDelay\", the results show that this variable is very important to explain ArrDelay. This is verified in the low results of the models.\n",
    "\n",
    "\n",
    "+ finally, finally we can understand that in lasso regression, algorithm is trying to remove the extra features that doesn't have any use which sounds better because we can train with less data very nicely as well but the processing is a little bit harder, but in ridge regression the algorithm is trying to make those extra features less effective but not removing them completely which is easier to process. \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "___\n",
    "$~$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0eedf5c",
   "metadata": {},
   "source": [
    "___\n",
    "$~$\n",
    "\n",
    "####  *References*:\n",
    "\n",
    "+ [methods for classification & regression](https://www.educative.io/blog/scikit-learn-cheat-sheet-classification-regression-methods) \n",
    "+ [Hyperparameter Optimization With Random Search and Grid Search](https://machinelearningmastery.com/hyperparameter-optimization-with-random-search-and-grid-search/) \n",
    "+ []() \n",
    "$~$\n",
    "___"
   ]
  }
 ],
 "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.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "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
}