First, let’s discuss what a potential assist actually is. A potential assist is a pass that leads directly to a shot, foul or turnover. If you watch basketball, you’ve probably noticed that the number of assists a player gets is largely dependent on how good his teammates are shooting that night. Let’s put it this way, consider two scenarios: In scenario one, player 1 makes three passes to player 2, and all three times player 2 shoots and makes a three pointer. That goes for both three potential assists and three assists for player 1. Each potential assist was actually realized as an actual assist, because player 2 made all his three 3-point attempts on passes from player 1. Now let’s consider scenario 2 – player 1 passes ten times to player 2, and player 2 shoots ten threes, making only two. This counts for TEN potential assists for player 1, while only two actual assists.

Now comes the important question, which scenario do you prefer? The answer is, it’s complicated, but in the long run, scenario 2 is definitely preferable to scenario 1. No one in the history of basketball is a 100% three point shooter, so we can’t expect 3 potential assists to translate to 3 assists too often. On the contrary, most NBA players don’t shoot 20% from the field, so we can’t expect 10 potential assists to translate to 2 assists often – usually more like 3 or 4 assists. This is why just knowing the number of assists a player had in a game is a misleading statistic. By using potential assists as a feature, you can take into account how repeatable his previous assist totals are going forward.

With that being said, let’s dig into the code. You’ll need the NBA API for this, and if you don’t have in installed yet, you can check out our previous blog post on working with the NBA API.

import pandas as pd
from nba_api.stats.endpoints import leaguedashptstats

Below we’ve created an easy to use function for you to scrape potential assists in addition to two other useful columns, passes made and passes received. The function itself takes in season, season_type, and game_date as arguments, and returns the three aformentioned features for all the players that played on that game date.

The parameters that the leaguedashptstats endpoint takes in as arguments are predefined, so just copy and paste the function exactly as is below.

def get_passing_stats(season, season_type, game_date):

    player_dash_info = leaguedashptstats.LeagueDashPtStats(
        last_n_games = 0,
        pt_measure_type = "Passing",
        player_or_team = "Player",
        per_mode_simple = "PerGame",
        season = season,
        season_type_all_star = season_type,
        team_id_nullable = 0,
        opponent_team_id = 0,
        date_from_nullable = game_date,
        date_to_nullable = game_date
    )

    player_logs = player_dash_info.get_data_frames()[0]
    player_logs["GAME_DATE"] = game_date
    
    player_logs["GAME_DATE"] = pd.to_datetime(player_logs["GAME_DATE"])
    
    return player_logs

And there you have it! Below is a dataframe the tells you how many passes made, passes received, and potential assists a player had for any particular game date. 

The post Scraping Potential Assists appeared first on AI Betting Edge.

First, as always (most of the time), we import pandas. That’s surprisingly the only package we’ll need for this blog post.

import pandas as pd

Next, let’s define the features we want to compute season averages for. For simplicity, we chose the basic box score stats.

stats = ['PTS','REB','AST','TOV','3PM','STL','BLK']

Now let’s dig into the logic. There are a few relatively straightforward preprocessing steps that need to be performed before computing the season average. But before digging into the code, let’s talk a little about what we DON’T want to do. Imagine the NBA season is 5 games long. Monday, Tuesday, Wednesday, Thursday and Friday. LeBron James scored 20, 25, 30, 35 and 40 points on those 5 days. We pass in all 5 games as part of our training data (the data the algorithm learns from), and the only feature we use is his season average for points. What is his season average? You may quickly think, oh it’s just (20+25+30+35+40)/5 = 30 points. But is his season average really 30 points for all of those 5 game dates? To the algorithm, when it’s predicting Wednesday, the games on Thursday and Friday have not happened yet. So really for Monday, there is no average, because there’s no “yesterday”. For Tuesday, his average is 20 (Monday’s total). For Wednesday, it’s 22.5 (taken by averaging Monday and Tuesday’s outcomes) and so on and so forth.

With that being said, let’s dig into the code. We first need to convert the “GAME_DATE” collumn to a pandas datetime object. Next, we need to sort based on three columns, first by “SEASON_ID”, second by “PLAYER_ID”, and third by “GAME_DATE”. The logic behind this is straightforward: We want each player’s per season stats, sorted in ascending order by game date (to prevent data leakage as mentioned above).

After the sorting is done, we do a groupby on “SEASON_ID”, “PLAYER_ID”, and “TEAM_ID” to ensure that if a player gets traded midseason, we’re counting his stats only with the current team he’s on (as per the game date in the row). We apply a lambda function to the stats columns we defined above, and shift everything by 1 day to make sure that we’re not accidentally counting the player’s stats from that day towards his averages for predicting that day (again a data leakage problem). For each unique SEASON_ID, PLAYER_ID, GAME_DATE group, the first row should be null. That’s because of the shift(1) we performed above.

# full_df is a dataframe with the player stats on each game_date

full_df["GAME_DATE"] = pd.to_datetime(full_df["GAME_DATE"])
full_df.sort_values(by=["SEASON_ID", "PLAYER_ID","GAME_DATE"], inplace=True)
full_df.reset_index(inplace=True,drop=False)

moving_average_dataframe = full_df.groupby(["SEASON_ID", "PLAYER_ID","TEAM_ID"])[stats].apply(lambda x: x.expanding().mean().shift(1)).reset_index(drop=True)
moving_average_dataframe.columns = "1_day_lag_season_average"+moving_average_dataframe.columns
full_df = full_df.join(moving_average_dataframe)

full_df.drop(columns=['index'],inplace=True)

The post Calculating Season Averages for NBA Betting Features appeared first on AI Betting Edge.