Tutoriel Scikit-learn : analytics baseball, partie 1

Importer les données

Vous allez lire les données en interrogeant une base sqlite avec le package sqlite3 puis en les convertissant en DataFrame avec pandas. Les données seront filtrées pour ne conserver que les équipes modernes encore actives et les saisons où l’équipe a disputé au moins 150 matchs.

Commencez par télécharger le fichier « lahman2016.sqlite » (ici). Chargez ensuite Pandas sous l’alias pd, l’alias usuel pour Pandas. Enfin, chargez sqlite3 et connectez-vous à la base, comme ceci :

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

Rédigez ensuite une requête, exécutez-la et récupérez les résultats.

# 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()

Astuce : pour aller plus loin avec SQL en Python, suivez le cours Introduction to Databases in Python sur DataCamp.

Avec pandas, convertissez ensuite les résultats en DataFrame et affichez les 5 premières lignes avec la méthode head() :

Chaque colonne contient des données pour une équipe et une année spécifiques. Voici les variables les plus importantes. La liste complète est disponible ici.

• yearID - Année
• teamID - Équipe
• franchID - Franchise (lien vers la table TeamsFranchise)
• G - Matchs joués
• W - Victoires
• LgWin - Champion de ligue (Y ou N)
• WSWin - Vainqueur des World Series (Y ou N)
• R - Points marqués
• AB - Presences au bâton
• H - Coups sûrs des batteurs
• HR - Circuits des batteurs
• BB - Buts sur balles obtenus
• SO - Retraits sur prises (batteurs)
• SB - Buts volés
• CS - Retirés en tentative de vol
• HBP - Atteints par un lancer
• SF - Ballons-sacrifices
• RA - Points concédés
• ER - Points mérités concédés
• ERA - Moyenne de points mérités
• CG - Matchs complets
• SHO - Jeux blancs
• SV - Sauvetages
• IPOuts - Retraits lancés (manches lancées x 3)
• HA - Coups sûrs alloués
• HRA - Circuits alloués
• BBA - Buts sur balles alloués
• SOA - Retraits sur prises (lanceurs)
• E - Erreurs
• DP - Doubles jeux
• FP - Pourcentage défensif
• name - Nom complet de l’équipe

Si vous n’êtes pas familier avec le baseball, voici un bref rappel du déroulé, en reliant quelques variables.

Le baseball oppose deux équipes (repérées dans les données par name ou teamID) de neuf joueurs. Elles alternent entre l’attaque (batte) et la défense (champ). L’équipe à la batte tente de marquer des points en frappant la balle lancée par le lanceur adverse, puis en courant dans le sens inverse des aiguilles d’une montre autour des quatre bases : première, deuxième, troisième et marbre. L’équipe en défense cherche à empêcher les points en retirant frappeurs et coureurs par divers moyens ; un point (R) est marqué lorsqu’un joueur fait le tour des bases et revient au marbre. Un frappeur qui atteint une base en sécurité tentera d’avancer lors des passages suivants, par exemple sur un coup sûr (H), un vol de base (SB), etc.

Les équipes alternent attaque et défense quand la défense enregistre trois retraits. Un tour d’attaque par équipe constitue une manche. Un match comprend neuf manches ; l’équipe qui a le plus de points à la fin gagne. Il n’y a pas d’horloge ; si le score est à égalité après neuf manches, on joue des manches supplémentaires jusqu’à ce qu’une équipe mène à la fin d’une manche additionnelle.

Pour une présentation détaillée des règles, consultez les règles officielles de la Major League Baseball.

Nettoyer et préparer les données

Comme vous le voyez, le DataFrame n’a pas d’en-têtes de colonnes. Vous pouvez les ajouter en passant la liste des en-têtes à l’attribut columns de pandas.

La fonction len() vous indique le nombre de lignes : 2 287, ce qui reste raisonnable ; espérons peu de valeurs manquantes.

Avant d’évaluer la qualité des données, éliminons les colonnes non nécessaires ou dérivées de la cible (Wins). La connaissance métier prend ici toute sa valeur : peu importe vos compétences en code ou en stats si vous ne maîtrisez pas le domaine des données. Être fan de baseball m’a clairement aidé pour ce projet.

Comme vu plus haut, les valeurs manquantes dégradent la qualité des données, et peuvent perturber les algorithmes de machine learning.

Vous allez donc les traiter. Plusieurs approches existent ; commencez par afficher le nombre de valeurs manquantes par colonne pour décider de la meilleure stratégie.

Vous observerez un compromis : il faut des données propres, mais l’échantillon n’est pas énorme. Deux colonnes ont peu de valeurs manquantes : 110 dans SO (strikeouts) et 22 dans DP (double jeu). Deux autres en ont beaucoup : 419 dans CS (vols de base avortés) et 1 777 dans HBP (frappeur atteint).

Supprimer les lignes pour SO et DP ferait perdre un peu plus de 5 % des données. Or, pour prédire les victoires, les points marqués et concédés sont très corrélés à la cible. Autant privilégier la précision de ces colonnes.

Les strikeouts (SO) et doubles jeux (DP) sont moins déterminants.

Il vaut mieux conserver les lignes et imputer les valeurs manquantes par la médiane de chaque colonne via fillna(). Les variables CS et HBP étant peu importantes et très lacunaires, le plus simple est de supprimer ces colonnes.

Explorer et visualiser les données

Maintenant que vos données sont nettoyées, explorez-les avec quelques visualisations simples. matplotlib est une excellente bibliothèque de visualisation.

Importez matplotlib.pyplot sous l’alias plt. Si vous utilisez un notebook Jupyter, pensez à la magie %matplotlib inline.

Commencez par un histogramme de la colonne cible pour visualiser la distribution des victoires.

# 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()

Remarque : si vous n’utilisez pas Jupyter, appelez plt.show() pour afficher les graphiques.

Affichez ensuite le nombre moyen de victoires (W) par année avec la méthode mean().

Créer des classes (bins) pour la colonne cible peut aider en exploration, mais ne les incluez jamais parmi les features lors de l’entraînement, au risque de « donner les réponses » au modèle.

Créez une fonction assign_win_bins qui prend un entier (victoires) et renvoie un entier de 1 à 5 selon l’intervalle.

Générez ensuite une colonne win_bins avec apply() sur la colonne des victoires.

Tracez maintenant un nuage de points avec l’année en abscisse et les victoires en ordonnée, en colorant selon win_bins.

# 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()

Comme on le voit, il y a très peu de saisons avant 1900 et le jeu était différent. Il est pertinent d’éliminer ces lignes du jeu de données.

Avec des données continues et des modèles linéaires, des entiers comme une année peuvent poser problème : 1950 n’a pas de relation « linéaire » évidente avec le reste des features.

Évitez cela en créant de nouvelles variables catégorielles à partir de yearID.

Les amateurs savent que différentes ères MLB se distinguent par un niveau de scoring plus ou moins élevé (ex. « dead-ball era » au début du XXe siècle, « steroid era » autour des années 2000).

Traçons d’abord l’évolution des points marqués par année.

Commencez par créer les dictionnaires runs_per_year et games_per_year. Parcourez le DataFrame avec iterrows() ; alimentez runs_per_year avec l’année en clé et le total de points marqués en valeur, et games_per_year avec l’année et le total de matchs joués.

Puis créez un dictionnaire mlb_runs_per_game : parcourez games_per_year avec items() et calculez les points par match (toutes équipes confondues) pour chaque année.

Enfin, représentez mlb_runs_per_game : années en abscisse, points par match en ordonnée.

# 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()

Ajouter de nouvelles features

Maintenant que vous comprenez les tendances de scoring, créez des variables indiquant l’ère correspondant à chaque ligne selon yearID, en procédant comme pour win_bins.

Cette fois, créez des variables indicatrices (dummies) : une colonne par ère, avec get_dummies().

Puisque vous avez calculé les points par match MLB pour chaque année, ajoutez cette donnée au jeu de données.

Convertissez ensuite les années en décennies avec des dummies par décennie, puis supprimez les colonnes devenues inutiles.

Au baseball, tout se résume aux points marqués et concédés. Vous pouvez améliorer sensiblement la précision du modèle en ajoutant des ratios : points par match et points concédés par match sont d’excellentes features.

Pandas simplifie cela : créez une nouvelle colonne en divisant R par G pour obtenir R_per_game.

Visualisez l’effet de ces deux nouvelles features sur la cible via deux nuages de points : points par match vs victoires, puis points concédés par match vs victoires.

# Create scatter plots for runs per game vs. wins and runs allowed per game vs. winsfig = plt.figure(figsize=(12, 6))ax1 = fig.add_subplot(1,2,1)ax2 = fig.add_subplot(1,2,2)ax1.scatter(df['R_per_game'], df['W'], c='blue')ax1.set_title('Runs per Game vs. Wins')ax1.set_ylabel('Wins')ax1.set_xlabel('Runs per Game')ax2.scatter(df['RA_per_game'], df['W'], c='red')ax2.set_title('Runs Allowed per Game vs. Wins')ax2.set_xlabel('Runs Allowed per Game')plt.show()

Avant de passer aux modèles, évaluez la corrélation de chaque variable avec la cible. Pandas le permet via corr().

Autre amélioration possible : ajouter des labels issus d’un clustering K-means via sklearn. K-means partitionne les données selon un nombre k de centroïdes, en assignant chaque point au centroïde le plus proche (distance euclidienne minimale).

Pour en savoir plus sur K-means : voir ici.

Commencez par créer un DataFrame sans la cible :

Avant d’appliquer K-means, vous devez choisir le nombre de clusters. La fonction silhouette_score() de sklearn aide à l’estimer : elle retourne le coefficient moyen de silhouette (plus haut est mieux, et il a tendance à baisser avec davantage de clusters).

Initialisez maintenant le modèle avec 6 clusters et random_state=1. Calculez les distances euclidiennes avec fit_transform() et visualisez les clusters en scatter plot.

# Create K-means model and determine euclidian distances for each data pointkmeans_model = KMeans(n_clusters=6, random_state=1)distances = kmeans_model.fit_transform(data_attributes)# Create scatter plot using labels from K-means model as colorlabels = kmeans_model.labels_plt.scatter(distances[:,0], distances[:,1], c=labels)plt.title('Kmeans Clusters')plt.show()

Ajoutez ensuite les labels des clusters comme nouvelle colonne, et ajoutez la chaîne « labels » à la liste attributes pour plus tard.

Avant d’entraîner un modèle, séparez les données en ensembles d’entraînement et de test. Entraîner et tester sur les mêmes données mènerait à un surapprentissage : le modèle « mémorise » au lieu de généraliser, et se comporte mal sur des données nouvelles.

Rassurez-vous, il existe plusieurs techniques de validation croisée.

Ici, prenez un échantillon aléatoire de 75 % pour l’ensemble train et les 25 % restants pour test. Créez une liste numeric_cols avec toutes les colonnes retenues. Générez un DataFrame data à partir de df avec ces colonnes, puis échantillonnez pour former train et test.

Choisir la métrique d’erreur et le modèle

La Mean Absolute Error (MAE) mesurera l’exactitude du modèle : elle indique l’écart absolu moyen entre les prédictions et les résultats. Ici, cela correspond au nombre moyen de victoires d’écart entre la prédiction et la réalité.

Par exemple, si vos prédictions ratent la cible de 5 victoires en moyenne, la métrique vaut 5.

Premier modèle : une régression linéaire. Importez LinearRegression et mean_absolute_error depuis sklearn.linear_model et sklearn.metrics, créez le modèle lr, entraînez-le, prédisez et calculez la MAE.

Si vous vous souvenez, la moyenne était d’environ 79 victoires. En moyenne, le modèle se trompe de 2,687 victoires.

Essayez maintenant un modèle Ridge. Importez RidgeCV depuis sklearn.linear_model et créez le modèle rrm. Le paramètre alpha contrôle la complexité (rétrécissement). Le modèle utilise la validation croisée pour déterminer le meilleur alpha.

Entraînez, prédisez et calculez la MAE.

Ce modèle est légèrement meilleur, avec une erreur moyenne de 2,673 victoires.