Explorando o Dataset do Titanic para Machine Learning

Caso não tenha visto a parte 2, recomendo a leitura.

Hoje nós iremos aprender sobre o que é um dataset, que em poucas palavras podemos resumir em um conjunto de dados organizados e estruturados, que contém uma gama de informações relacionado a um determinado domínio ou tema específico. Além disso, faremos a escolha de um modelo que se adeque melhor a resolver o nosso problema.

Dataset Titanic

E para o nosso tutorial de exploração escolhemos o conjunto de dados do Titanic, que é um problema comum de classificação onde desejamos classificar se um indivíduo sobreviveu à catástrofe do navio Titanic com base nas características individuais e da viagem.

Em nosso tutorial usaremos Python com o Google Colab. Caso não saiba o que é o Google Colab eu recomendo este vídeo:

Google Colab

Nosso modelo ao final do tutorial deverá ser capaz de prever se um passageiro sobreviveu ao Titanic a partir das informações sobre ele. A nossa intenção é responder a uma pergunta de classificação, pois faremos uma predição de um rótulo (label) acerca da sobrevivência de uma passageiro. E finalmente seremos capazes de responder se o passageiro conseguiu sobreviver ou infelizmente morreu na tragédia.

Antes de mais nada, você irá precisar da base que iremos utilizar e eu a obtive no desafio do Kaggle: https://www.kaggle.com/c/titanic/data

Lembre-se de subir o arquivo para o Google Colab, ao final você deverá ter algo como isso:

Dataset do titanic

Agora que já possuímos o Dataset podemos então instalar as bibliotecas que serão necessárias para a nossa exploração de dados. Para isso no Colab insira a seguinte lista:

!pip install ipywidgets
!pip install https://github.com/pandas-profiling/pandas-profiling/archive/master.zip
!pip install pyjanitor
!pip install mlxtend
!pip install six

Ao final você deverá ter algo como:

Instalação das bibliotecas

Agora que as bibliotecas estão instaladas vamos então importar tudo o que será necessário para a exploração dos dados, teste do módulo e finalmente a acurácia final do modelo.

Sendo assim, deixe o seu Colab com a seguinte estrutura de importação:

import matplotlib.pyplot as plt
import pandas as pd
from sklearn import (
    ensemble,
    preprocessing,
    tree
)
from sklearn.metrics import (
    auc,
    confusion_matrix,
    roc_auc_score,
    roc_curve
)
from sklearn.model_selection import (
    train_test_split,
    StratifiedKFold
)
from yellowbrick.classifier import (
    ConfusionMatrix,
    ROCAUC
)
from yellowbrick.model_selection import (
    LearningCurve
)

Antes de partir para a exploração dos dados é importante sabermos o que contém no dataset, ou você irá ler em alguma literatura como dicionário dos dados ou do dataset. Segue então uma breve explicação dos dados:

• pclass: Classe do passageiro (1 = primeira, 2 = segunda, 3 = terceira)
• survived: sobreviveu (0 = não, 1 = sim)
• name: Nome do passageiro
• sex: Sexo do passageiro
• age: Idade do passageiro
• sibsp: Número de irmãos/esposa(o) a bordo com o passageiro
• parch: Número de pais/filhos a bordo com o passageiro
• ticket: Número da passagem
• fare: Preço da passagem
• cabin: cabine
• embarked: (Local em que o passageiro embarcou:
• C = Cherbourg
• Q = Queenstown
• S = Southamption
• boat: Bote salva-vidas
• body: Número de identificação do corp
• home.dest: Onde o passageiro morava e o destino que estava indo.

Agora que já entendemos os dados, vamos então criar o nosso DataFrame, caso não saiba o que é um DataFrame é uma estrutura de dados tabular bidimensional em que os dados são organizados em linhas e colunas, podemos até dizer que é semelhante a uma tabela de banco de dados ou uma planilha.

Sendo assim crie mais uma linha no Colab e deixe com a seguinte instrução:

titanic_df = pd.read_csv("titanic.csv", sep=",")
original_df = titanic_df
titanic_df.head()

Ao executar você terá o seguinte resultado:

Resultado do dataframe

Podemos então iniciar a nossa tratativa e antes de mais nada precisamos descobrir os tipos de variáveis que estão contidas em nosso dataset e para isso podemos utilizar o dtypes:

titanic_df.dtypes

Será retornado então os tipos:

Tipos das variáveis

Agora que já sabemos os tipos, vamos então utilizar o pandas_profiling que irá sintetizar os tipos das colunas e permitir que sejamos capazes de visualizar os detalhes estatísticos dos quantis, as estatísticas descritivas e um histograma dos valores comuns. Sendo assim, vamos importar profiling:

from pandas_profiling import ProfileReport

Verificar o total de linhas e colunas do dataset:

titanic_df.shape

Executar a inicialização do ProfileReport:

profile = ProfileReport(titanic_df, title='Titanic', html={'style':{'full_width':True}})

Observe que declaramos a variável profile para que sejamos capazes de utilizar: to_notebook_iframe() que será responsável por devolver o resultado em tela que já veremos a seguir. Para isso então chamaremos a função que irá devolver o nosso resultado esperado:

profile.to_notebook_iframe()

Resultado do to_notebook_iframe()

Como você pode perceber o resultado é bem legal e ajuda e muito em nossa visualização dos dados. O mais importante é que podemos perceber que em nosso dataset existem dados nulos o que não será muito legal para o nosso modelo no final.

Vamos então realizar uma visualização dos dados que estão nulos e para verificá-los, colocaremos em um DataFrame e então exibir o total encontrado e também a proporção de valores nulos. Para isso insira a nova instrução:

titanic_df.isnull().mean(axis=1).loc[:10]

Ao executar essa instrução você terá como retorno o total com uma proporção de valores nulos:

Proporção de nulos

Podemos melhorar ainda mais a visualização dos dados e verificar o total e a proporção de nulos em um DataFrame. Para isso, insira uma nova linha do Colab e insira a seguinte instrução:

titanic_df.isnull() # Aqui verificamos o total de null na base se existir
titanic_df.isnull().sum()/len(titanic_df) # Aqui obtemos a proporção de null se existir

# Criamos um novo DataFrame para verificar o total e a proporção de null na base
pd.DataFrame(zip(titanic_df.isnull().sum(),titanic_df.isnull().sum()/len(titanic_df)), columns=['Count', 'Proportion'], index=titanic_df.columns)

Ao executar podemos perceber que agora a visualização foi melhorada e fica fácil de ver o total e a proporção:

Proporção de nulos

Aqui já podemos chegar a uma conclusão de que será necessário realizar os ajustes nos dados, mas posteriormente resolveremos isso.

Análise descritiva dos dados

Vamos então realizar uma pequena análise em nossos dados. Para isso, crie uma nova linha e então insira a seguinte instrução:

titanic_df.describe().iloc[:, [0,1]]

Ao executar você terá o seguinte resultado:

Resultado da análise descritiva

Vamos executar a mesma instrução na sequência mas arredondando os dados:

titanic_df.describe().round(2).T

Ao executar você terá o seguinte resultado:

Resultado da análise descritiva arredondado

Após a nossa visualização podemos chegar a algumas percepções dos dados:

• A média de sobrevivência atual é de: 0.38
• O desvio padrão é de: 0.49
• O mínimo é de: 0.00

Além disso, podemos verificar também que algumas variáveis provavelmente irão influenciar no modelo, pois estão bem correlacionadas:

• pclass
• fare
• survived
• sex
• boa
• embarked

E a nossa intenção era verificar as variáveis:

• pclass
• survived
• sex — Aqui veja que não é uma variável numérica

Continuando com a nossa exploração dos dados, vamos então remover a coluna body. Nós iremos remover essa coluna que é a identificação do corpo, pois, ela encontra-se ausente em muitas linhas e isso pode causar um problema de vazamento de informação e com isso o nosso modelo poderia usar esse dado para trapacear e acabar respondendo errado a questão de, se o passageiro iria sobreviver ou morrer.

Como nós queremos prever a morte, saber que ele teve um número de identificação de corpo nos levaria a saber, a priori, que ele morreu e como dito antes quebraria a ideia do nosso modelo.

De modo semelhante, a coluna boat(bote salva-vidas) causa vazamento de informação inversa, pois, nesse caso já diria que o passageiro sobreviveu.

Para fazer isso então insira a seguinte instrução:

mask = titanic_df.isnull().any(axis=1)

mask.head()

E você terá como retorno:

Retorno da remoção do nulo

E na sequência:

titanic_df[mask].body.head()

E você terá como retorno:

Exibição dos valores

Nosso tutorial irá parar por aqui para que não fique grande de mais e difícil de acompanhar. Na parte 2 daremos continuidade na limpeza de dados e na preparação do nosso modelo de prever se o passageiro irá sobreviver ou morrer. Por enquanto é isso, um grande abraço!

Python AI