BasicMLExample.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear regression single numeric feature\n",
    "\n",
    "This notebook contains code to train and evaluate a linear regression model using a single numeric feature and label."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Business Problem\n",
    "Flight delays cost airlines money and frustrate passengers. We want to predict flight delays so we they can be potentially avoided or at least reduce the impact."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data set\n",
    "The [US Department of Transportation](https://catalog.data.gov/dataset/) publishes a number of data sets including flight arrival and departure data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the required python libraries\n",
    "- **pandas** contains the dataframe object and a number of useful methods for manipulating and querying data contained in a dataframe\n",
    "- **numpy** contains a number of useful mathematical operations including some that are helpful when evaluating accuracy of trained models\n",
    "- **Scikitlearn train_test_split** splits data into training and test sets\n",
    "- **scikitlearn LinearRegression** used to train a linear regression model\n",
    "- **scikitlearn metrics** used to calculate metrics such as Mean Squared Error, helpful when evaluating accuracy of trained models\n",
    "- **matplotlib pyplot** used to plot graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd  \n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn import metrics\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Read flight data from csv file into Pandas dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(616101, 17)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flight_df=pd.read_csv('all_flights.csv') # Read csv file into flight_df dataframe\n",
    "flight_df.shape                          # Display shape of array to see how many rows and columns are in the dataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Display the first 10 rows in the dataset to make sure data looks like it imported correctly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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>FL_DATE</th>\n",
       "      <th>OP_UNIQUE_CARRIER</th>\n",
       "      <th>TAIL_NUM</th>\n",
       "      <th>OP_CARRIER_FL_NUM</th>\n",
       "      <th>ORIGIN</th>\n",
       "      <th>DEST</th>\n",
       "      <th>CRS_DEP_TIME</th>\n",
       "      <th>DEP_TIME</th>\n",
       "      <th>DEP_DELAY</th>\n",
       "      <th>CRS_ARR_TIME</th>\n",
       "      <th>ARR_TIME</th>\n",
       "      <th>ARR_DELAY</th>\n",
       "      <th>CRS_ELAPSED_TIME</th>\n",
       "      <th>ACTUAL_ELAPSED_TIME</th>\n",
       "      <th>AIR_TIME</th>\n",
       "      <th>DISTANCE</th>\n",
       "      <th>Unnamed: 16</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2018-10-01</td>\n",
       "      <td>WN</td>\n",
       "      <td>N221WN</td>\n",
       "      <td>802</td>\n",
       "      <td>ABQ</td>\n",
       "      <td>BWI</td>\n",
       "      <td>905</td>\n",
       "      <td>903.0</td>\n",
       "      <td>-2.0</td>\n",
       "      <td>1450</td>\n",
       "      <td>1433.0</td>\n",
       "      <td>-17.0</td>\n",
       "      <td>225.0</td>\n",
       "      <td>210.0</td>\n",
       "      <td>197.0</td>\n",
       "      <td>1670.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2018-10-01</td>\n",
       "      <td>WN</td>\n",
       "      <td>N8329B</td>\n",
       "      <td>3744</td>\n",
       "      <td>ABQ</td>\n",
       "      <td>BWI</td>\n",
       "      <td>1500</td>\n",
       "      <td>1458.0</td>\n",
       "      <td>-2.0</td>\n",
       "      <td>2045</td>\n",
       "      <td>2020.0</td>\n",
       "      <td>-25.0</td>\n",
       "      <td>225.0</td>\n",
       "      <td>202.0</td>\n",
       "      <td>191.0</td>\n",
       "      <td>1670.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2018-10-01</td>\n",
       "      <td>WN</td>\n",
       "      <td>N920WN</td>\n",
       "      <td>1019</td>\n",
       "      <td>ABQ</td>\n",
       "      <td>DAL</td>\n",
       "      <td>1800</td>\n",
       "      <td>1802.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2045</td>\n",
       "      <td>2032.0</td>\n",
       "      <td>-13.0</td>\n",
       "      <td>105.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>580.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2018-10-01</td>\n",
       "      <td>WN</td>\n",
       "      <td>N480WN</td>\n",
       "      <td>1499</td>\n",
       "      <td>ABQ</td>\n",
       "      <td>DAL</td>\n",
       "      <td>950</td>\n",
       "      <td>947.0</td>\n",
       "      <td>-3.0</td>\n",
       "      <td>1235</td>\n",
       "      <td>1223.0</td>\n",
       "      <td>-12.0</td>\n",
       "      <td>105.0</td>\n",
       "      <td>96.0</td>\n",
       "      <td>81.0</td>\n",
       "      <td>580.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2018-10-01</td>\n",
       "      <td>WN</td>\n",
       "      <td>N227WN</td>\n",
       "      <td>3635</td>\n",
       "      <td>ABQ</td>\n",
       "      <td>DAL</td>\n",
       "      <td>1150</td>\n",
       "      <td>1151.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1430</td>\n",
       "      <td>1423.0</td>\n",
       "      <td>-7.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>92.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>580.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      FL_DATE OP_UNIQUE_CARRIER TAIL_NUM  OP_CARRIER_FL_NUM ORIGIN DEST  \\\n",
       "0  2018-10-01                WN   N221WN                802    ABQ  BWI   \n",
       "1  2018-10-01                WN   N8329B               3744    ABQ  BWI   \n",
       "2  2018-10-01                WN   N920WN               1019    ABQ  DAL   \n",
       "3  2018-10-01                WN   N480WN               1499    ABQ  DAL   \n",
       "4  2018-10-01                WN   N227WN               3635    ABQ  DAL   \n",
       "\n",
       "   CRS_DEP_TIME  DEP_TIME  DEP_DELAY  CRS_ARR_TIME  ARR_TIME  ARR_DELAY  \\\n",
       "0           905     903.0       -2.0          1450    1433.0      -17.0   \n",
       "1          1500    1458.0       -2.0          2045    2020.0      -25.0   \n",
       "2          1800    1802.0        2.0          2045    2032.0      -13.0   \n",
       "3           950     947.0       -3.0          1235    1223.0      -12.0   \n",
       "4          1150    1151.0        1.0          1430    1423.0       -7.0   \n",
       "\n",
       "   CRS_ELAPSED_TIME  ACTUAL_ELAPSED_TIME  AIR_TIME  DISTANCE  Unnamed: 16  \n",
       "0             225.0                210.0     197.0    1670.0          NaN  \n",
       "1             225.0                202.0     191.0    1670.0          NaN  \n",
       "2             105.0                 90.0      80.0     580.0          NaN  \n",
       "3             105.0                 96.0      81.0     580.0          NaN  \n",
       "4             100.0                 92.0      80.0     580.0          NaN  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flight_df.head()                         # Displays the top 10 rows from flight_df dataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Display the names of the columns in the dataframe and their datatypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FL_DATE                 object\n",
       "OP_UNIQUE_CARRIER       object\n",
       "TAIL_NUM                object\n",
       "OP_CARRIER_FL_NUM        int64\n",
       "ORIGIN                  object\n",
       "DEST                    object\n",
       "CRS_DEP_TIME             int64\n",
       "DEP_TIME               float64\n",
       "DEP_DELAY              float64\n",
       "CRS_ARR_TIME             int64\n",
       "ARR_TIME               float64\n",
       "ARR_DELAY              float64\n",
       "CRS_ELAPSED_TIME       float64\n",
       "ACTUAL_ELAPSED_TIME    float64\n",
       "AIR_TIME               float64\n",
       "DISTANCE               float64\n",
       "Unnamed: 16            float64\n",
       "dtype: object"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flight_df.dtypes  # Displays the names and data types of the columns in the dataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a new dataframe containing ONLY the columns we want to use as features and labels.\n",
    "This saves us spending time cleaning up data we are not using to train our model.\n",
    "This model will use DISTANCE as a feature to predict the value of the label ARR_DELAY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(616101, 2)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min_flight_data_df = flight_df[['DISTANCE','ARR_DELAY']]  # Create a new dataframe containing only DISTANCE and ARR_DELAY\n",
    "min_flight_data_df.shape                                  # Display the shape of the dataframe as a quick check to ensure \n",
    "                                                          # dataframe has expected number of columns and rows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get rid of rows containing NaN/missing values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(610334, 2)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "no_missing_values_df = min_flight_data_df.dropna(axis=0,how='any')  # Use dropna to remove rows with NaN in any column\n",
    "no_missing_values_df.shape                                          # Display shape to see how many rows were removed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create one dataframe containing only the features (DISTANCE), and one dataframe containing only the label (ARR_DELAY) \n",
    "If either of these has only one column you must reshape the dataframe to -1,1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dataFrame containign the features\n",
    "# Reshape to -1,1 if only containing a single column\n",
    "X = no_missing_values_df['DISTANCE'].values.reshape(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a DataFrame containing the labels\n",
    "# Reshape to -1,1 if only containing a single column\n",
    "y = no_missing_values_df['ARR_DELAY'].values.reshape(-1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Split the data into two datasets, one for training the model, one for testing the model\n",
    "\n",
    "scikitlearn method [train_test_split]( \n",
    "https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) \n",
    "- **X** is the dataframe containing our features\n",
    "- **Y** is the dataframe containing our label\n",
    "- **test_size** determines what fraction of the data is put into the test dataframe\n",
    "- **random_state** defaults to a random number, by specifying a specific number I ensure the split I generate is reproducible. That way if I make changes I know changes in accuracy are not caused by different rows used as training or test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(427233, 1)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Split into training and test data\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.30, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the size of your test and training datasets (i.e. how many rows in each)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train.shape  # Display shape of training dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(183101, 1)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.shape   # Display shape of testing dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train the model using scikitlearn [LinearRegression]( \n",
    "https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html)\n",
    "\n",
    "Your feature must be numeric - there are many techniques you can use to convert non-numeric data into numeric data for training.\n",
    "\n",
    "Your training data cannot contain any missing values in rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "regressor = LinearRegression()     # Create a scikit learn LinearRegression object\n",
    "regressor.fit(X_train, y_train)    # Use the fit methong to train the model using your training data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what arrival delays are predicted for our test data by using the **predict** method of our linearRegression object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = regressor.predict(X_test)  # Create predictions for all our test data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare the actual arrival delay times and the predicted arrival delay times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'pd' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-e9e0387925af>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mresults_df\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m'Actual'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0my_test\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mflatten\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'Predicted'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0my_pred\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mflatten\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mresults_df\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhead\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'pd' is not defined"
     ]
    }
   ],
   "source": [
    "results_df = pd.DataFrame({'Actual':y_test.flatten(),'Predicted':y_pred.flatten()})\n",
    "results_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do some calculations to get a sense of overall accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean absolute error:  20.25653001742976\n"
     ]
    }
   ],
   "source": [
    "print('Mean absolute error: ',metrics.mean_absolute_error(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Squared Error: 1774.0880095844536\n"
     ]
    }
   ],
   "source": [
    "print('Mean Squared Error:', metrics.mean_squared_error(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Root Mean Squared Error: 42.11992414029795\n"
     ]
    }
   ],
   "source": [
    "print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test,y_pred)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the slope and intercept of the linear regression graph (think back to high school physics y = ax+b what is a and what is b)\n",
    "the interceptor is the intercept (b)\n",
    "the coef is the slope (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.62692537]\n"
     ]
    }
   ],
   "source": [
    "print(regressor.intercept_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.00101446]]\n"
     ]
    }
   ],
   "source": [
    "print(regressor.coef_) #Slope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets show a graph with the predicted linear regression and our test data all in one graph to visualize what is being predicted (in red) vs actual values (in grey)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEKCAYAAAAFJbKyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3X98HHd95/HXR7KUCEiUpDYhDXHtcOIgqTBJBKSFtqGiISIIuy5QKMUp0Aul4VpDe2m43mEU2iukV2qglDbQHHEbfhVkO8EIEtQQevRCIiWYzS9qNw7GxM0PQpSUCP+QPvfHzMir1c7szGpnf76fj4ce2p2d3fnOWv5+Zr4/Pl9zd0RERNLqanQBRESktShwiIhIJgocIiKSiQKHiIhkosAhIiKZKHCIiEgmChwiIpKJAoeIiGSiwCEiIpmsaHQB8rBy5Upfs2ZNo4shItJSpqenH3X3VZX2a8vAsWbNGqamphpdDBGRlmJm30uzn5qqREQkEwUOERHJRIFDREQyUeAQEZFMFDhERCSTthxVlbdCocDk5CQzMzP09/czPDzM4OBgo4slIlIXChwZFQoFbrjhBo4cOQLAzMwMN9xwA4CCh4h0BDVVZTQ5ObkQNCJHjhxhcnKyQSUSEakvBY6MZmZmMm0XEWk3ChwZ9ff3Z9ouItJuFDgyGh4epqenZ9G2np4ehoeHG1QiEZH6Uud4RlEHuEZViUinUuCowuDgoAKFiHQsNVWJiEgmChwiIpKJAoeIiGSiwCEiIpkocIiISCa5BQ4zO8PMbjaze83sbjP7/XD7KWZ2k5ntCX+fHG43M/uIme01s++Y2blFn3VJuP8eM7skrzKLiEhled5xHAX+wN2fD5wPXGZmZwFXAJPuPgBMhs8BRoCB8OdS4OMQBBpgC/AS4MXAlijYiIhI/eUWONz9oLvfET5+ErgXOB1YD1wb7nYtsCF8vB7Y5oFbgZPM7DTglcBN7v6Yu/8IuAm4KK9yi4hIsrr0cZjZGuAc4FvAqe5+EILgAjwz3O104PtFbzsQbovbLiIiDZB74DCzZwBfBDa7+xNJu5bZ5gnbS49zqZlNmdnUI488Ul1hRUSkolwDh5n1EASN69x9PNz8UNgERfj74XD7AeCMorc/G3gwYfsi7n61uw+5+9CqVatqeyIiIrIgz1FVBvwdcK+7f6jopeuBaGTUJcDOou2bwtFV5wMzYVPWV4ELzezksFP8wnCbiIg0QJ5JDl8KvBkomNm3w23/HfgA8HkzexuwH3hd+NqXgVcBe4GngLcAuPtjZvZ+4PZwvyvd/bEcyy0iIgnMfUl3QcsbGhryqampRhdDRKSlmNm0uw9V2k8zx0VEJBMFDhERyUSBQ0REMlHgEBGRTBQ4REQkEwUOERHJRIFDREQyUeAQEZFMFDhERCQTBQ4REclEgUNERDJR4BARkUwUOEREJBMFDhERyUSBQ0REMlHgEBGRTBQ4REQkEwUOERHJRIFDREQyUeAQEZFMFDhERCQTBQ4REclEgUNERDJR4BARkUwUOEREJJMVSS+a2c8Bvwn8AnAaMAvcBewC/sHdZ3IvoYiINJXYOw4zmwB+G/gqcBFB4DgL+B/A8cBOM3tNPQopIiLNI+mO483u/mjJtv8A7gh//sLMVuZWMhERaUqxdxxR0DCzp5tZV/j4uWb2GjPrKd5HREQ6R5rO8W8Ax5vZ6cAk8BbgU3kWSkREmleawGHu/hSwEfiou/8qQV+HiIh0oFSBIxxd9SaC0VRQYTSWiIi0rzSBYzPwHmC7u99tZmcCN+dbLBERaVYV7xzc/RbgFjN7evj8fuD38i6YiIg0p4p3HGb2c2Z2D3Bv+Hydmf117iUTEZGmlKapaivwSuCHAO6+G/jFSm8ys2vM7GEzu6to2/vM7Adm9u3w51VFr73HzPaa2XfN7JVF2y8Kt+01syuynJyIiNReqlxV7v79kk1zKd72KYIZ56X+0t1fGP58GcDMzgLeAJwdvuevzazbzLqBjwEjBCO53hjuKyIiDZJmdNT3zeznATezXoL+jXsrvcndv2Fma1KWYz3wWXc/BOwzs73Ai8PX9ob9KpjZZ8N970n5uSIiUmNpAsfvAB8GTgcOADcCv7uMY77TzDYBU8AfuPuPws++tWifA+E2gO+XbH/JMo7dsQqFApOTk8zMzNDf38/w8DDAkm2Dg4MNLqmINLs0geM/u/ubijeY2UuBb1ZxvI8D7wc8/P0XwFsBK7OvU74pzct9sJldClwKsHr16iqK1r4KhQI33HADR44cAWBmZoYdO3ZgZszNzS1su+GGGwAUPEQkUZo+jo+m3FaRuz/k7nPuPg98gmPNUQeAM4p2fTbwYML2cp99tbsPufvQqlWrqile25qcnFwIGpH5+fmFoBE5cuQIk5OT9SyaiLSg2DuOcLb4zwOrzOzdRS+dCHRXczAzO83dD4ZPf5VgbQ+A64FPm9mHgJ8GBoDbCO5EBsxsLfADgg7036jm2M2gXHNRPa7uZ2bSL5uSZV8R6UxJTVW9wDPCfU4o2v4E8NpKH2xmnwEuAFaa2QFgC3CBmb2QoLnpAeDtAOGM9M8TdHofBS5z97nwc95JsCZIN3CNu9+d4fyaRrnmono1DfX396cOCP39/bmWRURan7mX7TI4toPZz7j79+pUnpoYGhryqampRhdjka1bt5atvPv7+9m8eXOuxy4NWgBdXV2L+jgAenp6GB0dVR+HSIcys2l3H6q0X5rO8U+Z2ZLo4u6/XFXJOlTcFX89moaiQKBRVSJSC2kCxx8WPT4e+DWC5iTJIK65qF5NQ4ODg2WDggKFiGSVJsnhdMmmb5rZLTmVp20NDw8vaS7q6elZuPJvB7Xu/G/UYAIRSVYxcJjZKUVPu4DzgGflVqI2FddcVM+KMM+KuNad/40cTCAiydI0VU0TjIIygiaqfcDb8ixUu4prLqqHvCvicnNFonkh1Xx+rT9PRGonTVPV2noURPKVd0Vc687/Rg4mEJFkqZaADZMcrine39235VSmtlQoFJiYmGB2dhaAvr4+RkZG6nb1nHdFXOvO/0YPJhCReGkWcvp74H8DLwNeFP5UHOcrxxQKBXbu3LkQNABmZ2fZsWMHhUKhLmWIq3BrVREPDw/T09OzaNtyOv9r/XkiUjtp7jiGgLO80kxBiTU5ObkkLxQE+aLq1Waf96iuWnf+N8NgAhEpL03guItgFNXBSjtKeUnNQfVqs69HRVzrzv9GDiZIS0OGpROlCRwrgXvM7DbgULTR3V+TW6naTFKuqHq22bdCRdxKNGRYOlWawPG+vAvR7oaHh9m5c+eS5qquri612bcwDRmWTpVmOK5miS9TVIk0clSV1J6GDEunSlqP4/+6+8vM7EkWr7pngLv7ibmXroWVa/u+/PLLG10sqSENGZZOFTsc191fFv4+wd1PLPo5QUEjWdT2HVUqUdt3vYbeSn1oyLB0qrQTAE8mWMK1eALgHXkVqtWp7bszaMiwdKo0SQ7fD/wWcD8wH252QOtxxEhq+966dasqlzaikWrSidLccbweeI67H867MO0iafithmyKSKurmHKEYALgSXkXpJ2Ua/suFjVbiYi0ojR3HH8G3Glmd6EJgKmUtn2XoyGbItKq0gSOa4EPAgWO9XFIBVHb99atW3Mfsqm0FyJST2kCx6Pu/pHcS9IislbSeScXVNoLKaaLCKmHVCsAmtmfAdezuKmq44bjVlNJ5z1ks52G/qrSWx5dREi9pAkc54S/zy/a1pHDcautpPMcstkufSiq9JavnS4ipLmlyVX18noUpBU0YyXdLmkvOrnSq9WdVjP+fUp7ih2Oa2a/aWZJrz/HzF6WT7GaU96r6FWjXdJedGqlV8v0NM349yntKWkex08RDMO9xswuM7PXm9kmM7vSzG4BrgIeqk8xm0MzVtKDg4OMjo4uVA79/f2Mjo623FV6p1Z6SXdaWTXj36e0p9imKnf/sJn9FUFfxkuBFwCzwL3Am919f32K2Dzy7OheTnNFO6S9yHv0WbOq5Z2WcmdJvST2cbj7HHBT+CPkU0nHdQzv37+fPXv2dEQl0KmVXq37qNrhIkKaX6rsuJKvuOaKqampheedMMqoEyu9Tr3TktamwNEE0jZLLGeUkeZINKdOvdOS1mbunryDWXfYZNUyhoaGvPhqvRkkVdxxaUmSZKlgSpvCILiqbcVOdBHJj5lNu/tQpf3S3HHsNbMvAP/H3e9ZftE6T6XJbeWaKyqZmZlh586dC+uYJwWSTp4j0U501yjNIk1a9RcA/wp80sxuNbNLzUxLx2YwMTGROOSy3JDaoaGhxNTsAHNzc8zOzgLJ4/87dY5EO9FyxNJM0swcfxL4BPAJM/tF4DPAX4Z3Ie939705l7GlFQqFhcq9VHHFXa5jePXq1Ymp2UvF3UW0y+zyTqa7RmkmaZaO7QYuBt4CrAH+ArgO+AXgy8Bzcyxfy0uayFWp4i4OJmn7Qcrto5E7rU93jdJM0jRV7QHWA3/u7ue4+4fc/SF3/wLwlbg3hTPOHw4XgIq2nWJmN5nZnvD3yeF2M7OPmNleM/uOmZ1b9J5Lwv33mNkl1Z9q7RUKBbZu3crY2Bhbt27N1EwEZKq4K60qWKy0LO0yu7yTderMemlOqfo43P1t7v4vpS+4++8lvO9TwEUl264AJt19AJgMnwOMAAPhz6XAxyEINMAW4CXAi4EtUbBptHJtzuPj41x11VWLKu24/9h9fX2ZKu7Syj9JufbvqBM+araanJxU+3gLUToRaSZpRlUdNbPLgLOB46ON7v7WpDe5+zfMbE3J5vXABeHja4GvA38Ubt/mwdjgW83sJDM7Ldz3Jnd/DMDMbiIIRp9JUe5clWtzBpidna04Yqqnp4eRkZHMx4yarsbGxiruW9r+XYu05RrVU3tpv1PN95BmkiZw/D1wH/BK4ErgTQT5qqpxqrsfBHD3g2b2zHD76cD3i/Y7EG6L276EmV1KcLfC6tWrqyxeeklNUMWVdh7/4eM6u5PKuNzOVa2XUXtZv9NOnFkvzSlNU9V/cvf/CfzY3a8l6Civ9V+vldnmCduXbnS/2t2H3H1o1apVNS1cOZWajEpHTG3evJmNGzdy+PBhxsfHGRsbW9KslVba/o7iMi63c7WWWVwloO9UWlWaO47oL/txM/tZ4N8JRldV4yEzOy282zgNeDjcfgA4o2i/ZwMPhtsvKNn+9SqPXVPDw8OMj4/Hvl4aWAqFAjt37mRu7tgk/NnZWXbs2AFku2ovvYvp6+vj8OHDiz67tP17uUNy6zGqp9OawjRSSlpVmjuOq8MO6f9JsO74PQRrcVTjeiAaGXUJsLNo+6ZwdNX5wEzYpPVV4EIzOzksw4XhtoYbHBykr68v9vXSTsvJyclFFXtkfn6+qivM6C5my5YtXH755axfvz5x1NRyO1fzHtXTiRPcNFJKWlWaCYCfDB/eApyZ9oPN7DMEdwsrzewAweioDwCfN7O3AfuB14W7fxl4FbAXeIpgzgju/piZvR+4PdzvyqijvBmMjIyUTRUyNDS05Eo56SqyFleYldq/l9vXkvdckE6c4Kb5NdKqYgOHmb076Y3u/qEKr78x5qUl/yvC0VSXxXzONcA1ScdqlCyVcVKHdr2uMJfbubpixYqFSq6vr4+RkZGaVeqd2GyjkVLSqpLuOE6oWyla2P79+3niiSeA5FExw8PDS/o4ALq6upr+CrNcdt2jR4/W9BidmhZFI6WkFSUtHVt5skCH27VrF6Xp248cOcL4+Djj4+OLriCjyiHKZgtLr9p37drF9PQ07o6Zcd5553HxxRfX96TKqEczkpptRFpHmlxVzyWYyX2qu/+smb0AeI27/0nupWty09PTia+X3oEkXV2WBiF3X3je6OBRj2YkNduItI40w3E/Afw34G8B3P07ZvZpoOMDR6VFsCC4Mp+YmGBwcDBxuGlcEJqenm544KhXM5KabURaQ5rA8TR3v81s0Vy82jZwt7nZ2Vl27drF7t27Y2cJxwWhNMEJ0s+BqGauhJqRRKRYmsDxqJk9h3DGtpm9FjiYa6naUNR3UaxW/QRpU1dUmzakls1InTbJr9H0fUse0gSOy4CrgeeZ2Q+AfcBv5lqqNhR35xA1AfX09JRNmlg6aa9cRZC283o5ndy1aEZSvqv60vcteak4c9zd73f3VwCrgOe5+8vc/YHcS9ZmSpr6FkT9BKOjo2X3Wbdu3cLjuNnVaTuvGz1XQrmZ6kvft+Ql8wTAqHKrNAFQjunp6WHdunWL+jii7VE/weDgIHfeeSf79u1b9N4777yT1atXMzg4GFsRmFnZO5rSlCiNnivR6MDVafR9S16S7jhOCH+GgHdwLM357wBn5V+01hYF2Chv1MUXX5y4Cl+hUFgSNADm5uaYmJgA4v/Duzvd3d1Lth86dGhRrqdGLwak3Ez1pe9b8lJxAqCZ3Qic6+5Phs/fB/xjXUrXwk488cSFjshoidmoX2Ljxo1L2piTmg+iCYNJdwyHDx9e2C8SJVCMjtXouRIanVVf+r4lL2my464GDhc9P0z1adU7RtT/sGvXrlRZX9M0HyTdMZQGjeLPbZYlZLX2eX3p+5a8pF0B8DYz204wJPdXCZZ9bWuVhjGmqWyPHDmyJCVJtL10JFNSEsSor6LcOhwA4+Pjsf0cwKKRNPUaaRP3/WmSX33p+5Y8pBlV9acEac5/BDwOvMXd/yzvgjVSpbUhdu3albiIUxqlQWJ4eDh25NXZZ5+98Lh4NcGjR48u3GkkTRQsHklTj5E2nbi2hkgnSXPHgbvfAdyRc1maRqXKtdxdRFalHZSDg4OLEiAW27NnT6oyJimuxJNer4VOXFtDpJOk6ePoOEmVay2uzOM6KJP6KdJsS1Lczp30ei1oGKhIe1PgKCOpcq1U+ZV2Xpf7jLgOyiyVepaKvjhQ1WNIroaBirQ3BY4y4irXgYGB2H4IgO7ubkZHR9m4cWPZ92/cuJHNmzfHNtdkqdTL7VtOaaCqx0ibRs8XaYRoyPXY2Bhbt25Vf460NYvrVDWzJwkTG5a+RLDa64l5Fmw5hoaGfLn9EKWjggYGBpbM/C6nv7+fzZs3lx1VBJXnUGRJSlcoFNi+fXtsx3hUlkbopOR65VZI7Onp0dBXaTlmNu3uQxX3S5u2u5XUInCUiibwpRUNjy0OGnlULmNj8Qs1lptoWI16BIFWDjRxfxuNDNwi1UgbOFKNqgo/8JnA8dFzd99fZdlaUtaO3Sggz8zMsGPHDtw9l7Tqcf0ufX19NQsaec/7aPUsrhoMIJ2mYh+Hmb3GzPYQpFO/BXgAmMi5XE1nOR278/PzFdOqVyuuP2FkZCT2PVna4+sx76PVs7hqMIB0mjR3HO8Hzge+5u7nmNnLgTfmW6zmMzw8zI4dO5ifn1+0va+vL3YYbRr9/f2Lmml6e3s5fDjI8GJmnHfeeYlLx0ZX5MVzQFasiP9nzXp1X4+r6Va/YldOKOk0aQLHEXf/oZl1mVmXu99sZh/MvWRNqHREVXd3NyMjIwwODmbuA4FjI7WKK50oaEDQ3DU1NcUPf/hDNm3alPhZR48eW813dnY2NhiknZwXBbM4tbyabnS69zhp+10anTxSpN7SBI7HzewZwDeA68zsYTpwzfHJyUnm5uYWbZubm1uocMtddSYxM0ZHR1PNAN+3bx+FQiG2IooLBtu3bwcWB480V/flRgkVq/XVdDNesWe9M1NOKOkkaQLHemAWeBfwJqAfuDLPQjWjShVu6VVnNKqqr6+Pw4cPLwo6xaOp0ua8KhcEKpXN3Rcqu6hscYqv7pOCWTVX05Wu3Jvxil1pU0TipQkclwL/6O4H6ICsuOUkdR4XV7hxV51JFWea2egQBIGdO3cuHKe0DHGfceTIESYmJjh69GjqO4ik8mQdXpr2yj3NFXs9h+wmXSiMjY2lmmPTTIFQpJbSBI4Tga+a2WPAZ4EvuPtD+RaruSRdqc/MzLB169bEiiGpUszSxBWtBlj6WcPDw+zcuXNJU1okqfO+XKVWyz6HWl2513vIbqWAnnT8Vh9eLFJJxcARrgQ4ZmYvAH4duMXMDrj7K3IvXQMVCoXYbLWlSiuGpKvNcq9FfR0zMzN0d3fHBgAoHwSSMutWUu4Ooto+h3LnVqsRU/VuOkoT0OOOr2YuaXepJwACDwP/DvwQeGY+xWkOhUKh7NDbJFFndGmfxczMDOPj44yPj9PX18ehQ4cWPjd6DVi0pGyhUMi83kdS0Ihb5Cku71Y1fQ5xV9lxw5Wz3r3UY8huaeBbt24de/bsqXjn0YiyijRSxcBhZu8guNNYBXwB+C/ufk/eBWukycnJTEEjUil9S1LlXnrXEncHEa36VyppBnnccd09drRW1lFCcVfZK1asoKenZ8lrAwMDqT8bkpuOkkacpVUu8O3evXthEENSWpG0ZW308GKRWkmTHfdngM3ufra7b2n3oAGNuzIsni09MjJCV9fif56urq7YGeHlKuJo/6QKq9zKfNVkeo37zmZnZ1m3bt2S7bt3786UQTapmawWM8wrzV5fbubiRg8vFqml2MBhZlH226uA/WZ2SvFPfYrXGI28MoxG7UxOTnLuuecuSn++YcOG2FFb09PTsZ+ZlIK9NLVHtCxu1mVfk9JulFvBMGtKkaQ7iloE+jTDrdOmo69H6nqRRkpqqvo08GpgmiC9enGDuANn5liuhopLL1JPMzMzTE1NMTQ0lJhyBIJ0I+Wayebn55mYmKC3tzexkzeqHAuFQtllcdN07CZ1qMf111SzimFeTUBpPjtL850mBEo7iw0c7v5qC3pPf6nTMuGWy//UKFNTU6xevTqxEkoq4+zsbMVziCrHSsOOkyR1qEfb4o6bVp4zzOs5e11zPKTVJXaOu7ub2XbgvFoe1MweAJ4E5oCj7j4UNn99DlhDkIH39e7+ozB4fRh4FfAU8Fvufkcty1NO6RXjtm3b2LdvX96HLSuq0POobIorx6TgUKmST6oMa1Up5znDPO/Z68XfTzHN8ZBWlGY47q1m9iJ3v73Gx365uz9a9PwKYNLdP2BmV4TP/wgYAQbCn5cAHw9/102hUGhY0ICgcime4FfLyqY4k27SyKWkSr7ShLdaVsp5NgHl9dmVcn9pjoe0mjSB4+XA283se8CPObZ07AtqXJb1wAXh42uBrxMEjvXANg8a8W81s5PM7DR3P1jj48dqhnUhSicFxs0byao4k27cpLehoaHESi3NhLdObvNPk8hSczyklaQJHPErAlXPgRvNzIG/dfergVOjYODuB8MVBwFOB75f9N4D4bbcA0dc80KzqNWyv1E+q6gTvXTZ20oVfi0nvLVj+3+a78HMUuXAEmkGiYHDzLqAXe7+szU+7kvd/cEwONxkZvclFaPMtiU1ppldSpCQkdWrVy+7gJWaF9pNcSe6uy/0QaRJ2lhugh8k94uUCxBAQ3M85RW00iSyLF5qWH0e0uwqdY7Pm9luM1tdy5FV7v5g+PvhsPP9xcBDUROUmZ1GkOIEgjuMM4re/mzgwTKfeTVwNcDQ0NCyL8XTNC+0s7h293L9GeV0dXUxMDCwMOO6+C5mYGCA3bt3LwkQK1asaFiOpzwTEyblvSqXDkZ9HtLs0swcPw2428wmzez66KfaA5rZ083shOgxcCFwF3A9cEm42yXAzvDx9cAmC5wPzNSjfyPpCjEu7Ue7KfcdpA2o3d3d3HHHHQufUXxFPTU1VTZAxA0brkdTYZ7rnpebELhx40a2bNmS21r0InlK08cxVuNjngpsDxPsrQA+7e5fMbPbgc+b2duA/cDrwv2/TDAUdy/BcNy31Lg8ZSXlfvrJT35SjyI0XLmmprQVWi3v1uoxkz+pn6ZS2vw04gYHKK+VtKKKdxzufkvxD8Gysa+v9oDufr+7rwt/znb3Pw23/9Ddh919IPz9WLjd3f0yd3+Ouw+6+9KpzTmIS9MxOztbs07pJF1dXQt3Nn19fQuP+/v763bHU24Ibr0rtHrleEo6r7RpV6qhvFbSitI0VWFmLzSzq8KJe38C3JtrqZrA4OBg2eR89dDX14eZLTTdlM7+rtds9nJXyMPDw0uSL5aKy4uVVV9fX91yPA0PD9Pd3R37eq2arUopr5W0otimKjN7LvAG4I0Ea3B8DjB3f3mdytZQlRIH5qlS+vV6WM6dxbp167j77rsTz2NoaKjiWhf1bBJMsxhWXt99J89xkdaU1MdxH/DPwKi77wUws3fVpVQNFo2wqUeTVDNKaiqZmJiomPxxz549nH322WUTJkaixI1Ji1a5e12HpqbN6ZWkdEjvwMDAQoDUHA1pF0ltDr9GsOLfzWb2CTMbpvycirbT6kNxS1f2i1vpL+695ZpKojU60i6lmxQ0SjPOJvXZHDlyhPHx8dTrgixHUmBIu3TuDTfcsCgl/dTUVOYU9SLNLik77naC0U9PBzYA7wJONbOPA9vd/cY6lbHuWn0oZPGdUk9PDytWrEjdL+LuS9ZNL13ydjnKVcAjIyMVJ1vOzMywY8eOheakPK7e4+Zb9PX1MTIyUnEyZNwSvcU0R0PaQcXhuO7+Y+A64Lowg+3rCBIQtm3gSFMBtIojR45kvnsaG1s8AruWnfHl7mai59u3b0/83ufn5xfKkscM66zJGEsnDab9m2n1CxORNPM4FoRDZP82/GlLhUKhbYJGvaVJrTE+Ps74+Piiq/joqj3r95731fsTTzzB+Pg4k5OTZQNItU2aaQcetGPeLmkPmQJHJ2iGTLi11tfXx9GjR3Ptt+nu7mZ4eDj14lezs7Ps2LGD/fv3L0o/klUtr97j7iDi7m6qOXbUVFcpKBQKhUWrUEZNdaVlEGkEBY4S7diMUKv+iSRzc3OMj49n6oifn5+P7USPS5xYqpYTEpPuIKIMwsWVdpo7rN7eXrq7uxf1y8DSZI7RnVi0T7nRa9FSwAoc0mgKHCXaqX8jUs+102uZ6r23t5fDhw8n7vfUU09RKBQqVqZpmn0qBYHZ2dlFx0qzNv3hw4fp6elh48aNC+/bunVrbICK7m7iXm/0UsYioMCxRLsFjVZWKWhAEGCiJq9ovkTpeiKQLl17mjuI0j6VNEG5tC+m0jFaeSgnQINxAAAQaElEQVS4dIZUKUc6SZamFmkOUZNXuUy8URNQmsy3cfnJihVX+ln6w4rfpwSG0up0x1FCdxydo9yVf7k1QYoVV/pZ+sP6+voW1iZJyomV5nNEGk13HCV0x9E5ioNAoVBg+/btFfsQiicvZrlzmJ2dXQg0pevHl+rq6mJoaGhJMsmuri5GRvJYyVkkGwWOErrj6AylM9jT5Cbr6+tb1L+RV+rz4447josvvpgNGzYsypq7YcMGjaiSpqCmqhLtOKpKFiuXQiRNh/Tc3BxjY2OLkhfmIbrrUdbcYzQZsrnojqOEgkbrq9Tc2NvbW1WlE43yKk1emIcrr7ySXbt25fb5raRc8kgli2wsBY4SGvHS+lasWEFvb2/s6+Uq/Gbr23J3pqamFDzIdz14qY6aqkoMDAwkpgSX5lep2am/v39J08eaNWvYt29fnUqY3tTU1MLf49q1a9m0aVNDy9OIJqOk9eClMRQ4Stx9992NLoLk7JRTTlkyIbAVKqF9+/axbdu2hgWP0lxeeWQoLiduYqZaB46pd0BX4CihlA7trxnvLNJqZNnjmoy2b9++KM9WrSusuFaAgYGBmh6nVTUioCtwiLSxWl6Jxt2VVcoivFxxo9fyGtXWapL6gPIKHOocF2lTtR6NlKZpKI9Oa/VxJGvE96PAIdKmaj0aKU0uL6h9hRWXZkV9HIG47yHP70eBQ6TFpL1jqPWV6ODgIKOjowsVUtwQ5lpWWIVCgUOHDi3ZHi0cJuUDemlmhFpT4BBpMePj42zdurViAMn7SvT4449fkk+r1hXW5ORk2dT11U7ibEelAb2/v5/R0VGNqhKRxdJ0RNd6NFLp6J3Z2Vm6u7vp6+tbtMLhcius4g79OBr9uFi909MocIi0qEojZ2o9Gqlcn8nc3By9vb1cfvnlVX1mqdLgFKfZZvp3GgUOkRZWelWe5mq92j6OeozeSVr3vZhyyjWWAodICyteIKqvr49Dhw5VXM622j6OuBncZraQNXi5TVVpg5BGVDWWOsdFWljxAlGzs7MVg8ZyRiMNDw8v6QyHpRMAl5O1Nm1A0KzxxtIdRxGlaZZ2l3cTz3JnLA8PD6fq4yjup9m1axfT09O4O2bGeeedx8UXX1zV8SUdBY5Q1Ckn0s7m5+errtgnJiYq3tHA8vo8onKl7afZtWvXopFjUTp6YFnBQ8EomQJHKG2nnEirq7ZiTzsEdrn9D8VDS6+88sqyd0nRqKrp6emynzE9PV11RZ9XMMpToVBgYmJi4d+o3CqXtaTAEVLeG+kUcSk8amW5/Q/btm2rmAU4CiZxTW/LaZJbbjCqd4rzQqHA+Pj4om2zs7Ps3LkTyCdDbssEDjO7CPgw0A180t0/UMvPjxsxItJuZmdnGRsby9wEE030q2Rqaoo9e/ZUVWGmCRp5KG6aipMmGBUKBXbu3Mnc3BwQXJDmWYFD0IRYztzcXG4ZclsicJhZN/Ax4FeAA8DtZna9u99Tq2MMDw8vidoi7SxrE8yznvWs1JX6zMzMwv+nLBVXlqCxbdu21PsmKW2aWo6JiYmFoBGZm5tjYmKi6gq80h1MUjDP62K4JQIH8GJgr7vfD2BmnwXWAzULHDfeeCNdc3O84qabeNHttwPgRbNTo8flthU/7vvJT2pVpCUeO/nkisfX6+lfxwwvfVxuW5u/brfdBg88AGbHfsLXix+f/KUvcRJk+vx/u+ceBtevX/zZMZ+PGc+79970n79nD89Jen1ycumxyhzzoS9+kTPSfn/T04nlP+GBB3hGzPu5776KZSl9/b7vfpdbvvY1/OhRTgDmZ2a4+R/+gRUXXsjzzzoLzHj6k08uOtZTT3salBk2XUvWCjMwzey1wEXu/tvh8zcDL3H3d5bbf2hoyLNeQYyNjXHG/v289Zprll1eEZFGOfisZ3H129++EIi2bNmS+r1mNu3uQ5X2a5UJgOUS0yyKeGZ2qZlNmdnUI488UtVBfnD66Uyfd15V7xURaQZPPe1puR+jVZqqDgBnFD1/NvBg8Q7ufjVwNQR3HNUcZL67my+NjvKl0dFqyynScoaGhlL1cYyNjVX1+VmueKs9xnKOm+WYlT4z6bOyfA+RKJ1Mqf7+fjZv3lzxmHlplTuO24EBM1trZr3AG4DrG1wmkZZmZqmDRjtLs6phozRikaY0WuKOw92Pmtk7ga8SDMe9xt3vbnCxRFrae9/73kYXoSmMjo6yffv2psy4WzqTvh7zQtJoicAB4O5fBr6c1+cfd9xxZZeoFJHAypUrefTRR3M9xtq1a+s+jyNtmpNyCR7rYTmLNOU12bNVmqpyd8UVV3Dcccc1uhgidbF27drM77nssstyP86mTZtSv6erq4ve3t6yr8VtjzM4OMjmzZvZsmULGzduLLvPhg0bKn5OrcqTxdBQ/CCokZGRXI7ZEsNxs6pmOG6k3PR9kVZmZouaYdauXcumTZuq+qzSmdEQpGpfv349d95556K7heUcp/h4cc1IUQW/Y8eORckXu7q62LBhw7Kac6pNG1IoFHIpTyWlM997enqqWnc87XBcBY4yyi1fGf1D7N+/v2JqgjhdXV2psosuR72b3Jqxia+np4d169axe/futk9cuXbtWh544IGFLK5r1qzhsccey7U9vBG5mJIS+NW7PGnK20zlyUKBo0YpBBpluX98ld4fN8wPjl2hpj3uxz72sUVt3ytXrkxs1ohL8dDb28vhw4cb/p8tTabRcrmNou8ty/dX7ruI+/5auUKS1qDA0eKBI29Jd1X1qIy03oFI81HgUOCoSFewIlIsbeBomeG4UnvLGeYnIp1Lw3FFRCQTBQ4REclEgUNERDJR4BARkUwUOEREJJO2HI5rZo8A36virSuBfLO4NZ9OPGfozPPuxHOGzjzvas/5Z9x9VaWd2jJwVMvMptKMYW4nnXjO0Jnn3YnnDJ153nmfs5qqREQkEwUOERHJRIFjsasbXYAG6MRzhs487048Z+jM8871nNXHISIimeiOQ0REMlHgAMzsIjP7rpntNbMrGl2e5TKza8zsYTO7q2jbKWZ2k5ntCX+fHG43M/tIeO7fMbNzi95zSbj/HjO7pBHnkpaZnWFmN5vZvWZ2t5n9fri9bc/bzI43s9vMbHd4zmPh9rVm9q2w/J8zs95w+3Hh873h62uKPus94fbvmtkrG3NG2ZhZt5ndaWZfCp+39Xmb2QNmVjCzb5vZVLitMX/f7t7RP0A38G/AmUAvsBs4q9HlWuY5/SJwLnBX0bargCvCx1cAHwwfvwqYAAw4H/hWuP0U4P7w98nh45MbfW4J53wacG74+ATgX4Gz2vm8w7I/I3zcA3wrPJfPA28It/8N8I7w8e8CfxM+fgPwufDxWeHf/XHA2vD/Q3ejzy/F+b8b+DTwpfB5W5838ACwsmRbQ/6+dccBLwb2uvv97n4Y+CywvsFlWhZ3/wbwWMnm9cC14eNrgQ1F27d54FbgJDM7DXglcJO7P+buPwJuAi7Kv/TVcfeD7n5H+PhJ4F7gdNr4vMOy/0f4tCf8ceCXgS+E20vPOfouvgAMm5mF2z/r7ofcfR+wl+D/RdMys2cDFwOfDJ8bHXDeZTTk71uBI6hcvl/0/EC4rd2c6u4HIahkgWeG2+POv2W/l7Ap4hyCK/C2Pu+wuebbwMMElcC/AY+7+9Fwl+LyL5xb+PoM8FO02DmHtgKXA/Ph85+i/c/bgRvNbNrMLg23NeTvWws5BbdypTppqFnc+bfk92JmzwC+CGx29yeCC8vyu5bZ1nLn7e5zwAvN7CRgO/D8cruFv9vinM3s1cDD7j5tZhdEm8vs2lbnDbzU3R80s2cCN5nZfQn75nrOuuMIIu4ZRc+fDTzYoLLk6aHwVpXw98Ph9rjzb7nvxcx6CILGde4+Hm5u+/MGcPfHga8TtGefZGbRRWFx+RfOLXy9n6BJs9XO+aXAa8zsAYKm5V8muANp6/N29wfD3w8TXCS8mAb9fStwwO3AQDgio5eg8+z6BpcpD9cD0QiKS4CdRds3haMwzgdmwlverwIXmtnJ4UiNC8NtTSlss/474F53/1DRS2173ma2KrzTwMz6gFcQ9O3cDLw23K30nKPv4rXAP3nQY3o98IZw9NFaYAC4rT5nkZ27v8fdn+3uawj+v/6Tu7+JNj5vM3u6mZ0QPSb4u7yLRv19N3qkQDP8EIxA+FeC9uE/bnR5anA+nwEOAkcIrjDeRtCmOwnsCX+fEu5rwMfCcy8AQ0Wf81aCDsO9wFsafV4VzvllBLfc3wG+Hf68qp3PG3gBcGd4zncB7w23n0lQAe4F/hE4Ltx+fPh8b/j6mUWf9cfhd/FdYKTR55bhO7iAY6Oq2va8w3PbHf7cHdVTjfr71sxxERHJRE1VIiKSiQKHiIhkosAhIiKZKHCIiEgmChwiIpKJAoeIiGSiwCEdw8zmwpTUd1uQivzdZtYVvjZkZh9JeO8aM/uN+pV2yfH7zOyWMDfVBVEq8So/67NmNlDL8klnUeCQTjLr7i9097OBXyGYILgFwN2n3P33Et67BmhY4CCYtDXuQW6q5fo4QYJAkaoocEhH8iDfz6XAO8O0DAtX8Wb2S+GdybctWCjoBOADwC+E294V3oH8s5ndEf78fPjeC8zs62b2BTO7z8yuC9OhYGYvMrN/Ce92bjOzE8I7iD83s9vDBXfeHlPkN3EsncSC8DPvNLMzzex9Znatmd1owaI/G83sKgsW//lKmMsL4J+BVxTldRLJRH840rHc/f6wqeqZJS/9IXCZu38zzLb7E4JFcv7Q3V8NYGZPA37F3X8SNvt8BhgK338OcDZB8rhvAi81s9uAzwG/7u63m9mJwCxBOpgZd3+RmR0HfNPMbvRgfQjCY/USpMl4oLiQYbD6KLDe3feH8ek5wMsJFin6f8CvufvlZradYP2KHe4+b2Z7gXXA9PK+RelEChzS6cqlmf4m8CEzu46geeiALU3P3gP8lZm9EJgDnlv02m3ufgDAgrUy1hCsAXHQ3W8HcPcnwtcvBF5gZlFyvn6CZHv7ij5vJfB4yfGfD1wNXOhh1tTQhLsfMbMCweqWXwm3F8JyRB4GfhoFDqmCAod0LDM7k6DSf5iidSzc/QNmtougD+RWM3tFmbe/C3iI4Kq9i+CuJHKo6PEcwf8zo/y6Bwb8V3dPylA6S5Cor9jBcNs5LE6LfSg8h3kzO+LHktHNs/j/+/Hh54pkpj4O6UhmtopgXeq/8pJMn2b2HHcvuPsHgSngecCTBGuZR/oJ7iDmgTcTXN0nuQ/4aTN7UXiME8I+hq8C74j6H8zsuWHa7AUeLPHZbWbFweNxgqan/2XHFjPK4rkEWVZFMtMdh3SSvrDpqAc4Cvw98KEy+202s5cT3C3cA0wQXLEfNbPdwKeAvwa+aGavI1gH4sdJB3b3w2b268BHw7UzZgnWz/gkQRPSHWEn+iMcWze62I0EqeO/VvSZD5nZKDBhZm9N9Q0AZnYqwQizg2nfI1JMadVFWoCZnQO8293fXIPPehfwhLv/3fJLJp1ITVUiLcDd7wRuNrNKTWJpPA5cW4PPkQ6lOw4REclEdxwiIpKJAoeIiGSiwCEiIpkocIiISCYKHCIiksn/B7m0UMtTwzIfAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X_test,y_test,color='gray')\n",
    "plt.plot(X_test,y_pred, color='red',linewidth=2)\n",
    "plt.xlabel('Distance (km)')\n",
    "plt.ylabel('Arrival delay (minutes)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hmmmm those results don't look very good, maybe we should see if there is a correlation between the distance and arrival delay, i.e. does arrival delay tend to increase or decrease as distance of flight changes?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "min_flight_data_df.plot(x='DISTANCE',y='ARR_DELAY',style='o')\n",
    "plt.xlabel('Distance (km)')\n",
    "plt.ylabel('Arrival delay (minutes)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well that accounts for our lousy results, there is not a clear increase or decrease in the arrival delay as distance increases or decreases!  There are short flights with big delays and long flights with small delays and vice-versa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maybe we should try training a model using a different feature! Let's check if there is a correlation between departure delay and arrival delay\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "flight_df.plot(x='DEP_DELAY',y='ARR_DELAY',style='o')\n",
    "plt.xlabel('Departure delay (minutes)')\n",
    "plt.ylabel('Arrival delay (minutes)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now THERE's a correlation, you can clearly see higher departure delays results in higher arrival delays. Let's see what results we get if we train a model to predict arrival delay based on the departure delay."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min_flight_data_df = flight_df[['DEP_DELAY','ARR_DELAY']]  # Create dataframe with only features and labels\n",
    "no_missing_values_df = min_flight_data_df.dropna(axis=0,how='any') # Remove rows with missing values\n",
    "X = no_missing_values_df['DEP_DELAY'].values.reshape(-1,1) # Create dataframe containing feature DEP_DELAY\n",
    "y = no_missing_values_df['ARR_DELAY'].values.reshape(-1,1) # Create dataframe containing label ARR_DELAY\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.30, random_state=42) # split into test and training data\n",
    "regressor = LinearRegression()                             # Create linear Regression object\n",
    "regressor.fit(X_train, y_train)                            # Train model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run your test data through the model to predict arrival delays and compare values for actual and prediced arrival delay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "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>Actual</th>\n",
       "      <th>Predicted</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-13.0</td>\n",
       "      <td>-10.174140</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-24.0</td>\n",
       "      <td>-9.168756</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100.0</td>\n",
       "      <td>65.229722</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-8.0</td>\n",
       "      <td>-11.179525</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-19.0</td>\n",
       "      <td>-11.179525</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Actual  Predicted\n",
       "0   -13.0 -10.174140\n",
       "1   -24.0  -9.168756\n",
       "2   100.0  65.229722\n",
       "3    -8.0 -11.179525\n",
       "4   -19.0 -11.179525"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred = regressor.predict(X_test)  # Create predictions for all our test data\n",
    "results_df = pd.DataFrame({'Actual':y_test.flatten(),'Predicted':y_pred.flatten()})\n",
    "results_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "let's measure the accuracy of our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean absolute error:  9.033505526602951\n"
     ]
    }
   ],
   "source": [
    "print('Mean absolute error: ',metrics.mean_absolute_error(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Squared Error: 163.26825261343365\n"
     ]
    }
   ],
   "source": [
    "print('Mean Squared Error:', metrics.mean_squared_error(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Root Mean Squared Error: 12.777646599175986\n"
     ]
    }
   ],
   "source": [
    "print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test,y_pred)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's visualize the predicted vs actual values - predicted values in red, actual values in gray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X_test,y_test,color='gray')\n",
    "plt.xlabel('Departure delay (minutes)')\n",
    "plt.ylabel('Arrival delay (minutes)')\n",
    "plt.plot(X_test,y_pred, color='red',linewidth=2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "If we know the departure delay we can predict with some confidence the arrival delay.\n",
    "\n",
    "This particular model is not likely to revolutionize air travel. I think we could have guessed that if a flight leaves 30 minutes late it's likely to arrive around 30 minutes late, and a flight that leaves 500 minutes late will arrive around 500 mintues late which is approximately what this model predicts."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}