Identificați pădurile de mangrove folosind caracteristici de imagine prin satelit folosind Amazon SageMaker Studio și Amazon SageMaker Autopilot – Partea 2

Pădurile de mangrove sunt o parte importantă a unui ecosistem sănătos, iar activitățile umane sunt unul dintre motivele majore ale dispariției lor treptate de pe coastele din întreaga lume. Utilizarea unui model de învățare automată (ML) pentru a identifica regiunile de mangrove dintr-o imagine din satelit oferă cercetătorilor o modalitate eficientă de a monitoriza dimensiunea pădurilor în timp. În Partea 1 din această serie, am arătat cum să culegem datele satelitare într-un mod automat și să le analizăm Amazon SageMaker Studio cu vizualizare interactivă. În această postare, vă arătăm cum se utilizează Pilot automat cu Amazon SageMaker pentru a automatiza procesul de construire a unui clasificator personalizat de mangrove.

Antrenează un model cu Autopilot

Autopilot oferă o modalitate echilibrată de a construi mai multe modele și de a-l selecta pe cel mai bun. În timp ce creează mai multe combinații de diferite tehnici de preprocesare a datelor și modele ML cu efort minim, Autopilot oferă cercetătorului de date control complet asupra acestor pași componente, dacă dorește.

Puteți utiliza Autopilot folosind unul dintre SDK-urile AWS (detalii disponibile în Ghid de referință API pentru Autopilot) sau prin Studio. Utilizăm Autopilot în soluția noastră Studio, urmând pașii descriși în această secțiune:

1. Pe pagina Studio Launcher, alegeți semnul plus pentru Nou experiment Autopilot.
   
2. Pentru Conectați-vă datele, Selectați Găsiți găleată S3și introduceți numele compartimentului în care ați păstrat seturile de date de antrenament și de testare.
3. Pentru Numele fișierului setului de date, introduceți numele fișierului de date de antrenament pe care l-ați creat în fișierul Pregătiți datele de antrenament secțiune în Partea 1.
4. Pentru Locația datelor de ieșire (bucket S3), introduceți același nume de compartiment pe care l-ați folosit la pasul 2.
5. Pentru Numele directorului setului de date, introduceți un nume de folder sub compartimentul în care doriți ca Autopilot să stocheze artefacte.
6. Pentru Intrarea dvs. S3 este un fișier manifest?, alege de pe.
7. Pentru Ţintă, alege etichetă.
8. Pentru Implementare automată, alege de pe.
   
9. Sub setările avansate, Pentru Tip de problemă de învățare automată, alege Clasificare binară.
10. Pentru Măsură obiectivă, alege ASC.
11. Pentru Alegeți cum să rulați experimentul, alege Nu, rulați un pilot pentru a crea un blocnotes cu definițiile candidaților.
12. Alege Creați experiment.
    
    Pentru mai multe informații despre crearea unui experiment, consultați Creați un experiment Amazon SageMaker Autopilot.Poate dura aproximativ 15 minute pentru a executa acest pas.
13. Când ați terminat, alegeți Deschideți caietul de generație de candidați, care deschide un nou blocnotes în modul numai citire.
    
14. Alege Import notebook pentru a face caietul editabil.
    
15. Pentru Imagine, alegeți Știința datelor.
16. Pentru Nucleu, alege Python 3.
17. Alege Selectați.
    

Acest blocnotes generat automat are explicații detaliate și oferă control complet asupra sarcinii reale de construire a modelului de urmat. O versiune personalizată a caiet, unde un clasificator este instruit folosind benzile de satelit Landsat din 2013, este disponibil în depozitul de coduri sub notebooks/mangrove-2013.ipynb.

Cadrul de construire a modelului constă din două părți: transformarea caracteristicilor ca parte a pasului de procesare a datelor și optimizarea hiperparametrului (HPO) ca parte a pasului de selecție a modelului. Toate artefactele necesare pentru aceste sarcini au fost create în timpul experimentului Autopilot și salvate în Serviciul Amazon de stocare simplă (Amazon S3). Prima celulă de notebook descarcă acele artefacte de pe Amazon S3 în local Amazon SageMaker sistem de fișiere pentru inspecție și orice modificare necesară. Există două foldere: generated_module și sagemaker_automl, unde sunt stocate toate modulele și scripturile Python necesare rulării notebook-ului. Diferiții pași de transformare a caracteristicilor, cum ar fi imputarea, scalarea și PCA, sunt salvați ca generated_modules/candidate_data_processors/dpp*.py.

Autopilot creează trei modele diferite bazate pe algoritmii XGBoost, liniar Learner și multi-layer perceptron (MLP). O conductă candidată constă dintr-una dintre opțiunile de transformare a caracteristicilor, cunoscute ca data_transformer, și un algoritm. O conductă este un dicționar Python și poate fi definită după cum urmează:

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

În acest exemplu, pipeline transformă datele de antrenament conform scriptului în generated_modules/candidate_data_processors/dpp5.py și construiește un model XGBoost. Aici Autopilot oferă control complet cercetătorului de date, care poate alege transformarea caracteristicilor generate automat și pașii de selectare a modelului sau poate construi propria lor combinație.

Acum puteți adăuga conducta la un pool pentru ca Autopilot să ruleze experimentul după cum urmează:

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

Acesta este un pas important în care puteți decide să păstrați doar un subset de candidați sugerați de Autopilot, pe baza expertizei în materie, pentru a reduce durata totală de rulare. Pentru moment, păstrați toate sugestiile Autopilot, pe care le puteți enumera după cum urmează:

automl_interactive_runner.display_candidates()

Experimentul complet Autopilot este realizat în două părți. Mai întâi, trebuie să rulați joburile de transformare a datelor:

automl_interactive_runner.fit_data_transformers(parallel_jobs=7)

Acest pas ar trebui să se termine în aproximativ 30 de minute pentru toți candidații, dacă nu faceți alte modificări la dpp*.py fișiere.

Următorul pas este construirea celui mai bun set de modele prin reglarea hiperparametrilor pentru algoritmii respectivi. Hiperparametrii sunt de obicei împărțiți în două părți: statice și reglabile. Hiperparametrii statici rămân neschimbați pe tot parcursul experimentului pentru toți candidații care au același algoritm. Acești hiperparametri sunt trecuți experimentului ca dicționar. Dacă alegeți să alegeți cel mai bun model XGBoost prin maximizarea AUC din trei runde ale unei scheme de validare încrucișată de cinci ori, dicționarul arată ca următorul cod:

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

Pentru hiperparametrii reglabili, trebuie să treceți un alt dicționar cu intervale și tip de scalare:

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

Setul complet de hiperparametri este disponibil în mangrove-2013.ipynb caiet.

Pentru a crea un experiment în care toți cei șapte candidați pot fi testați în paralel, creați un tuner HPO cu mai multe algoritmi:

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)

Valorile obiective sunt definite independent pentru fiecare algoritm:

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

Încercarea tuturor valorilor posibile ale hiperparametrilor pentru toate experimentele este o risipă; puteți adopta o strategie bayesiană pentru a crea 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,
)

În setarea implicită, Autopilot alege 250 de lucrări în tuner pentru a alege cel mai bun model. Pentru acest caz de utilizare, este suficient să setați max_jobs=50 pentru a economisi timp și resurse, fără nicio penalizare semnificativă în ceea ce privește alegerea celui mai bun set de hiperparametri. În cele din urmă, trimiteți jobul HPO după cum urmează:

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

Procesul durează aproximativ 80 de minute pe cazuri ml.m5.4xlarge. Puteți monitoriza progresul pe consola SageMaker alegând Lucrări de reglare a hiperparametrilor în Pregătire în panoul de navigare.

Puteți vizualiza o serie de informații utile, inclusiv performanța fiecărui candidat, alegând numele postului în desfășurare.

În cele din urmă, comparați performanța modelului celor mai buni candidați, după cum urmează:

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)

Modelul cu cele mai bune performanțe bazat pe MLP, deși puțin mai bun decât modelele XGBoost, cu diferite opțiuni de pași de procesare a datelor, durează, de asemenea, mult mai mult timp pentru a fi antrenat. Puteți găsi detalii importante despre antrenamentul modelului MLP, inclusiv combinația de hiperparametri utilizați, după cum urmează:

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

Creați o conductă de inferență

Pentru a genera inferențe pe date noi, trebuie să construiți o conductă de inferență pe SageMaker pentru a găzdui cel mai bun model care poate fi apelat ulterior pentru a genera inferență. Modelul pipeline SageMaker necesită trei containere ca componente: transformarea datelor, algoritmul și transformarea inversă a etichetei (dacă predicțiile numerice trebuie mapate pe etichete nenumerice). Pentru concizie, doar o parte din codul necesar este afișată în următorul fragment; codul complet este disponibil în mangrove-2013.ipynb caiet:

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

După construirea containerelor model, puteți construi și implementa conducta după cum urmează:

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)

Implementarea punctului final durează aproximativ 10 minute.

Obțineți inferențe asupra setului de date de testare folosind un punct final

După ce punctul final este implementat, îl puteți invoca cu o încărcătură utilă de caracteristici B1–B7 pentru a clasifica fiecare pixel dintr-o imagine ca mangrove (1) sau altul (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()))

Detalii complete despre postprocesarea predicțiilor modelului pentru evaluare și reprezentare sunt disponibile în notebooks/model_performance.ipynb.

Obțineți inferențe asupra setului de date de testare folosind o transformare în lot

Acum că ați creat cel mai performant model cu Autopilot, putem folosi modelul pentru inferență. Pentru a obține inferențe cu privire la seturi mari de date, este mai eficient să utilizați o transformare în lot. Să generăm predicții asupra întregului set de date (antrenament și test) și să anexăm rezultatele la caracteristici, astfel încât să putem efectua analize suplimentare pentru, de exemplu, a verifica valorile prezise vs. reale și distribuția caracteristicilor între clasele prezise.

Mai întâi, creăm un fișier manifest în Amazon S3 care indică locațiile datelor de instruire și de testare din pașii anteriori de procesare a datelor:

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

Acum putem crea un job de transformare în lot. Pentru că trenul nostru de intrare și setul de date de testare au label ca ultima coloană, trebuie să o renunțăm în timpul inferenței. Pentru a face asta, trecem InputFilter în DataProcessing argument. Codul "$[:-2]" indică eliminarea ultimei coloane. Ieșirea estimată este apoi asociată cu datele sursă pentru o analiză ulterioară.

În următorul cod, construim argumentele pentru jobul de transformare în lot și apoi trecem la create_transform_job funcţie:

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)

Puteți monitoriza starea lucrării pe consola SageMaker.

Vizualizați performanța modelului

Acum puteți vizualiza performanța celui mai bun model din setul de date de testare, constând din regiuni din India, Myanmar, Cuba și Vietnam, ca o matrice de confuzie. Modelul are o valoare mare de reamintire pentru pixelii reprezentând mangrove, dar doar aproximativ 75% precizie. Precizia pixelilor non-mangrove sau a altor pixeli este de 99% cu o reamintire de 85%. Puteți regla limita de probabilitate a predicțiilor modelului pentru a ajusta valorile respective în funcție de cazul particular de utilizare.

Este de remarcat faptul că rezultatele sunt o îmbunătățire semnificativă față de modelul smileCart încorporat.

Vizualizați predicțiile modelului

În cele din urmă, este util să observați performanța modelului pe anumite regiuni de pe hartă. În imaginea următoare, zona de mangrove de la granița India-Bangladesh este reprezentată în roșu. Punctele eșantionate din patch-ul de imagine Landsat aparținând setului de date de testare sunt suprapuse regiunii, în care fiecare punct este un pixel pe care modelul îl determină ca reprezentând mangrove. Punctele albastre sunt clasificate corect de model, în timp ce punctele negre reprezintă greșeli ale modelului.

Următoarea imagine arată doar punctele pe care modelul le-a prezis să nu reprezinte mangrove, cu aceeași schemă de culori ca exemplul precedent. Conturul gri este partea din patch-ul Landsat care nu include nicio mangrove. După cum reiese din imagine, modelul nu face nicio greșeală în clasificarea punctelor de pe apă, dar se confruntă cu o provocare atunci când distinge pixelii care reprezintă mangrove de cei care reprezintă frunzișul obișnuit.

Următoarea imagine arată performanța modelului în regiunea de mangrove din Myanmar.

În imaginea următoare, modelul face o treabă mai bună identificând pixelii de mangrove.

A curăța

Punctul final de inferență SageMaker continuă să genereze costuri dacă este lăsat să funcționeze. Ștergeți punctul final după cum urmează, când ați terminat:

sagemaker.delete_endpoint(EndpointName=pipeline_model.name)

Concluzie

Această serie de postări a oferit un cadru end-to-end pentru oamenii de știință de date pentru rezolvarea problemelor GIS. Partea 1 a arătat procesul ETL și o modalitate convenabilă de a interacționa vizual cu datele. Partea 2 a arătat cum să utilizați Autopilot pentru a automatiza construirea unui clasificator personalizat de mangrove.

Puteți utiliza acest cadru pentru a explora noi seturi de date satelitare care conțin un set mai bogat de benzi utile pentru clasificarea mangrovelor și pentru a explora ingineria caracteristicilor prin încorporarea cunoștințelor de domeniu.

Despre Autori

Andrei Ivanovic este un student de master în știință informatică la Universitatea din Toronto și un absolvent recent al programului de Științe Ingineriei de la Universitatea din Toronto, cu specializare în Inteligența mașinilor cu o minoră în Robotică/Mecatronică. El este interesat de viziunea computerizată, învățarea profundă și robotică. A făcut munca prezentată în această postare în timpul stagiului său de vară la Amazon.

David Dong este Data Scientist la Amazon Web Services.

Arkajyoti Misra este Data Scientist la Amazon LastMile Transportation. Este pasionat de aplicarea tehnicilor de computer Vision pentru a rezolva problemele care ajută pământul. Îi place să lucreze cu organizații non-profit și este membru fondator al ekipi.org.

• Coinsmart. Cel mai bun schimb de Bitcoin și Crypto din Europa.
• Platoblockchain. Web3 Metaverse Intelligence. Cunoștințe amplificate. ACCES LIBER.
• CryptoHawk. Radar Altcoin. Încercare gratuită.
• Sursa: https://aws.amazon.com/blogs/machine-learning/part-2-identify-mangrove-forests-using-satellite-image-features-using-amazon-sagemaker-studio-and-amazon-sagemaker- pilot automat/