Scikit-Learn Tutorial: Baseball Analytics Pt 1

Importando os dados

Você vai ler os dados consultando um banco sqlite com o pacote sqlite3 e convertendo o resultado em um DataFrame com pandas. Os dados serão filtrados para incluir apenas times modernos atualmente ativos e apenas anos em que o time jogou 150 partidas ou mais.

Primeiro, baixe o arquivo “lahman2016.sqlite” (aqui). Em seguida, carregue o Pandas e renomeie para pd para agilizar o uso. Você deve lembrar que pd é o alias mais comum de Pandas. Por fim, carregue sqlite3 e conecte ao banco assim:

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

Depois, escreva uma query, execute e busque os 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()

Dica: se você quer aprender mais sobre como usar SQL com Python, considere fazer o curso Introduction to Databases in Python da DataCamp.

Usando pandas, então converta os resultados em um DataFrame e imprima as 5 primeiras linhas com o método head():

Cada coluna traz dados de um time em um ano específico. Algumas das variáveis mais importantes estão abaixo. A lista completa pode ser encontrada aqui.

• yearID - Ano
• teamID - Time
• franchID - Franquia (liga com a tabela TeamsFranchise)
• G - Jogos disputados
• W - Vitórias
• LgWin - Campeão da liga (Y ou N)
• WSWin - Campeão da World Series (Y ou N)
• R - Corridas anotadas
• AB - At bats (idas ao bastão)
• H - Rebatidas
• HR - Home runs
• BB - Walks (bases por bolas)
• SO - Strikeouts (eliminações por strike)
• SB - Bases roubadas
• CS - Pego roubando base
• HBP - Rebatedor atingido por arremesso
• SF - Sacrifice flies (bolas de sacrifício)
• RA - Corridas sofridas
• ER - Corridas merecidas permitidas
• ERA - Média de corridas merecidas
• CG - Jogos completos
• SHO - Shutouts (jogos sem sofrer corridas)
• SV - Saves
• IPOuts - Eliminações arremessadas (innings arremessados x 3)
• HA - Rebatidas permitidas
• HRA - Home runs sofridos
• BBA - Walks permitidos
• SOA - Strikeouts dos arremessadores
• E - Erros
• DP - Double plays
• FP - Fielding percentage (aproveitamento defensivo)
• name - Nome completo do time

Se você não está tão familiarizado com beisebol, aqui vai um resumo de como o jogo funciona, incluindo algumas das variáveis.

O beisebol é jogado entre dois times (que você verá nos dados por name ou teamID) com nove jogadores cada. As equipes se revezam atacando (rebater) e defendendo (campo). O time ao bastão tenta marcar corridas rebatendo a bola arremessada pelo pitcher do time de defesa e correndo, em sentido anti-horário, pelas quatro bases: primeira, segunda, terceira e home plate. A equipe de defesa tenta evitar corridas eliminando rebatedores ou corredores de base de várias maneiras, e uma corrida (R) é anotada quando um jogador completa o circuito e retorna ao home plate. Um jogador que chega em base com segurança tentará avançar nas rebatidas dos colegas, como em uma rebatida (H), roubo de base (SB) ou por outros meios.

Os times trocam ataque e defesa sempre que a equipe de campo registra três eliminações (outs). Um turno de ataque para cada time, começando pelo visitante, constitui uma entrada (inning). Um jogo tem nove entradas e vence quem tiver mais corridas ao final. O beisebol não tem cronômetro e, embora a maioria dos jogos termine na nona entrada, se houver empate após nove, o jogo vai para entradas extras e continua indefinidamente até que um time esteja à frente ao final de uma entrada extra.

Para uma explicação detalhada das regras, confira as regras oficiais da Major League Baseball.

Limpando e preparando os dados

Como você viu acima, o DataFrame não tem cabeçalhos de coluna. Você pode adicioná-los passando uma lista de nomes para o atributo columns do pandas.

A função len() mostra quantas linhas você tem: 2.287 não é um volume tão grande assim, então torcemos para não haver muitos valores ausentes.

Antes de avaliar a qualidade dos dados, vamos eliminar colunas desnecessárias ou derivadas da variável alvo (Wins). Aqui, o conhecimento do domínio faz muita diferença. Não adianta saber muito de código ou estatística se você não entende os dados com que trabalha. Ser fã de beisebol a vida toda certamente me ajudou neste projeto.

Como você leu acima, valores nulos afetam a qualidade dos dados e podem causar problemas em algoritmos de machine learning.

Por isso, vamos removê-los em seguida. Há várias formas de eliminar valores nulos, mas primeiro é uma boa ideia exibir a contagem de nulos por coluna para decidir a melhor estratégia.

E aqui aparece um trade-off: você precisa de dados limpos, mas não tem tanto volume para desperdiçar. Duas colunas têm poucos nulos: são 110 em SO (strikeouts) e 22 em DP (double plays). Outras duas têm muitos nulos: 419 em CS (pego roubando) e 1777 em HBP (rebatedor atingido por arremesso).

Se você eliminar as linhas com poucos nulos, perde pouco mais de 5% dos dados. Como estamos prevendo vitórias, corridas anotadas e corridas sofridas são altamente correlacionadas com o alvo. Queremos esses dados bem precisos.

Strikeouts (SO) e double plays (DP) não são tão críticos.

É melhor manter as linhas e preencher os nulos com a mediana de cada coluna usando fillna(). Já CS e HBP também não são tão importantes e têm nulos demais; o melhor é remover essas colunas.

Explorando e visualizando os dados

Agora que você limpou os dados, dá para explorar um pouco. Algumas visualizações simples já ajudam a entender melhor o conjunto. O matplotlib é uma ótima biblioteca para visualização.

Importe matplotlib.pyplot e renomeie como plt para agilizar. Se você estiver em um notebook Jupyter, use o magic %matplotlib inline.

Comece plotando um histograma da coluna alvo para ver a distribuição de vitórias.

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

Observe que, se você não estiver usando um Jupyter notebook, precisa usar plt.show() para exibir os gráficos.

Imprima a média de vitórias (W) por ano. Você pode usar o método mean().

Ao explorar, pode ser útil criar faixas (bins) para a coluna alvo, mas não inclua nenhuma feature gerada a partir da coluna alvo quando for treinar o modelo. Incluir no treino uma coluna de rótulos derivada do alvo seria como dar as respostas da prova para o modelo.

Para criar seus rótulos de vitórias, crie uma função assign_win_bins que recebe um inteiro (vitórias) e retorna um inteiro de 1 a 5 conforme o valor.

Depois, crie a coluna win_bins aplicando apply() sobre a coluna de vitórias e passando a função assign_win_bins().

Agora vamos fazer um gráfico de dispersão com o ano no eixo x e vitórias no eixo y, colorindo pela coluna 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 dá para ver no gráfico, há poucas temporadas antes de 1900 e o jogo era bem diferente. Por isso, faz sentido eliminar essas linhas do conjunto.

Ao lidar com dados contínuos e criar modelos lineares, valores inteiros como o ano podem trazer ruído. É improvável que “1950” tenha um relacionamento linear simples com o resto dos dados como o modelo inferiria.

Você pode evitar isso criando novas variáveis que rotulem os dados com base no yearID.

Quem acompanha beisebol sabe que, conforme a MLB evoluiu, surgiram “eras” em que a média de corridas por jogo aumentou ou diminuiu bastante. A “dead ball era” do início dos anos 1900 foi de poucos pontos; a “steroid era” na virada do século XXI teve muitas corridas.

Vamos fazer um gráfico que indique o nível de pontuação em cada ano.

Comece criando os dicionários runs_per_year e games_per_year. Percorra o dataframe com iterrows(). Preencha runs_per_year com anos como chaves e o total de corridas anotadas no ano. Preencha games_per_year com anos e o total de jogos disputados naquele ano.

Depois, crie o dicionário mlb_runs_per_game. Percorra games_per_year com items(). Preencha mlb_runs_per_game com anos como chaves e o número de corridas por jogo (na liga toda) como valor.

Por fim, crie o gráfico a partir de mlb_runs_per_game, com anos no eixo x e corridas por jogo no eixo 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()

Adicionando novas features

Agora que você entendeu melhor as tendências de pontuação, pode criar novas variáveis que indiquem a “era” à qual cada linha pertence com base no yearID. Vamos seguir a mesma lógica da criação de win_bins.

Desta vez, vamos criar colunas dummies, uma por era. Você pode usar get_dummies().

Como você já calculou as corridas por jogo da MLB por ano, adicione essa informação ao conjunto.

Agora, converta os anos em décadas criando colunas dummies por década. Depois, remova as colunas que não precisa mais.

Em beisebol, o que decide é quantas corridas você marca e quantas permite. Você pode aumentar bastante a acurácia criando colunas que são razões de outras colunas. Corridas por jogo e corridas sofridas por jogo serão ótimas features para adicionar.

Com o Pandas, isso é simples: crie uma nova coluna dividindo R por G para obter R_per_game.

Agora veja como essas duas novas variáveis se relacionam com a coluna de vitórias fazendo dois gráficos de dispersão. Coloque corridas por jogo no eixo x de um gráfico e corridas sofridas por jogo no eixo x do outro. Em ambos, use W no eixo 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 partir para modelos de machine learning, é útil ver como cada variável se correlaciona com o alvo. O Pandas facilita isso com corr().

Outra feature que você pode adicionar são rótulos derivados de um algoritmo de clusterização K-means do sklearn. K-means é um algoritmo simples que particiona os dados em k centróides indicados. Cada ponto é atribuído ao cluster cujo centróide tem a menor distância euclidiana a ele.

Saiba mais sobre K-means aqui.

Primeiro, crie um DataFrame sem a variável alvo:

Um ponto a definir antes de usar K-means é a quantidade de clusters. Você pode ter uma noção melhor usando a função silhouette_score() do sklearn. Ela retorna o coeficiente de silhueta médio. Quanto maior, melhor — a medida tende a cair conforme você aumenta o número de clusters.

Agora você pode inicializar o modelo. Defina 6 clusters e random state como 1. Calcule as distâncias euclidianas de cada ponto com fit_transform() e visualize os clusters com um 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()

Agora adicione os rótulos dos clusters ao conjunto como uma nova coluna. Também inclua a string “labels” na lista attributes para uso posterior.

Antes de construir o modelo, separe os dados em treino e teste. Se você treinar e testar no mesmo conjunto, o modelo pode decorar os dados e superajustar, o que degrada o desempenho em dados novos.

Sem estresse: há várias formas de fazer cross-validation.

Aqui, vamos amostrar aleatoriamente 75% para train e usar os 25% restantes como test. Crie a lista numeric_cols com todas as colunas usadas no modelo. Depois, crie o DataFrame data a partir de df com essas colunas. Em seguida, gere os conjuntos train e test amostrando o DataFrame data.

Escolhendo métrica de erro e modelo

A métrica que usaremos para avaliar o modelo é o Mean Absolute Error (MAE). Ela mede o quão próximas as previsões ficam dos resultados. Neste caso, indica o valor absoluto médio pelo qual sua previsão errou o alvo.

Ou seja, se em média suas previsões erram por 5 vitórias, sua métrica será 5.

O primeiro modelo será uma regressão linear. Você pode importar LinearRegression e mean_absolute_error de sklearn.linear_model e sklearn.metrics, respectivamente, criar o modelo lr, ajustar, prever e calcular o MAE.

Se você recall from above, the average number of wins was about 79 wins. On average, the model is off by only 2.687 wins.

Now try a Ridge regression model. Import RidgeCV from sklearn.linear_model and create model rrm. The RidgeCV model allows you to set the alpha parameter, which is a complexity parameter that controls the amount of shrinkage (read more here). The model will use cross-validation to deterime which of the alpha parameters you provide is ideal.

Again, fit your model, make predictions and determine the mean absolute error.

This model performed slightly better, and is off by 2.673 wins, on average.