Identifiera mangroveskogar med hjälp av satellitbildsfunktioner med Amazon SageMaker Studio och Amazon SageMaker Autopilot – Del 2

Mangroveskogar är en viktig del av ett hälsosamt ekosystem, och mänskliga aktiviteter är en av huvudorsakerna till att de gradvis försvinner från kuster runt om i världen. Att använda en maskininlärningsmodell (ML) för att identifiera mangroveregioner från en satellitbild ger forskare ett effektivt sätt att övervaka skogarnas storlek över tid. I del 1 i den här serien visade vi hur man samlar in satellitdata på ett automatiserat sätt och analyserar det Amazon SageMaker Studio med interaktiv visualisering. I det här inlägget visar vi hur man använder Amazon SageMaker autopilot för att automatisera processen att bygga en anpassad mangroveklassificerare.

Träna en modell med autopilot

Autopilot ger ett balanserat sätt att bygga flera modeller och välja den bästa. Samtidigt som man skapar flera kombinationer av olika dataförbehandlingstekniker och ML-modeller med minimal ansträngning, ger Autopilot fullständig kontroll över dessa komponentstegen till dataforskaren, om så önskas.

Du kan använda autopilot med en av AWS SDK:er (detaljer finns i API-referensguide för autopilot) eller via Studio. Vi använder autopilot i vår Studio-lösning genom att följa stegen som beskrivs i det här avsnittet:

1. På sidan Studio Launcher väljer du plustecknet för Nytt autopilotexperiment.
   
2. För Anslut dina data, Välj Hitta S3 hink, och ange bucket-namnet där du förvarade tränings- och testdatauppsättningarna.
3. För Datauppsättningsfilnamn, ange namnet på träningsdatafilen du skapade i Förbered träningsdata avsnitt i del 1.
4. För Utdataplats (S3-hink), ange samma hinknamn som du använde i steg 2.
5. För Datauppsättningskatalognamn, ange ett mappnamn under hinken där du vill att autopiloten ska lagra artefakter.
6. För Är din S3-inmatning en manifestfil?väljer off.
7. För Måletväljer etikett.
8. För Automatisk distributionväljer off.
   
9. Enligt Avancerade inställningar, För Problemtyp för maskininlärningväljer Binär klassificering.
10. För Objektiv mätvärdeväljer AUC.
11. För Välj hur du vill köra ditt experimentväljer Nej, kör en pilot för att skapa en anteckningsbok med kandidatdefinitioner.
12. Välja Skapa experiment.
    
    För mer information om att skapa ett experiment, se Skapa ett Amazon SageMaker Autopilot-experiment.Det kan ta cirka 15 minuter att köra detta steg.
13. När du är klar väljer du Öppna anteckningsbok för kandidatgenerering, som öppnar en ny anteckningsbok i skrivskyddat läge.
    
14. Välja Importera anteckningsbok för att göra anteckningsboken redigerbar.
    
15. För Bild, välj Data Science.
16. För Kärnaväljer python 3.
17. Välja Välja.
    

Denna automatiskt genererade anteckningsbok har detaljerade förklaringar och ger fullständig kontroll över själva modellbyggandet. En anpassad version av anteckningsbok, där en klassificerare tränas med Landsat-satellitband från 2013, finns tillgänglig i kodförrådet under notebooks/mangrove-2013.ipynb.

Modellbyggnadsramverket består av två delar: funktionstransformation som en del av databearbetningssteget och hyperparameteroptimering (HPO) som en del av modellvalssteget. Alla nödvändiga artefakter för dessa uppgifter skapades under autopilotexperimentet och sparades i Amazon enkel lagringstjänst (Amazon S3). Den första bärbara cellen laddar ner dessa artefakter från Amazon S3 till den lokala Amazon SageMaker filsystem för inspektion och eventuella nödvändiga ändringar. Det finns två mappar: generated_module och sagemaker_automl, där alla Python-moduler och skript som behövs för att köra anteckningsboken lagras. De olika funktionstransformationsstegen som imputering, skalning och PCA sparas som generated_modules/candidate_data_processors/dpp*.py.

Autopilot skapar tre olika modeller baserade på algoritmerna XGBoost, linjär inlärare och multi-layer perceptron (MLP). En kandidatpipeline består av ett av funktionstransformationsalternativen, känd som data_transformer, och en algoritm. En pipeline är en Python-ordbok och kan definieras enligt följande:

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 det här exemplet omvandlar pipelinen träningsdata enligt skriptet in generated_modules/candidate_data_processors/dpp5.py och bygger en XGBoost-modell. Det är här Autopilot ger fullständig kontroll till dataforskaren, som kan välja de automatiskt genererade funktionstransformations- och modellvalsstegen eller bygga sin egen kombination.

Du kan nu lägga till pipelinen i en pool för att Autopilot ska köra experimentet enligt följande:

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

Detta är ett viktigt steg där du kan bestämma dig för att bara behålla en delmängd av kandidater som föreslås av Autopilot, baserat på ämnesexpertis, för att minska den totala körtiden. För nu, behåll alla autopilotförslag, som du kan lista enligt följande:

automl_interactive_runner.display_candidates()

Det fullständiga autopilotexperimentet görs i två delar. Först måste du köra datatransformationsjobben:

automl_interactive_runner.fit_data_transformers(parallel_jobs=7)

Detta steg bör slutföras på cirka 30 minuter för alla kandidater, om du inte gör några ytterligare ändringar i dpp*.py filer.

Nästa steg är att bygga den bästa uppsättningen modeller genom att justera hyperparametrarna för respektive algoritm. Hyperparametrarna är vanligtvis uppdelade i två delar: statisk och avstämbar. De statiska hyperparametrarna förblir oförändrade under hela experimentet för alla kandidater som delar samma algoritm. Dessa hyperparametrar skickas till experimentet som en ordbok. Om du väljer att välja den bästa XGBoost-modellen genom att maximera AUC från tre omgångar av ett femfaldigt korsvalideringsschema, ser ordboken ut som följande kod:

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

För de avstämbara hyperparametrarna måste du skicka en annan ordbok med intervall och skalningstyp:

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

Den kompletta uppsättningen hyperparametrar är tillgänglig i mangrove-2013.ipynb anteckningsbok.

För att skapa ett experiment där alla sju kandidaterna kan testas parallellt, skapa en HPO-tuner med flera algoritmer:

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 objektiva mätvärdena definieras oberoende för varje algoritm:

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

Att prova alla möjliga värden på hyperparametrar för alla experiment är slösaktigt; du kan använda en Bayesiansk strategi för att skapa 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 standardinställningen väljer autopilot 250 jobb i tunern för att välja den bästa modellen. För detta användningsfall räcker det att ställa in max_jobs=50 för att spara tid och resurser, utan några betydande straff när det gäller att välja den bästa uppsättningen hyperparametrar. Slutligen, skicka in HPO-jobbet enligt följande:

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

Processen tar cirka 80 minuter på ml.m5.4xlarge instanser. Du kan övervaka framstegen på SageMaker-konsolen genom att välja Hyperparameter tuning jobb under Utbildning i navigeringsfönstret.

Du kan visualisera en mängd användbar information, inklusive resultatet för varje kandidat, genom att välja namnet på det pågående jobbet.

Slutligen, jämför modellprestandan för de bästa kandidaterna enligt följande:

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 topppresterande modellen baserad på MLP, även om den är marginellt bättre än XGBoost-modellerna med olika val av databehandlingssteg, tar också mycket längre tid att träna. Du kan hitta viktig information om MLP-modellutbildningen, inklusive kombinationen av hyperparametrar som används, enligt följande:

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

Skapa en slutledningspipeline

För att generera inferens på ny data måste du konstruera en inferenspipeline på SageMaker för att vara värd för den bästa modellen som kan anropas senare för att generera inferens. SageMakers pipelinemodell kräver tre behållare som dess komponenter: datatransformation, algoritm och omvänd etiketttransformation (om numeriska förutsägelser behöver mappas till icke-numeriska etiketter). För korthetens skull visas endast en del av den obligatoriska koden i följande kodavsnitt; hela koden finns tillgänglig i mangrove-2013.ipynb anteckningsbok:

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

Efter att modellbehållarna har byggts kan du konstruera och distribuera pipelinen enligt följande:

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 tar cirka 10 minuter att slutföra.

Få slutsatser om testdatauppsättningen med hjälp av en slutpunkt

Efter att slutpunkten har distribuerats kan du anropa den med en nyttolast av funktioner B1–B7 för att klassificera varje pixel i en bild som antingen mangrove (1) eller annan (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()))

Fullständig information om efterbearbetning av modellförutsägelser för utvärdering och plottning finns i notebooks/model_performance.ipynb.

Få slutsatser om testdatauppsättningen med hjälp av en batchtransform

Nu när du har skapat den bäst presterande modellen med autopilot kan vi använda modellen för slutledning. För att få slutsatser om stora datamängder är det mer effektivt att använda en batchtransform. Låt oss generera förutsägelser på hela datamängden (träning och test) och bifoga resultaten till funktionerna, så att vi kan utföra ytterligare analys för att till exempel kontrollera de förutspådda vs. faktiska värdena och fördelningen av funktioner mellan förutsagda klasser.

Först skapar vi en manifestfil i Amazon S3 som pekar på platserna för utbildningen och testdata från de tidigare databearbetningsstegen:

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 skapa ett batchtransformeringsjobb. Eftersom vårt indatatåg och testdataset har label som den sista kolumnen måste vi släppa den under slutledning. För att göra det passerar vi InputFilter i DataProcessing argument. Koden "$[:-2]" anger att den sista kolumnen ska släppas. Den förutsagda utdatan sammanfogas sedan med källdata för vidare analys.

I följande kod konstruerar vi argumenten för batchtransformeringsjobbet och skickar sedan vidare till create_transform_job fungera:

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 övervaka jobbets status på SageMaker-konsolen.

Visualisera modellens prestanda

Du kan nu visualisera prestandan för den bästa modellen på testdatauppsättningen, bestående av regioner från Indien, Myanmar, Kuba och Vietnam, som en förvirringsmatris. Modellen har ett högt återkallningsvärde för pixlar som representerar mangrove, men bara cirka 75 % precision. Precisionen för icke-mangrove eller andra pixlar ligger på 99 % med en återkallelse på 85 %. Du kan ställa in sannolikhetsgränsen för modellförutsägelserna för att justera respektive värden beroende på det specifika användningsfallet.

Det är värt att notera att resultaten är en betydande förbättring jämfört med den inbyggda smileCart-modellen.

Visualisera modellförutsägelser

Slutligen är det användbart att observera modellens prestanda på specifika regioner på kartan. På följande bild är mangroveområdet i gränsen mellan Indien och Bangladesh avbildat i rött. Punkter som samplas från Landsat-bildlappen som tillhör testdatauppsättningen överlagras på regionen, där varje punkt är en pixel som modellen bestämmer representerar mangrove. De blå punkterna klassificeras korrekt av modellen, medan de svarta punkterna representerar misstag av modellen.

Följande bild visar endast de punkter som modellen förutspådde att inte representera mangrove, med samma färgschema som föregående exempel. Den grå konturen är den del av Landsat-lappen som inte innehåller några mangroveträd. Som framgår av bilden gör modellen inga misstag med att klassificera punkter på vatten, utan står inför en utmaning när den särskiljer pixlar som representerar mangrove från de som representerar vanligt lövverk.

Följande bild visar modellens prestanda i Myanmars mangroveregion.

I följande bild gör modellen ett bättre jobb med att identifiera mangrovepixlar.

Städa upp

SageMaker slutpunkten fortsätter att dra på sig kostnader om den lämnas igång. Ta bort slutpunkten enligt följande när du är klar:

sagemaker.delete_endpoint(EndpointName=pipeline_model.name)

Slutsats

Den här serien av inlägg gav ett ramverk för datavetare för att lösa GIS-problem. del 1 visade ETL-processen och ett bekvämt sätt att visuellt interagera med datan. Del 2 visade hur man använder autopilot för att automatisera att bygga en anpassad mangroveklassificerare.

Du kan använda det här ramverket för att utforska nya satellitdatauppsättningar som innehåller en rikare uppsättning band användbara för mangroveklassificering och utforska funktionsteknik genom att införliva domänkunskap.

Om författarna

Andrei Ivanovic är en tillträdande masterstudent i datavetenskap vid University of Toronto och nyutexaminerad från Engineering Science-programmet vid University of Toronto, med huvudämne i Machine Intelligence med en biroll inom Robotics/Mekatronik. Han är intresserad av datorseende, djupinlärning och robotik. Han gjorde det arbete som presenterades i det här inlägget under sin sommarpraktik på Amazon.

David Dong är dataforskare på Amazon Web Services.

Arkajyoti Misra är en dataforskare på Amazon LastMile Transportation. Han brinner för att tillämpa datorseendetekniker för att lösa problem som hjälper jorden. Han älskar att arbeta med ideella organisationer och är en av grundarna av ekipi.org.

• Myntsmart. Europas bästa bitcoin- och kryptobörs.
• Platoblockchain. Web3 Metaverse Intelligence. Kunskap förstärkt. FRI TILLGÅNG.
• CryptoHawk. Altcoin radar. Gratis provperiod.
• Källa: https://aws.amazon.com/blogs/machine-learning/part-2-identify-mangrove-forests-using-satellite-image-features-using-amazon-sagemaker-studio-and-amazon-sagemaker- autopilot/