Identificeer mangrovebossen met behulp van satellietbeeldfuncties met Amazon SageMaker Studio en Amazon SageMaker Autopilot – Part 2

Mangrovebossen zijn een belangrijk onderdeel van een gezond ecosysteem en menselijke activiteiten zijn een van de belangrijkste redenen voor hun geleidelijke verdwijning van kusten over de hele wereld. Het gebruik van een machine learning (ML) -model om mangrovegebieden te identificeren op basis van een satellietbeeld, geeft onderzoekers een effectieve manier om de omvang van de bossen in de loop van de tijd te volgen. In Deel 1 van deze serie hebben we laten zien hoe je satellietgegevens op een geautomatiseerde manier kunt verzamelen en analyseren in Amazon SageMaker Studio met interactieve visualisatie. In dit bericht laten we zien hoe te gebruiken Amazon SageMaker-stuurautomaat om het proces van het bouwen van een aangepaste mangroveclassificatie te automatiseren.

Een model trainen met Autopilot

Autopilot biedt een uitgebalanceerde manier om verschillende modellen te bouwen en de beste te selecteren. Terwijl het creëren van meerdere combinaties van verschillende datavoorverwerkingstechnieken en ML-modellen met minimale inspanning, biedt Autopilot, indien gewenst, volledige controle over deze componentstappen aan de datawetenschapper.

U kunt Autopilot gebruiken met een van de AWS SDK's (details beschikbaar in de API-referentiegids voor Autopilot) of via Studio. We gebruiken Autopilot in onze Studio-oplossing volgens de stappen die in deze sectie worden beschreven:

1. Kies op de Studio Launcher-pagina het plusteken voor Nieuw Autopilot-experiment.
   
2. Voor Verbind uw gegevensselecteer S3-emmer zoekenen voer de bucketnaam in waar u de trainings- en testgegevenssets hebt bewaard.
3. Voor Bestandsnaam dataset, voer de naam in van het trainingsgegevensbestand dat u hebt gemaakt in de Bereid de trainingsgegevens voor sectie in Deel 1.
4. Voor Uitvoergegevenslocatie (S3-bucket), voer dezelfde bucketnaam in die u in stap 2 heeft gebruikt.
5. Voor Naam datasetdirectory, voer een mapnaam in onder de bucket waarin u wilt dat Autopilot artefacten opslaat.
6. Voor Is uw S3-invoer een manifestbestand?, kiezen af.
7. Voor doelwit, kiezen label.
8. Voor Automatisch implementeren, kiezen af.
   
9. Onder de geavanceerde instellingenvoor Type machine learning-probleem, kiezen Binaire classificatie.
10. Voor Objectieve statistiek, kiezen AUC.
11. Voor Kies hoe u uw experiment wilt uitvoeren, kiezen Nee, voer een pilot uit om een ​​notitieboek te maken met kandidaatdefinities.
12. Kies Creëer een experiment.
    
    Voor meer informatie over het maken van een experiment, zie: Een Amazon SageMaker Autopilot-experiment maken.Het kan ongeveer 15 minuten duren om deze stap uit te voeren.
13. Als u klaar bent, kiest u Notitieblok voor kandidaat-generatie openen, waarmee een nieuwe notebook in alleen-lezen modus wordt geopend.
    
14. Kies Notitieboek importeren om het notitieboek bewerkbaar te maken.
    
15. Kies bij Afbeelding data Science.
16. Voor pit, kiezen Python 3.
17. Kies kies.
    

Deze automatisch gegenereerde notebook heeft gedetailleerde uitleg en biedt volledige controle over de eigenlijke modelbouwtaak die moet worden gevolgd. Een aangepaste versie van de notitieboekje, waar een classifier wordt getraind met behulp van Landsat-satellietbanden uit 2013, is beschikbaar in de coderepository onder notebooks/mangrove-2013.ipynb.

Het modelbouwraamwerk bestaat uit twee delen: kenmerktransformatie als onderdeel van de gegevensverwerkingsstap en hyperparameteroptimalisatie (HPO) als onderdeel van de modelselectiestap. Alle benodigde artefacten voor deze taken zijn gemaakt tijdens het Autopilot-experiment en opgeslagen in Amazon eenvoudige opslagservice (Amazon S3). De eerste notebookcel downloadt die artefacten van Amazon S3 naar de lokale Amazon Sage Maker bestandssysteem voor inspectie en eventuele noodzakelijke wijzigingen. Er zijn twee mappen: generated_module en sagemaker_automl, waar alle Python-modules en -scripts die nodig zijn om de notebook uit te voeren, zijn opgeslagen. De verschillende functietransformatiestappen zoals imputatie, schaling en PCA worden opgeslagen als: generated_modules/candidate_data_processors/dpp*.py.

Autopilot maakt drie verschillende modellen op basis van de algoritmen XGBoost, lineaire leerling en meerlaagse perceptron (MLP). Een kandidaat-pijplijn bestaat uit een van de opties voor functietransformaties, ook wel bekend als: data_transformer, en een algoritme. Een pijplijn is een Python-woordenboek en kan als volgt worden gedefinieerd:

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

In dit voorbeeld transformeert de pijplijn de trainingsgegevens volgens het script in generated_modules/candidate_data_processors/dpp5.py en bouwt een XGBoost-model. Dit is waar Autopilot volledige controle biedt aan de datawetenschapper, die de automatisch gegenereerde functietransformatie en modelselectiestappen kan kiezen of hun eigen combinatie kan bouwen.

U kunt de pijplijn nu als volgt aan een pool toevoegen zodat Autopilot het experiment kan uitvoeren:

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

Dit is een belangrijke stap waarbij u kunt besluiten om alleen een subset van door Autopilot voorgestelde kandidaten te behouden, op basis van inhoudelijke expertise, om de totale doorlooptijd te verkorten. Bewaar voorlopig alle Autopilot-suggesties, die u als volgt kunt opsommen:

automl_interactive_runner.display_candidates()

Het volledige Autopilot-experiment bestaat uit twee delen. Eerst moet u de gegevenstransformatietaken uitvoeren:

automl_interactive_runner.fit_data_transformers(parallel_jobs=7)

Deze stap zou voor alle kandidaten in ongeveer 30 minuten moeten worden voltooid, als u geen verdere wijzigingen aanbrengt in de dpp*.py bestanden.

De volgende stap is het bouwen van de beste set modellen door de hyperparameters voor de respectievelijke algoritmen af ​​te stemmen. De hyperparameters zijn meestal verdeeld in twee delen: statisch en afstembaar. De statische hyperparameters blijven gedurende het hele experiment ongewijzigd voor alle kandidaten die hetzelfde algoritme delen. Deze hyperparameters worden als een woordenboek aan het experiment doorgegeven. Als u ervoor kiest om het beste XGBoost-model te kiezen door de AUC te maximaliseren uit drie ronden van een vijfvoudig kruisvalidatieschema, ziet het woordenboek eruit als de volgende code:

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

Voor de afstembare hyperparameters moet u een ander woordenboek doorgeven met bereiken en schaaltype:

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

De complete set hyperparameters is beschikbaar in de mangrove-2013.ipynb notitieboekje.

Als u een experiment wilt maken waarbij alle zeven kandidaten parallel kunnen worden getest, maakt u een HPO-tuner met meerdere algoritmen:

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)

De objectieve metrieken worden voor elk algoritme onafhankelijk gedefinieerd:

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

Het is verspilling om alle mogelijke waarden van hyperparameters voor alle experimenten te proberen; u kunt een Bayesiaanse strategie toepassen om een ​​HPO-tuner te creëren:

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

In de standaardinstelling kiest Autopilot 250 banen in de tuner om het beste model te kiezen. Voor dit gebruik is het voldoende om in te stellen max_jobs=50 om tijd en middelen te besparen, zonder enige significante boete in termen van het kiezen van de beste set hyperparameters. Dien ten slotte de HPO-opdracht als volgt in:

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

Het proces duurt ongeveer 80 minuten op ml.m5.4xgrote instanties. U kunt de voortgang volgen op de SageMaker-console door te kiezen voor Taken voor het afstemmen van hyperparameters voor Trainingen in het navigatievenster.

U kunt een groot aantal nuttige informatie visualiseren, waaronder de prestaties van elke kandidaat, door de naam van de lopende baan te kiezen.

Vergelijk ten slotte de modelprestaties van de beste kandidaten als volgt:

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)

Het best presterende model op basis van MLP, hoewel marginaal beter dan de XGBoost-modellen met verschillende keuzes van gegevensverwerkingsstappen, duurt ook veel langer om te trainen. Belangrijke details over de MLP-modeltraining, inclusief de combinatie van gebruikte hyperparameters, vindt u als volgt:

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

Een inferentiepijplijn maken

Om gevolgtrekkingen op nieuwe gegevens te genereren, moet u een inferentiepijplijn op SageMaker construeren om het beste model te hosten dat later kan worden aangeroepen om gevolgtrekkingen te genereren. Het SageMaker-pijplijnmodel vereist drie containers als componenten: gegevenstransformatie, algoritme en inverse labeltransformatie (als numerieke voorspellingen moeten worden toegewezen aan niet-numerieke labels). Kortheidshalve wordt slechts een deel van de vereiste code weergegeven in het volgende fragment; de volledige code is beschikbaar in de mangrove-2013.ipynb notitieboekje:

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

Nadat de modelcontainers zijn gebouwd, kunt u de pijplijn als volgt bouwen en implementeren:

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)

De implementatie van het eindpunt duurt ongeveer 10 minuten.

Verkrijg inferentie over de testdataset met behulp van een eindpunt

Nadat het eindpunt is geïmplementeerd, kunt u het aanroepen met een lading aan functies B1-B7 om elke pixel in een afbeelding te classificeren als mangrove (1) of andere (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()))

Volledige details over het nabewerken van de modelvoorspellingen voor evaluatie en plotten zijn beschikbaar in: notebooks/model_performance.ipynb.

Verkrijg inferentie over de testdataset met behulp van een batchtransformatie

Nu u het best presterende model met Autopilot hebt gemaakt, kunnen we het model gebruiken voor gevolgtrekkingen. Voor het verkrijgen van gevolgtrekkingen over grote gegevenssets is het efficiënter om een ​​batchtransformatie te gebruiken. Laten we voorspellingen genereren over de gehele dataset (training en test) en de resultaten toevoegen aan de kenmerken, zodat we verdere analyses kunnen uitvoeren om bijvoorbeeld de voorspelde vs. werkelijke waarden en de verdeling van kenmerken over voorspelde klassen te controleren.

Eerst maken we een manifestbestand in Amazon S3 dat verwijst naar de locaties van de trainings- en testgegevens uit de vorige gegevensverwerkingsstappen:

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

Nu kunnen we een batchtransformatietaak maken. Omdat onze invoertrein en testdataset hebben: label als de laatste kolom, moeten we deze tijdens de inferentie laten vallen. Om dat te doen, passeren we InputFilter in de DataProcessing argument. De code "$[:-2]" geeft aan dat de laatste kolom moet worden verwijderd. De voorspelde output wordt vervolgens samengevoegd met de brongegevens voor verdere analyse.

In de volgende code construeren we de argumenten voor de batchtransformatietaak en geven deze door aan de create_transform_job functie:

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)

U kunt de status van de taak volgen op de SageMaker-console.

Modelprestaties visualiseren

U kunt nu de prestaties van het beste model op de testdataset, bestaande uit regio's uit India, Myanmar, Cuba en Vietnam, visualiseren als een verwarringsmatrix. Het model heeft een hoge terugroepwaarde voor pixels die mangroven vertegenwoordigen, maar slechts ongeveer 75% precisie. De precisie van niet-mangrove of andere pixels staat op 99% met een terugroepactie van 85%. U kunt de waarschijnlijkheidsgrens van de modelvoorspellingen afstemmen om de respectieve waarden aan te passen, afhankelijk van het specifieke gebruik.

Het is vermeldenswaard dat de resultaten een aanzienlijke verbetering zijn ten opzichte van het ingebouwde smileCart-model.

Modelvoorspellingen visualiseren

Ten slotte is het handig om de prestaties van het model op specifieke regio's op de kaart te bekijken. In de volgende afbeelding is het mangrovegebied in de grens tussen India en Bangladesh in rood weergegeven. Punten die zijn bemonsterd uit de Landsat-beeldpatch die bij de testgegevensset hoort, worden over het gebied heen gelegd, waarbij elk punt een pixel is waarvan het model bepaalt dat het mangroven vertegenwoordigt. De blauwe punten worden door het model correct geclassificeerd, terwijl de zwarte punten fouten door het model vertegenwoordigen.

De volgende afbeelding toont alleen de punten die volgens het model geen mangroven vertegenwoordigen, met hetzelfde kleurenschema als in het voorgaande voorbeeld. De grijze omtrek is het deel van de Landsat-patch dat geen mangroven bevat. Zoals blijkt uit de afbeelding, maakt het model geen enkele fout bij het classificeren van punten op water, maar staat het voor een uitdaging bij het onderscheiden van pixels die mangroven vertegenwoordigen van die die normaal gebladerte vertegenwoordigen.

De volgende afbeelding toont de prestaties van een model in de mangroveregio van Myanmar.

In de volgende afbeelding kan het model mangrovepixels beter identificeren.

Opruimen

Het SageMaker-inferentie-eindpunt blijft kosten maken als het actief blijft. Verwijder het eindpunt als volgt wanneer u klaar bent:

sagemaker.delete_endpoint(EndpointName=pipeline_model.name)

Conclusie

Deze reeks berichten bood een end-to-end raamwerk voor datawetenschappers voor het oplossen van GIS-problemen. Deel 1 toonde het ETL-proces en een handige manier om visueel met de gegevens om te gaan. Deel 2 liet zien hoe Autopilot kan worden gebruikt om het bouwen van een aangepaste mangroveclassificatie te automatiseren.

U kunt dit raamwerk gebruiken om nieuwe satellietdatasets te verkennen die een rijkere reeks banden bevatten die nuttig zijn voor mangroveclassificatie en om feature-engineering te verkennen door domeinkennis op te nemen.

Over de auteurs

Andrej Ivanovic is een inkomende masterstudent Computerwetenschappen aan de Universiteit van Toronto en recent afgestudeerd aan het Engineering Science-programma aan de Universiteit van Toronto, met als hoofdvak Machine Intelligence met een minor Robotics/Mechatronics. Hij is geïnteresseerd in computervisie, deep learning en robotica. Hij deed het werk dat in deze post wordt gepresenteerd tijdens zijn zomerstage bij Amazon.

David Dong is een datawetenschapper bij Amazon Web Services.

Arkajyoti Misra is een datawetenschapper bij Amazon LastMile Transportation. Hij is gepassioneerd door het toepassen van Computer Vision-technieken om problemen op te lossen die de aarde helpen. Hij werkt graag met non-profitorganisaties en is een van de oprichters van ekipi.org.

• Coinsmart. Europa's beste Bitcoin- en crypto-uitwisseling.
• Platoblockchain. Web3 Metaverse Intelligentie. Kennis versterkt. GRATIS TOEGANG.
• CryptoHawk. Altcoin-radar. Gratis proefversie.
• Bron: https://aws.amazon.com/blogs/machine-learning/part-2-identify-mangrove-forests-using-satellite-image-features-using-amazon-sagemaker-studio-and-amazon-sagemaker- automatische piloot/