diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6ceed8c --- /dev/null +++ b/.gitignore @@ -0,0 +1,17 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] + +# VS Code +.vscode/ + +# Jupyter NB Checkpoints +.ipynb_checkpoints/ + +# Mac OS-specific storage files +.DS_Store + +*.profraw + +# Own +data/ diff --git a/Lesson4.py b/Lesson4.py deleted file mode 100644 index 9ccd330..0000000 --- a/Lesson4.py +++ /dev/null @@ -1,94 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -""" -Created on Sun Apr 5 13:19:08 2020 - -Script for lesson 4 of "Friends of Tracking" #FoT - -Data can be found at: https://github.com/metrica-sports/sample-data - -@author: Laurie Shaw (@EightyFivePoint) -""" - -import Metrica_IO as mio -import Metrica_Viz as mviz - -# set up initial path to data -DATADIR = '/PATH/TO/WHERE/YOU/SAVED/THE/SAMPLE/DATA' -game_id = 2 # let's look at sample match 2 - -# read in the event data -events = mio.read_event_data(DATADIR,game_id) - -# count the number of each event type in the data -print( events['Type'].value_counts() ) - -# Bit of housekeeping: unit conversion from metric data units to meters -events = mio.to_metric_coordinates(events) - -# Get events by team -home_events = events[events['Team']=='Home'] -away_events = events[events['Team']=='Away'] - -# Frequency of each event type by team -home_events['Type'].value_counts() -away_events['Type'].value_counts() - -# Get all shots -shots = events[events['Type']=='SHOT'] -home_shots = home_events[home_events.Type=='SHOT'] -away_shots = away_events[away_events.Type=='SHOT'] - -# Look at frequency of each shot Subtype -home_shots['Subtype'].value_counts() -away_shots['Subtype'].value_counts() - -# Look at the number of shots taken by each home player -print( home_shots['From'].value_counts() ) - -# Get the shots that led to a goal -home_goals = home_shots[home_shots['Subtype'].str.contains('-GOAL')].copy() -away_goals = away_shots[away_shots['Subtype'].str.contains('-GOAL')].copy() - -# Add a column event 'Minute' to the data frame -home_goals['Minute'] = home_goals['Start Time [s]']/60. - -# Plot the first goal -fig,ax = mviz.plot_pitch() -ax.plot( events.loc[198]['Start X'], events.loc[198]['Start Y'], 'ro' ) -ax.annotate("", xy=events.loc[198][['End X','End Y']], xytext=events.loc[198][['Start X','Start Y']], alpha=0.6, arrowprops=dict(arrowstyle="->",color='r')) - -# plot passing move in run up to goal -mviz.plot_events( events.loc[190:198], indicators = ['Marker','Arrow'], annotate=True ) - -#### TRACKING DATA #### - -# READING IN TRACKING DATA -tracking_home = mio.tracking_data(DATADIR,game_id,'Home') -tracking_away = mio.tracking_data(DATADIR,game_id,'Away') - -# Look at the column namems -print( tracking_home.columns ) - -# Convert positions from metrica units to meters -tracking_home = mio.to_metric_coordinates(tracking_home) -tracking_away = mio.to_metric_coordinates(tracking_away) - -# Plot some player trajectories (players 11,1,2,3,4) -fig,ax = mviz.plot_pitch() -ax.plot( tracking_home['Home_11_x'].iloc[:1500], tracking_home['Home_11_y'].iloc[:1500], 'r.', MarkerSize=1) -ax.plot( tracking_home['Home_1_x'].iloc[:1500], tracking_home['Home_1_y'].iloc[:1500], 'b.', MarkerSize=1) -ax.plot( tracking_home['Home_2_x'].iloc[:1500], tracking_home['Home_2_y'].iloc[:1500], 'g.', MarkerSize=1) -ax.plot( tracking_home['Home_3_x'].iloc[:1500], tracking_home['Home_3_y'].iloc[:1500], 'k.', MarkerSize=1) -ax.plot( tracking_home['Home_4_x'].iloc[:1500], tracking_home['Home_4_y'].iloc[:1500], 'c.', MarkerSize=1) - -# plot player positions at ,atckick-off -KO_Frame = events.loc[0]['Start Frame'] -fig,ax = mviz.plot_frame( tracking_home.loc[KO_Frame], tracking_away.loc[KO_Frame] ) - -# PLOT POISTIONS AT GOAL -fig,ax = mviz.plot_events( events.loc[198:198], indicators = ['Marker','Arrow'], annotate=True ) -goal_frame = events.loc[198]['Start Frame'] -fig,ax = mviz.plot_frame( tracking_home.loc[goal_frame], tracking_away.loc[goal_frame], figax = (fig,ax) ) - -# END diff --git a/Lesson5.py b/Lesson5.py deleted file mode 100644 index 328ca8c..0000000 --- a/Lesson5.py +++ /dev/null @@ -1,143 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- -""" -Created on Mon Apr 13 11:34:26 2020 - -Script for lesson 5 of "Friends of Tracking" #FoT - -Data can be found at: https://github.com/metrica-sports/sample-data - -Accompanying video tutorials can be found here: https://www.youtube.com/channel/UCUBFJYcag8j2rm_9HkrrA7w - -GitHub repo: https://github.com/Friends-of-Tracking-Data-FoTD/LaurieOnTracking - -@author: Laurie Shaw (@EightyFivePoint) -""" - - -import Metrica_IO as mio -import Metrica_Viz as mviz -import Metrica_Velocities as mvel -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd - -# set up initial path to data -DATADIR = '/PATH/TO/WHERE/YOU/SAVED/THE/SAMPLE/DATA' -game_id = 2 # let's look at sample match 2 - -# read in the event data -events = mio.read_event_data(DATADIR,game_id) - -# read in tracking data -tracking_home = mio.tracking_data(DATADIR,game_id,'Home') -tracking_away = mio.tracking_data(DATADIR,game_id,'Away') - -# Convert positions from metrica units to meters (note change in Metrica's coordinate system since the last lesson) -tracking_home = mio.to_metric_coordinates(tracking_home) -tracking_away = mio.to_metric_coordinates(tracking_away) -events = mio.to_metric_coordinates(events) - -# reverse direction of play in the second half so that home team is always attacking from right->left -tracking_home,tracking_away,events = mio.to_single_playing_direction(tracking_home,tracking_away,events) - -# Making a movie of the second home team goal -#PLOTDIR = DATADIR -#mviz.save_match_clip(tracking_home.iloc[73600:73600+500],tracking_away.iloc[73600:73600+500],PLOTDIR,fname='home_goal_2',include_player_velocities=False) - -# Calculate player velocities -tracking_home = mvel.calc_player_velocities(tracking_home,smoothing=True) -tracking_away = mvel.calc_player_velocities(tracking_away,smoothing=True) - -# plot a random frame, plotting the player velocities using quivers -mviz.plot_frame( tracking_home.loc[10000], tracking_away.loc[10000], include_player_velocities=True, annotate=True) - -# Create a Physical summary dataframe for home players -home_players = np.unique( [ c.split('_')[1] for c in tracking_home.columns if c[:4] == 'Home' ] ) -home_summary = pd.DataFrame(index=home_players) - -# Calculate minutes played for each player -minutes = [] -for player in home_players: - # search for first and last frames that we have a position observation for each player (when a player is not on the pitch positions are NaN) - column = 'Home_' + player + '_x' # use player x-position coordinate - player_minutes = ( tracking_home[column].last_valid_index() - tracking_home[column].first_valid_index() + 1 ) / 25 / 60. # convert to minutes - minutes.append( player_minutes ) -home_summary['Minutes Played'] = minutes -home_summary = home_summary.sort_values(['Minutes Played'], ascending=False) - -# Calculate total distance covered for each player -distance = [] -for player in home_summary.index: - column = 'Home_' + player + '_speed' - player_distance = tracking_home[column].sum()/25./1000 # this is the sum of the distance travelled from one observation to the next (1/25 = 40ms) in km. - distance.append( player_distance ) -home_summary['Distance [km]'] = distance - -# make a simple bar chart of distance covered for each player -plt.subplots() -ax = home_summary['Distance [km]'].plot.bar(rot=0) -ax.set_xlabel('Player') -ax.set_ylabel('Distance covered [km]') - -# plot positions at KO (to find out what position each player is playing) -mviz.plot_frame( tracking_home.loc[51], tracking_away.loc[51], include_player_velocities=False, annotate=True) - -# now calculate distance covered while: walking, joggings, running, sprinting -walking = [] -jogging = [] -running = [] -sprinting = [] -for player in home_summary.index: - column = 'Home_' + player + '_speed' - # walking (less than 2 m/s) - player_distance = tracking_home.loc[tracking_home[column] < 2, column].sum()/25./1000 - walking.append( player_distance ) - # jogging (between 2 and 4 m/s) - player_distance = tracking_home.loc[ (tracking_home[column] >= 2) & (tracking_home[column] < 4), column].sum()/25./1000 - jogging.append( player_distance ) - # running (between 4 and 7 m/s) - player_distance = tracking_home.loc[ (tracking_home[column] >= 4) & (tracking_home[column] < 7), column].sum()/25./1000 - running.append( player_distance ) - # sprinting (greater than 7 m/s) - player_distance = tracking_home.loc[ tracking_home[column] >= 7, column].sum()/25./1000 - sprinting.append( player_distance ) - -home_summary['Walking [km]'] = walking -home_summary['Jogging [km]'] = jogging -home_summary['Running [km]'] = running -home_summary['Sprinting [km]'] = sprinting - -# make a clustered bar chart of distance covered for each player at each speed -ax = home_summary[['Walking [km]','Jogging [km]','Running [km]','Sprinting [km]']].plot.bar(colormap='coolwarm') -ax.set_xlabel('Player') -ax.set_ylabel('Distance covered [m]') - -# sustained sprints: how many sustained sprints per match did each player complete? Defined as maintaining a speed > 7 m/s for at least 1 second -nsprints = [] -sprint_threshold = 7 # minimum speed to be defined as a sprint (m/s) -sprint_window = 1*25 # minimum duration sprint should be sustained (in this case, 1 second = 25 consecutive frames) -for player in home_summary.index: - column = 'Home_' + player + '_speed' - # trick here is to convolve speed with a window of size 'sprint_window', and find number of occassions that sprint was sustained for at least one window length - # diff helps us to identify when the window starts - player_sprints = np.diff( 1*( np.convolve( 1*(tracking_home[column]>=sprint_threshold), np.ones(sprint_window), mode='same' ) >= sprint_window ) ) - nsprints.append( np.sum( player_sprints == 1 ) ) -home_summary['# sprints'] = nsprints - -# Plot the trajectories for each of player 10's sprints -player = '10' -column = 'Home_' + player + '_speed' # spped -column_x = 'Home_' + player + '_x' # x position -column_y = 'Home_' + player + '_y' # y position -# same trick as before to find start and end indices of windows of size 'sprint_window' in which player speed was above the sprint_threshold -player_sprints = np.diff( 1*( np.convolve( 1*(tracking_home[column]>=sprint_threshold), np.ones(sprint_window), mode='same' ) >= sprint_window ) ) -player_sprints_start = np.where( player_sprints == 1 )[0] - int(sprint_window/2) + 1 # adding sprint_window/2 because of the way that the convolution is centred -player_sprints_end = np.where( player_sprints == -1 )[0] + int(sprint_window/2) + 1 -# now plot all the sprints -fig,ax = mviz.plot_pitch() -for s,e in zip(player_sprints_start,player_sprints_end): - ax.plot(tracking_home[column_x].iloc[s],tracking_home[column_y].iloc[s],'ro') - ax.plot(tracking_home[column_x].iloc[s:e+1],tracking_home[column_y].iloc[s:e+1],'r') - -# END diff --git a/README.md b/README.md index d42c581..7f4320b 100644 --- a/README.md +++ b/README.md @@ -6,3 +6,30 @@ The sample data can be found in Metrica's github repository here: https://github We'll be updating this repo as the friends of tracking series develops, adding code for measuring player velocity and acceleration, measuring team formations, and evaluating pitch control using a model published by Will Spearman. To create movies from the tracking data you'll need to have ffmpeg installed. You can do this by following the instructions here: https://anaconda.org/conda-forge/ffmpeg (you may need to restart python afterwards). + +## Notebooks +If you want to run the notebooks for each session, you can either install the repository locally or run it directly on Binder or Google Colab. In case you do not know, use Google Colab! +- Run each cell in the notebook and ignore the warning about the unknown environment. +- The data is downloaded directly from Metricas repository. +- Give it some time when it says "Readining team home" in a cell. + +| Lesson | Binder | Colab | +| --- | --- | --- | +| [Lesson 4 - Basic Plotting of Event and Tracking Data](notebooks/Lesson4.ipynb) | [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/seidlr/LaurieOnTracking/master?filepath=notebooks/Lesson4.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/seidlr/LaurieOnTracking/blob/master/notebooks/Lesson4.ipynb) | +| [Lesson 5 - Advanced Plotting and Summary Statistics](notebooks/Lesson5.ipynb) | [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/seidlr/LaurieOnTracking/master?filepath=notebooks/Lesson5.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/seidlr/LaurieOnTracking/blob/master/notebooks/Lesson5.ipynb) | +| [Lesson 6 - Pitch Control](notebooks/Lesson6.ipynb) | [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/seidlr/LaurieOnTracking/master?filepath=notebooks/Lesson6.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/seidlr/LaurieOnTracking/blob/master/notebooks/Lesson6.ipynb) | + + + +### Local installation +1. Download Anaconda +2. Clone repository +3. Create environment `fotd-laurie-on-tracking`: +``` +conda env update +``` +4. Start jupyter notebook server +``` +jupyter notebook +``` +5. Select the kernel `fotd-laurie-on-tracking` for your notebook \ No newline at end of file diff --git a/environment.yml b/environment.yml new file mode 100644 index 0000000..4ddc819 --- /dev/null +++ b/environment.yml @@ -0,0 +1,10 @@ +name: fotd-laurie-on-tracking +channels: + - conda-forge +dependencies: + - ipykernel + - numpy=1.18.1 + - matplotlib=3.2.1 + - pandas=1.0.3 + - requests=2.23.0 + - scipy=1.4.1 diff --git a/friendsoftracking/__init__.py b/friendsoftracking/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/Metrica_IO.py b/friendsoftracking/metrica/IO.py similarity index 72% rename from Metrica_IO.py rename to friendsoftracking/metrica/IO.py index 4f268e4..800c3eb 100644 --- a/Metrica_IO.py +++ b/friendsoftracking/metrica/IO.py @@ -9,39 +9,46 @@ @author: Laurie Shaw (@EightyFivePoint) """ - +import requests import pandas as pd import csv as csv -def read_match_data(DATADIR,gameid): +BASE_URL = 'https://raw.githubusercontent.com/metrica-sports/sample-data/master/data/' +EVENT_URL = 'Sample_Game_{game_id}/Sample_Game_{game_id}_RawEventsData.csv' +TRACKING_URL = 'Sample_Game_{game_id}/Sample_Game_{game_id}_RawTrackingData_{teamname}_Team.csv' + +def read_match_data(game_id): ''' - read_match_data(DATADIR,gameid): + read_match_data(gameid): read all Metrica match data (tracking data for home & away teams, and ecvent data) ''' - tracking_home = tracking_data(DATADIR,gameid,'Home') - tracking_away = tracking_data(DATADIR,gameid,'Away') - events = read_event_data(DATADIR,gameid) + tracking_home = read_tracking_data(game_id, 'Home') + tracking_away = read_tracking_data(game_id, 'Away') + events = read_event_data(game_id) return tracking_home,tracking_away,events -def read_event_data(DATADIR,game_id): +def read_event_data(game_id): ''' - read_event_data(DATADIR,game_id): + read_event_data(game_id): read Metrica event data for game_id and return as a DataFrame ''' - eventfile = '/Sample_Game_%d/Sample_Game_%d_RawEventsData.csv' % (game_id,game_id) # filename - events = pd.read_csv('{}/{}'.format(DATADIR, eventfile)) # read data + url = BASE_URL + EVENT_URL + events = pd.read_csv(url.format(game_id=game_id)) # read data return events -def tracking_data(DATADIR,game_id,teamname): +def read_tracking_data(game_id,teamname): ''' - tracking_data(DATADIR,game_id,teamname): + read_tracking_data(game_id,teamname): read Metrica tracking data for game_id and return as a DataFrame. teamname is the name of the team in the filename. For the sample data this is either 'Home' or 'Away'. ''' - teamfile = '/Sample_Game_%d/Sample_Game_%d_RawTrackingData_%s_Team.csv' % (game_id,game_id,teamname) - # First: deal with file headers so that we can get the player names correct - csvfile = open('{}/{}'.format(DATADIR, teamfile), 'r') # create a csv file reader - reader = csv.reader(csvfile) + + url = BASE_URL + TRACKING_URL + url = url.format(game_id=game_id, teamname=teamname) + response = requests.get(url) + decoded = response.content.decode('utf-8') + + reader = csv.reader(decoded.splitlines()) teamnamefull = next(reader)[3].lower() print("Reading team: %s" % teamnamefull) # construct column names @@ -53,7 +60,7 @@ def tracking_data(DATADIR,game_id,teamname): columns[-2] = "ball_x" # column headers for the x & y positions of the ball columns[-1] = "ball_y" # Second: read in tracking data and place into pandas Dataframe - tracking = pd.read_csv('{}/{}'.format(DATADIR, teamfile), names=columns, index_col='Frame', skiprows=3) + tracking = pd.read_csv(url, names=columns, index_col='Frame', skiprows=3) return tracking def merge_tracking_data(home,away): diff --git a/friendsoftracking/metrica/PitchControl.py b/friendsoftracking/metrica/PitchControl.py new file mode 100644 index 0000000..d992a64 --- /dev/null +++ b/friendsoftracking/metrica/PitchControl.py @@ -0,0 +1,287 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Mon Apr 19 14:52:19 2020 + +Module for calculating a Pitch Control surface using MetricaSports's tracking & event data. + +Pitch control (at a given location on the field) is the probability that a team will gain +possession if the ball is moved to that location on the field. + +Methdology is described in "Off the ball scoring opportunities" by William Spearman: +http://www.sloansportsconference.com/wp-content/uploads/2018/02/2002.pdf + +GitHub repo for this code can be found here: +https://github.com/Friends-of-Tracking-Data-FoTD/LaurieOnTracking + +Data can be found at: https://github.com/metrica-sports/sample-data + +Functions +---------- + +calculate_pitch_control_at_target(): calculate the pitch control probability for the attacking and defending teams at a specified target position on the ball. + +generate_pitch_control_for_event(): this function evaluates pitch control surface over the entire field at the moment +of the given event (determined by the index of the event passed as an input) + +Classes +--------- + +The 'player' class collects and stores trajectory information for each player required by the pitch control calculations. + +@author: Laurie Shaw (@EightyFivePoint) + +""" + +import numpy as np + + +def initialise_players(team,teamname,params): + """ + initialise_players(team,teamname,params) + + create a list of player objects that holds their positions and velocities from the tracking data dataframe + + Parameters + ----------- + + team: row (i.e. instant) of either the home or away team tracking Dataframe + teamname: team name "Home" or "Away" + params: Dictionary of model parameters (default model parameters can be generated using default_model_params() ) + + Returns + ----------- + + team_players: list of player objects for the team at at given instant + + """ + # get player ids + player_ids = np.unique( [ c.split('_')[1] for c in team.keys() if c[:4] == teamname ] ) + # create list + team_players = [] + for p in player_ids: + # create a player object for player_id 'p' + team_player = player(p,team,teamname,params) + if team_player.inframe: + team_players.append(team_player) + return team_players + +class player(object): + """ + player() class + + Class defining a player object that stores position, velocity, time-to-intercept and pitch control contributions for a player + + __init__ Parameters + ----------- + pid: id (jersey number) of player + team: row of tracking data for team + teamname: team name "Home" or "Away" + params: Dictionary of model parameters (default model parameters can be generated using default_model_params() ) + + + methods include: + ----------- + simple_time_to_intercept(r_final): time take for player to get to target position (r_final) given current position + probability_intercept_ball(T): probability player will have controlled ball at time T given their expected time_to_intercept + + """ + # player object holds position, velocity, time-to-intercept and pitch control contributions for each player + def __init__(self,pid,team,teamname,params): + self.id = pid + self.teamname = teamname + self.playername = "%s_%s_" % (teamname,pid) + self.vmax = params['max_player_speed'] # player max speed in m/s. Could be individualised + self.reaction_time = params['reaction_time'] # player reaction time in 's'. Could be individualised + self.tti_sigma = params['tti_sigma'] # standard deviation of sigmoid function (see Eq 4 in Spearman, 2018) + self.get_position(team) + self.get_velocity(team) + self.PPCF = 0. # initialise this for later + + def get_position(self,team): + self.position = np.array( [ team[self.playername+'x'], team[self.playername+'y'] ] ) + self.inframe = not np.any( np.isnan(self.position) ) + + def get_velocity(self,team): + self.velocity = np.array( [ team[self.playername+'vx'], team[self.playername+'vy'] ] ) + if np.any( np.isnan(self.velocity) ): + self.velocity = np.array([0.,0.]) + + def simple_time_to_intercept(self, r_final): + self.PPCF = 0. # initialise this for later + # Time to intercept assumes that the player continues moving at current velocity for 'reaction_time' seconds + # and then runs at full speed to the target position. + r_reaction = self.position + self.velocity*self.reaction_time + self.time_to_intercept = self.reaction_time + np.linalg.norm(r_final-r_reaction)/self.vmax + return self.time_to_intercept + + def probability_intercept_ball(self,T): + # probability of a player arriving at target location at time 'T' given their expected time_to_intercept (time of arrival), as described in Spearman 2018 + f = 1/(1. + np.exp( -np.pi/np.sqrt(3.0)/self.tti_sigma * (T-self.time_to_intercept) ) ) + return f + +""" Generate pitch control map """ + +def default_model_params(time_to_control_veto=3): + """ + default_model_params() + + Returns the default parameters that define and evaluate the model. See Spearman 2018 for more details. + + Parameters + ----------- + time_to_control_veto: If the probability that another team or player can get to the ball and control it is less than 10^-time_to_control_veto, ignore that player. + + + Returns + ----------- + + params: dictionary of parameters required to determine and calculate the model + + """ + # key parameters for the model, as described in Spearman 2018 + params = {} + # model parameters + params['max_player_accel'] = 7. # maximum player acceleration m/s/s, not used in this implementation + params['max_player_speed'] = 5. # maximum player speed m/s + params['reaction_time'] = 0.7 # seconds, time taken for player to react and change trajectory. Roughly determined as vmax/amax + params['tti_sigma'] = 0.45 # Standard deviation of sigmoid function in Spearman 2018 ('s') that determines uncertainty in player arrival time + params['kappa_def'] = 1. # kappa parameter in Spearman 2018 (=1.72 in the paper) that gives the advantage defending players to control ball, I have set to 1 so that home & away players have same ball control probability + params['lambda_att'] = 4.3 # ball control parameter for attacking team + params['lambda_def'] = 4.3 * params['kappa_def'] # ball control parameter for defending team + params['average_ball_speed'] = 15. # average ball travel speed in m/s + # numerical parameters for model evaluation + params['int_dt'] = 0.04 # integration timestep (dt) + params['max_int_time'] = 10 # upper limit on integral time + params['model_converge_tol'] = 0.01 # assume convergence when PPCF>0.99 at a given location. + # The following are 'short-cut' parameters. We do not need to calculated PPCF explicitly when a player has a sufficient head start. + # A sufficient head start is when the a player arrives at the target location at least 'time_to_control' seconds before the next player + params['time_to_control_att'] = time_to_control_veto*np.log(10) * (np.sqrt(3)*params['tti_sigma']/np.pi + 1/params['lambda_att']) + params['time_to_control_def'] = time_to_control_veto*np.log(10) * (np.sqrt(3)*params['tti_sigma']/np.pi + 1/params['lambda_def']) + return params + +def generate_pitch_control_for_event(event_id, events, tracking_home, tracking_away, params, field_dimen = (106.,68.,), n_grid_cells_x = 50): + """ generate_pitch_control_for_event + + Evaluates pitch control surface over the entire field at the moment of the given event (determined by the index of the event passed as an input) + + Parameters + ----------- + event_id: Index (not row) of the event that describes the instant at which the pitch control surface should be calculated + events: Dataframe containing the event data + tracking_home: tracking DataFrame for the Home team + tracking_away: tracking DataFrame for the Away team + params: Dictionary of model parameters (default model parameters can be generated using default_model_params() ) + field_dimen: tuple containing the length and width of the pitch in meters. Default is (106,68) + n_grid_cells_x: Number of pixels in the grid (in the x-direction) that covers the surface. Default is 50. + n_grid_cells_y will be calculated based on n_grid_cells_x and the field dimensions + + Returrns + ----------- + PPCFa: Pitch control surface (dimen (n_grid_cells_x,n_grid_cells_y) ) containing pitch control probability for the attcking team. + Surface for the defending team is just 1-PPCFa. + xgrid: Positions of the pixels in the x-direction (field length) + ygrid: Positions of the pixels in the y-direction (field width) + + """ + # get the details of the event (frame, team in possession, ball_start_position) + pass_frame = events.loc[event_id]['Start Frame'] + pass_team = events.loc[event_id].Team + ball_start_pos = np.array([events.loc[event_id]['Start X'],events.loc[event_id]['Start Y']]) + # break the pitch down into a grid + n_grid_cells_y = int(n_grid_cells_x*field_dimen[1]/field_dimen[0]) + xgrid = np.linspace( -field_dimen[0]/2., field_dimen[0]/2., n_grid_cells_x) + ygrid = np.linspace( -field_dimen[1]/2., field_dimen[1]/2., n_grid_cells_y ) + # initialise pitch control grids for attacking and defending teams + PPCFa = np.zeros( shape = (len(ygrid), len(xgrid)) ) + PPCFd = np.zeros( shape = (len(ygrid), len(xgrid)) ) + # initialise player positions and velocities for pitch control calc (so that we're not repeating this at each grid cell position) + if pass_team=='Home': + attacking_players = initialise_players(tracking_home.loc[pass_frame],'Home',params) + defending_players = initialise_players(tracking_away.loc[pass_frame],'Away',params) + elif pass_team=='Away': + defending_players = initialise_players(tracking_home.loc[pass_frame],'Home',params) + attacking_players = initialise_players(tracking_away.loc[pass_frame],'Away',params) + else: + assert False, "Team in possession must be either home or away" + # calculate pitch pitch control model at each location on the pitch + for i in range( len(ygrid) ): + for j in range( len(xgrid) ): + target_position = np.array( [xgrid[j], ygrid[i]] ) + PPCFa[i,j],PPCFd[i,j] = calculate_pitch_control_at_target(target_position, attacking_players, defending_players, ball_start_pos, params) + # check probabilitiy sums within convergence + checksum = np.sum( PPCFa + PPCFd ) / float(n_grid_cells_y*n_grid_cells_x ) + assert 1-checksum < params['model_converge_tol'], "Checksum failed: %1.3f" % (1-checksum) + return PPCFa,xgrid,ygrid + +def calculate_pitch_control_at_target(target_position, attacking_players, defending_players, ball_start_pos, params): + """ calculate_pitch_control_at_target + + Calculates the pitch control probability for the attacking and defending teams at a specified target position on the ball. + + Parameters + ----------- + target_position: size 2 numpy array containing the (x,y) position of the position on the field to evaluate pitch control + attacking_players: list of 'player' objects (see player class above) for the players on the attacking team (team in possession) + defending_players: list of 'player' objects (see player class above) for the players on the defending team + ball_start_pos: Current position of the ball (start position for a pass). If set to NaN, function will assume that the ball is already at the target position. + params: Dictionary of model parameters (default model parameters can be generated using default_model_params() ) + + Returrns + ----------- + PPCFatt: Pitch control probability for the attacking team + PPCFdef: Pitch control probability for the defending team ( 1-PPCFatt-PPCFdef < params['model_converge_tol'] ) + + """ + # calculate ball travel time from start position to end position. + if ball_start_pos is None or any(np.isnan(ball_start_pos)): # assume that ball is already at location + ball_travel_time = 0.0 + else: + # ball travel time is distance to target position from current ball position divided assumed average ball speed + ball_travel_time = np.linalg.norm( target_position - ball_start_pos )/params['average_ball_speed'] + + # first get arrival time of 'nearest' attacking player (nearest also dependent on current velocity) + tau_min_att = np.nanmin( [p.simple_time_to_intercept(target_position) for p in attacking_players] ) + tau_min_def = np.nanmin( [p.simple_time_to_intercept(target_position ) for p in defending_players] ) + + # check whether we actually need to solve equation 3 + if tau_min_att-max(ball_travel_time,tau_min_def) >= params['time_to_control_def']: + # if defending team can arrive significantly before attacking team, no need to solve pitch control model + return 0., 1. + elif tau_min_def-max(ball_travel_time,tau_min_att) >= params['time_to_control_att']: + # if attacking team can arrive significantly before defending team, no need to solve pitch control model + return 1., 0. + else: + # solve pitch control model by integrating equation 3 in Spearman et al. + # first remove any player that is far (in time) from the target location + attacking_players = [p for p in attacking_players if p.time_to_intercept-tau_min_att < params['time_to_control_att'] ] + defending_players = [p for p in defending_players if p.time_to_intercept-tau_min_def < params['time_to_control_def'] ] + # set up integration arrays + dT_array = np.arange(ball_travel_time-params['int_dt'],ball_travel_time+params['max_int_time'],params['int_dt']) + PPCFatt = np.zeros_like( dT_array ) + PPCFdef = np.zeros_like( dT_array ) + # integration equation 3 of Spearman 2018 until convergence or tolerance limit hit (see 'params') + ptot = 0.0 + i = 1 + while 1-ptot>params['model_converge_tol'] and i=0, 'Invalid attacking player probability (calculate_pitch_control_at_target)' + player.PPCF += dPPCFdT*params['int_dt'] # total contribution from individual player + PPCFatt[i] += player.PPCF # add to sum over players in the attacking team (remembering array element is zero at the start of each integration iteration) + for player in defending_players: + # calculate ball control probablity for 'player' in time interval T+dt + dPPCFdT = (1-PPCFatt[i-1]-PPCFdef[i-1])*player.probability_intercept_ball( T ) * params['lambda_def'] + # make sure it's greater than zero + assert dPPCFdT>=0, 'Invalid defending player probability (calculate_pitch_control_at_target)' + player.PPCF += dPPCFdT*params['int_dt'] # total contribution from individual player + PPCFdef[i] += player.PPCF # add to sum over players in the defending team + ptot = PPCFdef[i]+PPCFatt[i] # total pitch control probability + i += 1 + if i>=dT_array.size: + print("Integration failed to converge: %1.3f" % (ptot) ) + return PPCFatt[i-1], PPCFdef[i-1] + diff --git a/Metrica_Velocities.py b/friendsoftracking/metrica/Velocities.py similarity index 67% rename from Metrica_Velocities.py rename to friendsoftracking/metrica/Velocities.py index 4b0150e..465f9a8 100644 --- a/Metrica_Velocities.py +++ b/friendsoftracking/metrica/Velocities.py @@ -52,17 +52,27 @@ def calc_player_velocities(team, smoothing=True, filter_='Savitzky-Golay', windo if maxspeed>0: # remove unsmoothed data points that exceed the maximum speed (these are most likely position errors) - raw_speed = np.sqrt( vx.values**2 + vy.values**2 ) - vx.values[raw_speed>maxspeed] = np.nan - vy.values[raw_speed>maxspeed] = np.nan + raw_speed = np.sqrt( vx**2 + vy**2 ) + vx[ raw_speed>maxspeed ] = np.nan + vy[ raw_speed>maxspeed ] = np.nan if smoothing: - # calculate first half velocity - vx.loc[:second_half_idx] = signal.savgol_filter(vx.loc[:second_half_idx],window_length=window,polyorder=polyorder) - vy.loc[:second_half_idx] = signal.savgol_filter(vy.loc[:second_half_idx],window_length=window,polyorder=polyorder) - # calculate second half velocity - vx.loc[second_half_idx:] = signal.savgol_filter(vx.loc[second_half_idx:],window_length=window,polyorder=polyorder) - vy.loc[second_half_idx:] = signal.savgol_filter(vy.loc[second_half_idx:],window_length=window,polyorder=polyorder) + if filter_=='Savitzky-Golay': + # calculate first half velocity + vx.loc[:second_half_idx] = signal.savgol_filter(vx.loc[:second_half_idx],window_length=window,polyorder=polyorder) + vy.loc[:second_half_idx] = signal.savgol_filter(vy.loc[:second_half_idx],window_length=window,polyorder=polyorder) + # calculate second half velocity + vx.loc[second_half_idx:] = signal.savgol_filter(vx.loc[second_half_idx:],window_length=window,polyorder=polyorder) + vy.loc[second_half_idx:] = signal.savgol_filter(vy.loc[second_half_idx:],window_length=window,polyorder=polyorder) + elif filter_=='moving average': + ma_window = np.ones( window ) / window + # calculate first half velocity + vx.loc[:second_half_idx] = np.convolve( vx.loc[:second_half_idx] , ma_window, mode='same' ) + vy.loc[:second_half_idx] = np.convolve( vy.loc[:second_half_idx] , ma_window, mode='same' ) + # calculate second half velocity + vx.loc[second_half_idx:] = np.convolve( vx.loc[second_half_idx:] , ma_window, mode='same' ) + vy.loc[second_half_idx:] = np.convolve( vy.loc[second_half_idx:] , ma_window, mode='same' ) + # put player speed in x,y direction, and total speed back in the data frame team[player + "_vx"] = vx diff --git a/Metrica_Viz.py b/friendsoftracking/metrica/Viz.py similarity index 83% rename from Metrica_Viz.py rename to friendsoftracking/metrica/Viz.py index 00281e3..fe6eaf0 100644 --- a/Metrica_Viz.py +++ b/friendsoftracking/metrica/Viz.py @@ -120,6 +120,7 @@ def plot_frame( hometeam, awayteam, figax=None, team_colors=('r','b'), field_dim include_player_velocities: Boolean variable that determines whether player velocities are also plotted (as quivers). Default is False PlayerMarkerSize: size of the individual player marlers. Default is 10 PlayerAlpha: alpha (transparency) of player markers. Defaault is 0.7 + annotate: Boolean variable that determines with player jersey numbers are added to the plot (default is False) Returrns ----------- @@ -253,6 +254,50 @@ def plot_events( events, figax=None, field_dimen = (106.0,68), indicators = ['Ma ax.text( row['Start X'], row['Start Y'], textstring, fontsize=10, color=color) return fig,ax +def plot_pitchcontrol_for_event( event_id, events, tracking_home, tracking_away, PPCF, xgrid, ygrid, alpha = 0.7, include_player_velocities=True, annotate=False, field_dimen = (106.0,68)): + """ plot_pitchcontrol_for_event( event_id, events, tracking_home, tracking_away, PPCF, xgrid, ygrid ) + + Plots the pitch control surface at the instant of the event given by the event_id. Player and ball positions are overlaid. + + Parameters + ----------- + event_id: Index (not row) of the event that describes the instant at which the pitch control surface should be calculated + events: Dataframe containing the event data + tracking_home: (entire) tracking DataFrame for the Home team + tracking_away: (entire) tracking DataFrame for the Away team + PPCF: Pitch control surface (dimen (n_grid_cells_x,n_grid_cells_y) ) containing pitch control probability for the attcking team (as returned by the generate_pitch_control_for_event in Metrica_PitchControl) + xgrid: Positions of the pixels in the x-direction (field length) as returned by the generate_pitch_control_for_event in Metrica_PitchControl + ygrid: Positions of the pixels in the y-direction (field width) as returned by the generate_pitch_control_for_event in Metrica_PitchControl + alpha: alpha (transparency) of player markers. Default is 0.7 + include_player_velocities: Boolean variable that determines whether player velocities are also plotted (as quivers). Default is False + annotate: Boolean variable that determines with player jersey numbers are added to the plot (default is False) + field_dimen: tuple containing the length and width of the pitch in meters. Default is (106,68) + + Returrns + ----------- + fig,ax : figure and aixs objects (so that other data can be plotted onto the pitch) + + """ + + # pick a pass at which to generate the pitch control surface + pass_frame = events.loc[event_id]['Start Frame'] + pass_team = events.loc[event_id].Team + + # plot frame and event + fig,ax = plot_pitch(field_color='white', field_dimen = field_dimen) + plot_frame( tracking_home.loc[pass_frame], tracking_away.loc[pass_frame], figax=(fig,ax), PlayerAlpha=alpha, include_player_velocities=include_player_velocities, annotate=annotate ) + plot_events( events.loc[event_id:event_id], figax = (fig,ax), indicators = ['Marker','Arrow'], annotate=False, color= 'k', alpha=1 ) + + # plot pitch control surface + if pass_team=='Home': + cmap = 'bwr' + else: + cmap = 'bwr_r' + ax.imshow(np.flipud(PPCF), extent=(np.amin(xgrid), np.amax(xgrid), np.amin(ygrid), np.amax(ygrid)),interpolation='hanning',vmin=0.0,vmax=1.0,cmap=cmap,alpha=0.5) + + return fig,ax + + diff --git a/friendsoftracking/metrica/__init__.py b/friendsoftracking/metrica/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/notebooks/Lesson4.ipynb b/notebooks/Lesson4.ipynb new file mode 100644 index 0000000..3f88044 --- /dev/null +++ b/notebooks/Lesson4.ipynb @@ -0,0 +1,486 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install git+https://github.com/seidlr/LaurieOnTracking.git" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lesson 4\n", + "Created on Sun Apr 5 13:19:08 2020 \n", + "Script for lesson 4 of \"Friends of Tracking\" #FoT \n", + "Data can be found at: https://github.com/metrica-sports/sample-data \n", + "@author: Laurie Shaw (@EightyFivePoint) " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import friendsoftracking.metrica.IO as mio\n", + "import friendsoftracking.metrica.Viz as mviz\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = [10, 8]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TeamTypeSubtypePeriodStart FrameStart Time [s]End FrameEnd Time [s]FromToStart XStart YEnd XEnd Y
0AwaySET PIECEKICK OFF1512.04512.04Player23NaNNaNNaNNaNNaN
1AwayPASSNaN1512.04873.48Player23Player200.500.500.400.51
2AwayPASSNaN11465.841867.44Player20Player180.430.500.440.22
3AwayPASSNaN12489.9228311.32Player18Player170.470.190.310.28
4AwayPASSNaN131612.6434613.84Player17Player160.290.320.260.58
\n", + "
" + ], + "text/plain": [ + " Team Type Subtype Period Start Frame Start Time [s] End Frame \\\n", + "0 Away SET PIECE KICK OFF 1 51 2.04 51 \n", + "1 Away PASS NaN 1 51 2.04 87 \n", + "2 Away PASS NaN 1 146 5.84 186 \n", + "3 Away PASS NaN 1 248 9.92 283 \n", + "4 Away PASS NaN 1 316 12.64 346 \n", + "\n", + " End Time [s] From To Start X Start Y End X End Y \n", + "0 2.04 Player23 NaN NaN NaN NaN NaN \n", + "1 3.48 Player23 Player20 0.50 0.50 0.40 0.51 \n", + "2 7.44 Player20 Player18 0.43 0.50 0.44 0.22 \n", + "3 11.32 Player18 Player17 0.47 0.19 0.31 0.28 \n", + "4 13.84 Player17 Player16 0.29 0.32 0.26 0.58 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game_id = 2 # let's look at sample match 2\n", + "\n", + "# read in the event data\n", + "events = mio.read_event_data(game_id)\n", + "events.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "PASS 964\n", + "CHALLENGE 311\n", + "RECOVERY 248\n", + "BALL LOST 233\n", + "SET PIECE 80\n", + "BALL OUT 49\n", + "SHOT 24\n", + "FAULT RECEIVED 20\n", + "CARD 6\n", + "Name: Type, dtype: int64" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# count the number of each event type in the data\n", + "events['Type'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ON TARGET-SAVED 4\n", + "HEAD-OFF TARGET-OUT 4\n", + "ON TARGET-GOAL 2\n", + "OFF TARGET-OUT 2\n", + "HEAD-ON TARGET-GOAL 1\n", + "Name: Subtype, dtype: int64\n", + "\n", + "OFF TARGET-OUT 3\n", + "ON TARGET-GOAL 2\n", + "ON TARGET-SAVED 2\n", + "BLOCKED 2\n", + "OFF TARGET-HEAD-OUT 1\n", + "HEAD-OFF TARGET-OUT 1\n", + "Name: Subtype, dtype: int64\n", + "\n", + "Player9 4\n", + "Player10 3\n", + "Player5 2\n", + "Player4 1\n", + "Player7 1\n", + "Player12 1\n", + "Player3 1\n", + "Name: From, dtype: int64\n" + ] + } + ], + "source": [ + "# Bit of housekeeping: unit conversion from metric data units to meters\n", + "events = mio.to_metric_coordinates(events)\n", + "\n", + "# Get events by team\n", + "home_events = events[events['Team']=='Home']\n", + "away_events = events[events['Team']=='Away']\n", + "\n", + "# Frequency of each event type by team\n", + "home_events['Type'].value_counts()\n", + "away_events['Type'].value_counts()\n", + "\n", + "# Get all shots\n", + "shots = events[events['Type']=='SHOT']\n", + "home_shots = home_events[home_events.Type=='SHOT']\n", + "away_shots = away_events[away_events.Type=='SHOT']\n", + "\n", + "# Look at frequency of each shot Subtype\n", + "print(home_shots['Subtype'].value_counts())\n", + "print()\n", + "print(away_shots['Subtype'].value_counts())\n", + "print()\n", + "# Look at the number of shots taken by each home player\n", + "print( home_shots['From'].value_counts() )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(-47.7, -3.400000000000003, '')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get the shots that led to a goal\n", + "home_goals = home_shots[home_shots['Subtype'].str.contains('-GOAL')].copy()\n", + "away_goals = away_shots[away_shots['Subtype'].str.contains('-GOAL')].copy()\n", + "\n", + "# Add a column event 'Minute' to the data frame\n", + "home_goals['Minute'] = home_goals['Start Time [s]']/60.\n", + "\n", + "# Plot the first goal\n", + "fig,ax = mviz.plot_pitch()\n", + "ax.plot( events.loc[198]['Start X'], events.loc[198]['Start Y'], 'ro' )\n", + "ax.annotate(\"\", xy=events.loc[198][['End X','End Y']], xytext=events.loc[198][['Start X','Start Y']], alpha=0.6, arrowprops=dict(arrowstyle=\"->\",color='r'))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot passing move in run up to goal\n", + "mviz.plot_events( events.loc[190:198], indicators = ['Marker','Arrow'], annotate=True );" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading team: home\n", + "Reading team: away\n", + "Index(['Period', 'Time [s]', 'Home_11_x', 'Home_11_y', 'Home_1_x', 'Home_1_y',\n", + " 'Home_2_x', 'Home_2_y', 'Home_3_x', 'Home_3_y', 'Home_4_x', 'Home_4_y',\n", + " 'Home_5_x', 'Home_5_y', 'Home_6_x', 'Home_6_y', 'Home_7_x', 'Home_7_y',\n", + " 'Home_8_x', 'Home_8_y', 'Home_9_x', 'Home_9_y', 'Home_10_x',\n", + " 'Home_10_y', 'Home_12_x', 'Home_12_y', 'Home_13_x', 'Home_13_y',\n", + " 'Home_14_x', 'Home_14_y', 'ball_x', 'ball_y'],\n", + " dtype='object')\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#### TRACKING DATA ####\n", + "\n", + "# READING IN TRACKING DATA\n", + "tracking_home = mio.read_tracking_data(game_id, 'Home')\n", + "tracking_away = mio.read_tracking_data(game_id, 'Away')\n", + "\n", + "# Look at the column namems\n", + "print( tracking_home.columns )\n", + "\n", + "# Convert positions from metrica units to meters \n", + "tracking_home = mio.to_metric_coordinates(tracking_home)\n", + "tracking_away = mio.to_metric_coordinates(tracking_away)\n", + "\n", + "# Plot some player trajectories (players 11,1,2,3,4)\n", + "fig,ax = mviz.plot_pitch()\n", + "ax.plot( tracking_home['Home_11_x'].iloc[:1500], tracking_home['Home_11_y'].iloc[:1500], 'r.', MarkerSize=1)\n", + "ax.plot( tracking_home['Home_1_x'].iloc[:1500], tracking_home['Home_1_y'].iloc[:1500], 'b.', MarkerSize=1)\n", + "ax.plot( tracking_home['Home_2_x'].iloc[:1500], tracking_home['Home_2_y'].iloc[:1500], 'g.', MarkerSize=1)\n", + "ax.plot( tracking_home['Home_3_x'].iloc[:1500], tracking_home['Home_3_y'].iloc[:1500], 'k.', MarkerSize=1)\n", + "ax.plot( tracking_home['Home_4_x'].iloc[:1500], tracking_home['Home_4_y'].iloc[:1500], 'c.', MarkerSize=1);" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot player positions at ,atckick-off\n", + "KO_Frame = events.loc[0]['Start Frame']\n", + "fig,ax = mviz.plot_frame( tracking_home.loc[KO_Frame], tracking_away.loc[KO_Frame] )" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# PLOT POISTIONS AT GOAL\n", + "fig,ax = mviz.plot_events( events.loc[198:198], indicators = ['Marker','Arrow'], annotate=True )\n", + "goal_frame = events.loc[198]['Start Frame']\n", + "fig,ax = mviz.plot_frame( tracking_home.loc[goal_frame], tracking_away.loc[goal_frame], figax = (fig,ax) );" + ] + } + ], + "metadata": { + "hide_input": false, + "kernelspec": { + "display_name": "Python [conda env:friends-of-tracking-data-youtube]", + "language": "python", + "name": "conda-env-friends-of-tracking-data-youtube-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Lesson5.ipynb b/notebooks/Lesson5.ipynb new file mode 100644 index 0000000..8bc20cc --- /dev/null +++ b/notebooks/Lesson5.ipynb @@ -0,0 +1,1180 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install git+https://github.com/seidlr/LaurieOnTracking.git" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lesson 5\n", + "Created on Mon Apr 13 11:34:26 2020 \n", + "Script for lesson 5 of \"Friends of Tracking\" #FoT \n", + "Data can be found at: https://github.com/metrica-sports/sample-data \n", + "Accompanying video tutorials can be found here: https://www.youtube.com/channel/UCUBFJYcag8j2rm_9HkrrA7w \n", + "GitHub repo: https://github.com/Friends-of-Tracking-Data-FoTD/LaurieOnTracking \n", + "@author: Laurie Shaw (@EightyFivePoint) " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import friendsoftracking.metrica.IO as mio\n", + "import friendsoftracking.metrica.Viz as mviz\n", + "import friendsoftracking.metrica.Velocities as mvel\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = [10, 8]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "game_id = 2 # let's look at sample match 2" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TeamTypeSubtypePeriodStart FrameStart Time [s]End FrameEnd Time [s]FromToStart XStart YEnd XEnd Y
0AwaySET PIECEKICK OFF1512.04512.04Player23NaNNaNNaNNaNNaN
1AwayPASSNaN1512.04873.48Player23Player200.500.500.400.51
2AwayPASSNaN11465.841867.44Player20Player180.430.500.440.22
3AwayPASSNaN12489.9228311.32Player18Player170.470.190.310.28
4AwayPASSNaN131612.6434613.84Player17Player160.290.320.260.58
\n", + "
" + ], + "text/plain": [ + " Team Type Subtype Period Start Frame Start Time [s] End Frame \\\n", + "0 Away SET PIECE KICK OFF 1 51 2.04 51 \n", + "1 Away PASS NaN 1 51 2.04 87 \n", + "2 Away PASS NaN 1 146 5.84 186 \n", + "3 Away PASS NaN 1 248 9.92 283 \n", + "4 Away PASS NaN 1 316 12.64 346 \n", + "\n", + " End Time [s] From To Start X Start Y End X End Y \n", + "0 2.04 Player23 NaN NaN NaN NaN NaN \n", + "1 3.48 Player23 Player20 0.50 0.50 0.40 0.51 \n", + "2 7.44 Player20 Player18 0.43 0.50 0.44 0.22 \n", + "3 11.32 Player18 Player17 0.47 0.19 0.31 0.28 \n", + "4 13.84 Player17 Player16 0.29 0.32 0.26 0.58 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# read in the event data\n", + "events = mio.read_event_data(game_id)\n", + "events.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading team: home\n", + "Reading team: away\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PeriodTime [s]Home_11_xHome_11_yHome_1_xHome_1_yHome_2_xHome_2_yHome_3_xHome_3_y...Home_10_xHome_10_yHome_12_xHome_12_yHome_13_xHome_13_yHome_14_xHome_14_yball_xball_y
Frame
110.0446.9315-0.2808415.7007214.548618.817124.8939621.07492-3.81208...0.20564-7.56364NaNNaNNaNNaNNaNNaNNaNNaN
210.0846.9315-0.2808415.7007214.548618.817124.8939621.07492-3.81208...0.20564-7.56364NaNNaNNaNNaNNaNNaNNaNNaN
310.1246.9315-0.2808415.7007214.548618.817124.8939621.07492-3.81208...0.20564-7.56364NaNNaNNaNNaNNaNNaNNaNNaN
410.1646.9315-0.2808415.7007214.548618.817124.8939621.07492-3.81208...0.20564-7.56364NaNNaNNaNNaNNaNNaNNaNNaN
510.2046.9315-0.2808415.7007214.548618.817124.8939621.07492-3.81208...0.20564-7.56364NaNNaNNaNNaNNaNNaNNaNNaN
\n", + "

5 rows × 32 columns

\n", + "
" + ], + "text/plain": [ + " Period Time [s] Home_11_x Home_11_y Home_1_x Home_1_y Home_2_x \\\n", + "Frame \n", + "1 1 0.04 46.9315 -0.28084 15.70072 14.5486 18.81712 \n", + "2 1 0.08 46.9315 -0.28084 15.70072 14.5486 18.81712 \n", + "3 1 0.12 46.9315 -0.28084 15.70072 14.5486 18.81712 \n", + "4 1 0.16 46.9315 -0.28084 15.70072 14.5486 18.81712 \n", + "5 1 0.20 46.9315 -0.28084 15.70072 14.5486 18.81712 \n", + "\n", + " Home_2_y Home_3_x Home_3_y ... Home_10_x Home_10_y Home_12_x \\\n", + "Frame ... \n", + "1 4.89396 21.07492 -3.81208 ... 0.20564 -7.56364 NaN \n", + "2 4.89396 21.07492 -3.81208 ... 0.20564 -7.56364 NaN \n", + "3 4.89396 21.07492 -3.81208 ... 0.20564 -7.56364 NaN \n", + "4 4.89396 21.07492 -3.81208 ... 0.20564 -7.56364 NaN \n", + "5 4.89396 21.07492 -3.81208 ... 0.20564 -7.56364 NaN \n", + "\n", + " Home_12_y Home_13_x Home_13_y Home_14_x Home_14_y ball_x ball_y \n", + "Frame \n", + "1 NaN NaN NaN NaN NaN NaN NaN \n", + "2 NaN NaN NaN NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN NaN NaN NaN \n", + "5 NaN NaN NaN NaN NaN NaN NaN \n", + "\n", + "[5 rows x 32 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PeriodTime [s]Away_25_xAway_25_yAway_15_xAway_15_yAway_16_xAway_16_yAway_17_xAway_17_y...Away_22_xAway_22_yAway_23_xAway_23_yAway_24_xAway_24_yAway_26_xAway_26_yball_xball_y
Frame
110.04-51.70892-1.19884-18.13554-21.65528-20.42196-3.52376-18.83097.51128...-0.1176635.538840.18762-0.0986-0.511989.36088NaNNaNNaNNaN
210.08-51.70892-1.19884-18.13554-21.65528-20.42196-3.52376-18.83097.51128...-0.1176635.538840.18762-0.0986-0.511989.36088NaNNaNNaNNaN
310.12-51.70892-1.19884-18.13554-21.65528-20.42196-3.52376-18.83097.51128...-0.1176635.538840.18762-0.0986-0.511989.36088NaNNaNNaNNaN
410.16-51.70892-1.19884-18.19384-21.65596-20.42196-3.52376-18.83097.51128...-0.1176635.538840.18762-0.0986-0.511989.36088NaNNaNNaNNaN
510.20-51.70892-1.19884-18.25002-21.65596-20.42196-3.52376-18.83097.51128...-0.1176635.538840.18762-0.0986-0.511989.36088NaNNaNNaNNaN
\n", + "

5 rows × 28 columns

\n", + "
" + ], + "text/plain": [ + " Period Time [s] Away_25_x Away_25_y Away_15_x Away_15_y \\\n", + "Frame \n", + "1 1 0.04 -51.70892 -1.19884 -18.13554 -21.65528 \n", + "2 1 0.08 -51.70892 -1.19884 -18.13554 -21.65528 \n", + "3 1 0.12 -51.70892 -1.19884 -18.13554 -21.65528 \n", + "4 1 0.16 -51.70892 -1.19884 -18.19384 -21.65596 \n", + "5 1 0.20 -51.70892 -1.19884 -18.25002 -21.65596 \n", + "\n", + " Away_16_x Away_16_y Away_17_x Away_17_y ... Away_22_x Away_22_y \\\n", + "Frame ... \n", + "1 -20.42196 -3.52376 -18.8309 7.51128 ... -0.11766 35.53884 \n", + "2 -20.42196 -3.52376 -18.8309 7.51128 ... -0.11766 35.53884 \n", + "3 -20.42196 -3.52376 -18.8309 7.51128 ... -0.11766 35.53884 \n", + "4 -20.42196 -3.52376 -18.8309 7.51128 ... -0.11766 35.53884 \n", + "5 -20.42196 -3.52376 -18.8309 7.51128 ... -0.11766 35.53884 \n", + "\n", + " Away_23_x Away_23_y Away_24_x Away_24_y Away_26_x Away_26_y \\\n", + "Frame \n", + "1 0.18762 -0.0986 -0.51198 9.36088 NaN NaN \n", + "2 0.18762 -0.0986 -0.51198 9.36088 NaN NaN \n", + "3 0.18762 -0.0986 -0.51198 9.36088 NaN NaN \n", + "4 0.18762 -0.0986 -0.51198 9.36088 NaN NaN \n", + "5 0.18762 -0.0986 -0.51198 9.36088 NaN NaN \n", + "\n", + " ball_x ball_y \n", + "Frame \n", + "1 NaN NaN \n", + "2 NaN NaN \n", + "3 NaN NaN \n", + "4 NaN NaN \n", + "5 NaN NaN \n", + "\n", + "[5 rows x 28 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TeamTypeSubtypePeriodStart FrameStart Time [s]End FrameEnd Time [s]FromToStart XStart YEnd XEnd Y
0AwaySET PIECEKICK OFF1512.04512.04Player23NaNNaNNaNNaNNaN
1AwayPASSNaN1512.04873.48Player23Player200.00-0.00-10.60-0.68
2AwayPASSNaN11465.841867.44Player20Player18-7.42-0.00-6.3619.04
3AwayPASSNaN12489.9228311.32Player18Player17-3.1821.08-20.1414.96
4AwayPASSNaN131612.6434613.84Player17Player16-22.2612.24-25.44-5.44
\n", + "
" + ], + "text/plain": [ + " Team Type Subtype Period Start Frame Start Time [s] End Frame \\\n", + "0 Away SET PIECE KICK OFF 1 51 2.04 51 \n", + "1 Away PASS NaN 1 51 2.04 87 \n", + "2 Away PASS NaN 1 146 5.84 186 \n", + "3 Away PASS NaN 1 248 9.92 283 \n", + "4 Away PASS NaN 1 316 12.64 346 \n", + "\n", + " End Time [s] From To Start X Start Y End X End Y \n", + "0 2.04 Player23 NaN NaN NaN NaN NaN \n", + "1 3.48 Player23 Player20 0.00 -0.00 -10.60 -0.68 \n", + "2 7.44 Player20 Player18 -7.42 -0.00 -6.36 19.04 \n", + "3 11.32 Player18 Player17 -3.18 21.08 -20.14 14.96 \n", + "4 13.84 Player17 Player16 -22.26 12.24 -25.44 -5.44 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# read in tracking data\n", + "tracking_home = mio.read_tracking_data(game_id, 'Home')\n", + "tracking_away = mio.read_tracking_data(game_id, 'Away')\n", + "\n", + "# Convert positions from metrica units to meters (note change in Metrica's coordinate system since the last lesson)\n", + "tracking_home = mio.to_metric_coordinates(tracking_home)\n", + "tracking_away = mio.to_metric_coordinates(tracking_away)\n", + "events = mio.to_metric_coordinates(events)\n", + "\n", + "# reverse direction of play in the second half so that home team is always attacking from right->left\n", + "tracking_home,tracking_away,events = mio.to_single_playing_direction(tracking_home,tracking_away,events)\n", + "\n", + "display(tracking_home.head())\n", + "display(tracking_away.head())\n", + "display(events.head())" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Away_25_vyAway_25_speedAway_26_vxAway_26_vyAway_26_speed
Frame
1NaNNaNNaNNaNNaN
2NaNNaNNaNNaNNaN
3NaNNaNNaNNaNNaN
4NaNNaNNaNNaNNaN
51.2458571.708964NaNNaNNaN
\n", + "
" + ], + "text/plain": [ + " Away_25_vy Away_25_speed Away_26_vx Away_26_vy Away_26_speed\n", + "Frame \n", + "1 NaN NaN NaN NaN NaN\n", + "2 NaN NaN NaN NaN NaN\n", + "3 NaN NaN NaN NaN NaN\n", + "4 NaN NaN NaN NaN NaN\n", + "5 1.245857 1.708964 NaN NaN NaN" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Making a movie of the second home team goal\n", + "#PLOTDIR = DATADIR\n", + "#mviz.save_match_clip(tracking_home.iloc[73600:73600+500],tracking_away.iloc[73600:73600+500],PLOTDIR,fname='home_goal_2',include_player_velocities=False)\n", + "\n", + "# Calculate player velocities\n", + "tracking_home = mvel.calc_player_velocities(tracking_home,smoothing=True)\n", + "tracking_away = mvel.calc_player_velocities(tracking_away,smoothing=True)\n", + "tracking_away.iloc[:,-5:].head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot a random frame, plotting the player velocities using quivers\n", + "mviz.plot_frame( tracking_home.loc[10000], tracking_away.loc[10000], include_player_velocities=True, annotate=True);" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create a Physical summary dataframe for home players\n", + "home_players = np.unique( [ c.split('_')[1] for c in tracking_home.columns if c[:4] == 'Home' ] )\n", + "home_summary = pd.DataFrame(index=home_players)\n", + "\n", + "# Calculate minutes played for each player\n", + "minutes = []\n", + "for player in home_players:\n", + " # search for first and last frames that we have a position observation for each player (when a player is not on the pitch positions are NaN)\n", + " column = 'Home_' + player + '_x' # use player x-position coordinate\n", + " player_minutes = ( tracking_home[column].last_valid_index() - tracking_home[column].first_valid_index() + 1 ) / 25 / 60. # convert to minutes\n", + " minutes.append( player_minutes )\n", + "home_summary['Minutes Played'] = minutes\n", + "home_summary = home_summary.sort_values(['Minutes Played'], ascending=False)\n", + "\n", + "# Calculate total distance covered for each player\n", + "distance = []\n", + "for player in home_summary.index:\n", + " column = 'Home_' + player + '_speed'\n", + " player_distance = tracking_home[column].sum()/25./1000 # this is the sum of the distance travelled from one observation to the next (1/25 = 40ms) in km.\n", + " distance.append( player_distance )\n", + "home_summary['Distance [km]'] = distance\n", + "\n", + "# make a simple bar chart of distance covered for each player\n", + "plt.subplots()\n", + "ax = home_summary['Distance [km]'].plot.bar(rot=0)\n", + "ax.set_xlabel('Player')\n", + "ax.set_ylabel('Distance covered [km]');" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot positions at KO (to find out what position each player is playing)\n", + "mviz.plot_frame( tracking_home.loc[51], tracking_away.loc[51], include_player_velocities=False, annotate=True);" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# now calculate distance covered while: walking, joggings, running, sprinting\n", + "walking = []\n", + "jogging = []\n", + "running = []\n", + "sprinting = []\n", + "for player in home_summary.index:\n", + " column = 'Home_' + player + '_speed'\n", + " # walking (less than 2 m/s)\n", + " player_distance = tracking_home.loc[tracking_home[column] < 2, column].sum()/25./1000\n", + " walking.append( player_distance )\n", + " # jogging (between 2 and 4 m/s)\n", + " player_distance = tracking_home.loc[ (tracking_home[column] >= 2) & (tracking_home[column] < 4), column].sum()/25./1000\n", + " jogging.append( player_distance )\n", + " # running (between 4 and 7 m/s)\n", + " player_distance = tracking_home.loc[ (tracking_home[column] >= 4) & (tracking_home[column] < 7), column].sum()/25./1000\n", + " running.append( player_distance )\n", + " # sprinting (greater than 7 m/s)\n", + " player_distance = tracking_home.loc[ tracking_home[column] >= 7, column].sum()/25./1000\n", + " sprinting.append( player_distance )\n", + " \n", + "home_summary['Walking [km]'] = walking\n", + "home_summary['Jogging [km]'] = jogging\n", + "home_summary['Running [km]'] = running\n", + "home_summary['Sprinting [km]'] = sprinting\n", + "\n", + "# make a clustered bar chart of distance covered for each player at each speed\n", + "ax = home_summary[['Walking [km]','Jogging [km]','Running [km]','Sprinting [km]']].plot.bar(colormap='coolwarm')\n", + "ax.set_xlabel('Player')\n", + "ax.set_ylabel('Distance covered [m]');" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# sustained sprints: how many sustained sprints per match did each player complete? Defined as maintaining a speed > 7 m/s for at least 1 second\n", + "nsprints = []\n", + "sprint_threshold = 7 # minimum speed to be defined as a sprint (m/s)\n", + "sprint_window = 1*25 # minimum duration sprint should be sustained (in this case, 1 second = 25 consecutive frames)\n", + "for player in home_summary.index:\n", + " column = 'Home_' + player + '_speed'\n", + " # trick here is to convolve speed with a window of size 'sprint_window', and find number of occassions that sprint was sustained for at least one window length\n", + " # diff helps us to identify when the window starts\n", + " player_sprints = np.diff( 1*( np.convolve( 1*(tracking_home[column]>=sprint_threshold), np.ones(sprint_window), mode='same' ) >= sprint_window ) )\n", + " nsprints.append( np.sum( player_sprints == 1 ) )\n", + "home_summary['# sprints'] = nsprints\n", + " \n", + "# Plot the trajectories for each of player 10's sprints\n", + "player = '10'\n", + "column = 'Home_' + player + '_speed' # spped\n", + "column_x = 'Home_' + player + '_x' # x position\n", + "column_y = 'Home_' + player + '_y' # y position\n", + "# same trick as before to find start and end indices of windows of size 'sprint_window' in which player speed was above the sprint_threshold\n", + "player_sprints = np.diff( 1*( np.convolve( 1*(tracking_home[column]>=sprint_threshold), np.ones(sprint_window), mode='same' ) >= sprint_window ) )\n", + "player_sprints_start = np.where( player_sprints == 1 )[0] - int(sprint_window/2) + 1 # adding sprint_window/2 because of the way that the convolution is centred\n", + "player_sprints_end = np.where( player_sprints == -1 )[0] + int(sprint_window/2) + 1\n", + "# now plot all the sprints\n", + "fig,ax = mviz.plot_pitch()\n", + "for s,e in zip(player_sprints_start,player_sprints_end):\n", + " ax.plot(tracking_home[column_x].iloc[s],tracking_home[column_y].iloc[s],'ro')\n", + " ax.plot(tracking_home[column_x].iloc[s:e+1],tracking_home[column_y].iloc[s:e+1],'r')" + ] + } + ], + "metadata": { + "hide_input": false, + "kernelspec": { + "display_name": "Python [conda env:friends-of-tracking-data-youtube]", + "language": "python", + "name": "conda-env-friends-of-tracking-data-youtube-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Lesson6.ipynb b/notebooks/Lesson6.ipynb new file mode 100644 index 0000000..3ad66ff --- /dev/null +++ b/notebooks/Lesson6.ipynb @@ -0,0 +1,469 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install git+https://github.com/seidlr/LaurieOnTracking.git" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lesson 6 - Pitch Control\n", + "Created on Mon Apr 13 11:34:26 2020 \n", + "Script for lesson 6 of \"Friends of Tracking\" `#FoT`. \n", + "Data can be found at: https://github.com/metrica-sports/sample-data \n", + "Accompanying video tutorials can be found here: https://www.youtube.com/watch?v=5X1cSehLg6s \n", + "GitHub repo: https://github.com/Friends-of-Tracking-Data-FoTD/LaurieOnTracking \n", + "Author: Laurie Shaw (@EightyFivePoint) " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import friendsoftracking.metrica.IO as mio\n", + "import friendsoftracking.metrica.Viz as mviz\n", + "import friendsoftracking.metrica.Velocities as mvel\n", + "import friendsoftracking.metrica.PitchControl as mpc" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading team: home\n", + "Reading team: away\n" + ] + } + ], + "source": [ + "game_id = 2 # let's look at sample match 2\n", + "\n", + "# read in the event data\n", + "events = mio.read_event_data(game_id)\n", + "\n", + "# read in tracking data\n", + "tracking_home = mio.read_tracking_data(game_id, 'Home')\n", + "tracking_away = mio.read_tracking_data(game_id, 'Away')\n", + "\n", + "# Convert positions from metrica units to meters (note change in Metrica's coordinate system since the last lesson)\n", + "tracking_home = mio.to_metric_coordinates(tracking_home)\n", + "tracking_away = mio.to_metric_coordinates(tracking_away)\n", + "events = mio.to_metric_coordinates(events)\n", + "\n", + "# reverse direction of play in the second half so that home team is always attacking from right->left\n", + "tracking_home,tracking_away,events = mio.to_single_playing_direction(tracking_home,tracking_away,events)\n", + "\n", + "# Calculate player velocities\n", + "tracking_home = mvel.calc_player_velocities(tracking_home,smoothing=True)\n", + "tracking_away = mvel.calc_player_velocities(tracking_away,smoothing=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TeamTypeSubtypePeriodStart FrameStart Time [s]End FrameEnd Time [s]FromToStart XStart YEnd XEnd Y
198HomeSHOTON TARGET-GOAL112202488.0812212488.48Player10NaN-47.70-3.40-54.06-2.04
823AwaySHOTON TARGET-GOAL1530492121.96530752123.00Player24NaN44.522.7254.061.36
1118HomeSHOTHEAD-ON TARGET-GOAL2739832959.32739952959.80Player9NaN-47.701.36-54.062.04
1671AwaySHOTON TARGET-GOAL21150094600.361150244600.96Player20NaN40.281.3655.122.72
1723HomeSHOTON TARGET-GOAL21210274841.081210554842.20Player12NaN-30.745.44-54.062.72
\n", + "
" + ], + "text/plain": [ + " Team Type Subtype Period Start Frame Start Time [s] \\\n", + "198 Home SHOT ON TARGET-GOAL 1 12202 488.08 \n", + "823 Away SHOT ON TARGET-GOAL 1 53049 2121.96 \n", + "1118 Home SHOT HEAD-ON TARGET-GOAL 2 73983 2959.32 \n", + "1671 Away SHOT ON TARGET-GOAL 2 115009 4600.36 \n", + "1723 Home SHOT ON TARGET-GOAL 2 121027 4841.08 \n", + "\n", + " End Frame End Time [s] From To Start X Start Y End X End Y \n", + "198 12212 488.48 Player10 NaN -47.70 -3.40 -54.06 -2.04 \n", + "823 53075 2123.00 Player24 NaN 44.52 2.72 54.06 1.36 \n", + "1118 73995 2959.80 Player9 NaN -47.70 1.36 -54.06 2.04 \n", + "1671 115024 4600.96 Player20 NaN 40.28 1.36 55.12 2.72 \n", + "1723 121055 4842.20 Player12 NaN -30.74 5.44 -54.06 2.72 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\" **** pitch control for passes leading up to goal 2 **** \"\"\"\n", + "\n", + "# get all shots and goals in the match\n", + "shots = events[events['Type']=='SHOT']\n", + "goals = shots[shots['Subtype'].str.contains('-GOAL')].copy()\n", + "\n", + "goals" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the 3 events leading up to the second goal\n", + "mviz.plot_events( events.loc[820:823], color='k', indicators = ['Marker','Arrow'], annotate=True );" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# first get model parameters\n", + "params = mpc.default_model_params(3)\n", + "\n", + "# evaluated pitch control surface for first pass\n", + "PPCF,xgrid,ygrid = mpc.generate_pitch_control_for_event(820, events, tracking_home, tracking_away, params, field_dimen = (106.,68.,), n_grid_cells_x = 50)\n", + "mviz.plot_pitchcontrol_for_event( 820, events, tracking_home, tracking_away, PPCF, xgrid, ygrid, annotate=True )\n", + "# evaluated pitch control surface for second pass\n", + "PPCF,xgrid,ygrid = mpc.generate_pitch_control_for_event(821, events, tracking_home, tracking_away, params, field_dimen = (106.,68.,), n_grid_cells_x = 50)\n", + "mviz.plot_pitchcontrol_for_event( 821, events, tracking_home, tracking_away, PPCF, xgrid, ygrid, annotate=True )\n", + "# evaluated pitch control surface for third pass\n", + "PPCF,xgrid,ygrid = mpc.generate_pitch_control_for_event(822, events, tracking_home, tracking_away, params, field_dimen = (106.,68.,), n_grid_cells_x = 50)\n", + "mviz.plot_pitchcontrol_for_event( 822, events, tracking_home, tracking_away, PPCF, xgrid, ygrid, annotate=True );" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\" **** calculate pass probability for every home team succesful pass **** \"\"\"\n", + "# get all home passes\n", + "home_passes = events[ (events['Type'].isin(['PASS'])) & (events['Team']=='Home') ]\n", + "\n", + "# list for storing pass probablities\n", + "pass_success_probability = []\n", + "\n", + "for i,row in home_passes.iterrows():\n", + " pass_start_pos = np.array([row['Start X'],row['Start Y']])\n", + " pass_target_pos = np.array([row['End X'],row['End Y']])\n", + " pass_frame = row['Start Frame']\n", + " \n", + " attacking_players = mpc.initialise_players(tracking_home.loc[pass_frame],'Home',params)\n", + " defending_players = mpc.initialise_players(tracking_away.loc[pass_frame],'Away',params)\n", + " Patt,Pdef = mpc.calculate_pitch_control_at_target(pass_target_pos, attacking_players, defending_players, pass_start_pos, params)\n", + "\n", + " pass_success_probability.append( (i,Patt) )\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Frequency')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEGCAYAAACKB4k+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAYq0lEQVR4nO3de9RddX3n8fdHQC7CCEhgYgCDGEWwEjEyzqgVLxVklkbaWmMdi441WrHVGZcjMF2K7coqrnppq4MaFEG8YBQFVLwAFakXiEHDJVzGjCCEZJGIFy5SMOE7f+z9bI4PT5KT5Dnn5Mnzfq111tn7d/be5/vLk3U+Z1/Ob6eqkCQJ4FGjLkCStP0wFCRJHUNBktQxFCRJHUNBktTZedQFbIv99tuvZs+ePeoyJGlKufrqq39RVTMmem1Kh8Ls2bNZtmzZqMuQpCklyc839pqHjyRJHUNBktQZWCgk2S3J0iTXJFmR5L1t+2lJ7kiyvH0c37POKUlWJrk5ybGDqk2SNLFBnlN4AHhhVd2bZBfge0m+0b72oap6f+/CSQ4HFgBHAI8HLk3y5KraMMAaJUk9BranUI1729ld2semBlqaD5xXVQ9U1S3ASuDoQdUnSXqkgZ5TSLJTkuXAWuCSqrqqfemtSa5NclaSfdq2WcDtPauvatvGb3NhkmVJlq1bt26Q5UvStDPQUKiqDVU1FzgQODrJ04CPAocCc4E1wAfaxTPRJibY5uKqmldV82bMmPAyW0nSVhrK1UdV9WvgcuC4qrqzDYuHgDN5+BDRKuCgntUOBFYPoz5JUmOQVx/NSLJ3O7078GLgpiQzexY7Abi+nb4IWJBk1ySHAHOApYOqT5L0SIO8+mgmcE6SnWjCZ0lVfS3JuUnm0hwauhV4E0BVrUiyBLgBWA+c5JVHkrZns0/++sje+9bT/+tAtjuwUKiqa4FnTND+2k2sswhYNKiaJEmb5i+aJUkdQ0GS1DEUJEkdQ0GS1DEUJEkdQ0GS1DEUJEkdQ0GS1DEUJEkdQ0GS1DEUJEkdQ0GS1DEUJEkdQ0GS1DEUJEkdQ0GS1DEUJEkdQ0GS1DEUJEkdQ0GS1DEUJEmdgYVCkt2SLE1yTZIVSd7btu+b5JIkP22f9+lZ55QkK5PcnOTYQdUmSZrYIPcUHgBeWFVHAnOB45I8GzgZuKyq5gCXtfMkORxYABwBHAeckWSnAdYnSRpnYKFQjXvb2V3aRwHzgXPa9nOAV7TT84HzquqBqroFWAkcPaj6JEmPNNBzCkl2SrIcWAtcUlVXAQdU1RqA9nn/dvFZwO09q69q28Zvc2GSZUmWrVu3bpDlS9K0M9BQqKoNVTUXOBA4OsnTNrF4JtrEBNtcXFXzqmrejBkzJqtUSRJDuvqoqn4NXE5zruDOJDMB2ue17WKrgIN6VjsQWD2M+iRJjUFefTQjyd7t9O7Ai4GbgIuAE9vFTgQubKcvAhYk2TXJIcAcYOmg6pMkPdLOA9z2TOCc9gqiRwFLquprSX4ILEnyBuA24JUAVbUiyRLgBmA9cFJVbRhgfZKkcQYWClV1LfCMCdrvAl60kXUWAYsGVZMkadP8RbMkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqTOwUEhyUJLvJLkxyYokb2vbT0tyR5Ll7eP4nnVOSbIyyc1Jjh1UbZKkie08wG2vB95RVT9OshdwdZJL2tc+VFXv7104yeHAAuAI4PHApUmeXFUbBlijJKnHwPYUqmpNVf24nb4HuBGYtYlV5gPnVdUDVXULsBI4elD1SZIeaSjnFJLMBp4BXNU2vTXJtUnOSrJP2zYLuL1ntVVMECJJFiZZlmTZunXrBli1JE0/Aw+FJHsC5wNvr6q7gY8ChwJzgTXAB8YWnWD1ekRD1eKqmldV82bMmDGgqiVpehpoKCTZhSYQPltVXwaoqjurakNVPQScycOHiFYBB/WsfiCwepD1SZJ+3yCvPgrwSeDGqvpgT/vMnsVOAK5vpy8CFiTZNckhwBxg6aDqkyQ90iCvPnoO8FrguiTL27ZTgVcnmUtzaOhW4E0AVbUiyRLgBporl07yyiNJGq6BhUJVfY+JzxNcvIl1FgGLBlWTJGnT/EWzJKljKEiSOoaCJKljKEiSOoaCJKljKEiSOoaCJKljKEiSOoaCJKljKEiSOoaCJKljKEiSOoaCJKnTVygkedqgC5EkjV6/ewofS7I0yVuS7D3QiiRJI9NXKFTVc4HX0Nwuc1mSzyX5o4FWJkkaur7PKVTVT4G/Bd4FPB/4lyQ3JfnjQRUnSRqufs8pPD3Jh4AbgRcCL6uqp7bTHxpgfZKkIer3dpwfAc4ETq2q+8caq2p1kr8dSGWSpKHrNxSOB+6vqg0ASR4F7FZVv62qcwdWnSRpqPo9p3ApsHvP/B5tmyRpB9JvKOxWVfeOzbTTe2xqhSQHJflOkhuTrEjytrZ93ySXJPlp+7xPzzqnJFmZ5OYkx25NhyRJW6/fULgvyVFjM0meCdy/ieUB1gPvaE9IPxs4KcnhwMnAZVU1B7isnad9bQFwBHAccEaSnbakM5KkbdPvOYW3A19Msrqdnwm8alMrVNUaYE07fU+SG4FZwHzgmHaxc4DLaS5znQ+cV1UPALckWQkcDfyw385IkrZNX6FQVT9KchjwFCDATVX1u37fJMls4BnAVcABbWBQVWuS7N8uNgu4sme1VW3b+G0tBBYCHHzwwf2WIEnqQ797CgDPAma36zwjCVX16c2tlGRP4Hzg7VV1d5KNLjpBWz2ioWoxsBhg3rx5j3hdkrT1+gqFJOcChwLLgQ1tcwGbDIUku9AEwmer6stt851JZrZ7CTOBtW37KpphNMYcCKxGkjQ0/e4pzAMOr6q+v5mn2SX4JHBjVX2w56WLgBOB09vnC3vaP5fkg8DjgTnA0n7fT5K07foNheuB/0h74rhPzwFeC1yXZHnbdipNGCxJ8gbgNuCVAFW1IskS4AaaK5dOGvuxnCRpOPoNhf2AG5IsBR4Ya6yql29shar6HhOfJwB40UbWWQQs6rMmSdIk6zcUThtkEZKk7UO/l6R+N8kTgDlVdWmSPQB/WCZJO5h+h85+I/Al4ONt0yzggkEVJUkajX6HuTiJ5sTx3dDdcGf/Ta4hSZpy+g2FB6rqwbGZJDszwQ/LJElTW7+h8N0kpwK7t/dm/iLw1cGVJUkahX5D4WRgHXAd8CbgYpr7NUuSdiD9Xn30EM3tOM8cbDmSpFHqd+yjW5h4cLonTnpFkqSR2ZKxj8bsRjM0xb6TX44kaZT6OqdQVXf1PO6oqn8CXjjg2iRJQ9bv4aOjemYfRbPnsNdAKpIkjUy/h48+0DO9HrgV+LNJr0aSNFL9Xn30gkEXIkkavX4PH/3PTb0+7iY6kqQpakuuPnoWzd3RAF4GXAHcPoiiJEmjsSU32Tmqqu4BSHIa8MWq+stBFSZJGr5+h7k4GHiwZ/5BYPakVyNJGql+9xTOBZYm+QrNL5tPAD49sKokSSPR79VHi5J8A3he2/T6qvrJ4MqSJI1Cv4ePAPYA7q6qfwZWJTlkQDVJkkak39txvgd4F3BK27QL8JnNrHNWkrVJru9pOy3JHUmWt4/je147JcnKJDcnOXbLuyJJ2lb97imcALwcuA+gqlaz+WEuzgaOm6D9Q1U1t31cDJDkcGABcES7zhlJduqzNknSJOk3FB6sqqIdPjvJYza3QlVdAfyyz+3PB86rqgeq6hZgJXB0n+tKkiZJv6GwJMnHgb2TvBG4lK2/4c5bk1zbHl7ap22bxe//EG5V2yZJGqLNhkKSAF8AvgScDzwFeHdVfXgr3u+jwKHAXGANDw+0lwmWfcRNfdp6FiZZlmTZunXrtqIESdLGbPaS1KqqJBdU1TOBS7blzarqzrHpJGcCX2tnVwEH9Sx6ILB6I9tYDCwGmDdv3oTBIUnaOv0eProyybO29c2SzOyZPQEYuzLpImBBkl3bS13nAEu39f0kSVum3180vwB4c5Jbaa5ACs1OxNM3tkKSzwPHAPslWQW8BzgmyVyaQ0O3Am+i2dCKJEuAG2ju13BSVW3Ymg5JkrbeJkMhycFVdRvw0i3dcFW9eoLmT25i+UXAoi19H0nS5NncnsIFNKOj/jzJ+VX1J8MoSpI0Gps7p9B7VdATB1mIJGn0NhcKtZFpSdIOaHOHj45McjfNHsPu7TQ8fKL5Pwy0OknSUG0yFKrK8YckaRrZkqGzJUk7OENBktQxFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktQZWCgkOSvJ2iTX97Ttm+SSJD9tn/fpee2UJCuT3Jzk2EHVJUnauEHuKZwNHDeu7WTgsqqaA1zWzpPkcGABcES7zhlJvOubJA3ZwEKhqq4AfjmueT5wTjt9DvCKnvbzquqBqroFWAkcPajaJEkTG/Y5hQOqag1A+7x/2z4LuL1nuVVtmyRpiLaXE82ZoK0mXDBZmGRZkmXr1q0bcFmSNL0MOxTuTDIToH1e27avAg7qWe5AYPVEG6iqxVU1r6rmzZgxY6DFStJ0M+xQuAg4sZ0+Ebiwp31Bkl2THALMAZYOuTZJmvZ2HtSGk3weOAbYL8kq4D3A6cCSJG8AbgNeCVBVK5IsAW4A1gMnVdWGQdUmSZrYwEKhql69kZdetJHlFwGLBlWPJGnztpcTzZKk7YChIEnqGAqSpI6hIEnqGAqSpI6hIEnqGAqSpI6hIEnqDOzHa5I0LLNP/vqoS9hhuKcgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeqMZJTUJLcC9wAbgPVVNS/JvsAXgNnArcCfVdWvRlGfJE1Xo9xTeEFVza2qee38ycBlVTUHuKydlyQN0fZ0+Gg+cE47fQ7wihHWIknT0qhCoYBvJ7k6ycK27YCqWgPQPu8/0YpJFiZZlmTZunXrhlSuJE0Po7rz2nOqanWS/YFLktzU74pVtRhYDDBv3rwaVIGSNB2NJBSqanX7vDbJV4CjgTuTzKyqNUlmAmtHUZukredtMae+oR8+SvKYJHuNTQMvAa4HLgJObBc7Ebhw2LVJ0nQ3ij2FA4CvJBl7/89V1TeT/AhYkuQNwG3AK0dQmyRNa0MPhar6GXDkBO13AS8adj2SpIdtT5ekSpJGbFRXH0kaEE/2alu4pyBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOw1xIA+JwE5qK3FOQJHUMBUlSx1CQJHUMBUlSxxPN2qF5slfaMu4pSJI6hoIkqWMoSJI62905hSTHAf8M7AR8oqpOH3FJmgQe25emhu1qTyHJTsD/AV4KHA68Osnho61KkqaP7W1P4WhgZVX9DCDJecB84IaRVrWD8Nu6pM3Z3kJhFnB7z/wq4D/1LpBkIbCwnb03yc3b8H77Ab/YhvWnmunWX7DP08W063Pet019fsLGXtjeQiETtNXvzVQtBhZPypsly6pq3mRsayqYbv0F+zxd2OfJs12dU6DZMzioZ/5AYPWIapGkaWd7C4UfAXOSHJLk0cAC4KIR1yRJ08Z2dfioqtYneSvwLZpLUs+qqhUDfMtJOQw1hUy3/oJ9ni7s8yRJVW1+KUnStLC9HT6SJI2QoSBJ6uzwoZDkuCQ3J1mZ5OQJXk+Sf2lfvzbJUaOoczL10efXtH29NskPkhw5ijon0+b63LPcs5JsSPKnw6xvEPrpc5JjkixPsiLJd4dd42Tr4//2Y5N8Nck1bZ9fP4o6J0uSs5KsTXL9Rl6f/M+vqtphHzQnq/8f8ETg0cA1wOHjljke+AbNbySeDVw16rqH0Of/AuzTTr90OvS5Z7l/BS4G/nTUdQ/h77w3zWgAB7fz+4+67iH0+VTgfe30DOCXwKNHXfs29PkPgaOA6zfy+qR/fu3oewrdsBlV9SAwNmxGr/nAp6txJbB3kpnDLnQSbbbPVfWDqvpVO3slze9BprJ+/s4Afw2cD6wdZnED0k+f/xz4clXdBlBVU73f/fS5gL2SBNiTJhTWD7fMyVNVV9D0YWMm/fNrRw+FiYbNmLUVy0wlW9qfN9B805jKNtvnJLOAE4CPDbGuQern7/xkYJ8klye5OslfDK26weinzx8Bnkrzo9frgLdV1UPDKW8kJv3za7v6ncIAbHbYjD6XmUr67k+SF9CEwnMHWtHg9dPnfwLeVVUbmi+RU14/fd4ZeCbwImB34IdJrqyq/zvo4gaknz4fCywHXggcClyS5N+q6u5BFzcik/75taOHQj/DZuxoQ2v01Z8kTwc+Aby0qu4aUm2D0k+f5wHntYGwH3B8kvVVdcFwSpx0/f7f/kVV3Qfcl+QK4EhgqoZCP31+PXB6NQfcVya5BTgMWDqcEodu0j+/dvTDR/0Mm3ER8BftWfxnA7+pqjXDLnQSbbbPSQ4Gvgy8dgp/a+y12T5X1SFVNbuqZgNfAt4yhQMB+vu/fSHwvCQ7J9mDZsThG4dc52Tqp8+30ewZkeQA4CnAz4Za5XBN+ufXDr2nUBsZNiPJm9vXP0ZzJcrxwErgtzTfNKasPvv8buBxwBntN+f1NYVHmOyzzzuUfvpcVTcm+SZwLfAQzZ0MJ7y0cSro8+/898DZSa6jObTyrqqaskNqJ/k8cAywX5JVwHuAXWBwn18OcyFJ6uzoh48kSVvAUJAkdQwFSVLHUJAkdQwFSVLHUNDQtKOTLk9yfZIvttfOayskeV2Sj2zhOvdupP3vkry4nb48ybx2+uIke7ePt2x71ZoKDAUN0/1VNbeqngY8CLx51AVtz5LsNIz3qap3V9WlE7QfX1W/phlt1VCYJgwFjcq/AU9K8rIkVyX5SZJL21+hkuT57V7F8va1vZLMTHJFz97G88ZvNMnpSW5ox5Z/f9t2du/9E3q/MSf5X0mua8ffP71te1JbyzVJfpzk0Lb9nUl+1G77vW3bY5J8vV32+iSv2lgd4+o8Lcm5Sf41yU+TvLFtPybJd5J8DrguyW5JPtXW+JN2vKoxByX5Zpr7C7ynZ9sXpBkAb0WShePe9wNtny5LMmOif5+eZW9Nsh9wOnBo++/+j23d83uW+2ySl2/0L62pZdTjhfuYPg/g3vZ5Z5ohGP4K2IeHf0T5l8AH2umvAs9pp/ds13kH8L/btp2AvcZtf1/g5p7t7d0+n03P/RN66ngp8ANgj7H12+ergBPa6d2APYCX0NwoPTRfpr5GM9b9nwBn9mz7sRurY1ytp9HcD2B3mrGYbgceT/Pr1fuAQ9rl3gF8qp0+jGYYh92A1wFraH6ZvjtwPTBvXD/G2h/Xzhfwmnb63cBHxv/7AJf3bOfWtrbZ9IznDzwfuKCnv7cAO4/6/5ePyXm4p6Bh2j3JcmAZzYfbJ2kG8PpWOyzBO4Ej2mW/D3wwyd/QfKiupxn75vVJTgP+oKruGbf9u4F/Bz6R5I9pfva/KS+m+cD9LUBV/TLJXsCsqvpK2/bv7esvaR8/AX5M8wE9h2Z45hcneV+S51XVb7agjgur6v5qhmH4Ds39AgCWVtUt7fRzgXPbWm4Cfk4zJDbAJVV1V1XdTzOW1dhot3+T5Bqae2Uc1NYJzVAXX2inP8NWjo5bVd+l2cvbH3g1cH7799EOwFDQMI2dU5hbVX9dzY1SPkzzjfUPgDfRfAumqk6n2XPYHbgyyWHV3HDkD4E7gHMz7v4A7QfT0TQ30nkF8M32pfW0/9fTDPb06LY99DeU+lj7P/TU/6Sq+mQ1Awo+kyYc/iHJuzdRx3jj33ts/r4+6plw/STH0ITdf66qI2lCbLc+198S5wKvoRlr51PbsB1tZwwFjdpjaT7kAU4ca0xyaFVdV1Xvo9mzOCzJE4C1VXUmzV7G792PNsmewGOr6mLg7cDc9qVbaT64oblT1S7t9LeB/z52FVSSfasZd39Vkle0bbu2r3+rXXbPtn1Wkv2TPB74bVV9Bng/cNQm6hhvfnvO4HE0h41+NMEyV9B8+JLkycDBNIemAP4oyb5JdqcJn++3/56/qqrfJjmM5haNYx4FjJ07+HPgexupa7x7gL3GtZ3d9o2qWtHndjQF7NCjpGpKOA34YpI7aA53HNK2v709qbqB5j7D36AZKvmdSX4H3AuMv5PYXsCFSXaj+Yb9P9r2M9v2pcBltN/Eq+qbSeYCy5I8SDPi5KnAa4GPJ/k74HfAK6vq20meSnOjGtr3/2/Ak4B/TPJQu+xfbaKO8ZYCX6f5oP/7qlrdfvD3OgP4WHt4bT3wuqp6oK3hezTf2J8EfK6qlrXLvTnJtTThcWXPtu4DjkhyNfAb4FUbqev3VNVdSb6f5ubx36iqd1bVnUluBKby8OOagKOkSiPQnhe5t6oecWXSVNDuPV0HHNWeR9EOwsNHkrZImh+63QR82EDY8binIEnquKcgSeoYCpKkjqEgSeoYCpKkjqEgSer8f5eOB+2m+MUcAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax = plt.subplots()\n", + "ax.hist( [p[1] for p in pass_success_probability], np.arange(0,1.1,0.1)) \n", + "ax.set_xlabel('Pass success probability')\n", + "ax.set_ylabel('Frequency') " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Event following a risky (completed) pass\n", + "0.26455950351294005 CHALLENGE\n", + "0.28505234723760897 BALL LOST\n", + "0.3006628396711591 SHOT\n", + "0.31160841865474626 CHALLENGE\n", + "0.33704347298090714 CHALLENGE\n", + "0.3913125864694877 SHOT\n", + "0.4188148605128081 BALL LOST\n", + "0.4194468674048554 CHALLENGE\n", + "0.4204267746341931 PASS\n", + "0.4312712628523871 CHALLENGE\n", + "0.44436475742157466 CHALLENGE\n", + "0.44844895551994096 PASS\n", + "0.4593665151483775 CHALLENGE\n", + "0.4635633533167435 SHOT\n", + "0.468048170879984 CHALLENGE\n", + "0.4897275563912591 CHALLENGE\n", + "0.4900872646495704 CHALLENGE\n", + "0.4927699899300238 SHOT\n", + "0.5001349056944236 PASS\n", + "0.5026909720011078 PASS\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# sort the passes by pitch control probability\n", + "pass_success_probability = sorted( pass_success_probability, key = lambda x: x[1] )\n", + "\n", + "# identify the events corresponding to the most risky passes (pitch control < 0.5)\n", + "risky_passes = events.loc[ [p[0] for p in pass_success_probability if p[1]<0.5 ] ]\n", + "\n", + "# plot the events\n", + "mviz.plot_events( risky_passes, color='k', indicators = ['Marker','Arrow'], annotate=True )\n", + "\n", + "# Print events that followed those risky passes\n", + "print(\"Event following a risky (completed) pass\")\n", + "for p in pass_success_probability[:20]:\n", + " outcome = events.loc[ p[0]+1 ].Type\n", + " print( p[1], outcome )" + ] + } + ], + "metadata": { + "hide_input": false, + "kernelspec": { + "display_name": "Python [conda env:friends-of-tracking-data-youtube]", + "language": "python", + "name": "conda-env-friends-of-tracking-data-youtube-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..9bf25c4 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,5 @@ +numpy==1.18.1 +matplotlib==3.2.1 +pandas==1.0.3 +requests==2.23.0 +scipy==1.4.1 \ No newline at end of file diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..7df2beb --- /dev/null +++ b/setup.py @@ -0,0 +1,9 @@ +from setuptools import setup, find_packages + +setup( + name='FriendsOfTracking', + version='0.1dev', + packages=find_packages(), + license='Creative Commons Attribution-Noncommercial-Share Alike license', + long_description=open('README.md').read(), +) \ No newline at end of file