GRPO Fine-penalaan di DeepSeek-7b dengan Unsloth

DeepSeek telah mengambil dunia pemprosesan bahasa semulajadi oleh ribut. Dengan skala dan prestasi yang mengagumkan, model canggih ini cemerlang dalam tugas-tugas seperti menjawab soalan dan ringkasan teks. Keupayaannya untuk mengendalikan pemahaman yang bernuansa menjadikannya penukar permainan di seluruh industri. Penalaan halus meningkatkan kuasanya, menyesuaikannya dengan keperluan khusus dan memberikan hasil yang tepat dengan cepat. Penalaan halus mengubah DeepSeek-7B dari seorang ahli generalis kepada pakar domain dengan menyempurnakannya pada dataset khusus. Blog ini menerangkan bagaimana GRPO (pengoptimuman pretraining penguatkuasaan umum) meningkatkan penalaan dengan pembelajaran tetulang, dan bagaimana Unsloth mengoptimumkan pengurusan memori, mempercepat proses untuk model besar seperti DeepSeek-7b. Bersama-sama, kaedah ini membolehkan penalaan yang lebih cepat, kos efektif, memandu aplikasi AI gen seterusnya.

Objektif Pembelajaran

pada akhir blog ini, anda sepatutnya dapat:

• Belajar asas-asas penalaan deepseek-7b untuk peningkatan prestasi pada tugas khusus.
• Cari kelebihan GRPO ke atas PPO, meningkatkan kecekapan latihan dalam penalaan halus.
• Gunakan unsloth dan lora untuk cepat, memori yang cekap penalaan model besar.
• Sediakan DeepSeek-7b Fine-penalaan dengan Unsloth, VLLM, memeluk muka, dan mengoptimumkan prestasi GPU.
• Melaksanakan fungsi ganjaran seperti ketepatan dan XML untuk output berstruktur dalam pembelajaran tetulang.
• beban, simpan, dan tambah semula model yang disempurnakan dengan menggunakan LORA untuk kesimpulan yang cekap memori, prestasi tinggi.
• menyelesaikan masalah memori GPU dan masalah konfigurasi untuk penalaan halus yang lancar.
• meneroka penskalaan kepada dataset yang lebih besar, fungsi ganjaran baru, dan GRPO untuk model multi-modal.

Artikel ini diterbitkan sebagai sebahagian daripada Blogathon Sains Data

Jadual Kandungan

DeepSeek-7b dengan GRPO

menjimatkan dan memuatkan semula model halus
perangkap biasa dan penyelesaian masalah
Kesimpulan
• Memahami Model DeepSeek & Algoritma GRPO
• Apa itu DeepSeek-R1-Distill-Qwen-7b?
• DeepSeek-R1-Distill-Qwen-7b adalah model bahasa besar yang canggih yang dibina di atas seni bina Qwen. Dengan reka bentuk yang mantap dan berskala, ia memanfaatkan berbilion -bilion parameter untuk mengendalikan tugas NLP yang kompleks seperti penjanaan teks, menjawab soalan, dan ringkasan. Varian DeepSeek-7b adalah versi sulingan dari rakan-rakannya yang lebih besar, yang bermaksud ia mengekalkan banyak prestasi sementara menjadi lebih efisien dari segi pengiraan dan penggunaan memori. Ini menjadikannya sesuai untuk digunakan dalam persekitaran di mana kedua-dua kelajuan dan ketepatan kesimpulan adalah kritikal. Senibina menggunakan lapisan pengubah dengan mekanisme perhatian diri, menjadikannya sangat berkesan dalam memproses ketergantungan jarak jauh dalam teks.
• Ciri -ciri Utama dan Gambaran Keseluruhan Senibina

Pada terasnya, DeepSeek-7B menggunakan seni bina pengubah berbilang lapisan yang sangat disatukan, membolehkan latihan yang cekap pada dataset berskala besar. Setiap lapisan terdiri daripada satu siri modul perhatian diri dan rangkaian feedforward. Mekanisme perhatian membantu fokus model pada bahagian yang relevan dari urutan input semasa pemprosesan, menjadikannya sangat efisien untuk tugas yang memerlukan pemahaman kontekstual.

Proses DeepSeek-7B Token embeddings melalui pengekodan kedudukan, lapisan perhatian, dan lapisan ke hadapan, membolehkan skala yang cekap ke dataset yang besar sambil mengekalkan hasil yang berkualiti tinggi. Pemahaman konteksnya yang mendalam meningkatkan generalisasi merentasi domain selepas penalaan halus. Kaedah seperti LORA meningkatkan kecekapan latihan dengan menggunakan kemas kini peringkat rendah, menjadikan penalaan yang baik boleh dilaksanakan walaupun dengan sumber pengiraan yang terhad. Pengenalan kepada GRPO dan bagaimana ia meningkatkan penalaan halus GRPO (Pengoptimuman Pretraining Penguatkuasaan Umum) adalah teknik lanjutan yang direka untuk meningkatkan kecekapan model bahasa yang besar. Ia menggabungkan prinsip pembelajaran tetulang dengan pretraining untuk memperbaiki tingkah laku model menggunakan isyarat ganjaran dan bukan pengawasan langsung. GRPO mengoptimumkan parameter model dengan menggunakan pendekatan pengoptimuman berasaskan dasar. Dalam senario penalaan yang biasa, model ini dilatih dalam dataset yang diawasi, di mana ia secara langsung belajar dari label kebenaran tanah. Sebaliknya, GRPO memperkenalkan paradigma pembelajaran tetulang (RL) di mana model dilatih untuk memaksimumkan isyarat ganjaran yang membimbing tingkah lakunya. Proses ini membolehkan model menyesuaikan lebih fleksibel kepada nuansa khusus tugas, meningkatkan ketepatan dan penyebaran.

Formula utama untuk pengoptimuman dasar dalam GRPO boleh dinyatakan sebagai:

di mana:

Pendekatan berasaskan dasar ini memastikan bahawa model ini terus menyesuaikan diri dengan maklum balas yang disediakan semasa latihan, memberi tumpuan kepada meningkatkan isyarat ganjaran yang sepadan dengan matlamat khusus tugas.

isyarat ganjaran GRPO

Di GRPO, fungsi ganjaran boleh ditakrifkan mengikut keperluan tugas tertentu, membimbing model untuk memberi tumpuan kepada tingkah laku yang dikehendaki. Ganjaran ini boleh menjadi fungsi pelbagai faktor, seperti ketepatan, pemformatan, atau konsistensi logik. Sebagai contoh, fungsi ganjaran ketepatan r_correct boleh ditakrifkan sebagai:

Mekanisme maklum balas ini membolehkan GRPO secara progresif memperbaiki model, menekankan bidang -bidang yang paling penting untuk tugas yang diberikan.

Bagaimana GRPO berbeza dari PPO (pengoptimuman dasar proksimal)?

Walaupun GRPO memperkenalkan pembelajaran tetulang berasaskan dasar untuk mengoptimumkan proses pretraining, PPO (Pengoptimuman Dasar Proksimal) adalah satu lagi algoritma yang digunakan secara meluas dalam pembelajaran tetulang, terutamanya dalam konteks model-model besar. PPO terkenal dengan kestabilan dan keupayaannya untuk mengendalikan ruang tindakan dimensi tinggi, menjadikannya popular untuk latihan model berskala besar. Walau bagaimanapun, PPO sering memerlukan sejumlah besar data dan boleh sensitif terhadap hiperparameter seperti kadar pembelajaran.

Perbezaan utama antara GRPO dan PPO terletak pada sifat pengoptimuman dasar. Dalam PPO, dasar ini dikemas kini menggunakan objektif yang dipotong untuk mencegah penyimpangan besar dari dasar semasa, yang boleh membawa kepada latihan yang tidak stabil. Fungsi objektif PPO diberikan oleh:

di mana:

Mekanisme "kliping" ini dalam PPO membantu mengelakkan kemas kini dasar yang besar yang boleh menyebabkan ketidakstabilan, tetapi ia juga dapat melambatkan proses pembelajaran, terutama untuk model besar seperti DeepSeek-7b. Objektif yang dipotong memastikan bahawa model tidak membuat kemas kini yang besar dan tidak stabil dengan menghukum penyimpangan besar dalam dasar. Walau bagaimanapun, ia juga memperkenalkan tradeoff antara kestabilan dan kelajuan pembelajaran, terutamanya untuk model yang lebih besar di mana bilangan kemas kini dan kadar pembelajaran mesti ditala dengan teliti.

Sebaliknya, GRPO menggunakan struktur ganjaran yang lebih adaptif dan dinamik yang membolehkannya memaksimumkan prestasi secara langsung pada metrik khusus tugas tanpa bergantung pada pendekatan "amanah". Prosedur pengoptimuman di GRPO tidak memerlukan kliping, dan mekanisme pembelajaran berasaskan ganjarannya menyediakan laluan yang lebih langsung dan cekap untuk penalaan. Akibatnya, GRPO sering memerlukan kemas kini yang lebih sedikit untuk menumpu kepada prestasi yang optimum.

peraturan kemas kini kecerunan untuk parameter θ

Kecerunan untuk mengemas kini parameter model dalam GRPO dikira dengan mengulangi ganjaran melalui model. Jika ganjaran

r_t

pada masa langkah TIS dikira dari output model, peraturan kemas kini kecerunan untuk parameter θis:

Pendekatan keturunan kecerunan ini lebih langsung dan cekap berbanding dengan kaedah kliping PPO, di mana kecerunan diselaraskan berdasarkan fungsi kelebihan. Perbezaan utama antara PPO dan algoritma GRPO diringkaskan di bawah:

unsloth: meningkatkan kecekapan dalam penalaan halus

Model bahasa yang besar seperti DeepSeek-7b adalah mahal, memerlukan memori dan kuasa pemprosesan yang signifikan. Unsloth adalah rangka kerja pengoptimuman yang direka untuk mempercepatkan latihan sambil mengurangkan penggunaan memori secara drastik. Ia amat bermanfaat apabila menggunakan LORA (penyesuaian peringkat rendah) dan GRPO, kerana ia memastikan penggunaan sumber GPU yang cekap dan membolehkan penalaan halus pada perkakasan gred pengguna.

Bagaimana Unsloth Mengoptimumkan Latihan Model?

Unsloth memperkenalkan beberapa pengoptimuman yang meningkatkan kecekapan penalaan model:

• Memuatkan Memori Memori: Unsloth menyokong kuantisasi 4-bit dan 8-bit, mengurangkan jejak memori model sambil mengekalkan prestasi.
• Latihan dan kesimpulan yang cepat: Dengan memanfaatkan perhatian kilat dan pengoptimuman paged, tidak dapat dipercepatkan dengan ketara mempercepatkan kedua -dua latihan dan kesimpulan.
• Pemeriksaan kecerunan: Ia menyokong pemeriksaan kecerunan, yang mengurangkan memori GPU yang diperlukan dengan menyimpan hanya subset pengaktifan dan mengulangi mereka apabila diperlukan.
• Integrasi lancar dengan LORA: Unsloth secara asli menyokong LORA, yang membolehkan pengguna melatih hanya subset parameter model dan bukannya keseluruhan rangkaian.

Proses pemuatan model menggunakan Unsloth adalah mudah dan membolehkan pelaksanaan yang cekap. Butiran yang sama diliputi dalam bahagian berikutnya.

kelebihan menggunakan Unsloth

• mengurangkan penggunaan memori GPU sehingga 50%, membolehkan latihan pada GPU pertengahan peringkat.
• membolehkan latihan lebih cepat dengan mengintegrasikan mekanisme perhatian yang dioptimumkan.
• menyokong VLLM (model bahasa yang sangat besar) untuk pecutan kesimpulan.
• berfungsi dengan lancar dengan GRPO, memastikan penalaan baik berasaskan pembelajaran adalah sumber yang cekap.

Dengan memasukkan Unsloth ke dalam saluran paip penalaan halus, penyelidik dan jurutera dapat memaksimumkan prestasi DeepSeek-7b tanpa menjalankan batasan pengiraan yang sama.

Fine-penalaan DeepSeek-7b dengan GRPO

Membangun di atas asas yang telah kami letakkan di bahagian sebelumnya, di mana kami meliputi seni bina DeepSeek-7b dan algoritma GRPO, kini sudah tiba masanya untuk menyelidiki langkah-langkah praktikal yang diperlukan untuk menyempurnakan model. Bahagian ini akan membimbing anda melalui langkah -langkah yang diperlukan, dari menubuhkan persekitaran untuk mengkonfigurasi jurulatih GRPO, termasuk coretan kod dan penjelasan terperinci untuk setiap bahagian proses.

Model DeepSeek-7B, seperti yang dibincangkan dalam Bahagian 2, adalah alat yang berkuasa untuk mengendalikan tugas-tugas NLP berskala besar, dan apabila dipasangkan dengan GRPO (pengoptimuman pretraining tetulang umum), ia menjadi lebih efisien. Dengan menggunakan pendekatan GRPO, kita dapat menyempurnakan DeepSeek-7B pada tugas-tugas tertentu menggunakan rangka kerja pembelajaran tetulang. Ini membolehkan model bukan sahaja menghasilkan hasil yang lebih baik tetapi juga menyesuaikan diri dengan data baru dengan lebih berkesan daripada kaedah tradisional.

Mari kita meneroka langkah-langkah terperinci untuk penalaan DeepSeek-7B yang baik menggunakan GRPO dan Unsloth, memanfaatkan LORA untuk penggunaan memori yang cekap semasa latihan.

Langkah 1: Menyediakan Alam Sekitar

Untuk bermula dengan, penalaan DeepSeek-7b, anda perlu menubuhkan alam sekitar. Ini termasuk memasang kebergantungan seperti Unsloth, VLLM, dan pakej yang diperlukan. Inilah arahan untuk memasang pakej ini:

!pip install unsloth vllm datasets
!pip install git+https://github.com/huggingface/trl.git

Penjelasan:

• unsloth: Perpustakaan untuk model bahasa yang efisien penalaan dan pengoptimuman memori.
• vllm: membolehkan kesimpulan cepat untuk model besar.
• dataset: Perpustakaan untuk bekerja dengan pelbagai dataset NLP, termasuk yang memeluk muka.

Apabila ini dipasang, kita boleh meneruskan untuk memuatkan model dan mula menunaikan halus.

Langkah 2: Memuatkan model dengan Unsloth

Sekarang, kami akan memuatkan model DeepSeek-7B menggunakan Unsloth. Model ini akan dimuatkan dengan LORA (penyesuaian peringkat rendah) untuk penalaan halus yang cekap. Inilah coretan kod untuk langkah ini:

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/DeepSeek-R1-Distill-Qwen-7B",
    max_seq_length=512,
    load_in_4bit=True,  # Uses 4-bit quantization for memory efficiency
    fast_inference=True,  # Enables fast inference for quicker processing
    max_lora_rank=32,  # LoRA rank for fine-tuning efficiency
    gpu_memory_utilization=0.6  # Controls memory usage
)

Penjelasan:

• Model_name: Kami menentukan model yang akan dimuatkan, dalam kes ini, DeepSeek-R1-Distill-Qwen-7b.
• max_seq_length: mentakrifkan panjang urutan maksimum untuk token input.
• LOAD_IN_4BIT: Menggunakan kuantisasi 4-bit, mengurangkan penggunaan memori dengan ketara.
• fast_inference: Ini membolehkan VLLM mempercepatkan masa kesimpulan.
max_lora_rank:
• pangkat untuk penyesuaian LORA, mengawal saiz matriks peringkat rendah. gpu_memory_utilization:
Laraskan berapa banyak memori GPU digunakan oleh model untuk mengelakkan kesilapan keluar.
• Hasil yang dijangkakan: Model ini akan dimuatkan ke dalam memori dengan konfigurasi yang dioptimumkan, bersedia untuk penalaan dengan LORA.

Langkah 3: Memohon LORA untuk penalaan halus yang cekap

lora

digunakan untuk mengoptimumkan memori untuk model besar seperti DeepSeek-7b. Dengan memohon LORA, kami hanya mengemas kini matriks peringkat rendah dan bukannya keseluruhan model, yang menjadikan memori yang baik. Inilah coretan kod:

Penjelasan:

• r: pangkat matriks LORA. Kedudukan yang lebih tinggi boleh menyebabkan latihan yang lebih bijak tetapi lebih perlahan.
• target_modules: Lapisan model di mana LORA digunakan (mis., Q_PROJ untuk unjuran pertanyaan).
• lora_alpha: Faktor skala yang digunakan untuk mengawal kepentingan lapisan lora.
• use_gradient_checkpointing: Ini mengurangkan penggunaan memori dengan hanya menyimpan kecerunan perantaraan apabila diperlukan.
• random_state: Memastikan kebolehulangan proses penalaan halus.

Hasil yang diharapkan:

Model kini dioptimumkan untuk penggunaan memori dan dapat disesuaikan dengan baik pada dataset yang besar.

Langkah 4: Menyediakan dataset latihan

Fine-penalaan DeepSeek-7b memerlukan dataset yang diformat dengan cara tertentu. Di sini, kami akan memuatkan dan mengubah dataset dari format fail JSON ke objek dataset muka yang memeluk. Inilah kod:

Penjelasan:

!pip install unsloth vllm datasets
!pip install git+https://github.com/huggingface/trl.git

LOAD_AND_TRANSFORM_JSON:
• memuatkan fail JSON dan mengubahnya ke dalam format yang diperlukan untuk latihan. data termasuk soalan
dan
• jawapan untuk setiap entri, bersama-sama dengan prompt yang dihasilkan oleh Hasil yang dijangkakan: Dataset kini dalam format yang betul dan bersedia untuk latihan. Berikut adalah satu sampel dataset. Langkah 5: Merancang fungsi ganjaran untuk output berstruktur
Dalam pembelajaran tetulang, fungsi ganjaran membimbing model ke arah output yang diingini. Di sini, kami menentukan fungsi ganjaran untuk menilai tindak balas model. Contohnya, pemeriksaan ketepatan_reward_func jika jawapan yang diekstrak sepadan dengan jawapan yang diharapkan.

Penjelasan:

ketepatan_reward_func:

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/DeepSeek-R1-Distill-Qwen-7B",
    max_seq_length=512,
    load_in_4bit=True,  # Uses 4-bit quantization for memory efficiency
    fast_inference=True,  # Enables fast inference for quicker processing
    max_lora_rank=32,  # LoRA rank for fine-tuning efficiency
    gpu_memory_utilization=0.6  # Controls memory usage
)

Membandingkan respons yang diekstrak dengan jawapan yang diharapkan. Jika mereka sepadan, ia memberi ganjaran sebanyak 2.0, lain -lain 0.0.

int_reward_func:

• memberi ganjaran kepada model untuk menghasilkan respons angka. strict_format_reward_func:
• Memastikan output model mengikuti format XML yang ketat, memberi ganjaran untuk output yang dibentuk dengan baik. soft_format_reward_func:
• cek jika output model longgar mematuhi format yang dikehendaki. xmlcount_reward_func:
Menilai seberapa baik output mengikuti struktur XML, dengan penalti untuk respons yang tidak berstruktur.
• Hasil yang diharapkan:
Fungsi ganjaran ini membimbing model ke arah menghasilkan respons yang bukan sahaja betul tetapi juga berstruktur dengan baik dan dalam format yang dikehendaki.

• Langkah 6: Mengkonfigurasi Jurulatih GRPO

  Sekarang, kami akan mengkonfigurasi grpotrainer untuk menggunakan dataset latihan dan fungsi ganjaran. Objek Grpoconfig digunakan untuk menentukan parameter latihan seperti kadar pembelajaran dan saiz batch.

  !pip install unsloth vllm datasets
  !pip install git+https://github.com/huggingface/trl.git

  Penjelasan:

  • grpoconfig: Mengkonfigurasi pelbagai parameter latihan seperti kadar pembelajaran, saiz batch, dan bilangan generasi yang akan dihasilkan.
  Grpotrainer:
  • Kelas ini bertanggungjawab untuk proses latihan sebenar. Ia memerlukan model, tokenizer, fungsi ganjaran, dan hujah latihan.
  Penjelasan Parameter Grpoconfig:
  learning_rate:
  • Kadar pembelajaran untuk pengoptimuman model. Nilai yang lebih rendah seperti 5E-6 membolehkan latihan yang stabil di atas banyak lelaran.
  per_device_train_batch_size:
  • saiz batch untuk setiap langkah latihan. Di sini, ia ditetapkan kepada 1, yang bermaksud setiap GPU akan memproses satu contoh pada satu masa.
  num_generations:
  • Bilangan generasi yang dihasilkan oleh model semasa setiap langkah penalaan halus.
  max_prompt_length:
  • panjang token maksimum untuk prompt input.
  max_completion_length:
  • panjang token maksimum untuk output model.
  max_steps:
  • Bilangan langkah latihan untuk dilakukan.
  Hasil yang dijangkakan:

  Model ini akan dilatih dengan algoritma GRPO menggunakan fungsi ganjaran yang ditetapkan, penalaan model untuk melakukan lebih baik pada dataset yang diberikan.
  

  menjimatkan dan memuatkan semula model halus

  Setelah model DeepSeek-7B telah disesuaikan dengan GRPO dan LORA, penting untuk menyelamatkan model ke cakera atau penyimpanan awan untuk kegunaan masa depan. Dalam bahagian ini, kami akan merangkumi cara menyelamatkan model yang disesuaikan dengan halus dan memuatkannya lagi untuk kesimpulan. Ini memastikan bahawa anda dapat meneruskan kemajuan anda dan mengelakkan latihan semula dari awal.

  Menyimpan model lora-fine-disesuaikan

  Selepas model telah disesuaikan dengan LORA dan GRPO, anda perlu menyimpannya ke lokasi penyimpanan. Ini adalah langkah penting untuk memastikan bahawa anda boleh memuatkan semula model kemudian tanpa perlu melatih semula. Berikut adalah cara anda boleh menyimpan model yang disesuaikan dengan baik, termasuk berat khusus LORA, ke cakera:

  Penjelasan:

  from unsloth import FastLanguageModel
  
  model, tokenizer = FastLanguageModel.from_pretrained(
      model_name="unsloth/DeepSeek-R1-Distill-Qwen-7B",
      max_seq_length=512,
      load_in_4bit=True,  # Uses 4-bit quantization for memory efficiency
      fast_inference=True,  # Enables fast inference for quicker processing
      max_lora_rank=32,  # LoRA rank for fine-tuning efficiency
      gpu_memory_utilization=0.6  # Controls memory usage
  )

  • model.save_pretrained: Ini menjimatkan kedua-dua berat model dan lapisan khusus LORA (seperti matriks penyesuaian peringkat rendah).
  • tokenizer.save_pretrained: menjimatkan tokenizer, yang termasuk logik tokenisasi seperti token dan perbendaharaan kata khas.
  model_save_path:
  • direktori di mana anda ingin menyimpan model. Ini boleh menjadi laluan tempatan atau direktori awan (mis., Google Drive, S3).
  Hasil yang dijangkakan:

  Model dan tokenizer akan disimpan ke jalan yang ditentukan, menjadikannya tersedia untuk kegunaan masa depan. Anda kemudiannya boleh menggunakan model yang disimpan ini untuk memuatkan semula versi yang tepat untuk kesimpulan tanpa perlu melatih semula.
  Memuatkan model untuk kesimpulan masa depan

  Sebaik sahaja anda telah menyimpan model yang disesuaikan dengan halus, anda boleh memuatkannya semula ke dalam ingatan untuk kesimpulan atau penalaan halus. Inilah kod untuk memuatkan model dan tokenizer yang disimpan, bersama dengan konfigurasi khusus LORA:

  !pip install unsloth vllm datasets
  !pip install git+https://github.com/huggingface/trl.git

  Penjelasan:
  fastlanguagemodel.from_pretrained:
  • Fungsi ini memuatkan berat model dan tokenizer yang disimpan dari laluan yang ditentukan.
  max_lora_rank:
  • Kedudukan LORA yang digunakan semasa kesimpulan mesti sepadan dengan apa yang digunakan semasa penalaan halus untuk memastikan penyesuaian yang betul digunakan.
  LOAD_IN_4BIT DAN GPU_MEMORY_UTILIZATION:
  • Memastikan model terus menjadi efisien memori apabila dimuatkan untuk kesimpulan.
  Hasil yang diharapkan:

  Model ini dimuatkan dari direktori yang disimpan, bersama -sama dengan konfigurasi LORA, yang membolehkan anda melakukan kesimpulan dengan cekap. Ini bermakna model akan memanfaatkan parameter yang disempurnakan, dan anda boleh mula menghasilkan respons atau menjalankan tugas tanpa memohon semula proses penalaan yang baik. di bawah adalah contoh output pada dataset yang digunakan untuk menyempurnakan blog ini. Ia berkaitan dengan aliran aliran proses. Lihat bagaimana alasan model dan menghasilkan respons kepada pertanyaan. Penalaan halus dengan model GRPO menggabungkan keupayaan penalaran, yang ditunjukkan dalam jawapan di bawah.
  

  pilihan lanjutan: menyimpan ke penyimpanan awan

  Jika anda ingin menyimpan model ke penyimpanan awan (seperti Google Drive atau Amazon S3), anda boleh mengubah suai model_save_path untuk menunjuk ke direktori awan masing -masing. Berikut adalah contoh untuk menyimpan ke Google Drive menggunakan

  gdown
  :

  untuk Amazon S3,

  from unsloth import FastLanguageModel
  
  model, tokenizer = FastLanguageModel.from_pretrained(
      model_name="unsloth/DeepSeek-R1-Distill-Qwen-7B",
      max_seq_length=512,
      load_in_4bit=True,  # Uses 4-bit quantization for memory efficiency
      fast_inference=True,  # Enables fast inference for quicker processing
      max_lora_rank=32,  # LoRA rank for fine-tuning efficiency
      gpu_memory_utilization=0.6  # Controls memory usage
  )

  anda boleh menggunakan perpustakaan

  BOTO3 untuk memuat naik model: Penjelasan:

  • gdown.upload: Fungsi ini memuat naik model dari persekitaran tempatan anda ke Google Drive.
  • Boto3: Python SDK Amazon untuk berinteraksi dengan perkhidmatan AWS seperti S3. Ia membolehkan anda memuat naik model anda terus ke baldi S3.

  Hasil yang diharapkan:
  Anda boleh menyimpan dan mengakses model dari awan, menjadikannya mudah untuk dikongsi dan digunakan pada persekitaran lain.

  perangkap biasa dan penyelesaian masalah
  Apabila penalaan model besar seperti DeepSeek-7b, beberapa perangkap biasa boleh timbul, terutamanya yang berkaitan dengan memori GPU, konfigurasi latihan, dan penalaan fungsi ganjaran. Menyedari isu-isu ini dan memahami bagaimana menyelesaikan masalah mereka dapat menjimatkan banyak masa semasa proses penalaan halus.
  1. Overload memori GPU
  Model besar penalaan sering membawa kepada beban memori GPU, terutamanya apabila menggunakan konfigurasi lanjutan seperti LORA atau latihan dengan saiz batch yang tinggi. Untuk mengurangkan ini:
  Kurangkan saiz batch atau laraskan
  • per_device_train_batch_size parameter dalam grpoconfig untuk dimuatkan dalam ingatan GPU anda.
  Gunakan pemeriksaan kecerunan dengan menetapkan
  • use_gradient_checkpointing = "unsloth" , yang menyimpan pengaktifan perantaraan untuk mengurangkan penggunaan memori.
  Kurangkan pangkat LORA jika anda menghadapi masalah memori -pangkat yang lebih tinggi menuntut memori kurang.
  2. Model yang tidak betul Memuatkan
  Kadang-kadang, konfigurasi pemuatan model yang salah boleh menyebabkan masalah, terutamanya apabila memuatkan model besar dalam ketepatan 4-bit atau dengan LORA. Pastikan untuk:
  mengesahkan bahawa pangkat LORA dan konfigurasi khusus model lain (seperti
  • max_lora_rank dan Pastikan bahawa vllm didayakan untuk kesimpulan cepat apabila bekerja dengan model besar untuk mengelakkan kelewatan yang tidak perlu.
  • 3. Fungsi ganjaran ketidakpadanan Fine-penalaan dengan fungsi ganjaran memerlukan pertimbangan yang teliti. Konfigurasi fungsi ganjaran yang tidak betul atau terlalu ketat boleh menghalang pembelajaran, menjadikan model melakukan sub-optimum. Untuk menyelesaikan masalah:
    1. Semak semula pelaksanaan fungsi ganjaran seperti ketepatan_reward_func dan ambang ganjaran halus dan mekanisme pemarkahan jika model menghasilkan respons yang tidak menentu atau tidak diingini.
  • 4. Isu Data
  Kualiti data dan pemformatan adalah penting untuk latihan yang berjaya. Jika anda menggunakan dataset tersuai, ubahnya ke dalam format dataset muka yang memeluk dan pastikan parsing yang betul dan pra-pemprosesan mana-mana input berasaskan JSON. Sentiasa periksa dataset untuk sebarang percanggahan atau bidang yang hilang, terutamanya dalam fungsi ganjaran yang kompleks seperti ketepatan_reward_func, yang bergantung pada pemadanan jawapan yang tepat.

  5. Konfigurasi Konfigurasi Latihan

  Konflik dalam konfigurasi latihan, seperti kadar pembelajaran yang tidak sesuai, tetapan pengoptimal, atau langkah pengumpulan kecerunan, boleh menyebabkan prestasi suboptimal atau penumpuan yang lebih perlahan. Sentiasa pastikan bahawa parameter dalam konfigurasi GRPO disesuaikan mengikut keperluan khusus perkakasan dan objektif latihan anda. Di samping itu, kadar pembelajaran yang rendah dengan langkah -langkah pengumpulan kecerunan yang tinggi dapat membantu menstabilkan latihan untuk model yang sangat besar.

  Dengan menangani perangkap biasa dan pemantauan memori, pemformatan data, dan keberkesanan fungsi ganjaran, anda boleh menyelaraskan proses penalaan halus dan memastikan latihan model yang lebih lancar.

  Bonus
  :

  Sekarang, adakah anda teruja untuk mula bereksperimen dengan model DeepSeek terkini? Jangan ragu untuk menggunakan buku nota untuk blog ini dan membangunkannya untuk kes penggunaan anda!

  Kesimpulan Dalam panduan ini, kami meneroka proses penalaan GRPO pada DeepSeek-7B (pengoptimuman pretraining tetulang umum) dan LORA (penyesuaian peringkat rendah), menggabungkan kekuatan teknologi ini untuk mengoptimumkan latihan model yang besar. Kami bermula dengan membincangkan seni bina DeepSeek-7B dan GRPO, yang menggariskan peranan yang tidak terjual dalam pengurusan ingatan dan latihan model yang cekap. Kami juga menunjukkan langkah-langkah praktikal yang terlibat, dari menubuhkan persekitaran dan memuatkan model dengan LORA untuk menerapkan fungsi ganjaran berasaskan pembelajaran tetulang untuk penalaan halus.

  Penalaan halus yang berkesan menggabungkan GRPO dan LORA: GRPO meningkatkan pembelajaran melalui kemas kini berasaskan dasar, sementara LORA membolehkan latihan efisien memori. Kami menunjukkan fungsi ganjaran yang menentukan, mengoptimumkan dengan grpotrainer, dan memastikan kebolehgunaan model melalui penjimatan dan tambah nilai. Cabaran utama termasuk skala kepada dataset yang lebih besar dan fungsi ganjaran penapisan untuk kesesuaian yang lebih baik. Memperluas GRPO ke model multi-modal dapat memajukan keupayaan AI lagi.

  Takeaways Key

  • DeepSeek-7b dan GRPO menyediakan asas yang kuat untuk model berskala besar dengan pengoptimuman berasaskan pembelajaran tetulang.
  • LORA mengoptimumkan penggunaan memori dan membolehkan penalaan halus pada model besar dengan menggunakan penyesuaian peringkat rendah.
  • GRPO berbeza daripada kaedah tradisional seperti PPO dengan menawarkan kemas kini berasaskan dasar, yang membawa kepada latihan yang lebih cekap.
  • Mendefinisikan fungsi ganjaran yang berstruktur dengan baik adalah penting dalam pembelajaran pengukuhan yang baik, membimbing model ke arah output berkualiti tinggi.
  • Proses penjimatan dan tambah nilai model yang disempurnakan dengan baik memastikan kebolehgunaan semula dan prestasi model jangka panjang.
  • Penambahbaikan masa depan boleh memberi tumpuan kepada skala kepada dataset yang lebih besar, bereksperimen dengan fungsi ganjaran baru, dan memohon GRPO untuk model multi-modal (teks, imej, audio).

  Media yang ditunjukkan dalam artikel ini tidak dimiliki oleh Analytics Vidhya dan digunakan pada budi bicara penulis.

  Soalan Lazim

  Q1. Apakah peranan GRPO dalam proses penalaan halus?

  Ans. GRPO (pengoptimuman pretraining tetulang umum) mengoptimumkan fasa pretraining model dengan menggabungkan pembelajaran tetulang dengan kaedah penalaan tradisional. Ia meningkatkan kecekapan pembelajaran model dengan menggabungkan pengoptimuman berasaskan dasar, memastikan model menyesuaikan diri dengan tugas tertentu dengan langkah-langkah yang lebih sedikit. GRPO mengurangkan masa latihan dan meningkatkan prestasi keseluruhan model besar seperti DeepSeek-7b.

  Q2. Bagaimanakah LORA (penyesuaian peringkat rendah) meningkatkan kecekapan memori?

  Ans. Lora mengoptimumkan penalaan model besar dengan menggunakan penyesuaian peringkat rendah ke bahagian tertentu model. Daripada menyempurnakan keseluruhan model, LORA hanya menyesuaikan subset kecil berat (yang mempunyai kesan yang paling kepada prestasi), yang mengurangkan penggunaan memori dan masa pengiraan. Ini membolehkan model seperti DeepSeek-7b untuk disesuaikan dengan perkakasan yang lebih kecil tanpa mengorbankan prestasi.

  Q3. Kenapa pemeriksaan kecerunan penting apabila melatih model besar?

  Ans. Pemeriksaan kecerunan adalah teknik penjimatan memori yang digunakan semasa backpropagation dalam latihan model. Dengan menyimpan pengaktifan perantaraan di pusat pemeriksaan tertentu, ia mengurangkan penggunaan memori, membolehkan latihan model yang lebih besar pada sumber GPU terhad. Ini amat berguna apabila model penalaan halus seperti DeepSeek-7b, di mana penggunaan memori boleh menjadi hambatan.

  Q4. Bolehkah saya menyempurnakan DeepSeek-7b pada dataset kecil?

  Ans. Penalaan halus pada dataset yang lebih kecil adalah mungkin tetapi mungkin kurang berkesan jika dataset tidak mempunyai kepelbagaian atau tidak mewakili tugas. Dataset yang lebih besar membolehkan model untuk umum lebih baik. Untuk dataset yang lebih kecil, anda mungkin perlu menggunakan teknik seperti pembesaran data atau pemindahan pembelajaran dari model pra-terlatih untuk mencapai hasil yang memuaskan.

Atas ialah kandungan terperinci GRPO Fine-penalaan di DeepSeek-7b dengan Unsloth. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!