{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Challenge 1\n# Airplane delay: Analysis and Prediction\n\nNicolas SERVOT, Paul MICHEL\n\nGroupe 3\n\n","metadata":{}},{"cell_type":"markdown","source":"### Imports","metadata":{}},{"cell_type":"code","source":"! pip install scikit-learn==0.21\n! pip install hypopt","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import sys\nimport json\nimport warnings\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport matplotlib.dates as mdates\nimport seaborn as sns\nimport tensorflow as tf\nimport numpy as np\nimport tensorflow_probability as tfp\n\nfrom sklearn.impute import SimpleImputer\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import mean_squared_error\nfrom sklearn.linear_model import Ridge\nfrom sklearn.preprocessing import StandardScaler\nfrom hypopt import GridSearch\nfrom matplotlib import rc \nimport math\n\nplt.rcParams.update({'font.size': 5})\n\nif not sys.warnoptions:\n    warnings.simplefilter(\"ignore\")\n\nrc('figure', **{'dpi': 200})\npd.set_option('display.max_columns', None)  ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Loading data","metadata":{}},{"cell_type":"code","source":"X_dtype = {\n    'ID'                   : int,\n    'YEAR'                 : int,  \n    'MONTH'                : int,  \n    'DAY'                  : int,  \n    'DAY_OF_WEEK'          : int,  \n    'AIRLINE'              : str, \n    'FLIGHT_NUMBER'        : int,  \n    'TAIL_NUMBER'          : str, \n    'ORIGIN_AIRPORT'       : str, \n    'DESTINATION_AIRPORT'  : str, \n    'SCHEDULED_DEPARTURE'  : float,  \n    'DEPARTURE_TIME'       : float, \n    'DEPARTURE_DELAY'      : float,\n    'TAXI_OUT'             : float, \n    'WHEELS_OFF'           : float,\n    'SCHEDULED_TIME'       : float,\n    'AIR_TIME'             : float,\n    'DISTANCE'             : int,\n    'SCHEDULED_ARRIVAL'    : float,\n    'DIVERTED'             : int,  \n    'CANCELLED'            : int,  \n    'CANCELLATION_REASON'  : str\n}\n\ny_dtype = {\n    'ID'                   : int,\n    \"ARRIVAL_DELAY\"        : float\n}\n\nX_train_df = pd.read_csv(\"/kaggle/input/eurecom-aml-2021-challenge-1/data/train_features.csv\", dtype=X_dtype)\ny_train_df = pd.read_csv(\"/kaggle/input/eurecom-aml-2021-challenge-1/data/train_targets.csv\", dtype=y_dtype)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Loading the airport, airline and target csvs in dataframes","metadata":{}},{"cell_type":"code","source":"airports = pd.read_csv('/kaggle/input/eurecom-aml-2021-challenge-1/data/airports.csv',\n                       usecols=['IATA_CODE', 'AIRPORT', 'LATITUDE', 'LONGITUDE']).rename({'AIRPORT': 'NAME'}, axis='columns')\n\nairlines = pd.read_csv('/kaggle/input/eurecom-aml-2021-challenge-1/data/airlines.csv')\n\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Data Preparation\n\nSelecting useful data from the target features, the airport and the airline dataframes. \nFirst, let's define the columns needed for the data reformatting.\n","metadata":{}},{"cell_type":"code","source":"num_column_before_pre=[\n    'ID',\n    'YEAR',\n    'MONTH', \n    'DAY',  \n    'DAY_OF_WEEK',\n    'DEPARTURE_DELAY',\n    'SCHEDULED_TIME',\n    'AIR_TIME',\n    'DISTANCE',\n    'DIVERTED',  \n    'CANCELLED',\n    'ARRIVAL_DELAY',\n    'ORIGIN_LATITUDE',\n    'DESTINATION_LATITUDE',\n    'ORIGIN_LONGITUDE',\n    'DESTINATION_LONGITUDE',\n    'TIME_TO_GO',\n    'ARRIVAL_DELAY'\n\n]\n\nnum_column_after_pre=[\n    'ID',\n    'YEAR',\n    'MONTH', \n    'DAY',  \n    'DAY_OF_WEEK',\n    'DEPARTURE_DELAY',\n    'SCHEDULED_TIME',\n    'AIR_TIME',\n    'DISTANCE',\n    'ORIGIN_LATITUDE',\n    'DESTINATION_LATITUDE',\n    'ORIGIN_LONGITUDE',\n    'DESTINATION_LONGITUDE',\n    'ORIGIN_AIRPORT',\n    'DESTINATION_AIRPORT', \n    'SCHEDULED_DEPARTURE',  \n    'DEPARTURE_TIME',\n    'TAXI_OUT', \n    'WHEELS_OFF',\n    'SCHEDULED_ARRIVAL',\n    'FLIGHT_NUMBER',\n    'AIRLINE', \n    'TAIL_NUMBER',\n    'TIME_TO_GO',\n    'ARRIVAL_DELAY'\n\n]\n\nnum_column_after_pre = list( dict.fromkeys(num_column_after_pre) )\n\nstr_column_before_pre=[\n    'DAY_OF_WEEK',  \n    'AIRLINE', \n    'FLIGHT_NUMBER',  \n    'TAIL_NUMBER', \n    'ORIGIN_AIRPORT', \n    'DESTINATION_AIRPORT', \n    'SCHEDULED_DEPARTURE',  \n    'DEPARTURE_TIME',\n    'TAXI_OUT', \n    'WHEELS_OFF',\n    'SCHEDULED_ARRIVAL',\n    'CANCELLATION_REASON',\n    'DATE'\n]\n\nstr_column_after_pre=[\n    'ORIGIN_AIRPORT', \n    'DESTINATION_AIRPORT', \n    'CANCELLATION_REASON',\n    'DATE'\n]\n\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Then, let's join the longitude and latitude from airport to the main dataframe.","metadata":{}},{"cell_type":"code","source":"df= X_train_df.merge(airports[['LATITUDE', 'LONGITUDE','IATA_CODE']], how='left', left_on='ORIGIN_AIRPORT', right_on='IATA_CODE')\ndf = df.rename(columns={'LATITUDE': 'ORIGIN_LATITUDE', 'LONGITUDE':'ORIGIN_LONGITUDE'})\ndf = df.drop(['IATA_CODE'], axis=1)\n\n\ndf= df.merge(airports[['LATITUDE', 'LONGITUDE','IATA_CODE']], how='left', left_on='DESTINATION_AIRPORT', right_on='IATA_CODE')\ndf = df.drop(['IATA_CODE'], axis=1)\ndf = df.rename(columns={'LATITUDE': 'DESTINATION_LATITUDE', 'LONGITUDE':'DESTINATION_LONGITUDE'})\n\ndf = pd.merge(df, y_train_df, on='ID')\n\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Let's create another column to get the actual time elapsed during the flight, minus the taxi-in phase. We'll call it 'TIME_TO_GO'.","metadata":{}},{"cell_type":"code","source":"#La formule du savoir\n\ndf['TIME_TO_GO']=df['TAXI_OUT']+df['DEPARTURE_DELAY']+df['AIR_TIME']-df['SCHEDULED_TIME']\ndf.TIME_TO_GO\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Then, let's create a reformating function. It takes a dataframe as parameter and spits out the processed one. It converts some columns back to integers, reformat time as usable floats and encode strings to unique IDs. Converting strings to numerical values will be helpful when plotting the correlation matrix later on.","metadata":{}},{"cell_type":"code","source":"def reformat(df_t):\n    ints =[\n    'DAY_OF_WEEK',  \n    'FLIGHT_NUMBER'\n    ]\n    \n    time=[\n    'SCHEDULED_DEPARTURE',  \n    'DEPARTURE_TIME',\n    'WHEELS_OFF',\n    'SCHEDULED_ARRIVAL'\n    ]\n    \n    strings =[\n    'AIRLINE', \n    'TAIL_NUMBER', \n    'ORIGIN_AIRPORT', \n    'DESTINATION_AIRPORT'\n        \n    ]\n\n    \n    df_t[ints]=df_t[ints].astype(int)\n    \n    for i in time:\n        df_t[i]=df_t[i].apply(lambda x: round(int(x/100)+(x/100 - int(x/100))/0.6, 4))\n        \n    df_t[strings]=df_t[strings].apply(lambda x: x.factorize()[0])\n\n    \n    return df_t\n    ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"*df_pre* is the pre-processed data ready for data analysis.","metadata":{}},{"cell_type":"code","source":"df_pre=df.copy()    \ndf_pre=reformat(df_pre)[num_column_after_pre]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_pre.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Data analysis\n### Overview\n\nFirst we explore the data by answering the questions. \n\n- Basic queries:\n  - How many unique origin airports?\n  - How many unique destination airports?\n  - How many carriers?\n  - How many flights that have a scheduled departure time later than 18h00?\n\n\n- Statistics on flight volume: this kind of statistics are helpful to reason about delays. Indeed, it is plausible to assume that \"*the more flights in an airport, the higher the probability of delay*\".\n  - How many flights in each month of the year?\n  - Is there any relationship between the number of flights and the days of week?\n  - How many flights in different days of months and in different hours of days?\n  - Which are the top 20 busiest airports (this depends on inbound and outbound traffic)?\n  - Which are the top 20 busiest carriers?\n\n","metadata":{}},{"cell_type":"code","source":"#BASIC QUERIES\n\na=df_pre.ORIGIN_AIRPORT.drop_duplicates().count()\nb=df_pre.DESTINATION_AIRPORT.drop_duplicates().count()\nc=df_pre.TAIL_NUMBER.drop_duplicates().count()\nd=df_pre[df_pre.SCHEDULED_DEPARTURE>18.0].ID.count()\n\nprint(\"Number of unique airports (origin/destination): \"+str(a) +\" and \"+str(b) )\nprint(\"Number of unique carriers : \"+str(c))\nprint(\"Number of planes schedule to take off later than 6 pm :\" +str(d))\n\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Statistic on flight volume\nplt.rcParams.update({'font.size': 5})\n\nplt.figure()\nfig, axes = plt.subplots(nrows=2, ncols=2)\nfig.set_size_inches(8,8)\n\ndf_month = df_pre.groupby('MONTH').ID.count()\ndf_month.plot(ax=axes[0,0], kind=\"bar\", title=\"Flights per months\")\n\ndf_day = df_pre.groupby('DAY_OF_WEEK').ID.count()\ndf_day.plot(ax=axes[0,1], kind=\"bar\",title=\"Flights per day of the week\")\n\ndf_carrier = df.groupby('TAIL_NUMBER').ID.count().sort_values(ascending=False).head(20)\ndf_carrier.plot(ax=axes[1,0], kind=\"bar\", title=\"20 busiest carries\", rot=90)\n\ndf1=df.groupby('DESTINATION_AIRPORT').ID.count()\ndf2=df.groupby('ORIGIN_AIRPORT').ID.count()\ndf_airport = pd.concat([df1,df2],axis =1).sum(axis=1).sort_values(ascending=False).head(20)\ndf_airport.plot(ax=axes[1,1], kind=\"bar\", title=\"20 busiest airports\")\n\nplt.tight_layout()\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"These queries give us a sense of what we are dealing with and help us understand the dataset better.","metadata":{}},{"cell_type":"markdown","source":"### Correlation Analysis\n\nNow, let's move on to some analysis of our own, shall we?\nFirst let's plot the arrival delay with regards to all features of the pre-processed dataframe. Double click on the output to zoom-in.","metadata":{}},{"cell_type":"code","source":"a=sns.pairplot(df_pre, y_vars=['ARRIVAL_DELAY'], x_vars=num_column_after_pre[:5], height=3, aspect=1)\nb=sns.pairplot(df_pre, y_vars=['ARRIVAL_DELAY'], x_vars=num_column_after_pre[5:10], height=3, aspect=1)\nc=sns.pairplot(df_pre, y_vars=['ARRIVAL_DELAY'], x_vars=num_column_after_pre[10:15], height=3, aspect=1)\nd=sns.pairplot(df_pre, y_vars=['ARRIVAL_DELAY'], x_vars=num_column_after_pre[15:20], height=3, aspect=1)\ne=sns.pairplot(df_pre, y_vars=['ARRIVAL_DELAY'], x_vars=num_column_after_pre[20:], height=3, aspect=1)\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"That gives us several hints on the correlation between some features and the target.\n- DEPARTRE_DELAY is seems strongly correlated to ARRIVAL_DELAY\n- TIME_TO_GO is looking even more promissing. This was expected is its value is computed using TAXI_OUT, AIR_TIME and DEPARTURE_DELAY.\n\nHowever, we cannot conclude anything about numerically encoded string values such as the TAIL_NUMBER or the AIRLINE. These features will be looked at later on.\n\n\nLet's go more into detail and plot the correlation matrix.","metadata":{}},{"cell_type":"code","source":"corrmat = np.abs(df_pre, axis=1).corr()\nmask = np.zeros_like(corrmat)\nmask[np.triu_indices_from(mask)] = True\nwith sns.axes_style(\"white\"):\n    f, ax = plt.subplots(figsize=(12,8))\n    ax = sns.heatmap(corrmat, mask=mask, square=True, cmap=\"YlGnBu\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Let's reorganize that matrix only selecting the 8 most correlated features and sorting them.","metadata":{}},{"cell_type":"code","source":"n = 8\ncols = corrmat.nlargest(n, 'ARRIVAL_DELAY')['ARRIVAL_DELAY'].index # List of highly correlated colums with 'SalePrice'\ncm = np.corrcoef(df_pre[cols].values.T)\nmask = np.zeros_like(cm)\nmask[np.triu_indices_from(cm)] = True\nwith sns.axes_style(\"white\"):\n    f, ax = plt.subplots(figsize=(12, 9))\n    ax = sns.heatmap(cm, \n                     mask=mask, \n                     cbar=True, \n                     annot=True, \n                     square=True, \n                     fmt='.2f', \n                     annot_kws={'size': 10}, \n                     yticklabels=cols.values, \n                     xticklabels=cols.values,\n                     cmap=\"YlGnBu\"\n                    )\n    plt.show()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"With a correlation of nearly 1, *TIME_TO_GO* is a feature that needs to be considered for the training of the model. This feature is an improved version of *DEPARTURE_DELAY* as it also takes into account the taxi and air times.","metadata":{}},{"cell_type":"markdown","source":"#### Airlines\n\nAs the correlation matrix could not help with airlines, let's compare them by hand. First intuition : the busiest the airline, the bigger it is. A big company needs to manage a bigger crew, a bigger fleet and more passengers + belongings. As crew and passenger lateness account for a great portition of delay, it is a reasonable assumption. \n\nHence let's plot the average delay (red) and size(blue) of each airlines.","metadata":{}},{"cell_type":"code","source":"#airline\n\ndf_airline=df.groupby('AIRLINE').ARRIVAL_DELAY.mean()\ndf_airline_flight=df.groupby('AIRLINE').ID.count()\ndf_tot = pd.concat([df_airline,df_airline_flight],axis =1)\n\nax1 = df_tot.ID.plot(kind='bar', alpha=0.7)\nax2 = df_tot.ARRIVAL_DELAY.plot(kind='bar',secondary_y=True, color='r', alpha=0.5)\n\nax1.set_ylim(-0.19e6, 1.5e6)\nax2.set_ylim(-2, 16)\n\n#df_airline_flight.plot(kind='bar', secondary_y=True, style='green')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"There is seemingly no correlation between the size of the airline and the average delay. Therefore, we cannot simply assume that the biggest, the worst.\n\nLet's plot the delay with reards to each airlines. ","metadata":{}},{"cell_type":"code","source":"\nax = sns.stripplot(y=\"AIRLINE\", x=\"DEPARTURE_DELAY\", size = 4, \n                    data=df, linewidth = 0.5,  jitter=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"This representation gives a feeling on the dispersion of data, and shows very different distributions for each airline. It puts in perspective the relative homogeneity that appeared in the average delay plot. Indeed, we see that while all mean delays are around 10 minutes, this low value is a consequence of the fact that a majority of flights take off on time. However, we see that occasionally, we can face really large delays that can reach a few tens of hours.\n\nNow that we're done with the qualitative analysis, let's dive in the quantitative one. The goal is to estimate the distribution of the delay for each airline in order to rank them. To do so, let's plot the histograms and fit an their contours.","metadata":{}},{"cell_type":"code","source":"airline_list=df.AIRLINE.drop_duplicates().tolist()\n\nplt.figure()\nfig, axes = plt.subplots(nrows=7, ncols=2)\nfig.set_size_inches(8,8)\ni=0\n\nfor x in airline_list:\n    a,b=int(i/2),i%2\n    df[df['AIRLINE']==x]['DEPARTURE_DELAY'].hist(ax=axes[a,b], \n             bins=60, range = (15,180), density=1, legend=x)\n    i+=1\n    \nplt.tight_layout()\n\n    ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Each distribution is different. In all 14 cases, the delay follows an inverserve exponential distribution with different parameters. Long tail indicates that an airline is more likely to have significant delays, which is undesirable. Therefore longtail airports can be classified as worst than others. \n\nTherefore, it is an important feature to consider for the training of the model.\n\n","metadata":{}},{"cell_type":"markdown","source":"#### Airports\n\nFirst, let's plot the average delay on a map for each airport. We need to do it for both departure and arrival airports.\n","metadata":{}},{"cell_type":"code","source":"#geography\nimport geopandas as gpd\nfrom geopandas import GeoDataFrame\nfrom shapely.geometry import Point\n\ndf_meanO = df_pre.groupby(['ORIGIN_AIRPORT', 'ORIGIN_LATITUDE', 'ORIGIN_LONGITUDE']).ARRIVAL_DELAY.mean()\ndf_meanD = df_pre.groupby(['DESTINATION_AIRPORT', 'DESTINATION_LATITUDE', 'DESTINATION_LONGITUDE']).ARRIVAL_DELAY.mean()\n\n\ngeometryO, geometryD=[],[]\n\nfor i in range(df_meanO.size):\n    x,y= df_meanO.index[i][2], df_meanO.index[i][1]\n    xy = (x,y)\n    geometryO.append(Point(xy))#[Point(xy) for x in zip(df_geo_dep['LONGITUDE'], df_geo_dep['LATITUDE'])]\ngdfO = GeoDataFrame(df_meanO, geometry=geometryO)\n\nfor i in range(df_meanD.size):\n    x,y= df_meanD.index[i][2], df_meanD.index[i][1]\n    xy = (x,y)\n    geometryD.append(Point(xy))#[Point(xy) for x in zip(df_geo_dep['LONGITUDE'], df_geo_dep['LATITUDE'])]\ngdfD = GeoDataFrame(df_meanD, geometry=geometryD)\n\nworld = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))\nusa = world.iloc[[4]]\ngdfO.plot(ax=usa.plot(figsize=(10, 6)),column= 'ARRIVAL_DELAY' , legend=True, vmax=40, vmin=-20,markersize=35,cmap='OrRd')\n\ngdfD.plot(ax=usa.plot(figsize=(10, 6)),column= 'ARRIVAL_DELAY' , legend=True, vmax=40, vmin=-20,markersize=35,cmap='OrRd')\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"As we did for the airlines, we now need to go deeper for each departure airports. However, we need to make a selection as there are 628 of them. Let's choose the 14 busiest ones, and plot the delay distribution.","metadata":{}},{"cell_type":"code","source":"df_busiestO=df.groupby('ORIGIN_AIRPORT').ID.count().sort_values(ascending=False).head(14)\nsO=df_busiestO.index.tolist()\ndf_newO = df[df['ORIGIN_AIRPORT'].isin(sO)]\n\ndf_busiestD=df.groupby('DESTINATION_AIRPORT').ID.count().sort_values(ascending=False).head(14)\nsD=df_busiestD.index.tolist()\ndf_newD = df[df['DESTINATION_AIRPORT'].isin(sD)]\n\ndf_newO=df_newO[['ORIGIN_AIRPORT', 'DEPARTURE_DELAY']]\ndf_newO['BIN']='ORIGIN'\ndf_newO=df_newO.rename(columns={'ORIGIN_AIRPORT':'AIRPORT'})\ndf_newO.head()\n\ndf_newD=df_newD[['DESTINATION_AIRPORT', 'DEPARTURE_DELAY']]\ndf_newD['BIN']='DESTINATION'\ndf_newD=df_newD.rename(columns={'DESTINATION_AIRPORT':'AIRPORT'})\ndf_newD.head()\n\ndf_concat=pd.concat([df_newD, df_newO]).reset_index(drop=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"colors = ['firebrick', 'gold', 'lightcoral', 'aquamarine', 'c', 'yellowgreen', 'grey',\n          'seagreen', 'tomato', 'violet', 'wheat', 'chartreuse', 'lightskyblue', 'royalblue']\n\nax1=sns.stripplot(y='AIRPORT', x=\"DEPARTURE_DELAY\", size = 4, hue='BIN', \n                    data=df_concat, linewidth = 0.5,  jitter=True, dodge=True, color=colors, palette = colors)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The result is similar to the one we got for the airlines. There seems to be better airports than others when it comes to flight delay.\n\n","metadata":{}},{"cell_type":"markdown","source":"**To conclude, we shall consider the 4 following features for training purpose:**\n- TIME_TO_GO (~DEPARTURE_DELAY)\n- AIRLINES\n- ORIGIN_AIRPORT\n- DESTINATION_AIRPORT\n","metadata":{}},{"cell_type":"markdown","source":"## Data Pre-processing\n\nThe previous step should give you a better understanding of which pre-processing is required for the data.\nThis may include:\n\n- Normalising and standardising the given data;\n- Removing outliers;\n- Carrying out feature selection, possibly using metrics derived from information theory;\n- Handling missing information in the dataset;\n- Augmenting the dataset with external information;\n- Combining existing features.","metadata":{}},{"cell_type":"markdown","source":"Below is a very basic example of pre-processing steps.","metadata":{}},{"cell_type":"code","source":"# First of all, you should split the data into a training set and a validation set\nX_train_df, X_val_df, y_train_df, y_val_df = train_test_split(\n    df_pre, y_train_df, random_state=1, test_size=0.2)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Here  we only use the 4 features deemed interesting.","metadata":{}},{"cell_type":"code","source":"# Here we use 7 features as follows\nfeature_names = [ 'TIME_TO_GO', 'AIRLINE', 'ORIGIN_AIRPORT', 'DESTINATION_AIRPORT']\ntarget_name = ['ARRIVAL_DELAY']\n\nX_train_df = X_train_df[feature_names]\ny_train_df = y_train_df[target_name]\n\nX_val_df = X_val_df[feature_names]\ny_val_df = y_val_df[target_name]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Filling missing values by the mean along each column.\n# These statistics should be estimated by using the training set.\nimputer = SimpleImputer(missing_values=np.nan, strategy='mean')\nimputer.fit(X_train_df)\n\nX_train = imputer.transform(X_train_df)\nX_val = imputer.transform(X_val_df)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Standardize the features by removing the mean and scaling to unit variance\n# Similarly to the preivous step, the statistics used for standardization\n# should be computed across the training set only\nX_scaler = StandardScaler()\nX_scaler.fit(X_train)\n\nX_train = X_scaler.transform(X_train)\nX_val = X_scaler.transform(X_val)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# We should also standardize the targets.\ny_scaler = StandardScaler()\ny_scaler.fit(y_train_df)\n\ny_train = y_scaler.transform(y_train_df)\ny_val = y_scaler.transform(y_val_df)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The *preprocess_data()* function has been modified by adding to it the *format()* and by creating the additional column *TIME_TO_GO*.","metadata":{}},{"cell_type":"code","source":"def preprocess_data(df, feature_names, imputer, scaler):\n    \"\"\"Preprocess data.\n\n    Parameters\n    ----------\n    df: pandas DataFrame.\n        The input data.\n    feature_names: list of strings.\n        The names of selected features.\n    imputer: sklearn.impute.SimpleImputer\n        The imputation transformer for completing missing values.\n    scaler: sklearn.preprocessing.StandardScaler.\n        The scaler used to normalize the features.\n\n    Returns\n    -------\n    X: numpy array.\n        The preprocessed data.\n    \"\"\"\n    \n    df['TIME_TO_GO']=df['TAXI_OUT']+df['DEPARTURE_DELAY']+df['AIR_TIME']-df['SCHEDULED_TIME']\n    \n    ints =[\n    'DAY_OF_WEEK',  \n    'FLIGHT_NUMBER'\n    ]\n    \n    time=[\n    'SCHEDULED_DEPARTURE',  \n    'DEPARTURE_TIME',\n    'WHEELS_OFF',\n    'SCHEDULED_ARRIVAL'\n    ]\n    \n    strings =[\n    'AIRLINE', \n    'TAIL_NUMBER', \n    'ORIGIN_AIRPORT', \n    'DESTINATION_AIRPORT'\n        \n    ]\n\n    \n    df[ints]=df[ints].astype(int)\n    \n    for i in time:\n        df[i]=df[i].apply(lambda x: round(int(x/100)+(x/100 - int(x/100))/0.6, 4))\n        \n    df[strings]=df[strings].apply(lambda x: x.factorize()[0])\n    \n    \n    \n    # Select features\n    X_df = df[feature_names]\n\n\n    # Impute missing values\n    X = imputer.transform(X_df)\n    \n    # Normalize features\n    X = scaler.transform(X)\n\n    return X","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Model Selection\n​\nFor the model selection we had to pass through different steps in order to come up with our last final result : the Random Forest Regressor. The random forest was already a good choice since the beginning but we wanted to go step by step.\n","metadata":{}},{"cell_type":"code","source":"from sklearn import neighbors, datasets, preprocessing\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.ensemble import RandomForestRegressor\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.neural_network import MLPRegressor\nfrom sklearn.svm import SVR\nimport xgboost as xgb","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def make_prediction(X, model, scaler):\n    \"\"\"Makes predictions given a preprocessed dataset.\n\n    Parameters\n    ----------\n    X: numpy array.\n        The input data, which already is pre-processed.\n    model: an hypopt or sklearn model.\n        The trained model used for making predictions.\n    scaler: sklearn.preprocessing.StandardScaler.\n        The scaler used to normalize the targets.\n\n    Returns\n    -------\n    y_pred: numpy array.\n        The unnormalized predictions.\n    \"\"\"\n    y_pred = scaler.inverse_transform(model.predict(X))\n    return y_pred","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"​\n#### A word on Neural Network ..\n​\nThe Multi Layer Perceptron regressor is a Neural Network but we know that with a huge dataset like we have, this is way to slow for the training, so in terms of timing we didn't choose this model. Indeed we have tested it at several times and the training was too long so we stopped it and took a look at the results but the error was too high, because the training not ended.\n​\n","metadata":{}},{"cell_type":"markdown","source":"#### The K Nearest Neighbours Regressor\n​\nThe first implementation which worked well was the K Nearest Neighbours Regressor of scikit-learn. There were some advantages in terms of time and of parameter to use because this is a free parameter model.The advantage is that the model is really quick to set up since there are no particular parameters to calculate. The time become a bit longer in terms of prediction because even if there are no \"training\", it needs to search the \"nearest neighbors\" in all the dataset which takes time with a huge dataset. Another drawback at first was the error which was satisfying and better than the previous regression (around 21) but not enough at all. But then with the choice of fetaures, we've came up with some good results ( around 6 of training and validation RMSE). But we were thinking that, for a KNN it doesn't make huge sense to ask which features are the better or most useful since there are no weights, no training. That is why we oriented towards an other regression which was our first assumption of model : a Random Forest Regressor","metadata":{}},{"cell_type":"code","source":"knn = neighbors.KNeighborsRegressor(n_neighbors=6)\nknn.fit(X_train, y_train)\ny_train_pred = make_prediction(X_train, knn, y_scaler)\ntrain_rmse = np.sqrt(mean_squared_error(y_train_pred, y_train_df.values))\nprint(\"Training KNN RMSE: {:.5f}\".format(float(train_rmse)))\nprint(\"-------------------------\")\ny_val_pred = make_prediction(X_val, knn, y_scaler)\nval_rmse = np.sqrt(mean_squared_error(y_val_pred, y_val_df.values))\nprint(\"Validation KNN RMSE: {:.5f}\".format(float(val_rmse)))\nprint(\"--------------------------------\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We wanted to see how the KNN model could work if we optimize the only parameter for this model : the number of neighbors. Below is the plot for this search of optimization.\n\nNOTE : the plot is a screenshot resulting of the commented code below. It is commented as it takes about 2 hours to run.","metadata":{}},{"cell_type":"code","source":"#num_neighb = []\n#results = []\n#for k in range(1,10):\n#    knn = neighbors.KNeighborsRegressor(n_neighbors=k)\n#    knn.fit(X_train, y_train)\n#    y_train_pred = make_prediction(X_train, knn, y_scaler)\n#    train_rmse = np.sqrt(mean_squared_error(y_train_pred, y_train_df.values))\n#    print(\"--------------\"+str(k)+\"---------------\")\n#    print(\"Training KNN RMSE: {:.5f}\".format(float(train_rmse)))\n#    print(\"-------------------------\")\n#    y_val_pred = make_prediction(X_val, knn, y_scaler)\n#    val_rmse = np.sqrt(mean_squared_error(y_val_pred, y_val_df.values))\n #   print(\"Validation KNN RMSE: {:.5f}\".format(float(val_rmse)))\n #   print(\"-------------------------\")\n#    num_neighb.append(k)\n #   results.append([train_rmse, val_rmse])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#plt.plot(num_neighb, results)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![179669943_189322399698252_875678966591621494_n.png](attachment:f4c4c1d9-3717-4da8-92e9-94c1aadd52ff.png)","metadata":{},"attachments":{"f4c4c1d9-3717-4da8-92e9-94c1aadd52ff.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"#### The Random Forest Regressor\n​\nNow the model is effective, there is also a part of logic to use it for this case since we have features which drive in one branch or another of a decision tree. The model seems to be appropriate, then we have tested it with the initial set features provided and the result is way better (around 10). We think that this model should be the more appropriate since, after thinking about Neural Network and Deep Neural Network we think that the training would be too long for the dataset (and we have tested it for the NN and the DNN), so in terms of computing power and time the Random Forest Regressor is a good choice. By using it with our choice of features, we have discovered some really good results but the training error and validation error were not the same : it can be a problem of overfitting. Then we have decided to work with the parameters to avoid this overfitting problem. ","metadata":{}},{"cell_type":"code","source":"rfr = RandomForestRegressor(max_depth=9)\nrfr.fit(X_train,y_train)\n\ny_train_pred = make_prediction(X_train, rfr, y_scaler)\ntrain_rmse = np.sqrt(mean_squared_error(y_train_pred, y_train_df.values))\nprint(\"Training Random Forest RMSE: {:.5f}\".format(float(train_rmse)))\nprint(\"-------------------------\")\ny_val_pred = make_prediction(X_val, rfr, y_scaler)\nval_rmse = np.sqrt(mean_squared_error(y_val_pred, y_val_df.values))\nprint(\"Validation Random Forest RMSE: {:.5f}\".format(float(val_rmse)))\nprint(\"-------------------------\")\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Parameter Optimisation \n\nIrrespective of your choice, it is highly likely that your model will have one or more parameters that require tuning.\nThere are several techniques for carrying out such a procedure, including cross-validation, Bayesian optimisation, and several others.\nAs before, an analysis into which parameter tuning technique best suits your model is expected before proceeding with the optimisation of your model.","metadata":{}},{"cell_type":"markdown","source":"### Random Forest Analysis","metadata":{}},{"cell_type":"markdown","source":"NOTE : the plot is a screenshot resulting of the commented code below. It is commented as it takes about 1h30 to run.","metadata":{}},{"cell_type":"code","source":"#rfr = RandomForestRegressor(max_depth=k)\n#rfr.fit(X_train,y_train)\n#y_train_pred = make_prediction(X_train, rfr, y_scaler)\n#train_rmse = np.sqrt(mean_squared_error(y_train_pred, y_train_df.values))\n#print(\"Training Random Forest RMSE: {:.5f}\".format(float(train_rmse)))\n#print(\"-------------------------\")\n#y_val_pred = make_prediction(X_val, rfr, y_scaler)\n#val_rmse = np.sqrt(mean_squared_error(y_val_pred, y_val_df.values))\n#print(\"Validation Random Forest RMSE: {:.5f}\".format(float(val_rmse)))\n#num_depthsRFR.append(k)\n#resultsRFR.append([train_rmse, val_rmse])\n\n#X = [k for k in range(len(y_val_pred))]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#plt.plot(X[0:200],y_val_pred[0:200],y_val_df.values[0:200])","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![179235421_132633502180969_6053571332077337894_n.png](attachment:478cd8a8-7f3a-44c1-8b6b-d18380507fd0.png)","metadata":{},"attachments":{"478cd8a8-7f3a-44c1-8b6b-d18380507fd0.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"We can see with the graph above that the prediction seems to fit quite well the original distribution. Indeed the high delays are respected but the part for low delay are more discutable. Indeed we think that it is difficult to predict perfectly a delay of for example 10 minutes because it is more sensible to perturbations. \n\nBelow is an interesting graph showing the important of the features during the training of the Random Forest. We can see that TIME_TO_GO which is the more useful is a logic feature since it is directly linked to the Departure delay.","metadata":{}},{"cell_type":"code","source":"values = rfr.feature_importances_\nplt.bar(feature_names, values)\nvalues","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The graph bellow allows us to see that most of the datas are around a little delay, but also that there is a sort of bias around these little delay. Indeed we find back the shape of a similar plot with TIME_TO_GO in the data analysis. This comfort us in our feeling and result that TIME_TO_GO is a real useful feature.","metadata":{}},{"cell_type":"code","source":"sns.jointplot(x=y_val_pred,y=y_val_df['ARRIVAL_DELAY'], kind='reg')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\n\nos.system('jupyter nbconvert --to html yourNotebook.ipynb')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}