Exercício – Criar modelo de machine learning

15 minutos

Para criar um modelo de machine learning, você precisa de dois conjuntos de dados: um para treinamento e outro para teste. Na prática, você geralmente tem apenas um conjunto de dados, então você o divide em dois. Neste exercício, você executará uma divisão de 80-20% no DataFrame que você preparou no laboratório anterior, de modo que você possa usá-lo para treinar um modelo de machine learning. Você também vai separar o DataFrame em colunas de recursos e colunas de rótulo. As primeiras incluem as colunas usadas como entrada para o modelo (por exemplo, origem e destino do voo e a hora de partida agendada), enquanto a segunda contém a coluna que o modelo tentará prever — neste caso, a coluna ARR_DEL15, que indica se um voo chegará no horário.

Mude de volta para o Azure Notebook que você criou na seção anterior. Se você fechou o notebook, poderá entrar novamente no portal do Microsoft Azure Notebooks, abrir o notebook e usar o Célula – >Executar Tudo para executar novamente todas as células no notebook depois de abri-lo.
Insira e execute as instruções a seguir em uma nova célula no final do notebook:
```
from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(df.drop('ARR_DEL15', axis=1), df['ARR_DEL15'], test_size=0.2, random_state=42)
```
A primeira instrução importa a função auxiliar train_test_split do Scikit-learn. A segunda linha usa a função para dividir o DataFrame em um conjunto de treinamento que contém a 80% dos dados originais e um conjunto de teste que contém os 20% restantes. O parâmetro random_state propaga o gerador de número aleatório usado para fazer a divisão, enquanto o primeiro e o segundo parâmetros são DataFrames que contêm as colunas de recurso e a coluna de rótulo.
train_test_split retorna quatro DataFrames. Use o comando a seguir para exibir o número de linhas e colunas no DataFrame que contém as colunas de recurso usadas para treinamento:
```
train_x.shape
```
Agora use este comando a seguir para exibir o número de linhas e colunas no DataFrame que contém as colunas de recurso usadas para teste:
```
test_x.shape
```
Como as duas saídas diferem entre si e por quê?

Você pode prever o que você veria se você chamasse shape nos outros dois DataFrames, train_y e test_y? Se você não tem certeza, experimente e descubra.

Há muitos tipos de modelos de machine learning. Um dos mais comuns é o modelo de regressão, que usa um dos vários algoritmos de regressão para produzir um valor numérico, por exemplo, a idade de uma pessoa ou a probabilidade de uma transação de cartão de crédito ser fraudulenta. Você treinará um modelo de classificação, que busca resolver um conjunto de entradas em uma entre um conjunto de saídas conhecidas. Um exemplo clássico de um modelo de classificação é aquele que examina emails e os classifica como "spam" ou "não spam". Seu modelo será um modelo de classificação binária que prevê se um voo chegará no horário ou em atraso ("binário" porque há apenas duas saídas possíveis).

Um dos benefícios do uso do Scikit-learn é que você não precisa criar esses modelos, nem implementar os algoritmos que eles usam, manualmente. O Scikit-learn inclui uma variedade de classes para implementar modelos de machine learning comuns. Um deles é RandomForestClassifier, que adequa várias árvores de decisão aos dados e usa a média para melhorar a precisão geral e o sobreajuste do limite.

Execute o código a seguir em uma nova célula para criar um objeto RandomForestClassifier e treiná-lo chamando o método fit.
```
from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(random_state=13)
model.fit(train_x, train_y)
```
A saída mostra os parâmetros usados no classificador, incluindo n_estimators, que especifica o número de árvores em cada floresta de árvores de decisão, bem como max_depth, que especifica a profundidade máxima das árvores de decisão. Os valores mostrados são os padrões, mas você pode substituir qualquer um deles ao criar o objeto RandomForestClassifier.

Treinamento do modelo
Agora, chame o método predict para testar o modelo usando os valores em test_x, seguido pelo método score para determinar a precisão média do modelo:
```
predicted = model.predict(test_x)
model.score(test_x, test_y)
```
Confirme que você vê a seguinte saída:

Testar o modelo

A precisão média é 86%, que parece bom à primeira vista. No entanto, a precisão média nem sempre é um indicador confiável da precisão de um modelo de classificação. Vamos nos aprofundar um pouco mais e determinar a real exatidão do modelo, ou seja, quão capaz ele é de determinar se um voo chegará no horário.

Há várias maneiras de medir a precisão de um modelo de classificação. Uma das melhores medidas gerais para um modelo de classificação binária é área sob a curva característica operacional do receptor (também conhecido como "ROC AUC"), que quantifica, essencialmente, a frequência com que o modelo fará uma previsão correta, independentemente do resultado. Nesta unidade, você calculará uma pontuação de ROC AUC para o modelo que você criou anteriormente e aprenderá mais sobre alguns dos motivos pelos quais essa pontuação é menor do que precisão média produzida pelo método score. Você também aprenderá outras maneiras de medir a precisão do modelo.

Antes de calcular o ROC AUC, você deve gerar probabilidades de previsão para o conjunto de teste. Essas probabilidades são estimativas para cada uma das classes ou respostas que o modelo pode prever. Por exemplo, [0.88199435, 0.11800565] significa que há uma chance de 89% de um voo chegar no horário (ARR_DEL15 = 0) e uma chance de 12% de isso não ocorrer (ARR_DEL15 = 1). A soma das duas probabilidades resulta em 100%.

Execute o código a seguir para gerar um conjunto de probabilidades de previsão com base nos dados de teste:
```
from sklearn.metrics import roc_auc_score
probabilities = model.predict_proba(test_x)
```
Agora, use a instrução a seguir para gerar uma pontuação de ROC AUC das probabilidades usando o método roc_auc_score do Scikit-learn:
```
roc_auc_score(test_y, probabilities[:, 1])
```
Confirme que a saída mostra uma pontuação de 67%:

Gerando uma pontuação de AUC

Por que a pontuação de AUC é menor que a precisão média calculada no exercício anterior?

A saída do método score reflete quantos dos itens no conjunto de teste foram previstos corretamente pelo modelo. Essa pontuação é distorcida pelo fato de que o conjunto de dados com o qual o modelo foi treinado e testado contém muito mais linhas que representam chegadas no horário do que linhas que representam chegadas em atraso. Devido a esse desequilíbrio nos dados, você terá mais probabilidade de estar certo se prever que um voo chegará no horário do que se prever que um voo chegará atrasado.

O ROC AUC leva isso em consideração e fornece uma indicação mais exata de qual a probabilidade de uma previsão para chegada no horário ou em atraso esteja correta.
Você pode aprender mais sobre o comportamento do modelo, gerando uma matriz de confusão, também conhecida como matriz de erro. A matriz de confusão contabiliza o número de vezes que cada resposta foi classificada corretamente ou incorretamente. Especificamente, ela contabiliza o número de falsos positivos, falsos negativos, verdadeiros positivos e verdadeiros negativos. Isso é importante, porque se um modelo de classificação binário treinado para reconhecer gatos e cachorros é testado com um conjunto de dados composto por 95% de cachorros, ele pode pontuar 95% simplesmente adivinhando "cachorro" a cada vez. Mas se ele não conseguisse identificar nenhum gato, seria de pouco valor.

Use o seguinte código para produzir uma matriz de confusão para o seu modelo:
```
from sklearn.metrics import confusion_matrix
confusion_matrix(test_y, predicted)
```
A primeira linha na saída representa voos que chegaram no horário. A primeira coluna na linha mostra quantas voos foram previstos corretamente como chegando no horário, enquanto a segunda coluna revela quantos voos foram previstos como atrasados, mas não estavam. Com base nisso, o modelo parece estar apto a prever que um voo chegará no horário.

Gerar uma matriz de confusão

Mas veja a segunda linha, que representa os voos que chegaram atrasados. A primeira coluna mostra quantos voos atrasados foram previstos incorretamente como chegando no horário. A primeira coluna mostra quantos voos foram previstos incorretamente como chegando atrasados. Claramente, o modelo não está nem de longe tão apto a prever que um voo chegará atrasado quanto está para prever que um voo chegará no horário. O que você deseja em uma matriz de confusão é ter números grandes nos cantos superior esquerdo e inferior direito e números pequenos (preferencialmente zeros) nos cantos superior direito e inferior esquerdo.
Outras medidas de precisão para um modelo de classificação incluem precisão e recall. Suponha que o modelo foi apresentado com três chegadas no horário e três chegadas em atraso e que ele previu corretamente duas das chegadas no horário, mas previu incorretamente que duas das chegadas em atraso ocorreriam no horário. Neste caso, a precisão seria de 50% (dois dos quatro voos que ele classificou como no horário chegaram realmente no horário), enquanto o recall seria de 67% (ele identificou corretamente duas das três chegadas no horário). Você pode saber mais sobre a precisão e recall em https://en.wikipedia.org/wiki/Precision_and_recall

O Scikit-learn contém um método útil denominado precision_score para computar a precisão. Para quantificar a precisão do seu modelo, execute as seguintes instruções:
```
from sklearn.metrics import precision_score

train_predictions = model.predict(train_x)
precision_score(train_y, train_predictions)
```
Examine a saída. O que é a precisão do seu modelo?

Medindo a precisão
O Scikit-learn também contém um método chamado recall_score para cálculo do recall. Para medir o recall do modelo, execute as seguintes instruções:
```
from sklearn.metrics import recall_score

recall_score(train_y, train_predictions)
```
Qual é o recall do modelo?

Medir o recall
Use o comando Arquivo ->Salvar e Criar Ponto de Verificação para salvar o notebook.

No mundo real, um cientista de dados treinado procurará por maneiras de tornar o modelo ainda mais preciso. Entre outras coisas, ele tentaria algoritmos diferentes e tomaria medidas para ajustar o algoritmo escolhido para encontrar a combinação ideal de parâmetros. Outra etapa provável seria expandir o conjunto de dados para milhões de linhas em vez de alguns milhares e também tentar reduzir o desequilíbrio entre chegadas em atraso e no horário. Mas, para nossos propósitos, o modelo está bem no estado em que se encontra.

Continuar

Exercício – Criar modelo de machine learning

Comentários