เพิ่มความคล่องตัวในการประมวลผลข้อมูล ETL ที่ Talent.com ด้วย Amazon SageMaker | อเมซอนเว็บเซอร์วิส

โพสต์นี้เขียนร่วมกันโดย Anatoly Khomenko วิศวกรการเรียนรู้ของเครื่อง และ Abdenour Bezzouh ประธานเจ้าหน้าที่ฝ่ายเทคโนโลยีของ Talent.com

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

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

เพื่อให้มั่นใจว่าการทำงานที่มีประสิทธิภาพของเครื่องมือแนะนำงานนี้ จำเป็นอย่างยิ่งที่จะต้องใช้ไปป์ไลน์การประมวลผลข้อมูลขนาดใหญ่ที่รับผิดชอบในการแยกและปรับปรุงคุณลักษณะต่างๆ จากรายการงานที่รวบรวมไว้ของ Talent.com ไปป์ไลน์นี้สามารถประมวลผลบันทึกรายวัน 5 ล้านรายการในเวลาน้อยกว่า 1 ชั่วโมง และช่วยให้สามารถประมวลผลบันทึกหลายวันพร้อมกันได้ นอกจากนี้ โซลูชันนี้ยังช่วยให้สามารถปรับใช้กับการผลิตได้อย่างรวดเร็ว แหล่งข้อมูลหลักสำหรับไปป์ไลน์นี้คือรูปแบบ JSON Lines ซึ่งจัดเก็บไว้ใน บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) และแบ่งพาร์ติชันตามวันที่ ในแต่ละวัน ส่งผลให้มีการสร้างไฟล์ JSON Lines หลายหมื่นไฟล์ โดยมีการอัปเดตเพิ่มขึ้นทุกวัน

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

สำหรับข้อมูลเชิงลึกเพิ่มเติมเกี่ยวกับวิธีที่ Talent.com และ AWS ร่วมมือกันสร้างการประมวลผลภาษาธรรมชาติที่ล้ำสมัยและเทคนิคการฝึกอบรมโมเดลการเรียนรู้เชิงลึก โดยใช้ อเมซอน SageMaker เพื่อสร้างระบบแนะนำงาน โปรดดูที่ จากข้อความสู่งานในฝัน: การสร้างผู้แนะนำงานที่ใช้ NLP ที่ Talent.com ด้วย Amazon SageMaker. ระบบประกอบด้วยวิศวกรรมฟีเจอร์ การออกแบบสถาปัตยกรรมโมเดลการเรียนรู้เชิงลึก การเพิ่มประสิทธิภาพไฮเปอร์พารามิเตอร์ และการประเมินโมเดล โดยที่โมดูลทั้งหมดทำงานโดยใช้ Python

โพสต์นี้แสดงวิธีที่เราใช้ SageMaker เพื่อสร้างไปป์ไลน์การประมวลผลข้อมูลขนาดใหญ่เพื่อเตรียมคุณสมบัติสำหรับกลไกการแนะนำงานที่ Talent.com ผลลัพธ์ที่ได้ช่วยให้ Data Scientist สามารถคิดค้นการแยกคุณสมบัติในสมุดบันทึก SageMaker โดยใช้ไลบรารี Python เช่น Scikit-เรียนรู้ or ไพทอร์ชจากนั้นจึงปรับใช้โค้ดเดียวกันอย่างรวดเร็วในไปป์ไลน์การประมวลผลข้อมูลโดยทำการแยกคุณสมบัติตามขนาด โซลูชันไม่จำเป็นต้องย้ายโค้ดการแยกคุณลักษณะเพื่อใช้ PySpark ตามที่จำเป็นเมื่อใช้งาน AWS กาว เป็นโซลูชัน ETL โซลูชันของเราสามารถพัฒนาและปรับใช้ได้โดย Data Scientist แบบ end-to-end โดยใช้ SageMaker เท่านั้น และไม่จำเป็นต้องมีความรู้เกี่ยวกับโซลูชัน ETL อื่นๆ เช่น ชุด AWS. ซึ่งช่วยลดระยะเวลาที่จำเป็นในการปรับใช้ไปป์ไลน์ Machine Learning (ML) ในการผลิตได้อย่างมาก ไปป์ไลน์ดำเนินการผ่าน Python และผสานรวมกับเวิร์กโฟลว์การแยกคุณสมบัติได้อย่างราบรื่น ทำให้สามารถปรับให้เข้ากับแอปพลิเคชันการวิเคราะห์ข้อมูลที่หลากหลายได้

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

ไปป์ไลน์ประกอบด้วยสามขั้นตอนหลัก:

1. ใช้อ การประมวลผล Amazon SageMaker งานเพื่อจัดการไฟล์ JSONL ดิบที่เกี่ยวข้องกับวันที่ระบุ ข้อมูลหลายวันสามารถประมวลผลได้โดยแยกงานการประมวลผลพร้อมกัน
2. จ้าง AWS กาว สำหรับการรวบรวมข้อมูลหลังจากประมวลผลข้อมูลหลายวัน
3. โหลดคุณสมบัติที่ประมวลผลสำหรับช่วงวันที่ที่ระบุโดยใช้ SQL จาก อเมซอน อาเธน่า ตาราง จากนั้นฝึกอบรมและปรับใช้โมเดลผู้แนะนำงาน

ประมวลผลไฟล์ JSONL แบบดิบ

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

ต่อไปนี้คือโค้ดตัวอย่างเพื่อกำหนดเวลางานการประมวลผล SageMaker สำหรับวันที่ระบุ เช่น 2020-01-01 โดยใช้ SageMaker SDK งานอ่านไฟล์ JSONL แบบ Raw จาก Amazon S3 (เช่น จาก s3://bucket/raw-data/2020/01/01) และบันทึกไฟล์ Parquet ที่บีบอัดลงใน Amazon S3 (เช่น to s3://bucket/processed/table-name/day_partition=2020-01-01/).

### install dependencies %pip install sagemaker pyarrow s3fs awswrangler import sagemaker
import boto3 from sagemaker.processing import FrameworkProcessor
from sagemaker.sklearn.estimator import SKLearn
from sagemaker import get_execution_role
from sagemaker.processing import ProcessingInput, ProcessingOutput region = boto3.session.Session().region_name
role = get_execution_role()
bucket = sagemaker.Session().default_bucket() ### we use instance with 16 CPUs and 128 GiB memory
### note that the script will NOT load the entire data into memory during compaction
### depending on the size of individual jsonl files, larger instance may be needed
instance = "ml.r5.4xlarge"
n_jobs = 8 ### we use 8 process workers
date = "2020-01-01" ### process data for one day est_cls = SKLearn
framework_version_str = "0.20.0" ### schedule processing job
script_processor = FrameworkProcessor( role=role, instance_count=1, instance_type=instance, estimator_cls=est_cls, framework_version=framework_version_str, volume_size_in_gb=500,
) script_processor.run( code="processing_script.py", ### name of the main processing script source_dir="../src/etl/", ### location of source code directory ### our processing script loads raw jsonl files directly from S3 ### this avoids long start-up times of the processing jobs, ### since raw data does not need to be copied into instance inputs=[], ### processing job input is empty outputs=[ ProcessingOutput(destination="s3://bucket/processed/table-name/", source="/opt/ml/processing/output"), ], arguments=[ ### directory with job's output "--output", "/opt/ml/processing/output", ### temporary directory inside instance "--tmp_output", "/opt/ml/tmp_output", "--n_jobs", str(n_jobs), ### number of process workers "--date", date, ### date to process ### location with raw jsonl files in S3 "--path", "s3://bucket/raw-data/", ], wait=False
)

โครงร่างโค้ดต่อไปนี้สำหรับสคริปต์หลัก (processing_script.py) ที่รันงาน SageMaker Processing เป็นดังนี้:

import concurrent
import pyarrow.dataset as ds
import os
import s3fs
from pathlib import Path ### function to process raw jsonl file and save extracted features into parquet file from process_data import process_jsonl ### parse command line arguments
args = parse_args() ### we use s3fs to crawl S3 input path for raw jsonl files
fs = s3fs.S3FileSystem()
### we assume raw jsonl files are stored in S3 directories partitioned by date
### for example: s3://bucket/raw-data/2020/01/01/
jsons = fs.find(os.path.join(args.path, *args.date.split('-'))) ### temporary directory location inside the Processing job instance
tmp_out = os.path.join(args.tmp_output, f"day_partition={args.date}") ### directory location with job's output
out_dir = os.path.join(args.output, f"day_partition={args.date}") ### process individual jsonl files in parallel using n_jobs process workers
futures=[]
with concurrent.futures.ProcessPoolExecutor(max_workers=args.n_jobs) as executor: for file in jsons: inp_file = Path(file) out_file = os.path.join(tmp_out, inp_file.stem + ".snappy.parquet") ### process_jsonl function reads raw jsonl file from S3 location (inp_file) ### and saves result into parquet file (out_file) inside temporary directory futures.append(executor.submit(process_jsonl, file, out_file)) ### wait until all jsonl files are processed for future in concurrent.futures.as_completed(futures): result = future.result() ### compact parquet files
dataset = ds.dataset(tmp_out) if len(dataset.schema) > 0: ### save compacted parquet files with 1MM records per file ds.write_dataset(dataset, out_dir, format="parquet", max_rows_per_file=1024 * 1024)

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

รวบรวมข้อมูลข้อมูลที่ประมวลผลโดยใช้ AWS Glue

หลังจากประมวลผลข้อมูลดิบทั้งหมดเป็นเวลาหลายวันแล้ว เราสามารถสร้างตาราง Athena จากชุดข้อมูลทั้งหมดได้โดยใช้โปรแกรมรวบรวมข้อมูล AWS Glue เราใช้ AWS SDK สำหรับหมีแพนด้า (awswrangler) ไลบรารีเพื่อสร้างตารางโดยใช้ตัวอย่างต่อไปนี้:

import awswrangler as wr ### crawl processed data in S3
res = wr.s3.store_parquet_metadata( path='s3://bucket/processed/table-name/', database="database_name", table="table_name", dataset=True, mode="overwrite", sampling=1.0, path_suffix='.parquet',
) ### print table schema
print(res[0])

โหลดฟีเจอร์ที่ประมวลผลแล้วสำหรับการฝึก

ขณะนี้สามารถโหลดคุณสมบัติที่ประมวลผลแล้วสำหรับช่วงวันที่ที่ระบุได้จากตาราง Athena โดยใช้ SQL และคุณสมบัติเหล่านี้สามารถนำไปใช้ในการฝึกโมเดลผู้แนะนำงานได้ ตัวอย่างเช่น ตัวอย่างต่อไปนี้จะโหลดคุณลักษณะที่ประมวลผลแล้วหนึ่งเดือนลงใน DataFrame โดยใช้ awswrangler ห้องสมุด:

import awswrangler as wr query = """ SELECT * FROM table_name WHERE day_partition BETWEN '2020-01-01' AND '2020-02-01' """ ### load 1 month of data from database_name.table_name into a DataFrame
df = wr.athena.read_sql_query(query, database='database_name')

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

ประโยชน์ของโซลูชั่น

การใช้โซลูชันที่นำเสนอนำมาซึ่งข้อดีหลายประการต่อขั้นตอนการทำงานที่มีอยู่ของเรา ซึ่งรวมถึง:

• การใช้งานแบบง่าย – โซลูชันนี้ช่วยให้สามารถใช้งานการแยกคุณสมบัติใน Python โดยใช้ไลบรารี ML ยอดนิยม และไม่จำเป็นต้องย้ายรหัสไปยัง PySpark สิ่งนี้จะเพิ่มความคล่องตัวในการแยกคุณสมบัติ เนื่องจากโค้ดเดียวกันกับที่พัฒนาโดย Data Scientist ในโน้ตบุ๊กจะถูกดำเนินการโดยไปป์ไลน์นี้
• เส้นทางสู่การผลิตที่รวดเร็ว – นักวิทยาศาสตร์ข้อมูลสามารถพัฒนาและปรับใช้โซลูชันดังกล่าวได้ เพื่อดำเนินการแยกฟีเจอร์ในวงกว้าง ช่วยให้พวกเขาสามารถพัฒนาโมเดลผู้แนะนำ ML กับข้อมูลนี้ได้ ในเวลาเดียวกัน วิศวกร ML สามารถปรับใช้โซลูชันเดียวกันนี้กับการผลิตได้โดยไม่จำเป็นต้องแก้ไขเพียงเล็กน้อย
• ความสามารถในเรอุส – โซลูชันนี้มอบรูปแบบที่นำมาใช้ซ้ำได้สำหรับการดึงคุณลักษณะในวงกว้าง และสามารถปรับใช้กับกรณีการใช้งานอื่น ๆ นอกเหนือจากโมเดลผู้แนะนำการสร้างได้อย่างง่ายดาย
• อย่างมีประสิทธิภาพ – โซลูชั่นนำเสนอประสิทธิภาพที่ดี: ประมวลผลวันเดียวของ ทาเล้นท์.คอมข้อมูลของใช้เวลาน้อยกว่า 1 ชั่วโมง
• การปรับปรุงที่เพิ่มขึ้น – โซลูชันนี้ยังรองรับการอัพเดตเพิ่มเติมอีกด้วย ข้อมูลรายวันใหม่สามารถประมวลผลได้ด้วยงานการประมวลผลของ SageMaker และตำแหน่ง S3 ที่มีข้อมูลที่ประมวลผลแล้วสามารถรวบรวมข้อมูลซ้ำได้เพื่ออัปเดตตาราง Athena นอกจากนี้เรายังสามารถใช้งาน cron เพื่ออัปเดตข้อมูลของวันนี้ได้หลายครั้งต่อวัน (เช่น ทุก 3 ชั่วโมง)

เราใช้ไปป์ไลน์ ETL นี้เพื่อช่วยให้ Talent.com ประมวลผลไฟล์ 50,000 ไฟล์ต่อวันที่มีบันทึก 5 ล้านรายการ และสร้างข้อมูลการฝึกอบรมโดยใช้ฟีเจอร์ที่แยกมาจากข้อมูลดิบ 90 วันจาก Talent.com รวมเป็น 450 ล้านบันทึกจากไฟล์ 900,000 ไฟล์ ไปป์ไลน์ของเราช่วยให้ Talent.com สร้างและปรับใช้ระบบการแนะนำในการผลิตภายในเวลาเพียง 2 สัปดาห์ โซลูชันนี้ดำเนินการกระบวนการ ML ทั้งหมด รวมถึง ETL บน Amazon SageMaker โดยไม่ต้องใช้บริการ AWS อื่น ๆ ระบบแนะนำงานเพิ่มอัตราการคลิกผ่าน 8.6% ในการทดสอบ A/B ออนไลน์ เทียบกับโซลูชันที่ใช้ XGBoost รุ่นก่อน ซึ่งช่วยเชื่อมโยงผู้ใช้หลายล้านคนของ Talent.com เข้ากับงานที่ดีขึ้น

สรุป

โพสต์นี้สรุปไปป์ไลน์ ETL ที่เราพัฒนาขึ้นสำหรับการประมวลผลฟีเจอร์สำหรับการฝึกอบรมและการปรับใช้โมเดลผู้แนะนำงานที่ Talent.com ไปป์ไลน์ของเราใช้งาน SageMaker Processing เพื่อการประมวลผลข้อมูลที่มีประสิทธิภาพและการดึงฟีเจอร์ในวงกว้าง โค้ดการแยกคุณสมบัติถูกนำมาใช้ใน Python ทำให้สามารถใช้ไลบรารี ML ยอดนิยมเพื่อทำการแยกคุณสมบัติในวงกว้าง โดยไม่จำเป็นต้องย้ายโค้ดเพื่อใช้ PySpark

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

---

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

ดมิทรี เบสปาลอฟ เป็นนักวิทยาศาสตร์ประยุกต์อาวุโสที่ Amazon Machine Learning Solutions Lab ซึ่งเขาช่วยลูกค้า AWS ในอุตสาหกรรมต่างๆ เร่งการนำ AI และระบบคลาวด์ไปใช้

ยี่เซียง เป็นนักวิทยาศาสตร์ประยุกต์ II ที่ Amazon Machine Learning Solutions Lab ซึ่งเธอช่วยลูกค้า AWS ในอุตสาหกรรมต่างๆ เร่งการนำ AI และการนำระบบคลาวด์ไปใช้

ตงหวาง เป็นนักวิทยาศาสตร์ประยุกต์อาวุโสที่ Amazon Machine Learning Solutions Lab ซึ่งเขาช่วยลูกค้า AWS ในอุตสาหกรรมต่างๆ เร่งการนำ AI และระบบคลาวด์ไปใช้

อนาโตลี โคเมนโก เป็นวิศวกร Machine Learning อาวุโสที่ ทาเล้นท์.คอม ด้วยความหลงใหลในการประมวลผลภาษาธรรมชาติที่จับคู่คนดีเข้ากับงานที่ดี

อับเดนัวร์ เบซูห์ เป็นผู้บริหารที่มีประสบการณ์มากกว่า 25 ปีในการสร้างและนำเสนอโซลูชั่นเทคโนโลยีที่ขยายขนาดให้กับลูกค้าหลายล้านคน Abdenour ดำรงตำแหน่งประธานเจ้าหน้าที่ฝ่ายเทคโนโลยี (CTO) ที่ ทาเล้นท์.คอม เมื่อทีม AWS ออกแบบและดำเนินการโซลูชันนี้โดยเฉพาะ ทาเล้นท์.คอม.

หยานจุนฉี เป็นผู้จัดการอาวุโสด้านวิทยาศาสตร์ประยุกต์ที่ Amazon Machine Learning Solution Lab เธอคิดค้นและใช้แมชชีนเลิร์นนิงเพื่อช่วยให้ลูกค้า AWS เร่งการนำ AI และระบบคลาวด์ไปใช้

• เนื้อหาที่ขับเคลื่อนด้วย SEO และการเผยแพร่ประชาสัมพันธ์ รับการขยายวันนี้
• PlatoData.Network Vertical Generative Ai เพิ่มพลังให้กับตัวเอง เข้าถึงได้ที่นี่.
• เพลโตไอสตรีม. Web3 อัจฉริยะ ขยายความรู้ เข้าถึงได้ที่นี่.
• เพลโตESG. คาร์บอน, คลีนเทค, พลังงาน, สิ่งแวดล้อม แสงอาทิตย์, การจัดการของเสีย. เข้าถึงได้ที่นี่.
• เพลโตสุขภาพ เทคโนโลยีชีวภาพและข่าวกรองการทดลองทางคลินิก เข้าถึงได้ที่นี่.
• ที่มา: https://aws.amazon.com/blogs/machine-learning/streamlining-etl-data-processing-at-talent-com-with-amazon-sagemaker/