Treinar um modelo de regressão com AutoML e Python (SDK v1)

  • Artigo

APLICA-SE A:Python SDK azureml v1

Neste artigo, você aprenderá a treinar um modelo de regressão com o SDK Python do Azure Machine Learning usando o ML automatizado do Azure Machine Learning. Este modelo de regressão prevê as tarifas de táxi de Nova York.

Esse processo aceita dados de treinamento e definições de configuração e itera automaticamente por meio de combinações de diferentes métodos de normalização/padronização de recursos, modelos e configurações de hiperparâmetros para chegar ao melhor modelo.

Flow diagram

Você escreve código usando o Python SDK neste artigo. Você aprende as seguintes tarefas:

  • Baixar, transformar e limpar dados usando o Azure Open Datasets
  • Treinar um modelo de regressão de aprendizado de máquina automatizado
  • Calcular a precisão do modelo

Para AutoML sem código, tente os seguintes tutoriais:

Pré-requisitos

Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar. Experimente hoje mesmo a versão gratuita ou paga do Azure Machine Learning.

  • Conclua o Guia de início rápido: comece a usar o Azure Machine Learning se você ainda não tiver um espaço de trabalho do Azure Machine Learning ou uma instância de computação.
  • Depois de concluir o início rápido:
    1. Selecione Blocos de anotações no estúdio.
    2. Selecione a guia Amostras .
    3. Abra o notebook SDK v1/tutorials/regression-automl-nyc-taxi-data/regression-automated-ml.ipynb .
    4. Para executar cada célula no tutorial, selecione Clonar este bloco de anotações

Este artigo também está disponível no GitHub se você deseja executá-lo em seu próprio ambiente local. Para obter os pacotes necessários,

  • Instale o cliente completoautoml.
  • Execute pip install azureml-opendatasets azureml-widgets para obter os pacotes necessários.

Transferir e preparar dados

Importe os pacotes necessários. O pacote Open Datasets contém uma classe que representa cada fonte de dados (NycTlcGreen por exemplo) para filtrar facilmente os parâmetros de data antes do download.

from azureml.opendatasets import NycTlcGreen
import pandas as pd
from datetime import datetime
from dateutil.relativedelta import relativedelta

Comece criando um dataframe para armazenar os dados do táxi. Quando você trabalha em um ambiente não-Spark, Open Datasets só permite baixar um mês de dados de cada vez com determinadas classes para evitar MemoryError com grandes conjuntos de dados.

Para baixar dados de táxi, busque iterativamente um mês de cada vez e, antes de anexá-los, faça uma green_taxi_df amostragem aleatória de 2.000 registros de cada mês para evitar o inchaço do dataframe. Em seguida, visualize os dados.

green_taxi_df = pd.DataFrame([])
start = datetime.strptime("1/1/2015","%m/%d/%Y")
end = datetime.strptime("1/31/2015","%m/%d/%Y")

for sample_month in range(12):
    temp_df_green = NycTlcGreen(start + relativedelta(months=sample_month), end + relativedelta(months=sample_month)) \
        .to_pandas_dataframe()
    green_taxi_df = green_taxi_df.append(temp_df_green.sample(2000))

green_taxi_df.head(10)
ID do fornecedor lpepPickupDatahora lpepDropoffDatahora passengerCount tripDistância puLocationId doLocationId captaçãoLongitude captaçãoLatitude dropoffLongitude ... Tipo de pagamento fareAmount extra mtaImposto melhoriaSobretaxa gorjetaMontante PortagensMontante ehailFee totalAmount tripType
131969 2 2015-01-11 05:34:44 2015-01-11 05:45:03 3 4.84 None None -73.88 40.84 -73.94 ... 2 15,00 0.50 0.50 0.3 0.00 0.00 Nan 16.30
1129817 2 2015-01-20 16:26:29 2015-01-20 16:30:26 5 0.69 None None -73.96 40.81 -73.96 ... 2 4,50 1,00 0.50 0.3 0.00 0.00 Nan 6.30
1278620 2 2015-01-01 05:58:10 2015-01-01 06:00:55 5 0,45 None None -73.92 40.76 -73.91 ... 2 4.00 0.00 0.50 0.3 0.00 0.00 Nan 4.80
348430 2 2015-01-17 02:20:50 2015-01-17 02:41:38 5 0.00 None None -73.81 40.70 -73.82 ... 2 12.50 0.50 0.50 0.3 0.00 0.00 Nan 13.80
1269627 5 2015-01-01 05:04:10 2015-01-01 05:06:23 5 0.50 None None -73.92 40.76 -73.92 ... 2 4.00 0.50 0.50 0 0.00 0.00 Nan 5.00
811755 5 2015-01-04 19:57:51 2015-01-04 20:05:45 2 1.10 None None -73.96 40.72 -73.95 ... 2 6.50 0.50 0.50 0.3 0.00 0.00 Nan 7.80
737281 5 2015-01-03 12:27:31 2015-01-03 12:33:52 5 0.90 None None -73.88 40.76 -73.87 ... 2 6,00 0.00 0.50 0.3 0.00 0.00 Nan 6.80
113951 5 2015-01-09 23:25:51 2015-01-09 23:39:52 5 3.30 None None -73.96 40.72 -73.91 ... 2 12.50 0.50 0.50 0.3 0.00 0.00 Nan 13.80
150436 2 2015-01-11 17:15:14 2015-01-11 17:22:57 5 1.19 None None -73.94 40.71 -73.95 ... 5 7.00 0.00 0.50 0.3 1,75 0.00 Nan 9.55
432136 2 2015-01-22 23:16:33 2015-01-22 23:20:13 1 0.65 None None -73.94 40.71 -73.94 ... 2 5.00 0.50 0.50 0.3 0.00 0.00 Nan 6.30

Remova algumas das colunas que você não precisará para treinamento ou outra criação de recursos. O aprendizado de máquina automatizado lidará automaticamente com recursos baseados em tempo, como lpepPickupDatetime.

columns_to_remove = ["lpepDropoffDatetime", "puLocationId", "doLocationId", "extra", "mtaTax",
                     "improvementSurcharge", "tollsAmount", "ehailFee", "tripType", "rateCodeID",
                     "storeAndFwdFlag", "paymentType", "fareAmount", "tipAmount"
                    ]
for col in columns_to_remove:
    green_taxi_df.pop(col)

green_taxi_df.head(5)

Limpar dados

Execute a describe() função no novo dataframe para ver estatísticas de resumo para cada campo.

green_taxi_df.describe()
ID do fornecedor passengerCount tripDistância captaçãoLongitude captaçãoLatitude dropoffLongitude dropoffLatitude totalAmount month_num day_of_month day_of_week hour_of_day
contagem 48000.00 48000.00 48000.00 48000.00 48000.00 48000.00 48000.00 48000.00 48000.00 48000.00
mean 1.78 1.37 2.87 -73.83 40.69 -73.84 40.70 14.75 6.50 15.13
std 0.41 1.04 2.93 2.76 1.52 2.61 1.44 12.08 3.45 8.45
min 1,00 0.00 0.00 -74.66 0.00 -74.66 0.00 -300.00 1,00 1,00
25% 2.00 1,00 1.06 -73.96 40.70 -73.97 40.70 7.80 3.75 8,00
50% 2.00 1,00 1.90 -73.94 40.75 -73.94 40.75 11.30 6.50 15,00
75% 2.00 1,00 3.60 -73.92 40.80 -73.91 40.79 17.80 9.25 22.00
max 2.00 9,00 97.57 0.00 41.93 0.00 41.94 450.00 12.00 30,00

A partir das estatísticas de resumo, você vê que há vários campos que têm valores atípicos ou que reduzem a precisão do modelo. Primeiro, filtre os campos lat/long para estar dentro dos limites da área de Manhattan. Isso filtra viagens de táxi mais longas ou viagens que são atípicas em relação à sua relação com outros recursos.

Além disso, filtre o tripDistance campo para ser maior que zero, mas inferior a 31 milhas (a distância haversine entre os dois pares lat/long). Isso elimina longas viagens atípicas que têm custos de viagem inconsistentes.

Por fim, o campo tem valores negativos para as tarifas de táxi, que não fazem sentido no contexto do nosso modelo, e o totalAmountpassengerCount campo tem dados ruins com os valores mínimos sendo zero.

Filtre essas anomalias usando funções de consulta e, em seguida, remova as últimas colunas desnecessárias para treinamento.

final_df = green_taxi_df.query("pickupLatitude>=40.53 and pickupLatitude<=40.88")
final_df = final_df.query("pickupLongitude>=-74.09 and pickupLongitude<=-73.72")
final_df = final_df.query("tripDistance>=0.25 and tripDistance<31")
final_df = final_df.query("passengerCount>0 and totalAmount>0")

columns_to_remove_for_training = ["pickupLongitude", "pickupLatitude", "dropoffLongitude", "dropoffLatitude"]
for col in columns_to_remove_for_training:
    final_df.pop(col)

Ligue describe() novamente para os dados para garantir que a limpeza funcionou conforme o esperado. Agora você tem um conjunto preparado e limpo de dados de táxi, férias e clima para usar no treinamento de modelos de aprendizado de máquina.

final_df.describe()

Configurar a área de trabalho

Crie um objeto de área de trabalho a partir da área de trabalho existente. Um espaço de trabalho é uma classe que aceita sua assinatura do Azure e informações de recursos. Ele também cria um recurso de nuvem para monitorar e acompanhar as execuções do seu modelo. Workspace.from_config() lê o arquivo config.json e carrega os detalhes de autenticação em um objeto chamado ws. ws é usado em todo o resto do código neste artigo.

from azureml.core.workspace import Workspace
ws = Workspace.from_config()

Divida os dados em conjuntos de trem e teste

Divida os dados em conjuntos de treinamento e teste usando a train_test_splitscikit-learn função na biblioteca. Essa função segrega os dados no conjunto de dados x (recursos) para treinamento de modelo e no conjunto de dados y (valores para prever) para teste.

O test_size parâmetro determina a porcentagem de dados a serem alocados para testes. O random_state parâmetro define uma semente para o gerador aleatório, de modo que suas divisões de teste de trem sejam determinísticas.

from sklearn.model_selection import train_test_split

x_train, x_test = train_test_split(final_df, test_size=0.2, random_state=223)

O objetivo desta etapa é ter pontos de dados para testar o modelo acabado que não foram usados para treinar o modelo, a fim de medir a verdadeira precisão.

Em outras palavras, um modelo bem treinado deve ser capaz de fazer previsões com precisão a partir de dados que ainda não viu. Agora você tem dados preparados para treinar automaticamente um modelo de aprendizado de máquina.

Treinar automaticamente um modelo

Para treinar automaticamente um modelo, siga as seguintes etapas:

  1. Defina as configurações para a execução do experimento. Anexe seus dados de treinamento à configuração e modifique as configurações que controlam o processo de treinamento.
  2. Envie o experimento para ajuste do modelo. Depois de submeter a experiência, o processo itera através de diferentes algoritmos de aprendizagem automática e definições de hiperparâmetros, aderindo às restrições definidas. Ele escolhe o modelo mais adequado otimizando uma métrica de precisão.

Definir configurações de treinamento

Defina o parâmetro do experimento e as configurações do modelo para treinamento. Veja a lista completa de configurações. O envio do experimento com essas configurações padrão leva aproximadamente de 5 a 20 minutos, mas se você quiser um tempo de execução mais curto, reduza o experiment_timeout_hours parâmetro.

Property Valor neste artigo Description
iteration_timeout_minutes 10 Limite de tempo em minutos para cada iteração. Aumente esse valor para conjuntos de dados maiores que precisam de mais tempo para cada iteração.
experiment_timeout_hours 0.3 Quantidade máxima de tempo, em horas, que todas as iterações combinadas podem levar antes que o experimento termine.
enable_early_stopping True Sinalize para permitir a rescisão antecipada se a pontuação não estiver melhorando no curto prazo.
primary_metric spearman_correlation Métrica que pretende otimizar. O modelo mais adequado é escolhido com base nesta métrica.
featurização auto Usando auto, o experimento pode pré-processar os dados de entrada (manipulação de dados ausentes, conversão de texto em numérico, etc.)
Verborragia logging.INFO Controla o nível de registro.
n_cross_validations 5 Número de divisões de validação cruzada a serem executadas quando os dados de validação não são especificados. 
import logging

automl_settings = {
    "iteration_timeout_minutes": 10,
    "experiment_timeout_hours": 0.3,
    "enable_early_stopping": True,
    "primary_metric": 'spearman_correlation',
    "featurization": 'auto',
    "verbosity": logging.INFO,
    "n_cross_validations": 5
}

Use suas configurações de treinamento definidas como um parâmetro para um **kwargsAutoMLConfig objeto. Além disso, especifique seus dados de treinamento e o tipo de modelo, que é regression neste caso.

from azureml.train.automl import AutoMLConfig

automl_config = AutoMLConfig(task='regression',
                             debug_log='automated_ml_errors.log',
                             training_data=x_train,
                             label_column_name="totalAmount",
                             **automl_settings)

Nota

As etapas de pré-processamento automatizado de aprendizado de máquina (normalização de recursos, manipulação de dados ausentes, conversão de texto em numérico, etc.) tornam-se parte do modelo subjacente. Ao usar o modelo para previsões, as mesmas etapas de pré-processamento aplicadas durante o treinamento são aplicadas aos seus dados de entrada automaticamente.

Treinar o modelo de regressão automática

Crie um objeto de experimento em seu espaço de trabalho. Um experimento funciona como um contêiner para seus trabalhos individuais. Passe o objeto definido automl_config para o experimento e defina a saída para True exibir o progresso durante o trabalho.

Depois de iniciar o experimento, a saída mostrada é atualizada ao vivo à medida que o experimento é executado. Para cada iteração, você vê o tipo de modelo, a duração da execução e a precisão do treinamento. O campo BEST rastreia a melhor pontuação de treinamento de corrida com base no seu tipo de métrica.

from azureml.core.experiment import Experiment
experiment = Experiment(ws, "Tutorial-NYCTaxi")
local_run = experiment.submit(automl_config, show_output=True)

Running on local machine
Parent Run ID: AutoML_1766cdf7-56cf-4b28-a340-c4aeee15b12b
Current status: DatasetFeaturization. Beginning to featurize the dataset.
Current status: DatasetEvaluation. Gathering dataset statistics.
Current status: FeaturesGeneration. Generating features for the dataset.
Current status: DatasetFeaturizationCompleted. Completed featurizing the dataset.
Current status: DatasetCrossValidationSplit. Generating individually featurized CV splits.
Current status: ModelSelection. Beginning model selection.

****************************************************************************************************
ITERATION: The iteration being evaluated.
PIPELINE: A summary description of the pipeline being evaluated.
DURATION: Time taken for the current iteration.
METRIC: The result of computing score on the fitted pipeline.
BEST: The best observed score thus far.
****************************************************************************************************

 ITERATION   PIPELINE                                       DURATION      METRIC      BEST
         0   StandardScalerWrapper RandomForest             0:00:16       0.8746    0.8746
         1   MinMaxScaler RandomForest                      0:00:15       0.9468    0.9468
         2   StandardScalerWrapper ExtremeRandomTrees       0:00:09       0.9303    0.9468
         3   StandardScalerWrapper LightGBM                 0:00:10       0.9424    0.9468
         4   RobustScaler DecisionTree                      0:00:09       0.9449    0.9468
         5   StandardScalerWrapper LassoLars                0:00:09       0.9440    0.9468
         6   StandardScalerWrapper LightGBM                 0:00:10       0.9282    0.9468
         7   StandardScalerWrapper RandomForest             0:00:12       0.8946    0.9468
         8   StandardScalerWrapper LassoLars                0:00:16       0.9439    0.9468
         9   MinMaxScaler ExtremeRandomTrees                0:00:35       0.9199    0.9468
        10   RobustScaler ExtremeRandomTrees                0:00:19       0.9411    0.9468
        11   StandardScalerWrapper ExtremeRandomTrees       0:00:13       0.9077    0.9468
        12   StandardScalerWrapper LassoLars                0:00:15       0.9433    0.9468
        13   MinMaxScaler ExtremeRandomTrees                0:00:14       0.9186    0.9468
        14   RobustScaler RandomForest                      0:00:10       0.8810    0.9468
        15   StandardScalerWrapper LassoLars                0:00:55       0.9433    0.9468
        16   StandardScalerWrapper ExtremeRandomTrees       0:00:13       0.9026    0.9468
        17   StandardScalerWrapper RandomForest             0:00:13       0.9140    0.9468
        18   VotingEnsemble                                 0:00:23       0.9471    0.9471
        19   StackEnsemble                                  0:00:27       0.9463    0.9471

Explorar os resultados

Explore os resultados do treinamento automático com um widget Jupyter. O widget permite que você veja um gráfico e uma tabela de todas as iterações de trabalho individuais, juntamente com métricas de precisão de treinamento e metadados. Além disso, você pode filtrar métricas de precisão diferentes da métrica principal com o seletor suspenso.

from azureml.widgets import RunDetails
RunDetails(local_run).show()

Jupyter widget run detailsJupyter widget plot

Obter o melhor modelo

Selecione o melhor modelo das suas iterações. A get_output função retorna a melhor execução e o modelo ajustado para a última chamada de ajuste. Usando as sobrecargas no get_output, você pode recuperar o melhor modelo de execução e ajuste para qualquer métrica registrada ou uma iteração específica.

best_run, fitted_model = local_run.get_output()
print(best_run)
print(fitted_model)

Teste a melhor precisão do modelo

Use o melhor modelo para executar previsões no conjunto de dados de teste para prever as tarifas de táxi. A função predict usa o melhor modelo e prevê os valores de y, custo da viagem, a x_test partir do conjunto de dados. Imprima os primeiros 10 valores de custo previstos em y_predict.

y_test = x_test.pop("totalAmount")

y_predict = fitted_model.predict(x_test)
print(y_predict[:10])

Calcule os root mean squared error resultados. Converta o y_test dataframe em uma lista para comparar com os valores previstos. A função mean_squared_error usa duas matrizes de valores e calcula o erro quadrado médio entre elas. Tomando a raiz quadrada do resultado dá um erro nas mesmas unidades que a variável y, custo. Ele indica aproximadamente o quão longe as previsões de tarifas de táxi estão das tarifas reais.

from sklearn.metrics import mean_squared_error
from math import sqrt

y_actual = y_test.values.flatten().tolist()
rmse = sqrt(mean_squared_error(y_actual, y_predict))
rmse

Execute o código a seguir para calcular o erro percentual absoluto médio (MAPE) usando os conjuntos completo y_actual e y_predict de dados. Esta métrica calcula uma diferença absoluta entre cada valor previsto e real e soma todas as diferenças. Em seguida, expressa essa soma como uma porcentagem do total dos valores reais.

sum_actuals = sum_errors = 0

for actual_val, predict_val in zip(y_actual, y_predict):
    abs_error = actual_val - predict_val
    if abs_error < 0:
        abs_error = abs_error * -1

    sum_errors = sum_errors + abs_error
    sum_actuals = sum_actuals + actual_val

mean_abs_percent_error = sum_errors / sum_actuals
print("Model MAPE:")
print(mean_abs_percent_error)
print()
print("Model Accuracy:")
print(1 - mean_abs_percent_error)

Model MAPE:
0.14353867606052823

Model Accuracy:
0.8564613239394718

A partir das duas métricas de precisão de previsão, você vê que o modelo é bastante bom em prever tarifas de táxi a partir dos recursos do conjunto de dados, normalmente dentro de +- $ 4,00, e aproximadamente 15% de erro.

O processo tradicional de desenvolvimento de modelos de aprendizado de máquina consome muitos recursos e requer conhecimento de domínio significativo e investimento de tempo para executar e comparar os resultados de dezenas de modelos. Usar o aprendizado de máquina automatizado é uma ótima maneira de testar rapidamente muitos modelos diferentes para o seu cenário.

Clean up resources (Limpar recursos)

Não conclua esta seção se planeja executar outros tutoriais do Azure Machine Learning.

Pare a instância de computação

Se você usou uma instância de computação, pare a VM quando não estiver usando-a para reduzir custos.

  1. No espaço de trabalho, selecione Computação.

  2. Na lista, selecione o nome da instância de computação.

  3. Selecione Parar.

  4. Quando estiver pronto para usar o servidor novamente, selecione Iniciar.

Excluir tudo

Se não planeia utilizar os recursos que criou, elimine-os para não incorrer em quaisquer encargos.

  1. No portal do Azure, selecione Grupos de recursos na extremidade esquerda.
  2. Na lista, selecione o grupo de recursos que criou.
  3. Selecione Eliminar grupo de recursos.
  4. Insira o nome do grupo de recursos. Em seguida, selecione Eliminar.

Você também pode manter o grupo de recursos, mas excluir um único espaço de trabalho. Exiba as propriedades do espaço de trabalho e selecione Excluir.

Próximos passos

Neste artigo de aprendizado de máquina automatizado, você executou as seguintes tarefas:

  • Configurou um espaço de trabalho e preparou dados para um experimento.
  • Treinado usando um modelo de regressão automatizado localmente com parâmetros personalizados.
  • Explorou e revisou resultados de treinamento.

Configurar o AutoML para treinar modelos de visão computacional com Python (v1)