ระบุข้อมูลเชิงลึกที่สำคัญจากเอกสารข้อความผ่านการปรับแต่งอย่างละเอียดและ HPO ด้วย Amazon SageMaker JumpStart

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

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

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

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

เทมเพลตโซลูชัน JumpStart

Amazon SageMaker JumpStart ให้โซลูชันแบบ end-to-end แบบคลิกเดียวสำหรับกรณีการใช้งาน ML ทั่วไปจำนวนมาก สำรวจกรณีการใช้งานต่อไปนี้สำหรับข้อมูลเพิ่มเติมเกี่ยวกับเทมเพลตโซลูชันที่มี:

เทมเพลตโซลูชัน JumpStart ครอบคลุมกรณีการใช้งานที่หลากหลาย ภายใต้แต่ละเทมเพลตโซลูชันที่แตกต่างกันหลายรายการ (โซลูชันการทำความเข้าใจเอกสารนี้อยู่ภายใต้กรณีการใช้งาน "แยกและวิเคราะห์ข้อมูลจากเอกสาร")

เลือกเทมเพลตโซลูชันที่เหมาะกับกรณีการใช้งานของคุณมากที่สุดจากหน้า Landing Page ของ JumpStart สำหรับข้อมูลเพิ่มเติมเกี่ยวกับโซลูชันเฉพาะในแต่ละกรณีการใช้งาน และวิธีการเปิดใช้โซลูชัน JumpStart โปรดดู เทมเพลตโซลูชัน.

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

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

เปิดโซลูชันการทำความเข้าใจเอกสาร

นำทางไปยังโซลูชันการทำความเข้าใจเอกสารใน JumpStart

ตอนนี้เราสามารถดูเนื้อหาบางส่วนที่รวมอยู่ในโซลูชันนี้อย่างละเอียดยิ่งขึ้น โดยเริ่มจากโน้ตบุ๊กสาธิต

สมุดบันทึกสาธิต

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

หลังจากที่คุณเปิดใช้งานโซลูชันการทำความเข้าใจเอกสารแล้ว ให้เปิดสมุดบันทึกสาธิตโดยเลือก ใช้จุดสิ้นสุดในโน๊ตบุ๊ค.

เรามาเจาะลึกลงไปในโน้ตบุ๊กหลักทั้งห้าแต่ละรุ่นสำหรับโซลูชันนี้กัน

เบื้องต้น

In สตูดิโอ Amazon SageMakerตรวจสอบให้แน่ใจว่าคุณกำลังใช้ PyTorch 1.10 Python 3.8 CPU Optimized รูปภาพ/เคอร์เนลเพื่อเปิดสมุดบันทึก การฝึกอบรมใช้อินสแตนซ์ ml.g4dn.2xlarge ห้ารายการ ดังนั้นคุณควรเพิ่ม ขอเพิ่มวงเงินบริการ หากบัญชีของคุณต้องการขีดจำกัดที่เพิ่มขึ้นสำหรับประเภทนี้

การจัดประเภทข้อความ

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

ปรับใช้และรันการอนุมานบนโมเดลที่ผ่านการฝึกอบรมล่วงหน้า

โมเดลการจัดประเภทข้อความที่เราเลือกใช้สร้างขึ้นจากการฝังข้อความ (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) แบบอย่างจาก ฮับ ​​TensorFlowซึ่งได้รับการฝึกอบรมล่วงหน้าในชุดข้อมูล Wikipedia และ BookCorpus

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

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

model = Model(
    image_uri=deploy_image_uri,
    source_dir=deploy_source_uri,
    model_data=base_model_uri,
    entry_point="inference.py",
    role=aws_role,
    predictor_cls=Predictor,
    name=endpoint_name_tc,
)
# deploy the Model.
base_model_predictor = model.deploy(
    initial_instance_count=1,
    instance_type=inference_instance_type,
    endpoint_name=endpoint_name_tc,
)

text1 = "astonishing ... ( frames ) profound ethical and philosophical questions in the form of dazzling pop entertainment" 
text2 = "simply stupid , irrelevant and deeply , truly , bottomlessly cynical "

รหัสต่อไปนี้แสดงคำตอบของเรา:

Inference:
Input text: 'astonishing ... ( frames ) profound ethical and philosophical questions in the form of dazzling pop entertainment'
Model prediction: [0.000452966779, 0.999547064]
Labels: [0, 1]
Predicted Label: 1 # value 0 means negative sentiment and value 1 means positive sentiment

Inference:
Input text: 'simply stupid , irrelevant and deeply , truly , bottomlessly cynical '
Model prediction: [0.998723, 0.00127695734]
Labels: [0, 1]
Predicted Label: 0

ปรับแต่งโมเดลที่ได้รับการฝึกอบรมล่วงหน้าอย่างละเอียดในชุดข้อมูลที่กำหนดเอง

เราเพิ่งเดินผ่านการอนุมานโดยใช้โมเดล BERT ที่ผ่านการฝึกอบรมมาล่วงหน้า ซึ่งได้รับการปรับแต่งอย่างละเอียดบน SST-2 ชุดข้อมูล

ต่อไป เราจะหารือเกี่ยวกับวิธีปรับแต่งโมเดลในชุดข้อมูลที่กำหนดเองด้วยคลาสจำนวนเท่าใดก็ได้ ชุดข้อมูลที่เราใช้ในการปรับแต่งยังคงเป็น SST-2 ชุดข้อมูล คุณสามารถแทนที่ชุดข้อมูลนี้ด้วยชุดข้อมูลใดก็ได้ที่คุณสนใจ

เราดึงข้อมูลคอนเทนเนอร์ Docker การฝึกอบรม แหล่งที่มาของอัลกอริทึมการฝึกอบรม และโมเดลที่ได้รับการฝึกอบรมล่วงหน้า:

from sagemaker import image_uris, model_uris, script_uris, hyperparameters

model_id, model_version = model_id, "*" # all the other options of model_id are the same as the one in Section 2.
training_instance_type = config.TRAINING_INSTANCE_TYPE

# Retrieve the docker image
train_image_uri = image_uris.retrieve(
    region=None,
    framework=None,
    model_id=model_id,
    model_version=model_version,
    image_scope="training",
    instance_type=training_instance_type,
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
    model_id=model_id, model_version=model_version, script_scope="training"
)
# Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve(
    model_id=model_id, model_version=model_version, model_scope="training"
)

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

from sagemaker import hyperparameters

# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)

# [Optional] Override default hyperparameters with custom values
hyperparameters["batch-size"] = "64"
hyperparameters["adam-learning-rate"] = "1e-6"

ชุดข้อมูล (SST-2) แบ่งออกเป็นชุดการฝึก การตรวจสอบความถูกต้อง และชุดการทดสอบ โดยชุดการฝึกจะใช้เพื่อให้เหมาะกับโมเดล ชุดการตรวจสอบความถูกต้องจะใช้ในการคำนวณเมตริกการประเมินที่สามารถใช้สำหรับ HPO และชุดการทดสอบจะใช้เป็นข้อมูลการระงับ สำหรับประเมินประสิทธิภาพของโมเดล ถัดไป ชุดข้อมูลการฝึกและการตรวจสอบจะถูกอัปโหลดไปยัง Amazon S3 และใช้เพื่อเริ่มงานการฝึกปรับแต่ง:

# Create SageMaker Estimator instance
tc_estimator = Estimator(
    role=role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    base_job_name=training_job_name,
)

training_data_path_updated = f"s3://{config.S3_BUCKET}/{prefix}/train"
# Launch a SageMaker Training job by passing s3 path of the training data
tc_estimator.fit({"training": training_data_path_updated}, logs=True)

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

ปรับปรุงประสิทธิภาพการปรับแต่งเพิ่มเติมด้วยการปรับโมเดลอัตโนมัติของ SageMaker

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

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

# Define objective metric per framework, based on which the best model will be selected.
metric_definitions_per_model = {
    "tensorflow": {
        "metrics": [{"Name": "val_accuracy", "Regex": "val_accuracy: ([0-9.]+)"}],
        "type": "Maximize",
    }
}

# You can select from the hyperparameters supported by the model, and configure ranges of values to be searched for training the optimal model.(https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-ranges.html)
hyperparameter_ranges = {
    "adam-learning-rate": ContinuousParameter(0.00001, 0.01, scaling_type="Logarithmic")
}

# Increase the total number of training jobs run by AMT, for increased accuracy (and training time).
max_jobs = 6
# Change parallel training jobs run by AMT to reduce total training time, constrained by your account limits.
# if max_jobs=max_parallel_jobs then Bayesian search turns to Random.
max_parallel_jobs = 3

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

hp_tuner = HyperparameterTuner(
    tc_estimator,
    metric_definitions["metrics"][0]["Name"],
    hyperparameter_ranges,
    metric_definitions["metrics"],
    max_jobs=max_jobs,
    max_parallel_jobs=max_parallel_jobs,
    objective_type=metric_definitions["type"],
    base_tuning_job_name=tuning_job_name,
)

# Launch a SageMaker Tuning job to search for the best hyperparameters
hp_tuner.fit({"training": training_data_path_updated})

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

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

การรับรู้ชื่อนิติบุคคล

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

ปรับใช้และรันการอนุมานบนโมเดลที่ผ่านการฝึกอบรมล่วงหน้า

เราปรับใช้ En_core_web_md รุ่นจาก สปาซี ห้องสมุด. spaCy เป็นไลบรารี NLP แบบโอเพ่นซอร์สที่สามารถใช้กับงานต่างๆ และมีเมธอดในตัวสำหรับ NER เราใช้ AWS PyTorch Deep Learning Container (DLC) กับโหมดสคริปต์ และติดตั้งไลบรารี spaCy เป็นการอ้างอิงที่ด้านบนของคอนเทนเนอร์

ถัดไป จุดเริ่มต้นสำหรับสคริปต์ (argument entry_point.py) ถูกระบุ ซึ่งมีโค้ดทั้งหมดสำหรับดาวน์โหลดและโหลดไฟล์ En_core_web_md จำลองและทำการอนุมานข้อมูลที่ส่งไปยังปลายทาง สุดท้ายก็ยังต้องเผื่อไว้ model_data เป็นแบบฝึกล่วงหน้าสำหรับการอนุมาน เพราะได้รับการฝึกฝนมาก่อน En_core_web_md ดาวน์โหลดแบบจำลองได้ทันทีซึ่งระบุไว้ในสคริปต์รายการ เราจัดเตรียมไฟล์เก็บถาวรที่ว่างเปล่า หลังจากปรับใช้ตำแหน่งข้อมูลแล้ว คุณสามารถเรียกใช้งานตำแหน่งข้อมูลได้โดยตรงจากโน้ตบุ๊กโดยใช้ SageMaker Python SDK Predictor. ดูรหัสต่อไปนี้:

model = PyTorchModel(
    model_data=f"{config.SOURCE_S3_PATH}/artifacts/models/empty.tar.gz",
    entry_point="entry_point.py",
    source_dir="../containers/entity_recognition",
    role=config.IAM_ROLE,
    framework_version="1.5.0",
    py_version="py3",
    code_location="s3://" + config.S3_BUCKET + "/code",
    env={
        "MMS_DEFAULT_RESPONSE_TIMEOUT": "3000"
    }
)
predictor = model.deploy(
    endpoint_name=endpoint_name,
    instance_type=config.HOSTING_INSTANCE_TYPE,
    initial_instance_count=1,
    serializer=JSONSerializer(),
    deserializer=JSONDeserializer()
)

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

data = {'text': 'Amazon SageMaker is a fully managed service that provides every developer and data scientist with the ability to build, train, and deploy machine learning (ML) models quickly.'}
response = predictor.predict(data=data)

print(response['entities'])
print(response['noun_chunks'])

[{'text': 'Amazon SageMaker', 'start_char': 0, 'end_char': 16, 'label': 'ORG'}]
[{'text': 'Amazon SageMaker', 'start_char': 0, 'end_char': 16}, {'text': 'a fully managed service', 'start_char': 20, 'end_char': 43}, {'text': 'that', 'start_char': 44, 'end_char': 48}, {'text': 'every developer and data scientist', 'start_char': 58, 'end_char': 92}, {'text': 'the ability', 'start_char': 98, 'end_char': 109}, {'text': 'ML', 'start_char': 156, 'end_char': 158}]

ปรับแต่งโมเดลที่ได้รับการฝึกอบรมล่วงหน้าอย่างละเอียดในชุดข้อมูลที่กำหนดเอง

ในขั้นตอนนี้ เราจะสาธิตวิธีปรับแต่งโมเดลภาษาที่ฝึกไว้ล่วงหน้าอย่างละเอียดสำหรับ NER ในชุดข้อมูลของคุณเอง ขั้นตอนการปรับแต่งอย่างละเอียดจะอัปเดตพารามิเตอร์โมเดลเพื่อจับคุณลักษณะของข้อมูลของคุณเองและปรับปรุงความแม่นยำ เราใช้ วิกิแอน ชุดข้อมูล (PAN-X) เพื่อปรับแต่ง DitilBERT-ฐาน-ไม่มีกล่อง โมเดล Transformer จาก Hugging Face

ชุดข้อมูลแบ่งออกเป็นการฝึกอบรม การตรวจสอบ และชุดการทดสอบ

ต่อไป เราระบุไฮเปอร์พารามิเตอร์ของโมเดล และใช้ AWS Hugging Face DLC กับโหมดสคริปต์ (อาร์กิวเมนต์ entry_point) เพื่อทริกเกอร์งานปรับแต่ง:

hyperparameters = {
    "pretrained-model": "distilbert-base-uncased",
    "learning-rate": 2e-6,
    "num-train-epochs": 2,
    "batch-size": 16,
    "weight-decay": 1e-5,
    "early-stopping-patience": 2,
}

ner_estimator = HuggingFace(
    pytorch_version='1.10.2',
    py_version='py38',
    transformers_version="4.17.0",
    entry_point='training.py',
    source_dir='../containers/entity_recognition/finetuning',
    hyperparameters=hyperparameters,
    role=aws_role,
    instance_count=1,
    instance_type=training_instance_type,
    output_path=f"s3://{bucket}/{prefix}/output",
    code_location=f"s3://{bucket}/{prefix}/output",
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    sagemaker_session=sess,
    volume_size=30,
    env={
        'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'
    },
    base_job_name = training_job_name
)

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

สุดท้าย เราใช้เมตริกการประเมินในตัว Hugging Face ผลสืบเนื่อง เพื่อคำนวณคะแนนการประเมินจากข้อมูลการทดสอบการระงับ เมตริกการประเมินที่ใช้ ได้แก่ ความแม่นยำโดยรวม การเรียกคืนโดยรวม F1 โดยรวม และความแม่นยำ ภาพหน้าจอต่อไปนี้แสดงผลของเรา

ปรับปรุงประสิทธิภาพการปรับแต่งเพิ่มเติมด้วยการปรับโมเดลอัตโนมัติของ SageMaker

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

hyperparameters_range = {
    "learning-rate": ContinuousParameter(1e-5, 0.1, scaling_type="Logarithmic"),
    "weight-decay": ContinuousParameter(1e-6, 1e-2, scaling_type="Logarithmic"),
}

tuner = HyperparameterTuner(
    estimator,
    "f1",
    hyperparameters_range,
    [{"Name": "f1", "Regex": "'eval_f1': ([0-9.]+)"}],
    max_jobs=6,
    max_parallel_jobs=3,
    objective_type="Maximize",
    base_tuning_job_name=tuning_job_name,
)

tuner.fit({
    "train": f"s3://{bucket}/{prefix}/train/",
    "validation": f"s3://{bucket}/{prefix}/validation/",
}, logs=True)

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

เราจะเห็นว่าโมเดลที่มี HPO นั้นมีประสิทธิภาพที่ดีขึ้นอย่างมากในทุกเมตริก

ตอบคำถาม

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

ปรับใช้และรันการอนุมานบนโมเดลที่ผ่านการฝึกอบรมล่วงหน้า

โมเดลที่ฝึกไว้ล่วงหน้าของเราคือโมเดลการตอบคำถามแบบดึงข้อมูล (EQA) bert-ใหญ่-ไม่ได้ใส่-ทั้งคำ-กำบัง-finetuned-ทีม สร้างจากโมเดล Transformer จาก Hugging Face เราใช้ AWS PyTorch DLC กับโหมดสคริปต์และติดตั้ง หม้อแปลง ไลบรารีเป็นการพึ่งพาที่ด้านบนของคอนเทนเนอร์ เช่นเดียวกับงาน NER เรามีไฟล์เก็บถาวรเปล่าในอาร์กิวเมนต์ model_data เนื่องจากโมเดลที่ฝึกไว้ล่วงหน้าจะถูกดาวน์โหลดได้ทันที หลังจากปรับใช้ตำแหน่งข้อมูลแล้ว คุณสามารถเรียกใช้งานตำแหน่งข้อมูลได้โดยตรงจากโน้ตบุ๊กโดยใช้ SageMaker Python SDK Predictor. ดูรหัสต่อไปนี้:

model = PyTorchModel(
    model_data=f"{config.SOURCE_S3_PATH}/artifacts/models/empty.tar.gz",
    entry_point="entry_point.py",
    source_dir="../containers/question_answering",
    role=config.IAM_ROLE,
    framework_version="1.5.0",
    py_version="py3",
    code_location="s3://" + config.S3_BUCKET + "/code",
    env={
        "MODEL_ASSETS_S3_BUCKET": config.SOURCE_S3_BUCKET,
        "MODEL_ASSETS_S3_PREFIX": f"{config.SOURCE_S3_PREFIX}/artifacts/models/question_answering/",
        "MMS_DEFAULT_RESPONSE_TIMEOUT": "3000",
    },
)

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

data = {'question': 'what is my name?', 'context': "my name is thom"}
response = predictor.predict(data=data)

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

print(response['answers'])
[{'score': 0.9793591499328613, 'start': 11, 'end': 15, 'answer': 'thom'}, 
{'score': 0.02019440196454525, 'start': 0, 'end': 15, 'answer': 'my name is thom'}, 
{'score': 4.349117443780415e-05, 'start': 3, 'end': 15, 'answer': 'name is thom'}]

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

ปรับแต่งโมเดลที่ได้รับการฝึกอบรมล่วงหน้าอย่างละเอียดในชุดข้อมูลที่กำหนดเอง

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

คล้ายกับงานการจัดประเภทข้อความ ชุดข้อมูล (SQuAD2.0) จะถูกแยกออกเป็นการฝึก การตรวจสอบ และชุดการทดสอบ

ต่อไป เราระบุไฮเปอร์พารามิเตอร์ของโมเดล และใช้ JumpStart API เพื่อทริกเกอร์งานปรับแต่ง:

hyperparameters = {'epochs': '3', 'adam-learning-rate': '2e-05', 'batch-size': '16'}

eqa_estimator = Estimator(
    role=role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    base_job_name=training_job_name,
    debugger_hook_config=False,
)

training_data_path_updated = f"s3://{config.S3_BUCKET}/{prefix}/train"
# Launch a SageMaker Training job by passing s3 path of the training data
eqa_estimator.fit({"training": training_data_path_updated}, logs=True)

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

ปรับปรุงประสิทธิภาพการปรับแต่งเพิ่มเติมด้วยการปรับโมเดลอัตโนมัติของ SageMaker

คล้ายกับส่วนก่อนหน้านี้ เราใช้ HyperparameterTuner คัดค้านการเริ่มงานการปรับแต่ง:

hyperparameter_ranges = {
    "adam-learning-rate": ContinuousParameter(0.00001, 0.01, scaling_type="Logarithmic"),
    "epochs": IntegerParameter(3, 10),
    "train-only-top-layer": CategoricalParameter(["True", "False"]),
}

hp_tuner = HyperparameterTuner(
    eqa_estimator,
    metric_definitions["metrics"][0]["Name"],
    hyperparameter_ranges,
    metric_definitions["metrics"],
    max_jobs=max_jobs,
    max_parallel_jobs=max_parallel_jobs,
    objective_type=metric_definitions["type"],
    base_tuning_job_name=training_job_name,
)

# Launch a SageMaker Tuning job to search for the best hyperparameters
hp_tuner.fit({"training": training_data_path_updated})

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

เราจะเห็นว่าโมเดลที่มี HPO แสดงประสิทธิภาพที่ดีขึ้นอย่างมากในข้อมูลการทดสอบการระงับ

การสกัดความสัมพันธ์

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

ปรับแต่งโมเดลที่ได้รับการฝึกอบรมล่วงหน้าอย่างละเอียดในชุดข้อมูลที่กำหนดเอง

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

ชุดข้อมูลที่เราปรับแต่งโมเดลอย่างละเอียดคือ SemEval-2010 งาน 8. แบบจำลองที่ส่งคืนโดยการปรับแต่งอย่างละเอียดสามารถนำไปใช้เพื่อการอนุมานเพิ่มเติมได้

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

เราใช้ AWS PyTorch DLC กับโหมดสคริปต์จาก SageMaker Python SDK โดยที่ transformers ไลบรารีถูกติดตั้งเป็นการพึ่งพาที่ด้านบนของคอนเทนเนอร์ เรานิยาม SageMaker PyTorch ตัวประมาณค่าและชุดของไฮเปอร์พารามิเตอร์ เช่น แบบจำลองที่ผ่านการฝึกอบรมล่วงหน้า อัตราการเรียนรู้ และหมายเลขยุคเพื่อทำการปรับแต่งอย่างละเอียด รหัสสำหรับการปรับแต่งแบบจำลองการแยกความสัมพันธ์อย่างละเอียดถูกกำหนดไว้ใน entry_point.py. ดูรหัสต่อไปนี้:

hyperparameters = {
    "pretrained-model": "bert-base-uncased",
    "learning-rate": 0.0002,
    "max-epoch": 2,
    "weight-decay": 0,
    "batch-size": 16,
    "accumulate-grad-batches": 2,
    "gradient-clip-val": 1.0
}

re_estimator = PyTorch(
    framework_version='1.5.0',
    py_version='py3',
    entry_point='entry_point.py',
    source_dir='../containers/relationship_extraction',
    hyperparameters=hyperparameters,
    role=aws_role,
    instance_count=1,
    instance_type=train_instance_type,
    output_path=f"s3://{bucket}/{prefix}/output",
    code_location=f"s3://{bucket}/{prefix}/output",
    base_job_name=training_job_name,
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    sagemaker_session=sess,
    volume_size=30,
    env={
        'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'
    },
    debugger_hook_config=False
)

re_estimator.fit(
    {
        "train": f"s3://{bucket}/{prefix}/train/",
        "validation": f"s3://{bucket}/{prefix}/validation/",
    }
)

ปรับปรุงประสิทธิภาพการปรับแต่งเพิ่มเติมด้วยการปรับโมเดลอัตโนมัติของ SageMaker

คล้ายกับส่วนก่อนหน้านี้ เราใช้ HyperparameterTuner คัดค้านการโต้ตอบกับ API การปรับไฮเปอร์พารามิเตอร์ของ SageMaker เราสามารถเริ่มงานปรับแต่งไฮเปอร์พารามิเตอร์ได้โดยการเรียก fit วิธี:

hyperparameters = {
    "max-epoch": 2,
    "weight-decay": 0,
    "batch-size": 16,
    "accumulate-grad-batches": 2,
    "gradient-clip-val": 1.0
}

estimator = PyTorch(
    framework_version='1.5.0',
    py_version='py3',
    entry_point='entry_point.py',
    source_dir='../containers/relationship_extraction',
    hyperparameters=hyperparameters,
    role=aws_role,
    instance_count=1,
    instance_type=train_instance_type,
    output_path=f"s3://{bucket}/{prefix}/output",
    code_location=f"s3://{bucket}/{prefix}/output",
    base_job_name=tuning_job_name,
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    sagemaker_session=sess,
    volume_size=30,
    env={
        'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'
    },
    debugger_hook_config=False
    
    re_tuner = HyperparameterTuner(
    estimator,
    metric_definitions["metrics"][0]["Name"],
    hyperparameter_ranges,
    metric_definitions["metrics"],
    max_jobs=max_jobs,
    max_parallel_jobs=max_parallel_jobs,
    objective_type=metric_definitions["type"],
    base_tuning_job_name=tuning_job_name,
)

re_tuner.fit({
    "train": f"s3://{bucket}/{prefix}/train/",
    "validation": f"s3://{bucket}/{prefix}/validation/",
})

เมื่องานปรับแต่งไฮเปอร์พารามิเตอร์เสร็จสิ้น เราจะทำการอนุมานและตรวจสอบคะแนนการประเมิน

เราจะเห็นว่าโมเดลที่มี HPO แสดงประสิทธิภาพที่ดีกว่าในข้อมูลการทดสอบการระงับ

การสรุปเอกสาร

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

สมุดบันทึกนี้สาธิตการปรับใช้แบบจำลองการสรุปเอกสาร T5-ฐาน จาก Hugging Face ทรานส์ฟอร์มเมอร์ส ห้องสมุด. นอกจากนี้ เรายังทดสอบจุดสิ้นสุดที่ใช้งานโดยใช้บทความข้อความ และประเมินผลโดยใช้เมตริกการประเมินในตัว Hugging Face สีแดง.

คล้ายกับการตอบคำถามและสมุดบันทึก NER เราใช้ PyTorchModel จาก SageMaker Python SDK พร้อมกับไฟล์ entry_point.py สคริปต์เพื่อโหลดโมเดลฐาน T5 ไปยังปลายทาง HTTPS หลังจากปรับใช้จุดสิ้นสุดสำเร็จแล้ว เราสามารถส่งบทความข้อความไปยังจุดสิ้นสุดเพื่อรับคำตอบจากการคาดการณ์:

ARTICLE = """ Documents are a primary tool for communication,
collaboration, record keeping, and transactions across industries,
including financial, medical, legal, and real estate. The format of data
can pose an extra challenge in data extraction, especially if the content
is typed, handwritten, or embedded in a form or table. Furthermore,
extracting data from your documents is manual, error-prone, time-consuming,
expensive, and does not scale. Amazon Textract is a machine learning (ML)
service that extracts printed text and other data from documents as well as
tables and forms. We’re pleased to announce two new features for Amazon
Textract: support for handwriting in English documents, and expanding
language support for extracting printed text from documents typed in
Spanish, Portuguese, French, German, and Italian. Many documents, such as
medical intake forms or employment applications, contain both handwritten
and printed text. The ability to extract text and handwriting has been a
need our customers have asked us for. Amazon Textract can now extract
printed text and handwriting from documents written in English with high
confidence scores, whether it’s free-form text or text embedded in tables
and forms. Documents can also contain a mix of typed text or handwritten
text. The following image shows an example input document containing a mix
of typed and handwritten text, and its converted output document.."""

data = {'text': ARTICLE}
response = predictor.predict(data=data)
print(response['summary'])

"""Amazon Textract is a machine learning (ML) service that extracts printed text 
and other data from documents as well as tables and forms . 
customers can now extract and process documents in more languages .
support for handwriting in english documents and expanding language support for extracting 
printed text ."""

ต่อไป เราจะประเมินและเปรียบเทียบบทความที่เป็นข้อความและผลการสรุปโดยใช้เมตริก ROUGE มีการคำนวณเมตริกการประเมินสามรายการ: rougeN, rougeLและ rougeLsum. rougeN วัดจำนวนการจับคู่ n-grams ระหว่างข้อความที่โมเดลสร้างขึ้น (ผลการสรุป) และ reference (ใส่ข้อความ). เมตริก rougeL และ rougeLsum วัดลำดับการจับคู่ที่ยาวที่สุดของคำโดยมองหาสตริงย่อยทั่วไปที่ยาวที่สุดในสรุปที่สร้างขึ้นและอ้างอิง สำหรับเมตริกแต่ละรายการ จะมีการคำนวณช่วงความเชื่อมั่นสำหรับความแม่นยำ การเรียกคืน และคะแนน F1 ดูรหัสต่อไปนี้:

results = rouge.compute(predictions=[response['summary']], references=[ARTICLE])

rouge1: AggregateScore(low=Score(precision=1.0, recall=0.1070615034168565, fmeasure=0.1934156378600823), 
mid=Score(precision=1.0, recall=0.1070615034168565, fmeasure=0.1934156378600823), high=Score(precision=1.0, recall=0.1070615034168565, fmeasure=0.1934156378600823))

rouge2: AggregateScore(low=Score(precision=0.9565217391304348, recall=0.1004566210045662, fmeasure=0.18181818181818182), 
mid=Score(precision=0.9565217391304348, recall=0.1004566210045662, fmeasure=0.18181818181818182), high=Score(precision=0.9565217391304348, recall=0.1004566210045662, 
fmeasure=0.18181818181818182))

rougeL: AggregateScore(low=Score(precision=0.8085106382978723, recall=0.08656036446469248, fmeasure=0.15637860082304528), 
mid=Score(precision=0.8085106382978723, recall=0.08656036446469248, fmeasure=0.15637860082304528), high=Score(precision=0.8085106382978723, recall=0.08656036446469248, 
fmeasure=0.15637860082304528))

rougeLsum: AggregateScore(low=Score(precision=0.9787234042553191, recall=0.10478359908883828, fmeasure=0.18930041152263374), 
mid=Score(precision=0.9787234042553191, recall=0.10478359908883828, fmeasure=0.18930041152263374), high=Score(precision=0.9787234042553191, recall=0.10478359908883828, 
fmeasure=0.18930041152263374))

ทำความสะอาด

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

สรุป

ในโพสต์นี้ เราสาธิตวิธีการใช้เทคนิค ML ที่ล้ำสมัยเพื่อแก้ปัญหา NLP ห้างานที่แตกต่างกัน: การสรุปเอกสาร การจัดประเภทข้อความ คำถามและการตอบ การจดจำเอนทิตีที่มีชื่อ และการดึงความสัมพันธ์โดยใช้ Jumpstart เริ่มต้นใช้งาน Jumpstart ทันที!

เกี่ยวกับผู้เขียน

ดร.ซิน หวาง เป็นนักวิทยาศาสตร์ประยุกต์สำหรับอัลกอริทึมในตัวของ Amazon SageMaker JumpStart และ Amazon SageMaker เขามุ่งเน้นไปที่การพัฒนาอัลกอริธึมการเรียนรู้ของเครื่องที่ปรับขนาดได้ ความสนใจในงานวิจัยของเขาอยู่ในพื้นที่ของการประมวลผลภาษาธรรมชาติ การเรียนรู้เชิงลึกที่อธิบายได้บนข้อมูลแบบตาราง และการวิเคราะห์ที่มีประสิทธิภาพของการจัดกลุ่มพื้นที่และเวลาที่ไม่อิงพารามิเตอร์ เขาได้ตีพิมพ์บทความจำนวนมากในการประชุม ACL, ICDM, KDD และวารสาร Royal Statistical Society: Series A

วิเวกกังสนิ เป็นสถาปนิกอาวุโสด้านโซลูชันการเรียนรู้ของเครื่องที่ Amazon Web Services เขาช่วยสตาร์ทอัพสร้างและใช้งานแอปพลิเคชัน AI/ML ปัจจุบันเขามุ่งเน้นไปที่การรวมพื้นฐานของเขาในคอนเทนเนอร์และแมชชีนเลิร์นนิงเพื่อส่งมอบโซลูชันเกี่ยวกับ MLOps, ML Inference และ ML แบบโค้ดต่ำ ในเวลาว่าง เขาชอบลองร้านอาหารใหม่ๆ และสำรวจเทรนด์ใหม่ๆ ของ AI และการเรียนรู้เชิงลึก

เจเรมี โคเฮน เป็นสถาปนิกโซลูชันกับ AWS ซึ่งเขาช่วยลูกค้าสร้างโซลูชันบนระบบคลาวด์ที่ล้ำสมัย ในเวลาว่าง เขาชอบเดินเล่นบนชายหาด สำรวจบริเวณอ่าวกับครอบครัว ซ่อมของรอบๆ บ้าน ทำลายข้าวของในบ้าน และปิ้งบาร์บีคิว

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