{"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":"code","source":"# Load packages\n\nimport folium\nimport geopandas as gpd\nimport itertools\nimport math\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport matplotlib.ticker as mtick\nimport numpy as np\nimport pandas as pd\nimport pickle\nimport plotly\nimport plotly.express as px\nimport pyproj\nimport pytorch_lightning as pl\nimport seaborn as sns\nimport torch\nimport torch.nn.functional as F\nimport warnings\n\nfrom datetime import datetime\nfrom folium.plugins import TimestampedGeoJson\nfrom IPython.core.display import HTML\nfrom shapely.geometry import Point, Polygon, LineString, GeometryCollection, MultiLineString\nfrom shapely import ops\nfrom sklearn import model_selection\nfrom torch.utils import data\nfrom torch import nn\nfrom torch.nn.utils.rnn import pad_sequence\nfrom typing import Optional\n\nmatplotlib.rcParams['figure.figsize'] = [12, 6]\npd.options.plotting.backend = 'matplotlib'\nsns.set_theme()\nwarnings.filterwarnings('ignore')\n\n# Load constants\n\nMETRES_FURLONGS = 201.168\nMETRES_FEET = 0.3048\nMILLIMETRES_INCHES = 25.4\nMETRES_HORSE_LENGTH = 2.4\n\nCENTROIDS = {\n    'Aqueduct': Point([-73.82975, 40.67241]),\n    'Belmont': Point([-73.72251, 40.71513]),\n    'Saratoga': Point([-73.76856, 43.07165]),\n}\n\nFINISH_LINES = {\n    'Aqueduct': LineString([[-73.832120, 40.671790], [-73.831066, 40.671509]]),\n    'Belmont': LineString([[-73.722341, 40.713886], [-73.722707, 40.713075]]),\n    'Saratoga': LineString([[-73.770886, 43.072484], [-73.770363, 43.071785]]),\n}\n\nRACE_GOINGS = {\n    'FM ': 'Firm',\n    'GD ': 'Good',\n    'FT ': 'Fast',\n    'MY ': 'Muddy',\n    'SY ': 'Sloppy',\n    'SF ': 'Soft',\n    'YL ': 'Yielding',\n}\n\nRACE_SURFACES = {\n    'D': 'Dirt',\n    'I': 'Inner Turf',\n    'M': 'Hurdle',\n    'O': 'Outer Turf',\n    'T': 'Turf',\n}\n\nRACE_TYPES = {\n    'ALW': 'Allowance',\n    'AOC': 'Allowance Optional Claimer',\n    'CLM': 'Claiming',\n    'MCL': 'Maiden Claiming',\n    'MSW': 'Maiden Special Weight',\n    'STK': 'Stakes',\n    'STR': 'Starter Allowance',\n    'SHP': 'Starter Handicap',\n    'SOC': 'Starter Optional Claimer',\n    'SST': 'Starter Stakes',\n    'WCL': 'Waiver Claiming',\n    'WMC': 'Waiver Maiden Claiming',\n}\n\nVENUES = {\n    'AQU': 'Aqueduct',\n    'BEL': 'Belmont',\n    'SAR': 'Saratoga',\n}\n\n\n# Load custom data types\n\nrace_going_type = pd.CategoricalDtype(RACE_GOINGS.values(), ordered=False)\nrace_surface_type = pd.CategoricalDtype(RACE_SURFACES.values(), ordered=False)\nrace_type_type = pd.CategoricalDtype(RACE_TYPES.values(), ordered=False)\n\n\n# Load helper functions\n\ndef complex_split(geom: LineString, splitter, tolerance=1.0e-12):\n    \"\"\"Split a complex linestring by another geometry without splitting at\n    self-intersection points.\n    \n    https://github.com/shapely/shapely/issues/1068#issuecomment-770296614\n    \"\"\"\n    if geom.is_simple:\n        return ops.split(geom, splitter)\n\n    if isinstance(splitter, Polygon):\n        splitter = splitter.exterior\n    \n    relate_str = geom.relate(splitter)\n    if relate_str[0] == '1':\n        raise ValueError('Cannot split LineString by a geometry which '\n                         'intersects a continuous portion of the LineString.')\n    if not (relate_str[0] == '0' or relate_str[1] == '0'):\n        return GeometryCollection((geom,))\n\n    intersection_points = geom.intersection(splitter)\n    snapped_geom = ops.snap(geom, intersection_points, tolerance=tolerance)\n    return ops.split(snapped_geom, intersection_points)\n\ndef count_points(row):\n    x, y = row.geometry.xy\n    return len(x)\n\ndef drafting_percentage(df):\n    n = df.num_trakus_points_before_finish_line.iat[0]\n    return df.head(n).draft.sum() / n\n\ndef speed_fluctuation(geometry):\n    coords = geometry.coords\n\n    if len(coords) < 100:\n        return np.NaN\n    \n    segment_distances = [math.hypot(p1x - p2x, p1y - p2y)\n                         for (p1x, p1y), (p2x, p2y)\n                         in zip(coords, coords[1:])]\n    \n    return np.array(segment_distances[80:-1]).std()\n\ndef truncate_at_finish_line(row):\n    date, venue, number, horse_id = row.name\n    finish_line = FINISH_LINES[venue]\n    splits = complex_split(row.geometry, finish_line)\n\n    if len(splits) == 1:\n        return True, row.geometry\n    else:\n        return False, ops.linemerge(MultiLineString(list(splits)[:-1]))\n    \ndef unwrap(series):\n    return pd.Series(np.unwrap(series, period=360), index=series.index)\n\n\n# Custom CSS fonts \n\nstyling = \"\"\"@import url('https://fonts.googleapis.com/css2?family=Montserrat&display=swap');@font-face { font-family: 'Montserrat', sans-serif; }\"\"\"\nHTML(\"<style>\"+styling+\"</style>\")\n\n\n# PyTorch DataModule and Model \n\nclass DataModule(pl.LightningDataModule):\n    def __init__(self, data_file, features, k=0, n_splits=5, seed=42, batch_size=32):\n        super().__init__()\n        self.save_hyperparameters()\n\n    def prepare_data(self):\n        df_Xy = pd.read_parquet(self.hparams.data_file)\n        \n        X = df_Xy.filter(self.hparams.features).drop(['public_odds', 'place'], axis=1, errors='ignore')\n        p = df_Xy.public_odds\n        y = df_Xy.place\n        \n        X = (X - X.min()) / (X.max() - X.min())  # normalise between 0 and 1\n        \n        X_race = X.groupby(['date', 'venue', 'number']).apply(lambda df: torch.tensor(df.values))\n        p_race = p.groupby(['date', 'venue', 'number']).apply(lambda df: torch.tensor(df.values))\n        y_race = y.groupby(['date', 'venue', 'number']).apply(lambda df: torch.tensor(df.values))\n        \n        X_pad = pad_sequence(tuple(X_race), batch_first=True, padding_value=0.0).float()\n        p_pad = pad_sequence(tuple(p_race), batch_first=True, padding_value=1e-12).float()\n        y_pad = pad_sequence(tuple(y_race), batch_first=True, padding_value=999).long()\n                \n        self.dataset = data.TensorDataset(X_pad, p_pad, y_pad)\n        self.num_features = X.shape[1]\n        self.use_public_odds = 'public_odds' in self.hparams.features\n        \n    def setup(self, stage: Optional[str] = None):\n        kf = model_selection.KFold(n_splits=self.hparams.n_splits, shuffle=True, random_state=self.hparams.seed)\n        splits = [k for k in kf.split(self.dataset)]\n        train_indexes, val_indexes = splits[self.hparams.k]\n        train_indexes, val_indexes = train_indexes.tolist(), val_indexes.tolist()\n        self.train_set, self.val_set = data.Subset(self.dataset, train_indexes), data.Subset(self.dataset, val_indexes)\n        \n    def train_dataloader(self):\n        return data.DataLoader(self.train_set, batch_size=self.hparams.batch_size)\n\n    def val_dataloader(self):\n        return data.DataLoader(self.val_set, batch_size=self.hparams.batch_size)\n    \n    \nclass Model(pl.LightningModule):\n    def __init__(self, num_features, use_public_odds):\n        super().__init__()\n        self.save_hyperparameters()\n        self.linear = nn.Linear(num_features, 1, bias=False)\n        \n    def forward(self, x, p):\n        utility = torch.log(p * 1000) if self.hparams.use_public_odds else 0\n        return F.softmax(self.linear(x).squeeze() + utility, dim=1)\n    \n    def training_step(self, batch, batch_idx):\n        loss, pred = self._shared_evaluation(batch, batch_idx)\n        return loss\n\n    def validation_step(self, batch, batch_idx):\n        loss, pred = self._shared_evaluation(batch, batch_idx)\n        self.log('val_loss', loss)\n    \n    def _shared_evaluation(self, batch, batch_idx):\n        x, p, y = batch\n        pred = self(x, p)\n        loss = F.nll_loss(torch.log(pred), y.argmin(axis=1))\n        return loss, pred\n\n    def configure_optimizers(self):\n        return torch.optim.Adam(self.parameters(), lr=1e-3, weight_decay=1e-4)\n    \n    \n# Load Trakus data\n\nnames = ['venue', 'date', 'number', 'horse_number', 'trakus_id', 'latitude',\n         'longitude', 'race_official_distance', 'race_surface', 'race_going',\n         'race_run_up_distance', 'race_type', 'race_prize', 'race_post_time',\n         'weight_carried', 'jockey', 'odds', 'place']\n\ndf_trakus = (pd.read_csv('/kaggle/input/big-data-derby-2022/nyra_2019_complete.csv',\n                         names=names,\n                         dtype={'race_post_time': 'str'},\n                         converters={'horse_number': str.strip, 'venue': lambda x: VENUES[x]},\n                         parse_dates=['date'])\n             .assign(race_official_distance=lambda df: df.race_official_distance / 100.0 * METRES_FURLONGS,\n                     race_run_up_distance=lambda df: df.race_run_up_distance * METRES_FEET,\n                     race_total_distance=lambda df: df.race_run_up_distance + df.race_official_distance,\n                     race_going=lambda df: df.race_going.replace(RACE_GOINGS).astype(race_going_type),\n                     race_surface=lambda df: df.race_surface.replace(RACE_SURFACES).astype(race_surface_type),\n                     race_type=lambda df: df.race_type.replace(RACE_TYPES).astype(race_type_type),\n                     race_post_time=lambda df: pd.to_datetime(df.date.astype(str) + df.race_post_time, format='%Y-%m-%d0%H%M'),\n                     odds=lambda df: df.odds / 100.0))\n\n# Remove Steeplechase races\ndf_trakus = df_trakus[df_trakus.race_surface != 'Hurdle']\n\n# Merge Horse IDs\ns_horse_ids = (pd.read_csv('/kaggle/input/big-data-derby-2022-global-horse-ids-and-places/horse_ids.csv',\n                            header=0,\n                            names=['index', 'venue', 'date', 'number', 'horse_number', 'horse_id', 'place'],\n                            index_col=['date', 'venue', 'number', 'horse_number'],\n                            dtype={'horse_number': 'str'},\n                            converters={'horse_number': str.strip, 'venue': lambda x: VENUES[x]},\n                            parse_dates=['date'])\n                .horse_id)\n\ndf_trakus = df_trakus.merge(s_horse_ids, left_on=['date', 'venue', 'number', 'horse_number'], right_index=True)\n\n# Merge Horse Names\ns_horse_names = pd.read_csv('/kaggle/input/big-data-derby-2022-global-horse-ids-and-places/horse_names.csv', index_col='horse_id').horse_name\n\ndf_trakus = df_trakus.merge(s_horse_names, left_on='horse_id', right_index=True)\n\ndf_trakus = (df_trakus\n             .set_index(['date', 'venue', 'number', 'horse_id', 'trakus_id'])\n             .sort_index())\n\n\n# Generate features\n\ng = pyproj.Geod(ellps='WGS84')\n\n# Insert centroid coordinates into df_trakus\nfor venue in VENUES.values():\n    condition = df_trakus.index.get_level_values('venue') == venue\n    df_trakus.loc[condition, 'race_centroid_longitude'] = CENTROIDS[venue].x\n    df_trakus.loc[condition, 'race_centroid_latitude'] = CENTROIDS[venue].y\n\n# Calculate unwrapped azimuth (bearing) and distance_to_race_centroid\ndf_trakus['azimuth'], _, df_trakus['distance_to_race_centroid'] = g.inv(\n    df_trakus.race_centroid_longitude, df_trakus.race_centroid_latitude,\n    df_trakus.longitude, df_trakus.latitude\n)\n\ndf_trakus.azimuth = (df_trakus\n                     .groupby(['date', 'venue', 'number', 'horse_id'])\n                     .azimuth\n                     .apply(unwrap))\n\n# Determine running_position from azimuth\ndf_trakus['running_position'] = (df_trakus\n                                 .groupby(['date', 'venue', 'number', 'trakus_id'])\n                                 .azimuth\n                                 .rank())\n\n# Determine distance_behind_leader from running_position\ndf_leader = (df_trakus\n             .sort_values('running_position')\n             .groupby(['date', 'venue', 'number', 'trakus_id'])\n             .agg({'longitude': 'first', 'latitude': 'first'})\n             .add_prefix('leader_'))\n\ndf_trakus = df_trakus.merge(df_leader,\n                            left_on=['date', 'venue', 'number', 'trakus_id'],\n                            right_index=True)\n_, _, df_trakus['distance_behind_leader'] = g.inv(\n    df_trakus.leader_longitude, df_trakus.leader_latitude,\n    df_trakus.longitude, df_trakus.latitude\n)\n\n# Calculate longitude/latitude of draft point from azimuth of prev/next points\ndf_trakus['longitude_prev'] = (df_trakus\n                               .groupby(['date', 'venue', 'number', 'horse_id'])\n                               .longitude\n                               .shift(-1)\n                               .fillna(df_trakus.longitude))\ndf_trakus['longitude_next'] = (df_trakus\n                               .groupby(['date', 'venue', 'number', 'horse_id'])\n                               .longitude\n                               .shift()\n                               .fillna(df_trakus.longitude))\ndf_trakus['latitude_prev'] = (df_trakus\n                              .groupby(['date', 'venue', 'number', 'horse_id'])\n                              .latitude\n                              .shift(-1)\n                              .fillna(df_trakus.latitude))\ndf_trakus['latitude_next'] = (df_trakus\n                              .groupby(['date', 'venue', 'number', 'horse_id'])\n                              .latitude\n                              .shift()\n                              .fillna(df_trakus.latitude))\n\n_, azimuth, _ = g.inv(df_trakus.longitude_prev, df_trakus.latitude_prev,\n                      df_trakus.longitude_next, df_trakus.latitude_next)\n\ndf_trakus['longitude_draft'], df_trakus['latitude_draft'], _ = g.fwd(\n    df_trakus.longitude, df_trakus.latitude, azimuth, 3*np.ones(len(azimuth))\n)\n\n# Determine draft from draft point\ngdf_trakus = gpd.GeoDataFrame((df_trakus\n                               .assign(geometry=lambda df: gpd.points_from_xy(df.longitude, df.latitude),\n                                       geometry_draft=lambda df: gpd.points_from_xy(df.longitude_draft, df.latitude_draft))),\n                              geometry='geometry', crs='epsg:4326').to_crs(32118)\n\ngdf_shape = gdf_trakus.dissolve(['date', 'venue', 'number', 'trakus_id'])  # 4min\n\ngdf_trakus = (gdf_trakus\n              .set_geometry('geometry_draft', crs='epsg:4326')\n              .to_crs(32118))\n\ndf_trakus['draft'] = (gdf_trakus\n                      .buffer(2)\n                      .intersects(gdf_shape)\n                      .reorder_levels([0, 1, 2, 4, 3]))  # 2min\n\ndf_trakus.to_parquet('df_trakus.parquet')\n\n\n# Process Trakus datapoints\n\ndf_trakus = pd.read_parquet('df_trakus.parquet')\n\ndrop_columns = ['latitude', 'longitude', 'leader_longitude', 'leader_latitude',\n                'distance_to_race_centroid', 'distance_behind_leader',\n                'azimuth', 'running_position', \n                'longitude_prev', 'longitude_next',\n                'latitude_prev', 'latitude_next',\n                'longitude_draft', 'latitude_draft', 'draft']\ndf_starters = (df_trakus\n               .assign(geometry=lambda df: gpd.points_from_xy(df.longitude, df.latitude))\n               .groupby(['date', 'venue', 'number', 'horse_id'])\n               .agg(dict({column: 'first'\n                          for column in df_trakus.columns\n                          if column not in drop_columns},\n                         geometry=lambda x: LineString(x))))  # 2 min\n\n# Determine num_starters_in_race\ndf_starters['num_starters_in_race'] = (df_starters\n                                       .groupby(['date', 'venue', 'number'])\n                                       .size())\n\n# Determine draw \ndf_starters['draw'] = (df_trakus\n                       .groupby(['date', 'venue', 'number', 'horse_id'])\n                       .distance_to_race_centroid\n                       .nth(0)\n                       .groupby(['date', 'venue', 'number'])\n                       .rank())\n\n# Determine running_position at pace call\ndf_starters['running_position_at_pace_call'] = (df_trakus\n                                                .groupby(['date', 'venue', 'number', 'horse_id'])\n                                                .running_position\n                                                .nth(79))\n\n# Determine distance_behind_leader at pace call\ndf_starters['distance_behind_leader_at_pace_call'] = (df_trakus\n                                                      .groupby(['date', 'venue', 'number', 'horse_id'])\n                                                      .distance_behind_leader\n                                                      .nth(79))\n\n# Racing strategies\ndf_starters['racing_strategy'] = (df_starters.running_position_at_pace_call - 1) / (df_starters.num_starters_in_race - 1)\ndf_starters['early'] = (df_starters.running_position_at_pace_call - 1 == 0)\ndf_starters['early_presser'] = ((df_starters.running_position_at_pace_call - 1 > 0) &\n                                (df_starters.running_position_at_pace_call - 1 <= 0.25 * (df_starters.num_starters_in_race - 1)) &\n                                (df_starters.distance_behind_leader_at_pace_call < 2 * METRES_HORSE_LENGTH))\ndf_starters['presser'] = ((df_starters.running_position_at_pace_call - 1 > 0.25 * (df_starters.num_starters_in_race - 1)) &\n                          (df_starters.running_position_at_pace_call - 1 <= 0.75 * (df_starters.num_starters_in_race - 1)))\ndf_starters['sustainer'] = (df_starters.running_position_at_pace_call - 1 > 0.75 * (df_starters.num_starters_in_race - 1))\n\n# Convert odds to utility\ndf_starters['p_overround'] = 1 / (df_starters.odds + 1)\ndf_starters['overround'] = df_starters.groupby(['date', 'venue', 'number']).p_overround.sum()\ndf_starters['p'] = df_starters.p_overround / df_starters.overround\n\n# Truncate geometry at finish line\ndf_starters[['did_not_cross_finish_line', 'truncated_geometry']] = (\n    df_starters.apply(truncate_at_finish_line, axis=1, result_type='expand')\n)\n\n# Drafting\ndf_trakus['num_trakus_points_before_finish_line'] = df_starters.apply(count_points, axis=1) - 1\ndf_starters['drafting_percentage'] = df_trakus.groupby(['date', 'venue', 'number', 'horse_id']).apply(drafting_percentage)\n\n# Mark starters that did not finish\ndf_starters['num_trakus_points'] = (df_trakus\n                                    .groupby(['date', 'venue', 'number', 'horse_id'])\n                                    .size())\ndf_starters['race_num_trakus_points'] = (df_starters\n                                         .groupby(['date', 'venue', 'number'])\n                                         .num_trakus_points\n                                         .max())\ndf_starters['did_not_finish_tracking'] = df_starters.num_trakus_points < df_starters.race_num_trakus_points\n\ndf_starters['did_not_finish'] = df_starters.did_not_finish_tracking | df_starters.did_not_cross_finish_line\n\n\n# Generate GeoPandas DataFrame\n\ngdf_starters = gpd.GeoDataFrame(df_starters, geometry='truncated_geometry', crs='epsg:4326').to_crs(32118)\ngdf_starters['total_distance'] = gdf_starters.length\ngdf_starters['path_efficiency'] = gdf_starters.race_total_distance / gdf_starters.total_distance\ngdf_starters['speed_fluctuation'] = gdf_starters.truncated_geometry.apply(speed_fluctuation)\ngdf_starters.to_parquet('gdf_starters.parquet')\n\n\n# Generate df_Xy\n\ngdf_starters = gpd.read_parquet('gdf_starters.parquet')\nconditions = (~gdf_starters.did_not_finish) & (gdf_starters.path_efficiency > 0.96) \n(gdf_starters[conditions]\n .rename(columns={'p': 'public_odds'})\n .filter(['draw', 'weight_carried', 'drafting_percentage', 'racing_strategy', 'path_efficiency', 'speed_fluctuation', 'public_odds', 'place'])\n .to_parquet('df_Xy.parquet'))","metadata":{"execution":{"iopub.status.busy":"2022-11-10T06:33:18.685610Z","iopub.execute_input":"2022-11-10T06:33:18.686073Z","iopub.status.idle":"2022-11-10T06:33:18.735308Z","shell.execute_reply.started":"2022-11-10T06:33:18.686038Z","shell.execute_reply":"2022-11-10T06:33:18.733952Z"},"_kg_hide-input":true,"_kg_hide-output":true,"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<p><b>Analytics Competition</b></p>\n<p style=\"font-size: 48px\">Advanced horse race tactics using Trakus coordinate data</p>\n<p style=\"font-size: 24px; font-style: italic\">The impact of drafting percentage, path efficiency, race strategy and speed fluctuation on horse race tactics.</p>\n\n![saratoga.jpg](attachment:3a5772ab-ff7f-4066-837b-daa3566cefba.jpg)\n\n<div style=\"float: left\">\n    <img style=\"display: inline; margin: 0; padding: 4px; width: 64px; height: 64px; border-radius: 50%; object-fit: cover; object-position: 50% 50%; background-color: #fff\" alt=\"Timothy Leung\" src=\"https://neuralswarm.com/assets/images/authors/tlyleung.jpg\">\n    <img style=\"display: inline; margin: 0 0 0 -16px; padding: 4px; width: 64px; height: 64px; border-radius: 50%; object-fit: cover; object-position: 50% 50%; background-color: #fff\" alt=\"Philip Leung\" src=\"https://neuralswarm.com/assets/images/authors/plyleung.jpg\">\n</div>\n<div style=\"display: inline; height: 64px; padding-left: 12px; display: table\">\n    <div style=\"display: table-cell; vertical-align: middle\">By <a href=\"http://neuralswarm.com\">Timothy Leung</a> and <a href=\"http://www.eliteteaching.hk\">Philip Leung</a><br />10 November 2022</div></div>","metadata":{},"attachments":{"3a5772ab-ff7f-4066-837b-daa3566cefba.jpg":{"image/jpeg":"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"}}},{"cell_type":"markdown","source":"# Executive Summary\n\nIn this report, we will:\n1. Extract four performance-impacting features (drafting proportion, path efficiency, race strategy, speed fluctuation) from the coordinate data\n2. Analyse these features in relation to race distance and race surface/going\n3. Determine the predictive power of these features using a Multinomial Logit model\n4. Recommend racing strategies which we think will help horse owners, trainers and jockeys\n\n<div class=\"alert alert-info\" role=\"alert\">\n    <p><b>Key Takeaways</b></p>\n    <ul style=\"color: rgba(0,0,0,.7)\">\n        <li style=\"margin: 10px 0\">Jockeys and trainers should choose race tactics that prioritise <b>increasing path efficiency</b> and <b>decreasing speed fluctuation</b> over drafting percentage and racing strategy.</li>\n        <li style=\"margin: 10px 0\"><b>Public odds significantly undervalue horses with lower speed fluctuations.</b> If these undervalued horses can be identified before the race, this inefficiency can be exploited by placing exotic bets covering these horses.</li>\n    </ul>\n</div>","metadata":{}},{"cell_type":"markdown","source":"# Introduction\n\nThe most groundbreaking information provided in the NYTHA/NYRA dataset is the Trakus coordinate data provided for each horse during the race. Our focus is to extract features from the coordinate data which will help horse owners, trainers and jockeys make better decisions on their racing strategies.\n\nThe four features we will generate and analyse are the drafting proportion, path efficiency, race strategy (early runner or sustainer, etc.) and speed fluctuation of a horse during a race. Although horse trainers and jockeys may not be able to control exactly how much drafting benefit they receive, jockeys can certainly attempt to choose strategies that offer more drafting opportunities.\n\nWe supplement the Trakus coordinate dataset with the [Big Data Derby 2022: Global Horse IDs and places dataset](https://www.kaggle.com/datasets/themarkgreen/big-data-derby-2022-global-horse-ids-and-places) compiled by Mark Green.","metadata":{"execution":{"iopub.status.busy":"2022-10-31T00:05:46.298794Z","iopub.execute_input":"2022-10-31T00:05:46.299865Z","iopub.status.idle":"2022-10-31T00:05:52.209318Z","shell.execute_reply.started":"2022-10-31T00:05:46.299821Z","shell.execute_reply":"2022-10-31T00:05:52.208321Z"}}},{"cell_type":"markdown","source":"# Data Preprocessing\n\n## Coordinate Reference System Transformation\nWe use GeoPandas to transform the Trakus coordinate data from the latitude/longitude coordinate reference system based on the Earth’s center of mass that uses degrees as its measurement unit (ESPSG:4326) to a coordinate reference system centered on New York Long Island that uses metres as its measurement unit (EPSG: 32118). This transformation enables more accurate distance calculations. \n\n## Finish Line Truncation\nThe first Trakus sample provided for each race represents the starting position of the horses at the beginning of the race run-up. However, the final Trakus sample of each race does not represent the point where the horses cross the finish line, but is quite some time after the race finishes. The coordinates of the horses after they cross the finish line are irrelevant because the race has already finished.\n\nTo remove all coordinates where the horse has already finished the race, we sketch each horse’s path, intersect it with the finish line, and remove the coordinates past the finish line. To determine the location of the finish line, we pinpointed the exact coordinate location of the line on Google Maps.\n\nThis is what it looks like:","metadata":{}},{"cell_type":"code","source":"gdf_starters = gpd.read_parquet('gdf_starters.parquet')\ngdf_starters = gdf_starters.set_geometry('geometry', crs='epsg:4326').to_crs(32118)\n\ndate, venue, number = '2019-06-08', 'Belmont', 3\ngdf_race = gdf_starters[(gdf_starters.index.get_level_values('date') == date) &\n                        (gdf_starters.index.get_level_values('venue') == venue) &\n                        (gdf_starters.index.get_level_values('number') == number)]\n\ngdf_race['winner'] = (gdf_race.place == 1)\ngdf_race = gdf_race.filter(['horse_name', 'jockey', 'winner', 'place', 'geometry'])\ngdf_race = (gdf_race.assign(**{'Horse': lambda df: df.horse_name,\n                             'Jockey': lambda df: df.jockey,\n                             'Winner': lambda df: df.winner,\n                             'Place': lambda df: df.place}))\nm = gdf_race.explore('Winner',\n                     cmap=lambda value: '#dd8450',\n                     legend=False,\n                     tooltip=['Horse', 'Jockey', 'Place'],\n                     style_kwds={'weight': 0.5})\n\ntitle = f'Without Finish Line Truncation (Race {number}, {venue}, {datetime.strptime(date, \"%Y-%m-%d\"):%-d %B %Y})'\nm.get_root().html.add_child(folium.Element(f'<head><style> html {{ overflow-y: hidden; }} </style></head><h3 align=\"center\" style=\"font-size:16px\"><b>{title}</b></h3>'))\n\n# Add finish line\nx, y = FINISH_LINES[venue].xy\ncoordinates = zip(y.tolist(), x.tolist())\nfinish_line = folium.PolyLine(locations=list(coordinates), color='black', weight=3)\nm.add_child(finish_line)\n\nm","metadata":{"_kg_hide-input":true,"execution":{"iopub.status.busy":"2022-11-10T13:19:30.432633Z","iopub.execute_input":"2022-11-10T13:19:30.433110Z","iopub.status.idle":"2022-11-10T13:19:33.551212Z","shell.execute_reply.started":"2022-11-10T13:19:30.433071Z","shell.execute_reply":"2022-11-10T13:19:33.550066Z"},"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"gdf_starters = gpd.read_parquet('gdf_starters.parquet')\ndate, venue, number = '2019-06-08', 'Belmont', 3\ngdf_race = gdf_starters[(gdf_starters.index.get_level_values('date') == date) &\n                        (gdf_starters.index.get_level_values('venue') == venue) &\n                        (gdf_starters.index.get_level_values('number') == number)]\n\ngdf_race['winner'] = (gdf_race.place == 1)\ngdf_race = gdf_race.filter(['horse_name', 'jockey', 'winner', 'place', 'truncated_geometry'])\ngdf_race = (gdf_race.assign(**{'Horse': lambda df: df.horse_name,\n                             'Jockey': lambda df: df.jockey,\n                             'Winner': lambda df: df.winner,\n                             'Place': lambda df: df.place}))\nm = gdf_race.explore('Winner',\n                     cmap=lambda value: '#dd8450',\n                     legend=False,\n                     tooltip=['Horse', 'Jockey', 'Place'],\n                     style_kwds={'weight': 0.5})\n\ntitle = f'With Finish Line Truncation (Race {number}, {venue}, {datetime.strptime(date, \"%Y-%m-%d\"):%-d %B %Y})'\nm.get_root().html.add_child(folium.Element(f'<head><style> html {{ overflow-y: hidden; }}</style></head><h3 align=\"center\" style=\"font-size:16px\"><b>{title}</b></h3>'))\n\n# Add finish line\nx, y = FINISH_LINES[venue].xy\ncoordinates = zip(y.tolist(), x.tolist())\nfinish_line = folium.PolyLine(locations=list(coordinates), color='black', weight=3)\nm.add_child(finish_line)","metadata":{"_kg_hide-input":true,"execution":{"iopub.status.busy":"2022-11-10T13:19:41.105376Z","iopub.execute_input":"2022-11-10T13:19:41.105801Z","iopub.status.idle":"2022-11-10T13:19:42.106444Z","shell.execute_reply.started":"2022-11-10T13:19:41.105766Z","shell.execute_reply":"2022-11-10T13:19:42.105426Z"},"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Feature Engineering\n\nWe outline four features generated from the Trakus coordinate data that we use to determine horse performance:\n- **Drafting Percentage:** percentage of the race where a horse has a drafting benefit.\n- **Racing Strategy:** whether a horse prefers to lead from the front, settle in the middle of the pack, or start slow.\n- **Path Efficiency:** the efficiency of the path the horse takes around the course.\n- **Speed Fluctuation:** the amount of variation in velocity the horse experiences once the horse has settled into the race.","metadata":{}},{"cell_type":"markdown","source":"## How much drafting benefit does each horse receive?\n\nTo generate a feature representing drafting benefit, we need to look at the fundamentals of drafting. The reduction of aerodynamic drag from drafting is an essential element of horseracing because horses are able to save energy which they can expend closer to the finish line. Drafting occurs when a horse follows closely behind another horse.\n\nThe coordinate data helps us look slightly ahead of each horse to see if another horse occupies that space. We draw a circle 3 metres ahead of the horse’s current coordinate position and if another horse’s coordinate lies inside the 2 metre radius circle, then there is a drafting benefit.\n\nIn the figure below:\n- red points represent horses *with* draft benefit\n- black points represent horses *without* draft benefit\n- yellow circles represent look-ahead regions used to check for the presence of drafting","metadata":{"execution":{"iopub.status.busy":"2022-11-07T02:33:57.274033Z","iopub.execute_input":"2022-11-07T02:33:57.274566Z","iopub.status.idle":"2022-11-07T02:33:57.289882Z","shell.execute_reply.started":"2022-11-07T02:33:57.274519Z","shell.execute_reply":"2022-11-07T02:33:57.287704Z"}}},{"cell_type":"code","source":"def draft_feature(row):\n    return {\n        'type': 'Feature',\n        'geometry': {'type': 'Point', 'coordinates': [row.longitude_draft, row.latitude_draft]},\n        'properties': {\n            'time': str(row.time).split('.')[0],\n            'style': {'color': ''},\n            'tooltip': row.horse_name,\n            'icon': 'circle',\n            'iconstyle': {'fillColor': 'yellow', 'fillOpacity': 0.3, 'stroke': 'false', 'radius': 4},\n        },\n    }\n\ndef horse_feature(row):\n    return {\n        'type': 'Feature',\n        'geometry': {'type': 'Point', 'coordinates': [row.longitude, row.latitude]},\n        'properties': {\n            'time': str(row.time).split('.')[0],\n            'style': {'color': ''},\n            'tooltip': row.horse_name,\n            'icon': 'circle',\n            'iconstyle': {'fillColor': 'red' if row.draft else 'black', 'fillOpacity': 1, 'stroke': 'false', 'radius': 2},\n        },\n    }\n\ndf_trakus = pd.read_parquet('df_trakus.parquet')\ndate, venue, number = '2019-07-13', 'Saratoga', 6\ndf_temp = df_trakus[(df_trakus.index.get_level_values('date') == date) &\n                    (df_trakus.index.get_level_values('venue') == venue) &\n                    (df_trakus.index.get_level_values('number') == number)]\n\ndf_temp = df_temp[df_temp.index.get_level_values('trakus_id') % 2 == 0]\ndf_temp['time'] = df_temp.race_post_time + pd.to_timedelta(df_temp.index.get_level_values('trakus_id'), unit='s')\n\nx, y = CENTROIDS[venue].coords[0]\nm = folium.Map(location=[y, x], zoom_start=17)\n\nfeatures = []\nfor horse_id, df1 in df_temp.groupby(['horse_id']):\n    features.extend(df1.reset_index().apply(draft_feature, axis=1).tolist())\n    features.extend(df1.reset_index().apply(horse_feature, axis=1).tolist())\n\nTimestampedGeoJson(features, period='PT2S', duration='PT1S', add_last_point=False).add_to(m)\nm","metadata":{"execution":{"iopub.status.busy":"2022-11-10T06:34:36.261245Z","iopub.execute_input":"2022-11-10T06:34:36.261748Z","iopub.status.idle":"2022-11-10T06:34:41.117898Z","shell.execute_reply.started":"2022-11-10T06:34:36.261711Z","shell.execute_reply":"2022-11-10T06:34:41.115376Z"},"_kg_hide-input":true,"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Using this method, we can determine whether a horse receives a drafting benefit for every coordinate of a race. Hence, we can calculate the percentage of the race where a horse is receiving a drafting benefit. This feature takes a value between 0 and 1 inclusive, where 0 means that a horse received no drafting benefit during the race and 1 means that a horse received a drafting benefit for 100% of the race.","metadata":{}},{"cell_type":"markdown","source":"## What racing strategy is used by each horse?\n\nTo determine the racing strategy of each horse, we look at each horse’s running position once the race settles. This is usually determined at the first call of the race which is approximately 20 seconds into the race. The assumption is that the horses are still fresh near the start of the race so they can implement their strategy and position themselves ideally at the first call. At the first call, front runners would have a lower running position while horses that start slow and finish quickly would have a higher running position.\n\nHowever, we are not given the running position of each horse so we will estimate the running position of the horses by calculating the angle of each coordinate from the centroid of the racetrack.","metadata":{}},{"cell_type":"code","source":"df_trakus = pd.read_parquet('df_trakus.parquet')\n# date, venue, number, trakus_id = '2019-07-13', 'Saratoga', 1, 80\ndate, venue, number, trakus_id = '2019-04-14', 'Aqueduct', 6, 80\ndf_temp = df_trakus[(df_trakus.index.get_level_values('date') == date) &\n                    (df_trakus.index.get_level_values('venue') == venue) &\n                    (df_trakus.index.get_level_values('number') == number) &\n                    (df_trakus.index.get_level_values('trakus_id') == trakus_id)]\n\na = (df_temp\n     .filter(['longitude', 'latitude', 'horse_name', 'running_position', 'jockey', 'distance_behind_leader', 'draft'])\n     .assign(draft_marker=False))\nb = (df_temp\n     .filter(['longitude_draft', 'latitude_draft', 'horse_name', 'running_position', 'jockey', 'distance_behind_leader', 'draft'])\n     .rename(columns={'longitude_draft': 'longitude', 'latitude_draft': 'latitude'})\n     .assign(draft_marker=True))\n\ndf_temp = (pd.concat([a, b], axis=0)\n           .assign(geometry=lambda df: gpd.points_from_xy(df.longitude, df.latitude)))\ndf_temp = (df_temp.assign(**{'Horse': lambda df: df.horse_name,\n                             'Jockey': lambda df: df.jockey,\n                             'Running Position': lambda df: df.running_position.astype(int),\n                             'Distance Behind Leader': lambda df: df.distance_behind_leader,\n                             'Draft': lambda df: df.draft}))\n\ngdf_temp = gpd.GeoDataFrame(df_temp, geometry='geometry', crs='epsg:4326').to_crs(32118)\ngdf_temp.loc[gdf_temp.draft_marker, 'geometry'] = gdf_temp[gdf_temp.draft_marker].geometry.buffer(2)\nm = gdf_temp.explore('draft_marker',\n                     cmap=lambda value: 'transparent' if value else 'black',\n                     legend=False,\n                     tooltip=['Horse', 'Jockey', 'Running Position', 'Distance Behind Leader', 'Draft'],\n                     style_kwds={'stroke': False})\n\ntitle = f'Horse Running Positions at {trakus_id * 0.25}s (Race {number}, {venue}, {datetime.strptime(date, \"%Y-%m-%d\"):%-d %B %Y})'\nm.get_root().html.add_child(folium.Element(f'<head><style> html {{ overflow-y: hidden; }}</style></head><h3 align=\"center\" style=\"font-size:16px\"><b>{title}</b></h3>'))\n\nx, y = CENTROIDS[venue].xy\n\nfor row in a.itertuples():\n    line = folium.PolyLine(locations=[[y[0], x[0]], [row.latitude, row.longitude]],color='grey',weight=1, dash_array='4')\n    m.add_child(line)\n    \nm","metadata":{"execution":{"iopub.status.busy":"2022-11-10T06:34:47.977585Z","iopub.execute_input":"2022-11-10T06:34:47.977989Z","iopub.status.idle":"2022-11-10T06:34:52.384734Z","shell.execute_reply.started":"2022-11-10T06:34:47.977957Z","shell.execute_reply":"2022-11-10T06:34:52.383250Z"},"_kg_hide-input":true,"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We also normalise the value of the running position so that the feature is easier to compare between races with a different number of participants. After the normalisation, our racing strategy feature takes a value between 0 and 1 inclusive, where 0 means that the horse was leading 20 seconds into the race and 1 means that the horse was in last place 20 seconds into the race.","metadata":{}},{"cell_type":"markdown","source":"## How efficient is the horse’s path?\n\nA horse’s path is more efficient when it travels close to the rail because it travels less distance. However, this might not always be the best choice because the path closest to the rail might be congested with other horses, so it might make more sense to choose a less efficient path by going around the other horses. Also, the path close to the rail might be more muddy when it rains, which means that the shortest path might no longer be the ideal path.\n\nTo produce this feature of path efficiency, we first calculate the distance the horse travels by converting its path coordinates into segment distances (with the help of an improved Vincenty formula that uses geodesic distances) and adding them up. Then, in order to create a path efficiency metric we take the official race distance and divide it by the distance travelled by the horse, so a path efficiency of 1 means that the horse travelled the official distance of the race and 0.5 means that the horse travelled double the official distance of the race.\n\nHere is a visual representation of a race consisting of a starter with a higher path efficiency (in blue) compared to one in the same race with a lower path efficiency (in orange):","metadata":{}},{"cell_type":"code","source":"gdf_starters = gpd.read_parquet('gdf_starters.parquet')\n\ndate, venue, number = '2019-04-14', 'Aqueduct', 6\ngdf_race = gdf_starters[(gdf_starters.index.get_level_values('date') == date) &\n                        (gdf_starters.index.get_level_values('venue') == venue) &\n                        (gdf_starters.index.get_level_values('number') == number)]\n\ngdf_race = gdf_race.reset_index('horse_id').sort_values('path_efficiency').iloc[[0, -1]]\ngdf_race = gdf_race.filter(['horse_id', 'horse_name', 'jockey', 'total_distance', 'path_efficiency', 'truncated_geometry'])\ngdf_race = (gdf_race.assign(**{'Horse': lambda df: df.horse_name,\n                               'Jockey': lambda df: df.jockey,\n                               'Total Distance': lambda df: df.total_distance,\n                               'Path Efficiency': lambda df: df.path_efficiency}))\n\nm = gdf_race.explore('horse_id',\n                     cmap=lambda value: '#dd8450' if value > 400 else '#4b72b0',\n#                      zoom_start=19,\n#                      max_zoom=19,\n                     legend=False,\n                     tooltip=['Horse', 'Jockey', 'Total Distance', 'Path Efficiency'],\n                    )\n\ntitle = f'Horse Running Paths (Race {number}, {venue}, {datetime.strptime(date, \"%Y-%m-%d\"):%-d %B %Y})'\nm.get_root().html.add_child(folium.Element(f'<head><style> html {{ overflow-y: hidden; }}</style></head><h3 align=\"center\" style=\"font-size:16px\"><b>{title}</b></h3>'))\n\n# Add finish line\nx, y = FINISH_LINES[venue].xy\ncoordinates = zip(y.tolist(), x.tolist())\nfinish_line = folium.PolyLine(locations=list(coordinates),color='black',weight=3)\nm.add_child(finish_line)\n\nm","metadata":{"execution":{"iopub.status.busy":"2022-11-10T06:34:52.387445Z","iopub.execute_input":"2022-11-10T06:34:52.388033Z","iopub.status.idle":"2022-11-10T06:34:53.437444Z","shell.execute_reply.started":"2022-11-10T06:34:52.387990Z","shell.execute_reply":"2022-11-10T06:34:53.436105Z"},"_kg_hide-input":true,"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## How consistent is the horse’s speed?\n\nHorses with a smooth race usually have a low speed fluctuation because they have not needed to slow down suddenly due to being blocked by other horses. These unnecessary speed changes, in particular deceleration, cause horses to exert an unnecessary amount of energy which could be used to maintain or even increase their speed instead.\n\nTo generate this feature, we calculate the horse’s speed for each race segment by getting the distance travelled divided by the Trakus time interval, which is 0.25 seconds. Afterwards, we compute the acceleration by taking the difference between the speeds of consecutive segments. Finally, we take the standard deviation across the horse’s acceleration to determine the fluctuation of the horse’s speed. We only start measuring a horse’s speed fluctuation after the first call because the start of the race can be quite hectic as horses accelerate to their maximum speed while jostling for their ideal position.","metadata":{}},{"cell_type":"code","source":"df_trakus = pd.read_parquet('df_trakus.parquet')\n\ndate, venue, number, horse_id = '2019-01-01', 'Aqueduct', 1, 0\ndf_race = df_trakus[(df_trakus.index.get_level_values('date') == date) &\n                    (df_trakus.index.get_level_values('venue') == venue) &\n                    (df_trakus.index.get_level_values('number') == number) &\n                    (df_trakus.index.get_level_values('horse_id') == horse_id)]\n\ng = pyproj.Geod(ellps='WGS84')\n_, _, df_race['segment_distance'] = g.inv(df_race.longitude, df_race.latitude, df_race.longitude_prev, df_race.latitude_prev)\ndf_race['velocity'] = df_race.segment_distance * 4\ndf_race['acceleration'] = (df_race.velocity - df_race.velocity.shift()) * 4\ndf_race['geometry'] = df_race.apply(lambda df: LineString([[df.longitude, df.latitude], [df.longitude_prev, df.latitude_prev]]), axis=1)\n\ngdf_race = gpd.GeoDataFrame(df_race, geometry='geometry', crs='epsg:4326').to_crs(32118)\ngdf_race = gdf_race.filter(['horse_name', 'jockey', 'segment_distance', 'velocity', 'acceleration', 'geometry'])\ngdf_race = (gdf_race.assign(**{'Horse': lambda df: df.horse_name,\n                               'Jockey': lambda df: df.jockey,\n                               'Velocity': lambda df: df.velocity,\n                               'Acceleration': lambda df: df.acceleration}))\nm = gdf_race.iloc[:-1].explore('velocity',\n                             cmap='RdYlGn',\n                             tooltip=['Horse', 'Jockey', 'Velocity', 'Acceleration'])\n\ntitle = f'Velocity Map of {df_race.iloc[0].horse_name} (Race {number}, {venue}, {datetime.strptime(date, \"%Y-%m-%d\"):%-d %B %Y})'\nm.get_root().html.add_child(folium.Element(f'<head><style> html {{ overflow-y: hidden; }}</style></head><h3 align=\"center\" style=\"font-size:16px\"><b>{title}</b></h3>'))\n\n# Add finish line\nx, y = FINISH_LINES[venue].xy\ncoordinates = zip(y.tolist(), x.tolist())\nfinish_line = folium.PolyLine(locations=list(coordinates),color='black',weight=3)\nm.add_child(finish_line)\n\nm","metadata":{"execution":{"iopub.status.busy":"2022-11-10T06:34:53.440332Z","iopub.execute_input":"2022-11-10T06:34:53.441614Z","iopub.status.idle":"2022-11-10T06:34:57.953226Z","shell.execute_reply.started":"2022-11-10T06:34:53.441568Z","shell.execute_reply":"2022-11-10T06:34:57.949768Z"},"_kg_hide-input":true,"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_trakus = pd.read_parquet('df_trakus.parquet')\n\ndate, venue, number, horse_id = '2019-01-01', 'Aqueduct', 1, 0\n# date, venue, number, horse_id = '2019-04-14', 'Aqueduct', 6, 8\ndf_race = df_trakus[(df_trakus.index.get_level_values('date') == date) &\n                    (df_trakus.index.get_level_values('venue') == venue) &\n                    (df_trakus.index.get_level_values('number') == number) &\n                    (df_trakus.index.get_level_values('horse_id') == horse_id)]\n\ng = pyproj.Geod(ellps='WGS84')\n_, _, df_race['segment_distance'] = g.inv(df_race.longitude, df_race.latitude, df_race.longitude_prev, df_race.latitude_prev)\ndf_race['velocity'] = df_race.segment_distance * 4\ndf_race['acceleration'] = (df_race.velocity - df_race.velocity.shift()) * 4\ndf_race['geometry'] = df_race.apply(lambda df: LineString([[df.longitude, df.latitude], [df.longitude_prev, df.latitude_prev]]), axis=1)\n\ngdf_race = gpd.GeoDataFrame(df_race, geometry='geometry', crs='epsg:4326').to_crs(32118)\ngdf_race = gdf_race.filter(['horse_name', 'jockey', 'segment_distance', 'velocity', 'acceleration', 'geometry'])\ngdf_race = (gdf_race.assign(**{'Horse': lambda df: df.horse_name,\n                               'Jockey': lambda df: df.jockey,\n                               'Velocity': lambda df: df.velocity,\n                               'Acceleration': lambda df: df.acceleration}))\nm = gdf_race.iloc[:-20].explore('acceleration',\n                             cmap='RdYlGn',\n                             tooltip=['Horse', 'Jockey', 'Velocity', 'Acceleration'])\n\ntitle = f'Acceleration Map of {df_race.iloc[0].horse_name} (Race {number}, {venue}, {datetime.strptime(date, \"%Y-%m-%d\"):%-d %B %Y})'\nm.get_root().html.add_child(folium.Element(f'<head><style> html {{ overflow-y: hidden; }}</style></head><h3 align=\"center\" style=\"font-size:16px\"><b>{title}</b></h3>'))\n\n# Add finish line\nx, y = FINISH_LINES[venue].xy\ncoordinates = zip(y.tolist(), x.tolist())\nfinish_line = folium.PolyLine(locations=list(coordinates),color='black',weight=3)\nm.add_child(finish_line)\n\nm","metadata":{"execution":{"iopub.status.busy":"2022-11-10T06:34:57.955409Z","iopub.execute_input":"2022-11-10T06:34:57.955793Z","iopub.status.idle":"2022-11-10T06:35:02.027819Z","shell.execute_reply.started":"2022-11-10T06:34:57.955759Z","shell.execute_reply":"2022-11-10T06:35:02.026623Z"},"_kg_hide-input":true,"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"For this feature, a value of 0 indicates that the horse has no speed inconsistencies and has kept a perfectly consistent speed from the first call to the finish line, while a value of 0.5 means that the horse’s segment accelerations have a standard deviation of 0.5.\n","metadata":{}},{"cell_type":"markdown","source":"# Feature Analysis\n\n\n\n","metadata":{}},{"cell_type":"markdown","source":"## Attributes of Winning Horses\n\nBy analysing the race winners, we better understand about the attributes of race winners which might help us make informed decisions on how to become a race winner. We have segmented this analysis by race distance and race surface/going because different facets may favour specific race strategies (e.g. longer distances may favour slow starters over front runners).","metadata":{}},{"cell_type":"markdown","source":"### Drafting Percentage","metadata":{}},{"cell_type":"code","source":"gdf_starters = gpd.read_parquet('gdf_starters.parquet')\n\nbins1 = [-1, 0.2, 0.4, 0.6, 0.8]\nlabels1 = ['0–20%', '20–40%', '40–60%', '60–80%']\nbins2 = [1000, 1200, 1400, 1600, 1800, 2000]\nlabels2 = ['1000–1200m', '1200–1400m', '1400–1600m', '1600–1800m', '1800–2000m']\n\ngdf_temp = gdf_starters\ngdf_temp['winner'] = gdf_starters.place == 1\ngdf_temp['race_surface_going_binned'] = ((gdf_temp.race_surface.replace({'Inner Turf': 'Turf', 'Outer Turf': 'Turf'}).astype(str) + ' / ' + gdf_temp.race_going.astype(str))\n                                         .replace({'Dirt / Good': 'Dirt / Good Muddy', 'Dirt / Muddy': 'Dirt / Good Muddy'})\n                                         .astype('category')\n                                         .cat.set_categories(['Dirt / Fast', 'Dirt / Good Muddy', 'Dirt / Sloppy', 'Turf / Firm', 'Turf / Good']))\ngdf_temp['race_total_distance_binned'] = pd.cut(gdf_temp.race_total_distance, bins=bins2, labels=labels2)\ngdf_temp['drafting_percentage_binned'] = pd.cut(gdf_temp.drafting_percentage, bins=bins1, labels=labels1)\ngdf_temp.set_index(['race_surface_going_binned', 'race_total_distance_binned', 'drafting_percentage_binned'], append=True, inplace=True)\n\nfig, ((ax1, ax2)) = plt.subplots(1, 2, sharey=True)\nfig.tight_layout()\n\n(gdf_temp\n .groupby(['drafting_percentage_binned', 'race_total_distance_binned'])\n .winner\n .mean()\n .unstack(0)\n .plot\n .bar(ax=ax1, xlabel='', fontsize=14, legend=False, ylim=(0, 0.25), ylabel='Win Percentage'))\n\n(gdf_temp\n .groupby(['drafting_percentage_binned', 'race_surface_going_binned'])\n .winner\n .mean()\n .unstack(0)\n .plot\n .bar(ax=ax2, xlabel='', fontsize=14, legend=False, ylim=(0, 0.25)))\n\nax1.set_title('Win % by Drafting Percentage vs. Distance', pad=20, fontdict={'fontsize': 16})\nax2.set_title('Win % by Drafting Percentage vs. Surface/Going', pad=20, fontdict={'fontsize': 16})\nax1.yaxis.set_major_formatter(mtick.PercentFormatter(1.0, 0))\nax2.yaxis.set_major_formatter(mtick.PercentFormatter(1.0, 0))\nax2.legend(title='Drafting Percentage');","metadata":{"_kg_hide-input":true,"execution":{"iopub.status.busy":"2022-11-10T11:04:04.808698Z","iopub.execute_input":"2022-11-10T11:04:04.809050Z","iopub.status.idle":"2022-11-10T11:04:06.286409Z","shell.execute_reply.started":"2022-11-10T11:04:04.809022Z","shell.execute_reply":"2022-11-10T11:04:06.285538Z"},"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<div class=\"alert alert-success\" role=\"alert\">\n    <p><b>Observation</b><br />Horses with a meager drafting percentage have a much higher chance of winning the race than other horses. This is likely because these particular horses are front-runners with no one ahead. Interestingly, the win percentage of horses with a high drafting percentage increases for longer distances which means that a high drafting strategy is more effective for longer distances. Also, the low drafting percentage advantage is especially significant when the going is fast or firm but less significant when the going is more wet.</p>  \n</div>","metadata":{"execution":{"iopub.status.busy":"2022-11-09T03:21:13.438003Z","iopub.execute_input":"2022-11-09T03:21:13.438353Z","iopub.status.idle":"2022-11-09T03:21:13.444022Z","shell.execute_reply.started":"2022-11-09T03:21:13.438325Z","shell.execute_reply":"2022-11-09T03:21:13.442656Z"}}},{"cell_type":"markdown","source":"### Path Efficiency","metadata":{}},{"cell_type":"code","source":"gdf_starters = gpd.read_parquet('gdf_starters.parquet')\n\nbins1 = [0.980, 0.985, 0.990, 0.995, 1.0]\nlabels1 = ['98.0–98.5%', '98.5–99.0%', '99.0–99.5%', '99.5–100.0%']\nbins2 = [1000, 1200, 1400, 1600, 1800, 2000]\nlabels2 = ['1000–1200m', '1200–1400m', '1400–1600m', '1600–1800m', '1800–2000m']\n\ngdf_temp = gdf_starters\ngdf_temp['winner'] = gdf_starters.place == 1\ngdf_temp['race_surface_going_binned'] = ((gdf_temp.race_surface.replace({'Inner Turf': 'Turf', 'Outer Turf': 'Turf'}).astype(str) + ' / ' + gdf_temp.race_going.astype(str))\n                                         .replace({'Dirt / Good': 'Dirt / Good Muddy', 'Dirt / Muddy': 'Dirt / Good Muddy'})\n                                         .astype('category')\n                                         .cat.set_categories(['Dirt / Fast', 'Dirt / Good Muddy', 'Dirt / Sloppy', 'Turf / Firm', 'Turf / Good']))\ngdf_temp['race_total_distance_binned'] = pd.cut(gdf_temp.race_total_distance, bins=bins2, labels=labels2)\ngdf_temp['path_efficiency_binned'] = pd.cut(gdf_temp.path_efficiency, bins=bins1, labels=labels1)\ngdf_temp.set_index(['race_surface_going_binned', 'race_total_distance_binned', 'path_efficiency_binned'], append=True, inplace=True)\n\nfig, ((ax1, ax2)) = plt.subplots(1, 2, sharey=True)\nfig.tight_layout()\n\n(gdf_temp\n .groupby(['path_efficiency_binned', 'race_total_distance_binned'])\n .winner\n .mean()\n .unstack(0)\n .plot\n .bar(ax=ax1, xlabel='', fontsize=14, legend=False, ylim=(0, 0.2), ylabel='Win Percentage'))\n\n(gdf_temp\n .groupby(['path_efficiency_binned', 'race_surface_going_binned'])\n .winner\n .mean()\n .unstack(0)\n .plot\n .bar(ax=ax2, xlabel='', fontsize=14, legend=False, ylim=(0, 0.2)))\n\nax1.set_title('Win % by Path Efficiency vs. Distance', pad=20, fontdict={'fontsize': 16})\nax2.set_title('Win % by Path Efficiency vs. Surface/Going', pad=20, fontdict={'fontsize': 16})\nax1.yaxis.set_major_formatter(mtick.PercentFormatter(1.0, 0))\nax2.yaxis.set_major_formatter(mtick.PercentFormatter(1.0, 0))\nax2.legend(title='Path Efficiency');","metadata":{"_kg_hide-input":true,"execution":{"iopub.status.busy":"2022-11-10T11:04:57.815037Z","iopub.execute_input":"2022-11-10T11:04:57.815424Z","iopub.status.idle":"2022-11-10T11:04:59.357485Z","shell.execute_reply.started":"2022-11-10T11:04:57.815394Z","shell.execute_reply":"2022-11-10T11:04:59.356397Z"},"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<div class=\"alert alert-success\" role=\"alert\">\n    <p><b>Observation</b><br />Horses with a higher path efficiency generally have an advantage over horses with a lower path efficiency. This advantage is true across different distances and goings. Saving that extra 1% or 2% of the race distance compared to other competitors increases a horse’s win percentage.</p>  \n</div>","metadata":{"execution":{"iopub.status.busy":"2022-11-09T03:23:28.878166Z","iopub.execute_input":"2022-11-09T03:23:28.878502Z","iopub.status.idle":"2022-11-09T03:23:28.885159Z","shell.execute_reply.started":"2022-11-09T03:23:28.878474Z","shell.execute_reply":"2022-11-09T03:23:28.884212Z"}}},{"cell_type":"markdown","source":"### Racing Strategy","metadata":{}},{"cell_type":"markdown","source":"Here, our Racing Strategy categories mirror the Running Style categories used in Brisnet’s Ultimate Past Performances [1]:\n- **Early:** a horse that typically vies for the early lead.\n- **Early Presser:** a horse that runs second or third within a few lengths of the lead early before trying to run down the leader.\n- **Presser:** a horse that runs in the middle-of-the-pack early before trying to run down the leader.\n- **Sustainer:** a horse that runs in the back of the pack early before trying to run down the leader.","metadata":{}},{"cell_type":"code","source":"gdf_starters = gpd.read_parquet('gdf_starters.parquet')\n\nbins1 = [-1, 0.05, 0.25, 0.6, 1.5]\nlabels1 = ['Early', 'Early Presser', 'Presser', 'Sustainer']\nbins2 = [1000, 1200, 1400, 1600, 1800, 2000]\nlabels2 = ['1000–1200m', '1200–1400m', '1400–1600m', '1600–1800m', '1800–2000m']\n\ngdf_temp = gdf_starters\ngdf_temp['winner'] = gdf_starters.place == 1\ngdf_temp['race_surface_going_binned'] = ((gdf_temp.race_surface.replace({'Inner Turf': 'Turf', 'Outer Turf': 'Turf'}).astype(str) + ' / ' + gdf_temp.race_going.astype(str))\n                                         .replace({'Dirt / Good': 'Dirt / Good Muddy', 'Dirt / Muddy': 'Dirt / Good Muddy'})\n                                         .astype('category')\n                                         .cat.set_categories(['Dirt / Fast', 'Dirt / Good Muddy', 'Dirt / Sloppy', 'Turf / Firm', 'Turf / Good']))\ngdf_temp['race_total_distance_binned'] = pd.cut(gdf_temp.race_total_distance, bins=bins2, labels=labels2)\ngdf_temp['racing_strategy_binned'] = pd.cut(gdf_temp.racing_strategy, bins=bins1, labels=labels1)\ngdf_temp.set_index(['race_surface_going_binned', 'race_total_distance_binned', 'racing_strategy_binned'], append=True, inplace=True)\n\nfig, ((ax1, ax2)) = plt.subplots(1, 2, sharey=True)\nfig.tight_layout()\n\n(gdf_temp\n .groupby(['racing_strategy_binned', 'race_total_distance_binned'])\n .winner\n .mean()\n .unstack(0)\n .plot\n .bar(ax=ax1, xlabel='', fontsize=14, legend=False, ylim=(0, 0.4), ylabel='Win Percentage'))\n\n(gdf_temp\n .groupby(['racing_strategy_binned', 'race_surface_going_binned'])\n .winner\n .mean()\n .unstack(0)\n .plot\n .bar(ax=ax2, xlabel='', fontsize=14, legend=False, ylim=(0, 0.4)))\n\nax1.set_title('Win % by Racing Strategy vs. Distance', pad=20, fontdict={'fontsize': 16})\nax2.set_title('Win % by Racing Strategy vs. Surface/Going', pad=20, fontdict={'fontsize': 16})\nax1.yaxis.set_major_formatter(mtick.PercentFormatter(1.0, 0))\nax2.yaxis.set_major_formatter(mtick.PercentFormatter(1.0, 0))\nax2.legend(title='Racing Strategy');","metadata":{"_kg_hide-input":true,"execution":{"iopub.status.busy":"2022-11-10T11:03:42.068658Z","iopub.execute_input":"2022-11-10T11:03:42.069086Z","iopub.status.idle":"2022-11-10T11:03:43.433032Z","shell.execute_reply.started":"2022-11-10T11:03:42.069054Z","shell.execute_reply":"2022-11-10T11:03:43.431939Z"},"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<div class=\"alert alert-success\" role=\"alert\">\n    <p><b>Observation</b><br />Once again, front-runners are favoured to win the race. However, it is challenging to implement a strategy to ensure that a horse leads 20 seconds into the race because many other horses are fighting for the front position. In addition, the advantage of being an early horse seems to decrease for longer distances and when the going is more muddy.</p>  \n</div>","metadata":{}},{"cell_type":"markdown","source":"### Speed Fluctuation","metadata":{}},{"cell_type":"code","source":"gdf_starters = gpd.read_parquet('gdf_starters.parquet')\n\nbins1 = [0.1, 0.2, 0.3, 0.4]\nlabels1 = ['0.1–0.2', '0.2–0.3', '0.3–0.4']\nbins2 = [1000, 1200, 1400, 1600, 1800, 2000]\nlabels2 = ['1000–1200m', '1200–1400m', '1400–1600m', '1600–1800m', '1800–2000m']\n\ngdf_temp = gdf_starters\ngdf_temp['winner'] = gdf_starters.place == 1\ngdf_temp['race_surface_going_binned'] = ((gdf_temp.race_surface.replace({'Inner Turf': 'Turf', 'Outer Turf': 'Turf'}).astype(str) + ' / ' + gdf_temp.race_going.astype(str))\n                                         .replace({'Dirt / Good': 'Dirt / Good Muddy', 'Dirt / Muddy': 'Dirt / Good Muddy'})\n                                         .astype('category')\n                                         .cat.set_categories(['Dirt / Fast', 'Dirt / Good Muddy', 'Dirt / Sloppy', 'Turf / Firm', 'Turf / Good']))\ngdf_temp['race_total_distance_binned'] = pd.cut(gdf_temp.race_total_distance, bins=bins2, labels=labels2)\ngdf_temp['speed_fluctuation_binned'] = pd.cut(gdf_temp.speed_fluctuation, bins=bins1, labels=labels1)\ngdf_temp.set_index(['race_surface_going_binned', 'race_total_distance_binned', 'speed_fluctuation_binned'], append=True, inplace=True)\n\nfig, ((ax1, ax2)) = plt.subplots(1, 2, sharey=True)\nfig.tight_layout()\n\n(gdf_temp\n .groupby(['speed_fluctuation_binned', 'race_total_distance_binned'])\n .winner\n .mean()\n .unstack(0)\n .plot\n .bar(ax=ax1, xlabel='', fontsize=14, legend=False, ylim=(0, 0.35), ylabel='Win Percentage'))\n\n(gdf_temp\n .groupby(['speed_fluctuation_binned', 'race_surface_going_binned'])\n .winner\n .mean()\n .unstack(0)\n .plot\n .bar(ax=ax2, xlabel='', fontsize=14, legend=False, ylim=(0, 0.35)))\n\nax1.set_title('Win % by Speed Fluctuation vs. Distance', pad=20, fontdict={'fontsize': 16})\nax2.set_title('Win % by Speed Fluctuation vs. Surface/Going', pad=20, fontdict={'fontsize': 16})\nax1.yaxis.set_major_formatter(mtick.PercentFormatter(1.0, 0))\nax2.yaxis.set_major_formatter(mtick.PercentFormatter(1.0, 0))\nax2.legend(title='Speed Fluctuation');","metadata":{"_kg_hide-input":true,"execution":{"iopub.status.busy":"2022-11-10T11:04:38.967257Z","iopub.execute_input":"2022-11-10T11:04:38.967696Z","iopub.status.idle":"2022-11-10T11:04:40.579904Z","shell.execute_reply.started":"2022-11-10T11:04:38.967660Z","shell.execute_reply":"2022-11-10T11:04:40.579090Z"},"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<div class=\"alert alert-success\" role=\"alert\">\n    <p><b>Observation</b><br />Horses with a lower speed fluctuation perform significantly better across all different distances and race goings and is something that trainers and jockeys should prioritise. A lower speed fluctuation likely means that the horse has had a smooth race without being unexpectedly blocked or pushed by other horses.</p>  \n</div>","metadata":{}},{"cell_type":"markdown","source":"## Predictive Power of the Features\n\nTo determine the predictive power of these four features, we can input them into a Multinomial Logit model and use the loss function to measure the performance of these features. One of the key advantages of this method is that it allows us to compare horses competing in the same race by creating performance ratings for each horse, before transforming them into win probabilities. We will compare the results with a baseline model where every horse has an equal probability of winning.","metadata":{}},{"cell_type":"markdown","source":"<div class=\"alert alert-danger\" role=\"alert\">\n    <p><b>Multinomial Logit Explanation</b></p>\n    <p>The Multinomial Logit model was first applied to horse racing by Ruth Bolton and Randall Chapman [3] and further improved by William Benter [2] who went on to amass a \\$1bn fortune betting on horses in Hong Kong [4].</p>\n    <p>The model works by weighting the features and adding them up to create a performance rating for each horse. The stronger the horse, the higher the performance rating. Afterwards, we group the performance ratings by race and use the softmax function to transform these performance ratings into probabilities. Finally, we use the Maximum Likelihood Estimation (MLE) technique to adjust the feature weights by maximising the log likelihood of the win probabilities of the horses that won.</p>\n    <p>Mathematically, let $X_{ijk}$ represent the $k$-th feature of the $j$-th horse of the $i$-th race, $\\mathbf{1}_{ij}$ represent an indicator function which returns 1 if the $j$-th horse is the winner of the $i$-th race and 0 otherwise, and $\\alpha_{k}$ represent the weighting of the $k$-th feature. Then we have $U_{ij}$, which represents the performance rating of each horse:</p>\n    <p>$$U_{ij} = \\sum_{k}\\alpha_{k}X_{ijk}$$</p>\n    <p>To convert the performance rating to probabilities, we need to compare it with other horses in the same race. We group the performance ratings by race and perform the softmax function to convert them into win probabilities. Now, we have $p_{ij}$, which is the win probability of the $j$-th horse of the $i$-th race:</p>\n    <p>$$p_{ij} = \\frac{e^{U_{ij}}}{\\sum_{j}e^{U_{ij}}}$$</p>\n    <p>To get the maximum likelihood, we want to maximise:</p>\n    <p>$$p = \\prod_{i}p_{ij}\\mathbf{1}_{ij}$$</p>\n    <p>Which is the same as maximising the log likelihood function:</p>\n    <p>$$L(p) = \\ln\\left(\\prod_{i}p_{ij}\\mathbf{1}_{ij}\\right) = \\sum_{i}\\ln\\left(p_{ij}\\mathbf{1}_{ij}\\right)$$</p>\n</div>","metadata":{}},{"cell_type":"markdown","source":"<div class=\"alert alert-danger\" role=\"alert\">\n    <p><b>PyTorch Model</b></p>\n    <p>We turn to PyTorch to implement the Multinomial Logit model, since adjusting the feature weights to calculate the performance rating is the same as adjusting the weights of a single <code>nn.linear</code> layer neural network. PyTorch also comes with useful functions like <code>F.softmax</code>, which can be used to transform performance ratings to probabilities, and <code>F.nll_loss</code> which can be used to compare the predicted and target win probabilities.</p>\n    <p>The data is loaded into a PyTorch Lightning data module which applies min-max normalisation to all non-odds features and pads races, since the number of starters in each race varies between 3 and 14. The data is divided into 5 folds for cross validation.\n    <p>A PyTorch Lightning trainer is used to find the ideal weights by training the neural network using an Adam optimiser with learning rate of 1e-3 and L2 weight decay of 1e-4, and letting it run for 200 epochs.</p>\n</div>","metadata":{}},{"cell_type":"code","source":"results = []\nn_splits = 5\n\nfs = ['drafting_percentage', 'racing_strategy', 'path_efficiency', 'speed_fluctuation']\nfeatures_combinations = []\nfor i in range(len(fs)+1):\n    features_combinations.extend(itertools.combinations(fs, i))\n\nfor features in features_combinations:\n    result = {'features': features}\n    \n    for k in range(n_splits):\n        dm = DataModule('df_Xy.parquet', features, k=k, n_splits=n_splits)\n        dm.prepare_data()\n\n        model = Model(dm.num_features, use_public_odds=dm.use_public_odds)\n\n        trainer = pl.Trainer(max_epochs=200, logger=False, enable_progress_bar=False)\n        trainer.fit(model, datamodule=dm)\n        score = trainer.validate(model, datamodule=dm, verbose=False)[0]['val_loss']\n        result[f'split_{k}_val_loss'] = score\n        result[f'split_{k}_weights'] = trainer.model.linear.weight.detach().numpy().tolist()\n        \n    results.append(result)\n\nwith open('results1.pickle', 'wb') as handle:\n    pickle.dump(results, handle, protocol=pickle.HIGHEST_PROTOCOL)\n\nwith open('results1.pickle', 'rb') as handle:\n    results = pickle.load(handle)\n\ndf_results = pd.DataFrame(results)\ndf_dummies = df_results.features.str.join(sep='*').str.get_dummies(sep='*').astype(bool)\ndf_results = pd.concat([df_dummies, df_results.filter([c for c in df_results.columns if c.endswith('loss')])], axis=1).set_index(list(df_dummies.columns))\ndf_results['mean_val_loss'] = df_results.mean(axis=1)\ndf_results.reset_index(inplace=True)\ndf_results[list(df_dummies.columns)] = df_results[list(df_dummies.columns)].applymap({True: '✓', False: '✗'}.get)\n\nhtml = (df_results\n        .set_index(list(df_dummies.columns))\n        .sort_index()\n        .style\n        .set_properties(subset='mean_val_loss', **{'font-weight': 'bold'})\n        .highlight_min(color='#c8e6c9')\n        .render(sparse_index=False))\n\nHTML(html)","metadata":{"execution":{"iopub.status.busy":"2022-11-10T06:36:05.499775Z","iopub.execute_input":"2022-11-10T06:36:05.500264Z","iopub.status.idle":"2022-11-10T06:36:05.555180Z","shell.execute_reply.started":"2022-11-10T06:36:05.500226Z","shell.execute_reply":"2022-11-10T06:36:05.553562Z"},"_kg_hide-input":true,"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<div class=\"alert alert-success\" role=\"alert\">\n    <p><b>Observation</b><br />The predictive power using our four features is significantly better than the baseline model with the baseline giving a loss of 2.639 and our combined model giving us a loss of 1.965. We can analyse the weightings of the features to help inform racing tactics and decisions.</p>\n    <p>The feature weights inside the combined model, indicate the following, in order of significance:</p>\n    <ol style=\"color: rgba(0,0,0,.7)\">\n        <li>A higher path efficiency gives a very significant advantage (mean weight of 7.702)</li>\n        <li>A lower speed fluctuation gives a moderate advantage (mean weight of -3.609)</li>\n        <li>An early runner racing strategy gives a slight advantage (mean weight of -0.559)</li>\n        <li>Drafting percentage does not make much difference (mean weight of -0.081)</li>\n    </ol>\n</div>","metadata":{"execution":{"iopub.status.busy":"2022-11-09T03:01:58.176978Z","iopub.execute_input":"2022-11-09T03:01:58.177370Z","iopub.status.idle":"2022-11-09T03:01:58.192150Z","shell.execute_reply.started":"2022-11-09T03:01:58.177332Z","shell.execute_reply":"2022-11-09T03:01:58.191232Z"}}},{"cell_type":"markdown","source":"## Are the odds efficient?\n\nThe probability implied by the odds is supposed to factor in all facets of the race including drafting benefit, path efficiency, racing strategy and speed fluctuation. However, this may only sometimes be the case because there might be inefficiencies in the odds. In this section, we will use the Multinomial Logit model again to analyse whether the odds are efficient using only the starter-specific features which are available before the race, excluding features derived from coordinate data. The only starter-specific feature in the NYTHA/NYRA dataset is `weight_carried`, but we supplement this with `draw`, which we calculate using each starter’s distance to the centroid at the first Trakus measurement.","metadata":{}},{"cell_type":"code","source":"results = []\nn_splits = 5\n\nfor features in [('public_odds',),\n                 ('public_odds', 'draw'),\n                 ('public_odds', 'weight_carried'),\n                 ('public_odds', 'draw', 'weight_carried')]:    \n    result = {'features': features}\n    \n    for k in range(n_splits):\n        dm = DataModule('df_Xy.parquet', features, k=k, n_splits=n_splits)\n        dm.prepare_data()\n\n        model = Model(dm.num_features, use_public_odds=dm.use_public_odds)\n\n        trainer = pl.Trainer(max_epochs=200, logger=False, enable_progress_bar=False)\n        trainer.fit(model, datamodule=dm)\n        score = trainer.validate(model, datamodule=dm, verbose=False)[0]['val_loss']\n        result[f'split_{k}_val_loss'] = score\n        result[f'split_{k}_weights'] = trainer.model.linear.weight.detach().numpy().tolist()\n        \n    results.append(result)\n\nwith open('results2.pickle', 'wb') as handle:\n    pickle.dump(results, handle, protocol=pickle.HIGHEST_PROTOCOL)\n\nwith open('results2.pickle', 'rb') as handle:\n    results = pickle.load(handle)\n\ndf_results = pd.DataFrame(results)\ndf_dummies = df_results.features.str.join(sep='*').str.get_dummies(sep='*').astype(bool)\ndf_results = pd.concat([df_dummies, df_results.filter([c for c in df_results.columns if c.endswith('loss')])], axis=1).set_index(list(df_dummies.columns))\ndf_results['mean_val_loss'] = df_results.mean(axis=1)\ndf_results.reset_index(inplace=True)\ndf_results[list(df_dummies.columns)] = df_results[list(df_dummies.columns)].applymap({True: '✓', False: '✗'}.get)\n\nhtml = (df_results\n        .set_index(list(df_dummies.columns))\n        .reorder_levels([1, 0, 2])\n        .sort_index()\n        .style\n        .set_properties(subset='mean_val_loss', **{'font-weight': 'bold'})\n        .highlight_min(color='#c8e6c9')\n        .render(sparse_index=False))\n\nHTML(html)","metadata":{"execution":{"iopub.status.busy":"2022-11-10T06:36:20.934902Z","iopub.execute_input":"2022-11-10T06:36:20.936188Z","iopub.status.idle":"2022-11-10T06:36:20.984326Z","shell.execute_reply.started":"2022-11-10T06:36:20.936130Z","shell.execute_reply":"2022-11-10T06:36:20.983061Z"},"_kg_hide-input":true,"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<div class=\"alert alert-success\" role=\"alert\">\n    <p><b>Observation</b><br />The mean loss for both models are very similar which means that adding the two extra features of <code>draw</code> and <code>weight_carried</code> did not improve the odds probabilities significantly. The public odds have already factored in the two extra features which means that the odds are already efficient enough to reflect all the starter-specific pre-race information provided in the NYTHA/NYRA dataset.</p>\n</div>\n","metadata":{}},{"cell_type":"markdown","source":"## Do our features improve the odds?\n\nWe will now add the four newly generated features to the odds’ implied utility to see whether the model’s predictive power improves. It is worth noting that we do not have these features available before the race because they are generated from information during the race, but we may be able to forecast these features using a horse’s past performances.","metadata":{}},{"cell_type":"code","source":"results = []\nn_splits = 5\n\nfor features in [('public_odds',),\n                 ('public_odds', 'drafting_percentage'),\n                 ('public_odds', 'racing_strategy'),\n                 ('public_odds', 'path_efficiency'),\n                 ('public_odds', 'speed_fluctuation'),\n                 ('public_odds', 'drafting_percentage', 'racing_strategy', 'path_efficiency', 'speed_fluctuation')]:\n    result = {'features': features}\n    \n    for k in range(n_splits):\n        dm = DataModule('df_Xy.parquet', features, k=k, n_splits=n_splits)\n        dm.prepare_data()\n\n        model = Model(dm.num_features, use_public_odds=dm.use_public_odds)\n\n        trainer = pl.Trainer(max_epochs=200, logger=False, enable_progress_bar=False)\n        trainer.fit(model, datamodule=dm)\n        score = trainer.validate(model, datamodule=dm, verbose=False)[0]['val_loss']\n        result[f'split_{k}_val_loss'] = score\n        result[f'split_{k}_weights'] = trainer.model.linear.weight.detach().numpy().tolist()\n        \n    results.append(result)\n\nwith open('results3.pickle', 'wb') as handle:\n    pickle.dump(results, handle, protocol=pickle.HIGHEST_PROTOCOL)\n\nwith open('results3.pickle', 'rb') as handle:\n    results = pickle.load(handle)\n\ndf_results = pd.DataFrame(results)\ndf_dummies = df_results.features.str.join(sep='*').str.get_dummies(sep='*').astype(bool)\ndf_results = pd.concat([df_dummies, df_results.filter([c for c in df_results.columns if c.endswith('loss')])], axis=1).set_index(list(df_dummies.columns))\ndf_results['mean_val_loss'] = df_results.mean(axis=1)\ndf_results.reset_index(inplace=True)\ndf_results[list(df_dummies.columns)] = df_results[list(df_dummies.columns)].applymap({True: '✓', False: '✗'}.get)\n\nhtml = (df_results\n        .set_index(list(df_dummies.columns))\n        .reorder_levels([2, 0, 1, 3, 4])\n        .sort_index()\n        .style\n        .set_properties(subset='mean_val_loss', **{'font-weight': 'bold'})\n        .highlight_min(color='#c8e6c9')\n        .render(sparse_index=False))\n\nHTML(html)","metadata":{"execution":{"iopub.status.busy":"2022-11-10T06:40:08.223924Z","iopub.execute_input":"2022-11-10T06:40:08.224395Z","iopub.status.idle":"2022-11-10T06:57:24.525944Z","shell.execute_reply.started":"2022-11-10T06:40:08.224360Z","shell.execute_reply":"2022-11-10T06:57:24.524387Z"},"_kg_hide-input":true,"jupyter":{"source_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<div class=\"alert alert-success\" role=\"alert\">\n    <p><b>Observation</b><br />When we add all four features to the odds, there is a significant improvement in accuracy, dropping from 1.618 to 1.468. If we can forecast these features with reasonable accuracy, we can produce more accurate probabilities than the ones implied by the odds. Out of the four features we added, the one that helps improve the model the most is the speed fluctuation feature. This means that public odds largely undervalues the performance benefits of reduced speed fluctuation.</p>\n    <p>The feature weights inside the combined model, indicate the following, in order of significance:</p>\n    <ol style=\"color: rgba(0,0,0,.7)\">\n        <li>A lower speed fluctuation gives a very significant advantage over public odds (mean weight of -8.810)</li>\n        <li>A lower drafting percentage gives a moderate advantage over public odds (mean weight of -1.135)</li>\n        <li>An early runner racing strategy gives a slight advantage over public odds (mean weight of -0.450)</li>\n        <li>A lower path efficiency gives a slight advantage over public odds (mean weight of -0.433)</li>\n    </ol>\n</div>\n","metadata":{"execution":{"iopub.status.busy":"2022-11-09T04:10:56.017986Z","iopub.execute_input":"2022-11-09T04:10:56.018414Z","iopub.status.idle":"2022-11-09T04:10:56.027917Z","shell.execute_reply.started":"2022-11-09T04:10:56.018380Z","shell.execute_reply":"2022-11-09T04:10:56.026235Z"}}},{"cell_type":"markdown","source":"# Conclusion\n\n<div class=\"alert alert-info\" role=\"alert\">\n    <p><b>Key Takeaways</b></p>\n    <ul style=\"color: rgba(0,0,0,.7)\">\n        <li style=\"margin: 10px 0\">Jockeys and trainers should choose race tactics that prioritise <b>increasing path efficiency</b> and <b>decreasing speed fluctuation</b> over drafting percentage and racing strategy.</li>\n        <li style=\"margin: 10px 0\"><b>Public odds significantly undervalue horses with lower speed fluctuations.</b> If these undervalued horses can be identified before the race, this inefficiency can be exploited by placing exotic bets covering these horses.</li>\n    </ul>\n</div>\n\n## Recommended Race Tactics\n\nJockeys and trainers should prioritise increasing path efficiency and decreasing speed fluctuation in their race tactics because they both significantly increase the probability of winning a race. However, these two things may sometimes conflict with each other because the shortest path is close to the rail where it might be congested with other horses which might increase speed fluctuation. Hence, it is important find a balance between two and perhaps find a strategy which can maximise both path efficiency and speed fluctuation.\n\n\n## Recommended Betting Strategies\n\nPublic odds significantly undervalue horses with lower speed fluctuations. If these undervalued horses can be identified before the race, this inefficiency can be exploited by placing exotic bets covering these horses. By betting on multiple value horses at the same time, we have more opportunities to overcome the takeout rate. Bet sizes should be placed in accordance with the Kelly Criterion [5], in order to maximise the expected growth rate of wealth.","metadata":{}},{"cell_type":"markdown","source":"# References\n\n- [1] [How To Read Brisnet.com Ultimate Past Performances. (n.d.). *Brisnet.com*.](http://www.brisnet.com/content/brisnet-online-horse-racing-data-handicapping/read-brisnet-com-ultimate-past-performances)\n- [2] [Benter, W. (2008). Computer Based Horse Race Handicapping and Wagering Systems: A Report. *Efficiency of Racetrack Betting Markets*.](https://www.gwern.net/docs/statistics/decision/1994-benter.pdf)\n- [3] [Bolton, R. N., & Chapman, R. G. (1986). Searching for Positive Returns at the Track: A Multinomial Logit Model for Handicapping Horse Races. *Management Science*.](https://www.gwern.net/docs/statistics/decision/1986-bolton.pdf)\n- [4] [Chellel, K. (2018). The Gambler Who Cracked the Horse-Racing Code. *Bloomberg Businessweek.*](https://www.bloomberg.com/news/features/2018-05-03/the-gambler-who-cracked-the-horse-racing-code)\n- [5] [Kelly, J. L. (1956). A New Interpretation of Information Rate. *Bell System Technical Journal*.](https://www.princeton.edu/~wbialek/rome/refs/kelly_56.pdf)","metadata":{}}]}