Tinh chỉnh và triển khai mô hình tóm tắt bằng cách sử dụng các bộ chứa Amazon SageMaker ôm mặt mang tập lệnh của riêng bạn

Đã có nhiều tiến bộ gần đây trong miền NLP. Các mô hình được đào tạo trước và các dịch vụ NLP được quản lý đầy đủ đã thúc đẩy quyền truy cập và áp dụng NLP một cách dân chủ. Amazon hiểu là một dịch vụ được quản lý hoàn toàn có thể thực hiện các tác vụ NLP như nhận dạng thực thể tùy chỉnh, lập mô hình chủ đề, phân tích tình cảm và hơn thế nữa để trích xuất thông tin chi tiết từ dữ liệu mà không cần bất kỳ kinh nghiệm ML nào trước đó.

Năm ngoái, AWS đã công bố một quan hệ đối tác với Ôm mặt để giúp đưa các mô hình xử lý ngôn ngữ tự nhiên (NLP) vào sản xuất nhanh hơn. Hugging Face là một cộng đồng AI mã nguồn mở, tập trung vào NLP. Thư viện dựa trên Python của họ (Máy biến áp) cung cấp các công cụ để dễ dàng sử dụng các kiến ​​trúc Transformer hiện đại phổ biến như BERT, RoBERTa và GPT. Bạn có thể áp dụng các mô hình này cho nhiều tác vụ NLP khác nhau, chẳng hạn như phân loại văn bản, trích xuất thông tin và trả lời câu hỏi, trong số loại khác.

Amazon SageMaker là một dịch vụ được quản lý hoàn toàn cung cấp cho các nhà phát triển và nhà khoa học dữ liệu khả năng xây dựng, đào tạo và triển khai các mô hình học máy (ML) một cách nhanh chóng. SageMaker loại bỏ những công việc nặng nhọc khỏi mỗi bước của quy trình ML, giúp việc phát triển các mô hình chất lượng cao trở nên dễ dàng hơn. SageMaker Python SDK cung cấp các API và vùng chứa mã nguồn mở để đào tạo và triển khai các mô hình trên SageMaker, sử dụng một số khuôn khổ ML và deep learning khác nhau.

Tích hợp Khuôn mặt ôm với SageMaker cho phép bạn xây dựng các mô hình Khuôn mặt ôm trên quy mô lớn trong các trường hợp sử dụng miền cụ thể của riêng bạn.

Trong bài đăng này, chúng tôi sẽ hướng dẫn bạn một ví dụ về cách xây dựng và triển khai trình tóm tắt văn bản Khuôn mặt ôm tùy chỉnh trên SageMaker. Chúng tôi sử dụng Pegasus [1] cho mục đích này, mô hình dựa trên Máy biến áp đầu tiên được đào tạo cụ thể trước trên một mục tiêu được thiết kế riêng cho việc tóm tắt văn bản trừu tượng. BERT được đào tạo trước về cách che các từ ngẫu nhiên trong một câu; ngược lại, trong quá trình đào tạo trước của Pegasus, các câu sẽ bị che khỏi tài liệu đầu vào. Sau đó, mô hình tạo ra các câu bị thiếu dưới dạng một chuỗi đầu ra duy nhất sử dụng tất cả các câu không được đánh dấu làm ngữ cảnh, kết quả là tạo ra một bản tóm tắt điều hành của tài liệu.

Nhờ tính linh hoạt của thư viện HuggingFace, bạn có thể dễ dàng điều chỉnh mã hiển thị trong bài đăng này cho các loại mô hình máy biến áp khác, chẳng hạn như t5, BART, v.v.

Tải tập dữ liệu của riêng bạn để tinh chỉnh mô hình Khuôn mặt ôm

Để tải tập dữ liệu tùy chỉnh từ tệp CSV, chúng tôi sử dụng load_dataset phương pháp từ gói Transformers. Chúng tôi có thể áp dụng mã hóa cho tập dữ liệu đã tải bằng cách sử dụng datasets.Dataset.map chức năng. Các map hàm lặp qua tập dữ liệu đã tải và áp dụng hàm mã hóa cho từng ví dụ. Sau đó, tập dữ liệu được mã hóa có thể được chuyển cho người huấn luyện để tinh chỉnh mô hình. Xem đoạn mã sau:

# Python
def tokenize(batch):
    tokenized_input = tokenizer(batch[args.input_column], padding='max_length', truncation=True, max_length=args.max_source)
    tokenized_target = tokenizer(batch[args.target_column], padding='max_length', truncation=True, max_length=args.max_target)
    tokenized_input['target'] = tokenized_target['input_ids']

    return tokenized_input
    

def load_and_tokenize_dataset(data_dir):
    for file in os.listdir(data_dir):
        dataset = load_dataset("csv", data_files=os.path.join(data_dir, file), split='train')
    tokenized_dataset = dataset.map(lambda batch: tokenize(batch), batched=True, batch_size=512)
    tokenized_dataset.set_format('numpy', columns=['input_ids', 'attention_mask', 'labels'])
    
    return tokenized_dataset

Xây dựng kịch bản đào tạo của bạn cho công cụ ước tính Hugging Face SageMaker

Như đã giải thích trong bài AWS và Khuôn mặt ôm hợp tác để đơn giản hóa và đẩy nhanh việc áp dụng các mô hình Xử lý ngôn ngữ tự nhiên, đào tạo người mẫu có khuôn mặt ôm trên SageMaker chưa bao giờ dễ dàng hơn thế. Chúng ta có thể làm như vậy bằng cách sử dụng công cụ ước tính Khuôn mặt ôm từ SDK SageMaker.

Đoạn mã sau tinh chỉnh Pegasus trên tập dữ liệu của chúng tôi. Bạn cũng có thể tìm thấy nhiều sổ tay mẫu hướng dẫn bạn cách tinh chỉnh các loại mô hình khác nhau, có sẵn trực tiếp trong kho lưu trữ GitHub của máy biến áp. Để kích hoạt đào tạo phân tán, chúng tôi có thể sử dụng Thư viện song song dữ liệu trong SageMaker, đã được tích hợp sẵn trong API huấn luyện viên HuggingFace. Để kích hoạt tính năng song song dữ liệu, chúng ta cần xác định distribution trong công cụ ước tính Khuôn mặt ôm của chúng tôi.

# Python
from sagemaker.huggingface import HuggingFace
# configuration for running training on smdistributed Data Parallel
distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}
huggingface_estimator = HuggingFace(entry_point='train.py',
                                    source_dir='code',
                                    base_job_name='huggingface-pegasus',
                                    instance_type= 'ml.g4dn.16xlarge',
                                    instance_count=1,
                                    transformers_version='4.6',
                                    pytorch_version='1.7',
                                    py_version='py36',
                                    output_path=output_path,
                                    role=role,
                                    hyperparameters = {
                                        'model_name': 'google/pegasus-xsum',
                                        'epoch': 10,
                                        'per_device_train_batch_size': 2
                                    },
                                    distribution=distribution)
huggingface_estimator.fit({'train': training_input_path, 'validation': validation_input_path, 'test': test_input_path})

Kích thước lô đào tạo tối đa mà bạn có thể định cấu hình phụ thuộc vào kích thước mô hình và bộ nhớ GPU của phiên bản được sử dụng. Nếu đào tạo phân phối SageMaker được bật, tổng kích thước lô là tổng của mọi lô được phân phối trên mỗi thiết bị / GPU. Nếu chúng tôi sử dụng một ml.g4dn.16xlarge với đào tạo phân tán thay vì một phiên bản ml.g4dn.xlarge, chúng tôi có bộ nhớ gấp tám lần (8 GPU) so với một phiên bản ml.g4dn.xlarge (1 GPU). Kích thước lô cho mỗi thiết bị vẫn giữ nguyên, nhưng tám thiết bị đang đào tạo song song.

Như thường lệ với SageMaker, chúng tôi tạo train.py script để sử dụng với Chế độ Script và vượt qua các siêu tham số để đào tạo. Đoạn mã sau cho Pegasus tải mô hình và đào tạo nó bằng cách sử dụng Transformers Trainer lớp học:

# Python
from transformers import (
    AutoModelForSeq2SeqLM,
    AutoTokenizer,
    Seq2SeqTrainer,
    Seq2seqTrainingArguments
)

model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to(device)
    
training_args = Seq2seqTrainingArguments(
    output_dir=args.model_dir,
    num_train_epochs=args.epoch,
    per_device_train_batch_size=args.train_batch_size,
    per_device_eval_batch_size=args.eval_batch_size,
    warmup_steps=args.warmup_steps,
    weight_decay=args.weight_decay,
    logging_dir=f"{args.output_data_dir}/logs",
    logging_strategy='epoch',
    evaluation_strategy='epoch',
    saving_strategy='epoch',
    adafactor=True,
    do_train=True,
    do_eval=True,
    do_predict=True,
    save_total_limit = 3,
    load_best_model_at_end=True,
    metric_for_best_model='eval_loss'
    # With the goal to deploy the best checkpoint to production
    # it is important to set load_best_model_at_end=True,
    # this makes sure that the last model is saved at the root
    # of the model_dir” directory
)
    
trainer = Seq2SeqTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset['train'],
    eval_dataset=dataset['validation']
)

trainer.train()
trainer.save_model()

# Get rid of unused checkpoints inside the container to limit the model.tar.gz size
os.system(f"rm -rf {args.model_dir}/checkpoint-*/")

Mã đầy đủ có sẵn trên GitHub.

Triển khai mô hình Khuôn mặt ôm đã được đào tạo cho SageMaker

Những người bạn của chúng tôi tại Hugging Face đã làm cho việc suy luận về SageMaker cho các mô hình Transformers đơn giản hơn bao giờ hết nhờ vào Bộ công cụ suy luận khuôn mặt ôm SageMaker. Bạn có thể triển khai trực tiếp mô hình đã được đào tạo trước đó bằng cách thiết lập biến môi trường "HF_TASK":"summarization" (để được hướng dẫn, xem Mô hình Pegasus), lựa chọn Triển khai, và sau đó chọn Amazon SageMaker, mà không cần viết kịch bản suy luận.

Tuy nhiên, nếu bạn cần một số cách cụ thể để tạo hoặc xử lý dự đoán, chẳng hạn như tạo một số đề xuất tóm tắt dựa trên danh sách các tham số tạo văn bản khác nhau, thì việc viết tập lệnh suy luận của riêng bạn có thể hữu ích và tương đối đơn giản:

# Python
# inference.py script

import os
import json
import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

def model_fn(model_dir):
    # Create the model and tokenizer and load weights
    # from the previous training Job, passed here through "model_dir"
    # that is reflected in HuggingFaceModel "model_data"
    tokenizer = AutoTokenizer.from_pretrained(model_dir)
    model = AutoModelForSeq2SeqLM.from_pretrained(model_dir).to(device).eval()
    
    model_dict = {'model':model, 'tokenizer':tokenizer}
    
    return model_dict
        

def predict_fn(input_data, model_dict):
    # Return predictions/generated summaries
    # using the loaded model and tokenizer on input_data
    text = input_data.pop('inputs')
    parameters_list = input_data.pop('parameters_list', None)
    
    tokenizer = model_dict['tokenizer']
    model = model_dict['model']

    # Parameters may or may not be passed    
    input_ids = tokenizer(text, truncation=True, padding='longest', return_tensors="pt").input_ids.to(device)
    
    if parameters_list:
        predictions = []
        for parameters in parameters_list:
            output = model.generate(input_ids, **parameters)
            predictions.append(tokenizer.batch_decode(output, skip_special_tokens=True))
    else:
        output = model.generate(input_ids)
        predictions = tokenizer.batch_decode(output, skip_special_tokens=True)
    
    return predictions
    
    
def input_fn(request_body, request_content_type):
    # Transform the input request to a dictionary
    request = json.loads(request_body)
    return request

Như được hiển thị trong mã trước, một tập lệnh suy luận như vậy cho HuggingFace trên SageMaker chỉ cần các chức năng mẫu sau:

• model_fn () - Đọc nội dung của những gì đã được lưu vào cuối công việc đào tạo bên trong SM_MODEL_DIRhoặc từ một thư mục trọng số mô hình hiện có được lưu dưới dạng tệp tar.gz trong Dịch vụ lưu trữ đơn giản của Amazon (Amazon S3). Nó được sử dụng để tải mô hình được đào tạo và trình mã hóa liên quan.
• input_fn () - Định dạng dữ liệu nhận được từ một yêu cầu được thực hiện đến điểm cuối.
• dự đoán_fn () - Gọi đầu ra của model_fn() (mô hình và trình mã hóa) để chạy suy luận trên đầu ra của input_fn() (dữ liệu được định dạng).

Theo tùy chọn, bạn có thể tạo output_fn() hàm để định dạng suy luận, sử dụng đầu ra của predict_fn(), mà chúng tôi đã không chứng minh trong bài đăng này.

Sau đó, chúng tôi có thể triển khai mô hình Khuôn mặt ôm đã được đào tạo với tập lệnh suy luận liên quan đến SageMaker bằng cách sử dụng Ôm Face SageMaker Model lớp học:

# Python
from sagemaker.huggingface import HuggingFaceModel

model = HuggingFaceModel(model_data=huggingface_estimator.model_data,
                     role=role,
                     framework_version='1.7',
                     py_version='py36',
                     entry_point='inference.py',
                     source_dir='code')
                     
predictor = model.deploy(initial_instance_count=1,
                         instance_type='ml.g4dn.xlarge'
                         )

Kiểm tra mô hình đã triển khai

Đối với bản demo này, chúng tôi đã đào tạo mô hình trên Tập dữ liệu đánh giá quần áo thương mại điện tử dành cho nữ, trong đó có các bài đánh giá về các bài báo về quần áo (mà chúng tôi coi là văn bản đầu vào) và các tiêu đề liên quan của chúng (mà chúng tôi coi là tóm tắt). Sau khi chúng tôi xóa các bài báo có tiêu đề bị thiếu, tập dữ liệu chứa 19,675 bài đánh giá. Việc tinh chỉnh mô hình Pegasus trên một tập huấn luyện chứa 70% các bài báo đó trong năm kỷ nguyên mất khoảng 3.5 giờ trên một ví dụ phóng to ml.p3.16.

Sau đó, chúng tôi có thể triển khai mô hình và kiểm tra nó với một số dữ liệu ví dụ từ bộ thử nghiệm. Sau đây là một ví dụ đánh giá mô tả một chiếc áo len:

# Python
Review Text
"I ordered this sweater in green in petite large. The color and knit is beautiful and the shoulders and body fit comfortably; however, the sleeves were very long for a petite. I roll them, and it looks okay but would have rather had a normal petite length sleeve."

Original Title
"Long sleeves"

Rating
3

Nhờ tập lệnh suy luận tùy chỉnh của chúng tôi được lưu trữ trong điểm cuối SageMaker, chúng tôi có thể tạo một số bản tóm tắt cho bài đánh giá này với các thông số tạo văn bản khác nhau. Ví dụ: chúng ta có thể yêu cầu điểm cuối tạo ra một loạt các tóm tắt từ rất ngắn đến dài vừa phải chỉ định các hình phạt có độ dài khác nhau (hình phạt có độ dài càng nhỏ, bản tóm tắt được tạo càng ngắn). Sau đây là một số ví dụ về đầu vào tham số và các tóm tắt tiếp theo do máy tạo:

# Python
inputs = {
    "inputs":[
"I ordered this sweater in green in petite large. The color and knit is   beautiful and the shoulders and body fit comfortably; however, the sleeves were very long for a petite. I roll them, and it looks okay but would have rather had a normal petite length sleeve."
    ],

    "parameters_list":[
        {
            "length_penalty":2
        },
	{
            "length_penalty":1
        },
	{
            "length_penalty":0.6
        },
        {
            "length_penalty":0.4
        }
    ]

result = predictor.predict(inputs)
print(result)

[
    ["Beautiful color and knit but sleeves are very long for a petite"],
    ["Beautiful sweater, but sleeves are too long for a petite"],
    ["Cute, but sleeves are long"],
    ["Very long sleeves"]
]

Bạn thích bản tóm tắt nào hơn? Tiêu đề được tạo đầu tiên nắm bắt tất cả các thông tin quan trọng về bài đánh giá, với một phần tư số từ. Ngược lại, cuối cùng chỉ sử dụng ba từ (ít hơn 1/10 độ dài của bài đánh giá gốc) để tập trung vào tính năng quan trọng nhất của áo len.

Kết luận

Bạn có thể tinh chỉnh trình tóm tắt văn bản trên tập dữ liệu tùy chỉnh của mình và triển khai nó vào sản xuất trên SageMaker với ví dụ đơn giản này có sẵn trên GitHub. Bổ sung sổ tay mẫu để đào tạo và triển khai các mô hình Khuôn mặt ôm trên SageMaker cũng có sẵn.

Như mọi khi, AWS hoan nghênh phản hồi. Xin vui lòng gửi bất kỳ ý kiến ​​hoặc câu hỏi.

dự án

[1] PEGASUS: Đào tạo trước với các câu Gap đã trích xuất để tóm tắt trừu tượng

Giới thiệu về tác giả

Viktor Malesevic là Kỹ sư Máy học với Dịch vụ Chuyên nghiệp của AWS, đam mê Xử lý ngôn ngữ tự nhiên và MLOps. Anh ấy làm việc với khách hàng để phát triển và đưa các mô hình học sâu đầy thách thức vào sản xuất trên AWS. Khi rảnh rỗi, anh ấy thích chia sẻ một ly rượu vang đỏ và một ít pho mát với bạn bè.

Aamna Najmi là Nhà khoa học dữ liệu với Dịch vụ Chuyên nghiệp của AWS. Cô ấy đam mê giúp khách hàng đổi mới bằng công nghệ Dữ liệu lớn và Trí tuệ nhân tạo để khai thác giá trị kinh doanh và hiểu biết sâu sắc từ dữ liệu. Khi rảnh rỗi, cô thích làm vườn và đi du lịch đến những nơi mới.