Tutorial Mistral 7B: Panduan Langkah demi Langkah untuk Menggunakan dan Menyetel Halus Mistral 7B

Mengakses Mistral 7B

Kita dapat mengakses Mistral 7B di HuggingFace, Vertex AI, Replicate, Sagemaker Jumpstart, dan Baseten.

Ada juga cara baru dan lebih baik untuk mengakses model melalui fitur baru Kaggle bernama Models. Artinya Anda tidak perlu mengunduh model atau dataset; Anda dapat mulai melakukan inferensi atau penyetelan halus dalam beberapa menit.

Pada bagian ini, kita akan mempelajari cara memuat model Kaggle dan menjalankan inferensi dalam beberapa menit.

Sebelum mulai, kita harus memperbarui pustaka penting untuk menghindari galat KeyError: 'mistral.

!pip install -q -U transformers
!pip install -q -U accelerate
!pip install -q -U bitsandbytes

Setelah itu, kita akan membuat kuantisasi 4-bit dengan konfigurasi tipe NF4 menggunakan BitsAndBytes untuk memuat model kita dalam presisi 4-bit. Ini akan membantu kita memuat model lebih cepat dan mengurangi jejak memori sehingga dapat dijalankan di Google Colab atau GPU konsumen.

from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, pipeline
import torch

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
)

Sekarang kita akan mempelajari cara menambahkan model Mistral 7B ke Kaggle Notebook kita.

Gambar dari Mistral | Kaggle

1. Klik tombol “+Add Models” pada panel sisi kanan.
2. Cari model Anda dan klik tombol Plus untuk menambahkannya.
3. Pilih variasi yang benar “7b-v0.1-hf” dan versinya.
4. Setelah itu, salin path direktori dan tambahkan ke notebook Anda.

Sekarang kita akan memuat model dan tokenizer menggunakan pustaka Transformers.

model_name = "/kaggle/input/mistral/pytorch/7b-v0.1-hf/1"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
        model_name,
        load_in_4bit=True,
        quantization_config=bnb_config,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        trust_remote_code=True,
    )

Agar lebih mudah, kita akan menggunakan fungsi pipeline dari pustaka Transformers untuk menghasilkan respons berdasarkan prompt.

pipe = pipeline(
    "text-generation", 
    model=model, 
    tokenizer = tokenizer, 
    torch_dtype=torch.bfloat16, 
    device_map="auto"
)

Kemudian kita akan memberikan prompt ke objek pipeline dan menetapkan parameter tambahan untuk membuat jumlah token maksimum dan meningkatkan respons kita.

prompt = "As a data scientist, can you explain the concept of regularization in machine learning?"

sequences = pipe(
    prompt,
    do_sample=True,
    max_new_tokens=100, 
    temperature=0.7, 
    top_k=50, 
    top_p=0.95,
    num_return_sequences=1,
)
print(sequences[0]['generated_text'])

Seperti yang kita lihat, Mistral 7B telah menghasilkan hasil yang tepat yang menjelaskan proses regularisasi dalam pembelajaran mesin.

As a data scientist, can you explain the concept of regularization in machine learning?

Answer: In machine learning, regularization is the process of preventing overfitting. Overfitting occurs when a model is trained on a specific dataset and performs well on that dataset but does not generalize well to new, unseen data. Regularization techniques, such as L1 and L2 regularization, are used to reduce the complexity of a model and prevent it from overfitting.

Anda dapat menduplikasi dan menjalankan kode dengan menggunakan notebook Mistral 7B inferensi 4-bit di Kaggle.

Catatan: Kaggle menyediakan memori GPU yang cukup untuk Anda memuat model tanpa Kuantisasi 4-bit. Anda dapat mengikuti notebook Mistral 7B Simple Inference untuk mempelajari caranya.

Penyetelan Halus Mistral 7B

Pada bagian ini, kita akan mengikuti langkah-langkah serupa dari panduan Fine-Tuning LLaMA 2: A Step-by-Step Guide to Customizing the Large Language Model untuk menyetel halus model Mistral 7B pada dataset favorit kita guanaco-llama2-1k. Anda juga dapat membaca panduan tersebut untuk mempelajari tentang PEFT, kuantisasi 4-bit, QLoRA, dan SFT.

Penyiapan

Kita akan memperbarui dan memasang pustaka Python yang diperlukan.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U peft
%pip install -U accelerate
%pip install -U trl

Setelah itu, kita akan memuat modul yang diperlukan untuk penyetelan halus model yang efektif.

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 SFTTrainer

Perhatikan bahwa kita menggunakan Kaggle Notebook untuk menyetel halus model. Kita akan menyimpan kunci API dengan aman dengan mengklik tombol "Add-ons" dan memilih opsi "Secret". Untuk mengakses API di notebook, kita akan menyalin dan menjalankan cuplikan seperti di bawah ini.

Dalam kasus kita, kita akan menyimpan kunci API Hugging Face dan Weights and Biases dan mengaksesnya di notebook Kaggle.

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")
secret_wandb = user_secrets.get_secret("wandb")

Kita akan menggunakan API Hugging Face untuk menyimpan dan mendorong model ke Hugging Face Hub.

!huggingface-cli login --token $secret_hf

Untuk memantau kinerja LLM, kita akan menginisialisasi eksperimen Weights and Biases menggunakan API.

wandb.login(key = secret_wandb)
run = wandb.init(
    project='Fine tuning mistral 7B', 
    job_type="training", 
    anonymous="allow"
)

Pada bagian ini, kita akan menetapkan model dasar, dataset, dan nama model baru. Nama model baru akan digunakan untuk menyimpan model yang telah disetel halus.

Catatan: Jika Anda menggunakan versi gratis Colab, Anda harus memuat versi model yang dipecah (someone13574/Mistral-7B-v0.1-sharded).

Anda juga dapat memuat model dari Hugging Face Hub menggunakan nama model dasar: mistralai/Mistral-7B-v0.1

base_model = "/kaggle/input/mistral/pytorch/7b-v0.1-hf/1"
dataset_name = "mlabonne/guanaco-llama2-1k"
new_model = "mistral_7b_guanaco"

Pemuatan data

Sekarang kita akan memuat dataset dari Hugging Face Hub dan menampilkan baris ke-100.

#Importing the dataset
dataset = load_dataset(dataset_name, split="train")
dataset["text"][100]

Memuat model Mistral 7B

Sekarang kita akan memuat model menggunakan presisi 4-bit dari Kaggle untuk pelatihan yang lebih cepat. Langkah ini diperlukan jika Anda ingin memuat dan menyetel halus model pada GPU konsumen.

bnb_config = BitsAndBytesConfig(  
    load_in_4bit= True,
    bnb_4bit_quant_type= "nf4",
    bnb_4bit_compute_dtype= torch.bfloat16,
    bnb_4bit_use_double_quant= False,
)
model = AutoModelForCausalLM.from_pretrained(
        base_model,
        load_in_4bit=True,
        quantization_config=bnb_config,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        trust_remote_code=True,
)
model.config.use_cache = False # silence the warnings
model.config.pretraining_tp = 1
model.gradient_checkpointing_enable()

Memuat Tokenizer

Selanjutnya, kita akan memuat tokenizer dan mengonfigurasinya untuk memperbaiki masalah dengan fp16.

tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.padding_side = 'right'
tokenizer.pad_token = tokenizer.eos_token
tokenizer.add_eos_token = True
tokenizer.add_bos_token, tokenizer.add_eos_token

Menambahkan adapter ke layer

Pada langkah berikutnya, kita akan menyertakan layer adapter pada model kita. Ini akan memungkinkan kita menyetel halus model menggunakan sejumlah kecil parameter, sehingga keseluruhan proses menjadi lebih cepat dan hemat memori. Untuk pemahaman yang lebih baik tentang parameter, Anda dapat merujuk ke dokumentasi resmi PEFT.

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=["q_proj", "k_proj", "v_proj", "o_proj","gate_proj"]
)
model = get_peft_model(model, peft_config)

Hyperparameter

Sangat penting untuk menetapkan hyperparameter yang tepat. Anda dapat mempelajari setiap hyperparameter dengan membaca tutorial Fine-Tuning LLaMA 2.

training_arguments = TrainingArguments(
    output_dir="./results",
    num_train_epochs=1,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=1,
    optim="paged_adamw_32bit",
    save_steps=25,
    logging_steps=25,
    learning_rate=2e-4,
    weight_decay=0.001,
    fp16=False,
    bf16=False,
    max_grad_norm=0.3,
    max_steps=-1,
    warmup_ratio=0.03,
    group_by_length=True,
    lr_scheduler_type="constant",
    report_to="wandb"
)

Parameter SFT

Pustaka TRL dari HuggingFace menawarkan API yang ramah pengguna yang memungkinkan pembuatan dan pelatihan model Supervised fine-tuning (SFT) pada dataset Anda dengan pengodean minimal. Kita akan memberikan SFT Trainer komponen yang diperlukan, seperti model, dataset, konfigurasi Lora, tokenizer, dan parameter pelatihan.

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    peft_config=peft_config,
    max_seq_length= None,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)

Pelatihan model

Setelah semuanya disiapkan, kita akan melatih model kita.

trainer.train()

Perhatikan bahwa Anda menggunakan GPU versi T4 x2, yang dapat mengurangi waktu pelatihan menjadi 1 jam 30 menit.

Menyimpan model yang disetel halus

Terakhir, kita akan menyimpan adapter yang telah dipra-latih dan menyelesaikan run W&B.

trainer.model.save_pretrained(new_model)
wandb.finish()
model.config.use_cache = True

Kita dapat dengan mudah mengunggah model kita ke Hugging Face Hub hanya dengan satu baris kode, sehingga kita dapat mengaksesnya dari mesin mana pun.

trainer.model.push_to_hub(new_model, use_temp_dir=False)

Evaluasi model

Anda dapat melihat metrik sistem dan kinerja model dengan membuka wandb.ai dan memeriksa run terbaru.

Gambar dari wandb.ai

Untuk melakukan inferensi model, kita perlu menyediakan objek model dan tokenizer ke pipeline. Kemudian, kita dapat memberikan prompt dalam gaya dataset ke objek pipeline.

logging.set_verbosity(logging.CRITICAL)

prompt = "How do I find true love?"
pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_length=200)
result = pipe(f"<s>[INST] {prompt} [/INST]")
print(result[0]['generated_text'])

Mari kita menghasilkan respons untuk prompt lain.

prompt = "What is Datacamp Career track?"
result = pipe(f"<s>[INST] {prompt} [/INST]")
print(result[0]['generated_text'])

Sepertinya kita mendapatkan respons yang sempurna untuk pertanyaan sederhana kita.

Tautan penting untuk Mistral 7B:

• Notebook Penyetelan Halus Mistral 7B
• Model yang Disetel Halus Mistral 7B

Gambar dari Mistral 7B Penyetelan Halus QLoRA 4bit | Kaggle

Tautan penting untuk Mistral 7B Instruct:

• Notebook Penyetelan Halus Instruct Mistral 7B

Mistral 7B Model Instruct yang Disetel Halus

Menggabungkan adapter

Pada bagian ini, kita akan memuat model dasar dan memasang adapter menggunakan PeftModel, menjalankan inferensi, menggabungkan bobot model, dan mendorongnya ke Hugging Face Hub.

from transformers import AutoModelForCausalLM, AutoTokenizer,pipeline 
from peft import PeftModel
import torch

Memuat model dasar dengan adapter

Pertama, kita akan memuat ulang model dasar dan adapter yang telah disetel halus menggunakan peft. Fungsi di bawah ini akan memasang adapter pada model dasar.

base_model_reload = AutoModelForCausalLM.from_pretrained(
        base_model,
        return_dict=True,
        low_cpu_mem_usage=True,
        device_map="auto",
        trust_remote_code=True,
)

model = PeftModel.from_pretrained(base_model_reload, new_model)

Muat ulang tokenizer

Muat tokenizer model dasar dan perbaiki masalah dengan fp16.

tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

Inferensi

Bangun pipeline inferensi dengan tokenizer dan model.

pipe = pipeline(
    "text-generation", 
    model=model, 
    tokenizer = tokenizer, 
    torch_dtype=torch.bfloat16, 
    device_map="auto"
)

Berikan prompt dan jalankan pipeline untuk menghasilkan respons.

prompt = "How become a DataCamp certified data professional"

sequences = pipe(
    f"<s>[INST] {prompt} [/INST]",
    do_sample=True,
    max_new_tokens=100, 
    temperature=0.7, 
    top_k=50, 
    top_p=0.95,
    num_return_sequences=1,
)
print(sequences[0]['generated_text'])

Mendorong model yang disetel halus

Sekarang kita akan menggabungkan adapter dengan model dasar sehingga Anda dapat menggunakan model yang disetel halus secara langsung, seperti model Mistral 7B asli, dan menjalankan inferensi. Untuk itu, kita akan menggunakan fungsi merge_and_unload.

Setelah menggabungkan model, kita akan mendorong baik tokenizer maupun model ke Hugging Face Hub. Anda juga dapat mengikuti notebook Kaggle jika Anda mengalami kendala di suatu langkah.

model = model.merge_and_unload()

model.push_to_hub(new_model, use_temp_dir=False)
tokenizer.push_to_hub(new_model, use_temp_dir=False)

Gambar dari kingabzpro/mistral_7b_guanaco

Seperti yang Anda lihat, alih-alih hanya adapter, kini kita memiliki model penuh berukuran 13,98 GB.

Gambar dari kingabzpro/mistral_7b_guanaco

Mengakses model yang disetel halus

Untuk menunjukkan bahwa kita dapat memuat dan menjalankan inferensi tanpa bantuan model dasar, kita akan memuat model yang disetel halus dari Hugging Face Hub dan menjalankan inferensi.

from transformers import pipeline


pipe = pipeline(
    "text-generation", 
    model = "kingabzpro/mistral_7b_guanaco",
    device_map="auto"
)

prompt = "How do I become a data engineer in 6 months?"

sequences = pipe(
    f"<s>[INST] {prompt} [/INST]",
    do_sample=True,
    max_new_tokens=200, 
    temperature=0.7, 
    top_k=50, 
    top_p=0.95,
    num_return_sequences=1,)

print(sequences[0]['generated_text'])

Kesimpulan

Mistral 7B merupakan kemajuan menarik dalam kapabilitas model bahasa besar. Melalui inovasi seperti Grouped-query Attention dan Sliding Window Attention, model ini meraih kinerja mutakhir sekaligus tetap cukup efisien untuk diterapkan.

Dalam tutorial ini, kita telah mempelajari cara mengakses model Mistral 7B di Kaggle. Selain itu, kita juga mempelajari cara menyetel halus model pada dataset kecil dan menggabungkan adapter dengan model dasar.

Panduan ini merupakan sumber yang komprehensif bagi para penggemar pembelajaran mesin maupun pemula yang ingin bereksperimen dan melatih model bahasa besar pada GPU konsumen.

Jika Anda baru mengenal model bahasa besar, kami merekomendasikan mengikuti kursus Master LLMs Concepts. Bagi yang tertarik memulai karier di bidang kecerdasan buatan, mendaftar di jalur keterampilan AI Fundamentals adalah langkah awal yang tepat.

Sumber daya

• Blog Resmi
• GitHub
• Makalah Riset
• Hugging Face
• Ollama