Terapkan model dasar dengan Amazon SageMaker, ulangi dan pantau dengan TruEra | Layanan Web Amazon

Blog ini ditulis bersama Josh Reini, Shayak Sen dan Anupam Datta dari TruEra

Mulai Lompatan Amazon SageMaker menyediakan berbagai model pondasi terlatih seperti Llama-2 dan Mistal 7B yang dapat dengan cepat diterapkan ke titik akhir. Model dasar ini bekerja dengan baik dalam tugas generatif, mulai dari menyusun teks dan ringkasan, menjawab pertanyaan, hingga memproduksi gambar dan video. Meskipun model ini memiliki kemampuan generalisasi yang hebat, sering kali ada kasus penggunaan di mana model ini harus disesuaikan dengan tugas atau domain baru. Salah satu cara untuk mengungkapkan kebutuhan ini adalah dengan mengevaluasi model berdasarkan kumpulan data kebenaran dasar yang telah dikurasi. Setelah kebutuhan untuk mengadaptasi model pondasi jelas, Anda dapat menggunakan serangkaian teknik untuk melaksanakannya. Pendekatan yang populer adalah menyempurnakan model menggunakan kumpulan data yang disesuaikan dengan kasus penggunaan. Penyempurnaan dapat meningkatkan model dasar dan efektivitasnya dapat diukur kembali berdasarkan kumpulan data kebenaran dasar. Ini buku catatan menunjukkan cara menyempurnakan model dengan SageMaker JumpStart.

Salah satu tantangan dalam pendekatan ini adalah pembuatan kumpulan data kebenaran dasar yang dikurasi memerlukan biaya yang mahal. Dalam postingan ini, kami mengatasi tantangan ini dengan melengkapi alur kerja ini dengan kerangka kerja untuk evaluasi otomatis yang dapat diperluas. Kami memulai dengan model landasan dasar dari SageMaker JumpStart dan mengevaluasinya Lensa Tru, perpustakaan sumber terbuka untuk mengevaluasi dan melacak aplikasi model bahasa besar (LLM). Setelah kami mengidentifikasi kebutuhan adaptasi, kami dapat menggunakan penyesuaian di SageMaker JumpStart dan mengonfirmasi peningkatan dengan TruLens.

Evaluasi TruLens menggunakan abstraksi fungsi umpan balik. Fungsi-fungsi ini dapat diimplementasikan dalam beberapa cara, termasuk model gaya BERT, LLM yang diminta dengan tepat, dan banyak lagi. Integrasi TruLens dengan Batuan Dasar Amazon memungkinkan Anda menjalankan evaluasi menggunakan LLM yang tersedia dari Amazon Bedrock. Keandalan infrastruktur Amazon Bedrock sangat berharga untuk digunakan dalam melakukan evaluasi di seluruh pengembangan dan produksi.

Posting ini berfungsi sebagai pengenalan tempat TruEra di tumpukan aplikasi LLM modern dan panduan praktis untuk menggunakan Amazon SageMaker dan TrueEra untuk menyebarkan, menyempurnakan, dan mengulangi aplikasi LLM. Ini selengkapnya buku catatan dengan contoh kode untuk menunjukkan evaluasi kinerja menggunakan TruLens

TruEra di tumpukan aplikasi LLM

TruEra berada di lapisan observabilitas aplikasi LLM. Meskipun komponen-komponen baru telah masuk ke dalam lapisan komputasi (penyempurnaan, rekayasa cepat, API model) dan lapisan penyimpanan (database vektor), kebutuhan akan kemampuan observasi tetap ada. Kebutuhan ini mencakup pengembangan hingga produksi dan memerlukan kemampuan yang saling berhubungan untuk pengujian, debugging, dan pemantauan produksi, seperti yang diilustrasikan dalam gambar berikut.

Dalam pengembangan, Anda dapat menggunakan TruLens sumber terbuka untuk mengevaluasi, men-debug, dan mengulangi aplikasi LLM di lingkungan Anda dengan cepat. Rangkaian metrik evaluasi yang komprehensif, termasuk metrik berbasis LLM dan metrik tradisional yang tersedia di TruLens, memungkinkan Anda mengukur aplikasi berdasarkan kriteria yang diperlukan untuk memindahkan aplikasi ke produksi.

Dalam produksi, log dan metrik evaluasi ini dapat diproses dalam skala besar dengan pemantauan produksi TruEra. Dengan menghubungkan pemantauan produksi dengan pengujian dan debugging, penurunan kinerja seperti halusinasi, keselamatan, keamanan, dan banyak lagi dapat diidentifikasi dan diperbaiki.

Terapkan model dasar di SageMaker

Anda dapat menerapkan model dasar seperti Llama-2 di SageMaker hanya dengan dua baris kode Python:

from sagemaker.jumpstart.model import JumpStartModel
pretrained_model = JumpStartModel(model_id="meta-textgeneration-llama-2-7b")
pretrained_predictor = pretrained_model.deploy()

Panggil titik akhir model

Setelah penerapan, Anda dapat memanggil titik akhir model yang diterapkan dengan terlebih dahulu membuat payload yang berisi input dan parameter model Anda:

payload = {
    "inputs": "I believe the meaning of life is",
    "parameters": {
        "max_new_tokens": 64,
        "top_p": 0.9,
        "temperature": 0.6,
        "return_full_text": False,
    },
}

Kemudian Anda cukup meneruskan payload ini ke metode prediksi titik akhir. Perhatikan bahwa Anda harus meneruskan atribut untuk menerima perjanjian lisensi pengguna akhir setiap kali Anda memanggil model:

response = pretrained_predictor.predict(payload, custom_attributes="accept_eula=true")

Evaluasi kinerja dengan TruLens

Sekarang Anda dapat menggunakan TruLens untuk menyiapkan evaluasi Anda. TruLens adalah alat observasi, menawarkan serangkaian fungsi umpan balik yang dapat diperluas untuk melacak dan mengevaluasi aplikasi yang didukung LLM. Fungsi umpan balik sangat penting di sini untuk memverifikasi tidak adanya halusinasi di aplikasi. Fungsi umpan balik ini diterapkan dengan menggunakan model siap pakai dari penyedia seperti Amazon Bedrock. Model Amazon Bedrock merupakan keunggulan di sini karena kualitas dan keandalannya yang terverifikasi. Anda dapat mengatur penyedia dengan TruLens melalui kode berikut:

from trulens_eval import Bedrock
# Initialize AWS Bedrock feedback function collection class:
provider = Bedrock(model_id = "amazon.titan-tg1-large", region_name="us-east-1")

Dalam contoh ini, kami menggunakan tiga fungsi umpan balik: relevansi jawaban, relevansi konteks, dan landasan. Evaluasi ini dengan cepat menjadi standar untuk deteksi halusinasi dalam aplikasi penjawab pertanyaan yang mendukung konteks dan sangat berguna untuk aplikasi tanpa pengawasan, yang mencakup sebagian besar aplikasi LLM saat ini.

Mari kita bahas masing-masing fungsi umpan balik ini untuk memahami manfaatnya bagi kita.

Relevansi konteks

Konteks adalah masukan penting terhadap kualitas respons aplikasi kita, dan akan berguna untuk memastikan secara terprogram bahwa konteks yang diberikan relevan dengan kueri masukan. Hal ini penting karena konteks ini akan digunakan oleh LLM untuk membentuk jawaban, sehingga informasi yang tidak relevan dalam konteks tersebut dapat dijalin menjadi halusinasi. TruLens memungkinkan Anda mengevaluasi relevansi konteks dengan menggunakan struktur rekaman serial:

f_context_relevance = (Feedback(provider.relevance, name = "Context Relevance")
                       .on(Select.Record.calls[0].args.args[0])
                       .on(Select.Record.calls[0].args.args[1])
                      )

Karena konteks yang diberikan kepada LLM adalah langkah paling penting dalam alur Retrieval Augmented Generation (RAG), relevansi konteks sangat penting untuk memahami kualitas pengambilan. Saat bekerja dengan pelanggan lintas sektor, kami telah melihat berbagai mode kegagalan yang diidentifikasi menggunakan evaluasi ini, seperti konteks yang tidak lengkap, konteks yang tidak relevan, atau bahkan kurangnya konteks yang tersedia. Dengan mengidentifikasi sifat mode kegagalan ini, pengguna kami dapat menyesuaikan pengindeksan mereka (seperti model penyematan dan pengelompokan) dan strategi pengambilan (seperti jendela kalimat dan penggabungan otomatis) untuk mengurangi masalah ini.

membumi

Setelah konteks diambil, kemudian dibentuk menjadi jawaban oleh LLM. LLM sering kali cenderung menyimpang dari fakta yang diberikan, melebih-lebihkan atau memperluas jawaban yang terdengar benar. Untuk memverifikasi kebenaran permohonan, Anda harus memisahkan respons ke dalam pernyataan terpisah dan secara independen mencari bukti yang mendukung masing-masing pernyataan dalam konteks yang diambil.

grounded = Groundedness(groundedness_provider=provider)

f_groundedness = (Feedback(grounded.groundedness_measure, name = "Groundedness")
                .on(Select.Record.calls[0].args.args[1])
                .on_output()
                .aggregate(grounded.grounded_statements_aggregator)
            )

Permasalahan yang bersifat membumi seringkali merupakan dampak hilir dari relevansi konteks. Ketika LLM tidak memiliki konteks yang memadai untuk membentuk respons berbasis bukti, LLM cenderung berhalusinasi dalam upaya menghasilkan respons yang masuk akal. Bahkan dalam kasus di mana konteks yang lengkap dan relevan diberikan, LLM dapat terjerumus ke dalam masalah yang bersifat membumi. Khususnya, hal ini terjadi dalam aplikasi di mana LLM merespons dengan gaya tertentu atau digunakan untuk menyelesaikan tugas yang tidak cocok untuknya. Evaluasi landasan memungkinkan pengguna TruLens untuk memecah respons LLM klaim demi klaim untuk memahami di mana LLM paling sering berhalusinasi. Melakukan hal ini terbukti sangat berguna untuk menjelaskan jalan ke depan dalam menghilangkan halusinasi melalui perubahan sisi model (seperti dorongan, pilihan model, dan parameter model).

Relevansi jawaban

Terakhir, responsnya masih perlu menjawab pertanyaan awal dengan membantu. Anda dapat memverifikasi ini dengan mengevaluasi relevansi respons akhir terhadap masukan pengguna:

f_answer_relevance = (Feedback(provider.relevance, name = "Answer Relevance")
                      .on(Select.Record.calls[0].args.args[0])
                      .on_output()
                      )

Dengan mencapai evaluasi yang memuaskan untuk triad ini, Anda dapat membuat pernyataan yang berbeda tentang kebenaran aplikasi Anda; aplikasi ini diverifikasi bebas halusinasi hingga batas basis pengetahuannya. Dengan kata lain, jika database vektor hanya berisi informasi akurat, maka jawaban yang diberikan oleh aplikasi penjawab pertanyaan berkemampuan konteks juga akurat.

Evaluasi kebenaran dasar

Selain fungsi umpan balik untuk mendeteksi halusinasi, kami memiliki kumpulan data pengujian, DataBricks-Dolly-15k, yang memungkinkan kami menambahkan kesamaan kebenaran dasar sebagai metrik evaluasi keempat. Lihat kode berikut:

from datasets import load_dataset

dolly_dataset = load_dataset("databricks/databricks-dolly-15k", split="train")

# To train for question answering/information extraction, you can replace the assertion in next line to example["category"] == "closed_qa"/"information_extraction".
summarization_dataset = dolly_dataset.filter(lambda example: example["category"] == "summarization")
summarization_dataset = summarization_dataset.remove_columns("category")

# We split the dataset into two where test data is used to evaluate at the end.
train_and_test_dataset = summarization_dataset.train_test_split(test_size=0.1)

# Rename columns
test_dataset = pd.DataFrame(test_dataset)
test_dataset.rename(columns={"instruction": "query"}, inplace=True)

# Convert DataFrame to a list of dictionaries
golden_set = test_dataset[["query","response"]].to_dict(orient='records')

# Create a Feedback object for ground truth similarity
ground_truth = GroundTruthAgreement(golden_set)
# Call the agreement measure on the instruction and output
f_groundtruth = (Feedback(ground_truth.agreement_measure, name = "Ground Truth Agreement")
                 .on(Select.Record.calls[0].args.args[0])
                 .on_output()
                )

Bangun aplikasinya

Setelah Anda menyiapkan evaluator, Anda dapat membangun aplikasi Anda. Dalam contoh ini, kami menggunakan aplikasi QA yang mendukung konteks. Dalam aplikasi ini, berikan instruksi dan konteks ke mesin penyelesaian:

def base_llm(instruction, context):
    # For instruction fine-tuning, we insert a special key between input and output
    input_output_demarkation_key = "nn### Response:n"
    payload = {
        "inputs": template["prompt"].format(
            instruction=instruction, context=context
        )
        + input_output_demarkation_key,
        "parameters": {"max_new_tokens": 200},
    }
    
    return pretrained_predictor.predict(
        payload, custom_attributes="accept_eula=true"
    )[0]["generation"]

Setelah Anda membuat aplikasi dan fungsi umpan balik, Anda dapat dengan mudah membuat aplikasi terbungkus dengan TruLens. Aplikasi yang dibungkus ini, yang kami beri nama base_recorder, akan mencatat dan mengevaluasi aplikasi setiap kali dipanggil:

base_recorder = TruBasicApp(base_llm, app_id="Base LLM", feedbacks=[f_groundtruth, f_answer_relevance, f_context_relevance, f_groundedness])

for i in range(len(test_dataset)):
    with base_recorder as recording:
        base_recorder.app(test_dataset["query"][i], test_dataset["context"][i])

Hasil dengan basis Llama-2

Setelah Anda menjalankan aplikasi pada setiap catatan dalam kumpulan data pengujian, Anda dapat melihat hasilnya di buku catatan SageMaker Anda dengan tru.get_leaderboard(). Tangkapan layar berikut menunjukkan hasil evaluasi. Relevansi jawaban sangat rendah, yang menunjukkan bahwa model kesulitan untuk mengikuti instruksi yang diberikan secara konsisten.

Sempurnakan Llama-2 menggunakan SageMaker Jumpstart

Langkah-langkah untuk menyempurnakan model Llama-2 menggunakan SageMaker Jumpstart juga disediakan di sini buku catatan.

Untuk menyiapkan penyesuaian, Anda perlu mengunduh set pelatihan terlebih dahulu dan menyiapkan templat untuk mendapatkan petunjuk

# Dumping the training data to a local file to be used for training.
train_and_test_dataset["train"].to_json("train.jsonl")

import json

template = {
    "prompt": "Below is an instruction that describes a task, paired with an input that provides further context. "
    "Write a response that appropriately completes the request.nn"
    "### Instruction:n{instruction}nn### Input:n{context}nn",
    "completion": " {response}",
}
with open("template.json", "w") as f:
    json.dump(template, f)

Kemudian, unggah kumpulan data dan instruksi ke Layanan Penyimpanan Sederhana Amazon Bucket (Amazon S3) untuk pelatihan:

from sagemaker.s3 import S3Uploader
import sagemaker
import random

output_bucket = sagemaker.Session().default_bucket()
local_data_file = "train.jsonl"
train_data_location = f"s3://{output_bucket}/dolly_dataset"
S3Uploader.upload(local_data_file, train_data_location)
S3Uploader.upload("template.json", train_data_location)
print(f"Training data: {train_data_location}")

Untuk menyempurnakan SageMaker, Anda dapat menggunakan SageMaker JumpStart Estimator. Kami kebanyakan menggunakan hyperparameter default di sini, kecuali kami menyetel penyetelan instruksi ke true:

from sagemaker.jumpstart.estimator import JumpStartEstimator

estimator = JumpStartEstimator(
    model_id=model_id,
    environment={"accept_eula": "true"},
    disable_output_compression=True,  # For Llama-2-70b, add instance_type = "ml.g5.48xlarge"
)
# By default, instruction tuning is set to false. Thus, to use instruction tuning dataset you use
estimator.set_hyperparameters(instruction_tuned="True", epoch="5", max_input_length="1024")
estimator.fit({"training": train_data_location})

Setelah melatih model, Anda dapat menerapkannya dan membuat aplikasi seperti yang Anda lakukan sebelumnya:

finetuned_predictor = estimator.deploy()

def finetuned_llm(instruction, context):
    # For instruction fine-tuning, we insert a special key between input and output
    input_output_demarkation_key = "nn### Response:n"
    payload = {
        "inputs": template["prompt"].format(
            instruction=instruction, context=context
        )
        + input_output_demarkation_key,
        "parameters": {"max_new_tokens": 200},
    }
    
    return finetuned_predictor.predict(
        payload, custom_attributes="accept_eula=true"
    )[0]["generation"]

finetuned_recorder = TruBasicApp(finetuned_llm, app_id="Finetuned LLM", feedbacks=[f_groundtruth, f_answer_relevance, f_context_relevance, f_groundedness])

Evaluasi model yang telah disesuaikan

Anda dapat menjalankan model itu lagi pada set pengujian Anda dan melihat hasilnya, kali ini dibandingkan dengan basis Llama-2:

for i in range(len(test_dataset)):
    with finetuned_recorder as recording:
        finetuned_recorder.app(test_dataset["query"][i], test_dataset["context"][i])

tru.get_leaderboard(app_ids=[‘Base LLM’,‘Finetuned LLM’])

Model Llama-2 yang baru dan telah disempurnakan telah mengalami peningkatan besar dalam hal relevansi dan landasan jawaban, serta kemiripannya dengan rangkaian pengujian kebenaran dasar. Peningkatan kualitas yang besar ini mengakibatkan sedikit peningkatan latensi. Peningkatan latensi ini merupakan akibat langsung dari penyempurnaan peningkatan ukuran model.

Anda tidak hanya dapat melihat hasil ini di buku catatan, namun Anda juga dapat menjelajahi hasil di UI TruLens dengan menjalankan tru.run_dashboard(). Melakukan hal ini dapat memberikan hasil agregat yang sama pada halaman papan peringkat, namun juga memberi Anda kemampuan untuk menyelami lebih dalam catatan bermasalah dan mengidentifikasi mode kegagalan aplikasi.

Untuk memahami peningkatan aplikasi pada tingkat rekor, Anda dapat berpindah ke halaman evaluasi dan memeriksa skor masukan pada tingkat yang lebih terperinci.

Misalnya, jika Anda menanyakan pertanyaan kepada LLM dasar, “Apa mesin flat six Porsche yang paling bertenaga”, model tersebut akan berhalusinasi sebagai berikut.

Selain itu, Anda dapat memeriksa evaluasi terprogram dari catatan ini untuk memahami kinerja aplikasi terhadap setiap fungsi umpan balik yang telah Anda tetapkan. Dengan memeriksa hasil umpan balik groundedness di TruLens, Anda dapat melihat rincian bukti yang tersedia untuk mendukung setiap klaim yang dibuat oleh LLM.

Jika Anda mengekspor rekaman yang sama untuk LLM yang telah Anda sesuaikan di TruLens, Anda dapat melihat bahwa penyesuaian dengan SageMaker JumpStart secara signifikan meningkatkan landasan respons.

Dengan menggunakan alur kerja evaluasi otomatis dengan TruLens, Anda dapat mengukur aplikasi Anda di serangkaian metrik yang lebih luas untuk lebih memahami kinerjanya. Yang penting, Anda sekarang dapat memahami kinerja ini secara dinamis untuk kasus penggunaan apa pun—bahkan kasus penggunaan yang belum Anda kumpulkan kebenaran dasarnya.

Cara kerja TruLens

Setelah membuat prototipe aplikasi LLM, Anda dapat mengintegrasikan TruLens (ditampilkan sebelumnya) untuk melengkapi tumpukan panggilannya. Setelah tumpukan panggilan diinstrumentasi, tumpukan panggilan tersebut kemudian dapat dicatat setiap kali dijalankan ke database logging yang ada di lingkungan Anda.

Selain kemampuan instrumentasi dan logging, evaluasi adalah komponen nilai inti bagi pengguna TruLens. Evaluasi ini diterapkan di TruLens melalui fungsi umpan balik untuk dijalankan di atas tumpukan panggilan terinstrumentasi Anda, dan pada gilirannya memanggil penyedia model eksternal untuk menghasilkan umpan balik itu sendiri.

Setelah inferensi umpan balik, hasil umpan balik ditulis ke database logging, dari mana Anda dapat menjalankan dasbor TruLens. Dasbor TruLens, yang berjalan di lingkungan Anda, memungkinkan Anda menjelajahi, mengulangi, dan men-debug aplikasi LLM Anda.

Dalam skala besar, catatan dan evaluasi ini dapat dikirim ke TruEra kemampuan observasi produksi yang dapat memproses jutaan pengamatan dalam satu menit. Dengan menggunakan Platform Observabilitas TruEra, Anda dapat dengan cepat mendeteksi halusinasi dan masalah kinerja lainnya, dan memperbesar satu catatan dalam hitungan detik dengan diagnostik terintegrasi. Beralih ke sudut pandang diagnostik memungkinkan Anda dengan mudah mengidentifikasi dan memitigasi mode kegagalan untuk aplikasi LLM Anda seperti halusinasi, kualitas pengambilan yang buruk, masalah keamanan, dan banyak lagi.

Evaluasi tanggapan yang jujur, tidak berbahaya, dan bermanfaat

Dengan mencapai evaluasi yang memuaskan untuk triad ini, Anda dapat mencapai tingkat keyakinan yang lebih tinggi terhadap kebenaran tanggapan yang diberikan. Selain kebenarannya, TruLens memiliki dukungan luas untuk evaluasi yang diperlukan untuk memahami kinerja LLM Anda pada poros “Jujur, Tidak Berbahaya, dan Bermanfaat.” Pengguna kami mendapat banyak manfaat dari kemampuan untuk mengidentifikasi tidak hanya halusinasi seperti yang telah kita bahas sebelumnya, namun juga masalah terkait keselamatan, keamanan, kecocokan bahasa, koherensi, dan banyak lagi. Ini semua adalah masalah dunia nyata yang dihadapi pengembang aplikasi LLM, dan dapat diidentifikasi langsung dengan TruLens.

Kesimpulan

Postingan ini membahas bagaimana Anda dapat mempercepat produksi aplikasi AI dan menggunakan model dasar di organisasi Anda. Dengan SageMaker JumpStart, Amazon Bedrock, dan TruEra, Anda dapat menerapkan, menyempurnakan, dan melakukan iterasi pada model dasar untuk aplikasi LLM Anda. Lihat ini link untuk mengetahui lebih lanjut tentang TruEra dan mencoba  buku catatan dirimu sendiri.

Tentang penulis

Josh Reini adalah kontributor inti TruLens sumber terbuka dan Ilmuwan Data Hubungan Pengembang pendiri di TruEra di mana dia bertanggung jawab atas inisiatif pendidikan dan membina komunitas praktisi Kualitas AI yang berkembang.

Shayak Sen adalah CTO & Salah Satu Pendiri TruEra. Shayak fokus membangun sistem dan memimpin penelitian untuk membuat sistem pembelajaran mesin lebih mudah dijelaskan, mematuhi privasi, dan adil.

Anupam Datta adalah Salah Satu Pendiri, Presiden, dan Kepala Ilmuwan TruEra. Sebelum TruEra, ia menghabiskan 15 tahun di fakultas di Carnegie Mellon University (2007-22), terakhir sebagai Profesor tetap di bidang Teknik Elektro & Komputer dan Ilmu Komputer.

Vivek Gangasani adalah Arsitek Solusi Startup AI/ML untuk startup AI Generatif di AWS. Dia membantu startup GenAI yang sedang berkembang membangun solusi inovatif menggunakan layanan AWS dan akselerasi komputasi. Saat ini, dia fokus pada pengembangan strategi untuk menyempurnakan dan mengoptimalkan kinerja inferensi Model Bahasa Besar. Di waktu luangnya, Vivek menikmati hiking, menonton film, dan mencoba berbagai masakan.

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• PlatoData.Jaringan Vertikal Generatif Ai. Berdayakan Diri Anda. Akses Di Sini.
• PlatoAiStream. Intelijen Web3. Pengetahuan Diperkuat. Akses Di Sini.
• PlatoESG. Karbon, teknologi bersih, energi, Lingkungan Hidup, Tenaga surya, Penanganan limbah. Akses Di Sini.
• PlatoHealth. Kecerdasan Uji Coba Biotek dan Klinis. Akses Di Sini.
• Sumber: https://aws.amazon.com/blogs/machine-learning/deploy-foundation-models-with-amazon-sagemaker-iterate-and-monitor-with-truera/