Tu primer árbol de decisiones en Python (NFL Combine)

Feb 22 2023

¿Puede el desempeño de un jugador en el NFL Combine predecir si será reclutado o no? ¡Construyamos un modelo para averiguarlo! ¿Qué es un árbol de decisión? Un árbol de decisión es un algoritmo de aprendizaje automático que se utiliza para tareas de clasificación y regresión. Es un tipo de algoritmo de aprendizaje supervisado, lo que significa que está entrenado en datos etiquetados.

¿Puede el desempeño de un jugador en el NFL Combine predecir si será reclutado o no? ¡Construyamos un modelo para averiguarlo!

¿Qué es un árbol de decisión?

Un árbol de decisión es un algoritmo de aprendizaje automático que se utiliza para tareas de clasificación y regresión. Es un tipo de algoritmo de aprendizaje supervisado, lo que significa que está entrenado en datos etiquetados. La idea básica detrás de un árbol de decisión es crear un modelo que prediga el valor de una variable objetivo en función de varias variables de entrada.

¿Cómo podemos usarlo aquí?

Como se indicó anteriormente, los árboles de decisión se pueden usar para la clasificación (ya sea que un jugador sea reclutado o no) con datos etiquetados (los resultados del NFL Combine del pasado).

Implementemos esto en Python (Cuaderno completo que se encuentra aquí:https://github.com/ant-vessicchio/learn_data_science_through_sports/blob/main/NFL_Combine/NFL_Combine_1st_Decision_Tree.ipynb)

Primero, las importaciones que necesitaremos:

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é quiere decir esto?

Esta es una técnica utilizada en algoritmos de aprendizaje automático para evaluar el rendimiento de un modelo sin sesgos.

El conjunto de entrenamiento es la parte de los datos que se usa para entrenar el modelo de aprendizaje automático. En este conjunto de datos, el modelo "conoce" el resultado (se presenta con la etiqueta de salida de Y) y utilizará esta información para "ajustar" un modelo que podrá generalizar a datos nuevos e "invisibles".

El conjunto de prueba se usa para evaluar qué tan bien se desempeña el modelo entrenado en datos nuevos e invisibles. Los datos de prueba incluyen tanto los datos de entrada como las etiquetas de salida correspondientes, pero las etiquetas de salida __no__ se utilizan durante la prueba. En su lugar, el modelo hace predicciones sobre los datos de prueba y los resultados previstos se comparan con los resultados reales para evaluar el rendimiento del modelo.

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

Entrenamiento y evaluación del modelo

Usaremos el DecisionTreeClassifier en sklearn. El primer paso es crear una instancia de la clase y especificar cualquier hiperparámetro que desee usar. Algunos de los hiperparámetros comúnmente utilizados incluyen:

- max_ depth: la profundidad máxima del árbol de decisión
- min_samples_split: el número mínimo de muestras requeridas para dividir un nodo interno
- criterio: la función utilizada para medir la calidad de una división (p. ej., 'gini' o 'entropía')

No usaremos más que esto por ahora. ¡Y te animo a leer la documentación de sklearn para obtener más información!
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)}")

Visualiza lo que está pasando:

Una característica muy interesante de un árbol de decisiones son las visualizaciones que pueden proporcionar. Donde esencialmente puede ver el punto de corte para cada característica en la toma de decisiones, cuántas muestras se clasificaron en cada clase y el índice Gini, que es la medida de qué tan bien un atributo dado separa los ejemplos de capacitación en un árbol de decisión.

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 característica muy interesante de un árbol de decisión es la generación de la importancia de la característica. La importancia de las características en un árbol de decisión se refiere a una medida de la importancia de cada característica o variable de entrada para determinar el resultado final del árbol.

# 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

Y para hacer una ilustración simple de la importancia de las características:

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

Algunas ideas:

Cambiar/añadir hiperparámetros
¡Construya un modelo para cada posición y vea si eso mejora la precisión!
¿Tal vez intente manejar los datos faltantes de manera diferente?

Si disfrutó de este artículo, comente a continuación, sígame para obtener más contenido y siga todo mi curso gratuito "Aprender ciencia de datos a través del deporte" alojado en mi GitHub y SubReddit: