Model dan platform AI

Memahami Parameter dan Persyaratan Memori Model Bahasa Besar: Penelitian Mendalam

mm
Diterbitkan
Diperbarui
Tambahkan Unite.AI ke sumber pilihan Anda di Google

Model Bahasa Besar (LLM) telah mengalami kemajuan luar biasa dalam beberapa tahun terakhir. Model seperti GPT-4, Google’s Gemini, dan Claude 3 telah menetapkan standar baru dalam kemampuan dan aplikasi. Model-model ini tidak hanya meningkatkan kemampuan generasi teks dan terjemahan, tetapi juga memecahkan batasan baru dalam pemrosesan multimodal, menggabungkan teks, gambar, audio, dan video untuk menyediakan solusi AI yang lebih komprehensif.

Sebagai contoh, GPT-4 OpenAI telah menunjukkan perbaikan signifikan dalam memahami dan menghasilkan teks seperti manusia, sedangkan model Gemini Google excels dalam menangani berbagai jenis data, termasuk teks, gambar, dan audio, memungkinkan interaksi yang lebih lancar dan relevan. Demikian pula, model Claude 3 Anthropic dikenal karena kemampuan multibahasa dan kinerja yang ditingkatkan dalam tugas AI.

Karena pengembangan LLM terus mempercepat, memahami kerumitan model-model ini, terutama parameter dan persyaratan memori, menjadi sangat penting. Panduan ini bertujuan untuk memperjelas aspek-aspek ini, menawarkan penjelasan yang rinci dan mudah dipahami.

Dasar-Dasar Model Bahasa Besar

Apa itu Model Bahasa Besar?

Model Bahasa Besar adalah jaringan neural yang dilatih pada dataset besar untuk memahami dan menghasilkan bahasa manusia. Mereka bergantung pada arsitektur seperti Transformer, yang menggunakan mekanisme seperti self-attention untuk memproses dan menghasilkan teks.

Pentingnya Parameter dalam LLM

Parameter adalah komponen inti dari model-model ini. Mereka termasuk bobot dan bias, yang model sesuaikan selama pelatihan untuk meminimalkan kesalahan dalam prediksi. Jumlah parameter sering berkorelasi dengan kapasitas dan kinerja model, tetapi juga mempengaruhi persyaratan komputasi dan memori.

Memahami Arsitektur Transformer

Transformers-architecture

Arsitektur Transformers

Ringkasan

Arsitektur Transformer, yang diperkenalkan dalam makalah “Attention Is All You Need” oleh Vaswani et al. (2017), telah menjadi fondasi untuk banyak LLM. Ini terdiri dari encoder dan decoder, masing-masing terdiri dari beberapa lapisan identik.

Komponen Encoder dan Decoder

  • Encoder: Memproses urutan input dan membuat representasi yang sadar konteks.
  • Decoder: Menghasilkan urutan output menggunakan representasi encoder dan token yang dihasilkan sebelumnya.

Blok Bangunan Kunci

  1. Perhatian Multi-Kepala: Memungkinkan model untuk fokus pada bagian yang berbeda dari urutan input secara bersamaan.
  2. Jaringan Saraf Feed-Forward: Menambahkan non-linier dan kompleksitas ke model.
  3. Normalisasi Lapisan: Menstabilkan dan mempercepat pelatihan dengan menormalisasi output intermediate.

Menghitung Jumlah Parameter

Transformer Training

Model Pratraining untuk Pelatihan Transformer yang Efisien

Menghitung Parameter dalam LLM Berbasis Transformer

Mari kita turun ke perhitungan parameter untuk setiap komponen LLM berbasis Transformer. Kami akan menggunakan notasi dari makalah asli, di mana d_model mewakili dimensi dari keadaan tersembunyi model.

  1. Lapisan Embedding:
    • Parameter = vocab_size * d_model
  2. Perhatian Multi-Kepala:
    • Untuk h kepala, dengan d_k = d_v = d_model / h:
    • Parameter = 4 * d_model^2 (untuk Q, K, V, dan proyeksi output)
  3. Jaringan Saraf Feed-Forward:
    • Parameter = 2 * d_model * d_ff + d_model + d_ff
    • Di mana d_ff biasanya 4 * d_model
  4. Normalisasi Lapisan:
    • Parameter = 2 * d_model (untuk skala dan bias)

Total parameter untuk satu lapisan Transformer:

  • Parameter_lapisan = Parameter_perhatian + Parameter_ffn + 2 * Parameter_layernorm

Untuk model dengan N lapisan:

  • Total Parameter = N * Parameter_lapisan + Parameter_embedding + Parameter_output

Contoh Perhitungan

Mari kita pertimbangkan model dengan spesifikasi berikut:

  • d_model = 768
  • h (jumlah kepala perhatian) = 12
  • N (jumlah lapisan) = 12
  • vocab_size = 50.000
  1. Lapisan Embedding:
    • 50.000 * 768 = 38.400.000
  2. Perhatian Multi-Kepala:
    • 4 * 768^2 = 2.359.296
  3. Jaringan Saraf Feed-Forward:
    • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4.719.616
  4. Normalisasi Lapisan:
    • 2 * 768 = 1.536

Total parameter per lapisan:

  • 2.359.296 + 4.719.616 + (2 * 1.536) = 7.081.984

Total parameter untuk 12 lapisan:

  • 12 * 7.081.984 = 84.983.808

Total parameter model:

  • 84.983.808 + 38.400.000 = 123.383.808

Model ini akan memiliki sekitar 123 juta parameter.

Jenis Penggunaan Memori

Ketika bekerja dengan LLM, kita perlu mempertimbangkan dua jenis penggunaan memori utama:

  1. Memori Model: Memori yang diperlukan untuk menyimpan parameter model.
  2. Memori Kerja: Memori yang diperlukan selama inferensi atau pelatihan untuk menyimpan aktivasi intermediate, gradien, dan keadaan optimizer.

Menghitung Memori Model

Memori model secara langsung terkait dengan jumlah parameter. Setiap parameter biasanya disimpan sebagai angka floating-point 32-bit, meskipun beberapa model menggunakan pelatihan presisi campuran dengan float 16-bit.

Memori Model (byte) = Jumlah parameter * Byte per parameter

Untuk model contoh kami dengan 123 juta parameter:

  • Memori Model (32-bit) = 123.383.808 * 4 byte = 493.535.232 byte ≈ 494 MB
  • Memori Model (16-bit) = 123.383.808 * 2 byte = 246.767.616 byte ≈ 247 MB

Mengestimasi Memori Kerja

Persyaratan memori kerja dapat bervariasi secara signifikan berdasarkan tugas spesifik, ukuran batch, dan panjang urutan. Perkiraan kasar untuk memori kerja selama inferensi adalah:

Memori Kerja ≈ 2 * Memori Model

Ini mempertimbangkan penyimpanan baik parameter model dan aktivasi intermediate. Selama pelatihan, persyaratan memori dapat lebih tinggi karena kebutuhan untuk menyimpan gradien dan keadaan optimizer:

Memori Pelatihan ≈ 4 * Memori Model

Untuk model contoh kami:

  • Memori Kerja Inferensi ≈ 2 * 494 MB = 988 MB ≈ 1 GB
  • Memori Pelatihan ≈ 4 * 494 MB = 1.976 MB ≈ 2 GB

Penggunaan Memori Steady-State dan Penggunaan Memori Puncak

Ketika melatih model bahasa besar berbasis arsitektur Transformer, memahami penggunaan memori sangat penting untuk alokasi sumber daya yang efisien. Mari kita turun ke persyaratan memori menjadi dua kategori utama: penggunaan memori steady-state dan penggunaan memori puncak.

Penggunaan Memori Steady-State

Penggunaan memori steady-state terdiri dari komponen-komponen berikut:

  1. Bobot Model: Salinan FP32 dari parameter model, memerlukan 4N byte, di mana N adalah jumlah parameter.
  2. Keadaan Optimizer: Untuk optimizer Adam, ini memerlukan 8N byte (2 keadaan per parameter).
  3. Gradien: Salinan FP32 dari gradien, memerlukan 4N byte.
  4. Data Input: Menganggap input int64, ini memerlukan 8BD byte, di mana B adalah ukuran batch dan D adalah dimensi input.

Total penggunaan memori steady-state dapat diapproximasi oleh:

  • M_steady = 16N + 8BD byte

Penggunaan Memori Puncak

Penggunaan memori puncak terjadi selama pass backward ketika aktivasi disimpan untuk komputasi gradien. Kontributor utama penggunaan memori puncak adalah:

  1. Normalisasi Lapisan: Memerlukan 4E byte per lapisan norm, di mana E = BSH (B: ukuran batch, S: panjang urutan, H: ukuran tersembunyi).
  2. Blok Perhatian:
    • Perhitungan QKV: 2E byte
    • Matriks Perhatian: 4BSS byte (S: panjang urutan)
    • Output Perhatian: 2E byte
  3. Blok Jaringan Saraf Feed-Forward:
    • Lapisan linear pertama: 2E byte
    • Aktivasi GELU: 8E byte
    • Lapisan linear kedua: 2E byte
  4. Loss Cross-Entropy:
    • Logit: 6BSV byte (V: ukuran kosakata)

Total memori aktivasi dapat diestimasi sebagai:

  • M_act = L * (14E + 4BSS) + 6BSV byte

Di mana L adalah jumlah lapisan Transformer.

Total Penggunaan Memori Puncak

Penggunaan memori puncak selama pelatihan dapat diapproximasi dengan menggabungkan memori steady-state dan memori aktivasi:

  • M_peak = M_steady + M_act + 4BSV byte

Istilah tambahan 4BSV menghitung alokasi tambahan pada awal pass backward.

Dengan memahami komponen-komponen ini, kita dapat mengoptimalkan penggunaan memori selama pelatihan dan inferensi, memastikan alokasi sumber daya yang efisien dan kinerja model bahasa besar yang ditingkatkan.

Hukum Skala dan Pertimbangan Efisiensi

Hukum Skala untuk LLM

Penelitian telah menunjukkan bahwa kinerja LLM cenderung mengikuti hukum skala tertentu ketika jumlah parameter meningkat. Kaplan et al. (2020) mengamati bahwa kinerja model meningkat sebagai fungsi kekuatan dari jumlah parameter, anggaran komputasi, dan ukuran dataset.

Hubungan antara kinerja model dan jumlah parameter dapat diapproximasi oleh:

Kinerja ∝ N^α

Di mana N adalah jumlah parameter dan α adalah eksponen skala yang biasanya sekitar 0,07 untuk tugas pemodelan bahasa.

Ini berarti bahwa untuk mencapai perbaikan 10% dalam kinerja, kita perlu meningkatkan jumlah parameter dengan faktor 10^(1/α) ≈ 3,7.

Teknik Efisiensi

Karena LLM terus tumbuh, peneliti dan praktisi telah mengembangkan berbagai teknik untuk meningkatkan efisiensi:

a) Pelatihan Presisi Campuran: Menggunakan angka floating-point 16-bit atau bahkan 8-bit untuk operasi tertentu untuk mengurangi penggunaan memori dan persyaratan komputasi.

b) Paralelisme Model: Mendistribusikan model di seluruh beberapa GPU atau TPU untuk menangani model yang lebih besar daripada yang dapat dimuat pada satu perangkat.

c) Penyimpanan Gradien: Menggunakan komputasi untuk memori dengan menghitung kembali aktivasi tertentu selama pass backward daripada menyimpannya.

d) Pemangkasan dan Kuantisasi: Menghapus bobot yang kurang penting atau mengurangi presisi mereka setelah pelatihan untuk menciptakan model yang lebih kecil dan lebih efisien.

e) Destilasi: Melatih model yang lebih kecil untuk meniru perilaku model yang lebih besar, mempertahankan sebagian besar kinerja dengan parameter yang lebih sedikit.

Contoh Praktis dan Perhitungan

GPT-3, salah satu model bahasa terbesar, memiliki 175 miliar parameter. Ini menggunakan bagian decoder dari arsitektur Transformer. Untuk memahami skala ini, mari kita turun ke perhitungan parameter dengan nilai hipotetis:

  • d_model = 12288
  • d_ff = 4 * 12288 = 49152
  • Jumlah lapisan = 96

Untuk satu lapisan decoder:

Total Parameter = 8 * 12288^2 + 8 * 12288 * 49152 + 2 * 12288 ≈ 1,1 miliar

Total untuk 96 lapisan:

1,1 miliar * 96 = 105,6 miliar

Parameter yang tersisa berasal dari komponen embedding dan lain-lain.

Kesimpulan

Memahami parameter dan persyaratan memori model bahasa besar sangat penting untuk merancang, melatih, dan mengirimkan alat-alat kuat ini secara efektif. Dengan memecah komponen arsitektur Transformer dan memeriksa contoh praktis seperti GPT, kita memperoleh wawasan yang lebih dalam tentang kompleksitas dan skala model-model ini.

Untuk memahami kemajuan terbaru dalam model bahasa besar dan aplikasinya, lihat panduan komprehensif ini:

mm

Saya telah menghabiskan lima tahun terakhir dengan membenamkan diri dalam dunia Machine Learning dan Deep Learning yang menarik. Minat dan keahlian saya telah memimpin saya untuk berkontribusi pada lebih dari 50 proyek rekayasa perangkat lunak yang beragam, dengan fokus khusus pada AI/ML. Rasa ingin tahu saya yang terus-menerus juga telah menarik saya ke arah Natural Language Processing, sebuah bidang yang saya ingin jelajahi lebih lanjut.