Exercício – visualizar o resultado do modelo

8 minutos

Nesta unidade, irá importar o Matplotlib para o bloco de notas com que tem estado a trabalhar e configurar o bloco de notas para oferecer suporte inline ao resultado do Matplotlib.

Mude novamente para o bloco de notas do Azure que criou na secção anterior. Se você fechou o bloco de anotações, poderá entrar novamente no portal de Blocos de Anotações do Microsoft Azure, abrir seu bloco de anotações e usar a célula ->Executar Tudo para executar novamente todas as células do bloco de anotações depois de abri-lo.
Execute as seguintes instruções numa nova célula no final do bloco de notas. Ignore todas as mensagens de aviso apresentadas que estejam relacionadas com a colocação em cache do tipo de letra:
```
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns

sns.set()
```
A primeira instrução é um de vários comandos mágicos suportados pelo kernel do Python que selecionou quando criou o bloco de notas. Permite ao Jupyter compor o resultado do Matplotlib num bloco de notas sem fazer chamadas repetidas para mostrar. Além disso, tem de aparecer antes de quaisquer referências ao próprio Matplotlib. A instrução final configura a Seaborn para melhorar o resultado do Matplotlib.

Para ver o Matplotlib a funcionar, execute o seguinte código numa nova célula para desenhar a curva ROC para o modelo de machine learning que criou no laboratório anterior:

from sklearn.metrics import roc_curve

fpr, tpr, _ = roc_curve(test_y, probabilities[:, 1])
plt.plot(fpr, tpr)
plt.plot([0, 1], [0, 1], color='grey', lw=1, linestyle='--')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')

Confirme que vê o seguinte resultado:

A curva ROC gerada no Matplotlib

A linha ponteada no meio no gráfico representa uma probabilidade de 50% de obter uma resposta correta. A curva azul representa a precisão do seu modelo. Acima de tudo, o facto de este gráfico ser apresentado de todo demonstra que pode utilizar o Matplotlib num bloco de notas do Jupyter.

O motivo pelo qual criou um modelo de machine learning foi para prever se um voo vai chegar à hora prevista ou atrasado. Neste exercício, irá escrever uma função do Python que chama o modelo de machine learning que criou no laboratório anterior para calcular a probabilidade de um voo chegar à hora prevista. Em seguida, utilizará a função para analisar vários voos.

Introduza a seguinte definição de função numa nova célula e, em seguida, execute a célula.

def predict_delay(departure_date_time, origin, destination):
    from datetime import datetime

    try:
        departure_date_time_parsed = datetime.strptime(departure_date_time, '%d/%m/%Y %H:%M:%S')
    except ValueError as e:
        return 'Error parsing date/time - {}'.format(e)

    month = departure_date_time_parsed.month
    day = departure_date_time_parsed.day
    day_of_week = departure_date_time_parsed.isoweekday()
    hour = departure_date_time_parsed.hour

    origin = origin.upper()
    destination = destination.upper()

    input = [{'MONTH': month,
              'DAY': day,
              'DAY_OF_WEEK': day_of_week,
              'CRS_DEP_TIME': hour,
              'ORIGIN_ATL': 1 if origin == 'ATL' else 0,
              'ORIGIN_DTW': 1 if origin == 'DTW' else 0,
              'ORIGIN_JFK': 1 if origin == 'JFK' else 0,
              'ORIGIN_MSP': 1 if origin == 'MSP' else 0,
              'ORIGIN_SEA': 1 if origin == 'SEA' else 0,
              'DEST_ATL': 1 if destination == 'ATL' else 0,
              'DEST_DTW': 1 if destination == 'DTW' else 0,
              'DEST_JFK': 1 if destination == 'JFK' else 0,
              'DEST_MSP': 1 if destination == 'MSP' else 0,
              'DEST_SEA': 1 if destination == 'SEA' else 0 }]

    return model.predict_proba(pd.DataFrame(input))[0][0]

Esta função assume como entrada uma data e hora, o código do aeroporto de partida e o código do aeroporto de destino, e devolve um valor entre 0,0 e 1,0, indicando a probabilidade de o voo chegar ao seu destino à hora prevista. Utiliza o modelo de machine learning que criou no laboratório anterior para calcular a probabilidade. Para chamar o modelo, passa um DataFrame que contém os valores de entrada para predict_proba. A estrutura do DataFrame corresponde exatamente à estrutura do DataFrame que utilizámos anteriormente.

Nota

Entrada de data para a função de predict_delay com o formato de data internacional dd/mm/year.

Utilize o código abaixo para calcular a probabilidade de um voo de Nova Iorque para Atlanta, na noite de 1 de outubro, chegar à hora prevista. O ano que introduzir é irrelevante, porque não está a ser utilizado pelo modelo.
```
predict_delay('1/10/2018 21:45:00', 'JFK', 'ATL')
```
Confirme que o resultado mostra que a probabilidade de uma chegada à hora prevista é de 60%:

Prever se um voo vai chegar à hora prevista
Modifique o código para calcular a probabilidade de o mesmo voo, no dia a seguir, chegar a horas:
```
predict_delay('2/10/2018 21:45:00', 'JFK', 'ATL')
```
Qual a probabilidade de este voo chegar à hora prevista? Se os seus planos de viagem fossem flexíveis, consideraria adiar a sua viagem por um dia?
Modifique agora o código para calcular a probabilidade de um voo da manhã no mesmo dia, de Atlanta para Seattle, chegar à hora prevista:
```
predict_delay('2/10/2018 10:00:00', 'ATL', 'SEA')
```
É provável que este voo chegue à hora prevista?

Tem agora uma forma fácil de prever, com uma única linha de código, se um voo tem probabilidade de chegar à hora prevista ou atrasado. Pode experimentar com outras datas, horas, locais de partida e destinos. Contudo, lembre-se de que os resultados só são relevantes para os códigos de aeroporto ATL, DTW, JFK, MSP e SEA, pois esses são os únicos códigos de aeroporto com os quais o modelo foi preparado.

Execute o seguinte código para determinar a probabilidade de chegadas à hora prevista para um voo da noite saindo de JFK para ATL ao longo de um intervalo de dias:

import numpy as np

labels = ('Oct 1', 'Oct 2', 'Oct 3', 'Oct 4', 'Oct 5', 'Oct 6', 'Oct 7')
values = (predict_delay('1/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('2/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('3/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('4/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('5/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('6/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('7/10/2018 21:45:00', 'JFK', 'ATL'))
alabels = np.arange(len(labels))

plt.bar(alabels, values, align='center', alpha=0.5)
plt.xticks(alabels, labels)
plt.ylabel('Probability of On-Time Arrival')
plt.ylim((0.0, 1.0))

Confirme que o resultado tem este aspeto:

Probabilidade de chegadas à hora prevista para um intervalo de datas
Modifique o código para produzir um gráfico semelhante para voos que partem de JFK para MSP às 13h00 de 10 a 16 de abril. Em que medida este resultado se compara com o resultado do passo anterior?
Por conta própria, escreva um código para representar graficamente a probabilidade de que os voos que partem do SEA para o ATL às 9h00, meio-dia, 15h00, 18h00 e 21h00 de 30 de janeiro cheguem a tempo. Confirme que o resultado corresponde a este:

Probabilidade de chegadas à hora prevista para um intervalo de horas

Se não conhecer o Matplotlib e quiser saber mais sobre o mesmo, encontrará um excelente tutorial em https://www.labri.fr/perso/nrougier/teaching/matplotlib/.. Há muito mais sobre o Matplotlib do que o que foi mostrado aqui, que é um dos motivos pelos quais é tão popular na comunidade do Python.

Exercício – visualizar o resultado do modelo

Comentários