Dalam tutorial ini, kita akan melakukan prompt tuning terhadap Model IBM Granite menggunakan kumpulan data sintetis yang berisi ulasan pelanggan tentang bisnis perawatan anjing.
Penyetelan prompt adalah cara yang efisien dan murah untuk mengadaptasi model dasar kecerdasan buatan (AI) ke berbagai tugas hilir baru tanpa melatih ulang seluruh model dan memperbarui bobotnya.
Model dasar dibangun berdasarkan model bahasa besar (large language model, LLM) dan menerima sejumlah besar data pelatihan. Contoh penggunaan model dasar meliputi chatbot dan asisten virtual.
Ada beberapa cara untuk meningkatkan penafsiran input model dasar dan kualitas responsnya. Untuk lebih memahami nuansa ini, mari kita bandingkan beberapa metode.
- Rekayasa prompt adalah optimalisasi respons model terlatih dengan menyediakan prompt yang dirancang dengan baik. Tidak ada input data baru pada teknik ini, dan model tetap bersifat apa adanya. Dengan metode ini, model akan menerima prompt input dan prompt yang telah direkayasa di depannya. Sebagai contoh, Anda dapat menggunakan prompt: "Translate English to Spanish", dengan input: "good morning". Metode ini membutuhkan upaya ekstra dari pengguna. Namun, upaya manual manusia dalam merumuskan prompt yang efektif dapat membantu model AI generatif menghasilkan respons untuk tugas tertentu tanpa harus melatih ulang keseluruhan model dasar.
- Menyempurnakan model bahasa besar melibatkan penyempurnaan model yang sama dengan memberikan kumpulan data berlabel dalam jumlah besar. Penyempurnaan akan mengubah bobot model dan membuatnya sulit untuk dikelola karena tugas menjadi beragam. Ini membutuhkan sejumlah besar sumber daya komputasi. Pada gilirannya, metode ini cenderung memiliki akurasi terbaik karena model dapat dilatih untuk contoh penggunaan yang sangat spesifik.
- Berbeda dengan fine-tuning, prompt tuning tidak mengubah bobot model terlatih. Sebaliknya, teknik ini efisien untuk parameter, karena dapat menyesuaikan parameter prompt untuk memandu respons model ke arah yang diinginkan. Model ini dilengkapi dengan input dan soft prompt yang dapat di-tuning yang dihasilkan oleh AI itu sendiri. Konteks spesifik tugas ini memandu model besar untuk menyesuaikan responsnya terhadap tugas yang sempit, bahkan dengan data terbatas.
- Sama halnya dengan prompt tuning, pada prefix-tuning, model menerima beberapa contoh output yang disukai. Perbedaannya di sini adalah bahwa awalan atau prefix, yakni serangkaian vektor spesifik tugas, juga disertakan. Prefix-tuning menggunakan soft prompt dan prompt yang diinjeksikan ke lapisan model pembelajaran mendalam. "Token virtual" ini memberikan fleksibilitas bagi model yang di-tuning untuk mendukung berbagai tugas baru sekaligus. Metode ini mencapai kinerja serupa dengan proses fine-tuning semua lapisan, dan hanya melatih sekitar 0,1% dari parameter. Prefix-tuning bahkan mengungguli fine-tuning dalam hal pengaturan data rendah.
Prompt keras adalah buatan pengguna dan membutuhkan tindakan pengguna. Prompt keras dapat dianggap sebagai templat atau instruksi bagi LLM untuk menghasilkan respons. Bagian berikut ini menjelaskan contoh prompt keras. Kami sarankan Anda untuk melihat halaman Dokumentasi IBM untuk informasi lebih lanjut tentang jenis prompt ini dan beberapa jenis lainnya.
hard_prompt_template = """Generate a summary of the context that answers the question. Explain the answer in multiple steps if possible.
Answer style should match the context. Ideal Answer length is 2-3 sentences.\n\n{context}\nQuestion: {question}\nAnswer:
"""
Dengan menggunakan templat prompt keras ini, LLM bisa mendapatkan instruksi spesifik mengenai struktur dan gaya output yang diinginkan. Melalui prompt eksplisit ini, LLM kemungkinan besar akan menghasilkan respons yang diinginkan dengan kualitas yang lebih tinggi.
Prompt lunak, tidak seperti prompt keras, tidak ditulis dalam bahasa alami. Sebaliknya, prompt diawali sebagai vektor numerik buatan AI yang ditambahkan ke awal setiap penyematan input yang menyaring pengetahuan dari model yang lebih besar. Kurangnya interpretabilitas ini meluas ke AI yang memilih prompt yang dioptimalkan untuk tugas tertentu. AI sering kali tidak dapat menjelaskan mengapa ia memilih penanaman tersebut. Dibandingkan dengan metode prompting lainnya, token virtual ini tidak terlalu mahal dari segi komputasi dibandingkan dengan penyempurnaan karena model itu sendiri tetap tidak berubah dengan bobot yang tetap. Prompt lunak juga cenderung mengungguli prompt keras yang dibuat oleh manusia.
Kita akan menggunakan soft prompt untuk melakukan prompt tuning dalam tutorial ini.
Anda memerlukan akun IBM Cloud untuk membuat proyek watsonx.ai .
Langkah 1. Siapkan lingkungan Anda
Meskipun tersedia beberapa pilihan alat, tutorial ini akan memandu Anda menyiapkan akun IBM menggunakan Jupyter Notebook.
Masuk ke watsonx.ai menggunakan akun IBM Cloud Anda.
Buat proyek watsonx.ai.
Anda bisa mendapatkan ID proyek dari dalam proyek Anda. Klik tab Kelola . Kemudian, salin ID proyek dari bagian Detail di halaman Umum . Anda memerlukan ID ini untuk tutorial ini.
Buat Jupyter Notebook.
Langkah ini akan membuka lingkungan Notebook di mana Anda dapat menyalin kode dari tutorial ini untuk mengimplementasikan penyetelan prompt secara mandiri. Atau, Anda dapat mengunduh notebook ini ke sistem lokal Anda dan mengunggahnya ke proyek watsonx.ai Anda sebagai aset. Aplikasi Jupyter Notebook ini bersama dengan kumpulan data yang digunakan dapat ditemukan di GitHub.
Langkah 2. Siapkan instans watsonx.ai Runtime dan kunci API
Buat instans layanan watsonx.ai Runtime (pilih wilayah yang sesuai dan pilih paket Lite, yang merupakan instans gratis).
Buat Kunci API.
Tautkan instans layanan watsonx.ai Runtime ke proyek yang telah Anda buat di watsonx.ai.
Langkah 3. Instal dan impor perpustakaan yang relevan dan siapkan kredensial Anda
Kita membutuhkan beberapa pustaka dan modul untuk tutorial ini. Pastikan untuk mengimpor yang berikut ini; jika tidak diinstal, Anda dapat menyelesaikan masalah ini dengan instalasi pip cepat.
%pip install ibm-watsonx-ai | tail -n 1
%pip install pandas | tail -n 1
%pip install wget | tail -n 1
%pip install scikit-learn | tail -n 1
%pip install matplotlib | tail -n 1 #imports
import wget
import pandas as pd
from ibm_watsonx_ai import APIClient
from ibm_watsonx_ai.foundation_models.utils.enums import ModelTypes
from ibm_watsonx_ai.experiment import TuneExperiment
from ibm_watsonx_ai.helpers import DataConnection
from ibm_watsonx_ai.foundation_models import ModelInference
from sklearn.metrics import accuracy_score, f1_score
from datetime import datetime
Siapkan kredensial Anda. Masukkan kunci API dan ID proyek Anda.
"url": "https://us-south.ml.cloud.ibm.com",
"apikey": "YOUR_API_KEY_HERE"
}
project_id = "YOUR_PROJECT_ID_HERE"
Langkah 4. Tetapkan lingkungan dan impor kumpulan data
Sebagai langkah pertama dalam membangun lingkungan, buat instans APIClient dengan detail autentikasi Anda dan tetapkan project_id Anda.
client.set.default_project(project_id)
Output:
'SUCCESS'
Untuk tutorial ini, kita akan menggunakan kumpulan data sintetis yang terdiri dari ulasan bisnis perawatan anjing. Menggunakan URL yang sesuai, kita dapat menghubungkan kumpulan data tersebut ke klien API.
Anda dapat menggunakan kumpulan data apa pun yang disukai. Beberapa kumpulan data sumber terbuka tersedia di platform seperti HuggingFace.
url = "https://raw.githubusercontent.com/AnnaGutowska/think/main/tutorials/prompt-tuning-tutorial/" + train_filename
wget.download(url)
asset_details = client.data_assets.create(name=train_filename, file_path=train_filename)
asset_id = client.data_assets.get_id(asset_details)
Output:
Creating data asset...
SUCCESS
Output:
3b1db894-8d9e-428d-8fee-d96f328c7726
Untuk mendapatkan insight tentang pemformatan ulasan pelanggan ini, mari muat data ke dalam kerangka data Pandas dan cetak beberapa baris yang menunjukkan ulasan positif dan negatif. Output "1" menunjukkan ulasan positif dan "0" menunjukkan ulasan negatif.
df = pd.read_json(train_filename)
df[5:10]
Output:
Langkah 5. Setel model.
Kelas TuneExperiment digunakan untuk membuat eksperimen dan menjadwalkan tuning. Mari kita gunakan ini untuk menginisialisasi eksperimen dan menyiapkan model dasar, data pelatihan, dan parameter. Latihan prompt tuning ini bertujuan agar LLM menyesuaikan responsnya sesuai dengan peringkat kepuasan pelanggan yang diekstraksi dari kumpulan data. Ini adalah tugas klasifikasi, karena ulasan dapat diklasifikasikan sebagai positif ("1") atau negatif ("0").
Untuk tutorial ini, sebaiknya gunakan IBM Granite Model sebagai model bahasa besar untuk mencapai hasil yang serupa.
project_id=project_id
)
prompt_tuner = experiment.prompt_tuner(name="prompt tuning tutorial",
task_id=experiment.Tasks.CLASSIFICATION,
base_model="ibm/granite-3-8b-instruct",
accumulate_steps=16,
batch_size=8,
learning_rate=0.001,
max_input_tokens=128,
max_output_tokens=2,
num_epochs=12,
tuning_type=experiment.PromptTuningTypes.PT,
init_text="Extract the satisfaction from the comment. Return simple '1' for satisfied customer or '0' for unsatisfied. Comment:",
init_method="text",
verbalizer="classify {0, 1} {{input}}",
auto_update_model=True
)
Setelah menyiapkan eksperimen tuning, kita perlu menghubungkannya ke kumpulan data. Untuk ini, mari kita gunakan kelas DataConnection . Hal ini membutuhkan asset_id yang dihasilkan sebelumnya setelah memulai aset data dengan klien API.
Anda bebas menggunakan model AI apa pun pilihan Anda. Model dasar yang tersedia untuk penyetelan melalui watsonx dapat ditemukan di sini atau dengan menjalankan perintah berikut.
Output:
{'FLAN_T5_XL': 'google/flan-t5-xl', 'GRANITE_13B_INSTRUCT_V2': 'ibm/granite-13b-instruct-v2', 'LLAMA_2_13B_CHAT': 'meta-llama/llama-2-13b-chat'}
training_data_references=[data_conn],
background_mode=False)
Output:
##############################################
Running '20671f17-ff53-470b-9bfe-04318ecb91d9'
##############################################
pending......
running....................................................................................................................................
completed
Training of '20671f17-ff53-470b-9bfe-04318ecb91d9' finished successfully.
Langkah 6. Evaluasi hasil penyetelan.
Untuk memastikan penyetelan prompt telah selesai, kita dapat memeriksa statusnya. Jika status yang tertulis adalah apa pun selain "selesai," tunggu hingga penyetelan selesai sebelum melanjutkan.
print(status)
Output:
completed
Kita sekarang dapat mengambil ringkasan prompt tuning. Dalam ringkasan ini, Anda akan melihat nilai kerugian. Untuk setiap latihan yang dijalankan, fungsi kerugian mengukur perbedaan antara hasil yang diprediksi dan hasil aktual. Oleh karena itu, nilai kerugian yang lebih rendah lebih disukai.
Kami juga dapat menggambarkan kurva pembelajaran penyetelan model kami menggunakan fungsi plot_learning_curve(). Kurva miring ke bawah yang mendatar mendekati nol mengindikasikan bahwa model ini meningkatkan pembuatan output yang diharapkan. Untuk mempelajari lebih lanjut tentang menafsirkan grafik fungsi kerugian, lihat dokumentasi IBM watsonx yang relevan.
Output:
Plot kurva pembelajaran
Langkah 7. Terapkan model yang disetel.
Langkah penerapan model yang disetel ini sangat penting untuk menyelesaikan langkah selanjutnya dalam membandingkan kinerja model yang disetel dengan model sebelum penyetelan.
Catatan: SERVING_NAME diatur ke tanggal dan waktu saat ini karena harus berupa nilai unik.
meta_props = {
client.deployments.ConfigurationMetaNames.NAME: "PROMP TUNE DEPLOYMENT",
client.deployments.ConfigurationMetaNames.ONLINE: {},
client.deployments.ConfigurationMetaNames.SERVING_NAME : datetime.now().strftime('%Y_%m_%d_%H%M%S')
}
deployment_details = client.deployments.create(model_id, meta_props)
Output:
######################################################################################
Synchronous deployment creation for id: '6aa5dd5c-0cc4-44e0-9730-18303e88e14a' started
######################################################################################
initializing.......................
ready
-----------------------------------------------------------------------------------------------
Successfully finished deployment creation, deployment_id='24a97b84-47d0-4490-9f5f-21ed2376fdd6'
-----------------------------------------------------------------------------------------------
Langkah 8. Uji model yang sudah di-tuning.
Sekarang, mari kita uji kinerja model yang disetel dan model dasar asli untuk melihat dampak dari proses penyetelan kita. Pertama, mari kita muat kumpulan data pengujian. Kumpulan data ini harus merupakan bagian dari data yang tidak ada selama penyetelan. Kumpulan tes sering kali berukuran lebih kecil dari kumpulan pelatihan. Selain itu, setiap input dalam kumpulan data pengujian memiliki prompt sebagai awalan komentar pengguna.
url = "https://raw.githubusercontent.com/AnnaGutowska/think/main/tutorials/prompt-tuning-tutorial/" + test_filename
wget.download(url)
data = pd.read_json(test_filename)
Mari kita tampilkan sebagian kecil dari kumpulan data untuk lebih memahami strukturnya.
Output:
Setelah memuat kumpulan data pengujian, mari kita ekstrak input dan output.
satisfaction = list(data.output)
prompts_batch = ["\n".join([prompt]) for prompt in prompts]
Kita juga dapat mencetak contoh input dan output pengujian untuk lebih memahami cara kumpulan data diekstrak.
Output:
'Extract the satisfaction from the comment. Return simple 1 for satisfied customer or 0 for unsatisfied.\nComment: Long wait times.\nSatisfaction:\n'
Dalam contoh ini, prompt diberikan, dan diikuti oleh ulasan pelanggan tentang waktu tunggu yang lama. Pada akhirnya, kepuasan pelanggan adalah 0, yang menandakan ulasan negatif.
Output:
0
Setelah memiliki kumpulan data pengujian, mari kita uji akurasi dan skor F1 model yang sudah di-tuning. Skor F1 adalah rata-rata presisi dan daya ingat model. Kita membutuhkan deployment_id untuk melakukan ini. Perlu diingat, concurrency_limit ditetapkan ke 2 untuk menghindari batas tingkat API. Ini adalah jumlah permintaan yang akan dikirim secara paralel.
tuned_model = ModelInference(
deployment_id=deployment_id,
api_client=client
)
tuned_model_results = tuned_model.generate_text(prompt=prompts_batch, concurrency_limit=2)
print(f'accuracy_score: {accuracy_score(satisfaction, [int(float(x)) for x in tuned_model_results])}, f1_score: {f1_score(satisfaction, [int(float(x)) for x in tuned_model_results])}')
Output:
accuracy_score: 0.9827586206896551, f1_score: 0.9827586206896551
Mengingat akurasi tinggi model dan skor F1, mari kita uji kinerja model Granite yang sama tanpa penyetelan apa pun.
model_id="ibm/granite-3-8b-instruct",
api_client=client
)
base_model_results = base_model.generate_text(prompt=prompts_batch, concurrency_limit=2)
print(f'base model accuracy_score: {accuracy_score(satisfaction, [int(x) for x in base_model_results])}, base model f1_score: {f1_score(satisfaction, [int(x) for x in base_model_results])}')
Output:
accuracy_score model dasar: 0.9310344827586207, f1_score model dasar: 0.9298245614035088
Model yang disetel mengungguli model dasar yang telah dilatih. Karena model yang disetel mengkhususkan diri dalam mengekstrak skor kepuasan, model ini dapat digunakan untuk tugas ekstraksi kepuasan lainnya. Hebat!
Dalam tutorial ini, Anda telah melakukan prompt tuning pada model IBM Granite menggunakan watsonx API. Model yang telah di-tuning dan diterapkan berhasil mengungguli model dasar dengan akurasi sekitar 5% lebih besar.