Votre premier arbre de décision en Python (NFL Combine)

Feb 22 2023

Les performances d'un joueur dans le NFL Combine peuvent-elles prédire s'il sera repêché ou non ? Construisons un modèle pour le savoir ! Qu'est-ce qu'un arbre de décision ? Un arbre de décision est un algorithme d'apprentissage automatique utilisé pour les tâches de classification et de régression. Il s'agit d'un type d'algorithme d'apprentissage supervisé, ce qui signifie qu'il est formé sur des données étiquetées.

Les performances d'un joueur dans le NFL Combine peuvent-elles prédire s'il sera repêché ou non ? Construisons un modèle pour le savoir !

Qu'est-ce qu'un arbre de décision ?

Un arbre de décision est un algorithme d'apprentissage automatique utilisé pour les tâches de classification et de régression. Il s'agit d'un type d'algorithme d'apprentissage supervisé, ce qui signifie qu'il est formé sur des données étiquetées. L'idée de base derrière un arbre de décision est de créer un modèle qui prédit la valeur d'une variable cible en fonction de plusieurs variables d'entrée.

Comment pouvons-nous l'utiliser ici?

Comme indiqué ci-dessus, les arbres de décision peuvent être utilisés pour la classification (qu'un joueur soit repêché ou non) avec des données étiquetées (les résultats NFL Combine du passé).

Implémentons ceci en Python (Cahier complet trouvé ici :https://github.com/ant-vessicchio/learn_data_science_through_sports/blob/main/NFL_Combine/NFL_Combine_1st_Decision_Tree.ipynb)

Tout d'abord, les importations dont nous aurons besoin :

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn import tree

master_table = master_table = pd.read_csv("NFL.csv")
master_table.head()

X = master_table.iloc[:,3:9]
Y = master_table.iloc[:,-1]

#Drop Records Containing Null Values
X.dropna(inplace=True)  
X.isnull().sum() #Check

Qu'est-ce que cela signifie?

Il s'agit d'une technique utilisée dans les algorithmes d'apprentissage automatique afin d'évaluer les performances d'un modèle sans biais.

L'ensemble de formation est la partie des données qui est utilisée pour former le modèle d'apprentissage automatique. Dans cet ensemble de données, le modèle "connaît" le résultat (il est présenté avec l'étiquette de sortie de Y), et il utilisera ces informations pour "ajuster" un modèle qui pourra se généraliser à des données nouvelles et "invisibles".

L'ensemble de test est utilisé pour évaluer les performances du modèle entraîné sur de nouvelles données inédites. Les données de test incluent à la fois les données d'entrée et les étiquettes de sortie correspondantes, mais les étiquettes de sortie ne sont __pas__ utilisées pendant les tests. Au lieu de cela, le modèle fait des prédictions sur les données de test, et les sorties prédites sont comparées aux sorties réelles pour évaluer les performances du modèle.

X_train, X_test, y_train, y_test = train_test_split(X,Y, test_size = 0.3, random_state=100)

Formation et évaluation du modèle

Nous utiliserons le DecisionTreeClassifier dans sklearn. La première étape consiste à créer une instance de la classe et à spécifier les hyperparamètres que vous souhaitez utiliser. Certains des hyperparamètres couramment utilisés incluent :

- max_depth : la profondeur maximale de l'arbre de décision
- min_samples_split : le nombre minimal d'échantillons requis pour diviser un nœud interne
- critère : la fonction utilisée pour mesurer la qualité d'une division (par exemple, 'gini' ou 'entropy')

Nous n'en utiliserons pas plus pour l'instant. Et je vous encourage à lire la documentation de sklearn pour plus d'informations !
https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html

clf = DecisionTreeClassifier(criterion = 'gini',min_samples_split = 3, max_depth = 3)

clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

print(f" Accuracy score: {accuracy_score(y_test,y_pred)}")

Visualisez ce qui se passe :

Une fonctionnalité assez intéressante d'un arbre de décision est les visualisations qu'ils peuvent fournir. Où vous pouvez essentiellement voir le point de coupure pour chaque caractéristique dans la prise de décision, combien d'échantillons ont été classés dans chaque classe et l'indice de Gini qui est la mesure de la façon dont un attribut donné sépare les exemples d'apprentissage dans un arbre de décision.

plt.figure(figsize=(12,8))
from sklearn import tree
tree.plot_tree(clf.fit(X_train,y_train), feature_names = X_train.columns )
plt.show()

Une fonctionnalité très intéressante d'un arbre de décision est la génération de l'importance des fonctionnalités. L'importance des caractéristiques dans un arbre de décision fait référence à une mesure de l'importance de chaque caractéristique ou variable d'entrée dans la détermination de la sortie finale de l'arbre.

# let's create a dictionary of features and their importance values
feat_dict= {}
for col, val in sorted(zip(X_train.columns, clf.feature_importances_),key=lambda x:x[1],reverse=True):
  feat_dict[col]=val

feat_df = pd.DataFrame({'Feature':feat_dict.keys(),'Importance':feat_dict.values()})
feat_df

Et pour faire une illustration simple de l'importance des fonctionnalités :

import seaborn as sns
values = feat_df.Importance    
idx = feat_df.Feature
plt.figure(figsize=(10,8))
clrs = ['green' if (x < max(values)) else 'red' for x in values ]
sns.barplot(y=idx,x=values,palette=clrs).set(title='Feature Importance - Player Drafted (Y/N)')
plt.show()

Quelques idées:

Modifier/ajouter des hyperparamètres
Construisez un modèle pour chaque position et voyez si cela améliore la précision !
Essayez peut-être de gérer les données manquantes différemment ?

Si vous avez apprécié cet article, veuillez commenter ci-dessous, suivez-moi pour plus de contenu et suivez l'intégralité de mon cours gratuit "Apprendre la science des données par le sport" hébergé sur mon GitHub et SubReddit :