ปรับไฮเปอร์พารามิเตอร์ให้เหมาะสมด้วยการปรับโมเดลอัตโนมัติของ Amazon SageMaker

โมเดลแมชชีนเลิร์นนิง (ML) กำลังทำให้โลกต้องตกตะลึง ประสิทธิภาพขึ้นอยู่กับการใช้ข้อมูลการฝึกอบรมที่ถูกต้องและการเลือกรูปแบบและอัลกอริทึมที่เหมาะสม แต่มันไม่ได้จบลงที่นี่ โดยทั่วไปแล้ว อัลกอริทึมจะเลื่อนการตัดสินใจออกแบบบางอย่างออกไปเพื่อให้ผู้ปฏิบัติงาน ML นำไปใช้กับข้อมูลและงานเฉพาะของตน การตัดสินใจออกแบบที่รอการตัดบัญชีเหล่านี้แสดงให้เห็นว่า ไฮเปอร์พารามิเตอร์.

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

เช่นเดียวกับการหมุนปุ่มบนเครื่องรับวิทยุเพื่อหาความถี่ที่เหมาะสม ไฮเปอร์พารามิเตอร์แต่ละตัวควรได้รับการปรับอย่างระมัดระวังเพื่อเพิ่มประสิทธิภาพการทำงาน การค้นหาพื้นที่ไฮเปอร์พารามิเตอร์สำหรับค่าที่เหมาะสมเรียกว่า การปรับไฮเปอร์พารามิเตอร์ or การเพิ่มประสิทธิภาพไฮเปอร์พารามิเตอร์ (HPO) และควรได้ผลลัพธ์เป็นโมเดลที่ทำนายได้แม่นยำ

ในโพสต์นี้ เราตั้งค่าและเรียกใช้งาน HPO แรกของเราโดยใช้ การปรับโมเดลอัตโนมัติของ Amazon SageMaker (อมต). เราเรียนรู้เกี่ยวกับวิธีการที่มีในการสำรวจผลลัพธ์ และสร้างภาพข้อมูลเชิงลึกของการทดลอง HPO ของเราและการสำรวจพื้นที่พารามิเตอร์หลายมิติ!

การปรับโมเดลอัตโนมัติของ Amazon SageMaker

ในฐานะผู้ปฏิบัติงาน ML โดยใช้ SageMaker เอเอ็มทีคุณสามารถมุ่งเน้นไปที่สิ่งต่อไปนี้:

• จัดหางานฝึกอบรม
• การกำหนดเมตริกวัตถุประสงค์ที่ตรงกับงานของคุณ
• การกำหนดขอบเขตพื้นที่การค้นหาไฮเปอร์พารามิเตอร์

SageMaker AMT จะดูแลส่วนที่เหลือ และคุณไม่จำเป็นต้องคิดถึงโครงสร้างพื้นฐาน การจัดการงานฝึกอบรม และการปรับปรุงการเลือกไฮเปอร์พารามิเตอร์

เริ่มต้นด้วยการใช้ SageMaker AMT สำหรับงาน HPO อย่างง่ายงานแรกของเรา เพื่อฝึกและปรับแต่งอัลกอริทึม XGBoost เราต้องการให้การเดินทาง AMT ของคุณเป็นแบบลงมือปฏิบัติจริง เราจึงได้แบ่งปันตัวอย่างดังต่อไปนี้ พื้นที่เก็บข้อมูล GitHub. โพสต์นี้ครอบคลุมถึง 1_tuning_of_builtin_xgboost.ipynb สมุดบันทึก.

ในโพสต์ถัดไป เราจะขยายแนวคิดของการค้นหาไฮเปอร์พารามิเตอร์ที่ดีที่สุดและรวมถึงการเรียนรู้เกี่ยวกับพื้นที่การค้นหาและช่วงไฮเปอร์พารามิเตอร์ใดที่โมเดลมีความละเอียดอ่อน นอกจากนี้ เราจะแสดงวิธีเปลี่ยนกิจกรรมการปรับแต่งแบบ one-shot เป็นการสนทนาหลายขั้นตอนกับผู้ปฏิบัติงาน ML เพื่อเรียนรู้ร่วมกัน คอยติดตาม (ปุนตั้งใจ)!

เบื้องต้น

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

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

เรากำลังจะสร้างการตั้งค่าแบบ end-to-end เพื่อเรียกใช้งาน HPO แรกของเราโดยใช้ SageMaker AMT เมื่องานการปรับแต่งของเราเสร็จสิ้น เราจะพิจารณาวิธีการบางอย่างที่มีในการสำรวจผลลัพธ์ ทั้งผ่านทาง คอนโซลการจัดการ AWS และเขียนโปรแกรมผ่าน AWS SDK และ API

อันดับแรก เราทำความคุ้นเคยกับสภาพแวดล้อมและการฝึกอบรม SageMaker โดยการเรียกใช้งานการฝึกอบรมแบบสแตนด์อโลน โดยไม่ต้องปรับแต่งใดๆ ในตอนนี้ เราใช้อัลกอริทึม XGBoost ซึ่งเป็นหนึ่งในหลาย ๆ อัลกอริทึมที่มีให้เป็น อัลกอริทึมในตัวของ SageMaker (ไม่ต้องใช้สคริปต์การฝึกอบรม!).

เรามาดูกันว่า SageMaker Training ทำงานในลักษณะต่อไปนี้:

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

จากนั้นเราย้ายไปที่ AMT และเรียกใช้งาน HPO:

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

ฝึกอัลกอริทึม XGBoost ในตัวของ SageMaker

ทุกอย่างเริ่มต้นด้วยการฝึกอบรมแบบจำลอง ในการทำเช่นนั้น เราเข้าใจว่า SageMaker Training ทำงานอย่างไร

เราต้องการใช้ประโยชน์จากความเร็วและความสะดวกในการใช้งานที่นำเสนอโดย SageMaker อัลกอริทึมในตัว. สิ่งที่เราต้องทำมีเพียงไม่กี่ขั้นตอนในการเริ่มต้นการฝึกอบรม:

1. เตรียมและโหลดข้อมูล – เราดาวน์โหลดและเตรียมชุดข้อมูลของเราเป็นอินพุตสำหรับ XGBoost และอัปโหลดไปยังของเรา บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) ถัง
2. เลือก URI รูปภาพของอัลกอริทึมในตัวของเรา – SageMaker ใช้ URI นี้เพื่อดึงคอนเทนเนอร์การฝึกอบรมของเรา ซึ่งในกรณีของเราประกอบด้วยสคริปต์การฝึกอบรม XGBoost ที่พร้อมใช้งาน รองรับอัลกอริทึมหลายเวอร์ชัน.
3. กำหนดไฮเปอร์พารามิเตอร์ – SageMaker มีอินเทอร์เฟซสำหรับกำหนด ไฮเปอร์พารามิเตอร์ สำหรับอัลกอริทึมในตัวของเรา พารามิเตอร์เหล่านี้เป็นไฮเปอร์พารามิเตอร์เดียวกันกับที่ใช้โดยเวอร์ชันโอเพ่นซอร์ส
4. สร้างตัวประมาณค่า – เรากำหนดพารามิเตอร์การฝึกอบรม เช่น ประเภทอินสแตนซ์และจำนวนอินสแตนซ์
5. เรียกใช้ฟังก์ชัน fit() – เราเริ่มงานฝึกอบรมของเรา

แผนภาพต่อไปนี้แสดงให้เห็นว่าขั้นตอนเหล่านี้ทำงานร่วมกันอย่างไร

ให้ข้อมูล

ในการเรียกใช้การฝึกอบรม ML เราจำเป็นต้องให้ข้อมูล เราให้ข้อมูลการฝึกอบรมและการตรวจสอบแก่ SageMaker ผ่าน Amazon S3

ในตัวอย่างของเรา เพื่อความง่าย เราใช้บัคเก็ตเริ่มต้นของ SageMaker เพื่อจัดเก็บข้อมูลของเรา แต่อย่าลังเลที่จะปรับแต่งค่าต่อไปนี้ตามความต้องการของคุณ:

sm_sess = sagemaker.session.Session([..])

BUCKET = sm_sess.default_bucket()
PREFIX = 'amt-visualize-demo'
output_path = f's3://{BUCKET}/{PREFIX}/output'

ในสมุดบันทึก เราใช้ชุดข้อมูลสาธารณะและเก็บข้อมูลไว้ในเครื่อง data ไดเรกทอรี จากนั้นเราจะอัปโหลดข้อมูลการฝึกอบรมและการตรวจสอบไปยัง Amazon S3 ต่อมา เรายังกำหนดตัวชี้ไปยังตำแหน่งเหล่านี้เพื่อส่งต่อไปยัง SageMaker Training

# acquire and prepare the data (not shown here)
# store the data locally
[..]
train_data.to_csv('data/train.csv', index=False, header=False)
valid_data.to_csv('data/valid.csv', index=False, header=False)
[..]
# upload the local files to S3
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/train/train.csv')).upload_file('data/train.csv')
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/valid/valid.csv')).upload_file('data/valid.csv')

ในโพสต์นี้ เรามุ่งเน้นที่การแนะนำ HPO สำหรับภาพประกอบ เราใช้ชุดข้อมูลและงานเฉพาะ เพื่อให้เราสามารถรับการวัดเมตริกวัตถุประสงค์ที่เราใช้เพื่อปรับการเลือกไฮเปอร์พารามิเตอร์ให้เหมาะสมที่สุด อย่างไรก็ตาม สำหรับโพสต์โดยรวมนั้น ทั้งข้อมูลและงานก็ไม่มีความสำคัญ เพื่อนำเสนอภาพที่สมบูรณ์ ให้เราอธิบายสั้น ๆ เกี่ยวกับสิ่งที่เราทำ: เราฝึกโมเดล XGBoost ที่ควรจำแนกตัวเลขที่เขียนด้วยลายมือจาก
การจดจำด้วยแสงของชุดข้อมูลตัวเลขที่เขียนด้วยลายมือ [1] ผ่าน Scikit-learn XGBoost เป็นอัลกอริทึมที่ยอดเยี่ยมสำหรับข้อมูลที่มีโครงสร้างและสามารถนำไปใช้กับชุดข้อมูล Digits ได้ ค่าคือรูปภาพขนาด 8×8 ดังตัวอย่างที่แสดงต่อไปนี้
0 a
5 และ
4.

เลือก URI รูปภาพ XGBoost

หลังจากเลือกอัลกอริทึมในตัว (XGBoost) แล้ว เราต้องดึง URI ของรูปภาพและส่งต่อไปยัง SageMaker เพื่อโหลดไปยังอินสแตนซ์การฝึกอบรมของเรา สำหรับขั้นตอนนี้ เราจะตรวจสอบ รุ่นที่มี. เราได้ตัดสินใจใช้เวอร์ชัน 1.5.1 ซึ่งมีอัลกอริทึมเวอร์ชันล่าสุด ผู้ปฏิบัติงาน ML อาจเขียนสคริปต์การฝึกอบรมของตนเอง ซึ่งรวมถึงขั้นตอนการเตรียมข้อมูล เป็นต้น ทั้งนี้ขึ้นอยู่กับงาน แต่ไม่จำเป็นในกรณีของเรา

หากคุณต้องการเขียนสคริปต์การฝึกอบรมของคุณเอง คอยติดตาม เราจะอธิบายให้คุณทราบในโพสต์ถัดไปของเรา! เราจะแสดงวิธีเรียกใช้งาน SageMaker Training ด้วยสคริปต์การฝึกอบรมที่คุณกำหนดเอง

สำหรับตอนนี้ เราต้องการ URI รูปภาพที่ถูกต้องโดยการระบุอัลกอริทึม ภูมิภาค AWS และหมายเลขเวอร์ชัน:

xgboost_container = sagemaker.image_uris.retrieve('xgboost', region, '1.5-1')

แค่นั้นแหละ. ตอนนี้เรามีการอ้างอิงถึงอัลกอริทึม XGBoost

กำหนดไฮเปอร์พารามิเตอร์

ตอนนี้เรากำหนดไฮเปอร์พารามิเตอร์ของเรา ค่าเหล่านี้กำหนดวิธีที่แบบจำลองของเราจะได้รับการฝึกอบรม และในที่สุดก็มีอิทธิพลต่อวิธีที่แบบจำลองดำเนินการเทียบกับเมตริกวัตถุประสงค์ที่เรากำลังวัด เช่น ความแม่นยำในกรณีของเรา โปรดทราบว่าไม่มีสิ่งใดเกี่ยวกับบล็อกโค้ดต่อไปนี้เฉพาะสำหรับ SageMaker ที่จริงเรากำลังใช้ รุ่นโอเพ่นซอร์ส ของ XGBoost ซึ่งจัดทำโดยและปรับให้เหมาะสมสำหรับ SageMaker

แม้ว่าแต่ละไฮเปอร์พารามิเตอร์เหล่านี้จะกำหนดค่าและปรับเปลี่ยนได้ แต่เมตริกวัตถุประสงค์ multi:softmax ถูกกำหนดโดยชุดข้อมูลของเราและประเภทของปัญหาที่เรากำลังแก้ไข ในกรณีของเรา ชุดข้อมูล Digits มีหลายป้ายกำกับ (การสังเกตตัวเลขที่เขียนด้วยลายมืออาจเป็นได้ 0 or 1,2,3,4,5,6,7,8,9) หมายความว่าเป็นปัญหาการจำแนกประเภทหลายชั้น

hyperparameters = {
    'num_class': 10,
    'max_depth': 5,
    'eta':0.2,
    'alpha': 0.2,
    'objective':'multi:softmax',
    'eval_metric':'accuracy',
    'num_round':200,
    'early_stopping_rounds': 5
}

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับไฮเปอร์พารามิเตอร์อื่นๆ โปรดดูที่ XGBoost ไฮเปอร์พารามิเตอร์.

สร้างตัวประมาณค่า

เรากำหนดค่าการฝึกอบรมบนวัตถุประมาณ ซึ่งเป็นอินเทอร์เฟซระดับสูงสำหรับการฝึกอบรม SageMaker

ต่อไป เราจะกำหนดจำนวนของอินสแตนซ์ที่จะฝึก ประเภทอินสแตนซ์ (อิงตาม CPU หรือ GPU) และขนาดของที่เก็บข้อมูลที่แนบมา:

estimator = sagemaker.estimator.Estimator(
    image_uri=xgboost_container, 
    hyperparameters=hyperparameters,
    role=role,
    instance_count=1, 
    instance_type='ml.m5.large', 
    volume_size=5, # 5 GB 
    output_path=output_path
)

ขณะนี้เรามีการกำหนดค่าโครงสร้างพื้นฐานที่จำเป็นสำหรับการเริ่มต้นใช้งาน การฝึกอบรม SageMaker จะดูแลส่วนที่เหลือ

เรียกใช้ฟังก์ชัน fit()

จำข้อมูลที่เราอัปโหลดไปยัง Amazon S3 ก่อนหน้านี้ได้หรือไม่ ตอนนี้เราสร้างการอ้างอิงถึงมัน:

s3_input_train = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/train', content_type='csv')
s3_input_valid = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/valid', content_type='csv')

โทรไป fit() เปิดตัวการฝึกอบรมของเรา เราส่งการอ้างอิงไปยังข้อมูลการฝึกอบรมที่เราเพิ่งสร้างขึ้นเพื่อชี้ SageMaker Training ไปยังข้อมูลการฝึกอบรมและการตรวจสอบของเรา:

estimator.fit({'train': s3_input_train, 'validation': s3_input_valid})

โปรดทราบว่าหากต้องการเรียกใช้ HPO ในภายหลัง เราไม่จำเป็นต้องโทรหา fit() ที่นี่. เราแค่ต้องการวัตถุประมาณค่าในภายหลังสำหรับ HPO และสามารถข้ามไปที่การสร้างงาน HPO ของเราได้ แต่เนื่องจากเราต้องการเรียนรู้เกี่ยวกับ SageMaker Training และดูวิธีเรียกใช้งานการฝึกอบรมเดี่ยว เราจึงเรียกมันมาที่นี่และตรวจสอบผลลัพธ์

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

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

โปรดทราบว่าเมื่อสิ้นสุดงานเอาท์พุต ระยะเวลาการฝึกเป็นวินาทีและวินาทีที่เรียกเก็บเงินได้จะแสดงขึ้น

สุดท้าย เราเห็นว่า SageMaker อัปโหลดโมเดลการฝึกของเราไปยังพาธเอาต์พุต S3 ที่กำหนดไว้ในออบเจกต์ตัวประมาณค่า แบบจำลองพร้อมที่จะปรับใช้สำหรับการอนุมาน

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

ตรวจสอบงานฝึกอบรมในปัจจุบันและก่อนหน้านี้

จนถึงตอนนี้ เราได้ทำงานจากสมุดบันทึกของเราด้วยรหัสของเรา และส่งงานฝึกอบรมไปยัง SageMaker ลองเปลี่ยนมุมมองและทิ้งโน้ตบุ๊กไว้สักครู่เพื่อดูว่าสิ่งนี้มีลักษณะอย่างไรบนคอนโซล SageMaker

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

ภาพหน้าจอต่อไปนี้แสดงมุมมองคอนโซลของงานฝึกอบรมของเรา

เราสามารถตรวจสอบข้อมูลที่เราได้รับเป็นเอาต์พุตของเซลล์ไปยังเรา fit() ทำงานในการฝึกอบรมแต่ละงานภายในคอนโซล SageMaker พร้อมกับพารามิเตอร์และข้อมูลเมตาที่เรากำหนดไว้ในตัวประมาณค่าของเรา

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

นี่แสดงให้เราเห็นบันทึกอินสแตนซ์ภายใน CloudWatch

อย่าลืมไฮเปอร์พารามิเตอร์ที่เราระบุไว้ในสมุดบันทึกสำหรับงานฝึกอบรม เราเห็นพวกเขาที่นี่ใน UI เดียวกันของงานฝึกอบรมเช่นกัน

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

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

แม้ว่า SageMaker AMT จะจัดการงาน HPO แต่การทดลอง HPO ทั้งหมดจะเปิดตัวเป็นงาน SageMaker Training แต่ละงานและสามารถเข้าถึงได้ในลักษณะดังกล่าว

ครอบคลุมการฝึกอบรมแล้ว มาจูนกัน!

ฝึกฝนและปรับแต่งอัลกอริทึม XGBoost ในตัวของ SageMaker

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

from sagemaker.tuner import IntegerParameter, ContinuousParameter, HyperparameterTuner

hpt_ranges = {
    'alpha': ContinuousParameter(0.01, .5),
    'eta': ContinuousParameter(0.1, .5),
    'min_child_weight': ContinuousParameter(0., 2.),
    'max_depth': IntegerParameter(1, 10)
}

ช่วงสำหรับไฮเปอร์พารามิเตอร์แต่ละรายการจะระบุตามประเภท เช่น พารามิเตอร์ต่อเนื่อง. สำหรับข้อมูลเพิ่มเติมและเคล็ดลับในการเลือกช่วงพารามิเตอร์เหล่านี้ โปรดดูที่ ปรับแต่งโมเดล XGBoost.

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

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

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

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

หากคุณทำตามในโน้ตบุ๊กที่เชื่อมโยง โปรดทราบว่าเราผ่านตัวประมาณแบบเดียวกับที่เราใช้กับงานการฝึกอบรม XGBoost เดียวในตัวของเรา วัตถุประมาณค่านี้ทำหน้าที่เป็นแม่แบบสำหรับงานฝึกอบรมใหม่ที่ AMT สร้างขึ้น AMT จะเปลี่ยนไฮเปอร์พารามิเตอร์ภายในช่วงที่เรากำหนดไว้

โดยระบุว่าเราต้องการเพิ่มการวัดวัตถุประสงค์ของเราให้สูงสุด validation:accuracyเรากำลังบอกให้ SageMaker AMT ค้นหาเมตริกเหล่านี้ในบันทึกอินสแตนซ์การฝึก และเลือกค่าไฮเปอร์พารามิเตอร์ที่เชื่อว่าจะเพิ่มเมตริกความแม่นยำสูงสุดให้กับข้อมูลการตรวจสอบความถูกต้องของเรา เราเลือกที่เหมาะสม ตัวชี้วัดวัตถุประสงค์สำหรับ XGBoost จากเอกสารของเรา

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

เรายังกำหนด max_jobs เพื่อกำหนดจำนวนการทดลองใช้งานทั้งหมด อย่าลังเลที่จะเบี่ยงเบนจากตัวอย่างของเราและใช้ตัวเลขที่น้อยลงเพื่อประหยัดเงิน

n_jobs = 50
n_parallel_jobs = 3

tuner_parameters = {
    'estimator': estimator, # The same estimator object we defined above
    'base_tuning_job_name': 'bayesian',
    'objective_metric_name': 'validation:accuracy',
    'objective_type': 'Maximize',
    'hyperparameter_ranges': hpt_ranges,
    'strategy': 'Bayesian',
    'max_jobs': n_jobs,
    'max_parallel_jobs': n_parallel_jobs
}

เราโทรอีกครั้ง fit()เหมือนกับตอนที่เราเปิดตัวงานฝึกอบรมหนึ่งรายการก่อนหน้านี้ในโพสต์ แต่คราวนี้เป็นวัตถุจูนเนอร์ ไม่ใช่วัตถุประมาณค่า สิ่งนี้เป็นการเริ่มงานปรับแต่ง และในทางกลับกัน AMT ก็เริ่มงานฝึกอบรม

tuner = HyperparameterTuner(**tuner_parameters)
tuner.fit({'train': s3_input_train, 'validation': s3_input_valid}, wait=False)
tuner_name = tuner.describe()['HyperParameterTuningJobName']
print(f'tuning job submitted: {tuner_name}.')

แผนภาพต่อไปนี้ขยายขอบเขตของสถาปัตยกรรมก่อนหน้านี้โดยรวม HPO กับ SageMaker AMT

เราเห็นว่างาน HPO ของเราถูกส่งไปแล้ว ขึ้นอยู่กับจำนวนการทดลองที่กำหนดโดย n_jobs และระดับของการขนานกัน ซึ่งอาจใช้เวลาสักระยะหนึ่ง ตัวอย่างเช่น อาจใช้เวลาถึง 30 นาทีสำหรับการทดลอง 50 ครั้งโดยมีระดับการขนานกันเพียง 3 ระดับ

tuning job submitted: bayesian-221102-2053.

เมื่องานการปรับแต่งนี้เสร็จสิ้น เรามาสำรวจข้อมูลที่มีให้เราในคอนโซล SageMaker

ตรวจสอบงาน AMT บนคอนโซล

มาค้นหางานการปรับแต่งของเราบนคอนโซล SageMaker โดยเลือก การฝึกอบรม ในบานหน้าต่างนำทาง จากนั้น งานปรับแต่งไฮเปอร์พารามิเตอร์. ซึ่งแสดงรายการงาน AMT ของเราดังที่แสดงในภาพหน้าจอต่อไปนี้ ที่นี่เราค้นหาของเรา bayesian-221102-2053 งานจูนแล้วพบว่าตอนนี้เสร็จเรียบร้อยแล้ว

มาดูผลลัพธ์ของงาน HPO นี้กันดีกว่า

เราได้สำรวจการแยกผลลัพธ์โดยใช้โปรแกรมใน สมุดบันทึก. ครั้งแรกผ่านทาง SageMaker Python SDKซึ่งเป็นไลบรารี Python แบบโอเพ่นซอร์สระดับที่สูงกว่า โดยจัดเตรียม API เฉพาะสำหรับ SageMaker แล้วผ่านไป โบโต3ซึ่งให้ API ระดับล่างแก่เราแก่ SageMaker และบริการอื่นๆ ของ AWS

การใช้ SageMaker Python SDK เราสามารถรับผลลัพธ์ของงาน HPO ของเรา:

sagemaker.HyperparameterTuningJobAnalytics(tuner_name).dataframe()[:10]

สิ่งนี้ช่วยให้เราสามารถวิเคราะห์ผลลัพธ์ของการทดลองแต่ละครั้งของเราใน Pandas DataFrame ดังที่เห็นในภาพหน้าจอต่อไปนี้

ตอนนี้ลองเปลี่ยนมุมมองอีกครั้งและดูว่าผลลัพธ์บนคอนโซล SageMaker เป็นอย่างไร จากนั้นเราจะดูการแสดงภาพแบบกำหนดเองของเรา

ในหน้าเดียวกัน การเลือกของเรา bayesian-221102-2053 งานปรับแต่งให้รายชื่อการทดลองใช้งานสำหรับงานปรับแต่งของเรา การทดลอง HPO แต่ละครั้งที่นี่เป็นงานฝึกอบรม SageMaker นึกถึงก่อนหน้านี้เมื่อเราฝึกโมเดล XGBoost เดียวของเราและตรวจสอบงานการฝึกในคอนโซล SageMaker เราสามารถทำสิ่งเดียวกันกับการทดลองของเราได้ที่นี่

เมื่อเราตรวจสอบการทดลองของเรา เราเห็นสิ่งนั้น bayesian-221102-2053-048-b59ec7b4 สร้างแบบจำลองที่มีประสิทธิภาพดีที่สุดโดยมีความถูกต้องในการตรวจสอบประมาณ 89.815% มาดูกันว่าไฮเปอร์พารามิเตอร์ใดที่นำไปสู่ประสิทธิภาพนี้โดยเลือก งานฝึกอบรมที่ดีที่สุด แถบ

เราสามารถดูรายละเอียดของไฮเปอร์พารามิเตอร์ที่ดีที่สุดที่ได้รับการประเมิน

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

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

เห็นภาพการทดลองของเรา

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

from amtviz import visualize_tuning_job
visualize_tuning_job(tuner, trials_only=True)

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

หลังจากตรวจสอบความคืบหน้าโดยรวมเมื่อเวลาผ่านไป ตอนนี้ มาดูพื้นที่ไฮเปอร์พารามิเตอร์ของเรากัน

แผนภูมิต่อไปนี้แสดงความถูกต้องของการตรวจสอบความถูกต้องบนแกน y โดยจะแสดงแผนภูมิแต่ละรายการ max_depth, alpha, etaและ min_child_weight บนแกน x ตามลำดับ เราได้วางแผนงาน HPO ทั้งหมดไว้ในแต่ละแผนภูมิ แต่ละจุดเป็นการทดลองเดี่ยว และแต่ละแผนภูมิประกอบด้วยการทดลองทั้งหมด 50 รายการ แต่แยกสำหรับไฮเปอร์พารามิเตอร์แต่ละรายการ ซึ่งหมายความว่าการทดลองที่มีประสิทธิภาพดีที่สุดของเรา #48 จะแสดงด้วยจุดสีน้ำเงินหนึ่งจุดในแต่ละแผนภูมิเหล่านี้ (ซึ่งเราได้เน้นให้คุณเห็นในรูปต่อไปนี้) เราสามารถเปรียบเทียบประสิทธิภาพด้วยภาพภายในบริบทของการทดลองอื่นๆ ทั้งหมด 49 รายการ ดังนั้นมาดูกันอย่างใกล้ชิด

น่าหลงใหล! เราเห็นได้ทันทีว่าพื้นที่ใดของช่วงที่เรากำหนดไว้ในพื้นที่ไฮเปอร์พารามิเตอร์ของเรามีประสิทธิภาพมากที่สุด! คิดย้อนไปถึงเรื่องของเรา eta ค่า เป็นที่ชัดเจนว่าค่าการสุ่มตัวอย่างที่เข้าใกล้ 0 ให้ประสิทธิภาพที่แย่ลง ในขณะที่การขยับเข้าใกล้เส้นขอบของเรา 0.5 ให้ผลลัพธ์ที่ดีกว่า สิ่งที่ตรงกันข้ามดูเหมือนจะเป็นจริงสำหรับ alphaและ max_depth ดูเหมือนจะมีชุดของค่าที่ต้องการที่จำกัดมากขึ้น มองไปที่ max_depthคุณยังสามารถดูว่าการใช้กลยุทธ์ Bayesian สั่งให้ SageMaker AMT สุ่มตัวอย่างค่าที่เรียนรู้มาซึ่งทำงานได้ดีในอดีตให้บ่อยขึ้นได้อย่างไร

มองมาที่เรา eta ค่า เราอาจสงสัยว่ามันคุ้มค่าที่จะสำรวจเพิ่มเติมทางด้านขวาหรืออาจเกิน 0.45 หรือไม่ ความแม่นยำลดลงอย่างต่อเนื่อง หรือเราต้องการข้อมูลเพิ่มเติมที่นี่ ความสงสัยนี้เป็นส่วนหนึ่งของจุดประสงค์ในการเรียกใช้งาน HPO ครั้งแรกของเรา ให้ข้อมูลเชิงลึกแก่เราเกี่ยวกับพื้นที่ของพารามิเตอร์ไฮเปอร์พารามิเตอร์ที่เราควรสำรวจเพิ่มเติม

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

ทำความสะอาด

เพื่อหลีกเลี่ยงค่าใช้จ่ายที่ไม่ต้องการเมื่อคุณทำการทดลองกับ HPO เสร็จแล้ว คุณต้องลบไฟล์ทั้งหมดในบัคเก็ต S3 ของคุณที่มีคำนำหน้า amt-visualize-demo และนอกจากนี้ยังมี ปิดทรัพยากร Studio.

เรียกใช้รหัสต่อไปนี้ในสมุดบันทึกของคุณเพื่อลบไฟล์ S3 ทั้งหมดออกจากโพสต์นี้

!aws s3 rm s3://{BUCKET}/amt-visualize-demo --recursive

หากคุณต้องการเก็บชุดข้อมูลหรืออาร์ติแฟกต์แบบจำลองไว้ คุณอาจแก้ไขคำนำหน้าในโค้ดเป็น amt-visualize-demo/data เพื่อลบเฉพาะข้อมูลหรือ amt-visualize-demo/output เพื่อลบเฉพาะสิ่งประดิษฐ์แบบจำลอง

สรุป

ในโพสต์นี้ เราได้ฝึกฝนและปรับแต่งโมเดลโดยใช้อัลกอริทึม XGBoost เวอร์ชันในตัวของ SageMaker ด้วยการใช้ HPO กับ SageMaker AMT เราได้เรียนรู้เกี่ยวกับไฮเปอร์พารามิเตอร์ที่ทำงานได้ดีสำหรับอัลกอริทึมและชุดข้อมูลเฉพาะนี้

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

เมื่อใช้คอนโซล SageMaker เรายังเห็นวิธีลงลึกในการฝึกซ้อมแต่ละรายการและตรวจสอบบันทึกของพวกเขา

จากนั้นเราซูมออกเพื่อดูการทดลองทั้งหมดของเราร่วมกัน และทบทวนประสิทธิภาพที่เกี่ยวข้องกับการทดลองและไฮเปอร์พารามิเตอร์อื่นๆ

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

ในอนาคต เราจะพิจารณากลยุทธ์ HPO ต่างๆ ที่นำเสนอโดย SageMaker AMT และวิธีใช้รหัสการฝึกอบรมที่กำหนดเองของเรา แจ้งให้เราทราบในความคิดเห็นหากคุณมีคำถามหรือต้องการแนะนำพื้นที่ที่เราควรกล่าวถึงในโพสต์ที่จะเกิดขึ้น

ก่อนหน้านั้น เราขอให้คุณและนางแบบของคุณมีความสุขกับการเรียนรู้และการปรับแต่ง!

อ้างอิง

อ้างอิง:

[1] Dua, D. และ Graff, C. (2019). พื้นที่เก็บข้อมูลการเรียนรู้ของเครื่อง UCI [http://archive.ics.uci.edu/ml] Irvine, CA: มหาวิทยาลัยแคลิฟอร์เนีย คณะวิชาสารสนเทศและวิทยาการคอมพิวเตอร์

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

แอนดรูว์ เอลลูล เป็น Solutions Architect กับ Amazon Web Services เขาทำงานกับธุรกิจขนาดกลางและขนาดย่อมในเยอรมนี นอกเวลาทำงาน แอนดรูว์ชอบสำรวจธรรมชาติด้วยการเดินเท้าหรือปั่นจักรยาน

เอลิน่า เลสิค เป็น Solutions Architect ที่ตั้งอยู่ในเมืองมิวนิค เธอมุ่งเน้นไปที่ลูกค้าองค์กรจากอุตสาหกรรมบริการทางการเงิน ในเวลาว่าง Elina ชอบเรียนทฤษฎีกีตาร์ในภาษาสเปนเพื่อเรียนรู้แบบผสมผสานและออกไปวิ่ง

มาริอาโน แคมป์ เป็น Principal Solutions Architect กับ Amazon Web Services เขาทำงานร่วมกับลูกค้าบริการทางการเงินในเยอรมนีเกี่ยวกับแมชชีนเลิร์นนิง ในเวลาว่าง Mariano ชอบเดินป่ากับภรรยา