זהה תובנות מפתח ממסמכי טקסט באמצעות כוונון עדין ו-HPO עם Amazon SageMaker JumpStart

ארגונים על פני תעשיות כגון קמעונאות, בנקאות, פיננסים, שירותי בריאות, ייצור והלוואות נאלצים לעתים קרובות להתמודד עם כמויות עצומות של מסמכי טקסט לא מובנים המגיעים ממקורות שונים, כגון חדשות, בלוגים, ביקורות מוצרים, ערוצי תמיכת לקוחות ומדיה חברתית. מסמכים אלה מכילים מידע קריטי שהוא המפתח לקבלת החלטות עסקיות חשובות. ככל שארגון גדל, זה הופך לאתגר לחלץ מידע קריטי ממסמכים אלה. עם התקדמות טכניקות עיבוד שפה טבעית (NLP) ולמידת מכונה (ML), אנו יכולים לחשוף תובנות וקשרים חשובים ממסמכים טקסטואליים אלה במהירות ובדיוק גבוה, ובכך לעזור לחברות לקבל החלטות עסקיות איכותיות בזמן. שירותי NLP מנוהלים במלואם גם האיצו את האימוץ של NLP. אמזון להתבונן הוא שירות מנוהל במלואו המאפשר לך לבנות דגמי NLP מותאמים אישית הספציפיים לדרישות שלך, ללא צורך במומחיות כלשהי ב-ML.

בפוסט זה, אנו מדגימים כיצד להשתמש בטכניקות ML מתקדמות כדי לפתור חמש משימות NLP שונות: סיכום מסמכים, סיווג טקסט, מענה לשאלות, זיהוי ישות עם שם וחילוץ קשרים. עבור כל אחת ממשימות ה-NLP הללו, אנו מדגימים כיצד להשתמש אמזון SageMaker כדי לבצע את הפעולות הבאות:

• פרוס והפעל מסקנות על מודל מאומן מראש
• כוונן את המודל שהוכשר מראש על מערך נתונים מותאם אישית חדש
• שפר עוד יותר את ביצועי הכוונון העדין עם כוונון הדגם האוטומטי של SageMaker
• הערך את ביצועי המודל על נתוני הבדיקה המחזיקה מעמד עם מדדי הערכה שונים

למרות שאנו מכסים חמש משימות NLP ספציפיות בפוסט זה, אתה יכול להשתמש בפתרון זה כתבנית כדי להכליל כוונון עדין של מודלים מאומנים מראש עם מערך הנתונים שלך, ולאחר מכן להפעיל אופטימיזציה של היפרפרמטרים כדי לשפר את הדיוק.

תבניות פתרונות JumpStart

אמזון SageMaker JumpStart מספק פתרונות מקצה לקצה בלחיצה אחת עבור מקרי שימוש נפוצים רבים ב-ML. בדוק את מקרי השימוש הבאים לקבלת מידע נוסף על תבניות פתרונות זמינות:

תבניות הפתרון של JumpStart מכסות מגוון מקרי שימוש, תחת כל אחד מהם מוצעות מספר תבניות פתרונות שונות (פתרון הבנת המסמכים נמצא תחת מקרה השימוש "חלץ וניתוח נתונים ממסמכים").

בחר את תבנית הפתרון המתאימה ביותר למקרה השימוש שלך מדף הנחיתה של JumpStart. למידע נוסף על פתרונות ספציפיים תחת כל מקרה שימוש וכיצד להשיק פתרון JumpStart, ראה תבניות פתרונות.

סקירת פתרונות

התמונה הבאה מדגימה כיצד ניתן להשתמש בפתרון זה עם רכיבי SageMaker. משרות ההדרכה של SageMaker משמשות להכשרת מודל ה-NLP השונים, ונקודות הקצה של SageMaker משמשות לפריסת המודלים בכל שלב. אנו משתמשים שירות אחסון פשוט של אמזון (Amazon S3) לצד SageMaker כדי לאחסן את נתוני האימון וחפצי המודל, ו אמזון CloudWatch כדי לרשום תפוקות הדרכה ונקודות קצה.

פתח את פתרון הבנת המסמכים

נווט אל פתרון הבנת המסמכים ב-JumpStart.

כעת נוכל להסתכל מקרוב על כמה מהנכסים הכלולים בפתרון זה, החל ממחברת ההדגמה.

מחברת הדגמה

אתה יכול להשתמש במחברת ההדגמה כדי לשלוח נתונים לדוגמה לנקודות קצה של מודל שכבר נפרסו עבור משימות סיכום המסמך ותשובות לשאלות. מחברת ההדגמה מאפשרת לך לקבל חוויה מעשית במהירות על ידי שאילתת הנתונים לדוגמה.

לאחר שתפעיל את פתרון הבנת המסמכים, פתח את מחברת ההדגמה על ידי בחירה השתמש בנקודת קצה במחברת.

בואו נצלול עמוק יותר לתוך כל אחת מחמשת המחברות העיקריות לפתרון זה.

תנאים מוקדמים

In סטודיו SageMaker של אמזון, ודא שאתה משתמש ב- PyTorch 1.10 Python 3.8 CPU Optimized תמונה/קרנל כדי לפתוח את המחברות. אימון משתמש בחמישה מופעים של ml.g4dn.2xlarge, אז עליך להעלות א בקשה להגדלת הגבלת שירות אם החשבון שלך דורש הגבלות מוגברות עבור סוג זה.

סיווג טקסט

סיווג טקסט מתייחס לסיווג משפט קלט לאחת מתוויות הכיתה של מערך ההדרכה. מחברת זו מדגים כיצד להשתמש ב- ממשק API של JumpStart לסיווג טקסט.

פרוס והפעל מסקנות על המודל שהוכשר מראש

מודל סיווג הטקסט שבחרנו להשתמש בו בנוי על הטבעת טקסט (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) דגם מ TensorFlow Hub, שהוכשר מראש על מערכי הנתונים של ויקיפדיה ו-BookCorpus.

המודל הזמין לפריסה נוצר על ידי הצמדת שכבת סיווג בינארי לפלט של מודל הטבעת הטקסט, ולאחר מכן כוונון עדין של המודל כולו ב- SST-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 מערך נתונים. אתה יכול להחליף את מערך הנתונים הזה בכל מערך נתונים שאתה מעוניין בו.

אנו מאחזרים את מיכל הדוקר לאימון, מקור אלגוריתם האימון והמודל שהוכשר מראש:

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, וערכת הבדיקה משמשת כנתוני החזקה. להערכת ביצועי המודל. לאחר מכן, מערך הרכבת ומערך האימות מועלים לאמזון 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)

לאחר סיום עבודת הכוונון העדין, אנו פורסים את המודל, מפעילים הסקה על מערך הנתונים של בדיקת ה-hold-out ומחשבים מדדי הערכה. מכיוון שזו משימת סיווג בינארי, אנו משתמשים ב- ציון דיוק ו ציון F1 כמו מדדי ההערכה. ערך גדול יותר מציין את הביצועים הטובים יותר. צילום המסך הבא מציג את התוצאות שלנו.

שפר עוד יותר את ביצועי הכוונון העדין עם כוונון הדגמים האוטומטי של SageMaker

בשלב זה, אנו מדגימים כיצד ניתן לשפר עוד יותר את ביצועי הדגם על ידי כוונון עדין של הדגם עם כוונון דגם אוטומטי של SageMaker. כוונון מודלים אוטומטי, הידוע גם כאופטימיזציה של היפרפרמטרים (HPO), מוצא את הגרסה הטובה ביותר של מודל על ידי הפעלת מספר עבודות אימון במערך הנתונים שלך עם מגוון של פרמטרים היפר שאתה מציין. לאחר מכן הוא בוחר את ערכי ההיפרפרמטרים שמביאים למודל שמבצע את הביצועים הטובים ביותר, כפי שנמדד על ידי מדד שתבחר, במערך הנתונים של האימות.

ראשית, הגדרנו את המטרה בתור ציון הדיוק על נתוני האימות (val_accuracy) והגדירו מדדים עבור עבודת הכוונון על ידי ציון שם המדד האובייקטיבי וביטוי רגולרי (רגקס). הביטוי הרגולרי משמש כדי להתאים את פלט היומן של האלגוריתם וללכוד את הערכים המספריים של מדדים. לאחר מכן, אנו מציינים טווחי היפרפרמטרים לבחירת ערכי ההיפרפרמטר הטובים ביותר. אנחנו מגדירים את המספר הכולל של עבודות כוונון כשש ומחלקים את העבודות הללו לשלוש שונות ענן מחשוב אלסטי של אמזון (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 object in כפרמטר ל- Hyperparameter טונר בנאי וקורא ל 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 כתלות על גבי הקונטיינר.

לאחר מכן, נקודת כניסה לתסריט (טיעון entry_point.py) מצוין, המכיל את כל הקוד להורדה ולטעינה של En_core_web_md לדגמן ולבצע הסקה על הנתונים שנשלחים לנקודת הקצה. לבסוף, אנחנו עדיין צריכים לספק model_data כמודל שהוכשר מראש להסקת מסקנות. כי המאומנים מראש En_core_web_md המודל מוריד תוך כדי, אשר מצוין בסקריפט הכניסה, אנו מספקים קובץ ארכיון ריק. לאחר פריסת נקודת הקצה, תוכל להפעיל את נקודת הקצה ישירות מהמחברת באמצעות ה-SDK של SageMaker Python 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 במערך הנתונים שלך. שלב הכוונון העדין מעדכן את פרמטרי הדגם כדי ללכוד את המאפיין של הנתונים שלך ולשפר את הדיוק. אנו משתמשים ב- WikiANN (PAN-X) מערך נתונים כדי לכוונן את DistilBERT-base-uncased דגם שנאי מבית 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-large-uncased-all-word-masking-security-squad בנוי על דגם רובוטריק מבית Hugging Face. אנו משתמשים ב-AWS PyTorch DLC עם מצב סקריפט ומתקינים את רוֹבּוֹטרִיקִים הספרייה כתלות על גבי המיכל. בדומה למשימת NER, אנו מספקים קובץ ארכיון ריק בארגומנט model_data כי הדגם המאומן מראש מוריד תוך כדי תנועה. לאחר פריסת נקודת הקצה, תוכל להפעיל את נקודת הקצה ישירות מהמחברת באמצעות ה-SDK של SageMaker Python 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 במערך הנתונים שלך. שלב הכוונון העדין מעדכן את פרמטרי הדגם כדי ללכוד את המאפיין של הנתונים שלך ולשפר את הדיוק. אנו משתמשים ב- SQuAD2.0 מערך נתונים כדי לכוונן מודל הטמעת טקסט bert-base-uncased מתוך חיבוק פנים. המודל הזמין לכיוונון עדין מצמיד שכבת חילוץ תשובות למודל הטבעת הטקסט ומאתחל את פרמטרי השכבה לערכים אקראיים. שלב הכוונון העדין מכוון את כל פרמטרי המודל כדי למזער שגיאות חיזוי בנתוני הקלט ומחזיר את המודל המכוונן.

בדומה למשימת סיווג הטקסט, מערך הנתונים (SQuAD2.0) מפוצל לאימון, אימות ומערך בדיקות.

לאחר מכן, אנו מציינים את הפרמטרים ההיפר-פרמטרים של המודל, ונשתמש ב- ממשק API של JumpStart כדי להפעיל עבודת כוונון עדין:

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)

לאחר סיום עבודת הכוונון העדין, אנו פורסים את המודל, מפעילים הסקה על מערך הנתונים של בדיקת ה-hold-out ומחשבים מדדי הערכה. מדדי ההערכה המשמשים הם ציון התאמה מדויקת ממוצעת וציון F1 ממוצע. צילום המסך הבא מציג את התוצאות.

שפר עוד יותר את ביצועי הכוונון העדין עם כוונון הדגמים האוטומטי של SageMaker

בדומה לסעיפים הקודמים, אנו משתמשים ב-a 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-base-uncased מודל באמצעות שנאים מה מחבקים שנאי פנים סִפְרִיָה. המודל לכוונון עדין מצרף שכבת סיווג ליניארית שלוקחת זוג הטמעות אסימונים המופקות על ידי מודל הטבעת הטקסט ומאתחלת את פרמטרי השכבה לערכים אקראיים. שלב הכוונון העדין מכוון את כל פרמטרי המודל כדי למזער שגיאות חיזוי בנתוני הקלט ומחזיר את המודל המכוונן.

מערך הנתונים שאנו מכווננים את המודל הוא 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

בדומה לסעיפים הקודמים, אנו משתמשים ב-a 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 מ מחבקים שנאי פנים סִפְרִיָה. אנו גם בודקים את נקודות הקצה שנפרסו באמצעות מאמר טקסט ומעריכים תוצאות באמצעות מדד ההערכה המובנה של חיבוק פנים אדום.

בדומה למחברות המענה לשאלות ולמחברות NER, אנו משתמשים ב- PyTorchModel מה-SageMaker Python SDK יחד עם an 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.

Vivek Gangasani הוא ארכיטקט בכיר של פתרונות למידת מכונה בשירותי האינטרנט של אמזון. הוא עוזר לחברות סטארט-אפ לבנות ולהפעיל יישומי AI/ML. כרגע הוא מתמקד בשילוב הרקע שלו בקונטיינרים ולמידת מכונה כדי לספק פתרונות על MLOps, ML Inference ו-ML בקוד נמוך. בזמנו הפנוי, הוא נהנה לנסות מסעדות חדשות ולחקור טרנדים מתפתחים בבינה מלאכותית ולמידה עמוקה.

ג'רמי כהן הוא אדריכל פתרונות עם AWS, שם הוא עוזר ללקוחות לבנות פתרונות חדשניים מבוססי ענן. בזמנו הפנוי הוא נהנה מטיולים קצרים על החוף, לחקור את אזור המפרץ עם משפחתו, לתקן דברים מסביב לבית, לשבור דברים מסביב לבית ולברביקיו.

ניאלם קושיה הוא אדריכל לפתרונות ארגוניים ב- AWS. המוקד הנוכחי שלה הוא לעזור ללקוחות ארגוניים במסע אימוץ הענן שלהם לתוצאות עסקיות אסטרטגיות. בזמנה הפנוי היא נהנית לקרוא ולהיות בחוץ.