Conhecendo a validação cruzada

Estou estudando aprendizado de máquina e, para isso, criei um algoritmo que tenta predizer quais times de futebol podem ganhar na rodada.

O algoritmo utiliza de quatro perguntas:

• O time joga em casa?
• Teve algum jogador expulso?
• Está perto da zona de rebaixamento?
• O time ganhou?

Para treinar o algoritmo, eu utilizei dados de diversos times, vindos de um arquivo CSV. No arquivo, esses dados estão agrupados dessa forma:

casa,expulso,rebaixamento,ganhou
1, 0, 0, 1
1, 1, 0, 0
0, 0, 1, 1
1, 1, 0, 1
1, 0, 0, 0
1, 0, 1, 1
.
.
.

Respondemos as perguntas com os números 1 para sim e 0 para não. Por exemplo, o primeiro time jogou em casa, não teve jogador expulso nem está perto da zona de rebaixamento, e ganhou o último jogo. Enquanto o segundo time jogou em casa e teve um jogador expulso, ele não está perto da zona de rebaixamento nem ganhou o último jogo.

Já temos alguns dados disponíveis para serem usados, portanto, vamos começar a treinar nosso algoritmo!

Treinando a máquina

O Python é uma linguagem muito utilizada para análise de dados e aprendizagem de máquina,por isso, vamos utilizá-la para criar nossos modelos.

Nosso algoritmo precisa conhecer nossos dados para começar a "adivinhar" os resultados. Esses dados estão salvos em um arquivo CSV, onde cada linha representa um dado sobre um jogo de um time.

Para treinar nosso algoritmo, antes precisamos abrir esse arquivo. Vou utilizar o Pandas para conseguir abrir o CSV no Python.

O Pandas lê o nosso arquivo CSV e nos retorna um objeto com nossos dados agrupados como se fossem uma tabela, esse objeto é conhecido como um data frame.

Esse data frame tem todos os nossos dados. Contudo, nós temos dois tipos de dados diferentes, os dados que o algoritmo usa para chegar aos resultados - se o time joga em casa, por exemplo - e as marcações - se o time ganhou.

import pandas as pd
dados = pd.read_csv('futebol.csv')
variaveis = dados[['casa', 'expulso', 'rebaixamento']]
marcacoes = dados['ganhou']

Bacana! Já temos nossos dados e marcações separados, agora podemos treinar nosso modelo.

Mas como o nosso algoritmo vai conseguir classificar os jogos?

Existem vários algoritmos para o aprendizado de máquinas, um bem conhecido é o Naive Bayes. Com esse algoritmo, vamos conseguir classificar se um time vai ganhar ou não dependendo das variáveis como se ele joga em casa ou não.

Na biblioteca Scikit-learn temos algumas implementações do algoritmo Naive Bayes. Podemos falar para o Python importar do módulo naive_bayes da Scikit-learn (naive_bayes) o algoritmo MultinomialNB, que é uma das implementações do algoritmo Bayesiano.

# restante do código
from sklearn.naive_bayes import MultinomialNB
modelo = MultinomialNB()

Criamos nosso modelo, precisamos treiná-lo agora. Mas se nós usamos todos os dados para treinar o nosso modelo, como podemos validar depois?

Dividir e treinar

Se nós utilizarmos todos os nossos dados para treinamento, não conseguiremos validar o nosso algoritmo. Quer dizer, até conseguimos utilizar os mesmos dados para testar o aprendizado, mas o algoritmo já os conhecerá, ou seja, não teremos um cenário "desconhecido" para realizar o teste.

Pensando nisso, o que podemos fazer é separar uma parte dos nossos dados em dados de treino e dados de teste:

# restante do código
tamanho_de_treino = int(len(X) * 0.75)
variaveis_treino = variaveis[:tamanho_de_treino]
marcacoes_treino = marcacoes[:tamanho_de_treino]
variaveis_teste = variaveis[tamanho_de_treino:]
marcacoes_teste = marcacoes[tamanho_de_treino:]

Agora basta falar para o nosso algoritmo treinar (fit) utilizando nossos dados de treino:

# restante do código
modelo.fit(variaveis_treino, marcacoes_treino)

Podemos pedir para o modelo predizer o resultado do conjunto de teste e, com base nas nossas marcações, validar o tanto que o nosso algoritmo acertou:

# restante do código
diferencas = resultado == marcacoes_teste
media_de_acerto = sum(diferencas) / len(marcacoes_teste)
print(media_de_acerto) # 0.6666666666666666

Rodando esse código, vemos que nosso algoritmo acertou cerca de 66% das vezes, bacana, mas, o que acontece se mudarmos o valor do nosso tamanho de treino para que nosso algoritmo tenha menos dados para treinar?

# restante do código
tamanho_de_treino = int(len(X) * 0.7)
# restante do código

Mudando o nosso tamanho de treino, o nosso algoritmo acerta agora em cerca de 65.9% das vezes. Mesmo não sendo um valor tão distante um do outro, são valores diferentes. O que acontece se aumentarmos um pouco o tamanho de treino?

# restante do código
tamanho_de_treino = int(len(X) * 0.9)
# restante do código

Neste caso, o nosso modelo acertou em cerca de 60% dos casos. Um valor já bem diferente dos outros dois, por que isso aconteceu?

Combinando os dados

O que acontece se o nosso primeiro time, que está sendo utilizado no treinamento, for para a última posição do nosso conjunto? Neste caso, o algoritmo teve uma taxa de acerto de 61.46%.

Alterando a posição do elemento, temos um conjunto com dados completamente diferentes. Isso ocorre pois prendemos o algoritmo na sequência que os dados foram apresentados, isto é, a posição de cada elemento importa para o resultado do algoritmo. É por isso que quando alteramos o tamanho de treino o nosso algoritmo muda o resultado também. O que podemos fazer para evitar isso?

O que podemos fazer é separar uma parte dos dados para treino e teste criando várias combinações diferentes. Dessa forma cada combinação nos daria um resultado e, com esse resultado, veríamos o quão bom foi o nosso algoritmo.

Por exemplo, vamos supor que temos dez dados em todo o nosso conjunto. Podemos pegar os dados de um a oito e treinar o algoritmo e utilizar os dados nove e dez para testá-lo. Depois podemos pegar os dados de três a dez e utilizá-los para o treino, e então pegar os dados um e dois e testar nosso algoritmo com eles.

Dessa maneira, podemos fazer k combinações cruzando o nosso conjunto de dados. Cada um dos cruzamentos, nos retorna um valor que é a taxa de acerto daquela combinação.

Assim validamos nossos dados cruzando várias combinações possíveis. O nome dessa técnica em aprendizado de máquina é validação cruzada, ou em inglês cross validation.

Podemos pedir para o Python importar da biblioteca Scikit-learn do módulo de seleção de modelos (model_selection) a função de cruzamento de valores (cross_val_score).

Passamos como parâmetro dessa função o nosso modelo, e os valores dos nossos dados para treino, também precisamos falar quantas combinações (cv) queremos que ela faça:

# restante do código
from sklearn.model_selection import cross_val_score
medias = cross_val_score(modelo, X_teste, y_teste, cv=5)

Essa função nos retorna um vetor com as taxas de acerto de cada combinação. Nós podemos tirar uma média geral somando esses valores e dividindo pelo tamanho do vetor:

# restante do código
from sklearn.model_selection import cross_val_score
medias = cross_val_score(modelo, X_teste, y_teste, cv=5)
media = sum(medias) / len(medias)

Agora temos uma média de como o algoritmo MultinomialNB trabalha no nosso conjunto de dados, que no caso é 60%. Podemos utilizar essa mesma técnica em outros algoritmos e decidir qual o melhor modelo para o nosso conjunto de dados e validá-lo com o nosso conjunto de testes.

Para saber mais

Essa técnica de validação cruzada que utilizamos é chamada de K-fold. Ela é uma técnica muito utilizada em aprendizado de máquina, pois nos permite testar em vários cenários os nossos algoritmos antes de colocá-los em produção.

Além do algoritmo de Naive Bayes, existem diversos outros algoritmos que podemos usar para ensinar a máquina.

Aqui na Alura, temos uma formação em Machine Learning. Nela, você aprenderá sobre estatística, sobre como funciona um algoritmo de classificação. Aprenderá a classificar e-mails, a dizer se um usuário comprará ou não um produto. Verá como criar um sistema de recomendação, e até chatbots.