Identifica le foreste di mangrovie utilizzando le funzionalità di immagine satellitare utilizzando Amazon SageMaker Studio e Amazon SageMaker Autopilot – Parte 2

Le foreste di mangrovie sono una parte importante di un ecosistema sano e le attività umane sono una delle ragioni principali della loro graduale scomparsa dalle coste di tutto il mondo. L'utilizzo di un modello di apprendimento automatico (ML) per identificare le regioni di mangrovie da un'immagine satellitare offre ai ricercatori un modo efficace per monitorare le dimensioni delle foreste nel tempo. In Parte 1 di questa serie, abbiamo mostrato come raccogliere i dati satellitari in modo automatizzato e analizzarli Amazon Sage Maker Studio con visualizzazione interattiva. In questo post, mostriamo come utilizzare Pilota automatico Amazon SageMaker per automatizzare il processo di creazione di un classificatore di mangrovie personalizzato.

Addestra un modello con il pilota automatico

Il pilota automatico fornisce un modo equilibrato per costruire diversi modelli e selezionare quello migliore. Durante la creazione di più combinazioni di diverse tecniche di preelaborazione dei dati e modelli ML con il minimo sforzo, Autopilot fornisce al data scientist il controllo completo su questi passaggi dei componenti, se lo desidera.

Puoi utilizzare Autopilot utilizzando uno degli SDK AWS (dettagli disponibili in Guida di riferimento dell'API per il pilota automatico) o tramite Studio. Utilizziamo Autopilot nella nostra soluzione Studio seguendo i passaggi descritti in questa sezione:

1. Nella pagina Studio Launcher, scegli il segno più per Nuovo esperimento di pilota automatico.
   
2. Nel Collega i tuoi dati, selezionare Trova il secchio S3e inserisci il nome del bucket in cui hai conservato i set di dati di addestramento e test.
3. Nel Nome del file del set di dati, inserisci il nome del file di dati di allenamento che hai creato nel file Prepara i dati di allenamento sezione in Parte 1.
4. Nel Posizione dei dati di output (secchio S3), inserisci lo stesso nome del bucket utilizzato nel passaggio 2.
5. Nel Nome della directory del set di dati, inserisci un nome di cartella sotto il bucket in cui desideri che Autopilot memorizzi gli artefatti.
6. Nel Il tuo S3 ha inserito un file manifest?scegli sconto.
7. Nel Targetscegli etichetta.
8. Nel Distribuzione automaticascegli sconto.
   
9. Sotto il impostazioni avanzate, Per Tipo di problema di apprendimento automaticoscegli Classificazione binaria.
10. Nel Metrica oggettivascegli AUC.
11. Nel Scegli come eseguire il tuo esperimentoscegli No, esegui un pilota per creare un taccuino con le definizioni dei candidati.
12. Scegli Crea esperimento.
    
    Per ulteriori informazioni sulla creazione di un esperimento, fare riferimento a Crea un esperimento Amazon SageMaker Autopilot.L'esecuzione di questo passaggio potrebbe richiedere circa 15 minuti.
13. Al termine, scegli Notebook aperto per la generazione di candidati, che apre un nuovo notebook in modalità di sola lettura.
    
14. Scegli Importa taccuino per rendere modificabile il taccuino.
    
15. Per Immagine, scegli Science Data.
16. Nel noccioloscegli Python 3.
17. Scegli Seleziona.
    

Questo taccuino generato automaticamente contiene spiegazioni dettagliate e fornisce il controllo completo sull'effettiva attività di costruzione del modello da seguire. Una versione personalizzata del taccuino, dove un classificatore viene addestrato utilizzando le bande satellitari Landsat dal 2013, è disponibile nel repository del codice sotto notebooks/mangrove-2013.ipynb.

Il framework di costruzione del modello è costituito da due parti: la trasformazione delle caratteristiche come parte della fase di elaborazione dei dati e l'ottimizzazione degli iperparametri (HPO) come parte della fase di selezione del modello. Tutti gli artefatti necessari per queste attività sono stati creati durante l'esperimento Autopilot e salvati Servizio di archiviazione semplice Amazon (Amazon S3). La prima cella del notebook scarica quegli artefatti da Amazon S3 al locale Amazon Sage Maker file system per l'ispezione e le eventuali modifiche necessarie. Ci sono due cartelle: generated_module ed sagemaker_automl, dove sono archiviati tutti i moduli e gli script Python necessari per eseguire il notebook. I vari passaggi di trasformazione delle funzionalità come imputazione, ridimensionamento e PCA vengono salvati come generated_modules/candidate_data_processors/dpp*.py.

Autopilot crea tre diversi modelli basati sugli algoritmi XGBoost, Linear Learner e Multi-layer Perceptron (MLP). Una pipeline candidata è costituita da una delle opzioni di trasformazione delle funzionalità, note come data_transformere un algoritmo. Una pipeline è un dizionario Python e può essere definita come segue:

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 questo esempio, la pipeline trasforma i dati di addestramento in base allo script in generated_modules/candidate_data_processors/dpp5.py e costruisce un modello XGBoost. È qui che Autopilot fornisce il controllo completo al data scientist, che può scegliere la trasformazione delle funzionalità generate automaticamente e i passaggi di selezione del modello o creare la propria combinazione.

È ora possibile aggiungere la pipeline a un pool affinché Autopilot esegua l'esperimento come segue:

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

Questo è un passaggio importante in cui puoi decidere di mantenere solo un sottoinsieme di candidati suggeriti da Autopilot, in base all'esperienza in materia, per ridurre il tempo di esecuzione totale. Per ora, mantieni tutti i suggerimenti di Autopilot, che puoi elencare come segue:

automl_interactive_runner.display_candidates()

L'intero esperimento dell'autopilota viene eseguito in due parti. Innanzitutto, è necessario eseguire i lavori di trasformazione dei dati:

automl_interactive_runner.fit_data_transformers(parallel_jobs=7)

Questo passaggio dovrebbe essere completato in circa 30 minuti per tutti i candidati, se non si apportano ulteriori modifiche al dpp*.py File.

Il passaggio successivo consiste nel costruire il miglior set di modelli ottimizzando gli iperparametri per i rispettivi algoritmi. Gli iperparametri sono generalmente divisi in due parti: static e sintonizzabile. Gli iperparametri statici rimangono invariati durante l'esperimento per tutti i candidati che condividono lo stesso algoritmo. Questi iperparametri vengono passati all'esperimento come dizionario. Se scegli di scegliere il miglior modello XGBoost massimizzando l'AUC da tre round di uno schema di convalida incrociata quintuplicato, il dizionario avrà l'aspetto del codice seguente:

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

Per gli iperparametri sintonizzabili, devi passare un altro dizionario con intervalli e tipo di ridimensionamento:

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

Il set completo di iperparametri è disponibile in mangrove-2013.ipynb taccuino.

Per creare un esperimento in cui tutti e sette i candidati possono essere testati in parallelo, crea un sintonizzatore HPO multi-algoritmo:

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)

Le metriche obiettivo sono definite indipendentemente per ciascun algoritmo:

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

Provare tutti i possibili valori degli iperparametri per tutti gli esperimenti è uno spreco; puoi adottare una strategia bayesiana per creare un sintonizzatore 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,
)

Nell'impostazione predefinita, Autopilot seleziona 250 lavori nel sintonizzatore per scegliere il modello migliore. Per questo caso d'uso, è sufficiente impostare max_jobs=50 per risparmiare tempo e risorse, senza alcuna penalizzazione significativa in termini di scelta del miglior set di iperparametri. Infine, invia il lavoro HPO come segue:

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

Il processo richiede circa 80 minuti su istanze ml.m5.4xlarge. Puoi monitorare i progressi sulla console SageMaker scegliendo Lavori di ottimizzazione degli iperparametri per Training nel pannello di navigazione.

Puoi visualizzare una serie di informazioni utili, inclusa la performance di ogni candidato, scegliendo il nome del lavoro in corso.

Infine, confronta le prestazioni del modello dei migliori candidati come segue:

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)

Il modello più performante basato su MLP, sebbene leggermente migliore dei modelli XGBoost con varie scelte di fasi di elaborazione dei dati, richiede anche molto più tempo per l'addestramento. È possibile trovare dettagli importanti sull'addestramento del modello MLP, inclusa la combinazione di iperparametri utilizzati, come segue:

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

Crea una pipeline di inferenza

Per generare l'inferenza su nuovi dati, devi costruire una pipeline di inferenza su SageMaker per ospitare il miglior modello che può essere chiamato in seguito per generare l'inferenza. Il modello di pipeline SageMaker richiede tre contenitori come componenti: trasformazione dei dati, algoritmo e trasformazione inversa dell'etichetta (se è necessario mappare le previsioni numeriche su etichette non numeriche). Per brevità, nello snippet seguente viene mostrata solo una parte del codice richiesto; il codice completo è disponibile nella mangrove-2013.ipynb taccuino:

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

Dopo aver creato i contenitori del modello, puoi costruire e distribuire la pipeline come segue:

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)

Il completamento della distribuzione dell'endpoint richiede circa 10 minuti.

Ottieni l'inferenza sul set di dati di test usando un endpoint

Dopo che l'endpoint è stato distribuito, puoi richiamarlo con un payload di funzionalità B1–B7 per classificare ogni pixel in un'immagine come mangrovia (1) o altro (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()))

I dettagli completi sulla postelaborazione delle previsioni del modello per la valutazione e la stampa sono disponibili in notebooks/model_performance.ipynb.

Ottieni l'inferenza sul set di dati di test usando una trasformazione batch

Ora che hai creato il modello con le prestazioni migliori con Autopilot, possiamo utilizzare il modello per l'inferenza. Per ottenere l'inferenza su set di dati di grandi dimensioni, è più efficiente usare una trasformazione batch. Generiamo previsioni sull'intero set di dati (formazione e test) e aggiungiamo i risultati alle funzionalità, in modo da poter eseguire ulteriori analisi per, ad esempio, controllare le previsioni rispetto a quelle effettive e la distribuzione delle funzionalità tra le classi previste.

Innanzitutto, creiamo un file manifest in Amazon S3 che punta alle posizioni dei dati di addestramento e test delle precedenti fasi di elaborazione dei dati:

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

Ora possiamo creare un processo di trasformazione batch. Perché il nostro treno di input e il set di dati di test hanno label come ultima colonna, dobbiamo rilasciarla durante l'inferenza. Per farlo, passiamo InputFilter nel DataProcessing discussione. Il codice "$[:-2]" indica di eliminare l'ultima colonna. L'output previsto viene quindi unito ai dati di origine per ulteriori analisi.

Nel codice seguente, costruiamo gli argomenti per il processo di trasformazione batch e quindi li passiamo a create_transform_job funzione:

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)

È possibile monitorare lo stato del lavoro sulla console SageMaker.

Visualizza le prestazioni del modello

È ora possibile visualizzare le prestazioni del miglior modello sul set di dati di test, costituito da regioni di India, Myanmar, Cuba e Vietnam, come matrice di confusione. Il modello ha un alto valore di richiamo per i pixel che rappresentano le mangrovie, ma solo circa il 75% di precisione. La precisione dei pixel non mangrovie o di altro tipo è del 99% con un richiamo dell'85%. È possibile ottimizzare il limite di probabilità delle previsioni del modello per regolare i rispettivi valori in base al caso d'uso particolare.

Vale la pena notare che i risultati sono un miglioramento significativo rispetto al modello smileCart integrato.

Visualizza le previsioni del modello

Infine, è utile osservare le prestazioni del modello su regioni specifiche della mappa. Nell'immagine seguente, l'area di mangrovie al confine tra India e Bangladesh è raffigurata in rosso. I punti campionati dalla patch dell'immagine Landsat appartenenti al set di dati di test sono sovrapposti alla regione, dove ogni punto è un pixel che il modello determina rappresentare le mangrovie. I punti blu sono classificati correttamente dal modello, mentre i punti neri rappresentano errori del modello.

L'immagine seguente mostra solo i punti che il modello prevede non rappresentino le mangrovie, con la stessa combinazione di colori dell'esempio precedente. Il contorno grigio è la parte della macchia Landsat che non include le mangrovie. Come è evidente dall'immagine, il modello non commette alcun errore classificando i punti sull'acqua, ma affronta una sfida nel distinguere i pixel che rappresentano le mangrovie da quelli che rappresentano il fogliame regolare.

L'immagine seguente mostra le prestazioni del modello nella regione delle mangrovie del Myanmar.

Nell'immagine seguente, il modello fa un lavoro migliore nell'identificare i pixel delle mangrovie.

ripulire

L'endpoint di inferenza SageMaker continua a essere soggetto a costi se lasciato in esecuzione. Elimina l'endpoint come segue quando hai finito:

sagemaker.delete_endpoint(EndpointName=pipeline_model.name)

Conclusione

Questa serie di post ha fornito un framework end-to-end per i data scientist per la risoluzione dei problemi GIS. Parte 1 ha mostrato il processo ETL e un modo conveniente per interagire visivamente con i dati. La parte 2 ha mostrato come utilizzare Autopilot per automatizzare la creazione di un classificatore di mangrovie personalizzato.

Puoi utilizzare questo framework per esplorare nuovi set di dati satellitari contenenti un set più ricco di bande utili per la classificazione delle mangrovie ed esplorare l'ingegneria delle funzionalità incorporando la conoscenza del dominio.

Informazioni sugli autori

Andrej Ivanovic è uno studente in ingresso di un Master in Informatica presso l'Università di Toronto e un neolaureato del programma di Scienze dell'Ingegneria presso l'Università di Toronto, con una specializzazione in Machine Intelligence con una specializzazione in Robotica/Meccatronica. Si interessa di computer vision, deep learning e robotica. Ha svolto il lavoro presentato in questo post durante il suo stage estivo presso Amazon.

David Dong è un Data Scientist presso Amazon Web Services.

Arkajyoti Misura è un Data Scientist presso Amazon LastMile Transportation. È appassionato di applicare le tecniche di Computer Vision per risolvere problemi che aiutano la terra. Ama lavorare con organizzazioni no-profit ed è un membro fondatore di ekipi.org.

• Coinsmart. Il miglior scambio di bitcoin e criptovalute d'Europa.
• Platoblockchain. Web3 Metaverse Intelligence. Conoscenza amplificata. ACCESSO LIBERO.
• Criptofalco. Radar Altcoin. Prova gratuita.
• Fonte: https://aws.amazon.com/blogs/machine-learning/part-2-identify-mangrove-forests-using-satellite-image-features-using-amazon-sagemaker-studio-and-amazon-sagemaker- autopilota/