Bagaimana cara menukar model ke format GGUF?

Sebagai model bahasa yang besar (LLMS) terus berkembang secara berskala, begitu juga keperluan untuk cara yang cekap untuk menyimpan, menyebarkan, dan menjalankannya pada peranti sumber rendah. Walaupun model -model ini menawarkan keupayaan yang kuat, saiz dan permintaan memori mereka dapat membuat penempatan sebagai cabaran, terutama pada perkakasan pengguna. Di sinilah kuantisasi model dan format penyimpanan khusus seperti GGUF (format bersatu GPT generik) dimainkan.

Dalam panduan ini, kami akan menyelidiki format GGUF, meneroka faedahnya, dan memberikan tutorial langkah demi langkah mengenai model menukar kepada GGUF. Di sepanjang jalan, kami akan menyentuh sejarah kuantisasi model dan bagaimana GGUF berkembang untuk menyokong LLM moden. Pada akhirnya, anda akan mempunyai pemahaman yang mendalam tentang mengapa masalah GGUF dan bagaimana untuk mula menggunakannya untuk model anda sendiri.

Objektif pembelajaran

• Memahami tujuan dan struktur format GGUF dan evolusinya dari GGML.
• Tentukan kuantisasi dan terangkan kepentingannya dalam mengurangkan saiz model dan meningkatkan kecekapan penempatan.
• Mengiktiraf komponen Konvensyen Penamaan GGUF dan bagaimana mereka membantu dalam pengenalan dan pengurusan model.
• Gunakan llama.cpp untuk mengukur model ke format GGUF.
• Berikan konsep GGUF dan kuantisasi kepada kes-kes penggunaan praktikal, membolehkan penggunaan model AI yang berkesan dalam persekitaran yang terkawal sumber.

Artikel ini diterbitkan sebagai sebahagian daripada Blogathon Sains Data.

Jadual Kandungan

• Evolusi kuantisasi model
• Apa itu GGUF?
• Mengapa menggunakan GGUF?
• Struktur Format GGUF dan Konvensyen Penamaan
• Menyediakan penukaran ke format GGUF
• Menukar Model ke GGUF
• Amalan terbaik untuk penukaran GGUF
• Masa Depan Format Penyimpanan GGUF dan Model
• Kesimpulan
• Soalan yang sering ditanya

Evolusi kuantisasi model

Perjalanan ke arah GGUF bermula dengan memahami evolusi kuantisasi model. Kuantisasi mengurangkan ketepatan parameter model, dengan berkesan memampatkannya untuk mengurangkan permintaan memori dan pengiraan. Inilah gambaran ringkas:

Format dan cabaran awal

Pada masa -masa awal, model pembelajaran mendalam disimpan dalam format rangka kerja asli seperti Tensorflow dan Pytorch. Model Tensorflow yang digunakan .pb Fail, manakala Pytorch digunakan .pt atau .pth. Format ini bekerja untuk model yang lebih kecil tetapi membentangkan batasan:

• Saiz: Model disimpan dalam format terapung 32-bit, menjadikan saiz fail besar.
• Penggunaan Memori: Berat badan penuh menuntut memori yang besar, membuat penggunaan pada peranti dengan RAM terhad tidak praktikal.

ONNX (Buka Neural Network Exchange)

Kebangkitan interoperabilitas merentasi kerangka menyebabkan pembangunan ONNX, yang membolehkan model bergerak antara persekitaran. Walau bagaimanapun, sementara ONNX menyediakan beberapa pengoptimuman, ia masih dibina terutamanya di sekitar berat ketepatan penuh dan menawarkan sokongan kuantisasi terhad.

Perlu kuantisasi

Apabila model semakin besar, para penyelidik beralih kepada kuantisasi, yang memampatkan berat dari terapung 32-bit (FP32) hingga 16-bit (FP16) atau bahkan lebih rendah, seperti integer 8-bit (INT8). Pendekatan ini memotong keperluan memori dengan ketara, menjadikannya mungkin untuk menjalankan model pada lebih banyak jenis perkakasan. Contohnya:

 # Import perpustakaan yang diperlukan
obor import
import obor.nn sebagai nn
obor import

# Langkah 1: Tentukan model rangkaian saraf yang mudah di pytorch
Kelas Simplemodel (NN.Module):
    def __init __ (diri):
        super (simplemodel, diri) .__ init __ ()
        self.fc1 = nn.linear (10, 50) # Lapisan yang disambungkan sepenuhnya
        self.fc2 = nn.linear (50, 20) # Lapisan yang disambungkan sepenuhnya kedua
        self.fc3 = nn.linear (20, 5) # lapisan output

    def forward (diri, x):
        x = obor.relu (self.fc1 (x)) # pengaktifan relu selepas lapisan pertama
        x = obor.relu (self.fc2 (x)) # pengaktifan relu selepas lapisan kedua
        x = self.fc3 (x) # lapisan output
        kembali x

# Langkah 2: Mulakan model dan beralih ke mod penilaian
Model = SimpleModel ()
model.eval ()

# Simpan model sebelum kuantisasi untuk rujukan
obor.save (model, "simple_model.pth")

# Langkah 3: Gunakan kuantisasi dinamik ke model
# Di sini, kita hanya mengukur lapisan linear, menukar beratnya kepada int8
Quantized_model = quant.quantize_dynamic (
    model, {nn.linear}, dtype = obor.qint8
)

# Simpan model kuantitatif
obor.save (quantized_model, "quantized_simple_model.pth")

# Contoh penggunaan model kuantitatif dengan data dummy
dummy_input = obor.randn (1, 10) # Contoh Tensor input dengan 10 ciri
output = kuantiti_model (dummy_input)
Cetak ("Output Model Kuantiti:", Output)

Memeriksa saiz model asal dan kuantitatif

Apabila bekerja dengan model bahasa yang besar, memahami perbezaan saiz antara versi asal dan kuantitatif adalah penting. Perbandingan ini bukan sahaja menyoroti manfaat pemampatan model tetapi juga memaklumkan strategi penempatan untuk penggunaan sumber yang cekap.

 Import OS

# Laluan ke model yang disimpan
original_model_path = "simple_model.pth"
Quantized_model_path = "Quantized_simple_model.pth"

# Berfungsi untuk mendapatkan saiz fail dalam kb
def get_file_size (jalan):
    size_bytes = os.path.getSize (Path)
    size_kb = size_bytes / 1024 # tukar ke kb
    Kembali size_kb

# Periksa saiz model asal dan kuantitatif
original_size = get_file_size (original_model_path)
Quantized_size = get_file_size (quantized_model_path)

cetak (f "saiz model asal: {original_size: .2f} kb")
cetak (f "saiz model kuantitatif: {quantized_size: .2f} kb")
cetak (f "pengurangan saiz: {((original_size - quantized_size) / original_size) * 100: .2f}%")

Walau bagaimanapun, ketepatan 8-bit tidak mencukupi untuk model bahasa yang sangat besar seperti GPT-3 atau LLAMA, yang mendorong perkembangan format baru seperti GGML dan, akhirnya, GGUF.

Apa itu GGUF?

GGUF, atau format bersatu GPT generik, telah dibangunkan sebagai lanjutan kepada GGML untuk menyokong model yang lebih besar. Ia adalah format fail untuk menyimpan model untuk kesimpulan dengan GGML dan pelaksana berdasarkan GGML. GGUF adalah format binari yang direka untuk memuatkan dan menyimpan model cepat, dan untuk memudahkan bacaan. Model secara tradisinya dibangunkan menggunakan pytorch atau rangka kerja lain, dan kemudian ditukar kepada GGUF untuk digunakan dalam GGML.

GGUF adalah format fail pengganti untuk GGML, GGMF dan GGJT, dan direka untuk menjadi tidak jelas dengan mengandungi semua maklumat yang diperlukan untuk memuatkan model. Ia juga direka untuk diperluaskan, supaya maklumat baru dapat ditambah kepada model tanpa melanggar keserasian. Ia direka dengan tiga gol dalam fikiran:

• Kecekapan: Membolehkan model besar berjalan dengan cekap pada CPU dan perkakasan gred pengguna.
• Skalabiliti: Menyokong model yang sangat besar, sering 100GB atau lebih.
• Fleksibiliti: Membolehkan pemaju memilih antara tahap kuantisasi yang berbeza, mengimbangi saiz model dan ketepatan.

Mengapa menggunakan GGUF?

Format GGUF bersinar untuk pemaju yang perlu menggunakan model besar dan sumber yang berat pada perkakasan terhad tanpa mengorbankan prestasi. Berikut adalah beberapa kelebihan teras:

• Sokongan kuantisasi: GGUF menyokong pelbagai tahap kuantisasi (4-bit, 8-bit), yang membolehkan penjimatan memori yang signifikan sambil mengekalkan ketepatan model.
• Penyimpanan Metadata: GGUF boleh menyimpan metadata terperinci, seperti seni bina model, skim tokenisasi, dan tahap kuantisasi. Metadata ini menjadikannya lebih mudah untuk memuat dan mengkonfigurasi model.
• Pengoptimuman Inferensi: GGUF mengoptimumkan penggunaan memori, yang membolehkan kesimpulan yang lebih cepat terhadap sistem berasaskan CPU.

Struktur Format GGUF dan Konvensyen Penamaan

Format GGUF menggunakan konvensyen penamaan khusus untuk memberikan maklumat model utama sekilas. Konvensyen ini membantu pengguna mengenal pasti ciri-ciri model penting seperti seni bina, saiz parameter, jenis penalaan halus, versi, jenis pengekodan, dan pengurusan model dan penggunaan data yang lebih mudah.

Konvensyen Penamaan GGUF mengikuti struktur ini:

Setiap komponen dalam nama memberikan wawasan tentang model:

• Basename: Nama deskriptif untuk jenis asas model atau seni bina, yang diperolehi dari metadata (misalnya, llama atau mixtral).
• Sizelabel: Menunjukkan saiz model, menggunakan format X iaitu : bilangan pakar (misalnya, 8), : skala parameter model, seperti q untuk quadrillion, t untuk trilion, b untuk bilion, m untuk juta, k untuk ribuan parameter.
• Finetune: Model matlamat penalaan halus, seperti "sembang" atau "mengarahkan."
• Versi: Nombor versi model dalam v . Format, dengan v1.0 sebagai lalai jika tidak ditentukan.
• Pengekodan: Skim pengekodan berat, disesuaikan setiap projek.

• Jenis: Menunjukkan jenis fail GGUF, seperti LORA untuk penyesuai atau Vocab untuk data perbendaharaan kata.
• Shard: Menandakan model berpecah menjadi bahagian, diformat sebagai -of- .

Contoh penamaan

Menyediakan penukaran ke format GGUF

Sebelum menyelam ke dalam penukaran, pastikan anda mempunyai prasyarat berikut:

• Python 3.8 dipasang pada sistem anda.
• Fail sumber model: Biasanya, model pytorch atau tensorflow (misalnya, llama, falcon) atau model dari muka yang memeluk.
• Alat Penukaran GGUF: Alat ini, sering berdasarkan perpustakaan GGML atau skrip penukaran model tertentu.

Beberapa teknik kuantisasi yang patut diberi perhatian

Teknik kuantisasi memainkan peranan penting dalam mengoptimumkan rangkaian saraf dengan mengurangkan saiz dan keperluan pengiraannya. Dengan menukarkan berat dan pengaktifan ketepatan tinggi untuk representasi bit yang lebih rendah, kaedah ini membolehkan penggunaan model yang cekap tanpa menjejaskan prestasi yang ketara.

Menukar Model ke GGUF

Berikut adalah bagaimana anda boleh menukar model anda ke format GGUF.

Langkah 1: Pilih model untuk mengukur

Dalam kes ini, kami memilih model Flan-T5 Google untuk mengukur. Anda boleh mengikuti arahan untuk memuat turun model secara langsung dari Huggingface

 ! Pip Pasang Huggingface-Hub

dari huggingface_hub import snapshot_download

Model_ # Ganti dengan ID model yang ingin anda muat turun
snapshot_download (repo_id = model_id, local_dir = "t5")

Langkah 2: Klon repositori llama.cpp

Kami menggunakan llama.cpp untuk mengukur model ke format gguf

 ! Git clone https://github.com/ggerganov/llama.cpp

Langkah 3: Pasang kebergantungan yang diperlukan

Jika di Google Collaboratory, ikuti kod di bawah, jika tidak, anda boleh menavigasi ke direktori keperluan untuk memasang "Keperluan-CONVERT_HF_TO_GGUF.TXT"

 ! pip install -r /content/llama.cpp/requirements/requirements-convert_hf_to_gguf.txt

Langkah 4: Pilih tahap kuantisasi

Tahap kuantisasi menentukan perdagangan antara saiz model dan ketepatan. Kuantisasi rendah (seperti 4-bit) menjimatkan memori tetapi boleh mengurangkan ketepatan. Sebagai contoh, jika anda menyasarkan penempatan CPU sahaja dan tidak memerlukan ketepatan maksimum, INT4 mungkin pilihan yang baik. Di sini kita memilih "Q8_0".

Langkah 5: Jalankan skrip penukaran

Jika di Google Collab, jalankan skrip di bawah, lain ikuti komen.

 #! python {Path to conver_hf_to_gguf.py} {Path to hf_model} --outfile {name_of_outputfile.gguf} --outtype {kuantisasi jenis}

! python /content/llama.cpp/convert_hf_to_gguf.py/content/t5 --outfile t5.gguf --Outtype Q8_0

• Laluan ke HF_Model: Laluan ke direktori model.
• Name_of_outputfile.gguf: Nama fail output di mana model GGUF akan disimpan. Gunakan konvensyen penamaan GGUF jika menolak model kuantitatif kembali untuk memeluk muka.
• Jenis kuantisasi: Menentukan jenis kuantisasi (dalam kes ini, integer 8-bit kuantiti).

Membandingkan saiz model vs kuantiti asal

Apabila menggunakan model pembelajaran mesin, memahami perbezaan saiz antara versi asal dan kuantitatif adalah penting. Perbandingan ini menyoroti bagaimana kuantisasi dapat mengurangkan saiz model dengan ketara, yang membawa kepada kecekapan yang lebih baik dan masa kesimpulan yang lebih cepat tanpa kehilangan ketepatan yang besar.

 # Periksa saiz model asal dan kuantitatif
original_model_path = "/content/t5/model.safetensors"
kuantiti_model_path = "t5.gguf"
original_size = get_file_size (original_model_path)
Quantized_size = get_file_size (quantized_model_path)

cetak (f "saiz model asal: {original_size: .2f} kb")
cetak (f "saiz model kuantitatif: {quantized_size: .2f} kb")
cetak (f "pengurangan saiz: {((original_size - quantized_size) / original_size) * 100: .2f}%")

Kita dapat melihat pengurangan saiz 73.39% yang mengejutkan menggunakan teknik kuantisasi GGUF.

Amalan terbaik untuk penukaran GGUF

Untuk mendapatkan hasil yang terbaik, simpan petua ini:

• Eksperimen dengan tahap kuantisasi: Menguji pelbagai tahap (contohnya, 4-bit, 8-bit) untuk mencari keseimbangan terbaik antara ketepatan model dan kecekapan memori.
• Gunakan metadata untuk kelebihan anda: Penyimpanan metadata yang luas GGUF dapat memudahkan pemuatan model dan mengurangkan keperluan konfigurasi runtime.
• Kesimpulan Benchmark: Sentiasa penanda aras model GGUF pada perkakasan sasaran anda untuk memastikan ia memenuhi keperluan kelajuan dan ketepatan.

Masa Depan Format Penyimpanan GGUF dan Model

Apabila model terus berkembang, format seperti GGUF akan memainkan peranan yang semakin kritikal dalam membuat AI berskala besar boleh diakses. Kami tidak lama lagi akan melihat teknik kuantisasi yang lebih maju yang mengekalkan ketepatan yang lebih tinggi sambil mengurangkan keperluan memori. Buat masa ini, GGUF kekal di barisan hadapan, membolehkan penggunaan model bahasa yang besar pada peranti CPU dan Edge.

Kesimpulan

Format GGUF adalah penukar permainan untuk menggunakan model bahasa yang besar dengan cekap pada peranti sumber terhad. Dari usaha awal dalam kuantisasi model kepada pembangunan GGUF, landskap penyimpanan model AI telah berkembang untuk membuat model yang kuat dapat diakses oleh penonton yang lebih luas. Dengan mengikuti panduan ini, kini anda boleh menukar model ke format GGUF, menjadikannya lebih mudah untuk menggunakannya untuk aplikasi dunia nyata.

Kuantisasi akan terus berkembang, tetapi keupayaan GGUF untuk menyokong tahap ketepatan yang berbeza -beza dan pengurusan metadata yang cekap memastikan ia tetap relevan. Cuba menukar model anda ke GGUF dan meneroka manfaat secara langsung!

Takeaways utama

• Format bersatu GPT generik (GGUF) membolehkan penyimpanan dan penggunaan model bahasa yang besar (LLMS) pada peranti sumber rendah, menangani cabaran yang berkaitan dengan saiz model dan permintaan memori.
• Kuantisasi dengan ketara mengurangkan saiz model dengan memampatkan parameter, membolehkan model dijalankan pada perkakasan gred pengguna sambil mengekalkan tahap prestasi penting.
• Format GGUF mempunyai konvensyen penamaan berstruktur yang membantu mengenal pasti ciri -ciri model utama, memudahkan pengurusan dan penggunaan yang lebih mudah.
• Menggunakan alat seperti llama.cpp, pengguna dengan mudah boleh menukar model ke format GGUF, mengoptimumkannya untuk digunakan tanpa mengorbankan ketepatan.
• GGUF menyokong tahap kuantisasi lanjutan dan penyimpanan metadata yang luas, menjadikannya penyelesaian yang berpandangan ke hadapan untuk penggunaan model AI yang semakin besar.

Soalan yang sering ditanya

Q1. Apa itu GGUF dan bagaimana ia berbeza dari GGML?

A. GGUF (format bersatu GPT generik) adalah format penyimpanan model canggih yang direka untuk menyimpan dan menjalankan model bahasa besar yang dikira. Tidak seperti pendahulunya, GGML, yang mempunyai skalabilitas terhad untuk model melebihi 100GB, GGUF menyokong pilihan kuantisasi 4-bit dan 8-bit yang luas dan menyediakan keupayaan penyimpanan metadata yang kaya, meningkatkan pengurusan model dan penempatan.

S2. Bagaimanakah prestasi model kesan kuantisasi?

A. Kuantisasi mengurangkan ketepatan parameter model, dengan ketara mengurangkan saiz dan penggunaan memori. Walaupun ia boleh menyebabkan sedikit ketepatan, teknik kuantisasi yang direka dengan baik (seperti yang ada di GGUF) dapat mengekalkan tahap prestasi yang boleh diterima, menjadikannya mungkin untuk menggunakan model besar pada peranti yang dikendalikan oleh sumber.

Q3. Apakah komponen utama konvensyen penamaan GGUF?

A. Konvensyen Penamaan GGUF terdiri daripada beberapa komponen, termasuk nama bas (seni bina model), Sizelabel (kelas berat parameter), Finetune (matlamat penalaan), versi (nombor versi model), pengekodan (skema pengekodan berat), jenis (tujuan fail) Bersama -sama, komponen ini memberikan maklumat penting mengenai model ini.

Q4. Bagaimana saya boleh mengesahkan nama fail GGUF?

A. Anda boleh mengesahkan nama fail GGUF menggunakan ekspresi biasa yang memeriksa kehadiran sekurang -kurangnya nama base, sizelabel, dan versi dalam urutan yang betul. Ini memastikan fail mematuhi konvensyen penamaan dan mengandungi maklumat yang diperlukan untuk pengenalan model.

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

Atas ialah kandungan terperinci Bagaimana cara menukar model ke format GGUF?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!