Identifiser mangroveskoger ved hjelp av satellittbildefunksjoner ved hjelp av Amazon SageMaker Studio og Amazon SageMaker Autopilot – Del 2

Mangroveskoger er en viktig del av et sunt økosystem, og menneskelige aktiviteter er en av hovedårsakene til at de gradvis forsvinner fra kystlinjer rundt om i verden. Å bruke en maskinlæringsmodell (ML) for å identifisere mangroveregioner fra et satellittbilde gir forskere en effektiv måte å overvåke størrelsen på skogene over tid. I Del 1 av denne serien viste vi hvordan man samler satellittdata på en automatisert måte og analyserer dem Amazon SageMaker Studio med interaktiv visualisering. I dette innlegget viser vi hvordan du bruker Amazon SageMaker Autopilot å automatisere prosessen med å bygge en tilpasset mangroveklassifisering.

Tren en modell med autopilot

Autopilot gir en balansert måte å bygge flere modeller på og velge den beste. Mens du lager flere kombinasjoner av forskjellige dataforbehandlingsteknikker og ML-modeller med minimal innsats, gir Autopilot full kontroll over disse komponenttrinnene til dataforskeren, hvis ønskelig.

Du kan bruke autopilot ved å bruke en av AWS SDK-ene (detaljer tilgjengelig i API-referanseveiledning for autopilot) eller gjennom Studio. Vi bruker Autopilot i Studio-løsningen vår ved å følge trinnene som er skissert i denne delen:

1. På Studio Launcher-siden velger du plusstegnet for Nytt autopiloteksperiment.
   
2. Til Koble til dataene dine, plukke ut Finn S3 bøtte, og skriv inn bøttenavnet der du oppbevarte trenings- og testdatasettene.
3. Til Datasettfilnavn, skriv inn navnet på treningsdatafilen du opprettet i Forbered treningsdataene delen i Del 1.
4. Til Utdataplassering (S3-bøtte), skriv inn det samme bøttenavnet du brukte i trinn 2.
5. Til Datasettkatalognavn, skriv inn et mappenavn under bøtten der du vil at autopiloten skal lagre artefakter.
6. Til Er S3-inndata en manifestfil?, velg Av.
7. Til Target, velg etikett.
8. Til Automatisk distribusjon, velg Av.
   
9. Under Avanserte innstillingerFor Problemtype for maskinlæring, velg Binær klassifisering.
10. Til Objektiv metrikk, velg AUC.
11. Til Velg hvordan eksperimentet skal kjøres, velg Nei, kjør en pilot for å lage en notatbok med kandidatdefinisjoner.
12. Velg Lag eksperiment.
    
    For mer informasjon om å lage et eksperiment, se Lag et Amazon SageMaker Autopilot-eksperiment.Det kan ta omtrent 15 minutter å kjøre dette trinnet.
13. Når du er ferdig, velg Åpne notatbok for kandidatgenerering, som åpner en ny notatbok i skrivebeskyttet modus.
    
14. Velg Importer notatbok for å gjøre notatboken redigerbar.
    
15. Velg for bilde data Science.
16. Til Kernel, velg Python 3.
17. Velg Plukke ut.
    

Denne automatisk genererte notatboken har detaljerte forklaringer og gir full kontroll over selve modellbyggingsoppgaven som skal følges. En tilpasset versjon av bærbare, hvor en klassifiserer er trent ved bruk av Landsat-satellittbånd fra 2013, er tilgjengelig i kodelageret under notebooks/mangrove-2013.ipynb.

Rammeverket for modellbygging består av to deler: funksjonstransformasjon som en del av databehandlingstrinnet, og hyperparameteroptimalisering (HPO) som en del av modellvalgtrinnet. Alle nødvendige artefakter for disse oppgavene ble opprettet under autopiloteksperimentet og lagret i Amazon enkel lagringstjeneste (Amazon S3). Den første bærbare cellen laster ned disse artefaktene fra Amazon S3 til den lokale Amazon SageMaker filsystem for inspeksjon og eventuelle nødvendige endringer. Det er to mapper: generated_module og sagemaker_automl, der alle Python-modulene og skriptene som er nødvendige for å kjøre notatboken er lagret. De forskjellige funksjonstransformasjonstrinnene som imputering, skalering og PCA lagres som generated_modules/candidate_data_processors/dpp*.py.

Autopiloten lager tre forskjellige modeller basert på XGBoost, lineær innlærer og multi-layer perceptron (MLP) algoritmer. En kandidatpipeline består av et av funksjonstransformasjonsalternativene, kjent som data_transformer, og en algoritme. En pipeline er en Python-ordbok 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 eksemplet transformerer pipelinen treningsdataene i henhold til skriptet inn generated_modules/candidate_data_processors/dpp5.py og bygger en XGBoost-modell. Det er her Autopilot gir full kontroll til dataforskeren, som kan velge de automatisk genererte funksjonstransformasjonene og modellvalgtrinnene eller bygge sin egen kombinasjon.

Du kan nå legge til rørledningen til et basseng for at autopilot skal kjø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 viktig skritt der du kan bestemme deg for å beholde bare et undersett av kandidater foreslått av Autopilot, basert på fagekspertise, for å redusere den totale kjøretiden. For nå, behold alle autopilotforslag, som du kan liste opp som følger:

automl_interactive_runner.display_candidates()

Det fullstendige autopiloteksperimentet gjøres i to deler. Først må du kjøre datatransformasjonsjobbene:

automl_interactive_runner.fit_data_transformers(parallel_jobs=7)

Dette trinnet bør fullføres på omtrent 30 minutter for alle kandidatene, hvis du ikke gjør flere endringer i dpp*.py filer.

Det neste trinnet er å bygge det beste settet med modeller ved å justere hyperparametrene for de respektive algoritmene. Hyperparametrene er vanligvis delt inn i to deler: statisk og justerbar. De statiske hyperparametrene forblir uendret gjennom eksperimentet for alle kandidater som deler samme algoritme. Disse hyperparametrene sendes til eksperimentet som en ordbok. Hvis du velger å velge den beste XGBoost-modellen ved å maksimere AUC fra tre runder med et femdobbelt kryssvalideringsskjema, ser ordboken ut som følgende kode:

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

For de justerbare hyperparametrene må du sende en annen ordbok med områder 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 settet med hyperparametre er tilgjengelig i mangrove-2013.ipynb bærbare.

For å lage et eksperiment der alle syv kandidatene kan testes parallelt, lag 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 beregningene er definert uavhengig for hver algoritme:

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

Å prøve alle mulige verdier av hyperparametre for alle eksperimentene er bortkastet; du kan bruke en Bayesiansk strategi for å lage 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 standardinnstillingen velger autopilot 250 jobber i tuneren for å velge den beste modellen. For dette brukstilfellet er det tilstrekkelig å stille inn max_jobs=50 for å spare tid og ressurser, uten noen betydelig straff når det gjelder å velge det beste settet med hyperparametere. Til slutt, send inn HPO-jobben som følger:

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

Prosessen tar ca. 80 minutter på ml.m5.4xstore forekomster. Du kan overvåke fremdriften på SageMaker-konsollen ved å velge Hyperparameter tuning jobber etter Kurs i navigasjonsruten.

Du kan visualisere en rekke nyttig informasjon, inkludert ytelsen til hver kandidat, ved å velge navnet på jobben som pågår.

Til slutt, sammenligne modellytelsen til de beste kandidatene 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 beste modellen basert på MLP, selv om den er marginalt bedre enn XGBoost-modellene med ulike valg av databehandlingstrinn, tar også mye lengre tid å trene. Du kan finne viktige detaljer om MLP-modellopplæringen, inkludert kombinasjonen av hyperparametre som brukes, som følger:

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

Lag en slutningspipeline

For å generere inferens på nye data, må du konstruere en inferenspipeline på SageMaker for å være vert for den beste modellen som kan kalles senere for å generere inferens. SageMaker-pipelinemodellen krever tre beholdere som komponenter: datatransformasjon, algoritme og invers etiketttransformasjon (hvis numeriske spådommer må tilordnes til ikke-numeriske etiketter). For korthets skyld vises bare en del av den nødvendige koden i følgende kodebit; den komplette koden er tilgjengelig i mangrove-2013.ipynb bærbare:

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

Etter at modellbeholderne er bygget, kan du konstruere og distribuere 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)

Sluttpunktdistribusjonen tar omtrent 10 minutter å fullføre.

Få konklusjon om testdatasettet ved hjelp av et endepunkt

Etter at endepunktet er distribuert, kan du påkalle det med en nyttelast av funksjoner B1–B7 for å klassifisere hver piksel i et bilde som enten mangrove (1) eller annen (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()))

Fullstendige detaljer om etterbehandling av modellprediksjonene for evaluering og plotting er tilgjengelig i notebooks/model_performance.ipynb.

Få slutning om testdatasettet ved hjelp av en batchtransformasjon

Nå som du har laget den best ytelse modellen med autopilot, kan vi bruke modellen for slutning. For å få slutninger om store datasett, er det mer effektivt å bruke en batchtransformasjon. La oss generere spådommer på hele datasettet (trening og test) og legge til resultatene til funksjonene, slik at vi kan utføre ytterligere analyse for for eksempel å sjekke predikerte vs. faktiske og fordelingen av funksjoner blant predikerte klasser.

Først lager vi en manifestfil i Amazon S3 som peker på plasseringene til trenings- og testdataene fra de forrige databehandlingstrinnene:

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

Nå kan vi lage en batch-transformeringsjobb. Fordi vårt inputtog og testdatasett har label som den siste kolonnen, må vi slippe den under inferens. For å gjøre det, passerer vi InputFilter i DataProcessing argument. Koden "$[:-2]" indikerer å slippe den siste kolonnen. Den forutsagte utgangen slås deretter sammen med kildedataene for videre analyse.

I den følgende koden konstruerer vi argumentene for batch-transformeringsjobben og sender deretter til create_transform_job funksjon:

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åke statusen til jobben på SageMaker-konsollen.

Visualiser modellens ytelse

Du kan nå visualisere ytelsen til den beste modellen på testdatasettet, bestående av regioner fra India, Myanmar, Cuba og Vietnam, som en forvirringsmatrise. Modellen har en høy gjenkallingsverdi for piksler som representerer mangrover, men bare omtrent 75 % presisjon. Presisjonen til ikke-mangrove eller andre piksler står på 99 % med en tilbakekalling på 85 %. Du kan justere sannsynlighetsavskjæringen for modellprediksjonene for å justere de respektive verdiene avhengig av den spesielle brukssaken.

Det er verdt å merke seg at resultatene er en betydelig forbedring i forhold til den innebygde smileCart-modellen.

Visualiser modellspådommer

Til slutt er det nyttig å observere modellens ytelse på spesifikke områder på kartet. I det følgende bildet er mangroveområdet i grensen mellom India og Bangladesh avbildet i rødt. Punkter samplet fra Landsat-bildelappen som tilhører testdatasettet, legges over regionen, der hvert punkt er en piksel som modellen bestemmer å representere mangrover. De blå punktene klassifiseres riktig av modellen, mens de svarte punktene representerer feil av modellen.

Følgende bilde viser bare punktene som modellen spådde å ikke representere mangrover, med samme fargeskjema som det foregående eksempelet. Det grå omrisset er den delen av Landsat-flekken som ikke inkluderer noen mangrover. Som det fremgår av bildet, gjør ikke modellen noen feil ved å klassifisere punkter på vann, men står overfor en utfordring når den skiller piksler som representerer mangrover fra de som representerer vanlig løvverk.

Følgende bilde viser modellytelse på Myanmars mangroveregion.

I det følgende bildet gjør modellen en bedre jobb med å identifisere mangrove-piksler.

Rydd opp

SageMaker-slutningsendepunktet fortsetter å pådra seg kostnader hvis det kjøres. Slett endepunktet på følgende måte når du er ferdig:

sagemaker.delete_endpoint(EndpointName=pipeline_model.name)

konklusjonen

Denne serien med innlegg ga et ende-til-ende-rammeverk for dataforskere for å løse GIS-problemer. Del 1 viste ETL-prosessen og en praktisk måte å visuelt samhandle med dataene. Del 2 viste hvordan man bruker autopilot til å automatisere bygging av en tilpasset mangroveklassifisering.

Du kan bruke dette rammeverket til å utforske nye satellittdatasett som inneholder et rikere sett med bånd som er nyttige for mangroveklassifisering og utforske funksjonsteknikk ved å inkorporere domenekunnskap.

Om forfatterne

Andrei Ivanovic er en innkommende mastergrad i informatikkstudent ved University of Toronto og nyutdannet ved Engineering Science-programmet ved University of Toronto, med hovedfag i Machine Intelligence med en robotikk/mekatronikk-fagfag. Han er interessert i datasyn, dyp læring og robotikk. Han utførte arbeidet som ble presentert i dette innlegget under sitt sommerpraksis hos Amazon.

David Dong er dataforsker hos Amazon Web Services.

Arkajyoti Misra er dataforsker hos Amazon LastMile Transportation. Han brenner for å bruke Computer Vision-teknikker for å løse problemer som hjelper jorden. Han elsker å jobbe med ideelle organisasjoner og er et grunnleggende medlem av ekipi.org.

• Myntsmart. Europas beste Bitcoin og Crypto Exchange.
• Platoblokkkjede. Web3 Metaverse Intelligence. Kunnskap forsterket. FRI TILGANG.
• CryptoHawk. Altcoin Radar. Gratis prøveperiode.
• 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/