Identifique florestas de mangue usando recursos de imagem de satélite usando o Amazon SageMaker Studio e o Amazon SageMaker Autopilot – Parte 2

As florestas de mangue são uma parte importante de um ecossistema saudável, e as atividades humanas são uma das principais razões para seu desaparecimento gradual das costas em todo o mundo. O uso de um modelo de aprendizado de máquina (ML) para identificar regiões de mangue a partir de uma imagem de satélite oferece aos pesquisadores uma maneira eficaz de monitorar o tamanho das florestas ao longo do tempo. Dentro Parte 1 desta série, mostramos como coletar dados de satélite de forma automatizada e analisá-los em Estúdio Amazon SageMaker com visualização interativa. Neste post, mostramos como usar Piloto automático do Amazon SageMaker para automatizar o processo de construção de um classificador de mangue personalizado.

Treinar um modelo com o piloto automático

O piloto automático fornece uma maneira equilibrada de construir vários modelos e selecionar o melhor. Ao criar várias combinações de diferentes técnicas de pré-processamento de dados e modelos de ML com esforço mínimo, o Autopilot fornece controle completo sobre essas etapas do componente para o cientista de dados, se desejado.

Você pode usar o Autopilot usando um dos AWS SDKs (detalhes disponíveis no Guia de referência da API para o piloto automático) ou através do Studio. Usamos o Autopilot em nossa solução Studio seguindo as etapas descritas nesta seção:

1. Na página do Studio Launcher, escolha o sinal de mais para Novo experimento de piloto automático.
   
2. Escolha Conecte seus dados, selecione Encontrar bucket do S3e insira o nome do bucket em que você manteve os conjuntos de dados de treinamento e teste.
3. Escolha Nome do arquivo do conjunto de dados, insira o nome do arquivo de dados de treinamento que você criou no Preparar os dados de treinamento seção em Parte 1.
4. Escolha Local dos dados de saída (bucket S3), insira o mesmo nome de bucket usado na etapa 2.
5. Escolha Nome do diretório do conjunto de dados, insira um nome de pasta no bucket em que você deseja que o Autopilot armazene artefatos.
6. Escolha A sua entrada do S3 é um arquivo de manifesto?, escolha Off.
7. Escolha Target, escolha rótulo.
8. Escolha Implantação automática, escolha Off.
   
9. Sob o Configurações avançadas, Por Tipo de problema de aprendizado de máquina, escolha Classificação Binária.
10. Escolha Métrica objetiva, escolha AUC.
11. Escolha Escolha como executar sua experiência, escolha Não, execute um piloto para criar um notebook com definições de candidatos.
12. Escolha Criar experimento.
    
    Para obter mais informações sobre como criar um experimento, consulte Criar um experimento do Amazon SageMaker Autopilot.Pode levar cerca de 15 minutos para executar esta etapa.
13. Quando terminar, escolha Abra o caderno de geração de candidatos, que abre um novo bloco de anotações no modo somente leitura.
    
14. Escolha Importar bloco de anotações para tornar o notebook editável.
    
15. Para Imagem, escolha Ciência dados.
16. Escolha Núcleo, escolha Python 3.
17. Escolha Selecionar.
    

Este notebook gerado automaticamente tem explicações detalhadas e fornece controle completo sobre a tarefa real de construção do modelo a seguir. Uma versão personalizada do caderno, onde um classificador é treinado usando bandas de satélite Landsat a partir de 2013, está disponível no repositório de código em notebooks/mangrove-2013.ipynb.

A estrutura de construção de modelos consiste em duas partes: transformação de recursos como parte da etapa de processamento de dados e otimização de hiperparâmetros (HPO) como parte da etapa de seleção do modelo. Todos os artefatos necessários para essas tarefas foram criados durante o experimento do Autopilot e salvos em Serviço de armazenamento simples da Amazon (Amazônia S3). A primeira célula do notebook baixa esses artefatos do Amazon S3 para o local Amazon Sage Maker sistema de arquivos para inspeção e qualquer modificação necessária. Existem duas pastas: generated_module e sagemaker_automl, onde são armazenados todos os módulos e scripts Python necessários para executar o notebook. As várias etapas de transformação de recursos, como imputação, dimensionamento e PCA, são salvas como generated_modules/candidate_data_processors/dpp*.py.

O Autopilot cria três modelos diferentes com base nos algoritmos XGBoost, linear learner e multi-layer perceptron (MLP). Um pipeline candidato consiste em uma das opções de transformações de recursos, conhecidas como data_transformer, e um algoritmo. Um pipeline é um dicionário Python e pode ser definido da seguinte forma:

candidate1 = { "data_transformer": { "name": "dpp5", "training_resource_config": { "instance_type": "ml.m5.4xlarge", "instance_count": 1, "volume_size_in_gb": 50 }, "transform_resource_config": { "instance_type": "ml.m5.4xlarge", "instance_count": 1, }, "transforms_label": True, "transformed_data_format": "application/x-recordio-protobuf", "sparse_encoding": True }, "algorithm": { "name": "xgboost", "training_resource_config": { "instance_type": "ml.m5.4xlarge", "instance_count": 1, }, }
}

Neste exemplo, o pipeline transforma os dados de treinamento de acordo com o script em generated_modules/candidate_data_processors/dpp5.py e constrói um modelo XGBoost. É aqui que o Autopilot fornece controle completo ao cientista de dados, que pode escolher as etapas de transformação e seleção de modelo geradas automaticamente ou criar sua própria combinação.

Agora você pode adicionar o pipeline a um pool para que o Autopilot execute o experimento da seguinte maneira:

from sagemaker_automl import AutoMLInteractiveRunner, AutoMLLocalCandidate automl_interactive_runner = AutoMLInteractiveRunner(AUTOML_LOCAL_RUN_CONFIG)
automl_interactive_runner.select_candidate(candidate1)

Esta é uma etapa importante em que você pode decidir manter apenas um subconjunto de candidatos sugeridos pelo Autopilot, com base no conhecimento do assunto, para reduzir o tempo de execução total. Por enquanto, mantenha todas as sugestões do Autopilot, que você pode listar da seguinte forma:

automl_interactive_runner.display_candidates()

O experimento completo do piloto automático é feito em duas partes. Primeiro, você precisa executar os trabalhos de transformação de dados:

automl_interactive_runner.fit_data_transformers(parallel_jobs=7)

Esta etapa deve ser concluída em cerca de 30 minutos para todos os candidatos, se você não fizer mais modificações no dpp*.py arquivos.

O próximo passo é construir o melhor conjunto de modelos ajustando os hiperparâmetros para os respectivos algoritmos. Os hiperparâmetros são geralmente divididos em duas partes: estático e ajustável. Os hiperparâmetros estáticos permanecem inalterados ao longo do experimento para todos os candidatos que compartilham o mesmo algoritmo. Esses hiperparâmetros são passados ​​para o experimento como um dicionário. Se você optar por escolher o melhor modelo XGBoost maximizando a AUC de três rodadas de um esquema de validação cruzada de cinco vezes, o dicionário se parecerá com o seguinte código:

{ 'objective': 'binary:logistic', 'eval_metric': 'auc', '_kfold': 5, '_num_cv_round': 3,
} 

Para os hiperparâmetros ajustáveis, você precisa passar outro dicionário com intervalos e tipo de escala:

{ 'num_round': IntegerParameter(64, 1024, scaling_type='Logarithmic'), 'max_depth': IntegerParameter(2, 8, scaling_type='Logarithmic'), 'eta': ContinuousParameter(1e-3, 1.0, scaling_type='Logarithmic'),
... }

O conjunto completo de hiperparâmetros está disponível no mangrove-2013.ipynb caderno.

Para criar um experimento em que todos os sete candidatos possam ser testados em paralelo, crie um sintonizador HPO multi-algoritmo:

multi_algo_tuning_parameters = automl_interactive_runner.prepare_multi_algo_parameters( objective_metrics=ALGORITHM_OBJECTIVE_METRICS, static_hyperparameters=STATIC_HYPERPARAMETERS, hyperparameters_search_ranges=ALGORITHM_TUNABLE_HYPERPARAMETER_RANGES)

As métricas objetivas são definidas independentemente para cada algoritmo:

ALGORITHM_OBJECTIVE_METRICS = { 'xgboost': 'validation:auc', 'linear-learner': 'validation:roc_auc_score', 'mlp': 'validation:roc_auc',
}

Tentar todos os valores possíveis de hiperparâmetros para todos os experimentos é um desperdício; você pode adotar uma estratégia Bayesiana para criar um sintonizador HPO:

multi_algo_tuning_inputs = automl_interactive_runner.prepare_multi_algo_inputs()
ase_tuning_job_name = "{}-tuning".format(AUTOML_LOCAL_RUN_CONFIG.local_automl_job_name) tuner = HyperparameterTuner.create( base_tuning_job_name=base_tuning_job_name, strategy='Bayesian', objective_type='Maximize', max_parallel_jobs=10, max_jobs=50, **multi_algo_tuning_parameters,
)

Na configuração padrão, o Autopilot seleciona 250 trabalhos no sintonizador para escolher o melhor modelo. Para este caso de uso, é suficiente definir max_jobs=50 para economizar tempo e recursos, sem nenhuma penalidade significativa em termos de escolha do melhor conjunto de hiperparâmetros. Por fim, envie o trabalho HPO da seguinte maneira:

tuner.fit(inputs=multi_algo_tuning_inputs, include_cls_metadata=None)

O processo leva cerca de 80 minutos em instâncias ml.m5.4xlarge. Você pode monitorar o progresso no console do SageMaker escolhendo Jobs de ajuste de hiperparâmetros para Training no painel de navegação.

Você pode visualizar uma série de informações úteis, incluindo o desempenho de cada candidato, escolhendo o nome do trabalho em andamento.

Por fim, compare o desempenho do modelo dos melhores candidatos da seguinte forma:

from sagemaker.analytics import HyperparameterTuningJobAnalytics SAGEMAKER_SESSION = AUTOML_LOCAL_RUN_CONFIG.sagemaker_session
SAGEMAKER_ROLE = AUTOML_LOCAL_RUN_CONFIG.role tuner_analytics = HyperparameterTuningJobAnalytics( tuner.latest_tuning_job.name, sagemaker_session=SAGEMAKER_SESSION) df_tuning_job_analytics = tuner_analytics.dataframe() df_tuning_job_analytics.sort_values( by=['FinalObjectiveValue'], inplace=True, ascending=False if tuner.objective_type == "Maximize" else True) # select the columns to display and rename
select_columns = ["TrainingJobDefinitionName", "FinalObjectiveValue", "TrainingElapsedTimeSeconds"]
rename_columns = { "TrainingJobDefinitionName": "candidate", "FinalObjectiveValue": "AUC", "TrainingElapsedTimeSeconds": "run_time" } # Show top 5 model performances
df_tuning_job_analytics.rename(columns=rename_columns)[rename_columns.values()].set_index("candidate").head(5)

O modelo de melhor desempenho baseado em MLP, embora marginalmente melhor que os modelos XGBoost com várias opções de etapas de processamento de dados, também leva muito mais tempo para treinar. Você pode encontrar detalhes importantes sobre o treinamento do modelo MLP, incluindo a combinação de hiperparâmetros usados, como segue:

df_tuning_job_analytics.loc[df_tuning_job_analytics.TrainingJobName==best_training_job].T.dropna() 

Criar um pipeline de inferência

Para gerar inferência em novos dados, você precisa construir um pipeline de inferência no SageMaker para hospedar o melhor modelo que pode ser chamado posteriormente para gerar inferência. O modelo de pipeline do SageMaker requer três contêineres como seus componentes: transformação de dados, algoritmo e transformação de rótulo inverso (se as previsões numéricas precisarem ser mapeadas para rótulos não numéricos). Por questões de brevidade, apenas parte do código necessário é mostrada no snippet a seguir; o código completo está disponível no mangrove-2013.ipynb caderno:

from sagemaker.estimator import Estimator
from sagemaker import PipelineModel
from sagemaker_automl import select_inference_output …
# Final pipeline model model_containers = [best_data_transformer_model, best_algo_model]
if best_candidate.transforms_label: model_containers.append(best_candidate.get_data_transformer_model( transform_mode="inverse-label-transform", role=SAGEMAKER_ROLE, sagemaker_session=SAGEMAKER_SESSION)) # select the output type
model_containers = select_inference_output("BinaryClassification", model_containers, output_keys=['predicted_label'])

Depois que os contêineres do modelo forem criados, você poderá construir e implantar o pipeline da seguinte maneira:

from sagemaker import PipelineModel pipeline_model = PipelineModel( name=f"mangrove-automl-2013", role=SAGEMAKER_ROLE, models=model_containers, vpc_config=AUTOML_LOCAL_RUN_CONFIG.vpc_config) pipeline_model.deploy(initial_instance_count=1, instance_type='ml.m5.2xlarge', endpoint_name=pipeline_model.name, wait=True)

A implantação do endpoint leva cerca de 10 minutos para ser concluída.

Obtenha inferência no conjunto de dados de teste usando um endpoint

Após a implantação do endpoint, você pode invocá-lo com uma carga útil de recursos B1–B7 para classificar cada pixel em uma imagem como mangue (1) ou outro (0):

import boto3
sm_runtime = boto3.client('runtime.sagemaker') pred_labels = []
with open(local_download, 'r') as f: for i, row in enumerate(f): payload = row.rstrip('n') x = sm_runtime.invoke_endpoint(EndpointName=inf_endpt, ContentType="text/csv", Body=payload) pred_labels.append(int(x['Body'].read().decode().strip()))

Detalhes completos sobre o pós-processamento das previsões do modelo para avaliação e plotagem estão disponíveis em notebooks/model_performance.ipynb.

Obtenha inferência no conjunto de dados de teste usando uma transformação em lote

Agora que você criou o modelo de melhor desempenho com o Autopilot, podemos usar o modelo para inferência. Para obter inferência em grandes conjuntos de dados, é mais eficiente usar uma transformação em lote. Vamos gerar previsões em todo o conjunto de dados (treinamento e teste) e anexar os resultados aos recursos, para que possamos realizar análises adicionais para, por exemplo, verificar o previsto vs. real e a distribuição de recursos entre as classes previstas.

Primeiro, criamos um arquivo de manifesto no Amazon S3 que aponta para os locais dos dados de treinamento e teste das etapas anteriores de processamento de dados:

import boto3
data_bucket = <Name of the S3 bucket that has the training data>
prefix = "LANDSAT_LC08_C01_T1_SR/Year2013"
manifest = "[{{"prefix": "s3://{}/{}/"}},n"train.csv",n"test.csv"n]".format(data_bucket, prefix)
s3_client = boto3.client('s3')
s3_client.put_object(Body=manifest, Bucket=data_bucket, Key=f"{prefix}/data.manifest")

Agora podemos criar um trabalho de transformação em lote. Como nosso trem de entrada e conjunto de dados de teste têm label como a última coluna, precisamos eliminá-la durante a inferência. Para isso, passamos InputFilter no DataProcessing argumento. O código "$[:-2]" indica para descartar a última coluna. A saída prevista é então unida aos dados de origem para análise posterior.

No código a seguir, construímos os argumentos para o trabalho de transformação em lote e, em seguida, passamos para o create_transform_job função:

from time import gmtime, strftime batch_job_name = "Batch-Transform-" + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
output_location = "s3://{}/{}/batch_output/{}".format(data_bucket, prefix, batch_job_name)
input_location = "s3://{}/{}/data.manifest".format(data_bucket, prefix) request = { "TransformJobName": batch_job_name, "ModelName": pipeline_model.name, "TransformOutput": { "S3OutputPath": output_location, "Accept": "text/csv", "AssembleWith": "Line", }, "TransformInput": { "DataSource": {"S3DataSource": {"S3DataType": "ManifestFile", "S3Uri": input_location}}, "ContentType": "text/csv", "SplitType": "Line", "CompressionType": "None", }, "TransformResources": {"InstanceType": "ml.m4.xlarge", "InstanceCount": 1}, "DataProcessing": {"InputFilter": "$[:-2]", "JoinSource": "Input"}
} sagemaker = boto3.client("sagemaker")
sagemaker.create_transform_job(**request)
print("Created Transform job with name: ", batch_job_name)

Você pode monitorar o status do trabalho no console do SageMaker.

Visualize o desempenho do modelo

Agora você pode visualizar o desempenho do melhor modelo no conjunto de dados de teste, composto por regiões da Índia, Mianmar, Cuba e Vietnã, como uma matriz de confusão. O modelo tem um alto valor de recall para pixels representando manguezais, mas apenas cerca de 75% de precisão. A precisão de pixels não manguezais ou outros é de 99% com um recall de 85%. Você pode ajustar o corte de probabilidade das previsões do modelo para ajustar os respectivos valores dependendo do caso de uso específico.

Vale a pena notar que os resultados são uma melhoria significativa em relação ao modelo smileCart integrado.

Visualize as previsões do modelo

Por fim, é útil observar o desempenho do modelo em regiões específicas do mapa. Na imagem a seguir, a área de mangue na fronteira Índia-Bangladesh é representada em vermelho. Os pontos amostrados do patch de imagem Landsat pertencentes ao conjunto de dados de teste são sobrepostos na região, onde cada ponto é um pixel que o modelo determina como representando manguezais. Os pontos azuis são classificados corretamente pelo modelo, enquanto os pontos pretos representam erros do modelo.

A imagem a seguir mostra apenas os pontos que o modelo previu não representar manguezais, com o mesmo esquema de cores do exemplo anterior. O contorno cinza é a parte do patch Landsat que não inclui nenhum mangue. Como fica evidente na imagem, o modelo não comete nenhum erro ao classificar os pontos na água, mas enfrenta um desafio ao distinguir pixels que representam manguezais daqueles que representam a folhagem regular.

A imagem a seguir mostra o desempenho do modelo na região de mangue de Mianmar.

Na imagem a seguir, o modelo faz um trabalho melhor na identificação de pixels de mangue.

limpar

O endpoint de inferência do SageMaker continua a incorrer em custos se for deixado em execução. Exclua o endpoint da seguinte maneira quando terminar:

sagemaker.delete_endpoint(EndpointName=pipeline_model.name)

Conclusão

Esta série de postagens forneceu uma estrutura de ponta a ponta para cientistas de dados para resolver problemas de GIS. Parte 1 mostrou o processo ETL e uma maneira conveniente de interagir visualmente com os dados. A Parte 2 mostrou como usar o Autopilot para automatizar a construção de um classificador de mangue personalizado.

Você pode usar essa estrutura para explorar novos conjuntos de dados de satélite contendo um conjunto mais rico de bandas úteis para classificação de manguezais e explorar a engenharia de recursos incorporando o conhecimento do domínio.

Sobre os autores

Andrei Ivanovic é um estudante de mestrado em Ciência da Computação da Universidade de Toronto e recém-formado no programa de Ciências da Engenharia da Universidade de Toronto, com especialização em Inteligência de Máquinas com especialização em Robótica/Mecatrônica. Ele está interessado em visão computacional, aprendizado profundo e robótica. Ele fez o trabalho apresentado neste post durante seu estágio de verão na Amazon.

David Dong é Cientista de Dados da Amazon Web Services.

Arkajyoti Misra é cientista de dados da Amazon LastMile Transportation. Ele é apaixonado por aplicar técnicas de Visão Computacional para resolver problemas que ajudam a Terra. Ele adora trabalhar com organizações sem fins lucrativos e é membro fundador da www.ekipi.org.

• Coinsmart. A melhor troca de Bitcoin e criptografia da Europa.
• Platoblockchain. Inteligência Metaverso Web3. Conhecimento Ampliado. ACESSO LIVRE.
• CryptoHawk. Radar Altcoin. Teste grátis.
• Fonte: https://aws.amazon.com/blogs/machine-learning/part-2-identify-mangrove-forests-using-satellite-image-features-using-amazon-sagemaker-studio-and-amazon-sagemaker- piloto automático/