Elaborazione parallela dei dati con RStudio su Amazon SageMaker

Ripubblicato da Platone

Seguaci: 0

L'anno scorso abbiamo annunciato la disponibilità generale di RStudio su Amazon SageMaker, il primo ambiente di sviluppo integrato (IDE) RStudio Workbench completamente gestito del settore nel cloud. Puoi avviare rapidamente il familiare IDE di RStudio e selezionare le risorse di calcolo sottostanti senza interrompere il lavoro, semplificando la creazione di soluzioni di machine learning (ML) e analisi in R su larga scala.

Con la generazione di un volume di dati sempre crescente, i set di dati utilizzati per il ML e l'analisi statistica stanno crescendo di pari passo. Ciò comporta le sfide legate all'aumento dei tempi di sviluppo e alla gestione dell'infrastruttura di calcolo. Per risolvere queste sfide, i data scientist hanno cercato di implementare tecniche di elaborazione parallela dei dati. Elaborazione parallela dei dati, o parallelizzazione dei dati, prende grandi set di dati esistenti e li distribuisce su più processori o nodi per operare sui dati contemporaneamente. Ciò può consentire tempi di elaborazione più rapidi di set di dati più grandi, insieme a un utilizzo ottimizzato nel calcolo. Ciò può aiutare i professionisti del ML a creare modelli riutilizzabili per la generazione di set di dati e anche a ridurre il carico e i costi dell'infrastruttura di elaborazione.

Panoramica della soluzione

Nel quadro di Amazon Sage Maker, molti clienti usano Elaborazione di SageMaker per aiutare a implementare l'elaborazione parallela dei dati. Con SageMaker Processing, puoi utilizzare un'esperienza gestita e semplificata su SageMaker per eseguire i carichi di lavoro di elaborazione dei dati, come l'ingegneria delle funzionalità, la convalida dei dati, la valutazione del modello e l'interpretazione del modello. Ciò comporta molti vantaggi perché non c'è un'infrastruttura di lunga durata da gestire: le istanze di elaborazione si riducono quando i lavori sono completi, gli ambienti possono essere standardizzati tramite container, i dati all'interno Servizio di archiviazione semplice Amazon (Amazon S3) è distribuito in modo nativo tra le istanze e le impostazioni dell'infrastruttura sono flessibili in termini di memoria, elaborazione e archiviazione.

SageMaker Processing offre opzioni su come distribuire i dati. Per l'elaborazione parallela dei dati, è necessario utilizzare il Opzione ShardedByS3Key per S3DataDistributionType. Quando questo parametro è selezionato, SageMaker Processing prende il fornito n istanze e distribuire oggetti 1/n oggetti dall'origine dati di input nelle istanze. Ad esempio, se vengono fornite due istanze con quattro oggetti dati, ciascuna istanza riceve due oggetti.

SageMaker Processing richiede tre componenti per eseguire i lavori di elaborazione:

Un'immagine del contenitore che contiene il codice e le dipendenze per eseguire i carichi di lavoro di elaborazione dati
Un percorso a un'origine dati di input all'interno di Amazon S3
Un percorso a un'origine dati di output all'interno di Amazon S3

Il processo è illustrato nel diagramma seguente.

In questo post, ti mostriamo come utilizzare RStudio su SageMaker per interfacciarsi con una serie di processi di elaborazione SageMaker per creare una pipeline di elaborazione dati parallela utilizzando il Linguaggio di programmazione R.

La soluzione consiste nei seguenti passaggi:

Configura il progetto RStudio.
Crea e registra l'immagine del contenitore di elaborazione.
Esegui la pipeline di elaborazione in due fasi:
1. Il primo passaggio prende più file di dati e li elabora attraverso una serie di processi di elaborazione.
2. Il secondo passaggio concatena i file di output e li divide in set di dati di training, test e validazione.

Prerequisiti

Completa i seguenti prerequisiti:

Configura RStudio su SageMaker Workbench. Per ulteriori informazioni, fare riferimento a Annuncio di RStudio completamente gestito su Amazon SageMaker per i data scientist.
Crea un utente con RStudio su SageMaker con autorizzazioni di accesso appropriate.

Configura il progetto RStudio

Per impostare il progetto RStudio, completare i seguenti passaggi:

Vai al tuo Amazon Sage Maker Studio pannello di controllo sulla console SageMaker.
Avvia la tua app nell'ambiente RStudio.
Avvia una nuova sessione di RStudio.
Nel Nome della sessione, inserisci un nome.
Nel Tipo di istanza ed Immagine, utilizzare le impostazioni predefinite.
Scegli Inizia la sessione.
Naviga nella sessione.
Scegli Nuovo progetto, Controllo della versione, e poi Seleziona Git.
Nel URL del repository, accedere https://github.com/aws-samples/aws-parallel-data-processing-r.git
Lascia le opzioni rimanenti come predefinite e scegli Crea progetto.

Puoi navigare verso aws-parallel-data-processing-R directory sul File scheda per visualizzare il repository. Il repository contiene i seguenti file:

Container_Build.rmd
/dataset
- bank-additional-full-data1.csv
- bank-additional-full-data2.csv
- bank-additional-full-data3.csv
- bank-additional-full-data4.csv
/docker
Dockerfile-Processing
Parallel_Data_Processing.rmd
/preprocessing
- filter.R
- process.R

Costruisci il contenitore

In questo passaggio, creiamo la nostra immagine del contenitore di elaborazione e la inseriamo Registro dei contenitori Amazon Elastic (Amazon ECR). Completa i seguenti passaggi:

Passare alla Container_Build.rmd file.
installare il CLI per la creazione di immagini di SageMaker Studio eseguendo la cella seguente. Assicurati di disporre delle autorizzazioni necessarie prima di completare questo passaggio, questa è una CLI progettata per inviare e registrare le immagini del contenitore all'interno di Studio.
```
pip install sagemaker-studio-image-build
```

Esegui la cella successiva per creare e registrare il nostro contenitore di elaborazione:

/home/sagemaker-user/.local/bin/sm-docker build . --file ./docker/Dockerfile-Processing --repository sagemaker-rstudio-parallel-processing:1.0

Dopo che il lavoro è stato eseguito correttamente, si riceve un output simile al seguente:

Image URI: <Account_Number>.dkr.ecr.<Region>.amazonaws.com/sagemaker-rstudio- parallel-processing:1.0

Eseguire la pipeline di elaborazione

Dopo aver creato il contenitore, vai a Parallel_Data_Processing.rmd file. Questo file contiene una serie di passaggi che ci aiutano a creare la nostra pipeline di elaborazione dati parallela utilizzando SageMaker Processing. Il diagramma seguente illustra i passaggi della pipeline che completiamo.

Inizia eseguendo il passaggio di importazione del pacchetto. Importa i pacchetti RStudio richiesti insieme a SageMaker SDK:

suppressWarnings(library(dplyr))
suppressWarnings(library(reticulate))
suppressWarnings(library(readr))
path_to_python <- system(‘which python’, intern = TRUE)

use_python(path_to_python)
sagemaker <- import('sagemaker')

Ora imposta il tuo ruolo di esecuzione SageMaker e i dettagli dell'ambiente:

role = sagemaker$get_execution_role()
session = sagemaker$Session()
bucket = session$default_bucket()
account_id <- session$account_id()
region <- session$boto_region_name
local_path <- dirname(rstudioapi::getSourceEditorContext()$path)

Inizializza il contenitore che abbiamo creato e registrato nel passaggio precedente:

container_uri <- paste(account_id, "dkr.ecr", region, "amazonaws.com/sagemaker-rstudio-parallel-processing:1.0", sep=".")
print(container_uri)

Da qui ci addentriamo in ciascuna delle fasi di elaborazione in modo più dettagliato.

Carica il set di dati

Per il nostro esempio, utilizziamo il Set di dati di marketing bancario dell'UCI. Abbiamo già suddiviso il set di dati in più file più piccoli. Esegui il codice seguente per caricare i file su Amazon S3:

local_dataset_path <- paste0(local_path,"/dataset/")

dataset_files <- list.files(path=local_dataset_path, pattern=".csv$", full.names=TRUE)
for (file in dataset_files){
  session$upload_data(file, bucket=bucket, key_prefix="sagemaker-rstudio-example/split")
}

input_s3_split_location <- paste0("s3://", bucket, "/sagemaker-rstudio-example/split")

Dopo aver caricato i file, vai al passaggio successivo.

Eseguire l'elaborazione parallela dei dati

In questo passaggio, prendiamo i file di dati ed eseguiamo la progettazione delle funzionalità per filtrare determinate colonne. Questo lavoro è distribuito su una serie di istanze di elaborazione (per il nostro esempio, ne utilizziamo due).

Usiamo il filter.R per elaborare i dati e configurare il lavoro come segue:

filter_processor <- sagemaker$processing$ScriptProcessor(command=list("Rscript"),
                                                        image_uri=container_uri,
                                                        role=role,
                                                        instance_count=2L,
                                                        instance_type="ml.m5.large")

output_s3_filter_location <- paste0("s3://", bucket, "/sagemaker-rstudio-example/filtered")
s3_filter_input <- sagemaker$processing$ProcessingInput(source=input_s3_split_location,
                                                        destination="/opt/ml/processing/input",
                                                        s3_data_distribution_type="ShardedByS3Key",
                                                        s3_data_type="S3Prefix")
s3_filter_output <- sagemaker$processing$ProcessingOutput(output_name="bank-additional-full-filtered",
                                                         destination=output_s3_filter_location,
                                                         source="/opt/ml/processing/output")

filtering_step <- sagemaker$workflow$steps$ProcessingStep(name="FilterProcessingStep",
                                                      code=paste0(local_path, "/preprocessing/filter.R"),
                                                      processor=filter_processor,
                                                      inputs=list(s3_filter_input),
                                                      outputs=list(s3_filter_output))

Come accennato in precedenza, quando si esegue un processo di elaborazione dati parallela, è necessario regolare il parametro di input con la modalità di partizionamento dei dati e il tipo di dati. Pertanto, forniamo il metodo di partizionamento orizzontale di S3Prefix:

s3_data_distribution_type="ShardedByS3Key",
                                                      s3_data_type="S3Prefix")

Dopo aver inserito questi parametri, SageMaker Processing distribuirà equamente i dati sul numero di istanze selezionate.

Regolare i parametri in base alle esigenze, quindi eseguire la cella per creare un'istanza del processo.

Genera set di dati di addestramento, test e convalida

In questo passaggio, prendiamo i file di dati elaborati, li combiniamo e li dividiamo in set di dati di test, training e validazione. Questo ci permette di usare i dati per costruire il nostro modello.

Usiamo il process.R per elaborare i dati e configurare il lavoro come segue:

script_processor <- sagemaker$processing$ScriptProcessor(command=list("Rscript"),
                                                         image_uri=container_uri,
                                                         role=role,
                                                         instance_count=1L,
                                                         instance_type="ml.m5.large")

output_s3_processed_location <- paste0("s3://", bucket, "/sagemaker-rstudio-example/processed")
s3_processed_input <- sagemaker$processing$ProcessingInput(source=output_s3_filter_location,
                                                         destination="/opt/ml/processing/input",
                                                         s3_data_type="S3Prefix")
s3_processed_output <- sagemaker$processing$ProcessingOutput(output_name="bank-additional-full-processed",
                                                         destination=output_s3_processed_location,
                                                         source="/opt/ml/processing/output")

processing_step <- sagemaker$workflow$steps$ProcessingStep(name="ProcessingStep",
                                                      code=paste0(local_path, "/preprocessing/process.R"),
                                                      processor=script_processor,
                                                      inputs=list(s3_processed_input),
                                                      outputs=list(s3_processed_output),
                                                      depends_on=list(filtering_step))

È necessario regolare i parametri, quindi eseguire la cella per creare un'istanza del lavoro.

Esegui la pipeline

Dopo aver creato un'istanza di tutti i passaggi, avviare la pipeline di elaborazione per eseguire ogni passaggio eseguendo la cella seguente:

pipeline = sagemaker$workflow$pipeline$Pipeline(
  name="BankAdditionalPipelineUsingR",
  steps=list(filtering_step, processing_step)
)

upserted <- pipeline$upsert(role_arn=role)
execution <- pipeline$start()

execution$describe()
execution$wait()

Il tempo impiegato da ciascuno di questi lavori varierà in base alla dimensione dell'istanza e al conteggio selezionato.

Accedi alla console SageMaker per vedere tutti i tuoi lavori di elaborazione.

Iniziamo con il lavoro di filtraggio, come mostrato nella schermata seguente.

Al termine, la pipeline passa al processo di elaborazione dati.

Quando entrambi i lavori sono stati completati, vai al tuo bucket S3. Guarda dentro il sagemaker-rstudio-example cartella, sotto processed. Puoi vedere i file per i set di dati di treno, test e convalida.

Conclusione

Con una maggiore quantità di dati che sarà necessaria per costruire modelli sempre più sofisticati, dobbiamo cambiare il nostro approccio al modo in cui elaboriamo i dati. L'elaborazione parallela dei dati è un metodo efficiente per accelerare la generazione di set di dati e, se abbinata a moderni ambienti cloud e strumenti come RStudio su SageMaker e SageMaker Processing, può rimuovere gran parte del lavoro pesante indifferenziato della gestione dell'infrastruttura, della generazione di codice standard e della gestione dell'ambiente. In questo post, abbiamo illustrato come implementare l'elaborazione parallela dei dati all'interno di RStudio su SageMaker. Ti invitiamo a provarlo clonando il repository GitHub e, se hai suggerimenti su come migliorare l'esperienza, invia un problema o una richiesta pull.

Per ulteriori informazioni sulle funzionalità e sui servizi utilizzati in questa soluzione, fare riferimento a RStudio su Amazon SageMaker ed Elaborazione di Amazon SageMaker.

Circa gli autori

Raja Pathak è un Solutions Architect e un consulente tecnico per i clienti Fortune 50 e Mid-Sized FSI (Banking, Insurance, Capital Markets) in Canada e negli Stati Uniti. Raj è specializzato in Machine Learning con applicazioni in Document Extraction, Contact Center Transformation e Computer Vision.

Jake Wen è un Solutions Architect presso AWS con la passione per la formazione ML e l'elaborazione del linguaggio naturale. Jake aiuta i clienti di piccole e medie imprese con design e leadership di pensiero a creare e distribuire applicazioni su larga scala. Al di fuori del lavoro, gli piace fare escursioni.

Aditi Rajnish è uno studente del primo anno di ingegneria del software presso l'Università di Waterloo. I suoi interessi includono la visione artificiale, l'elaborazione del linguaggio naturale e l'edge computing. È anche appassionata di divulgazione e advocacy STEM basata sulla comunità. Nel suo tempo libero, può essere trovata ad arrampicarsi su roccia, suonare il piano o imparare a cuocere la focaccina perfetta.

Sean Morgan è un architetto di soluzioni AI/ML presso AWS. Ha esperienza nel campo dei semiconduttori e della ricerca accademica e utilizza la sua esperienza per aiutare i clienti a raggiungere i propri obiettivi su AWS. Nel suo tempo libero, Sean è un attivo collaboratore e manutentore dell'open source ed è il capo del gruppo di interesse speciale per i componenti aggiuntivi di TensorFlow.