การประมวลผลข้อมูลแบบขนานด้วย RStudio บน Amazon SageMaker

ปีที่แล้วเราได้ประกาศความพร้อมใช้งานทั่วไปของ RStudio บน Amazon SageMakerซึ่งเป็นสภาพแวดล้อมการพัฒนาแบบบูรณาการ (IDE) RStudio Workbench ที่มีการจัดการเต็มรูปแบบรายแรกของอุตสาหกรรมในระบบคลาวด์ คุณสามารถเปิดใช้ RStudio IDE ที่คุ้นเคยได้อย่างรวดเร็ว และหมุนขึ้นและลงทรัพยากรการประมวลผลพื้นฐานโดยไม่รบกวนการทำงานของคุณ ทำให้ง่ายต่อการสร้างโซลูชันการเรียนรู้ของเครื่อง (ML) และการวิเคราะห์ใน R ในปริมาณมาก

ด้วยการสร้างปริมาณข้อมูลที่เพิ่มขึ้นเรื่อยๆ ชุดข้อมูลที่ใช้สำหรับ ML และการวิเคราะห์ทางสถิติจึงเติบโตควบคู่กันไป ด้วยเหตุนี้จึงทำให้ความท้าทายของเวลาในการพัฒนาเพิ่มขึ้นและการจัดการโครงสร้างพื้นฐานด้านการคำนวณ เพื่อแก้ปัญหาความท้าทายเหล่านี้ นักวิทยาศาสตร์ด้านข้อมูลจึงมองหาการนำเทคนิคการประมวลผลข้อมูลแบบคู่ขนานมาใช้ การประมวลผลข้อมูลแบบขนานหรือ การทำข้อมูลให้ขนานกันนำชุดข้อมูลที่มีอยู่จำนวนมากและกระจายไปยังโปรเซสเซอร์หรือโหนดหลายตัวเพื่อดำเนินการกับข้อมูลพร้อมกัน ซึ่งช่วยให้ประมวลผลชุดข้อมูลขนาดใหญ่ได้เร็วขึ้น พร้อมกับการใช้งานที่ปรับให้เหมาะสมในการประมวลผล สิ่งนี้สามารถช่วยให้ผู้ปฏิบัติงาน ML สร้างรูปแบบที่ใช้ซ้ำได้สำหรับการสร้างชุดข้อมูล และยังช่วยลดภาระและต้นทุนของโครงสร้างพื้นฐานในการประมวลผล

ภาพรวมโซลูชัน

ภายใน อเมซอน SageMaker, ลูกค้าหลายคนใช้ การประมวลผล SageMaker เพื่อช่วยดำเนินการประมวลผลข้อมูลแบบคู่ขนาน ด้วยการประมวลผล SageMaker คุณสามารถใช้ประสบการณ์ที่ได้รับการจัดการที่เรียบง่ายและเรียบง่ายบน SageMaker เพื่อรันปริมาณงานการประมวลผลข้อมูลของคุณ เช่น วิศวกรรมคุณลักษณะ การตรวจสอบความถูกต้องของข้อมูล การประเมินแบบจำลอง และการตีความแบบจำลอง สิ่งนี้มีประโยชน์มากมาย เนื่องจากไม่มีโครงสร้างพื้นฐานที่ต้องใช้เวลานานในการจัดการ—อินสแตนซ์การประมวลผลจะค่อยๆ ลดลงเมื่องานเสร็จสมบูรณ์ สภาพแวดล้อมสามารถกำหนดมาตรฐานได้ผ่านคอนเทนเนอร์ ข้อมูลภายใน บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) มีการแจกจ่ายแบบเนทีฟทั่วทั้งอินสแตนซ์ และการตั้งค่าโครงสร้างพื้นฐานมีความยืดหยุ่นในแง่ของหน่วยความจำ การประมวลผล และพื้นที่จัดเก็บ

การประมวลผล SageMaker มีตัวเลือกสำหรับวิธีกระจายข้อมูล สำหรับการประมวลผลข้อมูลแบบขนาน คุณต้องใช้ ตัวเลือก ShardedByS3Key สำหรับ S3DataDistributionType. เมื่อเลือกพารามิเตอร์นี้ การประมวลผล SageMaker จะใช้ n อินสแตนซ์และแจกจ่ายวัตถุ 1/n อ็อบเจ็กต์จากแหล่งข้อมูลอินพุตข้ามอินสแตนซ์ ตัวอย่างเช่น หากอินสแตนซ์สองรายการได้รับออบเจ็กต์ข้อมูลสี่รายการ อินสแตนซ์แต่ละรายการจะได้รับสองออบเจ็กต์

การประมวลผล SageMaker ต้องการสามองค์ประกอบเพื่อรันงานการประมวลผล:

• อิมเมจคอนเทนเนอร์ที่มีโค้ดและการขึ้นต่อกันของคุณเพื่อเรียกใช้เวิร์กโหลดการประมวลผลข้อมูลของคุณ
• เส้นทางไปยังแหล่งข้อมูลอินพุตภายใน Amazon S3
• เส้นทางไปยังแหล่งข้อมูลเอาต์พุตภายใน Amazon S3

กระบวนการนี้อธิบายไว้ในแผนภาพต่อไปนี้

ในโพสต์นี้ เราจะแสดงวิธีใช้ RStudio บน SageMaker เพื่อเชื่อมต่อกับชุดของงานการประมวลผล SageMaker เพื่อสร้างไปป์ไลน์การประมวลผลข้อมูลแบบขนานโดยใช้ ภาษาโปรแกรมอาร์

การแก้ปัญหาประกอบด้วยขั้นตอนต่อไปนี้:

1. ตั้งค่าโครงการ RStudio
2. สร้างและลงทะเบียนอิมเมจคอนเทนเนอร์การประมวลผล
3. เรียกใช้ไปป์ไลน์การประมวลผลสองขั้นตอน:
   1. ขั้นตอนแรกใช้ไฟล์ข้อมูลหลายไฟล์และประมวลผลผ่านชุดงานการประมวลผล
   2. ขั้นตอนที่สองเชื่อมต่อไฟล์เอาต์พุตและแยกออกเป็นชุดข้อมูลฝึก ทดสอบ และยืนยันความถูกต้อง

เบื้องต้น

กรอกข้อกำหนดเบื้องต้นต่อไปนี้:

1. ตั้งค่า RStudio บน SageMaker Workbench สำหรับข้อมูลเพิ่มเติม โปรดดูที่ ประกาศ RStudio ที่มีการจัดการเต็มรูปแบบบน Amazon SageMaker สำหรับนักวิทยาศาสตร์ข้อมูล.
2. สร้างผู้ใช้ด้วย RStudio บน SageMaker ด้วยสิทธิ์การเข้าถึงที่เหมาะสม

ตั้งค่าโครงการ RStudio

ในการตั้งค่าโปรเจ็กต์ RStudio ให้ทำตามขั้นตอนต่อไปนี้:

1. ไปที่ของคุณ สตูดิโอ Amazon SageMaker แผงควบคุมบนคอนโซล SageMaker
2. เปิดแอปของคุณในสภาพแวดล้อม RStudio
   
3. เริ่มเซสชัน RStudio ใหม่
4. สำหรับ ชื่อเซสชัน, ป้อนชื่อ
5. สำหรับ ประเภทอินสแตนซ์ และ ภาพให้ใช้การตั้งค่าเริ่มต้น
6. Choose เริ่มเซสชัน.
   
7. นำทางไปยังเซสชัน
8. Choose โครงการใหม่, การควบคุมเวอร์ชันและจากนั้น เลือก Git.
9. สำหรับ URL ที่เก็บป้อน https://github.com/aws-samples/aws-parallel-data-processing-r.git
10. ปล่อยให้ตัวเลือกที่เหลือเป็นค่าเริ่มต้นและเลือก สร้างโครงการ.
    

คุณสามารถนำทางไปยัง aws-parallel-data-processing-R ไดเรกทอรีบน ไฟล์ แท็บเพื่อดูที่เก็บ ที่เก็บมีไฟล์ต่อไปนี้:

• 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

สร้างคอนเทนเนอร์

ในขั้นตอนนี้ เราสร้างอิมเมจคอนเทนเนอร์การประมวลผลและพุชไปที่ การลงทะเบียน Amazon Elastic Container (อเมซอน อีซีอาร์). ทำตามขั้นตอนต่อไปนี้:

1. ไปที่ Container_Build.rmd ไฟล์
2. ติดตั้ง CLI บิลด์อิมเมจของ SageMaker Studio โดยเรียกใช้เซลล์ต่อไปนี้ ตรวจสอบให้แน่ใจว่าคุณมีสิทธิ์ที่จำเป็นก่อนที่จะทำตามขั้นตอนนี้ นี่คือ CLI ที่ออกแบบมาเพื่อส่งและลงทะเบียนอิมเมจคอนเทนเนอร์ภายใน Studio

   pip install sagemaker-studio-image-build

3. เรียกใช้เซลล์ถัดไปเพื่อสร้างและลงทะเบียนคอนเทนเนอร์การประมวลผลของเรา:

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

หลังจากรันงานสำเร็จแล้ว คุณจะได้รับเอาต์พุตที่มีลักษณะดังนี้:

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

เรียกใช้ไปป์ไลน์การประมวลผล

หลังจากที่คุณสร้างคอนเทนเนอร์ ให้ไปที่ Parallel_Data_Processing.rmd ไฟล์. ไฟล์นี้มีขั้นตอนต่างๆ ที่ช่วยให้เราสร้างไปป์ไลน์การประมวลผลข้อมูลแบบคู่ขนานโดยใช้การประมวลผล SageMaker ไดอะแกรมต่อไปนี้แสดงขั้นตอนของไปป์ไลน์ที่เราดำเนินการเสร็จสิ้น

เริ่มต้นด้วยการรันขั้นตอนการนำเข้าแพ็คเกจ นำเข้าแพ็คเกจ RStudio ที่จำเป็นพร้อมกับ 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')

ตอนนี้ตั้งค่าบทบาทการดำเนินการ SageMaker และรายละเอียดสภาพแวดล้อม:

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)

เริ่มต้นคอนเทนเนอร์ที่เราสร้างและลงทะเบียนในขั้นตอนก่อนหน้า:

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

จากที่นี่ เราจะเจาะลึกลงไปในแต่ละขั้นตอนการประมวลผลอย่างละเอียดยิ่งขึ้น

อัปโหลดชุดข้อมูล

ตัวอย่างเช่น เราใช้ the ชุดข้อมูลการตลาดธนาคารจาก UCI. เราได้แบ่งชุดข้อมูลออกเป็นไฟล์ขนาดเล็กหลายไฟล์แล้ว เรียกใช้โค้ดต่อไปนี้เพื่ออัปโหลดไฟล์ไปยัง 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")

หลังจากอัปโหลดไฟล์แล้ว ให้ไปยังขั้นตอนถัดไป

ดำเนินการประมวลผลข้อมูลแบบขนาน

ในขั้นตอนนี้ เราจะนำไฟล์ข้อมูลและดำเนินการวิศวกรรมคุณลักษณะเพื่อกรองบางคอลัมน์ออก งานนี้กระจายไปตามชุดของอินสแตนซ์การประมวลผล (เช่น เราใช้สองอินสแตนซ์)

เราใช้ filter.R ไฟล์เพื่อประมวลผลข้อมูลและกำหนดค่างานดังนี้:

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

ดังที่ได้กล่าวไว้ก่อนหน้านี้ เมื่อรันงานการประมวลผลข้อมูลแบบขนาน คุณต้องปรับพารามิเตอร์อินพุตด้วยวิธีการแบ่งส่วนข้อมูลและประเภทของข้อมูล ดังนั้นเราจึงจัดเตรียมวิธีการชาร์ดโดย S3Prefix:

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

หลังจากที่คุณแทรกพารามิเตอร์เหล่านี้แล้ว การประมวลผล SageMaker จะกระจายข้อมูลตามจำนวนอินสแตนซ์ที่เลือกเท่าๆ กัน

ปรับพารามิเตอร์ตามความจำเป็น จากนั้นเรียกใช้เซลล์เพื่อสร้างอินสแตนซ์ของงาน

สร้างชุดข้อมูลการฝึกอบรม ทดสอบ และตรวจสอบความถูกต้อง

ในขั้นตอนนี้ เราจะนำไฟล์ข้อมูลที่ประมวลผลมา รวมเข้าด้วยกัน และแบ่งออกเป็นชุดข้อมูลทดสอบ ฝึกฝน และยืนยันความถูกต้อง ซึ่งช่วยให้เราใช้ข้อมูลเพื่อสร้างแบบจำลองของเราได้

เราใช้ process.R ไฟล์เพื่อประมวลผลข้อมูลและกำหนดค่างานดังนี้:

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

ปรับพารามิเตอร์ที่จำเป็น แล้วเรียกใช้เซลล์เพื่อสร้างอินสแตนซ์ของงาน

เรียกใช้ไปป์ไลน์

หลังจากสร้างอินสแตนซ์ของขั้นตอนทั้งหมดแล้ว ให้เริ่มต้นไปป์ไลน์การประมวลผลเพื่อเรียกใช้แต่ละขั้นตอนโดยเรียกใช้เซลล์ต่อไปนี้:

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

เวลาที่งานเหล่านี้ใช้จะแตกต่างกันไปตามขนาดอินสแตนซ์และจำนวนที่เลือก

ไปที่คอนโซล SageMaker เพื่อดูงานการประมวลผลทั้งหมดของคุณ

เราเริ่มต้นด้วยงานการกรองตามที่แสดงในภาพหน้าจอต่อไปนี้

เมื่อเสร็จสิ้น ไปป์ไลน์จะย้ายไปที่งานการประมวลผลข้อมูล

เมื่องานทั้งสองเสร็จสมบูรณ์ ให้ไปที่บัคเก็ต S3 ของคุณ ดูภายใน sagemaker-rstudio-example โฟลเดอร์ภายใต้ processed. คุณสามารถดูไฟล์สำหรับชุดข้อมูลรถไฟ การทดสอบ และการตรวจสอบความถูกต้อง

สรุป

ด้วยจำนวนข้อมูลที่เพิ่มขึ้นซึ่งจำเป็นต่อการสร้างแบบจำลองที่ซับซ้อนมากขึ้น เราจำเป็นต้องเปลี่ยนแนวทางของเราในการประมวลผลข้อมูล การประมวลผลข้อมูลแบบคู่ขนานเป็นวิธีที่มีประสิทธิภาพในการเร่งการสร้างชุดข้อมูล และหากควบคู่ไปกับสภาพแวดล้อมและเครื่องมือระบบคลาวด์ที่ทันสมัย ​​เช่น RStudio บน SageMaker และ SageMaker Processing สามารถขจัดการจัดการโครงสร้างพื้นฐาน การสร้างโค้ดสำเร็จรูป และการจัดการสภาพแวดล้อมที่ไม่แตกต่างกันออกไป ในโพสต์นี้ เราได้อธิบายวิธีการใช้การประมวลผลข้อมูลแบบขนานภายใน RStudio บน SageMaker เราขอแนะนำให้คุณลองใช้โดยการโคลนที่เก็บ GitHub และหากคุณมีข้อเสนอแนะเกี่ยวกับวิธีปรับปรุงประสบการณ์ใช้งานให้ดีขึ้น โปรดส่งปัญหาหรือคำขอดึง

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับคุณสมบัติและบริการที่ใช้ในโซลูชันนี้ โปรดดูที่ RStudio บน Amazon SageMaker และ การประมวลผล Amazon SageMaker.

เกี่ยวกับผู้แต่ง

ราชปฏัก เป็นสถาปนิกโซลูชันและที่ปรึกษาด้านเทคนิคสำหรับลูกค้า Fortune 50 และ FSI ขนาดกลาง (การธนาคาร ประกันภัย ตลาดทุน) ทั่วแคนาดาและสหรัฐอเมริกา Raj เชี่ยวชาญด้านแมชชีนเลิร์นนิงด้วยแอปพลิเคชันในการดึงเอกสาร การแปลงศูนย์การติดต่อ และคอมพิวเตอร์วิทัศน์

เจค เหวิน เป็นสถาปนิกโซลูชันที่ AWS ด้วยความหลงใหลในการฝึกอบรม ML และการประมวลผลภาษาธรรมชาติ Jake ช่วยลูกค้า Small Medium Business ด้วยการออกแบบและความเป็นผู้นำทางความคิดในการสร้างและปรับใช้แอปพลิเคชันในวงกว้าง นอกที่ทำงานเขาชอบเดินป่า

อดิติ รานิช เป็นนักศึกษาวิศวกรรมซอฟต์แวร์ปีแรกที่มหาวิทยาลัยวอเตอร์ลู ความสนใจของเธอ ได้แก่ คอมพิวเตอร์วิทัศน์ การประมวลผลภาษาธรรมชาติ และคอมพิวเตอร์เอดจ์ นอกจากนี้ เธอยังหลงใหลในการเผยแพร่ STEM ในระดับชุมชนและการสนับสนุน ในเวลาว่าง เธอสามารถปีนหน้าผา เล่นเปียโน หรือเรียนรู้วิธีทำสโคนที่สมบูรณ์แบบ

ฌอน มอร์แกน เป็นสถาปนิกโซลูชัน AI/ML ที่ AWS เขามีประสบการณ์ในสาขาเซมิคอนดักเตอร์และการวิจัยเชิงวิชาการ และใช้ประสบการณ์ของเขาเพื่อช่วยให้ลูกค้าบรรลุเป้าหมายบน AWS ในเวลาว่าง Sean เป็นผู้สนับสนุนและผู้ดูแลโอเพนซอร์สที่ทำงานอยู่ และเป็นผู้นำกลุ่มผลประโยชน์พิเศษสำหรับโปรแกรมเสริม TensorFlow

พอลวู เป็นสถาปนิกโซลูชันที่ทำงานใน Greenfield Business ของ AWS ในเท็กซัส ความเชี่ยวชาญของเขารวมถึงคอนเทนเนอร์และการย้ายถิ่นฐาน