Primeiros passos com Kaggle: Participando da sua primeira competição

Lucas Oliveira
Dec 23, 2018 · 12 min read
Fonte: https://www.kaggle.com

Provavelmente você já deve ter ouvido falar das competições de Machine Learning do Kaggle ou ter usado algum dataset disponibilizado pela plataforma.

Não se preocupe se você nunca ouviu falar. Vamos explicar tudo por aqui!

O que é?

Kaggle é a maior plataforma de hospedagem para projetos e competições de Data Science que existe atualmente. Kaggle disponibiliza datasets, kernels, plataforma de aprendizado e fórum para perguntas.

Como funciona?

A plataforma permite que você participe de competições abordando variados temas. Algumas competições são oferecidas por grandes empresas que pagam recompensas em dinheiro para a melhor solução. Caso você queira apenas treinar suas habilidades, existem as competições de aprendizado oferecidas pela própria plataforma. Além disso, você pode utilizar diversos dataset e criar kernels a partir deles.

Antes de abordamos as competições, é necessário o entendimento de alguns conceitos.

O que são kernels?

Kernel é uma exposição do seu código publicado na plataforma. Pense no kernel como uma versão do Jupyter Notebook. É apenas um jeito interativo de compartilhamento e visualização do seu código.

Fonte: https://www.kaggle.com/kernels

Podemos encontrar diversos kernels na plataforma. Cada kernel possui uma análise sobre um dataset.

Onde encontrar um dataset?

A plataforma oferece datasets sobre diferentes temas que servem para aprendizado e treinamento. São encontrados na aba “Datasets”. Perceba que são classificados pelos votos e podem ser utilizados a qualquer momento.

São disponibilizados em vários tipos de arquivos (CSV, JSON, Big Query e Others).

Fonte: https://www.kaggle.com/datasets

Plataforma de aprendizado

A plataforma de aprendizado, contém cursos rápidos para você dominar o básico e se preparar para uma competição. Todos os cursos são livres, com exercícios práticos e são produzidos diretamente em kernels, assim é possível interagir com o conteúdo.

Os cursos oferecidos não vão te tornar um expert no assunto, eles apresentam apenas o básico. Com o básico que você aprende, é possível alcançar os próximos níveis de conhecimento e aplicar o que você aprendeu em casos reais.

Fonte: https://www.kaggle.com/learn/overview

Porque utilizar o Kaggle?

A melhor maneira de aprender é praticando!

“Aquilo que escuto eu esqueço, aquilo que vejo eu lembro, aquilo que faço eu entendo.”

- Confúcio

Kaggle oferece a oportunidade de você colocar a mão na massa em projetos reais. São mais de 300 competições disponíveis. Quando preciso verificar um modelo de Machine Learning, posso recorrer a algum livro ou simplesmente ir no Kaggle e verificar como se aplica o modelo na prática.

Quando o problema que você está lidando é real, você vai tentar encontrar a melhor solução e isso garante uma motivação para aprender.

Como participar de uma competição?

Agora que você já sabe o básico da plataforma, vamos nos preparar para participar de uma competição. Realmente parece intimidador no começo, mas não fique assustado, depois da sua primeira competição, as outras serão mais fáceis.

Vamos seguir alguns passos antes de começar o nosso desafio.

1º Passo - Escolha a sua linguagem

Fonte: http://houseofbots.com/news-detail/916-4-machine-learning-showdown:-python-vs-r

As competições são feitas utilizando as linguagens Python e R. Então fique a vontade para usar a linguagem que você mais domina.

2º Passo - Encontre uma competição

Parece óbvio esse passo, mas escolher a competição certa para começar é essencial, isso evita que você comece uma competição e largue ela pela metade.

Nesse quesito, Titanic: Machine Learning from Disaster é uma ótima escolha para quem está iniciando. A competição conta com uma tarefa de Machine Learning supervisionada para prever quais passageiros tem chances de sobreviver ao desastre.

Fonte: https://www.kaggle.com/c/titanic

3º Passo - Compreenda o dataset

Esse é um dos passos mais importantes, pois é a partir do dataset que vamos tirar nossas análises.

Na aba “Data”, temos as descrições das informações que iremos utilizar.

4º Passo - Aprenda com a comunidade

Acredite, os kernels são seus melhores amigos.

Eles te ajudam a entender o contexto geral da análise e mostram abordagens que outras pessoas utilizaram.

Na maioria das vezes, você vai encontrar termos que são desconhecidos. Aproveite e aprenda a aplicação de cada um.

Simples abordagem de Machine Learning

Machine Learning é um método de aprendizado de máquina que automatiza a construção de modelos analíticos. Baseia-se em ensinar máquinas através de modelos de algoritmos.

Pode ser divididos em três modelos de aplicação:

  • Aprendizagem supervisionada;
  • Aprendizagem não supervisionada;
  • Aprendizagem por reforço.

Vamos recorrer ao clássico caso do naufrágio do Titanic. Com modelos supervisionados, é possível prever quais passageiros tem mais chances de sobreviver. O modelo toma como base algumas variáveis, como, classe, sexo, idade, número de filhos e etc.

Com a aprendizagem não supervisionados, temos pouca ideia do resultado. Nesse contexto, utilizamos estruturas de dados que não sabemos realmente o efeito das variáveis.

Já a aprendizagem por reforço, se baseia em observar o contexto e selecionar a melhor ação para aquela situação. Em troca, o sistema recebe uma premiação, caso contrário, recebe uma penalidade. O aprendizado por reforço busca a melhor estratégia de acordo com a sua política.

Algoritmos de aprendizado

Existem diversos algoritmos de Machine Learning.

  • Regressão Linear: É a melhor forma de descrever a relação entre duas variáveis. Tem como objetivo traçar um valor que não é possível estimar inicialmente. Faz parte do aprendizado supervisionado. O objetivo da regressão linear é encontrar a equação que ajuste a melhor linha para modelar os dados;
  • Clustering: Conhecido também como análise de agrupamento, consiste em agrupar cada ponto do conjunto de dados em um grupo específico. Os dados que são agrupados juntos compartilham uma semelhança entre si. Clustering é um exemplo de método de aprendizado não supervisionado;
  • Q-learning: É o método mais popular de aprendizado por reforço. Permite estabelecer uma política de ações de forma interativa e mostrar qual comportamento tomar em determinadas circunstâncias.

Abordamos um tipo de algoritmo respectivo a cada modelo de aplicação. Não vamos abordar todos, pois são muitos. Sugiro que pesquise outros algoritmos e suas devidas aplicações.


Entrando na competição

Agora que você já se preparou para o desafio, essa é a hora de entrarmos de vez na competição.

Existem diversos jeitos para resolver essa competição. Vamos resolver de uma forma bem simples e didática.

Conhecendo nossos dados

Conhecer e saber lidar com os dados é um dos passos mais importantes em qualquer análise. Sem o prévio conhecimento das informações, não é possível tirar conclusões ou realizar a manipulação dos dados.

Sendo assim, vamos conhecer as colunas do dataset.

PassengerId: Id do passageiro;

Survived: Composto por 0 e 1, informa se o passageiro sobreviveu ao desastre. O valor 0 é indicado para aqueles que não sobreviveram e o valor 1 para aqueles que sobreviveram;

Pclass: Classe na qual o passageiro estava, temos três valores de classe, 1, 2 e 3;

Name: Nome do passageiro;

Sex: Sexo do passageiro;

Age: Idade do passageiro;

Sibsp: Número de irmãos / cônjuges a bordo;

Parch: Número de pais / filhos a bordo;

Ticket: Número da passagem;

Fare: Preço pago na passagem;

Cabin: Número da cabine;

Embarked: Informa de qual porto o passageiro embarcou. “S” significa Southampton, “C” é referente a Cherbourg e “Q” para Queenstown.

Configurações iniciais

Recomendo a utilização do Jupyter Notebook para os próximos passos.

Primeiro, vamos importar algumas bibliotecas que serão usadas.

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

Nessa competição, train.csv e test.csv vão ser os arquivos que vamos usar. Basicamente um contém os dados que serão utilizados para treino, enquanto que o outro possui os dados para teste.

Você pode fazer o download dos arquivos na aba “Data”.

train = pd.read_csv('train.csv')
test = pd.read_csv('test.csv')

Vamos verificar uma amostra dos nossos dados de treino.

train.sample(5)
Simples amostra

Visualização dos dados

Nesse ponto, temos que tirar algumas conclusões do nosso dataset a partir da visualização dos dados.

Podemos ver a correlação das variáveis com um mapa de calor.

plt.figure(figsize=(10,10))
sns.heatmap(train.corr(), annot=True, cmap="Blues")
Mapa de calor mostrando as correlações

Conseguimos plotar um gráfico para mostrar a relação de sobreviventes com a coluna sexo.

plt.figure(figsize=(9,6))
sns.barplot(x='Sex',y='Survived',data=train)
Relação de sobreviventes pelo sexo.

É notável que temos mais sobreviventes do sexo feminino.

É possível também ver a relação entre a classe e os sobreviventes.

plt.figure(figsize=(9,6))
sns.barplot(x='Pclass', y='Survived', data=train)
Relação entre sobreviventes e a classe

Pode ser observado que os passageiros que pertencem a primeira e segunda classe tiveram mais chance de sobreviver, comparado com quem estava na terceira classe.

Removendo dados irrelevantes

Observando a correlação, podemos perceber que as variáveis Name, Ticket e Cabin não estão no mapa de calor, pois são variáveis do tipo object e não possuem relação com as outras entradas.

Além disso, vamos remover esses valores, pois não serão relevantes para nosso modelo de Machine Learning.

train.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)
test.drop(['Name', 'Ticket', 'Cabin'], axis=1, inplace=True)

Todas as alterações que fizermos no dataset de treino, terão que ser aplicadas no dataset de teste.

Limpeza dos dados

Algoritmos de Machine Learning não conseguem trabalhar com valores nulos e caso haja, o modelo poderá apresentar erro.

Com o método isnull() conseguimos verificar em quais colunas temos valores ausentes.

train.isnull().sum()
Valores nulos

Veja que na coluna Age e Embarked tem valores nulos. Podemos tratar esses valores de duas formas. Excluindo as linhas ou preenchendo com a média, mediana ou moda.

Para não perdermos todas essas linhas, vamos preencher os valores nulos com a mediana. A biblioteca Scikit-Learn possui uma classe Imputer para tratarmos valores esses valores.

Primeiro, é necessário importar a classe, logo em seguida, vamos criar uma instância de Imputer e especificar que queremos preencher os valores com a mediana.

from sklearn.preprocessing import Imputerimputer = Imputer(strategy="median")

A mediana apenas pode ser aplicada em valores numéricos, portanto, temos que separar do dataset as colunas que não são numéricas.

train_numerico = train.drop(['Sex','Embarked'], axis=1)
test_numerico = test.drop(['Sex','Embarked'], axis=1)

Agora, nós podemos aplicar o método fit() .

imputer.fit(train_numerico)

Como já temos o Imputer preparado, podemos preencher os valores que estão nulos.

train_no_null = imputer.transform(train_numerico)

Faça o mesmo passo com o dataset de treino.

imputer.fit(test_numerico)test_no_null = imputer.transform(test_numerico)

imputer.transform() devolve um array NumPy com as colunas modificadas.

Temos que transformar isso em um DataFrame.

train_tr = pd.DataFrame(train_no_null, columns=train_numerico.columns)test_tr = pd.DataFrame(test_no_null, columns=test_numerico.columns)

Podemos verificar novamente se temos algum valor nulo no dataset de treino.

Não temos mais valores nulos

Manipulando valores categóricos

Acima, nós removemos as colunas Sex e Embarked, pois são valores categóricos, consequentemente não é possível calcular a sua mediana.

A maioria dos algoritmos de Machine Learning preferem trabalhar com valores numéricos. Em vista disso, vamos converter os valores categóricos em numéricos utilizando a técnica One Hot Encoding.

A arte de transformar texto em números

One Hot Encoding é o processo pelo qual variáveis categóricas são convertidas em uma forma que o algoritmo de Machine Learning possa interpretar.

Algoritmos trabalham melhor com números.

Veja abaixo o exemplo, temos alguns valores categóricos que são transformados em valores numéricos, utilizando One Hot Encoding.

Fonte: https://www.kaggle.com/learn-forum/50008

Perceba que, a tabela da direita mostra quando cada elemento aparece. Red aparece nas primeiras duas linhas da coluna da esquerda, portanto foi criado uma coluna Red na tabela da direita em que as duas primeiras linhas estão preenchidas com o número 1. O mesmo caso se aplica aos demais valores.

Tendo isso em mente, vamos aplicar essa técnica no nosso dataset.

Será necessário selecionar as colunas categóricas.

train_cat = train[['Sex', 'Embarked']]
test_cat = test[['Sex', 'Embarked']]

Vamos utilizar o método get_dummies() da biblioteca Pandas que pode nos ajudar nessa tarefa.

train_cat_encoded = pd.get_dummies(train_cat)
test_cat_encoded = pd.get_dummies(test_cat)

Vamos ver como ficou nossos dados após a utilização do One Hot Encoding.

train_cat_encoded.head()

Juntado os dados

Lembra-se que separamos nossos dados numéricos quando tivemos que tratar os valores nulos e separamos acima os valores que são categóricos?

Nesse ponto, temos dois dataset:

  • train.tr: Contém os valores numéricos;
  • train.cat: Contém os valores categóricos;

O mesmo se aplica ao dataset de teste.

Precisamos juntar esses dois DataFrames para executarmos nosso algoritmo.

O método para concatenação que irei utilizar será o join() .

new_train = train_tr.join(train_cat_encoded)
new_test = test_tr.join(test_cat_encoded)

Finalmente, nossos dados de treino e de teste estão prontos para serem usados.

Aplicando um algoritmo de Machine Learning

Acredito que essa é a hora mais esperada, iremos aplicar um modelo de Machine Learning na prática!

Escolher qual algoritmo apresentaria um melhor resultado pode ser uma tarefa difícil no começo. Mas não se preocupe, temos recursos para fazer isso.

Existem diversos algoritmos que poderíamos estar utilizando. Para fins didáticos, eu separei dois para podermos analisar a eficácia de cada um e saber realmente qual será escolhido.

Executaremos os testes nos seguintes algoritmos:

Esses algoritmos são modelos supervisionados de Machine Leaning, e são ótimos para encontrarmos relações entre as variáveis.

Há diversas maneiras para medirmos a eficácia de nosso modelo. Vamos utilizar a accuracy_score, que pode ser obtida com sklearn.metrics. Essa é a métrica mais comum para classificação.

Nós vamos ajustar nossos dados de teste em 20% para testar a acurácia dos diferentes modelos.

from sklearn.model_selection import train_test_split

predictors = new_train.drop(['Survived', 'PassengerId'], axis=1)
target = train["Survived"]
x_train, x_val, y_train, y_val = train_test_split(predictors, target, test_size = 0.2, random_state = 0)

Separamos na variável predictors apenas os dados dos passageiros e na variável target os valores que queremos prever. O método train_test_split realiza a divisão dos dados. O parâmetro test_size=0.2 indica a porcentagem que a os dados devem ser separados para teste. Geralmente é em torno de 80% para treino e 20% para teste.

Começando pela Árvore de Decisão, conseguimos calcular sua acurácia da seguinte forma.

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
decisiontree = DecisionTreeClassifier()
decisiontree.fit(x_train, y_train)
y_pred = decisiontree.predict(x_val)
acc_decisiontree = round(accuracy_score(y_pred, y_val) * 100, 2)
print(acc_decisiontree)

O código utiliza a classe DecisionTreeClassifier que nos possibilitará aplicar o algoritmo de Árvore de Decisão e accuracy_score que será responsável por calcular a precisão do nosso modelo.

Após executar o código, eu obtive o valor 78.77%.

Vamos agora realizar o mesmo procedimento com o Algoritmo de Aumento de Gradiente.

from sklearn.ensemble import GradientBoostingClassifiergbk = GradientBoostingClassifier()
gbk.fit(x_train, y_train)
y_pred = gbk.predict(x_val)
acc_gbk = round(accuracy_score(y_pred, y_val) * 100, 2)
print(acc_gbk)

Utilizando esse algoritmo, eu obtive o valor de 84.36%.

Portanto, com os resultados de precisão obtidos, a melhor opção é utilizar o Algoritmo de Aumente de Gradiente.

Vamos criar uma variável predictions e atribuir a ela as predições do nosso modelo utilizando o gbk.predict(). É importante salvarmos os valores da coluna PassengerId para montarmos nosso arquivo de submissão que será enviado para o Kaggle.

ids = test['PassengerId']
predictions = gbk.predict(new_test.drop('PassengerId', axis=1))

Com tudo preparado, essa é a hora de criarmos nosso arquivo submission.csv, que conterá o resultado final do nosso modelo.

submission = pd.DataFrame({ 'PassengerId' : ids, 'Survived': predictions.astype('int64') })
submission.to_csv('submission.csv', index=False)

Enviando sua previsão para o Kaggle

Na aba “Overview” da competição, está informando que temos que submeter um arquivo do tipo .csv (Exatamente como fizemos acima) com 418 entradas.

O Kaggle fornece um jeito fácil para enviar os arquivos. Basta clicar em “Submit Predictions”.

Logo em seguida, clique em “Upload Files”.

Por fim, após o arquivo ser carregado, clique em “Make Submission”.

Excelente! Você acabou de participar da sua primeira competição no Kaggle. O Kaggle calcula a sua posição e mostra sua colocação no ranking.

Ficamos com scored de 0.77990, nada mal para nossa primeira competição.

Ranking

A partir de agora, você já está apito a aceitar os próximos desafios. Aproveite para treinar outros algoritmos e obter um resultado melhor.

Caso tenha ficado alguma dúvida ou tenha alguma sugestão, coloque nos comentários.

Até a próxima!