Parallell databehandling med RStudio på Amazon SageMaker

Förra året tillkännagav vi den allmänna tillgängligheten av RStudio på Amazon SageMaker, branschens första fullt hanterade RStudio Workbench integrerade utvecklingsmiljö (IDE) i molnet. Du kan snabbt starta den välbekanta RStudio IDE och ringa upp och ner de underliggande beräkningsresurserna utan att avbryta ditt arbete, vilket gör det enkelt att bygga maskininlärning (ML) och analyslösningar i R i skala.

Med en ständigt ökande datavolym som genereras växer datauppsättningar som används för ML och statistisk analys i takt. Med detta medför utmaningarna med ökad utvecklingstid och hantering av datorinfrastruktur. För att lösa dessa utmaningar har datavetare försökt implementera parallella databehandlingstekniker. Parallell databehandling, eller dataparallellisering, tar stora befintliga datamängder och distribuerar dem över flera processorer eller noder för att arbeta på datan samtidigt. Detta kan möjliggöra snabbare bearbetningstid för större datauppsättningar, tillsammans med optimerad användning på dator. Detta kan hjälpa ML-utövare att skapa återanvändbara mönster för datauppsättningsgenerering och även hjälpa till att minska belastningen och kostnaden för datorinfrastruktur.

Lösningsöversikt

Inom Amazon SageMaker, många kunder använder SageMaker-bearbetning för att hjälpa till att implementera parallell databehandling. Med SageMaker Processing kan du använda en förenklad, hanterad upplevelse på SageMaker för att köra dina databearbetningsarbetsbelastningar, såsom funktionsteknik, datavalidering, modellutvärdering och modelltolkning. Detta ger många fördelar eftersom det inte finns någon långvarig infrastruktur att hantera – bearbetningsinstanser snurrar ner när jobb är klara, miljöer kan standardiseras via behållare, data inom Amazon enkel lagringstjänst (Amazon S3) är inbyggt fördelat över instanser, och infrastrukturinställningarna är flexibla när det gäller minne, beräkning och lagring.

SageMaker Processing erbjuder alternativ för hur man distribuerar data. För parallell databehandling måste du använda ShardedByS3Key-alternativet för S3DataDistributionType. När denna parameter är vald tar SageMaker Processing den angivna n instanser och distribuera objekt 1/n objekt från indatakällan över instanserna. Till exempel, om två instanser är försedda med fyra dataobjekt, får varje instans två objekt.

SageMaker Processing kräver tre komponenter för att köra bearbetningsjobb:

• En behållarbild som har din kod och dina beroenden för att köra dina databearbetningsbelastningar
• En sökväg till en indatakälla inom Amazon S3
• En sökväg till en utdatakälla inom Amazon S3

Processen visas i följande diagram.

I det här inlägget visar vi dig hur du använder RStudio på SageMaker för att samverka med en serie SageMaker Processing-jobb för att skapa en parallell databehandlingspipeline med hjälp av R programmeringsspråk.

Lösningen består av följande steg:

1. Ställ in RStudio-projektet.
2. Bygg och registrera bearbetningsbehållarebilden.
3. Kör bearbetningspipelinen i två steg:
   1. Det första steget tar flera datafiler och bearbetar dem över en serie bearbetningsjobb.
   2. Det andra steget sammanfogar utdatafilerna och delar upp dem i tåg-, test- och valideringsdatauppsättningar.

Förutsättningar

Fyll i följande förutsättningar:

1. Ställ in RStudio på SageMaker Workbench. För mer information, se Tillkännager Fullt Managed RStudio på Amazon SageMaker för dataforskare.
2. Skapa en användare med RStudio på SageMaker med lämpliga åtkomstbehörigheter.

Ställ in RStudio-projektet

Utför följande steg för att ställa in RStudio-projektet:

1. Navigera till din Amazon SageMaker Studio kontrollpanelen på SageMaker-konsolen.
2. Starta din app i RStudio-miljön.
   
3. Starta en ny RStudio-session.
4. För Sessionens namn, ange ett namn.
5. För Typ av instans och Bild, använd standardinställningarna.
6. Välja Börja sessionen.
   
7. Navigera in i sessionen.
8. Välja Nytt projekt, Versionskontroll, Och sedan Välj Git.
9. För Repository URL, stiga på https://github.com/aws-samples/aws-parallel-data-processing-r.git
10. Lämna de återstående alternativen som standard och välj Skapa projekt.
    

Du kan navigera till aws-parallel-data-processing-R katalogen på Filer fliken för att visa arkivet. Förvaret innehåller följande 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 behållaren

I det här steget bygger vi vår bearbetningsbehållarebild och skjuter den till Amazon Elastic Container Registry (Amazon ECR). Slutför följande steg:

1. Navigera till Container_Build.rmd fil.
2. installera SageMaker Studio Image Build CLI genom att köra följande cell. Se till att du har de nödvändiga behörigheterna innan du slutför det här steget, detta är en CLI designad för att pusha och registrera behållarbilder i Studio.

   pip install sagemaker-studio-image-build

3. Kör nästa cell för att bygga och registrera vår bearbetningsbehållare:

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

När jobbet har körts får du en utdata som ser ut så här:

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

Kör bearbetningspipeline

När du har byggt behållaren, navigera till Parallel_Data_Processing.rmd fil. Den här filen innehåller en serie steg som hjälper oss att skapa vår parallella databehandlingspipeline med SageMaker Processing. Följande diagram visar stegen i pipelinen som vi slutför.

Börja med att köra paketimportsteget. Importera de nödvändiga RStudio-paketen tillsammans 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')

Ställ nu in din SageMaker exekveringsroll och 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)

Initiera behållaren som vi byggde och registrerade i det tidigare steget:

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

Härifrån dyker vi mer detaljerat in i vart och ett av bearbetningsstegen.

Ladda upp datasetet

För vårt exempel använder vi Databas för bankmarknadsföring från UCI. Vi har redan delat upp datasetet i flera mindre filer. Kör följande kod för att ladda upp filerna till 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")

När filerna har laddats upp går du vidare till nästa steg.

Utför parallell databehandling

I det här steget tar vi datafilerna och utför funktionsteknik för att filtrera bort vissa kolumner. Det här jobbet är fördelat över en serie bearbetningsinstanser (för vårt exempel använder vi två).

Vi använder filter.R fil för att bearbeta data och konfigurera jobbet enligt följande:

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 nämnts tidigare, när du kör ett parallellt databearbetningsjobb måste du justera indataparametern med hur data ska delas och typen av data. Därför tillhandahåller vi skärningsmetoden av S3Prefix:

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

När du har infogat dessa parametrar kommer SageMaker Processing att fördela data lika över antalet valda instanser.

Justera parametrarna efter behov och kör sedan cellen för att instansiera jobbet.

Generera utbildnings-, test- och valideringsdatauppsättningar

I det här steget tar vi de bearbetade datafilerna, kombinerar dem och delar upp dem i test-, tränings- och valideringsdatauppsättningar. Detta gör att vi kan använda data för att bygga vår modell.

Vi använder process.R fil för att bearbeta data och konfigurera jobbet enligt följande:

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

Justera parametrarna är nödvändiga och kör sedan cellen för att instansiera jobbet.

Kör rörledningen

När alla steg har instansierats startar du bearbetningspipelinen för att köra varje steg genom att köra följande cell:

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

Den tid varje av dessa jobb tar kommer att variera baserat på instansstorleken och antalet valda.

Navigera till SageMaker-konsolen för att se alla dina bearbetningsjobb.

Vi börjar med filtreringsjobbet, som visas i följande skärmdump.

När det är klart flyttas pipelinen till databearbetningsjobbet.

När båda jobben är klara, navigera till din S3-skopa. Titta inuti sagemaker-rstudio-example mapp, under processed. Du kan se filerna för tåg-, test- och valideringsdatauppsättningarna.

Slutsats

Med en ökad mängd data som kommer att krävas för att bygga allt mer sofistikerade modeller behöver vi ändra vårt synsätt på hur vi behandlar data. Parallell databehandling är en effektiv metod för att påskynda generering av dataset, och om den kombineras med moderna molnmiljöer och verktyg som RStudio på SageMaker och SageMaker Processing, kan den ta bort mycket av det odifferentierade tunga lyftet av infrastrukturhantering, generering av kodkod och miljöhantering. I det här inlägget gick vi igenom hur du kan implementera parallell databehandling inom RStudio på SageMaker. Vi uppmuntrar dig att prova det genom att klona GitHub-förvaret, och om du har förslag på hur du kan göra upplevelsen bättre, skicka in ett problem eller en pull-förfrågan.

För att lära dig mer om funktionerna och tjänsterna som används i den här lösningen, se RStudio på Amazon SageMaker och Amazon SageMaker-bearbetning.

Om författarna

Raj Pathak är en lösningsarkitekt och teknisk rådgivare till Fortune 50 och medelstora FSI-kunder (Banking, Insurance, Capital Markets) i Kanada och USA. Raj är specialiserad på maskininlärning med applikationer inom dokumentextraktion, kontaktcentertransformation och datorseende.

Jake Wen är en lösningsarkitekt på AWS med passion för ML-utbildning och Natural Language Processing. Jake hjälper Small Medium Business-kunder med design och tankeledarskap att bygga och distribuera applikationer i stor skala. Utanför jobbet tycker han om att vandra.

Aditi Rajnish är en första års programvaruingenjörsstudent vid University of Waterloo. Hennes intressen inkluderar datorseende, naturlig språkbehandling och edge computing. Hon brinner också för samhällsbaserad STEM-uppsökande och opinionsbildning. På fritiden kan hon hittas på att klättra, spela piano eller lära sig att baka den perfekta scones.

Sean Morgan är AI/ML Solutions Architect på AWS. Han har erfarenhet inom halvledarforskning och akademisk forskning och använder sin erfarenhet för att hjälpa kunder att nå sina mål på AWS. På sin fritid är Sean en aktiv bidragsgivare och underhållare med öppen källkod och är specialintressegruppledare för TensorFlow-tillägg.

Paul Wu är en lösningsarkitekt som arbetar i AWS Greenfield Business i Texas. Hans expertområden inkluderar containrar och migrationer.