Kursus
Mengembangkan Aplikasi LLM dengan LangChain
3 jam
51.9K
Ini masa yang menarik di dunia AI. Perusahaan besar seperti Google, Meta, dan Twitter sangat fokus membuat large language model (LLM) mereka bersifat open-source. Baru-baru ini, tim Google DeepMind meluncurkan Gemma—keluarga LLM yang ringan dan open-source, dibangun dari riset dan teknologi yang sama dengan yang digunakan untuk membuat model Gemini dari Google.
Gambar Sumber
Di sini, kita akan mempelajari model Gemma, cara mengaksesnya menggunakan GPU dan TPU cloud, serta cara melatih model Gemma 7b-it terbaru pada dataset role-play.
Memahami Gemma dari Google
Gemma (kata Latin untuk “batu mulia”) adalah keluarga model teks-ke-teks, decoder-only, yang terbuka dan dikembangkan oleh berbagai tim di Google, khususnya Google DeepMind. Model ini terinspirasi oleh model Gemini dan dirancang agar ringan serta kompatibel dengan semua kerangka kerja utama.
Google merilis bobot model untuk dua ukuran Gemma, yaitu Gemma 2B dan Gemma 7B, yang tersedia dalam varian pra-latih dan instruction-tuned seperti Gemma 2B-it dan Gemma 7B-it.
Seperti yang kita ketahui, Gemma berbagi komponen teknis serupa dengan Gemini, mencapai performa terbaik di kelasnya untuk ukurannya dibanding model open-source lain seperti Llama-2 dari Meta. Model ini melampaui Llama-2 pada semua tolok ukur LLM.
Gambar Sumber
Gemma mendukung beragam alat dan sistem, termasuk alat multi-framework seperti Keras 3.0, PyTorch native, JAX, dan Hugging Face Transformers. Model ini juga berjalan di berbagai jenis perangkat populer, termasuk laptop, desktop, IoT, seluler, dan cloud.
Anda kini dapat menjalankan inferensi dan supervised fine-tuning (SFT) pada Cloud TPU gratis menggunakan kerangka pembelajaran mesin favorit Anda seperti Keras 3.0.
Google juga memperkenalkan Responsible Generative AI Toolkit bersama Gemma untuk memberikan panduan, alat penting, dan metode klasifikasi keamanan agar pengembang dapat membuat aplikasi AI yang lebih aman.
Jika Anda baru di dunia AI dan LLM, disarankan untuk mengikuti jalur keterampilan AI Fundamentals. Ini akan membekali Anda dengan pengetahuan praktis tentang topik AI populer seperti ChatGPT, large language models, generative AI, dan lainnya.
Cara Mengakses Model Gemma dari Google
Mengakses Gemma sangat mudah; Anda dapat mulai menggunakannya secara gratis di HuggingChat dan Poe. Anda bahkan dapat menggunakannya secara lokal dengan mengunduh bobot model dari Hugging Face dan menggunakan GPT4ALL atau LMStudio.
Pada bagian ini, kita akan belajar memuat model Gemma dan menjalankan inferensi menggunakan GPU dan TPU gratis yang disediakan oleh platform Kaggle.
Menjalankan Inferensi Gemma di TPU
Anda dapat membuka Keras/Gemma, gulir ke bawah, pilih varian model “gemma_instruct_2b_en”, dan klik tombol “New Notebook”. Ini akan meluncurkan Cloud Notebook dengan model Gemma di direktori input.
Pilih akselerator “TPU VM v3-8” melalui panel kanan dan gulir ke bawah.
Pastikan Anda telah memasang dan memperbarui semua pustaka Python yang diperlukan.
!pip install -q tensorflow-cpu
!pip install -q -U keras-nlp tensorflow-hub
!pip install -q -U keras>=3
!pip install -q -U tensorflow-textUntuk memeriksa jumlah TPU yang tersedia, Anda dapat menggunakan pustaka `jax` dan fungsi `device` untuk menampilkan perangkat TPU. Kita memiliki akses ke 8 TPU.
import jax
jax.devices()[TpuDevice(id=0, process_index=0, coords=(0,0,0), core_on_chip=0),
TpuDevice(id=1, process_index=0, coords=(0,0,0), core_on_chip=1),
TpuDevice(id=2, process_index=0, coords=(1,0,0), core_on_chip=0),
TpuDevice(id=3, process_index=0, coords=(1,0,0), core_on_chip=1),
TpuDevice(id=4, process_index=0, coords=(0,1,0), core_on_chip=0),
TpuDevice(id=5, process_index=0, coords=(0,1,0), core_on_chip=1),
TpuDevice(id=6, process_index=0, coords=(1,1,0), core_on_chip=0),
TpuDevice(id=7, process_index=0, coords=(1,1,0), core_on_chip=1)]Sekarang kita akan mengaktifkan TPU untuk Keras 3 dengan mengatur `jax` sebagai backend Keras.
import os
os.environ["KERAS_BACKEND"] = "jax"Setelah penyiapan awal, mengakses model Gemma dan menghasilkan respons cukup mudah. Kita akan menggunakan pustaka `keras_nlp` untuk memuat model dari Kaggle lalu memberikan prompt ke fungsi `generate`.
import keras
import keras_nlp
model_name = "/kaggle/input/gemma/keras/gemma_instruct_2b_en/2"
gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset(model_name)
prompt = "Can you share an interesting fact about Leonardo da Vinci?"
gemma_lm.generate(prompt, max_length=100)Berikut hasilnya:
"Can you share an interesting fact about Leonardo da Vinci?\n\nSure, here's an interesting fact about Leonardo da Vinci:\n\nLeonardo da Vinci was born in a village called Vinci, Italy, which is now part of the city of Florence."
Anda dapat dengan mudah menjalankan notebook Kaggle (Gemma-2B-V2 Simple Inference on TPU) dan mulai menghasilkan respons menggunakan TPU gratis.
Menjalankan Inferensi Gemma di GPU
Sekarang, kita akan belajar menghasilkan respons menggunakan GPU dan menggunakan kerangka kerja transformer sebagai pengganti Keras.
Anda dapat membuka google/gemma, gulir ke bawah, pilih transformers, pilih varian model “7b-it”, dan klik tombol “New Notebook”. Ini akan meluncurkan Cloud Notebook dengan versi model Gemma yang tepat di direktori input.
Catatan: Anda bahkan dapat menggulir lebih jauh ke bawah halaman untuk mengakses bagian inferensi. Di sini, Anda dapat menguji semua jenis varian Gemma dengan memberikan prompt dan menghasilkan respons. Cepat dan praktis.
Di notebook baru, ubah judul lalu ubah akselerator ke GPT T4 x2.
Pasang dan perbarui semua paket Python yang diperlukan.
%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerateKita tidak dapat memuat seluruh model Gemma 7b-it di GPU Kaggle karena keterbatasan VRAM. Untuk mengatasinya, kita akan memuat model menggunakan kuantisasi 4-bit dengan konfigurasi tipe NF4 menggunakan BitsAndBytes. Juga, muat tokenizer.
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, AutoConfig
modelName = "/kaggle/input/gemma/transformers/7b-it/2"
bnbConfig = BitsAndBytesConfig(
load_in_4bit = True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained(
modelName,
device_map = "auto",
quantization_config=bnbConfig
)
tokenizer = AutoTokenizer.from_pretrained(modelName)Buat templat prompt sederhana dengan System, User, dan AI. Kita meminta model untuk menghasilkan kode untuk menampilkan pola bintang menggunakan Python.
Teruskan prompt final melalui tokenizer lalu ke model untuk menghasilkan prediksi. Kemudian kita dekode prediksi tersebut dan ubah respons menjadi string. Terakhir, kita gunakan fungsi Markdown untuk menampilkan respons dalam gaya Markdown.
from IPython.display import Markdown, display
system = "You are a skilled software engineer who consistently produces high-quality Python code."
user = "Write a Python code to display text in a star pattern."
prompt = f"System: {system} \n User: {user} \n AI: "
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")
outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)
text = tokenizer.decode(outputs[0], skip_special_tokens=True)
Markdown(text.split("AI:")[1])Seperti yang kita lihat, Gemma 7b-it bekerja dengan sangat baik.
Anda dapat menjalankan kodenya sendiri dengan mengkloning notebook Kaggle Gemma-7B Simple Inference on GPU.
Cara Fine-Tune Gemma dari Google: Panduan Langkah demi Langkah
Pada bagian ini, kita akan belajar melakukan fine-tuning model Gemma 7b-it pada dataset hieunguyenminh/roleplay. Kita akan menggunakan Kaggle GPU P100 sebagai akselerator.
Baca panduan kami, An Introductory Guide to Fine-Tuning LLMs, untuk memahami tiap langkah secara rinci.
Menyiapkan lingkungan
Penting untuk memasang dan memperbarui semua paket Python yang diperlukan agar terhindar dari error.
%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U peft
%pip install -U accelerate
%pip install -U trl
%pip install -U datasetsMuat semua paket yang akan kita gunakan untuk memuat dataset, model, dan tokenizer, serta melakukan supervised fine-tuning (SFT) dan inferensi.
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
BitsAndBytesConfig,
HfArgumentParser,
TrainingArguments,
pipeline,
logging,
)
from peft import (
LoraConfig,
PeftModel,
prepare_model_for_kbit_training,
get_peft_model,
)
import os, torch, wandb
from datasets import load_dataset
from trl import SFTTrainerTentukan nama untuk model dasar dan dataset, serta nama model hasil fine-tuning, yang nanti akan kita unggah ke Hugging Face Hub.
Variabel-variabel ini akan digunakan pada berbagai tahap, seperti memuat dataset dan model, tokenisasi, pelatihan, dan penyimpanan model.
base_model = "/kaggle/input/gemma/transformers/7b-it/2"
dataset_name = "hieunguyenminh/roleplay"
new_model = "gemma-7b-it-v2-role-play"Masuk ke Hugging Face CLI
Kita akan memuat kunci API Hugging Face dari secrets Kaggle (variabel lingkungan).
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")Gunakan kunci API untuk masuk ke Hugging Face CLI. Ini memungkinkan kita mengakses model dan juga menyimpannya di Hugging Face Hub.
!huggingface-cli login --token $secret_hfInisialisasi workspace W&B
Inisialisasi workspace Weights & Biases (W&B) menggunakan kunci API W&B. Kita akan menggunakan workspace ini untuk melacak pelatihan model.
secret_wandb = user_secrets.get_secret("wandb")
# Monitoring the LLM
wandb.login(key = secret_wandb)
run = wandb.init(
project='Fine tuning Gemma 7B',
job_type="training",
anonymous="allow"
)Memuat dataset
Ambil 1000 baris pertama data dari dataset role play yang tersedia di Hugging Face dan tampilkan sampel kolom `text`.
#Loading the dataset
dataset = load_dataset(dataset_name, split="train[0:1000]")
dataset["text"][100]Dataset kita berisi percakapan berkelanjutan antara pengguna dan asisten berdasarkan gaya selebritas. Ini adalah role-playing.
Memuat model dan tokenizer
Untuk menghindari masalah memori, kita akan memuat model dalam presisi 4-bit menggunakan BitsAndBytesConfig. Ini akan memuat model langsung dari Kaggle tanpa mengunduh.
# Load base model(Gemma 7B-it)
bnbConfig = BitsAndBytesConfig(
load_in_4bit = True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained(
base_model,
quantization_config=bnbConfig,
device_map="auto"
)
model.config.use_cache = False # silence the warnings. Please re-enable for inference!
model.config.pretraining_tp = 1
model.gradient_checkpointing_enable()Muat tokenizer dan konfigurasikan pad token untuk memperbaiki masalah dengan fp16.
# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model)
tokenizer.padding_side = 'right'
tokenizer.pad_token = tokenizer.eos_token
tokenizer.add_eos_token = True
tokenizer.add_bos_token, tokenizer.add_eos_tokenMenambahkan lapisan adapter
Dengan menambahkan lapisan adapter ke model kita, kita dapat melakukan fine-tune lebih efisien. Alih-alih melatih seluruh model, kita hanya perlu memperbarui parameter pada lapisan adapter, yang akan mempercepat proses pelatihan.
Modul target kita adalah 'o_proj', 'q_proj', 'up_proj', 'v_proj', 'k_proj', 'down_proj', dan 'gate_proj'.
model = prepare_model_for_kbit_training(model)
peft_config = LoraConfig(
lora_alpha=16,
lora_dropout=0.1,
r=64,
bias="none",
task_type="CAUSAL_LM",
target_modules=['o_proj', 'q_proj', 'up_proj', 'v_proj', 'k_proj', 'down_proj', 'gate_proj']
)
model = get_peft_model(model, peft_config)Melatih model
Untuk memulai pelatihan, kita perlu menentukan hiperparameter. Parameter ini mendasar dan dapat dimodifikasi untuk meningkatkan proses pelatihan dan kinerja model.
Jika Anda ingin memahami tiap hiperparameter dengan lebih baik, kami sarankan membaca tutorial Fine-Tuning LLaMA 2.
training_arguments = TrainingArguments(
output_dir="./gemma-7b-v2-role-play",
num_train_epochs=1,
per_device_train_batch_size=2,
gradient_accumulation_steps=1,
optim="paged_adamw_32bit",
save_strategy="epoch",
logging_steps=100,
logging_strategy="steps",
learning_rate=2e-4,
fp16=False,
bf16=False,
group_by_length=True,
report_to="wandb"
)Untuk menyiapkan pelatih Supervised Fine-tuning (SFT), kita perlu memberinya model, dataset, konfigurasi Lora, tokenizer, dan parameter pelatihan sebagai argumen.
trainer = SFTTrainer(
model=model,
train_dataset=dataset,
peft_config=peft_config,
max_seq_length= 512,
dataset_text_field="text",
tokenizer=tokenizer,
args=training_arguments,
packing= False,
)Sekarang kita akan menjalankan proses pelatihan menggunakan fungsi `.train`. Fine-tuning memakan waktu sekitar 1 jam 1 menit. Loss pelatihan menurun secara bertahap, dan Anda bahkan dapat menurunkannya lagi dengan menambah jumlah epoch.
trainer.train()
Akhiri sesi W&B dan konfigurasikan model untuk inferensi.
wandb.finish()
model.config.use_cache = True
Kami melatih model pada dua jenis akselerator GPU. Tampaknya P100 dua kali lebih cepat dibanding T4 2X.
Menyimpan model
Sekarang kita akan menyimpan adapter model secara lokal lalu mengunggah model ke Hugging Face hub. Perintah `push_to_hub` akan membuat repo dan mendorong konfigurasi adapter dan bobot adapter ke hub.
# Save the fine-tuned model
trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)Catatan: Ini hanyalah adapter—menyimpan model lengkap ukurannya sekitar 18 GB.
Kita dapat melihat model di Hugging Face dengan membuka halaman profil dan memeriksa model baru.
Gambar Sumber
Inferensi model
Untuk menghasilkan respons menggunakan model hasil fine-tune, kita perlu mengikuti beberapa langkah.
Pertama, kita akan membuat prompt dalam format dataset role-play. Lalu, kita teruskan prompt ke tokenizer dan selanjutnya ke model untuk menghasilkan prediksi.
Untuk menerjemahkan output prediksi menjadi teks yang dapat dibaca, kita akan mendekodenya menggunakan tokenizer.
prompt = '''<|system|>Harry Potter is a wizard known for his distinctive lightningshaped scar and his remarkable journey through magic and battles against the dark wizard Voldemort.
<|user|> What is the meaning of hate?
<|assistant|>'''
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")
outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)
text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(text)Tidak buruk sama sekali. Model juga mengajukan pertanyaan lanjutan yang relevan.
Coba lagi dengan karakter baru: Michel Jordan.
prompt = '''<|system|>Michael Jordan an NBA legend known for his competitive drive six championship wins with the Chicago Bulls.
<|user|> What motivates you in the life?
<|assistant|>'''
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")
outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)
text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(text)Menurut saya, kita telah melakukan pekerjaan yang baik dalam menyesuaikan model dasar agar memahami gaya baru dalam menghasilkan respons.
Jika Anda mengalami kesulitan melakukan fine-tuning model pada dataset Anda, silakan lihat notebook Kaggle Gemma-7B 4-bit QLoRA Fine-tuning.
Anda juga dapat mempelajari cara fine-tune model dengan performa tertinggi dan terbaik di kelasnya dengan mengikuti tutorial Fine-Tuning OpenAI's GPT-4.
Inferensi Gemma 7B dengan Adapter Role Play
Untuk menghasilkan respons, kita tidak bisa sekadar memuat adapter yang disimpan. Kita perlu menggabungkan adapter hasil fine-tune dengan model dasar (Gemma 7b-it).
Pada bagian ini, kita akan mempelajari cara memuat model dasar dan adapter lalu menggabungkannya untuk menghasilkan respons.
1. Pasang semua pustaka Python yang diperlukan.
%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft2. Muat kunci API dari secrets Kaggle dan masuk ke Hugging Face CLI.
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")!huggingface-cli login --token $secret_hf3. Sediakan lokasi model dasar dan adapter.
base_model = "/kaggle/input/gemma/transformers/7b-it/2"
new_model = "kingabzpro/gemma-7b-it-v2-role-play"4. Muat model dasar.
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from peft import PeftModel
import torch
base_model_reload = AutoModelForCausalLM.from_pretrained(
base_model,
return_dict=True,
low_cpu_mem_usage=True,
torch_dtype=torch.float16,
device_map="auto",
trust_remote_code=True,
)5. Muat dan gabungkan adapter dengan model dasar
model = PeftModel.from_pretrained(base_model_reload, new_model)
6. Muat tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"7. Teruskan prompt melalui tokenizer lalu ke model untuk menghasilkan respons.
prompt = '''<|system|> Alan Watts's colorful journey explored the depths of philosophy and religion, weaving together Eastern wisdom and Western insights.
<|user|> What does the self actually amount to?
<|assistant|>'''
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")
outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)
text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(text)Alan Watts menjelaskan makna “diri” dengan sangat tepat.
Sumber kode untuk menggabungkan model dasar dengan adapter tersedia di Gemma 7B Inference with Role Play Adopter.
Daftarkan diri Anda untuk webinar Fine-Tuning Your Own Llama 2 untuk menonton tutorial video dari pakar industri.
Penutup
Google memulai revolusi large language model bertahun-tahun lalu namun belum mampu memanfaatkannya. Kini, perusahaan melakukan perubahan yang diperlukan pada strateginya untuk kembali menjadi pemimpin industri.
Dengan peluncuran model open-source terbaru, Gemma, Google mengambil langkah untuk mendorong riset AI dan pada gilirannya akan mampu membangun model yang bahkan lebih baik di masa depan.
Perusahaan akhirnya menyadari kekuatan komunitas open-source dan bagaimana mereka dapat mengambil manfaat darinya. Dengan memanfaatkan platform cloud, kerangka kerja native, serta platform seperti Kaggle, Colab, dan Vertex AI, Google bertujuan memaksimalkan komunitas open-source dan tetap unggul dalam persaingan.
Dalam tutorial ini, kita telah mempelajari model Gemma dan cara mengaksesnya menggunakan GPU dan TPU cloud. Kita juga membahas proses fine-tuning model Gemma 7b-it terbaru menggunakan dataset role-play.
Langkah berikutnya dalam perjalanan AI Anda adalah membuat aplikasi berbasis LLM sendiri. Lihat tutorial cara membangun aplikasi LLM dengan LangChain dan pelajari cara menggunakan kerangka kerja Python yang kuat untuk mengembangkan aplikasi AI mutakhir.
Topik
