Identificer mangroveskove ved hjælp af satellitbilledfunktioner ved hjælp af Amazon SageMaker Studio og Amazon SageMaker Autopilot - Del 2

Mangroveskove er en vigtig del af et sundt økosystem, og menneskelige aktiviteter er en af ​​hovedårsagerne til deres gradvise forsvinden fra kyststrækninger rundt om i verden. Brug af en maskinlæringsmodel (ML) til at identificere mangroveregioner fra et satellitbillede giver forskere en effektiv måde at overvåge skovenes størrelse over tid. I del 1 i denne serie viste vi, hvordan man indsamler satellitdata på en automatiseret måde og analyserer dem Amazon SageMaker Studio med interaktiv visualisering. I dette indlæg viser vi, hvordan du bruger Amazon SageMaker Autopilot at automatisere processen med at bygge en brugerdefineret mangrove-klassifikator.

Træn en model med autopilot

Autopilot giver en afbalanceret måde at bygge flere modeller på og vælge den bedste. Mens du skaber flere kombinationer af forskellige dataforbehandlingsteknikker og ML-modeller med minimal indsats, giver Autopilot dataforskeren fuldstændig kontrol over disse komponenttrin, hvis det ønskes.

Du kan bruge autopilot ved at bruge et af AWS SDK'erne (detaljer tilgængelige i API referencevejledning til autopilot) eller gennem Studio. Vi bruger Autopilot i vores Studio-løsning ved at følge de trin, der er beskrevet i dette afsnit:

1. På Studio Launcher-siden skal du vælge plustegnet for Nyt autopilot-eksperiment.
   
2. Til Tilslut dine data, Vælg Find S3 spand, og indtast det spandnavn, hvor du opbevarede trænings- og testdatasættene.
3. Til Datasæt filnavn, indtast navnet på den træningsdatafil, du oprettede i Forbered træningsdataene afsnit i del 1.
4. Til Outputdataplacering (S3-bøtte), indtast det samme spandnavn, som du brugte i trin 2.
5. Til Datasætbiblioteksnavn, indtast et mappenavn under den bøtte, hvor du vil have autopiloten til at gemme artefakter.
6. Til Er din S3-input en manifestfil?, vælg af.
7. Til mål, vælg label.
8. Til Automatisk implementering, vælg af.
   
9. Under Avancerede indstillinger, For Maskinlæringsproblemtype, vælg Binær klassifikation.
10. Til Objektiv metrik, vælg AUC.
11. Til Vælg, hvordan dit eksperiment skal køres, vælg Nej, kør en pilot for at oprette en notesbog med kandidatdefinitioner.
12. Vælg Opret eksperiment.
    
    For mere information om oprettelse af et eksperiment, se Opret et Amazon SageMaker Autopilot-eksperiment.Det kan tage omkring 15 minutter at køre dette trin.
13. Når du er færdig, skal du vælge Åbn kandidatgenereringsnotesbog, som åbner en ny notesbog i skrivebeskyttet tilstand.
    
14. Vælg Importer notesbog for at gøre notesbogen redigerbar.
    
15. Vælg for billede data, Science.
16. Til kernel, vælg Python 3.
17. Vælg Type.
    

Denne autogenererede notesbog har detaljerede forklaringer og giver fuld kontrol over den faktiske modelbygningsopgave, der skal følges. En tilpasset version af notesbog, hvor en klassifikator er trænet i Landsat-satellitbånd fra 2013, er tilgængelig i kodelageret under notebooks/mangrove-2013.ipynb.

Modelbygningsrammen består af to dele: funktionstransformation som en del af databehandlingstrinnet og hyperparameteroptimering (HPO) som en del af modeludvælgelsestrinnet. Alle de nødvendige artefakter til disse opgaver blev oprettet under autopiloteksperimentet og gemt i Amazon Simple Storage Service (Amazon S3). Den første notebook-celle downloader disse artefakter fra Amazon S3 til den lokale Amazon SageMaker filsystem til inspektion og eventuelle nødvendige ændringer. Der er to mapper: generated_module , sagemaker_automl, hvor alle Python-moduler og scripts, der er nødvendige for at køre notesbogen, er gemt. De forskellige funktionstransformationstrin som imputation, skalering og PCA gemmes som generated_modules/candidate_data_processors/dpp*.py.

Autopilot opretter tre forskellige modeller baseret på XGBoost, lineær indlærer og multi-layer perceptron (MLP) algoritmer. En kandidatpipeline består af en af ​​funktionstransformationsmulighederne, kendt som data_transformer, og en algoritme. En pipeline er en Python-ordbog og kan defineres som følger:

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

I dette eksempel transformerer pipelinen træningsdataene i henhold til scriptet ind generated_modules/candidate_data_processors/dpp5.py og bygger en XGBoost-model. Det er her, Autopilot giver fuldstændig kontrol til dataforskeren, som kan vælge de automatisk genererede funktionstransformations- og modeludvælgelsestrin eller bygge deres egen kombination.

Du kan nu tilføje pipelinen til en pulje, så Autopilot kan køre eksperimentet som følger:

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

Dette er et vigtigt skridt, hvor du kan beslutte kun at beholde en delmængde af kandidater foreslået af Autopilot, baseret på emneekspertise, for at reducere den samlede kørselstid. Behold nu alle autopilotforslag, som du kan liste som følger:

automl_interactive_runner.display_candidates()

Det fulde autopiloteksperiment udføres i to dele. Først skal du køre datatransformationsjob:

automl_interactive_runner.fit_data_transformers(parallel_jobs=7)

Dette trin bør afsluttes på cirka 30 minutter for alle kandidaterne, hvis du ikke foretager yderligere ændringer i dpp*.py filer.

Det næste trin er at bygge det bedste sæt modeller ved at justere hyperparametrene for de respektive algoritmer. Hyperparametrene er normalt opdelt i to dele: statisk og tunbar. De statiske hyperparametre forbliver uændrede gennem hele eksperimentet for alle kandidater, der deler den samme algoritme. Disse hyperparametre sendes til eksperimentet som en ordbog. Hvis du vælger at vælge den bedste XGBoost-model ved at maksimere AUC fra tre runder af et femdobbelt krydsvalideringsskema, ser ordbogen ud som følgende kode:

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

For de justerbare hyperparametre skal du videregive en anden ordbog med intervaller og skaleringstype:

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

Det komplette sæt hyperparametre er tilgængeligt i mangrove-2013.ipynb notesbog.

For at lave et eksperiment, hvor alle syv kandidater kan testes parallelt, skal du oprette en multi-algoritme HPO-tuner:

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 objektive målinger er defineret uafhængigt for hver algoritme:

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

At prøve alle mulige værdier af hyperparametre for alle eksperimenterne er spild; du kan vedtage en Bayesiansk strategi for at skabe en HPO-tuner:

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

I standardindstillingen vælger autopilot 250 job i tuneren for at vælge den bedste model. Til denne brugssituation er det tilstrækkeligt at indstille max_jobs=50 for at spare tid og ressourcer uden nogen væsentlig bøde i forhold til at vælge det bedste sæt hyperparametre. Indsend endelig HPO-jobbet som følger:

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

Processen tager omkring 80 minutter på ml.m5.4xstore instanser. Du kan overvåge fremskridt på SageMaker-konsollen ved at vælge Hyperparameter tuning job under Kurser i navigationsruden.

Du kan visualisere en lang række nyttige oplysninger, herunder hver enkelt kandidats præstation, ved at vælge navnet på det igangværende job.

Sammenlign endelig modelpræstationen for de bedste kandidater som følger:

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)

Den bedste model baseret på MLP, selvom den er marginalt bedre end XGBoost-modellerne med forskellige valg af databehandlingstrin, tager også meget længere tid at træne. Du kan finde vigtige detaljer om MLP-modeltræningen, herunder kombinationen af ​​anvendte hyperparametre, som følger:

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

Opret en slutningspipeline

For at generere inferens på nye data, skal du konstruere en inferenspipeline på SageMaker for at være vært for den bedste model, der kan kaldes senere for at generere inferens. SageMaker-pipelinemodellen kræver tre containere som dens komponenter: datatransformation, algoritme og omvendt etikettransformation (hvis numeriske forudsigelser skal kortlægges på ikke-numeriske etiketter). For kortheds skyld vises kun en del af den påkrævede kode i følgende uddrag; den komplette kode er tilgængelig i mangrove-2013.ipynb notesbog:

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

Når modelbeholderne er bygget, kan du konstruere og implementere rørledningen som følger:

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)

Slutpunktsimplementeringen tager omkring 10 minutter at fuldføre.

Få konklusioner om testdatasættet ved hjælp af et slutpunkt

Når slutpunktet er implementeret, kan du aktivere det med en nyttelast af funktioner B1–B7 for at klassificere hver pixel i et billede som enten mangrove (1) eller andet (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()))

Fuldstændige detaljer om efterbehandling af modelforudsigelserne til evaluering og plotning er tilgængelige i notebooks/model_performance.ipynb.

Få konklusioner om testdatasættet ved hjælp af en batchtransformation

Nu hvor du har skabt den bedst ydende model med autopilot, kan vi bruge modellen til slutninger. For at få konklusioner om store datasæt er det mere effektivt at bruge en batchtransformation. Lad os generere forudsigelser på hele datasættet (træning og test) og tilføje resultaterne til funktionerne, så vi kan udføre yderligere analyse for for eksempel at kontrollere de forudsagte vs. faktiske værdier og fordelingen af ​​funktioner blandt forudsagte klasser.

Først opretter vi en manifestfil i Amazon S3, der peger på placeringen af ​​trænings- og testdata fra de tidligere databehandlingstrin:

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 kan vi oprette et batch-transformationsjob. Fordi vores inputtog og testdatasæt har label som den sidste kolonne skal vi droppe den under inferens. For at gøre det passerer vi InputFilter i DataProcessing argument. Koden "$[:-2]" angiver at droppe den sidste kolonne. Det forudsagte output sættes derefter sammen med kildedataene for yderligere analyse.

I den følgende kode konstruerer vi argumenterne for batchtransformationsjobbet og sender derefter til create_transform_job fungere:

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)

Du kan overvåge status for jobbet på SageMaker-konsollen.

Visualiser modellens ydeevne

Du kan nu visualisere ydeevnen af ​​den bedste model på testdatasættet, bestående af regioner fra Indien, Myanmar, Cuba og Vietnam, som en forvirringsmatrix. Modellen har en høj genkaldelsesværdi for pixels, der repræsenterer mangrover, men kun omkring 75 % præcision. Præcisionen af ​​ikke-mangrove eller andre pixels står på 99 % med en genkaldelse på 85 %. Du kan justere sandsynlighedsgrænsen for modelforudsigelserne for at justere de respektive værdier afhængigt af den særlige brugssituation.

Det er værd at bemærke, at resultaterne er en væsentlig forbedring i forhold til den indbyggede smileCart-model.

Visualiser modelforudsigelser

Endelig er det nyttigt at observere modellens ydeevne på specifikke områder på kortet. På det følgende billede er mangroveområdet i grænsen mellem Indien og Bangladesh afbildet med rødt. Punkter, der er samplet fra Landsat-billedplasteret, der tilhører testdatasættet, overlejres på området, hvor hvert punkt er en pixel, som modellen bestemmer repræsenterer mangrover. De blå punkter er klassificeret korrekt af modellen, mens de sorte punkter repræsenterer fejl i modellen.

Det følgende billede viser kun de punkter, som modellen forudsagde ikke at repræsentere mangrover, med samme farveskema som det foregående eksempel. Det grå omrids er den del af Landsat-området, der ikke indeholder nogen mangrover. Som det fremgår af billedet, laver modellen ingen fejl ved at klassificere punkter på vand, men står over for en udfordring, når den skal skelne pixels, der repræsenterer mangrover, fra dem, der repræsenterer almindeligt løv.

Følgende billede viser modellens ydeevne på Myanmars mangroveregion.

På det følgende billede klarer modellen et bedre stykke arbejde med at identificere mangrovepixel.

Ryd op

SageMaker-slutningsendepunktet fortsætter med at pådrage sig omkostninger, hvis det efterlades. Slet slutpunktet som følger, når du er færdig:

sagemaker.delete_endpoint(EndpointName=pipeline_model.name)

Konklusion

Denne serie af indlæg gav en ende-til-ende-ramme for datavidenskabsfolk til at løse GIS-problemer. del 1 viste ETL-processen og en bekvem måde at visuelt interagere med dataene. Del 2 viste, hvordan man bruger autopilot til at automatisere bygningen af ​​en brugerdefineret mangrove-klassificering.

Du kan bruge denne ramme til at udforske nye satellitdatasæt, der indeholder et rigere sæt bånd, der er nyttige til mangroveklassificering, og udforske funktionsteknologi ved at inkorporere domæneviden.

Om forfatterne

Andrei Ivanovic er en kommende Master of Computer Science-studerende ved University of Toronto og nyuddannet fra Engineering Science-programmet ved University of Toronto, med hovedfag i Machine Intelligence med en Robotics/Mekatronik-bifag. Han er interesseret i computersyn, deep learning og robotteknologi. Han udførte arbejdet præsenteret i dette indlæg under sit sommerpraktik hos Amazon.

David Dong er dataforsker hos Amazon Web Services.

Arkajyoti Misra er dataforsker hos Amazon LastMile Transportation. Han brænder for at anvende Computer Vision-teknikker til at løse problemer, der hjælper jorden. Han elsker at arbejde med non-profit organisationer og er stiftende medlem af ekipi.org.

• Coinsmart. Europas bedste Bitcoin og Crypto Exchange.
• Platoblokkæde. Web3 Metaverse Intelligence. Viden forstærket. FRI ADGANG.
• CryptoHawk. Altcoin radar. Gratis prøveversion.
• Kilde: https://aws.amazon.com/blogs/machine-learning/part-2-identify-mangrove-forests-using-satellite-image-features-using-amazon-sagemaker-studio-and-amazon-sagemaker- autopilot/