Kajian kes atau rujukan yang menunjukkan keuntungan prestasi dengan tali dan alibi
Posisi Rotary Embedding (Tali):
- Kajian Kes 1: Di dalam kertas "Roformer: kedudukan berputar yang membenamkan untuk model pengubah," penulis menunjukkan bahawa tali meningkatkan prestasi dengan ketara pada tugas-tugas jangka panjang seperti pemodelan bahasa. Keupayaan tali untuk umum lebih baik melalui urutan yang panjang tanpa memerlukan sumber pengiraan tambahan menjadikannya pilihan yang lebih efisien ke atas embeddings tradisional.
- Keuntungan Prestasi: Tali disediakan sehingga 4-6% ketepatan yang lebih baik dalam mengendalikan urutan lebih lama daripada 512 token, berbanding dengan model menggunakan pengekodan posisional tradisional.
Alibi (perhatian dengan bias linear):
- Kajian Kes 2: Dalam "Alibi: Perhatian dengan kecenderungan linear untuk pemodelan urutan jarak jauh yang efisien," pengenalan kecenderungan linear dalam mekanisme perhatian membolehkan model untuk memproses urutan secara efisien tanpa bergantung pada pengekodan kedudukan. Alibi mengurangkan overhead memori dan meningkatkan skalabiliti model untuk tugas seperti terjemahan mesin dan ringkasan.
- Keuntungan Prestasi: Alibi menunjukkan sehingga 8% masa latihan lebih cepat dan pengurangan ketara dalam penggunaan memori sambil mengekalkan atau meningkatkan prestasi model pada tanda aras urutan lama.
Kemajuan ini mempamerkan bagaimana teknik penyembuhan posisional moden seperti tali dan alibi bukan sahaja menangani batasan kaedah tradisional tetapi juga meningkatkan skalabilitas dan kecekapan model bahasa yang besar, terutama ketika berurusan dengan input yang panjang.
Memanfaatkan kekuatan ketepatan yang lebih rendah
LLM terdiri daripada matriks dan vektor yang luas yang mewakili beratnya. Berat ini biasanya disimpan dalam float32, bfloat16, atau float16 ketepatan. Keperluan memori boleh dianggarkan seperti berikut:
- Float32 Precision: Memori Diperlukan = 4 * X GB, di mana x adalah bilangan parameter model (dalam berbilion).
- Bfloat16/Float16 Precision: Memori Diperlukan = 2 * X GB.
Contoh penggunaan memori dalam ketepatan bfloat16:
- GPT-3: 175 bilion parameter, ~ 350 GB VRAM.
- Bloom: 176 bilion parameter, ~ 352 GB VRAM.
- Llama-2-70B: 70 bilion parameter, ~ 140 GB VRAM.
- Falcon-40B: 40 bilion parameter, ~ 80 GB VRAM.
- MPT-30B: 30 bilion parameter, ~ 60 GB VRAM.
- Starcoder: 15.5 bilion parameter, ~ 31 GB VRAM.
Memandangkan NVIDIA A100 GPU mempunyai maksimum 80 GB VRAM, model yang lebih besar memerlukan paralelisme tensor atau paralelisme saluran paip untuk beroperasi dengan cekap.
Contoh praktikal
Memuatkan mekar pada nod 8 x 80gb A100:
! Pip memasang transformer mempercepat bitsandbytes optimum
# dari Transformers Import AutomelforCausallm
# Model = automelforcausallm.from_pretrained ("BigScience/Bloom", device_map = "auto")
Dari Transformers Import Automelforcausallm, Autotokenizer, Pipa
obor import
Model = automelforcausallm.from_pretrained ("BigCode/octocoder", torch_dtype = obor.bfloat16, device_map = "auto", pad_token_id = 0)
tokenizer = autotokenizer.from_pretrained ("bigcode/octocoder")
paip = saluran paip ("generasi teks", model = model, tokenizer = tokenizer)
prompt = "Soalan: Sila tulis fungsi dalam python yang mengubah bait ke giga bytes. \ n \ nanswer:"
hasil = paip (prompt, max_new_tokens = 60) [0] ["Generated_text"] [len (prompt):]
hasil
def bytes_to_giga_bytes (bytes):
Kembali Bytes / 1024/1024/1024
bytes_to_giga_bytes (obor.cuda.max_memory_allocated ())
Model.to ("CPU")
del paip
Model Del
Import GC
obor import
Def Flush ():
gc.collect ()
obor.cuda.empty_cache ()
obor.cuda.reset_peak_memory_stats ()
Flush ()
Terdapat pelbagai teknik kuantisasi, yang tidak akan dibincangkan secara terperinci di sini, tetapi secara umum, semua teknik kuantisasi berfungsi seperti berikut:
- Kuantiti semua berat ke ketepatan sasaran.
- Muatkan berat kuantitatif, dan lulus urutan input vektor dalam ketepatan bfloat16.
- Secara dinamik menghilangkan berat ke BFLOAT16 untuk melakukan pengiraan dengan vektor input mereka dalam ketepatan BFLoat16.
- Kuantiti berat sekali lagi ke ketepatan sasaran selepas pengiraan dengan input mereka.
Ringkasnya, ini bermakna matriks-matrixmultiplications yang berat, dengan theinputs, dengan matriks berat dan output:
Y = x * w ditukar kepada y = x * dequantize (w); kuantisasi (w) untuk setiap pendaraban matriks. Dequanisasi dan quajul semula dilakukan secara berurutan untuk semua matriks berat sebagai input yang dijalankan melalui grafik rangkaian.
#! Pip memasang bitsandbytes
Model = automelforcausallm.from_pretrained ("BigCode/octocoder", load_in_8bit = true, low_cpu_mem_usage = true, pad_token_id = 0)
paip = saluran paip ("generasi teks", model = model, tokenizer = tokenizer)
hasil = paip (prompt, max_new_tokens = 60) [0] ["Generated_text"] [len (prompt):]
hasil
bytes_to_giga_bytes (obor.cuda.max_memory_allocated ())
model.cpu ()
Model Del
del paip
Flush ()
Model = automelforcausallm.from_pretrained ("BigCode/octocoder", load_in_4bit = true, low_cpu_mem_usage = true, pad_token_id = 0)
paip = saluran paip ("generasi teks", model = model, tokenizer = tokenizer)
hasil = paip (prompt, max_new_tokens = 60) [0] ["Generated_text"] [len (prompt):]
hasil
bytes_to_giga_bytes (obor.cuda.max_memory_allocated ())
model.cpu ()
Model Del
del paip
model.cpu ()
Model Del
del paip
Flush ()
Model = automelforcausallm.from_pretrained ("BigCode/octocoder", load_in_4bit = true, low_cpu_mem_usage = true, pad_token_id = 0)
paip = saluran paip ("generasi teks", model = model, tokenizer = tokenizer)
hasil = paip (prompt, max_new_tokens = 60) [0] ["Generated_text"] [len (prompt):]
hasil
bytes_to_giga_bytes (obor.cuda.max_memory_allocated ())
model.cpu ()
Model Del
del paip
Flush ()
Mekanisme perhatian kilat
Perhatian Flash mengoptimumkan mekanisme perhatian dengan meningkatkan kecekapan memori dan memanfaatkan penggunaan memori GPU yang lebih baik. Pendekatan ini membolehkan:
- Mengurangkan Jejak Memori: Secara drastik meminimumkan overhead memori dengan mengendalikan pengiraan perhatian dengan lebih cekap.
- Prestasi yang lebih tinggi: Penambahbaikan yang ketara dalam kelajuan semasa kesimpulan.
system_prompt = "" "Berikut adalah satu siri dialog antara pelbagai orang dan pembantu teknikal AI.
Pembantu cuba membantu, sopan, jujur, canggih, sedar secara emosi, dan rendah hati tetapi berpengetahuan.
Pembantu gembira dapat membantu soalan kod dan akan melakukan yang terbaik untuk memahami dengan tepat apa yang diperlukan.
Ia juga cuba untuk mengelakkan memberikan maklumat palsu atau mengelirukan, dan ia kaveat apabila ia tidak sepenuhnya pasti tentang jawapan yang betul.
Yang mengatakan, pembantu adalah praktikal benar -benar melakukan yang terbaik, dan tidak membiarkan berhati -hati terlalu banyak dengan cara yang berguna.
Model StarCoder adalah satu siri model parameter 15.5B yang dilatih pada 80 bahasa pengaturcaraan dari timbunan (v1.2) (tidak termasuk permintaan opt-out).
Model ini menggunakan perhatian multi pertanyaan, dilatih menggunakan objektif fill-in-the-middle, dan dengan 8,192 token jendela konteks untuk token trilion data yang banyak deduplikasi.
---
Soalan: Tulis fungsi yang mengambil dua senarai dan mengembalikan senarai yang mempunyai elemen berganti dari setiap senarai input.
Jawapan: Pasti. Berikut adalah fungsi yang melakukannya.
Def Ganti (List1, List2):
hasil = []
untuk saya dalam julat (len (list1)):
hasil.Append (List1 [i])
hasil.Append (list2 [i])
Hasil pulangan
Soalan: Bolehkah anda menulis beberapa kes ujian untuk fungsi ini?
Jawapan: Pasti, berikut adalah beberapa ujian.
menegaskan seli ([10, 20, 30], [1, 2, 3]) == [10, 1, 20, 2, 30, 3]
menegaskan berselang -seli ([benar, palsu], [4, 5]) == [benar, 4, palsu, 5]
menegaskan berselang -seli ([], []) == []
Soalan: Ubah suai fungsi supaya ia mengembalikan semua elemen input apabila senarai mempunyai panjang yang tidak rata. Unsur -unsur dari senarai yang lebih lama harus di akhir.
Jawapan: Inilah fungsi yang diubahsuai.
Def Ganti (List1, List2):
hasil = []
untuk i dalam julat (min (len (list1), len (list2))):
hasil.Append (List1 [i])
hasil.Append (list2 [i])
jika len (list1)> len (list2):
results.extend (list1 [i 1:])
lain:
results.extend (list2 [i 1:])
Hasil pulangan
---
"" "
long_prompt = 10 * sistem_prompt
Model = automelforcausallm.from_pretrained ("BigCode/octocoder", torch_dtype = obor.bfloat16, device_map = "auto")
tokenizer = autotokenizer.from_pretrained ("bigcode/octocoder")
paip = saluran paip ("generasi teks", model = model, tokenizer = tokenizer)
masa import
start_time = time.time ()
hasil = paip (long_prompt, max_new_tokens = 60) [0] ["Generated_text"] [len (long_prompt):]
cetak (f "dihasilkan dalam {time.time () - start_time} saat.")
hasil
bytes_to_giga_bytes (obor.cuda.max_memory_allocated ())
Output:
Flush ()
model = model.to_bettertransformer ()
start_time = time.time ()
hasil = paip (long_prompt, max_new_tokens = 60) [0] ["Generated_text"] [len (long_prompt):]
cetak (f "dihasilkan dalam {time.time () - start_time} saat.")
hasil
bytes_to_giga_bytes (obor.cuda.max_memory_allocated ())
Flush ()
Output:
Sains Di Sebalik Senibina LLM
Setakat ini, kami telah meneroka strategi untuk meningkatkan kecekapan pengiraan dan memori, termasuk:
- Pemotongan berat ke format ketepatan yang lebih rendah.
- Melaksanakan versi algoritma perhatian diri yang lebih efisien.
Sekarang, kita mengalihkan perhatian kita kepada bagaimana kita dapat mengubah suai seni bina model bahasa besar (LLM) untuk mengoptimumkannya untuk tugas yang memerlukan input teks yang panjang, seperti:
- Menjawab soalan pengambilan semula,
- Ringkasan,
- Aplikasi sembang.
Terutama, interaksi sembang memerlukan LLMs bukan sahaja memproses input teks yang panjang tetapi juga mengendalikan dialog dinamik, back-and-forth antara pengguna dan model, sama seperti yang dilakukan oleh ChatGPT.
Sejak mengubahsuai seni bina asas latihan pasca LLM adalah mencabar, membuat keputusan reka bentuk yang dipertimbangkan dengan baik adalah penting. Dua komponen utama dalam seni bina LLM yang sering menjadi kesesakan prestasi untuk urutan input yang besar adalah:
- Embeddings positional
- Cache nilai kunci
Mari kita menyelidiki lebih jauh ke dalam komponen ini.
Meningkatkan embeddings positional di LLMS
Mekanisme perhatian diri mengaitkan setiap token kepada orang lain dalam urutan teks. Sebagai contoh, matriks SoftMax (Qkt) untuk urutan input "Hello", "I", "Love", "You" boleh muncul seperti berikut:
|
Helo |
I |
Cinta |
Anda |
| Helo |
0.2 |
0.4 |
0.3 |
0.1 |
| I |
0.1 |
0.5 |
0.2 |
0.2 |
| Cinta |
0.05 |
0.3 |
0.65 |
0.0 |
| Anda |
0.15 |
0.25 |
0.35 |
0.25 |
Setiap token perkataan mempunyai taburan kebarangkalian yang menunjukkan berapa banyak ia menghadiri token lain. Sebagai contoh, perkataan "cinta" menghadiri "hello" dengan kebarangkalian 0.05, "i" dengan 0.3, dan sendiri dengan 0.65.
Walau bagaimanapun, tanpa embeddings kedudukan, LLM berjuang untuk memahami kedudukan relatif token, menjadikannya sukar untuk membezakan urutan seperti "Hello I Love You" dari "Anda Suka Saya Hello". Pengiraan QKT mengaitkan token tanpa mempertimbangkan jarak kedudukan, merawat masing -masing sebagai sama.
Untuk menyelesaikannya, pengekodan posisi diperkenalkan, memberikan isyarat berangka yang membantu model memahami susunan token.
Embeddings positional tradisional
Dalam perhatian asal adalah semua yang anda perlukan kertas, embeddings posting sinusoidal dicadangkan, di mana setiap vektor ditakrifkan sebagai fungsi sinusoidal kedudukannya. Embeddings ini ditambah kepada vektor urutan input sebagai:
Sesetengah model, seperti Bert, memperkenalkan embeddings posisional yang dipelajari, yang dipelajari semasa latihan.
Cabaran dengan embeddings posting mutlak
Sinusoidal dan embeddings positional yang dipelajari adalah mutlak, pengekodan kedudukan unik. Walau bagaimanapun, seperti yang dinyatakan oleh Huang et al. dan Su et al., Embeddings mutlak boleh menghalang prestasi untuk urutan yang panjang. Isu utama termasuk:
- Batasan Input Long: Lembutan mutlak melakukan buruk ketika mengendalikan urutan panjang kerana mereka memberi tumpuan kepada kedudukan tetap dan bukannya jarak relatif.
- Panjang Latihan Tetap: Embeddings yang dipelajari mengikat model dengan panjang latihan maksimum, mengehadkan keupayaannya untuk umum kepada input yang lebih panjang.
Kemajuan: Pembasmian kedudukan relatif
Untuk menangani cabaran -cabaran ini, embeddings kedudukan relatif telah mendapat daya tarikan. Dua kaedah yang ketara termasuk:
- Embedding kedudukan berputar (tali)
- Alibi (perhatian dengan bias linear)
Kedua-dua kaedah mengubah suai pengiraan QKT untuk menggabungkan perintah kalimat terus ke dalam mekanisme perhatian diri, memperbaiki bagaimana model mengendalikan input teks panjang.
Kedudukan Rotary Embedding (Tali) menyandi maklumat kedudukan dengan berputar pertanyaan dan vektor utama dengan sudut dan, masing -masing, di mana menunjukkan kedudukan:
Di sini, adalah matriks putaran, dan dipratentukan berdasarkan panjang input maksimum latihan.
Pendekatan ini membolehkan LLM memberi tumpuan kepada jarak relatif, meningkatkan generalisasi untuk urutan yang lebih lama dan memudahkan pengoptimuman khusus tugas yang cekap.
input_ids = tokenizer (prompt, return_tensors = "pt") ["input_ids"]. ke ("cuda")
untuk _ dalam julat (5):
next_logits = model (input_ids) ["logit"] [:, -1:]
next_token_id = obor.argmax (next_logits, dim = -1)
input_ids = obor.cat ([input_ids, next_token_id], dim = -1)
Cetak ("Bentuk input_ids", input_ids.shape)
Generated_text = tokenizer.batch_decode (input_ids [:, -5:])
Generated_text
past_key_values = tiada # past_key_values adalah cache nilai kunci
Generated_tokens = []
next_token_id = tokenizer (prompt, return_tensors = "pt") ["input_ids"]. ke ("cuda")
untuk _ dalam julat (5):
next_logits, past_key_values = model (next_token_id, past_key_values = past_key_values, use_cache = true) .to_tuple ()
next_logits = next_logits [:, -1:]
next_token_id = obor.argmax (next_logits, dim = -1)
Cetak ("Bentuk input_ids", next_token_id.shape)
cetak ("panjang cache nilai kunci", len (past_key_values [0] [0])) # PAST_KEY_VALUES terbentuk [num_layers, 0 untuk k, 1 untuk v, batch_size, panjang, tersembunyi_dim]
Generated_tokens.append (next_token_id.item ())
Generated_text = tokenizer.batch_decode (Generated_Tokens)
Generated_text
config = model.config
2 * 16_000 * config.n_layer * config.n_head * config.n_embd // config.n_head
Output
7864320000
Kesimpulan
Mengoptimumkan seni bina LLM untuk input teks panjang dan aplikasi sembang dinamik adalah penting dalam memajukan kebolehgunaan dunia sebenar mereka. Cabaran menguruskan konteks input yang luas, mengekalkan kecekapan pengiraan, dan memberikan interaksi perbualan yang bermakna memerlukan penyelesaian inovatif di peringkat seni bina. Teknik-teknik seperti embedding kedudukan berputar (tali), alibi, dan perhatian kilat menggambarkan potensi transformasi komponen pusat penalaan halus seperti embeddings kedudukan dan perhatian diri.
Memandangkan bidang itu terus maju, pusat pencampuran keberkesanan pengiraan dengan inventif kejuruteraan akan memacu gelombang terobosan berikut. Dengan memahami dan merealisasikan prosedur ini, pereka boleh menangani kawalan keseluruhan LLM, menjamin mereka tidak adil tetapi terlalu mudah disesuaikan, responsif, dan biasa untuk aplikasi dunia nyata yang berbeza.
Takeaways utama
- Teknik seperti tali dan alibi meningkatkan keupayaan LLM untuk memproses teks yang lebih panjang tanpa mengorbankan prestasi.
- Inovasi seperti perhatian kilat dan perhatian tingkap gelongsor mengurangkan penggunaan memori, menjadikan model besar praktikal untuk aplikasi dunia nyata.
- Mengoptimumkan LLM untuk input teks yang panjang meningkatkan keupayaan mereka untuk mengekalkan konteks dan koheren dalam perbualan lanjutan dan tugas yang kompleks.
- LLMS berkembang untuk menyokong tugas-tugas seperti ringkasan, pengambilan semula, dan dialog berbilang pusingan dengan skalabiliti dan respons yang lebih baik.
- Mengurangkan ketepatan model meningkatkan kecekapan pengiraan sambil mengekalkan ketepatan, membolehkan penggunaan yang lebih luas.
- Reka bentuk seni bina yang mengimbangi dan pengoptimuman sumber memastikan LLM kekal berkesan untuk kes -kes penggunaan yang pelbagai dan berkembang.
Soalan yang sering ditanya
Q1. 1. Apa itu LLM, dan mengapa mereka penting? A. Model bahasa yang besar (LLMS) adalah model AI yang digariskan untuk mendapatkannya dan mencipta kandungan seperti manusia. Mereka adalah kritikal kerana keupayaan mereka untuk melaksanakan pelbagai tugasan, dari menjawab soalan -soalan kepada pengarang imajinatif, menjadikan mereka alat yang fleksibel untuk perniagaan yang berbeza.
S2. Bagaimanakah tali dan alibi meningkatkan LLM? A. Tali (pengekodan posisi berputar) dan alibi (perhatian dengan bias linear) meningkatkan LLM dengan meningkatkan keupayaan mereka untuk mengendalikan konteks yang panjang, memastikan pemprosesan teks yang lanjutan tanpa kehilangan koheren.
Q3. Apakah perhatian kilat, dan bagaimanakah ia mengoptimumkan penggunaan memori? A. Perhatian Flash adalah algoritma yang mengira perhatian dengan lebih cekap, mengurangkan penggunaan memori dan mempercepatkan pemprosesan untuk model berskala besar.
Q4. Mengapa kuantisasi penting untuk LLMS? A. Kuantisasi mengurangkan ketepatan menunjukkan berat (contohnya, dari 32-bit hingga 8-bit), yang membawa keperluan pengiraan dan penggunaan ingatan manakala mengekalkan pelaksanaan, memperkasakan susunan pada alat yang lebih kecil.
S5. Apakah cabaran yang kekal untuk penskalaan LLMs lagi? A. Cabaran utama termasuk menguruskan kos pengiraan dan ingatan, menangani kebimbangan etika seperti kecenderungan dan penyalahgunaan, dan memastikan model dapat secara umum secara efektif merentasi tugas dan bahasa yang pelbagai.
S6. Bagaimanakah LLM boleh dioptimumkan untuk memproses input teks panjang dengan berkesan? A. Mengoptimumkan LLM untuk input teks yang panjang melibatkan teknik seperti pengembangan tetingkap konteks, mekanisme memori, dan pemprosesan token yang cekap untuk memastikan mereka mengekalkan koheren dan prestasi semasa perbualan lanjutan atau analisis dokumen.
