Bayangkan menggunakan model bahasa yang berkuasa seperti GPT-2—mampu mencipta cerita, menjawab soalan dan meniru teks manusia—dan memampatkannya menjadi versi yang lebih ramping dan lebih pantas tanpa menjejaskan keupayaannya.

Ini adalah janji pengkuantitian: teknik yang mengurangkan ketepatan pengiraan model, memperdagangkan ketepatan marginal untuk keuntungan kecekapan yang dramatik.

Fasa 0: Persediaan Teknikal

    !pip install torch transformers accelerate bitsandbytes psutil

    from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
    import torch
    import time
    import gc

    def get_memory_usage():
        return torch.cuda.memory_allocated() / 1e6 if torch.cuda.is_available() else 0


    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model_name = "gpt2"
    input_text = "Once upon a time"

Fasa 1: Garis Dasar – Ketepatan Penuh (FP32)

Percubaan bermula dengan GPT-2 dalam keadaan semula jadi: ketepatan titik terapung 32-bit (FP32). Ini ialah mod "kuasa penuh" model—sangat tepat tetapi intensif sumber.

• Memori: Memuatkan model FP32 menggunakan 511 MB memori GPU.
• Kelajuan: Menjana 50 token daripada gesaan “Pada suatu masa dahulu” mengambil masa 1.76 saat.
• Jejak Selepas Pembersihan: Walaupun selepas memadamkan model, 458 MB ingatan kekal sibuk.

FP32 berfungsi, tetapi ia besar.

    # Load tokenizer and base model
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    print(f"Pre-load memory: {get_memory_usage()} MB")

    # Full precision model
    model_fp32 = AutoModelForCausalLM.from_pretrained(model_name).to(device)
    print(f"Post-load memory: {get_memory_usage()} MB")  # 511.15 MB

    # Inference measurement
    inputs = tokenizer(input_text, return_tensors="pt").to(device)
    start_time = time.time()
    output = model_fp32.generate(**inputs, max_length=50)
    inference_time = time.time() - start_time  # 1.76s

    # Cleanup protocol
    del model_fp32, inputs
    gc.collect()
    torch.cuda.empty_cache()

Fasa 2: Memotong Lemak – Kuantiti 8-bit (INT8)

Masukkan pengkuantitian 8-bit, di mana pemberat dan pengaktifan disimpan sebagai integer dan bukannya terapung. Transformasi adalah serta-merta:

• Memori: Model INT8 dimuatkan dengan hanya 187 MB—63% lebih kecil daripada FP32.
• Kelajuan: Inferens memecut kepada 1.38 saat, satu 22% peningkatan.
• Jejak Selepas Pembersihan: Memori menurun kepada 139 MB selepas pemadaman.

Model lebih ringan, lebih pantas dan masih berfungsi. Peningkatan yang jelas.

    # 8-bit configuration
    quant_config_8bit = BitsAndBytesConfig(load_in_8bit=True)

    print(f"Pre-load memory: {get_memory_usage()} MB")  # 9.18 MB
    model_int8 = AutoModelForCausalLM.from_pretrained(
        model_name, 
        quantization_config=quant_config_8bit
    )

    # Dynamic input handling
    inputs_int8 = tokenizer(input_text, return_tensors="pt").to(model_int8.device)
    start_time = time.time()
    output = model_int8.generate(**inputs_int8, max_length=50)  # 1.38s

Fasa 3: Tepi Kecekapan – Kuantiti 4-bit (INT4)

Sekarang kita teruskan lagi. Dengan pengkuantitian 4-bit, pemberat dimampatkan kepada ketepatan hampir-minimum dan pengiraan menggunakan apungan 16-bit untuk kestabilan.

• Memori: Model INT4 mempunyai berat 149 MB, 71% lebih ringan daripada FP32.
• Kelajuan: Masa inferens turun kepada 1.08 saat, peningkatan 39% berbanding FP32.
• Jejak Selepas Pembersihan: Memori menurun kepada 58 MB—sebahagian kecil daripada yang asal.

Ini bukan sekadar pengoptimuman; ia ciptaan semula.

    # 8-bit configuration
    quant_config_8bit = BitsAndBytesConfig(load_in_8bit=True)

    print(f"Pre-load memory: {get_memory_usage()} MB")  # 9.18 MB
    model_int8 = AutoModelForCausalLM.from_pretrained(
        model_name, 
        quantization_config=quant_config_8bit
    )

    # Dynamic input handling
    inputs_int8 = tokenizer(input_text, return_tensors="pt").to(model_int8.device)
    start_time = time.time()
    output = model_int8.generate(**inputs_int8, max_length=50)  # 1.38s

Pertukaran: Ketepatan lwn Praktikal

Kuantisasi tidak percuma. Mengurangkan ketepatan boleh merendahkan ketepatan model secara halus, tetapi untuk banyak tugas—seperti penjanaan teks kasual—perbezaannya tidak dapat dilihat. Apa yang kami peroleh jauh melebihi kos:

• Kecekapan Memori:FP32: 511 MB → INT8: 187 MB → INT4: 149 MB.

Hasil: Model sesuai dengan kekangan memori yang lebih ketat, membolehkan penggunaan pada GPU pengguna atau peranti tepi.

• Kelajuan Inferens:FP32: 1.76s → INT8: 1.38s → INT4: 1.08s.

Hasil: Respons yang lebih pantas untuk aplikasi masa nyata, daripada chatbots kepada penjanaan kandungan automatik.

Cara Ia Berfungsi: Mekanik Pemampatan

Pada terasnya, kuantisasi memetakan nilai ketepatan tinggi (seperti apungan 32-bit) kepada format ketepatan yang lebih rendah (integer 8- atau 4-bit). Contohnya:

• FP32 menggunakan 32 bit setiap nombor, menangkap butiran halus tetapi memerlukan sumber yang berat.
• INT8/INT4 gunakan lebih sedikit bit, menganggarkan nilai dengan kehilangan yang minimum.

Pustaka bitsandbytes mengendalikan perkara ini secara automatik, membungkus semula pemberat dan melaraskan pengiraan untuk mengekalkan kestabilan.

Bukti Visual

Perbandingan sebelah menyebelah menutup hujah:

• Penggunaan Memori (Carta Bar): Menara FP32 di atas INT8 dan INT4, mempamerkan pengurangan ketara dalam permintaan sumber.
• Masa Inferens (Plot Garis): Cerun ke bawah dari FP32 ke INT4 menyerlahkan peningkatan kelajuan.

Ambil bawa pulang? Kuantisasi bukan sekadar nota kaki teknikal—ia merupakan alat praktikal untuk mendemokrasikan AI.

    !pip install torch transformers accelerate bitsandbytes psutil

    from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
    import torch
    import time
    import gc

    def get_memory_usage():
        return torch.cuda.memory_allocated() / 1e6 if torch.cuda.is_available() else 0


    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model_name = "gpt2"
    input_text = "Once upon a time"

Kata Akhir

Melalui pengkuantitian, kami telah mengubah GPT-2 daripada raksasa yang penuh dengan sumber kepada alat yang lincah dan cekap—membuktikan bahawa dengan teknik yang betul, gergasi pun boleh belajar bergerak dengan ringan.

Pelaksanaan ini mendedahkan kuasa kuantisasi melalui kod dan ukuran konkrit. Dengan mengubah suai hanya 10-15 baris konfigurasi dan menggunakan pengkuantitian, kami mencapai:

• 71% pengurangan jejak ingatan
• 39% kelajuan inferens lebih pantas

Jika anda ingin tahu dan ingin mendapatkan akses kepada buku nota penuh untuk percubaan - pergi ke Google Colab.

Atas ialah kandungan terperinci Kuasa Pengkuantitian: Mengecilkan Kelajuan Pelepas GPT. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!