Tutorial de Scikit-Learn: analítica de béisbol (parte 1)

Importar datos

Leerás los datos consultando una base de datos sqlite con el paquete sqlite3 y convirtiéndolos en un DataFrame con pandas. Filtrarás los datos para incluir solo equipos modernos activos y temporadas con 150 o más partidos jugados.

Primero, descarga el archivo "lahman2016.sqlite" (aquí). Luego, carga Pandas y asígnale el alias pd por comodidad. Quizá recuerdes que pd es el alias habitual de Pandas. Por último, carga sqlite3 y conecta con la base de datos así:

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

A continuación, escribe una consulta, ejecútala y recupera los resultados.

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

Consejo: si quieres aprender más sobre cómo usar SQL con Python, plantéate hacer el curso Introduction to Databases in Python de DataCamp.

Con pandas, convierte los resultados en un DataFrame e imprime las 5 primeras filas con el método head():

Cada columna contiene datos de un equipo y un año específicos. A continuación verás algunas de las variables más importantes. Puedes consultar la lista completa de variables aquí.

• yearID - Año
• teamID - Equipo
• franchID - Franquicia (enlaza con la tabla TeamsFranchise)
• G - Partidos jugados
• W - Victorias
• LgWin - Campeón de liga (Y o N)
• WSWin - Ganador de la World Series (Y o N)
• R - Carreras anotadas
• AB - Turnos de bateo
• H - Hits de los bateadores
• HR - Home runs de los bateadores
• BB - Bases por bolas de los bateadores
• SO - Strikeouts de los bateadores
• SB - Bases robadas
• CS - Cazado robando
• HBP - Golpeados por lanzamiento
• SF - Flies de sacrificio
• RA - Carreras permitidas al rival
• ER - Carreras limpias permitidas
• ERA - Promedio de carreras limpias
• CG - Partidos completos
• SHO - Blanqueadas
• SV - Salvamentos
• IPOuts - Outs lanzados (innings lanzados x 3)
• HA - Hits permitidos
• HRA - Home runs permitidos
• BBA - Bases por bolas permitidas
• SOA - Strikeouts de los lanzadores
• E - Errores
• DP - Dobles matanzas
• FP - Porcentaje de fildeo
• name - Nombre completo del equipo

Si no estás familiarizado con el béisbol, aquí tienes una explicación rápida de cómo funciona el juego, incluyendo algunas de las variables anteriores.

El béisbol se juega entre dos equipos (que identificarás en los datos por name o teamID) de nueve jugadores. Los equipos se turnan para batear y defender. El equipo al bate intenta anotar carreras golpeando la pelota que lanza el pitcher del equipo a la defensiva y corriendo en sentido antihorario por cuatro bases: primera, segunda, tercera y home. El equipo a la defensiva intenta evitar carreras eliminando a bateadores o corredores de varias formas, y se anota una carrera (R) cuando un jugador recorre todas las bases y vuelve al home. Un bateador que llega a salvo a base intentará avanzar en turnos posteriores de sus compañeros, ya sea con un hit (H), una base robada (SB) u otros medios.

Los equipos cambian entre bateo y defensa cada vez que el equipo defensor consigue tres outs. Un turno de bateo para ambos equipos, empezando por el visitante, constituye una entrada (inning). Un partido tiene nueve entradas, y gana el que más carreras tiene al final. El béisbol no tiene reloj; aunque la mayoría de partidos acaban en la novena entrada, si hay empate se juegan entradas extra hasta que un equipo acabe una entrada con ventaja.

Para una explicación detallada del juego, consulta el reglamento oficial de las Major Leagues.

Limpiar y preparar los datos

Como ves arriba, el DataFrame no tiene cabeceras de columna. Puedes añadirlas pasando una lista con tus nombres al atributo columns de pandas.

La función len() te dirá cuántas filas tienes: 2.287 no es un número enorme, así que esperemos que no haya demasiados nulos.

Antes de evaluar la calidad de los datos, eliminemos primero las columnas innecesarias o derivadas de la variable objetivo (Wins). Aquí es donde el conocimiento del dominio empieza a ser clave: de poco sirve saber mucho de código o estadística si no conoces los datos con los que trabajas. Ser fan del béisbol de toda la vida me ayudó mucho en este proyecto.

Como has leído, los valores nulos afectan a la calidad de los datos y pueden causar problemas a los algoritmos de machine learning.

Por eso, lo siguiente será tratarlos. Hay varias formas de eliminar nulos, pero es mejor empezar mostrando el recuento de nulos por columna para decidir cómo gestionarlos.

Aquí surge una disyuntiva: necesitas datos limpios, pero tampoco te sobra muestra. Dos columnas tienen pocos nulos. Hay 110 nulos en SO (strikeouts) y 22 en DP (doble matanza). Otras dos columnas tienen muchos. Hay 419 nulos en CS (cazado robando) y 1.777 en HBP (golpeado por lanzamiento).

Si eliminas las filas con pocos nulos, pierdes algo más del cinco por ciento de los datos. Como quieres predecir victorias, las carreras anotadas y permitidas están muy correlacionadas con el objetivo; quieres que esas columnas sean muy precisas.

Los strikeouts (SO) y las dobles matanzas (DP) no son tan críticas.

Es mejor conservar las filas y rellenar los nulos con la mediana de cada columna con fillna(). Cazado robando (CS) y golpeado por lanzamiento (HBP) tampoco son variables importantes y, con tantos nulos, conviene eliminarlas por completo.

Explorar y visualizar los datos

Ahora que has limpiado los datos, puedes explorarlos. Unas cuantas visualizaciones sencillas te ayudarán a entender mejor el conjunto. matplotlib es una librería excelente para visualizar datos.

Importa matplotlib.pyplot y renómbralo como plt para abreviar. Si trabajas en un cuaderno Jupyter, usa el magic %matplotlib inline.

Empieza representando un histograma de la columna objetivo para ver la distribución de victorias.

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

Ten en cuenta que si no usas Jupyter, debes llamar a plt.show() para mostrar los gráficos.

Imprime la media de victorias (W) por año. Puedes usar el método mean().

Puede ser útil crear rangos para la columna objetivo al explorar los datos, pero asegúrate de no incluir ninguna característica generada a partir de la columna objetivo cuando entrenes el modelo. Incluir en el train etiquetas derivadas del objetivo sería como darle las respuestas al modelo.

Para crear las etiquetas de victorias, define una función assign_win_bins que reciba un entero (victorias) y devuelva un entero de 1 a 5 según el valor de entrada.

Después crea una nueva columna win_bins aplicando assign_win_bins() sobre la columna de victorias con apply().

Ahora hagamos un diagrama de dispersión con el año en el eje x y las victorias en el eje y, coloreando por 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()

Como ves en el gráfico, hay muy pocas temporadas anteriores a 1900 y el juego era muy distinto entonces. Tiene sentido eliminar esas filas del conjunto.

Con datos continuos y modelos lineales, valores enteros como el año pueden dar problemas. Es poco probable que 1950 tenga la relación con el resto de variables que el modelo infiere.

Puedes evitarlo creando nuevas variables que etiqueten los datos según el valor de yearID.

Quien siga el béisbol sabe que, a lo largo de la MLB, han surgido épocas con más o menos carreras por partido. La dead ball era de principios del siglo XX es un ejemplo de era de baja anotación, y la era de los esteroides a comienzos del XXI, de alta anotación.

Hagamos un gráfico que muestre cuánta anotación hubo cada año.

Empieza creando los diccionarios runs_per_year y games_per_year. Recorre el DataFrame con iterrows(). Rellena runs_per_year con años como claves y el total de carreras de ese año como valores. Rellena games_per_year con años como claves y el total de partidos jugados ese año como valores.

Ahora, crea un diccionario mlb_runs_per_game. Itera por games_per_year con items(). Rellena mlb_runs_per_game con años como claves y el número de carreras por partido de toda la liga como valores.

Por último, crea el gráfico a partir del diccionario mlb_runs_per_game, con los años en el eje x y las carreras por partido en el eje y.

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

Añadir nuevas características

Con una idea más clara de las tendencias de anotación, puedes crear variables que indiquen la era a la que pertenece cada fila en función de yearID. Seguirás el mismo proceso que cuando creaste win_bins.

Esta vez crearás variables dummy: una columna nueva por era. Puedes usar get_dummies() para ello.

Ya que has calculado las carreras por partido de la MLB por año, añade esa información al conjunto.

Ahora convertirás los años en décadas creando columnas dummy por década. Después puedes eliminar las columnas que ya no necesitas.

En el béisbol, la clave es cuántas carreras anotas y cuántas permites. Puedes aumentar bastante la precisión del modelo creando columnas que sean razones de otras. Las carreras por partido y las carreras permitidas por partido serán grandes aportes al dataset.

Pandas lo hace muy sencillo: crea una nueva columna dividiendo R entre G para obtener R_per_game.

Ahora examina cómo se relacionan estas nuevas variables con la columna objetivo de victorias con un par de gráficos de dispersión. Representa las carreras por partido en el eje x de un gráfico y las permitidas por partido en el del otro. En ambos, usa W en el eje y.

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

Antes de entrar en modelos de machine learning, es útil ver cómo se correlaciona cada variable con el objetivo. Pandas lo facilita con corr().

Otra característica que puedes añadir al dataset son etiquetas derivadas de un algoritmo de clustering K-means de sklearn. K-means es un algoritmo sencillo que particiona los datos en k centroides. Cada punto se asigna al clúster con menor distancia euclídea al centroide.

Puedes aprender más sobre K-means aquí.

Primero, crea un DataFrame que excluya la variable objetivo:

Antes de usar K-means debes decidir cuántos clústeres quieres. Una forma de orientarte es la función silhouette_score() de sklearn. Devuelve el coeficiente medio de silueta; cuanto mayor, mejor, y suele disminuir al añadir más clústeres.

Ahora inicializa el modelo. Fija 6 clústeres y random_state a 1. Calcula las distancias euclídeas de cada punto con fit_transform() y visualiza los clústeres con un scatter.

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

Añade ahora las etiquetas de tus clústeres al dataset como columna nueva. Añade también la cadena "labels" a la lista attributes para usarla más adelante.

Antes de construir el modelo, divide los datos en train y test. Si entrenas y pruebas con los mismos datos, el modelo puede sobreajustarse: memoriza en lugar de aprender y rinde mal con datos nuevos.

No te preocupes: hay varias formas de validar.

En esta ocasión, toma una muestra aleatoria del 75 % como train y usa el 25 % restante como test. Crea una lista numeric_cols con todas las columnas que usarás. Después, crea un nuevo DataFrame data a partir de df con esas columnas. Por último, crea los conjuntos train y test muestreando data.

Elegir métrica de error y modelo

La métrica que usarás para evaluar la precisión del modelo es el error absoluto medio (MAE). Mide cuán cerca están las predicciones de los resultados reales. En este caso, te da el valor medio absoluto en que tu predicción se ha desviado.

Es decir, si de media fallas por 5 victorias, la métrica valdrá 5.

El primer modelo será una regresión lineal. Importa LinearRegression y mean_absolute_error desde sklearn.linear_model y sklearn.metrics, respectivamente, crea el modelo lr, ajústalo, predice y calcula el MAE.

Si recuerdas, la media de victorias era de unas 79. De media, el modelo falla por 2,687 victorias.

Ahora prueba un modelo de regresión Ridge. Importa RidgeCV desde sklearn.linear_model y crea el modelo rrm. El modelo RidgeCV permite fijar el parámetro alpha, un parámetro de complejidad que controla la cantidad de contracción (lee más aquí). El modelo usará validación cruzada para determinar cuál de los parámetros alpha que proporciones es el ideal.

De nuevo, ajusta el modelo, haz predicciones y calcula el error absoluto medio.

Este modelo funcionó un poco mejor, con un error medio de 2,673 victorias.