Il tuo primo albero decisionale in Python (combinazione NFL)

Feb 22 2023

La prestazione di un giocatore nella NFL Combine può prevedere se verrà arruolato o meno? Costruiamo un modello per scoprirlo! Cos'è un albero decisionale? Un albero decisionale è un algoritmo di apprendimento automatico utilizzato per attività di classificazione e regressione. È un tipo di algoritmo di apprendimento supervisionato, il che significa che è addestrato su dati etichettati.

La prestazione di un giocatore nella NFL Combine può prevedere se verrà arruolato o meno? Costruiamo un modello per scoprirlo!

Cos'è un albero decisionale?

Un albero decisionale è un algoritmo di apprendimento automatico utilizzato per attività di classificazione e regressione. È un tipo di algoritmo di apprendimento supervisionato, il che significa che è addestrato su dati etichettati. L'idea alla base di un albero decisionale è creare un modello che preveda il valore di una variabile target in base a diverse variabili di input.

Come possiamo usarlo qui?

Come affermato sopra, gli alberi decisionali possono essere utilizzati per la classificazione (se un giocatore verrà scelto o meno) con dati etichettati (i risultati della NFL Combine del passato).

Implementiamolo in Python (taccuino completo trovato qui:https://github.com/ant-vessicchio/learn_data_science_through_sports/blob/main/NFL_Combine/NFL_Combine_1st_Decision_Tree.ipynb)

Innanzitutto, le importazioni di cui avremo bisogno:

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

Cosa significa questo?

Questa è una tecnica utilizzata negli algoritmi di apprendimento automatico per valutare le prestazioni di un modello senza pregiudizi.

Il training set è la porzione di dati utilizzata per addestrare il modello di machine learning. In questo set di dati, il modello "conosce" il risultato (viene presentato con l'etichetta di output da Y) e utilizzerà queste informazioni per "adattare" un modello che sarà in grado di generalizzare a dati nuovi e "non visti".

Il set di test viene utilizzato per valutare le prestazioni del modello addestrato su dati nuovi e invisibili. I dati di test includono sia i dati di input che le corrispondenti etichette di output, ma le etichette di output __non__ vengono utilizzate durante il test. Al contrario, il modello effettua previsioni sui dati di test e gli output previsti vengono confrontati con gli output effettivi per valutare le prestazioni del modello.

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

Formazione e valutazione del modello

Useremo DecisionTreeClassifier in sklearn. Il primo passaggio consiste nel creare un'istanza della classe e specificare gli eventuali iperparametri che si desidera utilizzare. Alcuni degli iperparametri comunemente usati includono:

- max_depth: la profondità massima dell'albero decisionale
- min_samples_split: il numero minimo di campioni richiesti per suddividere un nodo interno
- criterio: la funzione utilizzata per misurare la qualità di una suddivisione (ad esempio, 'gini' o 'entropia')

Non useremo più di questo per ora. E ti incoraggio a leggere la documentazione di sklearn per maggiori informazioni!
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)}")

Visualizza cosa sta succedendo:

Una caratteristica piuttosto interessante di un albero decisionale sono le visualizzazioni che possono fornire. Dove puoi essenzialmente vedere il punto limite per ogni caratteristica nel processo decisionale, quanti campioni sono stati classificati in ogni classe e l'indice gini che è la misura di quanto bene un dato attributo separa gli esempi di addestramento in un albero decisionale.

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

Una caratteristica molto interessante di un albero decisionale è la generazione dell'importanza delle funzionalità. L'importanza delle caratteristiche in un albero decisionale si riferisce a una misura dell'importanza di ciascuna caratteristica o variabile di input nel determinare l'output finale dell'albero.

# 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

E per fare una semplice illustrazione dell'importanza delle funzionalità:

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

Qualche idea:

Modifica/aggiungi iperparametri
Costruisci un modello per ogni posizione e vedi se questo migliora la precisione!
Forse provare a gestire i dati mancanti in modo diverso?

Se ti è piaciuto questo articolo, commenta di seguito, seguimi per ulteriori contenuti e segui il mio intero corso gratuito "Impara la scienza dei dati attraverso lo sport" ospitato sul mio GitHub e SubReddit: