Scikit-Learn-tutorial: Baseball-analytics, deel 1

Data importeren

Je leest de data in door een sqlite-database te bevragen met het pakket sqlite3 en zet die met pandas om naar een DataFrame. Je data wordt gefilterd op alleen momenteel actieve, moderne teams en alleen jaren waarin het team 150 of meer wedstrijden speelde.

Download eerst het bestand “lahman2016.sqlite” (hier). Laad daarna Pandas en hernoem dit naar pd voor het gemak. Je herinnert je misschien dat pd de gangbare alias is voor Pandas. Laad tot slot sqlite3 en maak verbinding met de database, zoals dit:

# import `pandas` and `sqlite3`import pandas as pdimport sqlite3# Connecting to SQLite Databaseconn = sqlite3.connect('lahman2016.sqlite')Mogelijk gemaakt door

Vervolgens schrijf je een query, voer je die uit en haal je de resultaten op.

# Querying Database for all seasons where a team played 150 or more games and is still active today. query = '''select * from Teams inner join TeamsFranchiseson Teams.franchID == TeamsFranchises.franchIDwhere Teams.G >= 150 and TeamsFranchises.active == 'Y';'''# Creating dataframe from query.Teams = conn.execute(query).fetchall()Mogelijk gemaakt door

Tip: Wil je meer leren over het gebruik van SQL met Python, overweeg dan DataCamp’s cursus Introduction to Databases in Python.

Met pandas zet je de resultaten vervolgens om naar een DataFrame en print je de eerste 5 rijen met de head()-methode:

# Convert `Teams` to DataFrame
teams_df = pd.DataFrame(_____)

# Print out first 5 rows
print(_______________)

Elke kolom bevat data over een specifiek team en jaar. Enkele van de belangrijkere variabelen staan hieronder. Een volledige lijst vind je hier.

• yearID - Jaar
• teamID - Team
• franchID - Franchise (linkt naar de tabel TeamsFranchise)
• G - Gespeelde wedstrijden
• W - Overwinningen
• LgWin - League-kampioen (Y of N)
• WSWin - World Series-winnaar (Y of N)
• R - Gemaakte runs
• AB - Slagbeurten (at bats)
• H - Hits door slagmensen
• HR - Homeruns door slagmensen
• BB - Vier wijd door slagmensen
• SO - Drie slag door slagmensen
• SB - Gestolen honken
• CS - Uitgegleden bij stelen (caught stealing)
• HBP - Raak gegooid (hit by pitch)
• SF - Sacrifice flies
• RA - Tegenstanders: gescoorde runs
• ER - Earned runs tegen
• ERA - Earned run average
• CG - Complete games
• SHO - Shutouts
• SV - Saves
• IPOuts - Outs gegooid (innings pitched x 3)
• HA - Toegestane hits
• HRA - Toegestane homeruns
• BBA - Toegestane vier wijd
• SOA - Drie slag door pitchers
• E - Fouten
• DP - Dubbelspelen
• FP - Fielding-percentage
• name - Volledige teamnaam

Voor wie minder bekend is met honkbal volgt hier kort hoe het spel werkt, met enkele variabelen erbij.

Honkbal wordt gespeeld tussen twee teams (in de data terug te vinden als name of teamID) van elk negen spelers. De teams wisselen af tussen slaan en fielden. Het slagteam probeert runs te scoren door om beurten een door de pitcher van het fieldende team geworpen bal te slaan, en vervolgens tegen de klok in langs vier honken te rennen: eerste, tweede, derde en thuisplaat. Het fieldende team probeert runs te voorkomen door slagmensen of honklopers op verschillende manieren uit te maken; een run (R) wordt gescoord wanneer een speler alle honken passeert en terugkeert bij thuisplaat. Een speler van het slagteam die veilig een honk bereikt, probeert tijdens de beurten van teamgenoten verder op te schuiven, bijvoorbeeld op een hit (H), gestolen honk (SB) of op andere manieren.

De teams wisselen van slag- en veldbeurt zodra het fieldende team drie nullen heeft gemaakt. Eén slagbeurt voor beide teams, te beginnen met het uitspelende team, vormt een inning. Een wedstrijd bestaat uit negen innings, en het team met de meeste runs aan het einde wint. Er is geen spelklok; meestal eindigen wedstrijden in de negende inning, maar bij een gelijke stand na negen innings volgen extra innings en gaat het door totdat een team na een extra inning vóór staat.

Voor een uitgebreide uitleg van honkbal, bekijk de officiële regels van Major League Baseball.

De data opschonen en voorbereiden

Zoals je hierboven ziet, heeft het DataFrame geen kolomkoppen. Je kunt koppen toevoegen door een lijst met koppen door te geven aan het attribuut columns van pandas.

# Adding column names to dataframe
cols = ['yearID','lgID','teamID','franchID','divID','Rank','G','Ghome','W','L','DivWin','WCWin','LgWin','WSWin','R','AB','H','2B','3B','HR','BB','SO','SB','CS','HBP','SF','RA','ER','ERA','CG','SHO','SV','IPouts','HA','HRA','BBA','SOA','E','DP','FP','name','park','attendance','BPF','PPF','teamIDBR','teamIDlahman45','teamIDretro','franchID','franchName','active','NAassoc']
teams_df.columns = ____

# Print the first rows of `teams_df`
print(______________)

# Print the length of `teams_df`
print(len(________))

De functie len() laat zien met hoeveel rijen je werkt: 2.287 is niet heel veel, hopelijk zijn er dus niet te veel null-waarden.

Voordat je de datakwaliteit beoordeelt, halen we eerst kolommen weg die niet nodig zijn of die zijn afgeleid van de doelkolom (Wins). Kennis van de data waar je mee werkt wordt hier heel waardevol. Het maakt weinig uit hoeveel je weet van coderen of statistiek als je niets weet over je data. Een leven lang honkbalfan zijn hielp me zeker bij dit project.

# Dropping your unnecesary column variables.
drop_cols = ['lgID','franchID','divID','Rank','Ghome','L','DivWin','WCWin','LgWin','WSWin','SF','name','park','attendance','BPF','PPF','teamIDBR','teamIDlahman45','teamIDretro','franchID','franchName','active','NAassoc']

df = teams_df.drop(drop_cols, axis=1)

# Print out first rows of `df`
print(_________)

Zoals je hierboven las, beïnvloeden null-waarden de datakwaliteit, wat op zijn beurt problemen kan geven voor machinelearningalgoritmen.

Daarom haal je die nu weg. Er zijn meerdere manieren om null-waarden te verwijderen, maar het is beter om eerst het aantal null-waarden per kolom te tonen, zodat je kunt beslissen hoe je ze het best behandelt.

# Print out null values of all columns of `df`
print(_________.sum(axis=0).tolist())

Hier zie je de afweging: je wilt schone data, maar je hebt ook niet overdreven veel data te verliezen. Twee kolommen hebben relatief weinig null-waarden. Er zijn 110 null-waarden in de kolom SO (strikeouts) en 22 in DP (double play). Twee kolommen hebben er juist veel. Er zijn 419 null-waarden in CS (caught stealing) en 1777 in HBP (hit by pitch).

Als je de rijen weglaat waarin kolommen met weinig null-waarden voorkomen, verlies je iets meer dan vijf procent van onze data. Omdat je overwinningen wilt voorspellen, zijn gemaakte runs en toegestane runs sterk gecorreleerd met het doel. Je wilt dat de data in die kolommen zeer nauwkeurig is.

Strikeouts (SO) en double plays (DP) zijn minder belangrijk.

Ik denk dat je beter de rijen behoudt en de null-waarden opvult met de mediaan van elke kolom met de methode fillna(). Caught stealing (CS) en hit by pitch (HBP) zijn ook niet erg belangrijke variabelen. Met zoveel null-waarden in deze kolommen kun je ze het best geheel verwijderen.

# Eliminating columns with null values
df = df.drop(['CS','HBP'], axis=1)

# Filling null values
df['SO'] = df['SO'].fillna(df['SO'].median())
df['DP'] = df['DP'].fillna(df['DP'].median())

# Print out null values of all columns of `df`
print(df.isnull().sum(axis=0).tolist())

De data verkennen en visualiseren

Nu je data is opgeschoond, kun je verkennen. Met een paar eenvoudige visualisaties krijg je gevoel voor de dataset. matplotlib is een uitstekende bibliotheek voor datavisualisatie.

Je importeert matplotlib.pyplot en hernoemt dit naar plt voor het gemak. Werk je in een Jupyter-notebook, gebruik dan de magic %matplotlib inline.

Begin met een histogram van de doelkolom zodat je de verdeling van overwinningen ziet.

# import the pyplot module from matplotlibimport matplotlib.pyplot as plt# matplotlib plots inline  %matplotlib inline# Plotting distribution of winsplt.hist(df['W'])plt.xlabel('Wins')plt.title('Distribution of Wins')plt.show()Mogelijk gemaakt door

Let op: als je geen Jupyter-notebook gebruikt, moet je plt.show() aanroepen om de plots te tonen.

Print het gemiddelde aantal overwinningen (W) per jaar. Gebruik hiervoor de methode mean().

print(df['_'].______)

Het kan nuttig zijn om tijdens de verkenning bins te maken voor je doelkolom, maar zorg dat je geen kenmerk dat je uit de doelkolom afleidt, meeneemt in het trainen van je model. Zo’n kolom labels uit de doelkolom opnemen in je trainingsset is alsof je je model de antwoorden geeft.

Voor de winlabels maak je een functie assign_win_bins die een geheel getal (wins) inneemt en een integer van 1-5 teruggeeft, afhankelijk van de invoerwaarde.

Vervolgens maak je een nieuwe kolom win_bins door de apply()-methode op de wins-kolom te gebruiken en de functie assign_win_bins() door te geven.

# Creating bins for the win column
def assign_win_bins(_):
    if W < 50:
        return 1
    if W >= 50 and W <= 69:
        return 2
    if W >= 70 and W <= 89:
        return 3
    if W >= 90 and W <= 109:
        return 4
    if W >= 110:
        return 5
        
# Apply `assign_win_bins` to `df['W']`    
df['win_bins'] = df['_'].apply(______________)

Maak nu een scatterplot met het jaar op de x-as en overwinningen op de y-as en kleur de win_bins-kolom.

# Plotting scatter graph of Year vs. Winsplt.scatter(df['yearID'], df['W'], c=df['win_bins'])plt.title('Wins Scatter Plot')plt.xlabel('Year')plt.ylabel('Wins')plt.show()Mogelijk gemaakt door

Zoals je in de scatterplot ziet, zijn er heel weinig seizoenen van vóór 1900 en toen was het spel ook heel anders. Daarom is het logisch om die rijen uit de dataset te halen.

# Filter for rows where 'yearID' is greater than 1900
df = df[___________________]

Bij continue data en lineaire modellen kunnen integerwaarden zoals een jaar voor problemen zorgen. Het is onwaarschijnlijk dat het getal 1950 dezelfde relatie met de rest van de data heeft als het model veronderstelt.

Dat kun je vermijden door nieuwe variabelen te maken die de data labelen op basis van de waarde yearID.

Iedereen die MLB volgt, weet dat er door de jaren heen verschillende tijdperken (era’s) waren met veel of juist weinig runs per wedstrijd. De dead-ball era begin 1900 is een laag-scorende periode; de steroid era rond de eeuwwisseling een hoog-scorende.

Laten we hieronder een grafiek maken die laat zien hoeveel er per jaar gescoord werd.

Begin met de dictionaries runs_per_year en games_per_year. Loop door het dataframe met de methode iterrows(). Vul runs_per_year met jaren als sleutel en het aantal gescoorde runs in dat jaar als waarde. Vul games_per_year met jaren als sleutel en het aantal gespeelde wedstrijden in dat jaar als waarde.

# Create runs per year and games per year dictionaries
runs_per_year = {}
games_per_year = {}

for i, row in df.iterrows():
    year = row['yearID']
    runs = row['R']
    games = row['G']
    if year in runs_per_year:
        runs_per_year[year] = runs_per_year[year] + runs
        games_per_year[year] = games_per_year[year] + games
    else:
        runs_per_year[year] = runs
        games_per_year[year] = games
        
print(runs_per_year)
print(games_per_year)

Maak vervolgens de dictionary mlb_runs_per_game. Itereer door games_per_year met de methode items(). Vul mlb_runs_per_game met jaren als sleutel en het aantal runs per wedstrijd, voor de hele league, als waarde.

# Create MLB runs per game (per year) dictionary
mlb_runs_per_game = {}
for k, v in games_per_year.items():
    year = k
    games = v
    runs = runs_per_year[year]
    mlb_runs_per_game[year] = runs / games
    
print(mlb_runs_per_game)

Maak tot slot je plot uit de dictionary mlb_runs_per_game met jaren op de x-as en runs per wedstrijd op de y-as.

# Create lists from mlb_runs_per_game dictionarylists = sorted(mlb_runs_per_game.items())x, y = zip(*lists)# Create line plot of Year vs. MLB runs per Gameplt.plot(x, y)plt.title('MLB Yearly Runs per Game')plt.xlabel('Year')plt.ylabel('MLB Runs per Game')plt.show()Mogelijk gemaakt door

Nieuwe features toevoegen

Nu je beter zicht hebt op scoretrends, kun je nieuwe variabelen maken die de era aangeven waarin elke rij op basis van yearID valt. Je volgt hetzelfde proces als bij de kolom win_bins.

Dit keer maak je echter dummy-kolommen; één nieuwe kolom per era. Gebruik hiervoor de methode get_dummies().

# Creating "year_label" column, which will give your algorithm information about how sertain years are related 
# (Dead ball eras, Live ball/Steroid Eras)

def assign_label(____):
    if year < 1920:
        return 1
    elif year >= 1920 and year <= 1941:
        return 2
    elif year >= 1942 and year <= 1945:
        return 3
    elif year >= 1946 and year <= 1962:
        return 4
    elif year >= 1963 and year <= 1976:
        return 5
    elif year >= 1977 and year <= 1992:
        return 6
    elif year >= 1993 and year <= 2009:
        return 7
    elif year >= 2010:
        return 8
        
# Add `year_label` column to `df`    
df['year_label'] = df['yearID'].apply(___________)

dummy_df = pd.get_dummies(df['year_label'], prefix='era')

# Concatenate `df` and `dummy_df`
df = pd.concat([df, dummy_df], axis=1)

print(df.head())

Omdat je al hebt bepaald hoeveel MLB-runs per wedstrijd er per jaar waren, voeg je die data toe aan de dataset.

# Create column for MLB runs per game from the mlb_runs_per_game dictionary
def assign_mlb_rpg(year):
    return mlb_runs_per_game[year]

df['mlb_rpg'] = df['yearID'].apply(assign_mlb_rpg)

Nu zet je de jaren om naar decennia door dummy-kolommen per decennium te maken. Daarna kun je kolommen die je niet meer nodig hebt, droppen.