ฝึกโมเดลขนาดมหึมาด้วยการปรับขนาดแบบใกล้เชิงเส้นโดยใช้ข้อมูลแบบคู่ขนานของชาร์ดบน Amazon SageMaker

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

นี่คือเหตุผลที่เราเพิ่งเปิดตัว sความเท่าเทียมกันของข้อมูลแข็ง on อเมซอน SageMaker, เทคนิคการฝึกอบรมแบบกระจายการประหยัดหน่วยความจำใหม่ใน ไลบรารี่ SageMaker รุ่น Parallel (SMP). ข้อมูลคู่ขนานของข้อมูลที่ชาร์ดสร้างขึ้นตามวัตถุประสงค์สำหรับโมเดลขนาดใหญ่มากและใช้ Amazon ภายในองค์กร มิคส เทคโนโลยีภายใต้ประทุน ซึ่งเป็นความพยายามทางวิทยาศาสตร์ในการลดขนาดการสื่อสารโดยลดค่าใช้จ่ายด้านการสื่อสารที่มีราคาแพงซึ่งมีรากฐานมาจากการรวบรวมพารามิเตอร์และการซิงโครไนซ์แบบไล่ระดับ ด้วยรุ่น GPT-30 พารามิเตอร์ 2B ที่มีความยาวลำดับ 2048 คุณลักษณะใหม่นี้ได้รับ 141 TFLOPs เพิ่มขึ้น 39.7% เมื่อเทียบกับ DeepSpeed ​​ZeRO-3 สำหรับรุ่น 10B GPT-2 ที่มีความยาวลำดับ 512 คุณลักษณะใหม่นี้ยังได้รับ 564 ตัวอย่างต่อวินาที เพิ่มขึ้น 13.9% เมื่อเทียบกับ Fully Sharded Data Parallel (FSDP) ของ PyTorch โปรดจำไว้ว่าในการฝึกโมเดลขนาดยักษ์ ทุกๆ เปอร์เซ็นต์ของการเร่งความเร็วจะแปลเป็นเงินที่ประหยัดได้และประสิทธิภาพการทำงานที่ได้รับในทีมของคุณ

ในบล็อกโพสต์นี้ อันดับแรก เราจะพิจารณาอย่างละเอียดถึงตัวสร้างความแตกต่างที่สำคัญของการขนานข้อมูลแบบชาร์ดและใช้เมื่อใด จากนั้น คุณจะได้เรียนรู้วิธีฝึกโมเดล GPT-30 พารามิเตอร์ 2B บน SageMaker อย่างง่ายดายด้วยฟีเจอร์ใหม่นี้ สุดท้าย เราจะเปรียบเทียบประสิทธิภาพกับตัวเลือกโอเพ่นซอร์สอื่นๆ โดยเฉพาะอย่างยิ่ง มีประสิทธิภาพเหนือกว่า DeepSpeed ​​ZeRO มากถึง 39.7% บน 256 GPUs

การทำงานของข้อมูลแบบคู่ขนานที่ชาร์ดทำงานอย่างไรและควรใช้เมื่อใด

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

ในเฟรมเวิร์กที่มีอยู่ซึ่งอยู่ภายใต้กระบวนทัศน์นี้ โดยเฉพาะ DeepSpeed ​​ZeRO-3 และ FSDP ของ PyTorch ที่อัพสตรีมจาก FairScale สถานะของโมเดลจะถูกแบ่งส่วน ทั้งหมด GPUs ซึ่งเป็นกลยุทธ์ที่ลดการใช้หน่วยความจำใน GPU แต่ละตัวโดยเสียค่าใช้จ่ายในการสื่อสารจำนวนมาก ซึ่งเพิ่มขึ้นตามขนาดคลัสเตอร์ และทำให้ความสามารถในการปรับขนาดลดลงอย่างมากตามขนาด ในทางตรงกันข้าม การแบ่งข้อมูลแบบขนานกันในสถานะโมเดลพาร์ติชั่นไลบรารี SMP ใน a ตระหนักถึงขนาด ลักษณะโดยแบ่งแบบจำลองแต่ละแบบจำลองของสถานะเฉพาะภายใน เซตย่อย ของ GPU

มาดูกันดีกว่าว่า การแบ่งพาร์ติชันแบบจำลองตามมาตราส่วน ใน MiCS ซึ่งเป็นเทคโนโลยีหลักที่อยู่เบื้องหลังข้อมูลชาร์ดแบบคู่ขนาน สัญชาตญาณเบื้องหลังการออกแบบนี้คือการแบ่งพาร์ติชั่นสถานะการฝึกอบรมทั่วทั้งกลุ่มข้อมูลคู่ขนานอาจไม่จำเป็นต้องฝึกแบบจำลองที่มีพารามิเตอร์หลายหมื่นล้านตัว ตัวอย่างเช่น 8 V100 GPUs (32GB แต่ละตัว) เพียงพอที่จะเก็บแบบจำลองสถานะของแบบจำลองของรุ่นพารามิเตอร์ 10B ซึ่งต้องการหน่วยความจำประมาณ 200GB เมื่อฝึกกับ Adam Optimizer โดยใช้ความแม่นยำแบบผสม โดยจำกัดแบบจำลองที่สมบูรณ์ของสถานะแบบจำลองใน น้อยที่สุด ส่วนย่อยของ GPU เราสามารถลดขนาดของค่าใช้จ่ายในการสื่อสารได้อย่างมีประสิทธิภาพเมื่อเทียบกับ DeepSpeed ​​และ PyTorch FSDP ข้อมูลที่แบ่งส่วนคู่ขนานกันยังใช้ประโยชน์จากเทคนิคอื่นๆ ใน MiCS เช่น การสื่อสารแบบลำดับชั้นและการซิงโครไนซ์ไล่ระดับ 2 ฮอป ดูรายละเอียดเพิ่มเติมได้ที่ การปรับขนาดแบบใกล้เชิงเส้นของการฝึกโมเดลขนาดยักษ์บน AWS or MiCS: การปรับสเกลใกล้เชิงเส้นสำหรับการฝึกโมเดลขนาดยักษ์บนคลาวด์สาธารณะ.

ตอนนี้ คุณจะรู้ได้อย่างไรว่าเมื่อใดควรเลือกข้อมูลที่ชาร์ดคู่ขนานกับเทคนิคการฝึกอบรมแบบกระจายอื่นๆ กฎทั่วไปคือถ้าโมเดลของคุณมีพารามิเตอร์น้อยกว่า 1 พันล้านตัวและสามารถใส่ลงในหน่วยความจำ GPU ได้ ไลบรารีข้อมูลคู่ขนานของ SageMaker or คอมไพเลอร์การฝึกอบรม SageMaker ก็เพียงพอสำหรับคุณ หากคุณมีโมเดลทางภาษาหรือคอมพิวเตอร์วิทัศน์ที่ใหญ่กว่า ข้อเสนอแนะของเราคือการฝึกโดยใช้เทคนิคการแบ่งข้อมูลแบบคู่ขนานร่วมกับ การเปิดใช้งานจุดตรวจ และ การเปิดใช้งาน offloading ในไลบรารีคู่ขนานรุ่น SageMaker ก่อน ก่อนเทคนิคอื่นๆ เช่น ความขนานของเทนเซอร์ หรือไปป์ไลน์ขนานกัน

การใช้ความเท่าเทียมกันของข้อมูลที่ชาร์ดเพื่อฝึก GPT-2 บน Amazon SageMaker

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

1. เริ่มต้น

ความเท่าเทียมกันของข้อมูลที่แชร์มีอยู่ใน PyTorch v1.12.0+ และใช้งานได้กับทั้ง FP16 และ BF16 วิธีที่ง่ายที่สุดในการใช้ไลบรารี SMP คือการใช้ AWS Deep Learning Container สำหรับ PyTorch ที่สร้างไว้ล่วงหน้า อย่างไรก็ตาม หากคุณต้องการนำคอนเทนเนอร์ Docker มาเอง สามารถดูได้ที่ สร้างคอนเทนเนอร์ Docker ของคุณเองด้วย SageMaker Distributed Model Parallel Library ในการเริ่มต้น ให้ปฏิบัติตาม แก้ไขสคริปต์การฝึกอบรม PyTorch เพื่อปรับ API ของ SMP ในสคริปต์การฝึกอบรมของคุณ ในส่วนนี้ เราจะพูดถึงขั้นตอนหลักเพียงไม่กี่ขั้นตอนด้วยข้อมูลโค้ดจากสคริปต์การฝึกอบรมที่พร้อมใช้งาน train_gpt_simple.py. สามารถติดตามความคิดเห็นในสคริปต์และ เอกสาร API เพื่อเรียนรู้เพิ่มเติมเกี่ยวกับตำแหน่งที่ใช้ SMP API

ขั้นแรก นำเข้าและเริ่มต้นไลบรารีโดยโทร smdistributed.modelparallel.torch.init() ที่จุดเริ่มต้นของสคริปต์การฝึกอบรม:

import smdistributed.modelparallel.torch as smp

smp.init(smp_config)

ประการที่สอง ห่อโมเดลที่จะแบ่งพาร์ติชันด้วย smdistributed.modelparallel.torch.DistributedModel และใช้การส่งคืน DistributedModel วัตถุไปข้างหน้า:

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_config(model_config)
model = smp.DistributedModel(model, trace_device="gpu", backward_passes_per_step=args.gradient_accumulation)

ห่อเครื่องมือเพิ่มประสิทธิภาพด้วย smdistributed.modelparallel.torch.DistributedOptimizer สำหรับการบันทึกและโหลดสถานะเครื่องมือเพิ่มประสิทธิภาพ

from torch import optim

optimizer = optim.Adam(
    param_groups, betas=(args.beta1, args.beta2), lr=args.lr, weight_decay=args.weight_decay
)

optimizer = smp.DistributedOptimizer(
        optimizer, 
        static_loss_scale=None, 
        dynamic_loss_scale=True,
        dynamic_loss_args={"scale_window": 1000, "min_scale": 1, "delayed_shift": 2},
        )

ใส่ตรรกะไปข้างหน้าและข้างหลังในฟังก์ชันขั้นตอนและตกแต่งด้วย smdistributed.modelparallel.torch.step.  การคำนวณใด ๆ ที่กำหนดไว้ภายใน smp.step-decorated ฟังก์ชั่นจะดำเนินการในลักษณะกระจาย

@smp.step
def train_step(model, optimizer, input_ids, attention_mask, args):
    loss = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)["loss"]
    model.backward(loss)

    return loss

@smp.step
def test_step(model, input_ids, attention_mask):
    loss = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)["loss"]
    
    return loss

2. เตรียมชุดข้อมูล

เราใช้ ข้อความเปิดเว็บ คือชุดข้อมูลที่เราใช้ในตัวอย่างนี้ สมุดบันทึกใช้สคริปต์ data_prep_512.py เพื่อดาวน์โหลดและประมวลผลชุดข้อมูลล่วงหน้า คุณยังสามารถฝึกกับชุดข้อมูลอื่นได้โดยการแก้ไข data_pipeline.py. เมื่อต้องรับมือกับชุดข้อมูลและโมเดลขนาดใหญ่ คุณสามารถเร่งงานการฝึกอบรมได้โดยใช้ข้อมูลที่เก็บไว้ใน Amazon FSx สำหรับความมันวาวซึ่งให้ระบบไฟล์ประสิทธิภาพสูงที่ผสานรวมกับ บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (ส3). โปรดดูคำแนะนำจาก กำหนดค่าช่องทางการป้อนข้อมูลเพื่อใช้ Amazon FSx for Luster เพื่อเป็นแนวทางในการตั้งค่าระบบไฟล์ FSx Luster เป็นช่องทางการป้อนข้อมูล

3. เริ่มงานฝึกอบรม

ขั้นตอนนี้ถือว่าคุณมีอยู่แล้ว แก้ไขสคริปต์การฝึกอบรมของคุณ และเตรียมชุดข้อมูลตามที่กล่าวไว้ในส่วนที่แล้ว ถึง เปิดใช้งานความเท่าเทียมกันของข้อมูลที่ชาร์ดเพียงตั้งค่า sharded_data_parallel_degree ใน ตัวประมาณค่า PyTorch. ในบทช่วยสอนนี้ เราตั้งค่า sharded_data_parallel_degree=128 และ  instace_count=32 สำหรับโหนด p4d.24xlarge ซึ่งบ่งชี้ว่าสถานะของรุ่นจะถูกแบ่งส่วนใน 128 GPUs จากทั้งหมด 256 GPUs ตามค่าที่เลือกนี้ SMP จะตั้งค่าระดับข้อมูลคู่ขนานเป็น 2 โดยอัตโนมัติ (เพราะ 256/128=2) หมายความว่าเราจะมีแบบจำลองสองแบบสำหรับความขนานของข้อมูล กฎทั่วไปในการเลือกมูลค่าในอุดมคติสำหรับ sharded_data_parallel_degree คือการเพิ่มโหนดอีกหนึ่งโหนดในกลุ่มการแบ่งปันต่อทุกๆ 3B ของพารามิเตอร์โมเดล ในบทช่วยสอนนี้ ขนาดโมเดลของเราคือ 30B เราจึงควรใช้โหนดอย่างน้อย 10 โหนดสำหรับการชาร์ด และเนื่องจาก 16 โหนด (128 GPU) เป็นพลังที่น้อยที่สุดของ-2 เหนือขีดจำกัด เราจึงตั้งค่า sharded_data_parallel_degree=128.

สำหรับด่านตรวจ เรายังจัดเตรียมชุดสาธารณูปโภคจุดตรวจใน sharded_data_parallel_checkpoint.py รวมถึงยูทิลิตี้ในการสร้างใหม่ทั้งหมด state_dict สำหรับกรณีการใช้งานขั้นสูง สุดท้าย เราสามารถเริ่มงานการฝึกอบรมแบบกระจายโดยเรียก fit() บน Estimator

smp_estimator = PyTorch(
    entry_point="train_gpt_simple.py",
    instance_type="ml.p4d.24xlarge",
    source_dir=os.getcwd(),
    volume_size=500,
    instance_count=32,
    distribution={
        "mpi": {
            "enabled": True,
            "processes_per_host": processes_per_host,
            "custom_mpi_options": mpioptions,
        },
        "smdistributed": {
            "modelparallel": {
                "enabled": True,
                "parameters": {
                    "ddp": True,
                    "skip_tracing": True,
                    "delayed_parameter_initialization": True,
                    "offload_activations": True,
                    "activation_loading_horizon": 4,
                    # To enable sharded data parallelism.
                    # Here we shard model states across 128 GPUs. 
                    "sharded_data_parallel_degree": 128, 
                    "fp16": False,
                    "bf16": True,
                    # This is to disable pipeline parallelism.
                    "partitions": 1,
                },
            }
        },
    },
    framework_version="1.12",
    py_version="py38",
    hyperparameters=hyperparameters,
    checkpoint_s3_uri=checkpoint_s3_uri if not use_fsx else None,
    checkpoint_local_path=hyperparameters["checkpoint-dir"] if use_fsx else None,
    ...
)

smp_estimator.fit(inputs=data_channels)

4. ติดตามงานฝึกอบรม

คุณสามารถเข้าถึงบันทึกการฝึกอบรมและติดตามการใช้ GPU และหน่วยความจำบน อเมซอน คลาวด์วอตช์. อย่าลืมดูบันทึกของ “algo-1” เพราะนั่นคือโหนดหลักที่สตรีมเอาต์พุตมีบันทึกการใช้งานการฝึกอบรมจากทุกอินสแตนซ์

ประสิทธิภาพการเปรียบเทียบ

เราเปรียบเทียบความเท่าเทียมของข้อมูลที่แบ่งส่วนในไลบรารี SMP บนทั้งโหนด 16 และ 32 p4d.24xlarge สำหรับลำดับความยาว 512 และ 2048 ตามลำดับ โมเดล GPT30 พารามิเตอร์ 2B ได้รับการกำหนดค่าให้ใช้ความกว้างที่ซ่อนอยู่ 7168, 48 เลเยอร์ และ 64 หัว คุณสามารถใช้การกำหนดค่าเดียวกันโดยที่ความยาวของลำดับคือ 2048 โดยการตั้งค่า model_config = "gpt2-30b" ในสมุดบันทึกบทช่วยสอน ด้วยการตั้งค่านี้ SMP ได้ 73.52 ตัวอย่างต่อวินาที เพิ่มขึ้น 39.7% เมื่อเทียบกับ DeepSpeed ​​ZeRO-3 หากขนาดโทเค็นของคุณคือ 500 แสนล้าน การเพิ่มความเร็วนี้หมายถึงการประหยัดโหนด p367d.4xlarge ได้เกือบ 24 ชั่วโมง ซึ่งเทียบเท่ากับงบประมาณที่ประหยัดได้มากกว่า 12,000 ดอลลาร์ต่อการฝึกอบรม! ตารางต่อไปนี้สรุปผลการวัดประสิทธิภาพของเรา

1/ สำหรับการกำหนดค่าแต่ละรุ่น เราได้ทดสอบคุณสมบัติ ขั้นตอน และการกำหนดค่าที่แตกต่างกันใน DeepSpeed ​​ZeRO และเลือกรูปแบบที่ให้ปริมาณงานที่ดีที่สุดเป็นพื้นฐาน DeepSpeed เกณฑ์มาตรฐานทำงานบน อเมซอน อีลาสติก คอมพิวท์ คลาวด์ (อเมซอน อีซี2). 2/ ผลลัพธ์เหล่านี้ขึ้นอยู่กับกลุ่มการสื่อสารที่ได้รับการปรับปรุงซึ่งได้รับการปรับให้เหมาะสมสำหรับ AWS ซึ่งจะพร้อมใช้งานในไม่ช้า 3/ ระยะเวลาในการฝึกคำนวณจากความเร็วตามจำนวนโทเค็นที่ประมวลผล

โดยสรุป เราสังเกตเห็นปริมาณงานที่สูงขึ้นอย่างต่อเนื่องโดยมีการขนานข้อมูลแบบชาร์ดใน SMP เมื่อเทียบกับ DeepSpeed ​​ในรุ่นต่างๆ และการกำหนดค่าต่างๆ คุณสมบัติใหม่นี้ยังแสดงให้เห็นถึงประสิทธิภาพของหน่วยความจำที่ดีกว่าเมื่อเทียบกับ DeepSpeed ​​ทำให้ SMP สามารถใส่ขนาดแบทช์ที่ใหญ่ขึ้น และลดระดับของการสะสมเกรเดียนท์ที่จำเป็นเพื่อให้พอดีกับขนาดแบทช์ทั่วโลกโดยเฉพาะ

สรุป

ในโพสต์นี้ เราแนะนำเทคนิคการฝึกอบรมแบบกระจายใหม่ — ชาร์ดข้อมูลแบบคู่ขนาน — และวิธีเพิ่มความเร็วในการฝึกโมเดลขนาดยักษ์ด้วยการปรับขนาดเกือบเป็นเส้นตรงบน Amazon SageMaker นอกจากนี้เรายังได้แนะนำวิธีการฝึกโมเดล GPT-2 ด้วยเทคนิคใหม่ดังต่อไปนี้ ตัวอย่างที่สมบูรณ์. สามารถติดตาม ตัวอย่าง Amazon SageMaker GitHub repo เพื่อติดตามตัวอย่างรุ่น SageMaker แบบขนานทั้งหมดหรือเข้าร่วมรายการต่อไปของเรา กระจายการอบรมเชิงปฏิบัติการ. หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับความเท่าเทียมกันของข้อมูลที่ชาร์ด โปรดดูที่ เอกสาร.

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

เอมิลี่ เว็บเบอร์ เข้าร่วม AWS หลังจากเปิดตัว SageMaker และพยายามบอกให้โลกรู้ตั้งแต่นั้นมา! นอกเหนือจากการสร้างประสบการณ์ ML ใหม่ให้กับลูกค้าแล้ว เอมิลี่ชอบนั่งสมาธิและศึกษาพุทธศาสนาในทิเบต

แคน คาราคุส เป็นนักวิทยาศาสตร์ประยุกต์อาวุโสที่ AWS เพิ่มประสิทธิภาพการเรียนรู้เชิงลึกแบบกระจายขนาดใหญ่บน AWS ความสนใจในงานวิจัยของเขาครอบคลุมถึงการเรียนรู้เชิงลึก การเพิ่มประสิทธิภาพแบบกระจาย ระบบแบบกระจาย และทฤษฎีสารสนเทศ นอกเวลางาน เขาชอบปั่นจักรยาน ท่องเที่ยว อ่านหนังสือ และเรียนรู้

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

สุหิต ก้องกุล เป็นวิศวกรพัฒนาซอฟต์แวร์กับกลุ่ม AWS Artificial Intelligence ที่ทำงานเกี่ยวกับเฟรมเวิร์กการเรียนรู้เชิงลึก ในเวลาว่าง เขาชอบเดินป่า ท่องเที่ยว และทำอาหาร

เอริน โฮ เป็น Product Manager สำหรับ AWS Deep Learning เธอทำงานเกี่ยวกับผลิตภัณฑ์ที่ช่วยให้ลูกค้าฝึกโมเดลการเรียนรู้เชิงลึกบน AWS ได้ง่ายขึ้น เธอชอบเดินป่าและเล่นสกีเพื่อความสนุกสนานนอกบ้าน