Точная настройка и развертывание модели сумматора с использованием контейнеров Hugging Face Amazon SageMaker с собственным сценарием.

В последнее время в области НЛП было сделано много достижений. Предварительно обученные модели и полностью управляемые сервисы НЛП демократизировали доступ и внедрение НЛП. Amazon Comprehend — это полностью управляемая служба, которая может выполнять задачи NLP, такие как распознавание пользовательских сущностей, моделирование тем, анализ настроений и многое другое, для извлечения информации из данных без необходимости какого-либо предварительного опыта ML.

В прошлом году AWS объявила о партнерство Обнимая лицо чтобы ускорить внедрение моделей обработки естественного языка (NLP) в производство. Hugging Face — это сообщество искусственного интеллекта с открытым исходным кодом, ориентированное на НЛП. Их библиотека на основе Python (Трансформаторы) предоставляет инструменты для простого использования популярных современных архитектур Transformer, таких как BERT, RoBERTa и GPT. Вы можете применять эти модели к различным задачам НЛП, таким как классификация текста, извлечение информации и ответы на вопросы, среди другие исследователи.

Создатель мудреца Амазонки — это полностью управляемая служба, которая предоставляет разработчикам и специалистам по данным возможность быстро создавать, обучать и развертывать модели машинного обучения (ML). SageMaker избавляет от тяжелой работы на каждом этапе процесса машинного обучения, упрощая разработку высококачественных моделей. SageMaker Python SDK предоставляет API и контейнеры с открытым исходным кодом для обучения и развертывания моделей в SageMaker с использованием нескольких различных платформ машинного обучения и глубокого обучения.

Интеграция Hugging Face с SageMaker позволяет создавать модели Hugging Face в масштабе для ваших собственных сценариев использования в конкретной предметной области.

В этом посте мы познакомим вас с примером того, как создать и развернуть пользовательское средство суммирования текста Hugging Face в SageMaker. Для этой цели мы используем Pegasus [1], первую модель на основе Transformer, специально предварительно обученную на цели, предназначенной для абстрактного суммирования текста. BERT предварительно обучен маскированию случайных слов в предложении; напротив, во время предварительного обучения Pegasus предложения маскируются из входного документа. Затем модель генерирует отсутствующие предложения как единую выходную последовательность, используя все немаскированные предложения в качестве контекста, создавая в результате резюме документа.

Благодаря гибкости библиотеки HuggingFace вы можете легко адаптировать код, показанный в этом посте, для других типов моделей трансформеров, таких как t5, BART и других.

Загрузите свой собственный набор данных для точной настройки модели Hugging Face.

Чтобы загрузить пользовательский набор данных из файла CSV, мы используем load_dataset метод из пакета Transformers. Мы можем применить токенизацию к загруженному набору данных, используя datasets.Dataset.map функция. map функция перебирает загруженный набор данных и применяет функцию tokenize к каждому примеру. Затем токенизированный набор данных можно передать тренеру для точной настройки модели. См. следующий код:

# 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

Создайте сценарий обучения для оценщика Hugging Face SageMaker.

Как поясняется в посте AWS и Hugging Face сотрудничают, чтобы упростить и ускорить внедрение моделей обработки естественного языка., обучение модели Hugging Face в SageMaker еще никогда не было таким простым. Мы можем сделать это, используя оценщик Hugging Face из SageMaker SDK.

Следующий фрагмент кода точно настраивает Pegasus в нашем наборе данных. Вы также можете найти множество образцы записных книжек которые проведут вас через тонкую настройку различных типов моделей, доступных непосредственно в репозитории трансформеров GitHub. Чтобы включить распределенное обучение, мы можем использовать Библиотека параллелизма данных в SageMaker, встроенном в API HuggingFace Trainer. Чтобы включить параллелизм данных, нам нужно определить distribution параметр в нашем оценщике Hugging Face.

# 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})

Максимальный размер обучающего пакета, который вы можете настроить, зависит от размера модели и памяти графического процессора используемого экземпляра. Если включено распределенное обучение SageMaker, общий размер пакета представляет собой сумму всех пакетов, распределенных по каждому устройству/графическому процессору. Если мы используем экземпляр ml.g4dn.16xlarge с распределенным обучением вместо экземпляра ml.g4dn.xlarge, у нас будет в восемь раз (8 GPU) больше памяти, чем у экземпляра ml.g4dn.xlarge (1 GPU). Размер пакета на устройство остается прежним, но восемь устройств обучаются параллельно.

Как обычно в SageMaker, мы создаем train.py сценарий для использования в режиме сценария и передачи гиперпараметров для обучения. Следующий фрагмент кода для Pegasus загружает модель и обучает ее с помощью Transformers. Trainer учебный класс:

# 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-*/")

Полный код доступен на GitHub.

Разверните обученную модель Hugging Face в SageMaker.

Наши друзья из Hugging Face сделали вывод о моделях SageMaker for Transformers проще, чем когда-либо, благодаря Набор инструментов SageMaker Hugging Face Inference. Вы можете напрямую развернуть ранее обученную модель, просто настроив переменную среды "HF_TASK":"summarization" (инструкции см. Модели Пегаса), выбирая Развертывание, а затем выбрав Создатель мудреца Амазонки, без необходимости писать сценарий вывода.

Однако, если вам нужен какой-то конкретный способ генерировать или постобрабатывать прогнозы, например генерировать несколько сводных предложений на основе списка различных параметров генерации текста, написание собственного сценария вывода может быть полезным и относительно простым:

# 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

Как показано в предыдущем коде, такому сценарию вывода для HuggingFace в SageMaker нужны только следующие функции шаблона:

• model_fn () - Читает содержимое того, что было сохранено в конце учебного задания внутри SM_MODEL_DIR, или из существующего каталога весов модели, сохраненного в виде файла tar.gz в Простой сервис хранения Amazon (Амазон С3). Он используется для загрузки обученной модели и связанного с ней токенизатора.
• input_fn () – Форматирует данные, полученные из запроса, сделанного в конечной точке.
• predict_fn () – вызывает вывод model_fn() (модель и токенизатор) для выполнения вывода на выходе input_fn() (отформатированные данные).

По желанию можно создать output_fn() функция для форматирования вывода, использующая вывод predict_fn(), что мы не продемонстрировали в этом посте.

Затем мы можем развернуть обученную модель Hugging Face с соответствующим сценарием логического вывода в SageMaker, используя Обнимающее лицо Модель SageMaker учебный класс:

# 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'
                         )

Протестируйте развернутую модель

Для этой демонстрации мы обучили модель Набор данных "Обзоры женской одежды для электронной коммерции", который содержит обзоры статей об одежде (которые мы рассматриваем как входной текст) и связанные с ними заголовки (которые мы рассматриваем как резюме). После того, как мы удалили статьи с отсутствующими заголовками, набор данных содержит 19,675 70 обзоров. Точная настройка модели Pegasus на обучающем наборе, содержащем 3.5 % этих статей для пяти эпох, заняла примерно 3.16 часа на экземпляре ml.pXNUMXxlarge.

Затем мы можем развернуть модель и протестировать ее с некоторыми примерами данных из тестового набора. Ниже приведен пример обзора, описывающего свитер:

# 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

Благодаря нашему пользовательскому сценарию вывода, размещенному в конечной точке SageMaker, мы можем создать несколько сводок для этого обзора с различными параметрами генерации текста. Например, мы можем попросить конечную точку сгенерировать диапазон от очень коротких до умеренно длинных сводок с указанием различных штрафов за длину (чем меньше штраф за длину, тем короче сгенерированная сводка). Ниже приведены некоторые примеры ввода параметров и последующие сводки, сгенерированные машиной:

# 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"]
]

Какое резюме вы предпочитаете? Первый сгенерированный заголовок содержит все важные факты об обзоре и содержит четверть слова. Напротив, в последнем используется всего три слова (менее 1/10 длины исходного обзора), чтобы сосредоточиться на наиболее важной особенности свитера.

Заключение

Вы можете точно настроить средство суммирования текста в пользовательском наборе данных и развернуть его в рабочей среде SageMaker с помощью этого простого примера, доступного на GitHub, дополнительный образцы записных книжек для обучения и развертывания моделей Hugging Face в SageMaker.

Как всегда, AWS приветствует обратную связь. Пожалуйста, отправьте любые комментарии или вопросы.

Рекомендации

[1] PEGASUS: предварительное обучение с извлеченными предложениями-пробелами для абстрактного обобщения

Об авторах

Виктор Малесевич — инженер по машинному обучению в AWS Professional Services, увлеченный обработкой естественного языка и MLOps. Он работает с клиентами над разработкой и внедрением сложных моделей глубокого обучения в производство на AWS. В свободное время он любит выпить бокал красного вина и немного сыра с друзьями.

Амна Наджми является специалистом по данным в AWS Professional Services. Она увлечена тем, что помогает клиентам внедрять инновации с помощью технологий больших данных и искусственного интеллекта, чтобы использовать бизнес-ценность и идеи из данных. В свободное время она занимается садоводством и путешествует по новым местам.