Exercício – Visualizar a saída do modelo

  • 8 minutos

Nesta unidade, você importará o Matplotlib para o notebook no qual você tem trabalhado e configurará o notebook para ser compatível com a saída de Matplotlib embutido.

  1. 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.

  2. Execute as instruções a seguir em uma nova célula no final do notebook. Ignore quaisquer mensagens de aviso exibidas relacionadas a caching de fonte:

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

sns.set()

    A primeira instrução é um dos vários comandos mágicos com suporte do kernel Python que você selecionou quando criou o notebook. Ela permite que o Jupyter renderize a saída de Matplotlib em um notebook sem fazer chamadas repetidas a show. E ela precisa aparecer antes de quaisquer referências ao Matplotlib propriamente dito. A instrução final configura Seaborn para aprimorar a saída de Matplotlib.

  3. Para ver o Matplotlib em funcionamento, execute o seguinte código em uma nova célula para plotar a curva de ROC para o modelo de machine learning que você 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')

  4. Confirme que você vê a seguinte saída:

    ROC curve generated with Matplotlib.

    Curva de ROC gerada com Matplotlib

A linha pontilhada no meio do gráfico representa uma chance de 50-50 de obter uma resposta correta. A curva azul representa a precisão de seu modelo. Mais importante, o fato de que este gráfico chega a ser exibido demonstra que você pode usar o Matplotlib em um Jupyter Notebook.

O motivo pelo qual que você criou um modelo de machine learning é prever se um voo chegará no prazo ou atrasado. Neste exercício, você escreverá uma função de Python que chama o modelo de machine learning criado no laboratório anterior para calcular a probabilidade de que um voo chegará no horário. Em seguida, você usará a função para analisar vários voos.

  1. Insira a definição de função a seguir em uma 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]

    Essa função usa como entrada uma data e hora, um código de aeroporto de origem e um código de aeroporto de destino e retorna um valor entre 0,0 e 1,0 que indica a probabilidade de que o voo chegará em seu destino no horário. Ele usa o modelo de machine learning criado no laboratório anterior para calcular a probabilidade. E para chamar o modelo, ele passa um DataFrame que contém os valores de entrada para predict_proba. A estrutura do DataFrame corresponde exatamente à estrutura do DataFrame que usamos anteriormente.

    Observação

    A entrada de data para a função predict_delay usa o formato de data internacional dd/mm/year.

  2. Use o código a seguir para calcular a probabilidade de um voo de Nova York para Atlanta, na noite de 1º de outubro, chegará no horário. O ano que você insere é irrelevante, porque ele não é usado pelo modelo.

    predict_delay('1/10/2018 21:45:00', 'JFK', 'ATL')

    Confirme que a saída mostra que a probabilidade de uma chegada no horário é de 60%:

    Predicting whether a flight will arrive on time.

    Prever se um voo chegará no horário

  3. Modificar o código para calcular a probabilidade de que o mesmo voo, no dia seguinte, chegue no horário:

    predict_delay('2/10/2018 21:45:00', 'JFK', 'ATL')

    Qual é a probabilidade desse voo chegar no horário? Se os seus planos de viagem fossem flexíveis, você consideraria adiar sua viagem em um dia?

  4. Agora, modifique o código para calcular a probabilidade de que um voo matutino de Atlanta a Seattle, no mesmo dia, chegue no horário:

    predict_delay('2/10/2018 10:00:00', 'ATL', 'SEA')

    É provável que esse voo chegue no horário?

Agora você tem uma maneira fácil de prever, com uma única linha de código, se um voo provavelmente chegará no horário ou atrasado. Fique à vontade fazer experiências com outras datas, horários, origens e destinos. Mas tenha em mente que os resultados só são úteis para os códigos de aeroporto ATL, DTW, JFK, MSP e SEA, porque esses são os únicos códigos de aeroporto com os quais o modelo foi treinado.

  1. Execute o código a seguir para gerar um gráfico com a probabilidade de chegadas no horário de um voo noturno de JFK para ATL em 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))

  2. Confirme se a saída se parece com esta:

    Probability of on-time arrivals for a range of dates.

    Probabilidade de chegadas no horário para um intervalo de datas

  3. Modifique o código para produzir um gráfico semelhante para voos saindo de JFK com destino a MSP às 13h, do dia 10 de abril até 16 de abril. Como a saída se compara à saída na etapa anterior?

  4. Por conta própria, escreva código para representar graficamente a probabilidade de que voos saindo de SEA rumo a ATL às 9:00, ao meio-dia, às 15:00, às 18:00 e às 21:00, em 30 de janeiro, serão pontuais. Confirme se a saída corresponde a esta:

    Probability of on-time arrivals for a range of times.

    Probabilidade de chegadas no horário para um intervalo de horários

Se você for novo no Matplotlib e quiser saber mais sobre isso, você encontrará um excelente tutorial em https://www.labri.fr/perso/nrougier/teaching/matplotlib/. Há muito mais sobre o Matplotlib além do que foi mostrado aqui, que é um dos motivos pelos quais ele é tão popular na comunidade do Python.