Update app

data.py

@@ -15,24 +15,17 @@ from translate import (
 )
 
 # load game data
-# game_df = pd.read_csv('game.csv').drop_duplicates()
 game_df = pl.read_csv('game.csv').unique()
 assert len(game_df) == len(game_df['game_pk'].unique())
 
 # load pa data
 pa_df = []
-# for game_pk in tqdm(game_df['game_pk']):
-#   pa_df.append(pd.read_csv(os.path.join('pa', f'{game_pk}.csv'), dtype={'pa_pk': str}))
-# pa_df = pd.concat(pa_df, axis='rows')
 for game_pk in tqdm(game_df['game_pk']):
   pa_df.append(pl.read_csv(os.path.join('pa', f'{game_pk}.csv'), schema_overrides={'pa_pk': str}))
 pa_df = pl.concat(pa_df)
 
 # load pitch data
 pitch_df = []
-# for game_pk in tqdm(game_df['game_pk']):
-#   pitch_df.append(pd.read_csv(os.path.join('pitch', f'{game_pk}.csv'), dtype={'pa_pk': str}))
-# pitch_df = pd.concat(pitch_df, axis='rows')
 for game_pk in tqdm(game_df['game_pk']):
   pitch_df.append(pl.read_csv(os.path.join('pitch', f'{game_pk}.csv'), schema_overrides={'pa_pk': str, 'on_1b': pl.Int64, 'on_2b': pl.Int64, 'on_3b': pl.Int64}))
 pitch_df = pl.concat(pitch_df)
@@ -56,14 +49,6 @@ def identify_bb_type(hit_type):
   else:
     raise Exception(f'Unexpect hit_type {hit_type}')
 
-# pa_df['_des'] = pa_df['des'].str.strip()
-# pa_df['des'] = pa_df['des'].str.strip()
-# pa_df['des_more'] = pa_df['des_more'].str.strip()
-# pa_df.loc[pa_df['des'].isna(), 'des'] = pa_df[pa_df['des'].isna()]['des_more']
-# pa_df.loc[:, 'des'] = pa_df['des'].apply(lambda item: item.split()[0] if (len(item.split()) > 1 and re.search(r'＋\d+点', item)) else item)
-# non_home_plate_outcome = (pa_df['des'].isin(['ボール', '見逃し', '空振り'])) | (pa_df['des'].str.endswith('塁けん制'))
-# pa_df.loc[non_home_plate_outcome, 'des'] = pa_df.loc[non_home_plate_outcome, 'des_more']
-# pa_df['des'] = pa_df['des'].apply(translate_pa_outcome)
 pa_df = (
     pa_df
     .with_columns(
@@ -108,16 +93,6 @@ pa_df = (
 )
 
 # translate pitch data
-# pitch_df = pitch_df[~pitch_df['pitch_name'].isna()]
-# pitch_df['jp_pitch_name'] = pitch_df['pitch_name']
-# pitch_df['pitch_name'] = pitch_df['jp_pitch_name'].apply(lambda pitch_name: jp_pitch_to_en_pitch[pitch_name])
-# pitch_df['pitch_type'] = pitch_df['jp_pitch_name'].apply(lambda pitch_name: jp_pitch_to_pitch_code[pitch_name])
-# pitch_df['description'] = pitch_df['description'].apply(lambda item: item.split()[0] if len(item.split()) > 1 else item)
-# pitch_df['description'] = pitch_df['description'].apply(translate_pitch_outcome)
-# pitch_df['release_speed'] = pitch_df['release_speed'].replace('-', np.nan)
-# pitch_df.loc[~pitch_df['release_speed'].isna(), 'release_speed'] = pitch_df.loc[~pitch_df['release_speed'].isna(), 'release_speed'].str.removesuffix('km/h').astype(int)
-# pitch_df['plate_x'] = (pitch_df['plate_x'] + 13) - 80
-# pitch_df['plate_z'] = 200 - (pitch_df['plate_z'] + 13) - 100
 pitch_df = (
     pitch_df
     .filter(pl.col('pitch_name').is_not_null())
@@ -147,31 +122,6 @@ pitch_df = (
 )
 
 # translate player data
-# client = Client("Ramos-Ramos/npb_name_translator")
-# # en_names = client.predict(
-# # 		jp_names='\n'.join(player_df.name.tolist()),
-# # 		api_name="/predict"
-# # )
-# # player_df['jp_name'] = player_df['name']
-# # player_df['name'] = [name if name != 'nan' else np.nan for name in en_names.splitlines()]
-# en_names = client.predict(
-# 		jp_names='\n'.join(player_df['name'].to_list()),
-# 		api_name="/predict"
-# )
-# player_df = (
-#     player_df
-#     .with_columns(
-#         pl.col('name').alias('jp_name'),
-#         pl.Series('name', en_names.splitlines())
-#     )
-#     .with_columns(
-#         pl.when(pl.col('name') == 'nan')
-#         .then(None)
-#         .otherwise(pl.col('name'))
-#         .alias('name')
-#     )
-# )
-
 player_df = pl.read_csv('player.csv')
 register = (
     pl.read_csv('register.csv')
@@ -187,13 +137,7 @@ register = (
 )
 player_df = player_df.join(register, on=['name', 'team'], how='inner').with_columns(pl.col('en_name').alias('name')).drop(pl.col('en_name'))
 
-# # merge pitch and pa data
-# df = pd.merge(pitch_df, pa_df, 'inner', on=['game_pk', 'pa_pk'])
-# df = pd.merge(df, player_df.rename(columns={'player_id': 'pitcher'}), 'inner', on='pitcher')
-# df['whiff'] = df['description'].isin(['SS', 'K'])
-# df['swing'] = ~df['description'].isin(['B', 'BB', 'LS', 'inv_K', 'bunt_K', 'HBP', 'SH', 'SH E', 'SH FC', 'obstruction', 'illegal_pitch', 'defensive_interference'])
-# df['csw'] = df['description'].isin(['SS', 'K', 'LS', 'inv_K'])
-# df['normal_pitch'] = ~df['description'].isin(['obstruction', 'illegal_pitch', 'defensive_interference']) # guess
+# merge pitch and pa data
 
 df = (
     (
@@ -207,15 +151,7 @@ df = (
         pl.col('description').is_in(['SS', 'K', 'LS', 'inv_K']).alias('csw'),
         ~pl.col('description').is_in(['obstruction', 'illegal_pitch', 'defensive_interference']).alias('normal_pitch') # guess
     )
-)
-
-# df_by_player_pitch = df.groupby(['name', 'pitch_name'])
-# whiff_rate = (df_by_player_pitch['whiff'].sum() / df_by_player_pitch['swing'].sum() * 100).round(1).rename('Whiff%')
-# csw_rate = (df_by_player_pitch['csw'].sum() / df_by_player_pitch['normal_pitch'].sum() * 100).round(1).rename('CSW%')
-# velo = df_by_player_pitch['release_speed'].apply(lambda x: round(x.mean(), 1)).rename('Velocity')
-
-# pitch_stats = pd.concat([whiff_rate, csw_rate, velo], axis=1)
-# league_pitch_stats = pd.DataFrame(df.groupby('pitch_name')['release_speed'].apply(lambda x: round(x.mean(), 1)).rename('Velocity'))
+).sort(['game_pk', 'pa_pk', 'pitch_id'])
 
 pitch_stats, rhb_pitch_stats, lhb_pitch_stats = [
     (

demo.py

@@ -19,7 +19,7 @@ css = '''
 .pitch-velo {height: 100px}
 .pitch-velo .js-plotly-plot {height: 100%}
 
-.pitch-loc {height: 256px}
+.pitch-loc {height: 320px}
 .pitch-loc .js-plotly-plot {height: 100%}
 
 .pitch-velo-summary div.plotly-notifier {visibility: hidden}
@@ -33,6 +33,7 @@ with gr.Blocks(
   [Data from SportsNavi](https://sports.yahoo.co.jp/)
   ''')
 
+  source_df = gr.State(df)
   app_df = gr.State(df)
   app_league_df = gr.State(df)
   app_pitch_stats = gr.State(pitch_stats)
@@ -58,6 +59,10 @@ with gr.Blocks(
   gr.Markdown('''
   ## Pitch Locations
   Pitcher's persective
+  <br>
+  `NPB` refers to the top 10% of pitches thrown across the league with the current search constraints e.g. handedness
+  <br>
+  Note: To speed up the KDE, we restrict the league-wide pitches to 5,000 pitches
   ''')
   pitch_rows = []
   pitch_groups = []
@@ -86,10 +91,10 @@ with gr.Blocks(
 
   (
       player
-      .input(update_dfs, inputs=[player, handedness], outputs=[app_df, app_pitch_stats, app_league_pitch_stats])
+      .input(update_dfs, inputs=[player, handedness, source_df], outputs=[app_df, app_league_df, app_pitch_stats, app_league_pitch_stats])
       .then(lambda : gr.update(value='Both', interactive=True), outputs=handedness)
   )
-  handedness.input(update_dfs, inputs=[player, handedness], outputs=[app_df, app_pitch_stats, app_league_pitch_stats])
+  handedness.input(update_dfs, inputs=[player, handedness, source_df], outputs=[app_df, app_league_df, app_pitch_stats, app_league_pitch_stats])
 
   # app_df.change(preview_df, inputs=app_df, outputs=preview)
   # app_df.change(set_download_file, inputs=app_df, outputs=download_file)
@@ -105,7 +110,7 @@ with gr.Blocks(
       .then(plot_usage, inputs=[app_df, player], outputs=usage)
       .then(plot_velo_summary, inputs=[app_df, app_league_df, player], outputs=velo_summary)
       .then(lambda df: plot_loc(df), inputs=app_df, outputs=loc_summary)
-      .then(plot_pitch_cards, inputs=[app_df, app_pitch_stats], outputs=pitch_rows+pitch_groups+pitch_names+pitch_infos+pitch_velos+pitch_locs)
+      .then(plot_pitch_cards, inputs=[app_df, app_league_df, app_pitch_stats], outputs=pitch_rows+pitch_groups+pitch_names+pitch_infos+pitch_velos+pitch_locs)
   )
 
   gr.Markdown('## Bugs and other notes')

gradio_function.py

@@ -4,7 +4,6 @@ import plotly.graph_objects as go
 import plotly.colors as pc
 from scipy.stats import gaussian_kde
 import numpy as np
-# import pandas as pd
 import polars as pl
 import gradio as gr
 
@@ -21,6 +20,8 @@ from data import (
 MAX_LOCS = len(jp_pitch_to_en_pitch)
 LOCS_PER_ROW = 4
 MAX_ROWS = ceil(MAX_LOCS/LOCS_PER_ROW)
+INSUFFICIENT_PITCHES_MSG = 'No visualization: Not enough pitches thrown'
+INSUFFICIENT_PITCHES_MSG_MULTI_LINE = 'No visualization:<br>Not enough pitches thrown'
 
 # GRADIO FUNCTIONS
 
@@ -75,7 +76,7 @@ colorscale = [
 
 
 @clone_df
-def plot_loc(df, min_pitches=3):
+def plot_loc(df, league_df=None, min_pitches=3, max_pitches=5000):
 
   loc = df.select(['plate_x', 'plate_z'])
 
@@ -111,12 +112,48 @@ def plot_loc(df, min_pitches=3):
       fig.add_annotation(
           x=0,
           y=0,
-          text=f'No visualization<br>as less than {min_pitches} pitches thrown',
+          text=INSUFFICIENT_PITCHES_MSG_MULTI_LINE,
           showarrow=False
       )
+
+  if league_df is not None:
+    league_loc = league_df.select(pl.col('plate_x', 'plate_z'))
+    if len(league_loc) > max_pitches:
+      league_loc = league_loc.sample(max_pitches, seed=0)
+
+    if len(league_loc) >= min_pitches:
+      league_Z = fit_pred_kde(league_loc.to_numpy().T, X, Y)
+      percentile = np.quantile(league_Z, 0.9)
+      fig.add_trace(go.Contour(
+          z=league_Z,
+          x=kde_range,
+          y=kde_range,
+          colorscale=[
+              [0, 'rgba(0, 0, 0, 0)'],
+              [1, 'rgba(0, 0, 0, 0)']
+          ],
+          zmin=percentile,
+          zmax=league_Z.max(),
+          contours={
+              'start': percentile,
+              'end': league_Z.max(),
+              'size': league_Z.max() - percentile,
+              # 'coloring': 'heatmap'
+          },
+          line={
+              'width': 2,
+              'color': 'black',
+              'dash': 'dash'
+          },
+          showlegend=True,
+          showscale=False,
+          name='NPB'
+      ))
+
   fig.update_layout(
     xaxis=dict(range=[-plot_s/2, plot_s/2+1], showticklabels=False),
     yaxis=dict(range=[-plot_s/2, plot_s/2+1], scaleanchor='x', scaleratio=1, showticklabels=False),
+    legend=dict(orientation='h', y=0, yanchor='top'),
     # width=384,
     # height=384
   )
@@ -145,7 +182,7 @@ def plot_velo(df=None, player=None, velos=None, pitch_type=None, pitch_name=None
     fig.add_annotation(
         x=(170+125)/2,
         y=0.3/2,
-        text=f'No visualization<br>as less than {min_pitches} pitches thrown',
+        text=INSUFFICIENT_PITCHES_MSG_MULTI_LINE,
         showarrow=False,
     )
     x_range = [125, 170]
@@ -223,7 +260,7 @@ def plot_velo_summary(df, league_df, player):
       fig.add_trace(go.Scatter(
           x=[velo_center],
           y=[pitch_name],
-          text=[f'No visualization as less than {min_pitches} pitches thrown'],
+          text=[INSUFFICIENT_PITCHES_MSG],
           textposition='top center',
           hovertext=False,
           mode="lines+text",
@@ -271,7 +308,7 @@ def plot_velo_summary(df, league_df, player):
   return fig
 
 
-def update_dfs(player, handedness):
+def update_dfs(player, handedness, df):
   if handedness == 'Both':
     handedness_filter = pl.col('stand').is_in(['R', 'L'])
     _pitch_stats = pitch_stats
@@ -286,7 +323,7 @@ def update_dfs(player, handedness):
     _league_pitch_stats = lhb_league_pitch_stats
   player_filter = pl.col('name') == player
   final_filter = player_filter & handedness_filter
-  return df.filter(final_filter), _pitch_stats.filter(player_filter), _league_pitch_stats,
+  return df.filter(final_filter), df.filter(handedness_filter), _pitch_stats.filter(player_filter), _league_pitch_stats,
 
 def set_download_file(df):
   file_path = 'files/npb.csv'
@@ -303,7 +340,7 @@ def plot_usage(df, player):
   return fig
 
 @clone_df
-def plot_pitch_cards(df, pitch_stats):
+def plot_pitch_cards(df, league_df, pitch_stats):
   pitch_counts = df['pitch_name'].value_counts().sort('count', descending=True)
 
   pitch_rows = []
@@ -331,7 +368,10 @@ def plot_pitch_cards(df, pitch_stats):
         visible=True
     ))
     pitch_locs.append(gr.update(
-        value=plot_loc(df=df.filter(pl.col('pitch_name') == pitch_name)),
+        value=plot_loc(
+            df=df.filter(pl.col('pitch_name') == pitch_name),
+            league_df=league_df.filter(pl.col('pitch_name') == pitch_name)
+        ),
         label='Pitch location',
         visible=True
     ))
@@ -358,91 +398,3 @@ def update_velo_stats(pitch_stats, league_pitch_stats):
       .sort('Count', descending=True)
       .drop('Count')
   )
-
-# def get_data(player, handedness):
-#   player_name = f'# {player}'
-
-#   # _df = df.set_index('name').sort_index().loc[player]
-#   # _df.to_csv(f'files/npb.csv', index=False)
-#   # _df_by_pitch_name = _df.set_index('pitch_name').sort_index()
-#   _df = df.filter(pl.col('name') == player)
-#   league_df = df
-#   _pitch_stats = pitch_stats
-#   _league_pitch_stats = league_pitch_stats
-#   if handedness == 'Right':
-#     _df = _df.filter(pl.col('stand') == 'R')
-#     league_df = league_df.filter(pl.col('stand') == 'R')
-#     _pitch_stats = rhb_pitch_stats
-#     _league_pitch_stats = rhb_league_pitch_stats
-#   elif handedness == 'Left':
-#     _df = _df.filter(pl.col('stand') == 'L')
-#     league_df = league_df.filter(pl.col('stand') == 'L')
-#     _pitch_stats = lhb_pitch_stats
-#     _league_pitch_stats = lhb_league_pitch_stats
-
-#   handedness = gr.update(value=handedness, interactive=True)
-
-#   # usage_fig = px.pie(_df['pitch_name'], names='pitch_name')
-#   usage_fig = px.pie(_df.select('pitch_name'), names='pitch_name')
-
-#   usage_fig.update_traces(texttemplate='%{percent:.1%}', hovertemplate=f'<b>{player}</b><br>' + 'threw a <b>%{label}</b><br><b>%{percent:.1%}</b> of the time (<b>%{value}</b> pitches)')
-
-#   pitch_counts = _df['pitch_name'].value_counts().sort('count', descending=True)
-
-#   # pitch_velo_summary = plot_all_pitch_velo(player=player, player_df=_df_by_pitch_name, pitch_counts=pitch_counts.sort_values(ascending=True))
-#   pitch_velo_summary = plot_all_pitch_velo(df=league_df, player=player, player_df=_df.filter(pl.col('release_speed').is_not_null()), pitch_counts=pitch_counts.sort('count', descending=False))
-#   pitch_loc_summary = plot_pitch_map(df=_df, player=player, all_pitches=True)
-
-#   pitch_groups = []
-#   pitch_names = []
-#   pitch_infos = []
-#   pitch_velos = []
-#   pitch_maps = []
-
-#   # for pitch_name, count in pitch_counts.items():
-#   for pitch_name, count in pitch_counts.iter_rows():
-#     pitch_groups.append(gr.update(visible=True))
-#     pitch_names.append(gr.update(value=f'### {pitch_name}', visible=True))
-#     pitch_infos.append(gr.update(
-#         # value=pd.DataFrame([{
-#         #     'Whiff%': pitch_stats.loc[(player, pitch_name), 'Whiff%'].item(),
-#         #     'CSW%': pitch_stats.loc[(player, pitch_name), 'CSW%'].item()
-#         # }]),
-#         value=_pitch_stats.filter((pl.col('name') == player) & (pl.col('pitch_name') == pitch_name)).select(['Whiff%', 'CSW%']),
-#         visible=True
-#     ))
-
-#     pitch_velos.append(gr.update(
-#         # value=plot_pitch_velo(velos=_df_by_pitch_name.loc[pitch_name, 'release_speed']),
-#         value=plot_pitch_velo(velos=_df.filter((pl.col('pitch_name') == pitch_name) & (pl.col('release_speed').is_not_null()))['release_speed']),
-#         visible=True
-#     ))
-#     pitch_maps.append(gr.update(
-#         value=plot_pitch_map(df=_df, player=player, pitch_name=pitch_name),
-#         label='Pitch location',
-#         visible=True
-#     ))
-
-#   for _ in range(max_pitch_types - len(pitch_names)):
-#     pitch_groups.append(gr.update(visible=False))
-#     pitch_names.append(gr.update(value=None, visible=False))
-#     pitch_infos.append(gr.update(value=None, visible=False))
-#   for _ in range(max_pitch_types - len(pitch_maps)):
-#     pitch_velos.append(gr.update(value=None, visible=False))
-#     pitch_maps.append(gr.update(value=None, visible=False))
-
-#   # velo_stats = pd.concat([pitch_stats.loc[player, 'Velocity'].rename('Avg. Velo'), league_pitch_stats['Velocity'].rename('League Avg. Velo')], join='inner', axis=1).rename_axis(['Pitch']).reset_index()
-#   velo_stats = (
-#       _pitch_stats
-#       .filter(pl.col('name') == player)
-#       .select(pl.col('pitch_name').alias('Pitch'), pl.col('Velocity').alias('Avg. Velo'), pl.col('Count'))
-#       .join(
-#           _league_pitch_stats.select(pl.col('pitch_name').alias('Pitch'), pl.col('Velocity').alias('League Avg. Velo')),
-#           on='Pitch',
-#           how='inner'
-#       )
-#       .sort('Count', descending=True)
-#       .drop('Count')
-#   )
-
-#   return player_name, handedness, 'files/npb.csv', usage_fig, pitch_velo_summary, pitch_loc_summary, *pitch_groups, *pitch_names, *pitch_infos, *pitch_velos, *pitch_maps, velo_stats