Penalaan Llama 3.2 3b untuk Rag - Analytics Vidhya

Model bahasa kecil (SLMs) membuat kesan yang signifikan dalam AI. Mereka memberikan prestasi yang kuat semasa menjadi cekap dan kos efektif. Satu contoh yang menonjol ialah Llama 3.2 3B. Ia melakukan yang sangat baik dalam tugas-tugas generasi pengambilan semula (RAG), memotong kos pengiraan dan penggunaan memori sambil mengekalkan ketepatan yang tinggi. Artikel ini meneroka cara menyempurnakan model Llama 3.2 3B. Ketahui bagaimana model yang lebih kecil dapat cemerlang dalam tugas -tugas RAG dan tolak sempadan penyelesaian AI yang kompak.

Jadual Kandungan

• Apa itu llama 3.2 3b?
• Finetuning llama 3.2 3b
• Lora
• Perpustakaan diperlukan
• Import perpustakaan
• Memulakan model dan tokenizer
• Memulakan model untuk peft
• Pemprosesan data
• Menetapkan parameter jurulatih
• Penalaan model
• Uji dan simpan model
• Kesimpulan
• Soalan yang sering ditanya

Apa itu llama 3.2 3b?

Model Llama 3.2 3B, yang dibangunkan oleh META, adalah SLM berbilang bahasa dengan 3 bilion parameter, yang direka untuk tugas -tugas seperti menjawab soalan, ringkasan, dan sistem dialog. Ia mengatasi banyak model sumber terbuka mengenai penanda aras industri dan menyokong pelbagai bahasa. Tersedia dalam pelbagai saiz, Llama 3.2 menawarkan prestasi pengiraan yang cekap dan termasuk versi kuantitatif untuk penempatan yang lebih cepat, efisien memori dalam persekitaran mudah alih dan kelebihan.

Juga baca: 13 model bahasa kecil (SLMS)

Finetuning llama 3.2 3b

Penalaan halus adalah penting untuk menyesuaikan SLM atau LLM ke domain atau tugas tertentu, seperti aplikasi perubatan, undang-undang, atau RAG. Walaupun pra-latihan membolehkan model bahasa menjana teks merentasi topik yang pelbagai, penalaan halus melatih model pada data khusus domain atau tugas khusus untuk meningkatkan kaitan dan prestasi. Untuk menangani kos pengiraan yang tinggi untuk penalaan semua parameter, teknik seperti parameter Efisien Fine-Tuning (PEFT) memberi tumpuan kepada latihan hanya subset parameter model, mengoptimumkan penggunaan sumber sambil mengekalkan prestasi.

Lora

Satu kaedah PEFT sedemikian adalah penyesuaian pangkat rendah (LORA).

Di LORA, matriks berat di SLM atau LLM diuraikan ke dalam produk dua matriks peringkat rendah.

 W = wa * wb

Jika W mempunyai baris M dan lajur N, maka ia boleh diuraikan ke WA dengan baris M dan lajur R, dan WB dengan baris R dan lajur N. Di sini r jauh lebih rendah daripada m atau n. Jadi, bukannya latihan nilai m*n, kita hanya boleh melatih nilai r*(mn). R dipanggil pangkat yang merupakan hiperparameter yang boleh kita pilih.

 def lora_linear (x):<br> h = x @ w # linear biasa<br> h = skala * (x @ w_a @ w_b) # kemas kini peringkat rendah<br> kembali h

Checkout: Parameter-penalaan halus model bahasa besar dengan LORA dan Qlora

Mari kita melaksanakan LORA pada model Llama 3.2 3B.

Perpustakaan diperlukan

• Unsloth - 2024.12.9
• Dataset - 3.1.0

Memasang versi sloth di atas juga akan memasang perpustakaan Pytorch, Transformers, dan NVIDIA yang serasi. Kita boleh menggunakan Google Colab untuk mengakses GPU.

Mari lihat pelaksanaan sekarang!

Import perpustakaan

 dari fastlanguagemodel import yang tidak disengaja, is_bfloat16_supported, train_on_responses_only

Dari dataset import load_dataset, dataset

Dari TRL Import Sfttrainer, apply_chat_template

Dari Transformers mengimport Latihan, DataCollatorForseq2Seq, TextStreamer

obor import

Memulakan model dan tokenizer

 max_seq_length = 2048 
dtype = tiada # tiada untuk pengesanan automatik.
LOAD_IN_4BIT = BENAR # Gunakan kuantisasi 4bit untuk mengurangkan penggunaan memori. Boleh palsu.

model, tokenizer = fastlanguagemodel.from_pretrained (
	model_name = "unsloth/llama-3.2-3b-instruct",
	max_seq_length = max_seq_length,
	dtype = dtype,
	LOAD_IN_4BIT = LOAD_IN_4BIT,
	# token = "hf _...", # Gunakan jika menggunakan model berpagar seperti meta-llama/llama-3.2-11b
)

Untuk model lain yang disokong oleh Unsloth, kita boleh merujuk kepada dokumen ini.

Memulakan model untuk peft

 model = fastlanguagemodel.get_peft_model (
	model,
	r = 16,
	target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                  	"GATE_PROJ", "up_proj", "down_proj",],
	lora_alpha = 16,
	lora_dropout = 0, 
	Bias = "Tiada",
	use_gradient_checkpointing = "unsloth",
	random_state = 42,
	use_rslora = palsu, 
	loftq_config = Tiada,
)

Penerangan untuk setiap parameter

• R : pangkat Lora; Nilai yang lebih tinggi meningkatkan ketepatan tetapi menggunakan lebih banyak memori (dicadangkan: 8-128).
• Target_modules : Modul untuk menyempurnakan; Sertakan semua untuk hasil yang lebih baik
• lora_alpha : faktor skala; biasanya sama dengan atau menggandakan pangkat r.
• LORA_DROPOUT : Kadar dropout; Tetapkan kepada 0 untuk latihan yang dioptimumkan dan lebih cepat.
• Bias : jenis bias; "Tiada" dioptimumkan untuk kelajuan dan minimum overfitting.
• use_gradient_checkpointing : Mengurangkan memori untuk latihan konteks panjang; "Unsloth" sangat disyorkan.
• Random_state : Benih untuk larian deterministik, memastikan hasil yang boleh dihasilkan (contohnya, 42).
• use_rslora : Automasi pemilihan alpha; Berguna untuk LORA yang stabil pangkat.
• LOFTQ_CONFIG : Inisialisasi LORA dengan vektor tunggal R Top untuk ketepatan yang lebih baik, walaupun memori-intensif.

Pemprosesan data

Kami akan menggunakan data RAG ke Finetune. Muat turun data dari Huggingface.

 dataset = LOAD_DATASET ("Neural-Bridge/RAG-Dataset-1200", Split = "Train")

Dataset mempunyai tiga kunci seperti berikut:

Dataset ({ciri: ['konteks', 'soalan', 'jawapan'], num_rows: 960})

Data perlu dalam format tertentu bergantung kepada model bahasa. Baca maklumat lanjut di sini .

Oleh itu, mari kita menukar data ke dalam format yang diperlukan:

 def convert_dataset_to_dict (dataset):
    dataset_dict = {
        "Prompt": [],
        "Penyelesaian": []
    }

    untuk baris dalam dataset:
        user_content = f "konteks: {row ['context']} \ nquestion: {row ['soal']}"
        pembantu_content = baris ['jawapan']

        dataset_dict ["prompt"]. append ([[
            {"peranan": "pengguna", "kandungan": user_content}
        ])
        dataset_dict ["Penyelesaian"]. Tambah ([[
            {"peranan": "pembantu", "kandungan": pembantu_content}
        ])
    kembali dataset_dict
    
    
converted_data = convert_dataset_to_dict (dataset)
dataset = dataset.from_dict (converted_data)
dataset = dataset.map (apply_chat_template, fn_kwargs = {"tokenizer": tokenizer})

Mesej dataset akan seperti berikut:

Menetapkan parameter jurulatih

Kami boleh memulakan jurulatih untuk memakan SLM:

 jurulatih = sfttrainer (
	model = model,
	tokenizer = tokenizer,
	train_dataset = dataset,
	max_seq_length = max_seq_length,
	data_collator = dataCollatorForseq2Seq (tokenizer = tokenizer),
	dataset_num_proc = 2,
	Pembungkusan = palsu, # boleh membuat latihan 5x lebih cepat untuk urutan pendek.
	args = trainingArguments (
    	per_device_train_batch_size = 2,
    	gradient_accumulation_steps = 4,
    	Warmup_steps = 5,
    	# num_train_epochs = 1, # Tetapkan ini untuk 1 latihan penuh.
    	max_steps = 6, # menggunakan nombor kecil untuk diuji
    	pembelajaran_rate = 2e-4,
    	fp16 = bukan is_bfloat16_supported (),
    	bf16 = is_bfloat16_supported (),
    	logging_steps = 1,
    	Optim = "ADAMW_8BIT",
    	weight_decay = 0.01,
    	lr_scheduler_type = "linear",
    	benih = 3407,
    	output_dir = "output",
    	laporan_to = "Tiada", # Gunakan ini untuk wandb dll
	))
)

Penerangan beberapa parameter:

• per_device_train_batch_size: saiz batch per peranti; Meningkatkan untuk menggunakan lebih banyak memori GPU tetapi menonton ketidakcekapan padding (dicadangkan: 2).
• Gradient_accumulation_steps: Simulasi saiz batch yang lebih besar tanpa penggunaan memori tambahan; Peningkatan untuk keluk kerugian yang lebih lancar (dicadangkan: 4).
• max_steps: Jumlah langkah latihan; Tetapkan untuk berjalan lebih cepat (misalnya, 60), atau gunakan `num_train_epochs` untuk pas dataset penuh (misalnya, 1-3).
• learning_rate: Mengawal kelajuan latihan dan penumpuan; Kadar yang lebih rendah (contohnya, 2e-4) meningkatkan ketepatan tetapi latihan perlahan.

Jadikan Model Keretapi pada Respons hanya dengan menentukan templat tindak balas:

 jurulatih = train_on_responses_only (
	jurulatih,
	instruksi_part = " pengguna  \ n \ n",
	response_part = " pembantu  \ n \ n",
)

Penalaan model

 Trainer_stats = Trainer.Train ()

Inilah statistik latihan:

Uji dan simpan model

Mari gunakan model untuk kesimpulan:

 FastLanguageModel.for_inference (model)

Mesej = [
	{"Peranan": "Pengguna", "Kandungan": "Konteks: Langit biasanya jelas pada siang hari. Soalan: Apa warna air?"},
]
input = tokenizer.apply_chat_template (
	mesej,
	tokenize = benar,
	add_generation_prompt = benar,
	return_tensors = "pt",
) .to ("Cuda")

text_streamer = textStreamer (tokenizer, skip_prompt = true)
_ = model.generate (input_ids = input, streamer = text_streamer, max_new_tokens = 128,
               	use_cache = benar, suhu = 1.5, min_p = 0.1)

Untuk menyelamatkan yang terlatih termasuk berat LORA, gunakan kod di bawah

 model.save_pretrained_merged ("model", tokenizer, save_method = "digabungkan_16bit")

Checkout: Panduan untuk menala model bahasa yang besar

Kesimpulan

Penalaan Llama 3.2 3B untuk tugas-tugas RAG mempamerkan kecekapan model yang lebih kecil dalam menyampaikan prestasi tinggi dengan kos pengiraan yang dikurangkan. Teknik seperti LORA mengoptimumkan penggunaan sumber sambil mengekalkan ketepatan. Pendekatan ini memberi kuasa kepada aplikasi khusus domain, menjadikan AI yang lebih mudah diakses, berskala, dan kos efektif, memacu inovasi dalam generasi pengambilan semula dan demokrasi AI untuk cabaran dunia nyata.

Juga Baca: Bermula dengan Meta Llama 3.2

Soalan yang sering ditanya

Q1. Apa itu kain?

A. Rag menggabungkan sistem pengambilan semula dengan model generatif untuk meningkatkan respons dengan mendasari mereka dalam pengetahuan luaran, menjadikannya sesuai untuk tugas -tugas seperti menjawab soalan dan ringkasan.

S2. Mengapa Memilih Llama 3.2 3B untuk penalaan halus?

A. Llama 3.2 3B menawarkan keseimbangan prestasi, kecekapan, dan skalabiliti, menjadikannya sesuai untuk tugas -tugas RAG sambil mengurangkan keperluan pengiraan dan memori.

Q3. Apa itu Lora, dan bagaimanakah ia memperbaiki penalaan halus?

A. Penyesuaian peringkat rendah (LORA) meminimumkan penggunaan sumber dengan latihan hanya matriks peringkat rendah dan bukannya semua parameter model, yang membolehkan penalaan halus pada perkakasan yang terkawal.

Q4. Dataset apa yang digunakan untuk penalaan halus dalam artikel ini?

A. Memeluk Wajah menyediakan dataset RAG, yang mengandungi konteks, soalan, dan jawapan, untuk menyempurnakan model Llama 3.2 3B untuk prestasi tugas yang lebih baik.

S5. Bolehkah model yang disempurnakan digunakan pada peranti tepi?

A. Ya, Llama 3.2 3b, terutamanya dalam bentuk kuantitinya, dioptimumkan untuk penyebaran efisien memori pada persekitaran dan persekitaran mudah alih.

Atas ialah kandungan terperinci Penalaan Llama 3.2 3b untuk Rag - Analytics Vidhya. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!