{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Formula One Project: Modeling\n",
    "\n",
    "DUE: December 4th, 2024 (Wed)  \n",
    "Name(s): Sean O'Connor, Connor Coles    \n",
    "Class: CSCI 349 - Intro to Data Mining  \n",
    "Semester: Fall 2024  \n",
    "Instructor: Brian King  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment Description\n",
    "\n",
    "Copy over the important cells from the previous step that read in and cleaned your data to this new notebook file. You do not need to copy over all your EDA and plots describing your data, only the code that prepares your data for modeling. This notebook is about exploring the development of predictive models. Some initial preliminary work on applying some modeling techniques should be completed.\n",
    "Be sure to commit and push all supporting code that you've completed in this file. Include in this notebook a summary cell at the top that details your accomplishments, challenges, and what you expect to accomplish for your final steps. Be sure to update your readme.md in your repository.\n",
    "\n",
    "## Progress Summary\n",
    "\n",
    "### Accomplishments So Far\n",
    "- Successfully loaded and preprocessed Formula 1 race data from 2021-2024\n",
    "- Created comprehensive feature engineering pipeline including weather and track conditions\n",
    "- Implemented initial modeling with Random Forest, XGBoost, and Gradient Boosting\n",
    "- Achieved best performance on Belgian GP (R² = 0.775) and Mexico City GP (R² = 0.505)\n",
    "\n",
    "### Challenges Faced\n",
    "- High variability in model performance across different tracks\n",
    "- British GP proving particularly difficult to predict (best R² = 0.047)\n",
    "- Complex interactions between weather variables and lap times\n",
    "- Limited data availability for some races/conditions\n",
    "\n",
    "### Next Steps\n",
    "- Implement hyperparameter tuning using GridSearchCV\n",
    "- Explore additional feature engineering possibilities\n",
    "- Test neural network approaches for complex weather-performance relationships\n",
    "- Create ensemble model combining best performers for each track\n",
    "- Prepare final visualizations and analysis for report\n",
    "\n",
    "## Data Preparation and Feature Engineering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing Libraries\n",
    "import os\n",
    "import logging\n",
    "\n",
    "import fastf1\n",
    "import fastf1.plotting\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import xgboost as xgb\n",
    "from xgboost import XGBRegressor\n",
    "from fastf1.ergast.structure import FastestLap\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.ensemble import GradientBoostingRegressor, RandomForestRegressor\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "from sklearn.model_selection import cross_val_score, train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.metrics import mean_absolute_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FastF1 general setup\n",
    "cache_dir = '../data/cache'\n",
    "if not os.path.exists(cache_dir):\n",
    "    os.makedirs(cache_dir)\n",
    "\n",
    "fastf1.Cache.enable_cache(cache_dir)\n",
    "fastf1.plotting.setup_mpl(misc_mpl_mods=False, color_scheme=None)\n",
    "logging.disable(logging.INFO)\n",
    "\n",
    "# Set up plot style\n",
    "# print style.available to check available styles\n",
    "plt.style.use('seaborn-v0_8-whitegrid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define years, sessions, and events of interest\n",
    "years = [2021, 2022, 2023, 2024]\n",
    "sessions = ['Race']\n",
    "events = ['Bahrain Grand Prix', 'British Grand Prix', 'Belgian Grand Prix', 'United States Grand Prix', 'Mexico City Grand Prix']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing 2021 Bahrain Grand Prix - Race\n",
      "Processing 2021 British Grand Prix - Race\n",
      "Processing 2021 Belgian Grand Prix - Race\n",
      "Processing 2021 United States Grand Prix - Race\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "core        WARNING \tDriver  7: Lap timing integrity check failed for 1 lap(s)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing 2021 Mexico City Grand Prix - Race\n",
      "Processing 2022 Bahrain Grand Prix - Race\n",
      "Processing 2022 British Grand Prix - Race\n",
      "Processing 2022 Belgian Grand Prix - Race\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "events      WARNING \tCorrecting user input 'United States Grand Prix' to 'United States Grand Prix'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing 2022 United States Grand Prix - Race\n",
      "Processing 2022 Mexico City Grand Prix - Race\n",
      "Processing 2023 Bahrain Grand Prix - Race\n",
      "Processing 2023 British Grand Prix - Race\n",
      "Processing 2023 Belgian Grand Prix - Race\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "events      WARNING \tCorrecting user input 'United States Grand Prix' to 'United States Grand Prix'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing 2023 United States Grand Prix - Race\n",
      "Processing 2023 Mexico City Grand Prix - Race\n",
      "Processing 2024 Bahrain Grand Prix - Race\n",
      "Processing 2024 British Grand Prix - Race\n",
      "Processing 2024 Belgian Grand Prix - Race\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "events      WARNING \tCorrecting user input 'United States Grand Prix' to 'United States Grand Prix'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing 2024 United States Grand Prix - Race\n",
      "Processing 2024 Mexico City Grand Prix - Race\n"
     ]
    }
   ],
   "source": [
    "# Get data from FastF1 API\n",
    "\n",
    "# Data containers\n",
    "weather_data_list = []\n",
    "lap_data_list = []\n",
    "\n",
    "# Loop through years and sessions\n",
    "for year in years:\n",
    "    for event_name in events:   \n",
    "        for session_name in sessions:\n",
    "            try:\n",
    "                print(f\"Processing {year} {event_name} - {session_name}\")\n",
    "                \n",
    "                # Load the session\n",
    "                session = fastf1.get_session(year, event_name, session_name, backend='fastf1')\n",
    "                session.load()\n",
    "                \n",
    "                # Process weather data\n",
    "                weather_data = session.weather_data\n",
    "                if weather_data is not None:\n",
    "                    weather_df = pd.DataFrame(weather_data)\n",
    "                    # Add context columns\n",
    "                    weather_df['Year'] = year\n",
    "                    weather_df['Event'] = event_name\n",
    "                    weather_df['Session'] = session_name\n",
    "                    weather_data_list.append(weather_df)\n",
    "\n",
    "                # Process lap data\n",
    "                lap_data = session.laps\n",
    "                if lap_data is not None:\n",
    "                    lap_df = pd.DataFrame(lap_data)\n",
    "                    # Add context columns\n",
    "                    lap_df['Year'] = year\n",
    "                    lap_df['Event'] = event_name\n",
    "                    lap_df['Session'] = session_name\n",
    "                    # Ensure driver information is included\n",
    "                    if 'Driver' not in lap_df.columns:\n",
    "                        lap_df['Driver'] = lap_df['DriverNumber'].map(session.drivers)\n",
    "                    # Add team information if available\n",
    "                    if 'Team' not in lap_df.columns:\n",
    "                        lap_df['Team'] = lap_df['Driver'].map(session.drivers_info['TeamName'])\n",
    "                    lap_data_list.append(lap_df)\n",
    "        \n",
    "            except Exception as e:\n",
    "                print(f\"Error with {event_name} {session_name} ({year}): {e}\")\n",
    "\n",
    "# Combine data into DataFrames\n",
    "if weather_data_list:\n",
    "    weather_data_combined = pd.concat(weather_data_list, ignore_index=True)\n",
    "    # Ensure consistent column ordering\n",
    "    weather_cols = ['Time', 'Year', 'Event', 'Session', \n",
    "                   'AirTemp', 'Humidity', 'Pressure', 'Rainfall', \n",
    "                   'TrackTemp', 'WindDirection', 'WindSpeed']\n",
    "    weather_data_combined = weather_data_combined[weather_cols]\n",
    "    \n",
    "if lap_data_list:\n",
    "    lap_data_combined = pd.concat(lap_data_list, ignore_index=True)\n",
    "    # Ensure consistent column ordering\n",
    "    lap_cols = ['Time', 'Year', 'Event', 'Session', \n",
    "                'Driver', 'Team', 'LapNumber', 'LapTime',\n",
    "                'Sector1Time', 'Sector2Time', 'Sector3Time',\n",
    "                'Compound', 'TyreLife', 'FreshTyre',\n",
    "                'SpeedI1', 'SpeedI2', 'SpeedFL', 'SpeedST']\n",
    "    # Only include columns that exist\n",
    "    existing_cols = [col for col in lap_cols if col in lap_data_combined.columns]\n",
    "    lap_data_combined = lap_data_combined[existing_cols]\n",
    "    \n",
    "# Time conversion\n",
    "# Function to convert timedelta to datetime\n",
    "def convert_timedelta_to_datetime(df, base_date='2021-01-01'):\n",
    "    if 'Time' in df.columns:\n",
    "        # Create a base datetime and add the timedelta\n",
    "        base = pd.Timestamp(base_date)\n",
    "        if df['Time'].dtype == 'timedelta64[ns]':\n",
    "            df['Time'] = base + df['Time']\n",
    "    return df\n",
    "\n",
    "# Apply conversion to both dataframes\n",
    "weather_data_combined = convert_timedelta_to_datetime(weather_data_combined)\n",
    "lap_data_combined = convert_timedelta_to_datetime(lap_data_combined)\n",
    "\n",
    "# Remove missing values\n",
    "weather_data_combined = weather_data_combined.dropna()\n",
    "lap_data_combined = lap_data_combined.dropna()\n",
    "\n",
    "# Create a new column for lap time in seconds\n",
    "lap_data_combined['LapTime_seconds'] = lap_data_combined['LapTime'].dt.total_seconds()\n",
    "\n",
    "# Merge the data\n",
    "merged_data = pd.merge_asof(\n",
    "    lap_data_combined.sort_values('Time'),\n",
    "    weather_data_combined.sort_values('Time'),\n",
    "    on='Time',\n",
    "    by=['Event', 'Year'],  # Match within same event and year\n",
    "    direction='nearest',\n",
    "    tolerance=pd.Timedelta('1 min')  # Allow matching within 1 minute\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def engineer_features(df):\n",
    "    \"\"\"\n",
    "    Engineer features for F1 lap time prediction with track-specific optimizations.\n",
    "    \n",
    "    Parameters:\n",
    "        df (pandas.DataFrame): Input dataframe containing raw F1 session data\n",
    "    Returns:\n",
    "        pandas.DataFrame: DataFrame with engineered features\n",
    "    \"\"\"\n",
    "    # Basic weather and track condition features\n",
    "    df['GripCondition'] = df.apply(lambda x: \n",
    "        x['TrackTemp'] * (1 - x['Humidity']/200) if 'British' in x['Event']\n",
    "        else x['TrackTemp'] * (1 - x['Humidity']/100), axis=1)\n",
    "    \n",
    "    df['TempDelta'] = df['TrackTemp'] - df['AirTemp']\n",
    "    \n",
    "    # Tire degradation\n",
    "    df['TyreDeg'] = df.apply(lambda x: \n",
    "        np.exp(-0.02 * x['TyreLife']) if 'British' in x['Event']\n",
    "        else np.exp(-0.025 * x['TyreLife']) if 'Belgian' in x['Event']\n",
    "        else np.exp(-0.015 * x['TyreLife']), axis=1)\n",
    "    \n",
    "    # Track evolution with weather adjustment\n",
    "    df['TrackEvolution'] = df.apply(lambda x: \n",
    "        (1 - np.exp(-0.12 * x['LapNumber'])) * (1 - x['Humidity']/300) if 'British' in x['Event']\n",
    "        else (1 - np.exp(-0.15 * x['LapNumber'])) if 'United States' in x['Event']\n",
    "        else 1 - np.exp(-0.1 * x['LapNumber']), axis=1)\n",
    "    \n",
    "    # Temperature interactions\n",
    "    df['TempInteraction'] = df['TrackTemp'] * df['AirTemp']\n",
    "    df['TempInteractionSquared'] = df['TempInteraction'] ** 2\n",
    "    \n",
    "    # Weather complexity\n",
    "    df['WeatherComplexity'] = df.apply(lambda x:\n",
    "        (x['WindSpeed'] * 0.5 + abs(x['TempDelta']) * 0.3 + x['Humidity'] * 0.2) / 100.0\n",
    "        if 'Belgian' in x['Event']\n",
    "        else (x['WindSpeed'] * 0.3 + abs(x['TempDelta']) * 0.4 + x['Humidity'] * 0.3) / 100.0\n",
    "        if 'British' in x['Event']\n",
    "        else (x['WindSpeed'] * 0.2 + abs(x['TempDelta']) * 0.5 + x['Humidity'] * 0.3) / 100.0,\n",
    "        axis=1)\n",
    "    \n",
    "    # Track-specific features\n",
    "    df['DesertEffect'] = np.where(\n",
    "        df['Event'].str.contains('Bahrain'),\n",
    "        df['WindSpeed'] * df['Humidity'] * df['TempInteraction'] / 10000,\n",
    "        0\n",
    "    )\n",
    "    \n",
    "    df['WetWeatherEffect'] = df.apply(lambda x:\n",
    "        (x['Humidity'] * x['WindSpeed'] * abs(x['TempDelta'])) / 1200 if 'British' in x['Event']\n",
    "        else (x['Humidity'] * x['WindSpeed'] * abs(x['TempDelta'])) / 1000 if 'Belgian' in x['Event']\n",
    "        else 0, axis=1)\n",
    "    \n",
    "    df['AltitudeEffect'] = np.where(\n",
    "        df['Event'].str.contains('Mexico City'),\n",
    "        df['AirTemp'] * (1 - df['Humidity']/200) * df['WindSpeed'] / 10,\n",
    "        0\n",
    "    )\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_modeling_data(df):\n",
    "    \"\"\"\n",
    "    Prepare data for modeling with optimized track-specific configurations.\n",
    "    \n",
    "    Parameters:\n",
    "        df (pandas.DataFrame): Input dataframe with raw F1 session data\n",
    "        \n",
    "    Returns:\n",
    "        dict: Dictionary containing modeling results for each track\n",
    "    \"\"\"\n",
    "    data = engineer_features(df)\n",
    "    track_results = {}\n",
    "    \n",
    "    base_features = [\n",
    "        'TrackTemp', 'AirTemp', 'Humidity', 'WindSpeed',\n",
    "        'TyreLife', 'TyreDeg', 'TempDelta', 'GripCondition',\n",
    "        'TrackEvolution', 'TempInteraction', 'TempInteractionSquared',\n",
    "        'WeatherComplexity', 'DesertEffect', 'WetWeatherEffect', 'AltitudeEffect'\n",
    "    ]\n",
    "    \n",
    "    # Track-specific configurations\n",
    "    track_configs = {\n",
    "        'Bahrain': {\n",
    "            'n_estimators': 200,\n",
    "            'max_depth': 6,\n",
    "            'learning_rate': 0.007,\n",
    "            'outlier_threshold': 1.8,\n",
    "            'split_ratio': 0.8\n",
    "        },\n",
    "        'Belgian': {\n",
    "            'n_estimators': 180,\n",
    "            'max_depth': 5,\n",
    "            'learning_rate': 0.008,\n",
    "            'outlier_threshold': 1.8,\n",
    "            'split_ratio': 0.8\n",
    "        },\n",
    "        'Mexico City': {\n",
    "            'n_estimators': 160,\n",
    "            'max_depth': 6,\n",
    "            'learning_rate': 0.009,\n",
    "            'outlier_threshold': 1.6,\n",
    "            'split_ratio': 0.8\n",
    "        },\n",
    "        'United States': {\n",
    "            'n_estimators': 200,\n",
    "            'max_depth': 5,\n",
    "            'learning_rate': 0.006,\n",
    "            'outlier_threshold': 1.7,\n",
    "            'split_ratio': 0.75\n",
    "        },\n",
    "        'British': {\n",
    "            'n_estimators': 180,\n",
    "            'max_depth': 4,\n",
    "            'learning_rate': 0.008,\n",
    "            'outlier_threshold': 1.7,\n",
    "            'split_ratio': 0.75\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    for event in data['Event'].unique():\n",
    "        print(f\"\\nProcessing {event}\")\n",
    "        track_data = data[data['Event'] == event].copy()\n",
    "        \n",
    "        # Get track-specific config\n",
    "        config = next((v for k, v in track_configs.items() if k in event), {\n",
    "            'n_estimators': 150,\n",
    "            'max_depth': 6,\n",
    "            'learning_rate': 0.01,\n",
    "            'outlier_threshold': 1.7,\n",
    "            'split_ratio': 0.8\n",
    "        })\n",
    "        \n",
    "        # Outlier removal with track-specific thresholds\n",
    "        Q1 = track_data['LapTime_seconds'].quantile(0.25)\n",
    "        Q3 = track_data['LapTime_seconds'].quantile(0.75)\n",
    "        IQR = Q3 - Q1\n",
    "        track_data = track_data[\n",
    "            (track_data['LapTime_seconds'] >= Q1 - config['outlier_threshold'] * IQR) &\n",
    "            (track_data['LapTime_seconds'] <= Q3 + config['outlier_threshold'] * IQR)\n",
    "        ]\n",
    "        \n",
    "        # Feature preparation\n",
    "        track_data = pd.get_dummies(track_data, columns=['Compound'])\n",
    "        compound_features = [col for col in track_data.columns if col.startswith('Compound_')]\n",
    "        feature_columns = base_features + compound_features\n",
    "        \n",
    "        # Split data\n",
    "        track_data = track_data.sort_values('Time')\n",
    "        split_idx = int(len(track_data) * config['split_ratio'])\n",
    "        \n",
    "        X_train = track_data.iloc[:split_idx][feature_columns]\n",
    "        X_test = track_data.iloc[split_idx:][feature_columns]\n",
    "        y_train = track_data.iloc[:split_idx]['LapTime_seconds']\n",
    "        y_test = track_data.iloc[split_idx:]['LapTime_seconds']\n",
    "        \n",
    "        # Scale features\n",
    "        scaler = StandardScaler()\n",
    "        X_train_scaled = scaler.fit_transform(X_train)\n",
    "        X_test_scaled = scaler.transform(X_test)\n",
    "        \n",
    "        # Models with track-specific configurations\n",
    "        models = {\n",
    "            'Random Forest': RandomForestRegressor(\n",
    "                n_estimators=config['n_estimators'],\n",
    "                max_depth=config['max_depth'],\n",
    "                random_state=42\n",
    "            ),\n",
    "            'XGBoost': XGBRegressor(\n",
    "                n_estimators=config['n_estimators'],\n",
    "                max_depth=config['max_depth'],\n",
    "                learning_rate=config['learning_rate'],\n",
    "                random_state=42\n",
    "            ),\n",
    "            'Gradient Boosting': GradientBoostingRegressor(\n",
    "                n_estimators=config['n_estimators'],\n",
    "                max_depth=config['max_depth'],\n",
    "                learning_rate=config['learning_rate'],\n",
    "                random_state=42\n",
    "            )\n",
    "        }\n",
    "        \n",
    "        track_results[event] = {}\n",
    "        \n",
    "        for name, model in models.items():\n",
    "            model.fit(X_train_scaled, y_train)\n",
    "            y_pred = model.predict(X_test_scaled)\n",
    "            \n",
    "            rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
    "            r2 = r2_score(y_test, y_pred)\n",
    "            mean_error = mean_absolute_error(y_test, y_pred)\n",
    "            \n",
    "            track_results[event][name] = {\n",
    "                'RMSE': rmse,\n",
    "                'R2': r2,\n",
    "                'Mean Error': mean_error,\n",
    "                'Feature Importance': pd.DataFrame({\n",
    "                    'feature': feature_columns,\n",
    "                    'importance': model.feature_importances_\n",
    "                }).sort_values('importance', ascending=False)\n",
    "            }\n",
    "            \n",
    "            print(f\"\\nResults for {event} - {name}:\")\n",
    "            print(f\"RMSE: {rmse:.2f} seconds\")\n",
    "            print(f\"R2 Score: {r2:.3f}\")\n",
    "            print(f\"Mean Error: {mean_error:.2f} seconds\")\n",
    "            print(\"\\nTop 5 important features:\")\n",
    "            print(track_results[event][name]['Feature Importance'].head().to_string())\n",
    "            \n",
    "    return track_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_model_performance(track_results):\n",
    "    # Prepare data for plotting\n",
    "    comparison_data = []\n",
    "    for track, models in track_results.items():\n",
    "        for model_name, metrics in models.items():\n",
    "            comparison_data.append({\n",
    "                'Track': track.replace(' Grand Prix', ''),  # Shorter names\n",
    "                'Model': model_name,\n",
    "                'RMSE': metrics['RMSE'],\n",
    "                'R2': metrics['R2'],\n",
    "                'Mean Error': metrics['Mean Error']\n",
    "            })\n",
    "    \n",
    "    comparison_df = pd.DataFrame(comparison_data)\n",
    "    \n",
    "    # Create figure with subplots\n",
    "    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(15, 12))\n",
    "    \n",
    "    # Plot RMSE\n",
    "    sns.barplot(data=comparison_df, x='Track', y='RMSE', hue='Model', ax=ax1)\n",
    "    ax1.set_title('Model Performance (RMSE) by Track')\n",
    "    ax1.set_xlabel('')  # Remove x-label from top plot\n",
    "    plt.setp(ax1.get_xticklabels(), rotation=45, ha='right')\n",
    "    ax1.legend(title='Model', bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "    \n",
    "    # Plot R²\n",
    "    sns.barplot(data=comparison_df, x='Track', y='R2', hue='Model', ax=ax2)\n",
    "    ax2.set_title('Model Performance (R²) by Track')\n",
    "    ax2.set_xlabel('Track')\n",
    "    plt.setp(ax2.get_xticklabels(), rotation=45, ha='right')\n",
    "    ax2.legend(title='Model', bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "    \n",
    "    # Add a title for the entire figure\n",
    "    fig.suptitle('F1 Lap Time Prediction Model Performance', fontsize=16, y=1.02)\n",
    "    \n",
    "    # Adjust layout to prevent overlap\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "    # Print detailed statistics\n",
    "    print(\"\\nDetailed Statistics by Track:\")\n",
    "    for track in comparison_df['Track'].unique():\n",
    "        track_data = comparison_df[comparison_df['Track'] == track]\n",
    "        print(f\"\\n{track}:\")\n",
    "        print(f\"Best RMSE: {track_data['RMSE'].min():.2f} seconds\")\n",
    "        print(f\"Best R²: {track_data['R2'].max():.3f}\")\n",
    "        best_model = track_data.loc[track_data['R2'].idxmax(), 'Model']\n",
    "        print(f\"Best Model: {best_model}\")\n",
    "    \n",
    "    # Print overall model rankings\n",
    "    print(\"\\nOverall Model Rankings (by mean R²):\")\n",
    "    model_rankings = comparison_df.groupby('Model')['R2'].agg(['mean', 'std']).sort_values('mean', ascending=False)\n",
    "    print(model_rankings.round(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Processing Bahrain Grand Prix\n",
      "\n",
      "Results for Bahrain Grand Prix - Random Forest:\n",
      "RMSE: 1.48 seconds\n",
      "R2 Score: 0.199\n",
      "Mean Error: 1.05 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "                   feature  importance\n",
      "9          TempInteraction    0.254072\n",
      "10  TempInteractionSquared    0.248422\n",
      "8           TrackEvolution    0.234635\n",
      "7            GripCondition    0.078404\n",
      "4                 TyreLife    0.038056\n",
      "\n",
      "Results for Bahrain Grand Prix - XGBoost:\n",
      "RMSE: 1.41 seconds\n",
      "R2 Score: 0.275\n",
      "Mean Error: 1.02 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "            feature  importance\n",
      "9   TempInteraction    0.806055\n",
      "7     GripCondition    0.071437\n",
      "8    TrackEvolution    0.032646\n",
      "6         TempDelta    0.017066\n",
      "17    Compound_SOFT    0.014787\n",
      "\n",
      "Results for Bahrain Grand Prix - Gradient Boosting:\n",
      "RMSE: 1.43 seconds\n",
      "R2 Score: 0.259\n",
      "Mean Error: 1.02 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "                   feature  importance\n",
      "10  TempInteractionSquared    0.293157\n",
      "8           TrackEvolution    0.238935\n",
      "9          TempInteraction    0.202298\n",
      "7            GripCondition    0.067621\n",
      "5                  TyreDeg    0.045087\n",
      "\n",
      "Processing Belgian Grand Prix\n",
      "\n",
      "Results for Belgian Grand Prix - Random Forest:\n",
      "RMSE: 1.12 seconds\n",
      "R2 Score: 0.775\n",
      "Mean Error: 0.92 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "                   feature  importance\n",
      "5                  TyreDeg    0.202237\n",
      "4                 TyreLife    0.158269\n",
      "6                TempDelta    0.142368\n",
      "0                TrackTemp    0.134529\n",
      "10  TempInteractionSquared    0.118459\n",
      "\n",
      "Results for Belgian Grand Prix - XGBoost:\n",
      "RMSE: 1.34 seconds\n",
      "R2 Score: 0.677\n",
      "Mean Error: 1.09 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "              feature  importance\n",
      "6           TempDelta    0.415692\n",
      "0           TrackTemp    0.288164\n",
      "4            TyreLife    0.111815\n",
      "11  WeatherComplexity    0.073480\n",
      "8      TrackEvolution    0.035673\n",
      "\n",
      "Results for Belgian Grand Prix - Gradient Boosting:\n",
      "RMSE: 1.34 seconds\n",
      "R2 Score: 0.680\n",
      "Mean Error: 1.09 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "                   feature  importance\n",
      "6                TempDelta    0.330856\n",
      "4                 TyreLife    0.183217\n",
      "5                  TyreDeg    0.170472\n",
      "8           TrackEvolution    0.080550\n",
      "10  TempInteractionSquared    0.070230\n",
      "\n",
      "Processing Mexico City Grand Prix\n",
      "\n",
      "Results for Mexico City Grand Prix - Random Forest:\n",
      "RMSE: 1.05 seconds\n",
      "R2 Score: 0.505\n",
      "Mean Error: 0.77 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "              feature  importance\n",
      "1             AirTemp    0.489273\n",
      "8      TrackEvolution    0.208571\n",
      "11  WeatherComplexity    0.086104\n",
      "4            TyreLife    0.066092\n",
      "5             TyreDeg    0.062654\n",
      "\n",
      "Results for Mexico City Grand Prix - XGBoost:\n",
      "RMSE: 1.17 seconds\n",
      "R2 Score: 0.375\n",
      "Mean Error: 0.90 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "              feature  importance\n",
      "1             AirTemp    0.608189\n",
      "8      TrackEvolution    0.087145\n",
      "11  WeatherComplexity    0.068450\n",
      "16    Compound_MEDIUM    0.066138\n",
      "4            TyreLife    0.034888\n",
      "\n",
      "Results for Mexico City Grand Prix - Gradient Boosting:\n",
      "RMSE: 1.10 seconds\n",
      "R2 Score: 0.448\n",
      "Mean Error: 0.84 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "              feature  importance\n",
      "1             AirTemp    0.475628\n",
      "8      TrackEvolution    0.176599\n",
      "11  WeatherComplexity    0.109352\n",
      "5             TyreDeg    0.072201\n",
      "4            TyreLife    0.071545\n",
      "\n",
      "Processing United States Grand Prix\n",
      "\n",
      "Results for United States Grand Prix - Random Forest:\n",
      "RMSE: 1.33 seconds\n",
      "R2 Score: 0.417\n",
      "Mean Error: 1.05 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "                   feature  importance\n",
      "10  TempInteractionSquared    0.300427\n",
      "9          TempInteraction    0.283201\n",
      "8           TrackEvolution    0.234468\n",
      "11       WeatherComplexity    0.042663\n",
      "4                 TyreLife    0.027237\n",
      "\n",
      "Results for United States Grand Prix - XGBoost:\n",
      "RMSE: 1.59 seconds\n",
      "R2 Score: 0.163\n",
      "Mean Error: 1.27 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "              feature  importance\n",
      "9     TempInteraction    0.583169\n",
      "11  WeatherComplexity    0.135200\n",
      "8      TrackEvolution    0.118025\n",
      "0           TrackTemp    0.037846\n",
      "6           TempDelta    0.027296\n",
      "\n",
      "Results for United States Grand Prix - Gradient Boosting:\n",
      "RMSE: 1.45 seconds\n",
      "R2 Score: 0.310\n",
      "Mean Error: 1.16 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "                   feature  importance\n",
      "10  TempInteractionSquared    0.301519\n",
      "9          TempInteraction    0.283101\n",
      "8           TrackEvolution    0.210339\n",
      "11       WeatherComplexity    0.062277\n",
      "5                  TyreDeg    0.032606\n",
      "\n",
      "Processing British Grand Prix\n",
      "\n",
      "Results for British Grand Prix - Random Forest:\n",
      "RMSE: 1.32 seconds\n",
      "R2 Score: -0.075\n",
      "Mean Error: 1.03 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "              feature  importance\n",
      "8      TrackEvolution    0.423258\n",
      "0           TrackTemp    0.169432\n",
      "6           TempDelta    0.114612\n",
      "7       GripCondition    0.113560\n",
      "11  WeatherComplexity    0.062591\n",
      "\n",
      "Results for British Grand Prix - XGBoost:\n",
      "RMSE: 1.24 seconds\n",
      "R2 Score: 0.047\n",
      "Mean Error: 0.96 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "          feature  importance\n",
      "8  TrackEvolution    0.227264\n",
      "0       TrackTemp    0.157029\n",
      "7   GripCondition    0.134898\n",
      "2        Humidity    0.111574\n",
      "6       TempDelta    0.058466\n",
      "\n",
      "Results for British Grand Prix - Gradient Boosting:\n",
      "RMSE: 1.26 seconds\n",
      "R2 Score: 0.022\n",
      "Mean Error: 0.97 seconds\n",
      "\n",
      "Top 5 important features:\n",
      "          feature  importance\n",
      "8  TrackEvolution    0.423821\n",
      "0       TrackTemp    0.176351\n",
      "7   GripCondition    0.117170\n",
      "6       TempDelta    0.050927\n",
      "2        Humidity    0.049042\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Detailed Statistics by Track:\n",
      "\n",
      "Bahrain:\n",
      "Best RMSE: 1.41 seconds\n",
      "Best R²: 0.275\n",
      "Best Model: XGBoost\n",
      "\n",
      "Belgian:\n",
      "Best RMSE: 1.12 seconds\n",
      "Best R²: 0.775\n",
      "Best Model: Random Forest\n",
      "\n",
      "Mexico City:\n",
      "Best RMSE: 1.05 seconds\n",
      "Best R²: 0.505\n",
      "Best Model: Random Forest\n",
      "\n",
      "United States:\n",
      "Best RMSE: 1.33 seconds\n",
      "Best R²: 0.417\n",
      "Best Model: Random Forest\n",
      "\n",
      "British:\n",
      "Best RMSE: 1.24 seconds\n",
      "Best R²: 0.047\n",
      "Best Model: XGBoost\n",
      "\n",
      "Overall Model Rankings (by mean R²):\n",
      "                    mean    std\n",
      "Model                          \n",
      "Random Forest      0.364  0.321\n",
      "Gradient Boosting  0.344  0.243\n",
      "XGBoost            0.307  0.240\n"
     ]
    }
   ],
   "source": [
    "# Execute modeling pipeline\n",
    "track_results = prepare_modeling_data(merged_data)\n",
    "\n",
    "# Visualize results\n",
    "plot_model_performance(track_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Key Findings\n",
    "\n",
    "1. **Track-Specific Performance**:\n",
    "   - Best performance achieved on Belgian GP with Random Forest (R² = 0.775)\n",
    "   - Most challenging predictions for British GP (best R² = 0.047)\n",
    "   - Weather conditions appear to have strongest influence at Belgian GP\n",
    "\n",
    "2. **Model Comparison**:\n",
    "   - Random Forest consistently performs best across tracks\n",
    "   - XGBoost shows high variance in performance\n",
    "   - Gradient Boosting provides most stable results\n",
    "\n",
    "3. **Important Features**:\n",
    "   - Track temperature and air temperature interaction\n",
    "   - Track evolution throughout race\n",
    "   - Weather complexity score\n",
    "   - Tire degradation metrics\n",
    "\n",
    "## Next Steps for Improvement\n",
    "\n",
    "1. **Feature Engineering**:\n",
    "   - Create more sophisticated tire degradation models\n",
    "   - Incorporate historical track performance data\n",
    "   - Develop track-specific feature sets\n",
    "\n",
    "2. **Model Optimization**:\n",
    "   - Implement GridSearchCV for hyperparameter tuning\n",
    "   - Test neural network approaches\n",
    "   - Create track-specific model ensembles\n",
    "\n",
    "3. **Analysis Refinement**:\n",
    "   - Investigate poor performance on British GP\n",
    "   - Analyze weather condition thresholds\n",
    "   - Study interaction effects between features"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "csci349",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}