Identifique los bosques de manglares mediante funciones de imágenes satelitales con Amazon SageMaker Studio y Amazon SageMaker Autopilot: parte 2

Los bosques de manglares son una parte importante de un ecosistema saludable, y las actividades humanas son una de las principales razones de su desaparición gradual de las costas de todo el mundo. El uso de un modelo de aprendizaje automático (ML) para identificar regiones de manglares a partir de una imagen satelital brinda a los investigadores una forma efectiva de monitorear el tamaño de los bosques a lo largo del tiempo. En Parte 1 de esta serie, mostramos cómo recopilar datos satelitales de manera automatizada y analizarlos en Estudio Amazon SageMaker con visualización interactiva. En esta publicación, mostramos cómo usar Piloto automático Amazon SageMaker para automatizar el proceso de construcción de un clasificador personalizado de manglares.

Entrenar un modelo con Autopilot

El piloto automático proporciona una forma equilibrada de construir varios modelos y seleccionar el mejor. Al crear múltiples combinaciones de diferentes técnicas de preprocesamiento de datos y modelos de ML con un esfuerzo mínimo, Autopilot proporciona un control completo sobre estos pasos de componentes al científico de datos, si así lo desea.

Puede usar Autopilot usando uno de los SDK de AWS (detalles disponibles en el Guía de referencia de API para Autopilot) o a través de Studio. Utilizamos Autopilot en nuestra solución Studio siguiendo los pasos descritos en esta sección:

1. En la página de Studio Launcher, elija el signo más para Nuevo experimento de piloto automático.
   
2. Conecta tus datos, seleccione Buscar depósito S3e ingrese el nombre del depósito donde guardó los conjuntos de datos de entrenamiento y prueba.
3. Nombre de archivo del conjunto de datos, ingresa el nombre del archivo de datos de entrenamiento que creaste en el Preparar los datos de entrenamiento sección en Parte 1.
4. Ubicación de los datos de salida (depósito de S3), ingrese el mismo nombre de depósito que usó en el paso 2.
5. Nombre del directorio del conjunto de datos, ingrese un nombre de carpeta debajo del depósito donde desea que Autopilot almacene los artefactos.
6. ¿Es su entrada S3 un archivo de manifiesto?, escoger DESC.
7. Target, escoger Label.
8. Implementación automática, escoger DESC.
   
9. Bajo la Configuración avanzada, Para Tipo de problema de aprendizaje automático, escoger Clasificación binaria.
10. Métrica objetiva, escoger AUC.
11. Elija cómo ejecutar su experimento, escoger No, ejecute una prueba piloto para crear un cuaderno con definiciones de candidatos.
12. Elige Crear experimento.
    
    Para obtener más información sobre cómo crear un experimento, consulte Cree un experimento de piloto automático de Amazon SageMaker.Puede tardar unos 15 minutos en ejecutar este paso.
13. Cuando termine, elija Cuaderno de generación de candidatos abierto, que abre un nuevo bloc de notas en modo de solo lectura.
    
14. Elige Importar libreta para hacer que el bloc de notas sea editable.
    
15. Para Imagen, elija Data science.
16. Núcleo, escoger 3 Python.
17. Elige Seleccione.
    

Este cuaderno generado automáticamente tiene explicaciones detalladas y proporciona un control completo sobre la tarea de construcción del modelo real a seguir. Una versión personalizada del cuaderno, donde se entrena a un clasificador utilizando las bandas de satélite Landsat desde 2013, está disponible en el repositorio de códigos bajo notebooks/mangrove-2013.ipynb.

El marco de creación de modelos consta de dos partes: la transformación de características como parte del paso de procesamiento de datos y la optimización de hiperparámetros (HPO) como parte del paso de selección del modelo. Todos los artefactos necesarios para estas tareas se crearon durante el experimento de Autopilot y se guardaron en Servicio de almacenamiento simple de Amazon (Amazon S3). La primera celda de la notebook descarga esos artefactos de Amazon S3 al local Amazon SageMaker sistema de archivo para inspección y cualquier modificación necesaria. Hay dos carpetas: generated_module y sagemaker_automl, donde se almacenan todos los módulos y scripts de Python necesarios para ejecutar el cuaderno. Los diversos pasos de transformación de características, como imputación, escalado y PCA, se guardan como generated_modules/candidate_data_processors/dpp*.py.

Autopilot crea tres modelos diferentes basados ​​en los algoritmos XGBoost, aprendizaje lineal y perceptrón multicapa (MLP). Una tubería candidata consta de una de las opciones de transformación de características, conocida como data_transformery un algoritmo. Una canalización es un diccionario de Python y se puede definir de la siguiente manera:

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, }, }
}

En este ejemplo, la canalización transforma los datos de entrenamiento de acuerdo con el script en generated_modules/candidate_data_processors/dpp5.py y construye un modelo XGBoost. Aquí es donde Autopilot proporciona un control completo al científico de datos, que puede elegir los pasos de selección de modelo y transformación de características generados automáticamente o crear su propia combinación.

Ahora puede agregar la canalización a un grupo para que Autopilot ejecute el experimento de la siguiente manera:

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

Este es un paso importante en el que puede decidir mantener solo un subconjunto de candidatos sugeridos por Autopilot, en función de la experiencia en la materia, para reducir el tiempo de ejecución total. Por ahora, conserve todas las sugerencias de Autopilot, que puede enumerar de la siguiente manera:

automl_interactive_runner.display_candidates()

El experimento completo de Autopilot se realiza en dos partes. Primero, debe ejecutar los trabajos de transformación de datos:

automl_interactive_runner.fit_data_transformers(parallel_jobs=7)

Este paso debe completarse en aproximadamente 30 minutos para todos los candidatos, si no realiza más modificaciones en el dpp*.py archivos.

El siguiente paso es construir el mejor conjunto de modelos ajustando los hiperparámetros para los respectivos algoritmos. Los hiperparámetros se suelen dividir en dos partes: estáticos y sintonizables. Los hiperparámetros estáticos permanecen sin cambios durante todo el experimento para todos los candidatos que comparten el mismo algoritmo. Estos hiperparámetros se pasan al experimento como un diccionario. Si elige elegir el mejor modelo XGBoost maximizando el AUC de tres rondas de un esquema de validación cruzada quíntuple, el diccionario tiene el siguiente código:

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

Para los hiperparámetros ajustables, debe pasar otro diccionario con rangos y 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'),
... }

El conjunto completo de hiperparámetros está disponible en el mangrove-2013.ipynb cuaderno.

Para crear un experimento en el que los siete candidatos se puedan probar en paralelo, cree un sintonizador HPO de varios algoritmos:

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)

Las métricas objetivas se definen de forma independiente para cada algoritmo:

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

Probar todos los valores posibles de hiperparámetros para todos los experimentos es un desperdicio; puede adoptar una estrategia bayesiana para crear un 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,
)

En la configuración predeterminada, Autopilot elige 250 trabajos en el sintonizador para elegir el mejor modelo. Para este caso de uso, es suficiente establecer max_jobs=50 para ahorrar tiempo y recursos, sin ninguna penalización significativa en términos de elegir el mejor conjunto de hiperparámetros. Finalmente, envíe el trabajo de HPO de la siguiente manera:

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

El proceso tarda unos 80 minutos en instancias ml.m5.4xlarge. Puede monitorear el progreso en la consola de SageMaker eligiendo Trabajos de ajuste de hiperparámetros bajo Formación en el panel de navegación.

Puede visualizar una gran cantidad de información útil, incluido el desempeño de cada candidato, eligiendo el nombre del trabajo en curso.

Finalmente, compare el rendimiento del modelo de los mejores candidatos de la siguiente manera:

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)

El modelo de mayor rendimiento basado en MLP, aunque marginalmente mejor que los modelos XGBoost con varias opciones de pasos de procesamiento de datos, también requiere mucho más tiempo para entrenar. Puede encontrar detalles importantes sobre el entrenamiento del modelo MLP, incluida la combinación de hiperparámetros utilizados, de la siguiente manera:

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

Crear una canalización de inferencia

Para generar inferencias sobre nuevos datos, debe construir una canalización de inferencias en SageMaker para alojar el mejor modelo al que se pueda llamar más adelante para generar inferencias. El modelo de canalización de SageMaker requiere tres contenedores como componentes: transformación de datos, algoritmo y transformación de etiqueta inversa (si es necesario asignar predicciones numéricas a etiquetas no numéricas). Para abreviar, solo se muestra una parte del código requerido en el siguiente fragmento; el código completo está disponible en el mangrove-2013.ipynb cuaderno:

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'])

Una vez que se construyen los contenedores del modelo, puede construir e implementar la canalización de la siguiente manera:

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)

La implementación del punto final tarda unos 10 minutos en completarse.

Obtener inferencias sobre el conjunto de datos de prueba mediante un punto final

Después de implementar el punto final, puede invocarlo con una carga de características B1–B7 para clasificar cada píxel en una imagen como manglar (1) u otro (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()))

Los detalles completos sobre el posprocesamiento de las predicciones del modelo para la evaluación y el trazado están disponibles en notebooks/model_performance.ipynb.

Obtenga inferencias sobre el conjunto de datos de prueba mediante una transformación por lotes

Ahora que ha creado el modelo de mejor rendimiento con Autopilot, podemos usar el modelo para la inferencia. Para obtener inferencias sobre grandes conjuntos de datos, es más eficiente usar una transformación por lotes. Generemos predicciones en todo el conjunto de datos (entrenamiento y prueba) y agreguemos los resultados a las características, de modo que podamos realizar un análisis más detallado para, por ejemplo, verificar la predicción frente a los datos reales y la distribución de características entre las clases previstas.

Primero, creamos un archivo de manifiesto en Amazon S3 que apunta a las ubicaciones de los datos de prueba y entrenamiento de los pasos de procesamiento de datos anteriores:

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")

Ahora podemos crear un trabajo de transformación por lotes. Debido a que nuestro tren de entrada y nuestro conjunto de datos de prueba tienen label como última columna, debemos soltarla durante la inferencia. Para ello, pasamos InputFilter existentes DataProcessing argumento. El código "$[:-2]" indica que se suelte la última columna. La salida pronosticada luego se une con los datos de origen para un análisis más detallado.

En el siguiente código, construimos los argumentos para el trabajo de transformación por lotes y luego los pasamos al create_transform_job función:

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)

Puede monitorear el estado del trabajo en la consola de SageMaker.

Visualice el rendimiento del modelo

Ahora puede visualizar el rendimiento del mejor modelo en el conjunto de datos de prueba, que consta de regiones de India, Myanmar, Cuba y Vietnam, como una matriz de confusión. El modelo tiene un alto valor de recuperación para los píxeles que representan manglares, pero solo alrededor del 75 % de precisión. La precisión de los píxeles que no son manglares u otros píxeles es del 99 % con una recuperación del 85 %. Puede ajustar el límite de probabilidad de las predicciones del modelo para ajustar los valores respectivos según el caso de uso particular.

Vale la pena señalar que los resultados son una mejora significativa con respecto al modelo integrado smileCart.

Visualice las predicciones del modelo

Por último, es útil observar el rendimiento del modelo en regiones específicas del mapa. En la siguiente imagen, el área de manglares en la frontera entre India y Bangladesh se representa en rojo. Los puntos muestreados del parche de imagen de Landsat que pertenecen al conjunto de datos de prueba se superponen a la región, donde cada punto es un píxel que el modelo determina que representa manglares. Los puntos azules están clasificados correctamente por el modelo, mientras que los puntos negros representan errores del modelo.

La siguiente imagen muestra solo los puntos que el modelo predijo que no representarían manglares, con el mismo esquema de color que el ejemplo anterior. El contorno gris es la parte del parche Landsat que no incluye manglares. Como se desprende de la imagen, el modelo no comete ningún error al clasificar puntos en el agua, pero se enfrenta a un desafío al distinguir los píxeles que representan manglares de los que representan follaje normal.

La siguiente imagen muestra el rendimiento del modelo en la región de manglares de Myanmar.

En la siguiente imagen, el modelo identifica mejor los píxeles de los manglares.

Limpiar

El extremo de inferencia de SageMaker continúa incurriendo en costos si se deja en ejecución. Elimine el punto final de la siguiente manera cuando haya terminado:

sagemaker.delete_endpoint(EndpointName=pipeline_model.name)

Conclusión

Esta serie de publicaciones proporcionó un marco integral para que los científicos de datos resuelvan problemas de SIG. Parte 1 mostró el proceso ETL y una forma conveniente de interactuar visualmente con los datos. La Parte 2 mostró cómo usar Autopilot para automatizar la construcción de un clasificador de manglares personalizado.

Puede usar este marco para explorar nuevos conjuntos de datos satelitales que contienen un conjunto más rico de bandas útiles para la clasificación de manglares y explorar la ingeniería de características incorporando conocimiento del dominio.

Acerca de los autores

andréi ivanovic es un estudiante entrante de Maestría en Ciencias de la Computación en la Universidad de Toronto y recién graduado del programa de Ciencias de la Ingeniería en la Universidad de Toronto, con especialización en Inteligencia de Máquinas con especialización en Robótica/Mecatrónica. Está interesado en la visión artificial, el aprendizaje profundo y la robótica. Hizo el trabajo presentado en esta publicación durante su pasantía de verano en Amazon.

david dong es científico de datos en Amazon Web Services.

Arkajyoti misra es científico de datos en Amazon LastMile Transportation. Le apasiona aplicar técnicas de Visión por Computador para resolver problemas que ayuden a la tierra. Le encanta trabajar con organizaciones sin fines de lucro y es miembro fundador de ekipi.org.

• Coinsmart. El mejor intercambio de Bitcoin y criptografía de Europa.
• Platoblockchain. Inteligencia del Metaverso Web3. Conocimiento amplificado. ACCESO LIBRE.
• CriptoHawk. Radar de altcoins. Prueba gratis.
• Fuente: 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/