Parallell databehandling med RStudio på Amazon SageMaker

I fjor kunngjorde vi generell tilgjengelighet av RStudio på Amazon SageMaker, bransjens første fullt administrerte RStudio Workbench integrerte utviklingsmiljø (IDE) i skyen. Du kan raskt starte den velkjente RStudio IDE, og ringe opp og ned de underliggende dataressursene uten å avbryte arbeidet ditt, noe som gjør det enkelt å bygge maskinlæring (ML) og analyseløsninger i R i stor skala.

Med stadig økende datavolum som genereres, vokser datasett brukt for ML og statistisk analyse i takt. Med dette bringer utfordringene med økt utviklingstid og styring av datainfrastruktur. For å løse disse utfordringene har dataforskere sett på å implementere parallelle databehandlingsteknikker. Parallell databehandling, eller dataparallellisering, tar store eksisterende datasett og distribuerer dem på tvers av flere prosessorer eller noder for å operere på dataene samtidig. Dette kan gi raskere behandlingstid for større datasett, sammen med optimalisert bruk på databehandling. Dette kan hjelpe ML-utøvere med å lage gjenbrukbare mønstre for datasettgenerering, og også bidra til å redusere belastningen og kostnadene for datainfrastruktur.

Løsningsoversikt

Innen Amazon SageMaker, bruker mange kunder SageMaker-behandling for å hjelpe til med å implementere parallell databehandling. Med SageMaker Processing kan du bruke en forenklet, administrert opplevelse på SageMaker til å kjøre databehandlingsarbeidsmengdene dine, for eksempel funksjonsutvikling, datavalidering, modellevaluering og modelltolkning. Dette gir mange fordeler fordi det ikke er noen langvarig infrastruktur å administrere – behandlingsforekomster spinner ned når jobber er fullført, miljøer kan standardiseres via containere, data innenfor Amazon enkel lagringstjeneste (Amazon S3) er naturlig distribuert på tvers av instanser, og infrastrukturinnstillingene er fleksible når det gjelder minne, databehandling og lagring.

SageMaker Processing tilbyr alternativer for hvordan du kan distribuere data. For parallell databehandling må du bruke ShardedByS3Key-alternativet for S3DataDistributionType. Når denne parameteren er valgt, tar SageMaker Processing den oppgitte n instanser og distribuer objekter 1/n objekter fra inndatakilden på tvers av forekomstene. For eksempel, hvis to instanser er utstyrt med fire dataobjekter, mottar hver instans to objekter.

SageMaker Processing krever tre komponenter for å kjøre prosesseringsjobber:

• Et beholderbilde som har din kode og avhengigheter for å kjøre databehandlingsarbeidsbelastningene dine
• En bane til en inndatakilde i Amazon S3
• En bane til en utdatakilde i Amazon S3

Prosessen er avbildet i følgende diagram.

I dette innlegget viser vi deg hvordan du bruker RStudio på SageMaker til å grensesnitt med en serie SageMaker Processing-jobber for å lage en parallell databehandlingspipeline ved hjelp av R programmeringsspråk.

Løsningen består av følgende trinn:

1. Sett opp RStudio-prosjektet.
2. Bygg og registrer behandlingsbeholderbildet.
3. Kjør to-trinns behandlingspipeline:
   1. Det første trinnet tar flere datafiler og behandler dem på tvers av en rekke behandlingsjobber.
   2. Det andre trinnet setter sammen utdatafilene og deler dem i tog-, test- og valideringsdatasett.

Forutsetninger

Fullfør følgende forutsetninger:

1. Sett opp RStudio på SageMaker Workbench. For mer informasjon, se Kunngjør Fullt administrert RStudio på Amazon SageMaker for dataforskere.
2. Opprett en bruker med RStudio på SageMaker med passende tilgangstillatelser.

Sett opp RStudio-prosjektet

For å sette opp RStudio-prosjektet, fullfør følgende trinn:

1. Naviger til din Amazon SageMaker Studio kontrollpanelet på SageMaker-konsollen.
2. Start appen din i RStudio-miljøet.
   
3. Start en ny RStudio-økt.
4. Til Sesjonsnavn, skriv inn et navn.
5. Til Forekomsttype og Bilde, bruk standardinnstillingene.
6. Velg Start økten.
   
7. Naviger inn i økten.
8. Velg Nytt prosjekt, Versjonskontroll, Og deretter Velg Git.
9. Til Repository URL, Tast inn https://github.com/aws-samples/aws-parallel-data-processing-r.git
10. La de resterende alternativene være standard og velg Opprett prosjekt.
    

Du kan navigere til aws-parallel-data-processing-R katalog på Filer fanen for å vise depotet. Depotet inneholder følgende filer:

• 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

Bygg beholderen

I dette trinnet bygger vi vårt behandlingsbeholderbilde og skyver det til Amazon Elastic Container Registry (Amazon ECR). Fullfør følgende trinn:

1. Naviger til Container_Build.rmd filen.
2. Installer SageMaker Studio Image Build CLI ved å kjøre følgende celle. Sørg for at du har de nødvendige tillatelsene før du fullfører dette trinnet, dette er en CLI designet for å pushe og registrere containerbilder i Studio.

   pip install sagemaker-studio-image-build

3. Kjør neste celle for å bygge og registrere vår behandlingsbeholder:

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

Etter at jobben har kjørt, mottar du en utdata som ser slik ut:

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

Kjør prosesseringsrørledningen

Etter at du har bygget beholderen, naviger til Parallel_Data_Processing.rmd fil. Denne filen inneholder en rekke trinn som hjelper oss å lage vår parallelle databehandlingspipeline ved hjelp av SageMaker Processing. Følgende diagram viser trinnene i rørledningen som vi fullfører.

Start med å kjøre trinnet for pakkeimport. Importer de nødvendige RStudio-pakkene sammen med 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')

Sett nå opp SageMaker-utførelsesrollen og miljødetaljer:

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)

Initialiser beholderen som vi bygde og registrerte i det tidligere trinnet:

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

Herfra dykker vi mer detaljert inn i hvert av behandlingstrinnene.

Last opp datasettet

For vårt eksempel bruker vi Bankmarkedsføringsdatasett fra UCI. Vi har allerede delt opp datasettet i flere mindre filer. Kjør følgende kode for å laste opp filene til 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")

Etter at filene er lastet opp, gå til neste trinn.

Utfør parallell databehandling

I dette trinnet tar vi datafilene og utfører funksjonsutvikling for å filtrere ut visse kolonner. Denne jobben er fordelt på en rekke behandlingsforekomster (for eksempel bruker vi to).

Vi bruker filter.R fil for å behandle dataene, og konfigurer jobben som følger:

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

Som nevnt tidligere, når du kjører en parallell databehandlingsjobb, må du justere inngangsparameteren med hvordan dataene skal deles, og typen data. Derfor tilbyr vi skjæringsmetoden ved S3Prefix:

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

Etter at du har satt inn disse parameterne, vil SageMaker Processing fordele dataene likt over antall valgte forekomster.

Juster parametrene etter behov, og kjør deretter cellen for å instansiere jobben.

Generer opplærings-, test- og valideringsdatasett

I dette trinnet tar vi de behandlede datafilene, kombinerer dem og deler dem opp i test-, trenings- og valideringsdatasett. Dette lar oss bruke dataene til å bygge vår modell.

Vi bruker process.R fil for å behandle dataene, og konfigurer jobben som følger:

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

Juster parametrene som er nødvendige, og kjør deretter cellen for å instansiere jobben.

Kjør rørledningen

Etter at alle trinnene er instansiert, starter du prosesseringsrørledningen for å kjøre hvert trinn ved å kjøre følgende celle:

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

Tiden hver av disse jobbene tar vil variere basert på forekomststørrelsen og antallet valgt.

Naviger til SageMaker-konsollen for å se alle behandlingsjobbene dine.

Vi starter med filtreringsjobben, som vist i følgende skjermbilde.

Når det er fullført, flyttes rørledningen til databehandlingsjobben.

Når begge jobbene er fullført, naviger til S3-bøtten. Se innenfor sagemaker-rstudio-example mappe, under processed. Du kan se filene for tog-, test- og valideringsdatasettene.

konklusjonen

Med en økt mengde data som vil kreves for å bygge flere og mer sofistikerte modeller, må vi endre vår tilnærming til hvordan vi behandler data. Parallell databehandling er en effektiv metode for å akselerere datasettgenerering, og hvis den kombineres med moderne skymiljøer og verktøy som RStudio på SageMaker og SageMaker Processing, kan den fjerne mye av det udifferensierte tunge løftet av infrastrukturstyring, generering av kodekoder og miljøstyring. I dette innlegget gikk vi gjennom hvordan du kan implementere parallell databehandling i RStudio på SageMaker. Vi oppfordrer deg til å prøve det ut ved å klone GitHub-depotet, og hvis du har forslag til hvordan du kan gjøre opplevelsen bedre, vennligst send inn et problem eller en pull-forespørsel.

For å lære mer om funksjonene og tjenestene som brukes i denne løsningen, se RStudio på Amazon SageMaker og Amazon SageMaker-prosessering.

Om forfatterne

Raj Pathak er en løsningsarkitekt og teknisk rådgiver for Fortune 50 og mellomstore FSI-kunder (Banking, Insurance, Capital Markets) over hele Canada og USA. Raj spesialiserer seg på maskinlæring med applikasjoner innen dokumentutvinning, kontaktsentertransformasjon og datasyn.

Jake Wen er en løsningsarkitekt hos AWS med lidenskap for ML-trening og naturlig språkbehandling. Jake hjelper Small Medium Business-kunder med design og tankeledelse med å bygge og distribuere applikasjoner i stor skala. Utenom jobben liker han å gå tur.

Aditi Rajnish er en førsteårs programvareingeniørstudent ved University of Waterloo. Hennes interesser inkluderer datasyn, naturlig språkbehandling og edge computing. Hun er også lidenskapelig opptatt av samfunnsbasert STEM-oppsøking og talsmann. På fritiden kan hun bli funnet i fjellklatring, spille piano eller lære å bake den perfekte scones.

Sean Morgan er AI/ML Solutions Architect hos AWS. Han har erfaring innen halvleder- og akademisk forskningsfelt, og bruker sin erfaring til å hjelpe kundene med å nå sine mål på AWS. På fritiden er Sean en aktiv bidragsyter og vedlikeholder av åpen kildekode, og er spesialinteressegruppeleder for TensorFlow-tillegg.

Paul Wu er en løsningsarkitekt som jobber i AWS' Greenfield Business i Texas. Hans ekspertiseområder inkluderer containere og migreringer.