Identifiez les forêts de mangroves à l'aide de fonctionnalités d'image satellite à l'aide d'Amazon SageMaker Studio et d'Amazon SageMaker Autopilot - Partie 2

Les forêts de mangroves font partie intégrante d'un écosystème sain et les activités humaines sont l'une des principales raisons de leur disparition progressive des côtes du monde entier. L'utilisation d'un modèle d'apprentissage automatique (ML) pour identifier les régions de mangroves à partir d'une image satellite offre aux chercheurs un moyen efficace de surveiller la taille des forêts au fil du temps. Dans Partie 1 de cette série, nous avons montré comment collecter des données satellitaires de manière automatisée et les analyser en Amazon SageMakerStudio avec visualisation interactive. Dans cet article, nous montrons comment utiliser Pilote automatique Amazon SageMaker pour automatiser le processus de création d'un classificateur de mangrove personnalisé.

Entraîner un modèle avec Autopilot

Le pilote automatique offre une manière équilibrée de construire plusieurs modèles et de sélectionner le meilleur. Tout en créant plusieurs combinaisons de différentes techniques de prétraitement des données et modèles ML avec un minimum d'effort, Autopilot offre un contrôle complet sur ces étapes de composants au scientifique des données, s'il le souhaite.

Vous pouvez utiliser Autopilot à l'aide de l'un des kits SDK AWS (détails disponibles dans le Guide de référence de l'API pour le pilote automatique) ou via Studio. Nous utilisons Autopilot dans notre solution Studio en suivant les étapes décrites dans cette section :

1. Sur la page Studio Launcher, choisissez le signe plus pour Nouvelle expérience de pilote automatique.
   
2. Pour Connectez vos données, sélectionnez Rechercher un compartiment S3, puis saisissez le nom du compartiment dans lequel vous avez conservé les ensembles de données d'entraînement et de test.
3. Pour Nom du fichier de l'ensemble de données, entrez le nom du fichier de données d'entraînement que vous avez créé dans Préparer les données d'entraînement section Partie 1.
4. Pour Emplacement des données de sortie (compartiment S3), saisissez le même nom de compartiment que vous avez utilisé à l'étape 2.
5. Pour Nom du répertoire de l'ensemble de données, saisissez un nom de dossier sous le compartiment dans lequel vous souhaitez qu'Autopilot stocke les artefacts.
6. Pour Votre entrée S3 est-elle un fichier manifeste ?, choisissez de.
7. Pour Target, choisissez étiquette.
8. Pour Déploiement automatique, choisissez de.
   
9. En vertu des Normes sur l’information et les communications, les organismes doivent rendre leurs sites et applications Web accessibles. Ils y parviennent en conformant leurs sites Web au niveau AA des Web Content Accessibility Guidelines (WCAG). paramètres avancés, Pour Type de problème d'apprentissage automatique, choisissez Classement binaire.
10. Pour Indicateur objectif, choisissez ASC.
11. Pour Choisissez comment exécuter votre test, choisissez Non, exécutez un pilote pour créer un bloc-notes avec des définitions de candidats.
12. Selectionnez Créer une expérience.
    
    Pour plus d'informations sur la création d'une expérience, reportez-vous à Créer une expérience Amazon SageMaker Autopilot.L'exécution de cette étape peut prendre environ 15 minutes.
13. Une fois terminé, choisissez Ouvrir le cahier de génération de candidats, qui ouvre un nouveau bloc-notes en mode lecture seule.
    
14. Selectionnez Importer un bloc-notes pour rendre le bloc-notes modifiable.
    
15. Pour Image, choisissez Sciences des données.
16. Pour Noyau, choisissez Python 3.
17. Selectionnez Sélectionnez.
    

Ce bloc-notes généré automatiquement contient des explications détaillées et offre un contrôle complet sur la tâche de construction de modèle réelle à suivre. Une version personnalisée du cahier, où un classificateur est formé à l'aide des bandes satellites Landsat à partir de 2013, est disponible dans le référentiel de code sous notebooks/mangrove-2013.ipynb.

Le cadre de construction du modèle se compose de deux parties : la transformation des caractéristiques dans le cadre de l'étape de traitement des données et l'optimisation des hyperparamètres (HPO) dans le cadre de l'étape de sélection du modèle. Tous les artefacts nécessaires à ces tâches ont été créés au cours de l'expérience Autopilot et enregistrés dans Service de stockage simple Amazon (Amazon S3). La première cellule de bloc-notes télécharge ces artefacts d'Amazon S3 vers le local Amazon Sage Maker système de fichiers pour inspection et toute modification nécessaire. Il y a deux dossiers : generated_module ainsi que sagemaker_automl, où tous les modules et scripts Python nécessaires à l'exécution du bloc-notes sont stockés. Les différentes étapes de transformation des caractéristiques telles que l'imputation, la mise à l'échelle et l'ACP sont enregistrées sous generated_modules/candidate_data_processors/dpp*.py.

Le pilote automatique crée trois modèles différents basés sur les algorithmes XGBoost, apprenant linéaire et perceptron multicouche (MLP). Un pipeline candidat se compose de l'une des options de transformation de fonctionnalités, appelées data_transformer, et un algorithme. Un pipeline est un dictionnaire Python et peut être défini comme suit :

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

Dans cet exemple, le pipeline transforme les données d'apprentissage en fonction du script dans generated_modules/candidate_data_processors/dpp5.py et construit un modèle XGBoost. C'est là qu'Autopilot fournit un contrôle complet au scientifique des données, qui peut choisir les étapes de transformation de fonctionnalités et de sélection de modèle générées automatiquement ou créer sa propre combinaison.

Vous pouvez maintenant ajouter le pipeline à un pool pour qu'Autopilot exécute l'expérience comme suit :

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

Il s'agit d'une étape importante où vous pouvez décider de ne conserver qu'un sous-ensemble de candidats suggérés par Autopilot, en fonction de l'expertise du sujet, afin de réduire le temps d'exécution total. Pour l'instant, conservez toutes les suggestions du pilote automatique, que vous pouvez répertorier comme suit :

automl_interactive_runner.display_candidates()

L'expérience complète du pilote automatique se déroule en deux parties. Tout d'abord, vous devez exécuter les tâches de transformation de données :

automl_interactive_runner.fit_data_transformers(parallel_jobs=7)

Cette étape devrait se terminer en 30 minutes environ pour tous les candidats, si vous n'apportez aucune autre modification au dpp*.py fichiers.

L'étape suivante consiste à construire le meilleur ensemble de modèles en ajustant les hyperparamètres pour les algorithmes respectifs. Les hyperparamètres sont généralement divisés en deux parties : statique et ajustable. Les hyperparamètres statiques restent inchangés tout au long de l'expérience pour tous les candidats partageant le même algorithme. Ces hyperparamètres sont transmis à l'expérience sous forme de dictionnaire. Si vous choisissez de choisir le meilleur modèle XGBoost en maximisant l'AUC à partir de trois tours d'un schéma de validation croisée quintuple, le dictionnaire ressemble au code suivant :

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

Pour les hyperparamètres ajustables, vous devez passer un autre dictionnaire avec des plages et un type de mise à l'échelle :

{ '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'),
... }

Le jeu complet d'hyperparamètres est disponible dans le mangrove-2013.ipynb cahier.

Pour créer une expérience où les sept candidats peuvent être testés en parallèle, créez un tuner HPO multi-algorithme :

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)

Les métriques objectives sont définies indépendamment pour chaque algorithme :

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

Essayer toutes les valeurs possibles d'hyperparamètres pour toutes les expériences est un gaspillage ; vous pouvez adopter une stratégie bayésienne pour créer un tuner 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,
)

Dans le paramètre par défaut, le pilote automatique sélectionne 250 tâches dans le syntoniseur pour sélectionner le meilleur modèle. Pour ce cas d'utilisation, il suffit de définir max_jobs=50 pour économiser du temps et des ressources, sans aucune pénalité significative en termes de sélection du meilleur ensemble d'hyperparamètres. Enfin, soumettez le travail HPO comme suit :

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

Le processus prend environ 80 minutes sur les instances ml.m5.4xlarge. Vous pouvez surveiller la progression sur la console SageMaker en choisissant Tâches de réglage d'hyperparamètres sous Formation dans le volet de navigation.

Vous pouvez visualiser une foule d'informations utiles, y compris la performance de chaque candidat, en choisissant le nom du travail en cours.

Enfin, comparez les performances du modèle des meilleurs candidats comme suit :

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)

Le modèle le plus performant basé sur MLP, bien que légèrement meilleur que les modèles XGBoost avec différents choix d'étapes de traitement des données, prend également beaucoup plus de temps à s'entraîner. Vous pouvez trouver des détails importants sur la formation du modèle MLP, y compris la combinaison d'hyperparamètres utilisés, comme suit :

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

Créer un pipeline d'inférence

Pour générer de l'inférence sur de nouvelles données, vous devez construire un pipeline d'inférence sur SageMaker pour héberger le meilleur modèle pouvant être appelé ultérieurement pour générer de l'inférence. Le modèle de pipeline SageMaker nécessite trois conteneurs comme composants : transformation de données, algorithme et transformation d'étiquette inverse (si les prédictions numériques doivent être mappées sur des étiquettes non numériques). Par souci de brièveté, seule une partie du code requis est affichée dans l'extrait de code suivant ; le code complet est disponible dans le mangrove-2013.ipynb cahier:

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

Une fois les conteneurs de modèles créés, vous pouvez créer et déployer le pipeline comme suit :

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)

Le déploiement du point de terminaison prend environ 10 minutes.

Obtenir une inférence sur l'ensemble de données de test à l'aide d'un point de terminaison

Une fois le point de terminaison déployé, vous pouvez l'invoquer avec une charge utile de fonctionnalités B1 à B7 pour classer chaque pixel d'une image comme mangrove (1) ou autre (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()))

Des détails complets sur le post-traitement des prédictions du modèle pour l'évaluation et le traçage sont disponibles dans notebooks/model_performance.ipynb.

Obtenir une inférence sur l'ensemble de données de test à l'aide d'une transformation par lots

Maintenant que vous avez créé le modèle le plus performant avec Autopilot, nous pouvons utiliser le modèle pour l'inférence. Pour obtenir une inférence sur de grands ensembles de données, il est plus efficace d'utiliser une transformation par lots. Générons des prédictions sur l'ensemble de données (formation et test) et ajoutons les résultats aux fonctionnalités, afin que nous puissions effectuer une analyse plus approfondie pour, par exemple, vérifier les prévisions par rapport aux valeurs réelles et la distribution des fonctionnalités parmi les classes prédites.

Tout d'abord, nous créons un fichier manifeste dans Amazon S3 qui pointe vers les emplacements des données de formation et de test des étapes de traitement de données précédentes :

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

Nous pouvons maintenant créer une tâche de transformation par lots. Parce que notre train d'entrée et notre ensemble de données de test ont label en tant que dernière colonne, nous devons la supprimer lors de l'inférence. Pour ce faire, nous passons InputFilter dans l' DataProcessing dispute. Le code "$[:-2]" indique de supprimer la dernière colonne. La sortie prédite est ensuite jointe aux données source pour une analyse plus approfondie.

Dans le code suivant, nous construisons les arguments pour le travail de transformation par lots, puis nous passons au create_transform_job fonction:

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)

Vous pouvez surveiller l'état du travail sur la console SageMaker.

Visualisez les performances du modèle

Vous pouvez maintenant visualiser les performances du meilleur modèle sur l'ensemble de données de test, composé de régions de l'Inde, du Myanmar, de Cuba et du Vietnam, sous la forme d'une matrice de confusion. Le modèle a une valeur de rappel élevée pour les pixels représentant les mangroves, mais seulement environ 75 % de précision. La précision des pixels non-mangrove ou autres est de 99 % avec un rappel de 85 %. Vous pouvez ajuster le seuil de probabilité des prédictions du modèle pour ajuster les valeurs respectives en fonction du cas d'utilisation particulier.

Il convient de noter que les résultats sont une amélioration significative par rapport au modèle smileCart intégré.

Visualisez les prédictions du modèle

Enfin, il est utile d'observer les performances du modèle sur des régions spécifiques de la carte. Dans l'image suivante, la zone de mangrove à la frontière entre l'Inde et le Bangladesh est représentée en rouge. Les points échantillonnés à partir du patch d'image Landsat appartenant à l'ensemble de données de test sont superposés à la région, où chaque point est un pixel que le modèle détermine comme représentant les mangroves. Les points bleus sont classés correctement par le modèle, tandis que les points noirs représentent les erreurs du modèle.

L'image suivante montre uniquement les points qui, selon le modèle, ne représentent pas les mangroves, avec le même schéma de couleurs que l'exemple précédent. Le contour gris est la partie du patch Landsat qui n'inclut aucune mangrove. Comme le montre l'image, le modèle ne fait aucune erreur en classant les points sur l'eau, mais fait face à un défi lorsqu'il s'agit de distinguer les pixels représentant les mangroves de ceux représentant le feuillage régulier.

L'image suivante montre les performances du modèle sur la région de mangrove du Myanmar.

Dans l'image suivante, le modèle identifie mieux les pixels de la mangrove.

Nettoyer

Le point de terminaison d'inférence SageMaker continue d'engendrer des coûts s'il est laissé en cours d'exécution. Lorsque vous avez terminé, supprimez le point de terminaison comme suit :

sagemaker.delete_endpoint(EndpointName=pipeline_model.name)

Conclusion

Cette série d'articles a fourni un cadre de bout en bout aux scientifiques des données pour résoudre les problèmes SIG. Partie 1 a montré le processus ETL et un moyen pratique d'interagir visuellement avec les données. La partie 2 a montré comment utiliser le pilote automatique pour automatiser la création d'un classificateur de mangrove personnalisé.

Vous pouvez utiliser ce cadre pour explorer de nouveaux ensembles de données satellitaires contenant un ensemble plus riche de bandes utiles pour la classification des mangroves et explorer l'ingénierie des fonctionnalités en incorporant la connaissance du domaine.

À propos des auteurs

Andreï Ivanovic est un nouvel étudiant à la maîtrise en informatique à l'Université de Toronto et un récent diplômé du programme de sciences de l'ingénieur de l'Université de Toronto, avec une majeure en intelligence artificielle avec une mineure en robotique/mécatronique. Il s'intéresse à la vision par ordinateur, à l'apprentissage en profondeur et à la robotique. Il a réalisé le travail présenté dans ce post lors de son stage d'été chez Amazon.

David Dong est Data Scientist chez Amazon Web Services.

Arkajyoti Misra est Data Scientist chez Amazon LastMile Transportation. Il est passionné par l'application des techniques de vision par ordinateur pour résoudre des problèmes qui aident la terre. Il aime travailler avec des organismes à but non lucratif et est membre fondateur de ekipi.org.

• Coinsmart. Le meilleur échange Bitcoin et Crypto d'Europe.
• Platoblockchain. Intelligence métaverse Web3. Connaissance amplifiée. ACCÈS LIBRE.
• CryptoHawk. Radar Altcoins. Essai gratuit.
• Source : https://aws.amazon.com/blogs/machine-learning/part-2-identify-mangrove-forests-using-satellite-image-features-using-amazon-sagemaker-studio-and-amazon-sagemaker- pilote automatique/