Identifikasi wawasan utama dari dokumen teks melalui penyempurnaan dan HPO dengan Amazon SageMaker JumpStart

Organisasi lintas industri seperti ritel, perbankan, keuangan, perawatan kesehatan, manufaktur, dan pinjaman sering kali harus berurusan dengan sejumlah besar dokumen teks tidak terstruktur yang berasal dari berbagai sumber, seperti berita, blog, ulasan produk, saluran dukungan pelanggan, dan media sosial. Dokumen-dokumen ini berisi informasi penting yang merupakan kunci untuk membuat keputusan bisnis yang penting. Ketika sebuah organisasi tumbuh, menjadi tantangan untuk mengekstrak informasi penting dari dokumen-dokumen ini. Dengan kemajuan teknik pemrosesan bahasa alami (NLP) dan pembelajaran mesin (ML), kami dapat mengungkap wawasan dan koneksi berharga dari dokumen tekstual ini dengan cepat dan akurat, sehingga membantu perusahaan membuat keputusan bisnis yang berkualitas tepat waktu. Layanan NLP yang dikelola sepenuhnya juga telah mempercepat penerapan NLP. Amazon Comprehend adalah layanan terkelola sepenuhnya yang memungkinkan Anda membangun model NLP khusus yang spesifik untuk kebutuhan Anda, tanpa memerlukan keahlian ML apa pun.

Dalam postingan ini, kami mendemonstrasikan cara menggunakan teknik ML yang canggih untuk menyelesaikan lima tugas NLP yang berbeda: peringkasan dokumen, klasifikasi teks, menjawab pertanyaan, pengenalan entitas bernama, dan ekstraksi hubungan. Untuk setiap tugas NLP ini, kami mendemonstrasikan cara menggunakannya Amazon SageMaker untuk melakukan tindakan berikut:

• Men-deploy dan menjalankan inferensi pada model terlatih
• Sempurnakan model terlatih pada set data kustom baru
• Tingkatkan lebih lanjut kinerja fine-tuning dengan Tuning model otomatis SageMaker
• Mengevaluasi kinerja model pada data uji tahan dengan berbagai metrik evaluasi

Meskipun kami membahas lima tugas NLP khusus dalam posting ini, Anda dapat menggunakan solusi ini sebagai template untuk menggeneralisasi model pra-pelatihan fine-tuning dengan dataset Anda sendiri, dan selanjutnya menjalankan optimasi hyperparameter untuk meningkatkan akurasi.

Templat solusi JumpStart

Mulai Lompatan Amazon SageMaker memberikan solusi end-to-end sekali klik untuk banyak kasus penggunaan ML yang umum. Jelajahi kasus penggunaan berikut untuk informasi selengkapnya tentang template solusi yang tersedia:

Template solusi JumpStart mencakup berbagai kasus penggunaan, di mana masing-masing template menawarkan beberapa template solusi yang berbeda (solusi Pemahaman Dokumen ini berada di bawah kasus penggunaan "Mengekstrak dan menganalisis data dari dokumen").

Pilih template solusi yang paling sesuai dengan kasus penggunaan Anda dari halaman arahan JumpStart. Untuk informasi selengkapnya tentang solusi spesifik di bawah setiap kasus penggunaan dan cara meluncurkan solusi JumpStart, lihat Templat Solusi.

Ikhtisar solusi

Gambar berikut menunjukkan cara menggunakan solusi ini dengan komponen SageMaker. Tugas pelatihan SageMaker digunakan untuk melatih berbagai model NLP, dan titik akhir SageMaker digunakan untuk menerapkan model di setiap tahap. Kita gunakan Layanan Penyimpanan Sederhana Amazon (Amazon S3) bersama SageMaker untuk menyimpan data pelatihan dan artefak model, dan amazoncloudwatch untuk mencatat keluaran pelatihan dan titik akhir.

Buka solusi Pemahaman Dokumen

Arahkan ke solusi Pemahaman Dokumen di JumpStart.

Sekarang kita dapat melihat lebih dekat beberapa aset yang termasuk dalam solusi ini, dimulai dengan notebook demo.

Buku catatan demo

Anda dapat menggunakan buku catatan demo untuk mengirim data contoh ke titik akhir model yang sudah diterapkan untuk tugas peringkasan dokumen dan menjawab pertanyaan. Buku catatan demo dengan cepat memungkinkan Anda mendapatkan pengalaman langsung dengan menanyakan data contoh.

Setelah Anda meluncurkan solusi Pemahaman Dokumen, buka buku catatan demo dengan memilih Gunakan Endpoint di Notebook.

Mari selami lebih dalam masing-masing dari lima notebook utama untuk solusi ini.

Prasyarat

In Studio Amazon SageMaker, pastikan Anda menggunakan PyTorch 1.10 Python 3.8 CPU Optimized image/kernel untuk membuka notebook. Pelatihan menggunakan lima instans ml.g4dn.2xlarge, jadi Anda harus meningkatkan a permintaan kenaikan batas layanan jika akun Anda memerlukan peningkatan batas untuk jenis ini.

Klasifikasi teks

Klasifikasi teks mengacu pada mengklasifikasikan kalimat input ke salah satu label kelas dari dataset pelatihan. Notebook ini mendemonstrasikan cara menggunakan API JumpStart untuk klasifikasi teks.

Men-deploy dan menjalankan inferensi pada model yang telah dilatih sebelumnya

Model klasifikasi teks yang kami pilih untuk digunakan dibangun di atas penyisipan teks (tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2) model dari Pusat TensorFlow, yang dilatih sebelumnya di kumpulan data Wikipedia dan BookCorpus.

Model yang tersedia untuk penerapan dibuat dengan melampirkan lapisan klasifikasi biner ke keluaran model penyematan teks, lalu menyempurnakan seluruh model pada SST-2 kumpulan data, yang terdiri dari ulasan film positif dan negatif.

Untuk menjalankan inferensi pada model ini, pertama-tama kita perlu mengunduh wadah inferensi (deploy_image_uri), skrip inferensi (deploy_source_uri), dan model terlatih (base_model_uri). Kami kemudian meneruskannya sebagai parameter untuk membuat instance objek model SageMaker, yang kemudian dapat kami terapkan:

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 "

Kode berikut menunjukkan respons kami:

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

Sempurnakan model yang telah dilatih sebelumnya pada kumpulan data khusus

Kami baru saja menjalankan inferensi pada model BERT yang telah dilatih sebelumnya, yang disetel dengan baik pada SST-2 Himpunan data.

Selanjutnya, kita membahas cara menyempurnakan model pada kumpulan data khusus dengan sejumlah kelas. Dataset yang kami gunakan untuk fine-tuning masih SST-2 Himpunan data. Anda dapat mengganti kumpulan data ini dengan kumpulan data apa pun yang Anda minati.

Kami mengambil wadah Docker pelatihan, sumber algoritme pelatihan, dan model pra-pelatihan:

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

Untuk hyperparameter khusus algoritme, kita mulai dengan mengambil kamus Python dari hyperparameter pelatihan yang diterima algoritme dengan nilai defaultnya. Anda dapat menimpanya dengan nilai khusus, seperti yang ditampilkan dalam kode berikut:

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"

Kumpulan data (SST-2) dibagi menjadi set pelatihan, validasi, dan pengujian, di mana set pelatihan digunakan agar sesuai dengan model, set validasi digunakan untuk menghitung metrik evaluasi yang dapat digunakan untuk HPO, dan set pengujian digunakan sebagai data tahan untuk mengevaluasi kinerja model. Berikutnya, dataset latih dan validasi diunggah ke Amazon S3 dan digunakan untuk meluncurkan tugas pelatihan penyesuaian:

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

Setelah pekerjaan penyempurnaan selesai, kami menerapkan model, menjalankan inferensi pada kumpulan data uji tahan, dan menghitung metrik evaluasi. Karena ini adalah tugas klasifikasi biner, kami menggunakan skor akurasi dan Skor F1 sebagai metrik evaluasi. Nilai yang lebih besar menunjukkan kinerja yang lebih baik. Tangkapan layar berikut menunjukkan hasil kami.

Tingkatkan lebih lanjut kinerja penyempurnaan dengan penyetelan model otomatis SageMaker

Pada langkah ini, kami mendemonstrasikan bagaimana Anda dapat lebih meningkatkan kinerja model dengan menyempurnakan model dengan penyetelan model otomatis SageMaker. Penyesuaian model otomatis, juga dikenal sebagai pengoptimalan hiperparameter (HPO), menemukan versi terbaik model dengan menjalankan beberapa tugas pelatihan pada kumpulan data Anda dengan rentang hiperparameter yang Anda tentukan. Kemudian memilih nilai hyperparameter yang menghasilkan model yang berperforma terbaik, sebagaimana diukur dengan metrik yang Anda pilih, pada kumpulan data validasi.

Pertama, kami menetapkan tujuan sebagai skor akurasi pada data validasi (val_accuracy) dan menentukan metrik untuk tugas penyetelan dengan menentukan nama metrik tujuan dan ekspresi reguler (regex). Ekspresi reguler digunakan untuk mencocokkan keluaran log algoritme dan menangkap nilai numerik metrik. Selanjutnya, kami menentukan rentang hyperparameter untuk memilih nilai hyperparameter terbaik. Kami menetapkan jumlah total pekerjaan penyetelan sebagai enam dan mendistribusikan pekerjaan ini pada tiga pekerjaan yang berbeda Cloud komputasi elastis Amazon (Amazon EC2) untuk menjalankan tugas penyetelan paralel. Lihat kode berikut:

# 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

Kami meneruskan nilai tersebut untuk membuat instance objek SageMaker Estimator, serupa dengan yang kami lakukan di langkah penyempurnaan sebelumnya. Alih-alih memanggil fit fungsi dari Estimator objek, kami melewati Estimator objek sebagai parameter ke Hyperparameter Tuner konstruktor dan memanggil fit fungsinya untuk meluncurkan pekerjaan penyetelan:

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

Setelah tugas penyetelan selesai, kami menerapkan model yang memberikan skor metrik evaluasi terbaik pada set data validasi, melakukan inferensi pada set data uji tahan yang sama seperti yang kami lakukan di bagian sebelumnya, dan menghitung metrik evaluasi.

Hasilnya menunjukkan bahwa model yang dipilih dengan penyetelan model otomatis secara signifikan mengungguli model yang disetel halus di bagian sebelumnya pada kumpulan data uji tahan.

Pengakuan entitas yang dinamai

Pengenalan entitas bernama (NER) adalah proses mendeteksi dan mengklasifikasikan entitas bernama ke dalam kategori yang telah ditentukan sebelumnya, seperti nama orang, organisasi, lokasi, dan jumlah. Ada banyak kasus penggunaan NER di dunia nyata, seperti mesin rekomendasi, mengkategorikan dan menugaskan tiket dukungan pelanggan ke departemen yang tepat, mengekstraksi informasi penting dari laporan pasien di layanan kesehatan, dan klasifikasi konten dari berita dan blog.

Men-deploy dan menjalankan inferensi pada model yang telah dilatih sebelumnya

Kami menyebarkan En_core_web_md model dari spaCy Perpustakaan. spaCy adalah pustaka NLP sumber terbuka yang dapat digunakan untuk berbagai tugas, dan memiliki metode bawaan untuk NER. Kami menggunakan AWS PyTorch Deep Learning Container (DLC) dengan mode skrip dan menginstal pustaka spaCy sebagai dependensi di atas container.

Selanjutnya, titik masuk untuk skrip (argument entry_point.py) ditentukan, berisi semua kode untuk mengunduh dan memuat En_core_web_md model dan melakukan inferensi pada data yang dikirim ke titik akhir. Akhirnya, kita masih perlu menyediakan model_data sebagai model terlatih untuk inferensi. Karena pra-dilatih En_core_web_md model diunduh dengan cepat, yang ditentukan dalam skrip entri, kami menyediakan file arsip kosong. Setelah titik akhir diterapkan, Anda dapat memanggil titik akhir langsung dari notebook menggunakan SageMaker Python SDK Predictor. Lihat kode berikut:

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

Data input untuk model adalah dokumen tekstual. Model entitas bernama mengekstrak potongan kata benda dan entitas bernama dalam dokumen tekstual dan mengklasifikasikannya ke dalam beberapa jenis yang berbeda (seperti orang, tempat, dan organisasi). Contoh input dan output ditunjukkan dalam kode berikut. Itu start_char parameter menunjukkan offset karakter untuk awal rentang, dan end_char menunjukkan akhir bentang.

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

Sempurnakan model yang telah dilatih sebelumnya pada kumpulan data khusus

Pada langkah ini, kami mendemonstrasikan cara menyempurnakan model bahasa terlatih untuk NER pada kumpulan data Anda sendiri. Langkah penyempurnaan memperbarui parameter model untuk menangkap karakteristik data Anda sendiri dan meningkatkan akurasi. Kami menggunakan WikiANN (PAN-X) dataset untuk menyempurnakan DistiBERT-base-uncased Model transformer dari Hugging Face.

Dataset dibagi menjadi set pelatihan, validasi, dan pengujian.

Selanjutnya, kami menentukan hyperparameter model, dan menggunakan DLC AWS Hugging Face dengan mode skrip (argumen entry_point) untuk memicu tugas fine-tuning:

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
)

Setelah pekerjaan penyempurnaan selesai, kami menerapkan titik akhir dan kueri titik akhir tersebut dengan data uji tahan. Untuk mengkueri titik akhir, setiap string teks perlu diberi token menjadi satu atau beberapa token dan dikirim ke model transformator. Setiap token mendapatkan tag entitas bernama yang diprediksi. Karena setiap string teks dapat dipatok menjadi satu atau beberapa token, kita perlu menduplikasi tag entitas bernama kebenaran dasar dari string ke semua token yang terkait dengannya. Buku catatan yang disediakan memandu Anda melalui langkah-langkah untuk mencapainya.

Terakhir, kami menggunakan metrik evaluasi bawaan Hugging Face berurutan untuk menghitung skor evaluasi pada data tes bertahan. Metrik evaluasi yang digunakan adalah overall precision, overall recall, overall F1, dan akurasi. Tangkapan layar berikut menunjukkan hasil kami.

Tingkatkan lebih lanjut kinerja penyempurnaan dengan penyetelan model otomatis SageMaker

Mirip dengan klasifikasi teks, kami mendemonstrasikan bagaimana Anda dapat lebih meningkatkan kinerja model dengan menyempurnakan model dengan penyetelan model otomatis SageMaker. Untuk menjalankan tugas penyetelan, kita perlu menentukan metrik objektif yang ingin kita gunakan untuk mengevaluasi kinerja model pada dataset validasi (skor F1 dalam kasus ini), rentang hyperparameter untuk memilih nilai hyperparameter terbaik, serta konfigurasi tugas penyetelan seperti jumlah maksimum tugas penyetelan dan jumlah tugas paralel yang akan diluncurkan sekaligus:

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)

Setelah tugas penyetelan selesai, kami menerapkan model yang memberikan skor metrik evaluasi terbaik pada set data validasi, melakukan inferensi pada set data uji tahan yang sama seperti yang kami lakukan di bagian sebelumnya, dan menghitung metrik evaluasi.

Kita dapat melihat bahwa model dengan HPO mencapai kinerja yang jauh lebih baik di semua metrik.

Menjawab pertanyaan

Menjawab pertanyaan berguna saat Anda ingin meminta sejumlah besar teks untuk informasi tertentu. Ini memungkinkan pengguna untuk mengungkapkan pertanyaan dalam bahasa alami dan mendapatkan tanggapan langsung dan singkat. Sistem penjawab pertanyaan yang didukung oleh NLP dapat digunakan di mesin pencari dan antarmuka percakapan telepon.

Men-deploy dan menjalankan inferensi pada model yang telah dilatih sebelumnya

Model pra-pelatihan kami adalah model penjawab pertanyaan ekstraktif (EQA). bert-besar-uncased-whole-word-masking-finetuned-squad dibangun di atas model Transformer dari Hugging Face. Kami menggunakan DLC AWS PyTorch dengan mode skrip dan menginstal transformer perpustakaan sebagai ketergantungan di atas wadah. Mirip dengan tugas NER, kami menyediakan file arsip kosong di argumen model_data karena model pra-pelatihan diunduh dengan cepat. Setelah titik akhir diterapkan, Anda dapat memanggil titik akhir langsung dari notebook menggunakan SageMaker Python SDK Predictor. Lihat kode berikut:

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

Yang perlu kita lakukan hanyalah membuat objek kamus dengan dua kunci. context adalah teks yang ingin kita ambil informasinya. question adalah kueri bahasa alami yang menentukan informasi apa yang ingin kami ekstrak. Kami memanggil predict pada prediktor kami, dan kami harus mendapatkan respons dari titik akhir yang berisi jawaban yang paling mungkin:

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

Kami memiliki jawabannya, dan kami dapat mencetak jawaban yang paling mungkin yang telah diambil dari teks sebelumnya. Setiap jawaban memiliki skor keyakinan yang digunakan untuk peringkat (namun skor ini tidak boleh ditafsirkan sebagai probabilitas sebenarnya). Selain jawaban kata demi kata, Anda juga mendapatkan indeks karakter awal dan akhir jawaban dari konteks aslinya:

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

Sekarang kami menyempurnakan model ini dengan kumpulan data khusus kami sendiri untuk mendapatkan hasil yang lebih baik.

Sempurnakan model yang telah dilatih sebelumnya pada kumpulan data khusus

Pada langkah ini, kami mendemonstrasikan cara menyempurnakan model bahasa terlatih untuk EQA pada kumpulan data Anda sendiri. Langkah penyempurnaan memperbarui parameter model untuk menangkap karakteristik data Anda sendiri dan meningkatkan akurasi. Kami menggunakan SQuAD2.0 dataset untuk menyempurnakan model penyisipan teks bert-base-tanpa casing dari Memeluk Wajah. Model yang tersedia untuk fine-tuning melampirkan lapisan ekstraksi jawaban ke model penyisipan teks dan menginisialisasi parameter lapisan ke nilai acak. Langkah penyempurnaan menyempurnakan semua parameter model untuk meminimalkan kesalahan prediksi pada data masukan dan mengembalikan model yang telah disempurnakan.

Mirip dengan tugas klasifikasi teks, dataset (SQuAD2.0) dibagi menjadi set pelatihan, validasi, dan pengujian.

Selanjutnya, kami menentukan hyperparameter model, dan menggunakan API JumpStart untuk memicu pekerjaan fine-tuning:

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)

Setelah pekerjaan penyempurnaan selesai, kami menerapkan model, menjalankan inferensi pada kumpulan data uji tahan, dan menghitung metrik evaluasi. Metrik evaluasi yang digunakan adalah rata-rata skor pencocokan tepat dan rata-rata skor F1. Tangkapan layar berikut menunjukkan hasilnya.

Tingkatkan lebih lanjut kinerja penyempurnaan dengan penyetelan model otomatis SageMaker

Mirip dengan bagian sebelumnya, kami menggunakan a HyperparameterTuner objek untuk meluncurkan pekerjaan penyetelan:

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

Setelah tugas penyetelan selesai, kami menerapkan model yang memberikan skor metrik evaluasi terbaik pada set data validasi, melakukan inferensi pada set data uji tahan yang sama seperti yang kami lakukan di bagian sebelumnya, dan menghitung metrik evaluasi.

Kita dapat melihat bahwa model dengan HPO menunjukkan kinerja yang jauh lebih baik pada data uji bertahan.

Ekstraksi hubungan

Ekstraksi hubungan adalah tugas mengekstraksi hubungan semantik dari teks, yang biasanya terjadi antara dua entitas atau lebih. Ekstraksi hubungan memainkan peran penting dalam mengekstraksi informasi terstruktur dari sumber tidak terstruktur seperti teks mentah. Dalam buku catatan ini, kami mendemonstrasikan dua kasus penggunaan ekstraksi relasi.

Sempurnakan model yang telah dilatih sebelumnya pada kumpulan data khusus

Kami menggunakan model ekstraksi hubungan yang dibangun di atas a BERT-basis-tanpa casing model menggunakan transformer dari Memeluk Transformer Wajah Perpustakaan. Model untuk penyempurnaan melampirkan lapisan klasifikasi linier yang mengambil sepasang penyematan token yang dihasilkan oleh model penyematan teks dan menginisialisasi parameter lapisan ke nilai acak. Langkah penyempurnaan menyempurnakan semua parameter model untuk meminimalkan kesalahan prediksi pada data masukan dan mengembalikan model yang telah disempurnakan.

Dataset yang kami sempurnakan adalah modelnya SemEval-2010 Tugas 8. Model yang dikembalikan dengan fine-tuning dapat digunakan lebih lanjut untuk inferensi.

Dataset berisi set pelatihan, validasi, dan pengujian.

Kami menggunakan AWS PyTorch DLC dengan mode skrip dari SageMaker Python SDK, di mana transformers perpustakaan diinstal sebagai ketergantungan di atas wadah. Kami mendefinisikan SageMaker PyTorch estimator dan satu set hyperparameter seperti model pra-terlatih, kecepatan pembelajaran, dan nomor zaman untuk melakukan penyetelan halus. Kode untuk menyempurnakan model ekstraksi hubungan didefinisikan dalam entry_point.py. Lihat kode berikut:

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

Tingkatkan lebih lanjut kinerja penyempurnaan dengan penyetelan model otomatis SageMaker

Mirip dengan bagian sebelumnya, kami menggunakan a HyperparameterTuner objek untuk berinteraksi dengan API penyetelan hyperparameter SageMaker. Kita dapat memulai pekerjaan penyetelan hyperparameter dengan memanggil fit Metode:

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

Saat pekerjaan penyetelan hyperparameter selesai, kami melakukan inferensi dan memeriksa skor evaluasi.

Kita dapat melihat bahwa model dengan HPO menunjukkan performa yang lebih baik pada data uji hold-out.

Ringkasan dokumen

Peringkasan dokumen atau teks adalah tugas memadatkan data teks dalam jumlah besar menjadi subkumpulan kalimat bermakna yang lebih kecil yang mewakili informasi paling penting atau relevan dalam konten aslinya. Peringkasan dokumen adalah teknik yang berguna untuk menyaring informasi penting dari sejumlah besar data teks menjadi beberapa kalimat. Peringkasan teks digunakan dalam banyak kasus penggunaan, seperti pemrosesan dokumen dan penggalian informasi dari blog, artikel, dan berita.

Notebook ini mendemonstrasikan penerapan model peringkasan dokumen basis T5 dari Memeluk Transformer Wajah Perpustakaan. Kami juga menguji titik akhir yang diterapkan menggunakan artikel teks dan mengevaluasi hasilnya menggunakan metrik evaluasi bawaan Hugging Face RED.

Mirip dengan menjawab pertanyaan dan buku catatan NER, kami menggunakan PyTorchModel dari SageMaker Python SDK bersama dengan entry_point.py skrip untuk memuat model berbasis T5 ke titik akhir HTTPS. Setelah titik akhir berhasil diterapkan, kami dapat mengirimkan artikel teks ke titik akhir untuk mendapatkan respons prediksi:

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

Selanjutnya, kami mengevaluasi dan membandingkan artikel teks dan hasil ringkasan menggunakan metrik ROUGE. Tiga metrik evaluasi dihitung: rougeN, rougeL, dan rougeLsum. rougeN mengukur jumlah pencocokan n-grams antara teks yang dihasilkan model (hasil peringkasan) dan a reference (Masukkan teks). Metrik rougeL dan rougeLsum mengukur urutan kata yang paling cocok dengan mencari substring umum terpanjang dalam ringkasan yang dihasilkan dan referensi. Untuk setiap metrik, interval kepercayaan untuk skor presisi, daya ingat, dan F1 dihitung. Lihat kode berikut:

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

Membersihkan

Sumber daya yang dibuat untuk solusi ini dapat dihapus menggunakan Hapus semua sumber daya tombol dari SageMaker Studio IDE. Setiap notebook juga menyediakan bagian pembersihan dengan kode untuk menghapus titik akhir.

Kesimpulan

Dalam postingan ini, kami mendemonstrasikan cara menggunakan teknik ML yang canggih untuk menyelesaikan lima tugas NLP yang berbeda: peringkasan dokumen, klasifikasi teks, tanya jawab, pengenalan entitas bernama, dan ekstraksi hubungan menggunakan Jumpstart. Mulailah dengan Jumpstart sekarang!

Tentang Penulis

Dr Xin Huang adalah Ilmuwan Terapan untuk Amazon SageMaker JumpStart dan algoritma bawaan Amazon SageMaker. Dia berfokus pada pengembangan algoritme pembelajaran mesin yang dapat diskalakan. Minat penelitiannya adalah di bidang pemrosesan bahasa alami, pembelajaran mendalam yang dapat dijelaskan pada data tabular, dan analisis yang kuat dari pengelompokan ruang-waktu non-parametrik. Dia telah menerbitkan banyak makalah di ACL, ICDM, konferensi KDD, dan jurnal Royal Statistical Society: Series A.

Vivek Gangasani adalah Arsitek Solusi Pembelajaran Mesin Senior di Amazon Web Services. Dia membantu Startups membangun dan mengoperasionalkan aplikasi AI/ML. Dia saat ini fokus untuk menggabungkan latar belakangnya di Containers dan Machine Learning untuk memberikan solusi pada MLOps, Inferensi ML, dan ML kode rendah. Di waktu luangnya, dia menikmati mencoba restoran baru dan menjelajahi tren yang muncul dalam AI dan pembelajaran mendalam.

Geremy Cohen adalah Arsitek Solusi dengan AWS di mana dia membantu pelanggan membangun solusi mutakhir berbasis cloud. Di waktu luangnya, ia menikmati jalan-jalan singkat di pantai, menjelajahi daerah teluk bersama keluarganya, memperbaiki barang-barang di sekitar rumah, memecahkan barang-barang di sekitar rumah, dan BBQing.

Neelam Koshiya adalah arsitek solusi perusahaan di AWS. Fokusnya saat ini adalah membantu pelanggan perusahaan dengan perjalanan adopsi cloud mereka untuk hasil bisnis strategis. Di waktu luangnya, ia menikmati membaca dan berada di luar.