Zidentyfikuj kluczowe informacje z dokumentów tekstowych poprzez dostrajanie i HPO za pomocą Amazon SageMaker JumpStart

Organizacje z różnych branż, takich jak handel detaliczny, bankowość, finanse, opieka zdrowotna, produkcja i pożyczki, często muszą radzić sobie z ogromną ilością nieustrukturyzowanych dokumentów tekstowych pochodzących z różnych źródeł, takich jak wiadomości, blogi, recenzje produktów, kanały obsługi klienta i media społecznościowe. Dokumenty te zawierają krytyczne informacje, które są kluczowe przy podejmowaniu ważnych decyzji biznesowych. W miarę rozwoju organizacji wyzwaniem staje się wyodrębnienie krytycznych informacji z tych dokumentów. Wraz z postępem technik przetwarzania języka naturalnego (NLP) i uczenia maszynowego (ML) możemy szybko i z dużą dokładnością odkrywać cenne spostrzeżenia i powiązania z tych dokumentów tekstowych, pomagając w ten sposób firmom w podejmowaniu wysokiej jakości decyzji biznesowych na czas. W pełni zarządzane usługi NLP również przyspieszyły przyjęcie NLP. Amazon Comprehend to w pełni zarządzana usługa, która umożliwia budowanie niestandardowych modeli NLP, które są specyficzne dla Twoich wymagań, bez potrzeby posiadania wiedzy specjalistycznej w zakresie uczenia maszynowego.

W tym poście pokazujemy, jak wykorzystać najnowocześniejsze techniki ML do rozwiązania pięciu różnych zadań NLP: podsumowania dokumentów, klasyfikacji tekstu, odpowiadania na pytania, rozpoznawania nazwanych jednostek i ekstrakcji relacji. Dla każdego z tych zadań NLP pokazujemy, jak używać Amazon Sage Maker wykonać następujące czynności:

• Wdrażaj i uruchamiaj wnioskowanie na wstępnie wytrenowanym modelu
• Dostosuj wstępnie wytrenowany model na nowym niestandardowym zestawie danych
• Dalsza poprawa wydajności dostrajania za pomocą Automatyczne dostrajanie modelu SageMaker
• Oceń wydajność modelu na danych testu wstrzymania za pomocą różnych metryk oceny

Chociaż w tym poście omawiamy pięć konkretnych zadań NLP, możesz użyć tego rozwiązania jako szablonu do uogólnienia dostrajania wstępnie wytrenowanych modeli z własnym zestawem danych, a następnie uruchomić optymalizację hiperparametrów w celu zwiększenia dokładności.

Szablony rozwiązań JumpStart

Amazon SageMaker JumpStart zapewnia kompleksowe rozwiązania jednym kliknięciem dla wielu typowych przypadków użycia uczenia maszynowego. Zapoznaj się z poniższymi przypadkami użycia, aby uzyskać więcej informacji na temat dostępnych szablonów rozwiązań:

Szablony rozwiązania JumpStart obejmują różne przypadki użycia, z których każdy oferuje kilka różnych szablonów rozwiązań (to rozwiązanie Document Understanding znajduje się w przypadku użycia „Wyodrębnianie i analizowanie danych z dokumentów”).

Wybierz szablon rozwiązania, który najlepiej pasuje do Twojego przypadku użycia ze strony docelowej JumpStart. Aby uzyskać więcej informacji na temat konkretnych rozwiązań w każdym przypadku użycia oraz sposobu uruchamiania rozwiązania JumpStart, zobacz Szablony rozwiązań.

Omówienie rozwiązania

Poniższy obraz pokazuje, jak można użyć tego rozwiązania z komponentami SageMaker. Zadania szkoleniowe SageMaker są używane do uczenia różnych modeli NLP, a punkty końcowe SageMaker są używane do wdrażania modeli na każdym etapie. Używamy Usługa Amazon Simple Storage (Amazon S3) wraz z SageMaker do przechowywania danych treningowych i artefaktów modeli oraz Amazon Cloud Watch do rejestrowania wyników szkolenia i punktów końcowych.

Otwórz rozwiązanie do rozumienia dokumentów

Przejdź do rozwiązania Document Understanding w JumpStart.

Teraz możemy przyjrzeć się bliżej niektórym zasobom zawartym w tym rozwiązaniu, zaczynając od notatnika demonstracyjnego.

Notatnik demonstracyjny

Notatnika demonstracyjnego można użyć do wysłania przykładowych danych do już wdrożonych punktów końcowych modelu na potrzeby podsumowania dokumentów i zadań związanych z odpowiadaniem na pytania. Notatnik demonstracyjny pozwala szybko zdobyć praktyczne doświadczenie, wykonując zapytania dotyczące przykładowych danych.

Po uruchomieniu rozwiązania Document Understanding otwórz notatnik demonstracyjny, wybierając opcję Użyj punktu końcowego w Notatniku.

Przyjrzyjmy się dokładniej każdemu z pięciu głównych notesów tego rozwiązania.

Wymagania wstępne

In Studio Amazon SageMaker, upewnij się, że używasz PyTorch 1.10 Python 3.8 CPU Optimized image/kernel, aby otworzyć notatniki. Szkolenie wykorzystuje pięć instancji ml.g4dn.2xlarge, więc powinieneś podnieść a wniosek o zwiększenie limitu usług jeśli Twoje konto wymaga zwiększonych limitów dla tego typu.

Klasyfikacja tekstu

Klasyfikacja tekstu odnosi się do klasyfikowania zdania wejściowego do jednej z etykiet klasy uczącego zestawu danych. Ten notatnik pokazuje, jak korzystać z Interfejs API JumpStart do klasyfikacji tekstów.

Wdróż i uruchom wnioskowanie na wstępnie wytrenowanym modelu

Wybrany przez nas model klasyfikacji tekstu opiera się na osadzeniu tekstu (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) wzór z Centrum TensorFlow, który jest wstępnie przeszkolony w zakresie zestawów danych Wikipedii i BookCorpus.

Model dostępny do wdrożenia jest tworzony przez dołączenie binarnej warstwy klasyfikacji do danych wyjściowych modelu osadzania tekstu, a następnie dostrojenie całego modelu na SST-2 zbiór danych, który składa się z pozytywnych i negatywnych recenzji filmów.

Aby uruchomić wnioskowanie na tym modelu, musimy najpierw pobrać kontener wnioskowania (deploy_image_uri), skrypt wnioskowania (deploy_source_uri) i wstępnie wyszkolony model (base_model_uri). Następnie przekazujemy je jako parametry w celu utworzenia instancji obiektu modelu SageMaker, który możemy następnie wdrożyć:

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 "

Poniższy kod pokazuje nasze odpowiedzi:

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

Dostosuj wstępnie przeszkolony model na niestandardowym zestawie danych

Właśnie przeprowadziliśmy wnioskowanie na temat wstępnie wytrenowanego modelu BERT, który został dopracowany w programie SST-2 zestaw danych.

Następnie omówimy, jak dostroić model na niestandardowym zestawie danych z dowolną liczbą klas. Zbiór danych, którego używamy do dostrajania, nadal jest aktualny SST-2 zestaw danych. Możesz zastąpić ten zestaw danych dowolnym zestawem danych, który Cię interesuje.

Pobieramy kontener szkolenia Docker, źródło algorytmu szkolenia i wstępnie wytrenowany model:

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"
)

W przypadku hiperparametrów specyficznych dla algorytmu zaczynamy od pobrania słownika Pythona hiperparametrów szkoleniowych, które algorytm akceptuje wraz z ich wartościami domyślnymi. Możesz je zastąpić wartościami niestandardowymi, jak pokazano w poniższym kodzie:

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"

zestaw danych (SST-2) jest podzielony na zestawy treningowe, walidacyjne i testowe, gdzie zestaw treningowy jest używany do dopasowania modelu, zestaw walidacyjny służy do obliczania metryk oceny, które można wykorzystać do HPO, a zestaw testowy jest używany jako dane wstrzymane do oceny wydajności modelu. Następnie zestaw danych pociągu i walidacji jest przesyłany do Amazon S3 i używany do uruchomienia zadania szkoleniowego dostrajania:

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

Po zakończeniu zadania dostrajania wdrażamy model, uruchamiamy wnioskowanie na testowym zestawie danych wstrzymania i obliczamy metryki oceny. Ponieważ jest to zadanie klasyfikacji binarnej, używamy metody wynik dokładności i Wynik F1 jako mierniki oceny. Większa wartość oznacza lepszą wydajność. Poniższy zrzut ekranu przedstawia nasze wyniki.

Dalsza poprawa wydajności dostrajania dzięki automatycznemu dostrajaniu modelu SageMaker

W tym kroku pokazujemy, w jaki sposób można jeszcze bardziej poprawić wydajność modelu, dostrajając model za pomocą automatycznego dostrajania modelu SageMaker. Automatyczne dostrajanie modelu, znane również jako optymalizacja hiperparametrów (HPO), znajduje najlepszą wersję modelu przez uruchomienie wielu zadań szkoleniowych w zestawie danych z określonym zakresem hiperparametrów. Następnie wybiera wartości hiperparametrów, które dają model, który działa najlepiej, mierzony za pomocą wybranej metryki, w zbiorze danych walidacji.

Najpierw ustawiamy cel jako wynik dokładności danych walidacyjnych (val_accuracy) i zdefiniowane metryki dla zadania dostrajania, określając nazwę metryki celu i wyrażenie regularne (regex). Wyrażenie regularne służy do dopasowania danych wyjściowych dziennika algorytmu i przechwytywania wartości liczbowych metryk. Następnie określamy zakresy hiperparametrów, z których wybieramy najlepsze wartości hiperparametrów. Ustawiamy całkowitą liczbę zadań dostrajania na sześć i rozdzielamy te zadania na trzy różne Elastyczna chmura obliczeniowa Amazon (Amazon EC2) do uruchamiania równoległych zadań dostrajania. Zobacz następujący kod:

# 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

Przekazujemy te wartości, aby utworzyć instancję obiektu SageMaker Estimator, podobnie jak w poprzednim kroku dostrajania. Zamiast dzwonić do fit funkcja Estimator obiekt, mijamy Estimator obiekt jako parametr do HyperparametrTuner konstruktora i wywołaj fit jego funkcja, aby uruchomić zadania strojenia:

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

Po zakończeniu zadań dostrajania wdrażamy model, który daje najlepszy wynik metryki oceny w zestawie danych do walidacji, przeprowadzamy wnioskowanie na tym samym zestawie danych testowych wstrzymania, które wykonaliśmy w poprzedniej sekcji, i obliczamy metryki oceny.

Wyniki pokazują, że model wybrany przez automatyczne dostrajanie modelu znacznie przewyższa model dostrojony w poprzedniej sekcji na zbiorze danych testu wstrzymania.

Rozpoznawanie nazwanych jednostek

Rozpoznawanie nazwanych jednostek (NER) to proces wykrywania i klasyfikowania nazwanych jednostek do predefiniowanych kategorii, takich jak nazwiska osób, organizacje, lokalizacje i ilości. Istnieje wiele rzeczywistych przypadków użycia NER, takich jak silniki rekomendacji, kategoryzowanie i przypisywanie zgłoszeń obsługi klienta do odpowiedniego działu, wydobywanie istotnych informacji z raportów pacjentów w opiece zdrowotnej oraz klasyfikacja treści z wiadomości i blogów.

Wdróż i uruchom wnioskowanie na wstępnie wytrenowanym modelu

Wdrażamy En_core_web_md model z Przestronny biblioteka. spaCy to biblioteka NLP o otwartym kodzie źródłowym, która może być używana do różnych zadań i ma wbudowane metody dla NER. Używamy AWS PyTorch Deep Learning Container (DLC) z trybem skryptowym i instalujemy bibliotekę spaCy jako zależność na wierzchu kontenera.

Następnie punkt wejścia dla skryptu (argument entry_point.py) jest określony, zawierający cały kod do pobrania i załadowania En_core_web_md modelować i przeprowadzać wnioskowanie na podstawie danych wysyłanych do punktu końcowego. Wreszcie musimy jeszcze zapewnić model_data jako wstępnie wytrenowany model do wnioskowania. Ponieważ wstępnie przeszkolony En_core_web_md model jest pobierany w locie, co jest określone w skrypcie wejściowym, udostępniamy pusty plik archiwum. Po wdrożeniu punktu końcowego można wywołać punkt końcowy bezpośrednio z notebooka przy użyciu pakietu SageMaker Python SDK Predictor. Zobacz następujący kod:

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()
)

Danymi wejściowymi do modelu jest dokument tekstowy. Model nazwanych jednostek wyodrębnia fragmenty rzeczowników i nazwane jednostki w dokumencie tekstowym i klasyfikuje je na wiele różnych typów (takich jak ludzie, miejsca i organizacje). Przykładowe dane wejściowe i wyjściowe są pokazane w poniższym kodzie. The start_char parametr wskazuje przesunięcie znaku na początku zakresu i end_char wskazuje koniec zakresu.

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}]

Dostosuj wstępnie przeszkolony model na niestandardowym zestawie danych

W tym kroku pokazujemy, jak dostroić wstępnie wytrenowane modele językowe dla NER na własnym zbiorze danych. Krok dostrajania aktualizuje parametry modelu, aby uchwycić charakterystykę własnych danych i poprawić dokładność. Używamy WikiANN (PAN-X) w celu dostrojenia DestilBERT-base-uncased Model transformatora z Hugging Face.

Zestaw danych jest podzielony na zestawy uczące, sprawdzające walidację i testowe.

Następnie określamy hiperparametry modelu i używamy DLC AWS Hugging Face z trybem skryptowym (argument entry_point), aby uruchomić zadanie dostrajania:

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
)

Po zakończeniu zadania dostrajania wdrażamy punkt końcowy i wysyłamy zapytanie do tego punktu końcowego za pomocą wstrzymanych danych testowych. Aby wysłać zapytanie do punktu końcowego, każdy ciąg tekstowy musi zostać podzielony na jeden lub wiele tokenów i wysłany do modelu transformatora. Każdy token otrzymuje przewidywany nazwany tag jednostki. Ponieważ każdy ciąg tekstowy można podzielić na jeden lub wiele tokenów, musimy zduplikować podstawowy znacznik podmiotu o nazwie prawdy na wszystkie tokeny, które są z nim powiązane. Dostarczony notatnik przeprowadzi Cię przez kroki, które należy wykonać, aby to osiągnąć.

Na koniec używamy wbudowanych wskaźników oceny Hugging Face sekwencja obliczyć wyniki oceny na danych z testu wstrzymania. Zastosowane metryki oceny to ogólna precyzja, ogólna pamięć, ogólna F1 i dokładność. Poniższy zrzut ekranu przedstawia nasze wyniki.

Dalsza poprawa wydajności dostrajania dzięki automatycznemu dostrajaniu modelu SageMaker

Podobnie jak w przypadku klasyfikacji tekstu, pokazujemy, w jaki sposób można jeszcze bardziej poprawić wydajność modelu, dostrajając model za pomocą automatycznego dostrajania modelu SageMaker. Aby uruchomić zadanie dostrajania, musimy zdefiniować obiektywną metrykę, której chcemy użyć do oceny wydajności modelu na zbiorze danych walidacji (w tym przypadku wynik F1), zakresy hiperparametrów, z których można wybrać najlepsze wartości hiperparametrów, a także konfiguracje zadań dostrajania, takie jak maksymalna liczba zadań dostrajania i liczba zadań równoległych do uruchomienia jednocześnie:

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)

Po zakończeniu zadań dostrajania wdrażamy model, który daje najlepszy wynik metryki oceny w zestawie danych do walidacji, przeprowadzamy wnioskowanie na tym samym zestawie danych testowych wstrzymania, które wykonaliśmy w poprzedniej sekcji, i obliczamy metryki oceny.

Widzimy, że model z HPO osiąga znacznie lepszą wydajność we wszystkich metrykach.

Odpowiadanie na pytania

Odpowiadanie na pytania jest przydatne, gdy chcesz przeszukać dużą ilość tekstu w celu uzyskania określonych informacji. Pozwala użytkownikowi zadać pytanie w języku naturalnym i uzyskać natychmiastową i krótką odpowiedź. Systemy odpowiedzi na pytania oparte na NLP mogą być używane w wyszukiwarkach i telefonicznych interfejsach konwersacyjnych.

Wdróż i uruchom wnioskowanie na wstępnie wytrenowanym modelu

Nasz wstępnie wytrenowany model to model odpowiedzi na pytania ekstrakcyjne (EQA). bert-duże-nieosłonięte-całe-słowa-maskujące-dostrojone-squad zbudowany na modelu Transformer z Hugging Face. Używamy DLC AWS PyTorch z trybem skryptowym i instalujemy Transformatory biblioteka jako zależność na górze kontenera. Podobnie jak w zadaniu NER, w argumencie podajemy pusty plik archiwum model_data ponieważ wstępnie wytrenowany model jest pobierany w locie. Po wdrożeniu punktu końcowego można wywołać punkt końcowy bezpośrednio z notebooka przy użyciu pakietu SageMaker Python SDK Predictor. Zobacz następujący kod:

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",
    },
)

Wszystko, co musimy zrobić, to skonstruować obiekt słownika z dwoma kluczami. context jest tekstem, z którego chcemy pobrać informacje. question to zapytanie w języku naturalnym, które określa, jakie informacje chcemy wyodrębnić. Nazywamy predict na naszym predyktorze i powinniśmy otrzymać odpowiedź z punktu końcowego, który zawiera najbardziej prawdopodobne odpowiedzi:

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

Mamy odpowiedź i możemy wydrukować najbardziej prawdopodobne odpowiedzi, które zostały wyodrębnione z poprzedniego tekstu. Każda odpowiedź ma wynik ufności używany do rankingu (ale ten wynik nie powinien być interpretowany jako prawdziwe prawdopodobieństwo). Oprócz dosłownej odpowiedzi otrzymujesz także indeksy znaków początkowych i końcowych odpowiedzi z oryginalnego kontekstu:

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'}]

Teraz dostrajamy ten model za pomocą własnego niestandardowego zestawu danych, aby uzyskać lepsze wyniki.

Dostosuj wstępnie przeszkolony model na niestandardowym zestawie danych

W tym kroku pokazujemy, jak dostroić wstępnie wytrenowane modele językowe dla EQA na własnym zbiorze danych. Krok dostrajania aktualizuje parametry modelu, aby uchwycić charakterystykę własnych danych i poprawić dokładność. Używamy ODDZIAŁ 2.0 zestawu danych w celu dostrojenia modelu osadzania tekstu bert-base-bez obudowy z Przytulania Twarzy. Model dostępny do dostrajania dołącza warstwę wyodrębniania odpowiedzi do modelu osadzania tekstu i inicjuje parametry warstwy do losowych wartości. Krok dostrajania dostraja wszystkie parametry modelu, aby zminimalizować błąd predykcji danych wejściowych i zwraca precyzyjnie dostrojony model.

Podobnie jak w przypadku zadania klasyfikacji tekstu, zbiór danych (SQuAD2.0) jest podzielony na zbiór uczący, walidacyjny i testowy.

Następnie określamy hiperparametry modelu i używamy Interfejs API JumpStart aby uruchomić zadanie dostrajania:

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)

Po zakończeniu zadania dostrajania wdrażamy model, uruchamiamy wnioskowanie na testowym zestawie danych wstrzymania i obliczamy metryki oceny. Stosowane wskaźniki oceny to średni wynik dokładnego dopasowania i średni wynik F1. Poniższy zrzut ekranu przedstawia wyniki.

Dalsza poprawa wydajności dostrajania dzięki automatycznemu dostrajaniu modelu SageMaker

Podobnie jak w poprzednich sekcjach, używamy a HyperparameterTuner obiekt do uruchamiania zadań dostrajania:

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

Po zakończeniu zadań dostrajania wdrażamy model, który daje najlepszy wynik metryki oceny w zestawie danych do walidacji, przeprowadzamy wnioskowanie na tym samym zestawie danych testowych wstrzymania, które wykonaliśmy w poprzedniej sekcji, i obliczamy metryki oceny.

Widzimy, że model z HPO wykazuje znacznie lepszą wydajność na danych testu wstrzymania.

Ekstrakcja relacji

Ekstrakcja relacji to zadanie wydobywania relacji semantycznych z tekstu, które zwykle występują między dwoma lub większą liczbą jednostek. Ekstrakcja relacji odgrywa ważną rolę w wydobywaniu ustrukturyzowanych informacji z nieustrukturyzowanych źródeł, takich jak nieprzetworzony tekst. W tym notatniku zademonstrujemy dwa przypadki użycia ekstrakcji relacji.

Dostosuj wstępnie przeszkolony model na niestandardowym zestawie danych

Używamy modelu ekstrakcji relacji zbudowanego na BERT bez obudowy model wykorzystujący transformatory z Przytulanie transformatorów twarzy biblioteka. Model do precyzyjnego dostrajania dołącza liniową warstwę klasyfikacji, która pobiera parę osadzonych tokenów wyprowadzanych przez model osadzania tekstu i inicjuje parametry warstwy do losowych wartości. Krok dostrajania dostraja wszystkie parametry modelu, aby zminimalizować błąd predykcji danych wejściowych i zwraca precyzyjnie dostrojony model.

Zbiór danych, w którym dopracowujemy model SemEval-2010 Zadanie 8. Model zwrócony przez dostrajanie może być dalej wykorzystywany do wnioskowania.

Zestaw danych zawiera zestawy treningowe, sprawdzania poprawności i testowe.

Używamy AWS PyTorch DLC z trybem skryptowym z SageMaker Python SDK, gdzie transformers biblioteka jest instalowana jako zależność na górze kontenera. Definiujemy SageMakera PyTorch estymator i zestaw hiperparametrów, takich jak wstępnie wytrenowany model, szybkość uczenia się i liczby epok, aby przeprowadzić precyzyjne dostrajanie. Kod służący do dostrajania modelu wyodrębniania relacji jest zdefiniowany w pliku entry_point.py. Zobacz następujący kod:

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/",
    }
)

Dalsza poprawa wydajności dostrajania dzięki automatycznemu dostrajaniu modelu SageMaker

Podobnie jak w poprzednich sekcjach, używamy a HyperparameterTuner obiekt do interakcji z interfejsami API dostrajania hiperparametrów SageMaker. Możemy rozpocząć zadanie dostrajania hiperparametrów, wywołując funkcję fit metoda:

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/",
})

Po zakończeniu zadania dostrajania hiperparametrów przeprowadzamy wnioskowanie i sprawdzamy wynik oceny.

Widzimy, że model z HPO wykazuje lepszą wydajność na danych testu wstrzymania.

Podsumowanie dokumentu

Podsumowanie dokumentu lub tekstu to zadanie skondensowania dużych ilości danych tekstowych w mniejszy podzbiór znaczących zdań, które reprezentują najważniejsze lub istotne informacje w oryginalnej treści. Podsumowanie dokumentu to przydatna technika wyodrębniania ważnych informacji z dużej ilości danych tekstowych do kilku zdań. Podsumowanie tekstu jest używane w wielu przypadkach, takich jak przetwarzanie dokumentów i wydobywanie informacji z blogów, artykułów i wiadomości.

W tym notesie przedstawiono wdrażanie modelu podsumowania dokumentów podstawa T5 z Przytulanie transformatorów twarzy biblioteka. Testujemy również wdrożone punkty końcowe za pomocą artykułu tekstowego i oceniamy wyniki za pomocą wbudowanej metryki oceny Hugging Face CZERWONA.

Podobnie jak w przypadku odpowiedzi na pytania i notatników NER, używamy PyTorchModel z SageMaker Python SDK wraz z plikiem entry_point.py skrypt do ładowania modelu bazowego T5 do punktu końcowego HTTPS. Po pomyślnym wdrożeniu punktu końcowego możemy wysłać artykuł tekstowy do punktu końcowego, aby uzyskać odpowiedź przewidywania:

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 ."""

Następnie oceniamy i porównujemy artykuł tekstowy i wynik podsumowania za pomocą metryki ROUGE. Obliczane są trzy wskaźniki oceny: rougeN, rougeL, rougeLsum. rougeN mierzy liczbę dopasowań n-grams między tekstem wygenerowanym przez model (wynik podsumowania) a a reference (Wprowadź tekst). Metryki rougeL i rougeLsum mierzyć najdłuższe pasujące sekwencje słów, wyszukując najdłuższe wspólne podciągi w wygenerowanych i referencyjnych podsumowaniach. Dla każdej metryki obliczane są przedziały ufności dla precyzji, odwołania i wyniku F1. Zobacz następujący kod:

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

Sprzątać

Zasoby utworzone dla tego rozwiązania można usunąć za pomocą Usuń wszystkie zasoby przycisk z SageMaker Studio IDE. Każdy notatnik zawiera również sekcję czyszczenia z kodem do usuwania punktów końcowych.

Wnioski

W tym poście pokazaliśmy, jak wykorzystać najnowocześniejsze techniki ML do rozwiązania pięciu różnych zadań NLP: podsumowania dokumentów, klasyfikacji tekstu, pytań i odpowiedzi, rozpoznawania nazwanych jednostek i ekstrakcji relacji za pomocą Jumpstart. Rozpocznij teraz z Szybkim startem!

O autorach

Dr Xin Huang jest naukowcem w zakresie wbudowanych algorytmów Amazon SageMaker JumpStart i Amazon SageMaker. Koncentruje się na tworzeniu skalowalnych algorytmów uczenia maszynowego. Jego zainteresowania badawcze dotyczą przetwarzania języka naturalnego, wyjaśnialnego głębokiego uczenia się na danych tabelarycznych oraz solidnej analizy nieparametrycznego klastrowania przestrzenno-czasowego. Opublikował wiele artykułów na konferencjach ACL, ICDM, KDD oraz Royal Statistical Society: Series A.

Vivek Gangasani jest starszym architektem rozwiązań uczenia maszynowego w Amazon Web Services. Pomaga Startupom budować i operacjonalizować aplikacje AI/ML. Obecnie koncentruje się na połączeniu swojego doświadczenia w zakresie kontenerów i uczenia maszynowego, aby dostarczać rozwiązania dotyczące MLOps, wnioskowania ML i uczenia maszynowego o niskim poziomie kodu. W wolnym czasie lubi próbować nowych restauracji i badać pojawiające się trendy w sztucznej inteligencji i głębokim uczeniu się.

Geremiego Cohena jest architektem rozwiązań w AWS, gdzie pomaga klientom w tworzeniu najnowocześniejszych rozwiązań w chmurze. W wolnym czasie lubi krótkie spacery po plaży, zwiedzanie zatoki z rodziną, naprawianie rzeczy w domu, niszczenie rzeczy wokół domu i grillowanie.

Neelam Koshiya jest architektem rozwiązań dla przedsiębiorstw w AWS. Obecnie koncentruje się na pomocy klientom korporacyjnym w ich drodze do wdrożenia chmury w celu uzyskania strategicznych wyników biznesowych. W wolnym czasie lubi czytać i przebywać na świeżym powietrzu.