Mengoptimumkan LLM untuk input teks panjang dan aplikasi sembang

Model bahasa yang besar (LLMS) telah merevolusikan dialek ciri-ciri (NLP), memancarkan aplikasi yang meluas dari ringkasan dan tafsiran kepada pengendali perbualan dan rangka kerja berasaskan pengambilan semula. Model-model ini, seperti GPT dan Bert, telah menggambarkan keupayaan luar biasa dalam memahami dan menghasilkan kandungan seperti manusia.

Mengendalikan urutan teks panjang dengan cekap adalah penting untuk ringkasan dokumen, menjawab soalan pengambilan semula, dan dialog berbilang pusingan dalam chatbots. Walau bagaimanapun, seni bina LLM tradisional sering berjuang dengan senario ini kerana batasan memori dan pengiraan dan keupayaan mereka untuk memproses maklumat kedudukan dalam urutan input yang luas. Kesesakan ini menuntut strategi seni bina yang inovatif untuk memastikan skalabiliti, kecekapan, dan interaksi pengguna yang lancar.

Artikel ini meneroka sains di sebalik seni bina LLM, memberi tumpuan kepada mengoptimumkannya untuk mengendalikan input teks yang panjang dan membolehkan dinamik perbualan yang berkesan. Dari konsep asas seperti embeddings kedudukan kepada penyelesaian lanjutan seperti pengekodan kedudukan berputar (tali), kami akan menyelidiki pilihan reka bentuk yang memberi kuasa kepada LLM untuk cemerlang dalam cabaran NLP moden.

Objektif pembelajaran

• Memahami cabaran seni bina LLM tradisional yang dihadapi dalam memproses urutan teks panjang dan aliran perbualan yang dinamik.
• Terokai peranan embeddings kedudukan dalam meningkatkan prestasi LLM untuk tugas -tugas berurutan.
• Belajar teknik untuk mengoptimumkan LLM untuk mengendalikan input teks yang panjang untuk meningkatkan prestasi dan koheren dalam aplikasi.
• Ketahui tentang teknik canggih seperti embedding kedudukan berputar (tali) dan alibi untuk mengoptimumkan LLM untuk pengendalian input yang panjang.
• Mengenali kepentingan pilihan reka bentuk peringkat seni bina dalam meningkatkan kecekapan dan skalabiliti LLM.
• Ketahui bagaimana mekanisme perhatian diri menyesuaikan diri dengan akaun maklumat kedudukan dalam urutan lanjutan.

Jadual Kandungan

• Teknik untuk penggunaan LLM yang cekap
• Teknik penyembuhan posisional tradisional vs moden
• Perbandingan visual atau jadual dari embeddings tradisional dan moden
• Kajian kes atau rujukan yang menunjukkan keuntungan prestasi dengan tali dan alibi
• Memanfaatkan kekuatan ketepatan yang lebih rendah
• Mekanisme perhatian kilat
• Sains Di Sebalik Senibina LLM
• Meningkatkan embeddings positional di LLMS
• Kesimpulan
• Soalan yang sering ditanya

Teknik untuk penggunaan LLM yang cekap

Menggunakan model bahasa yang besar (LLMS) dengan berkesan adalah penting untuk menangani cabaran seperti pengiraan tinggi yang mengambil tol, penggunaan memori, dan ketidakaktifan, yang dapat menghalang fleksibiliti mereka yang berdaya maju. Pengambilan prosedur sangat berkesan dalam mengatasi cabaran -cabaran ini:

• Perhatian Flash: Teknik ini mengoptimumkan ingatan dan kecekapan pengiraan dengan meminimumkan operasi berlebihan semasa mekanisme perhatian. Ia membolehkan model memproses maklumat lebih cepat dan mengendalikan konteks yang lebih besar tanpa sumber perkakasan yang luar biasa.
• Penghampiran peringkat rendah: Strategi ini sama sekali mengurangkan bilangan parameter dengan menghampiri kisi parameter dengan kedudukan yang lebih rendah, memandu ke demonstrasi yang lebih ringan sambil mengekalkan pelaksanaan.
• Kuantisasi: Ini termasuk mengurangkan ketepatan pengiraan berangka, seperti menggunakan integrasi 8-bit atau 4-bit daripada drifts 16-bit atau 32-bit, yang mengurangkan penggunaan aset dan penggunaan daya hidup tanpa kemalangan yang patut ditunjukkan untuk menunjukkan ketepatan.
• Pengendalian konteks yang lebih panjang (Tali dan Alibi): Teknik seperti embeddings kedudukan berputar (tali) dan perhatian dengan bias linear (alibi) memanjangkan keupayaan model untuk memegang dan menggunakan data ke atas tetapan yang lebih lama, yang asas untuk aplikasi seperti ringkasan rekod dan soal jawab.
• Penggunaan perkakasan yang cekap: Mengoptimumkan persekitaran penempatan dengan memanfaatkan GPU, TPU, atau pemecut lain yang direka untuk tugas pembelajaran mendalam dapat meningkatkan kecekapan model.

Dengan mengamalkan strategi ini, organisasi boleh menggunakan LLM dengan berkesan semasa mengimbangi kos, prestasi, dan skalabiliti, yang membolehkan penggunaan AI yang lebih luas dalam aplikasi dunia sebenar.

Teknik penyembuhan posisional tradisional vs moden

Kami akan meneroka perbandingan antara teknik embeddings kedudukan tradisional dan moden di bawah:

Lembutan kedudukan mutlak tradisional:

• Embeddings sinusoidal: Teknik ini menggunakan fungsi matematik tetap (sine dan cosine) untuk menyandikan kedudukan token. Ia adalah komputasi yang cekap tetapi berjuang dengan mengendalikan urutan yang lebih panjang atau mengekstrapolasi melebihi panjang latihan.
• Embeddings yang dipelajari: Ini dipelajari semasa latihan, dengan setiap kedudukan yang mempunyai penyembuhan yang unik. Walaupun fleksibel, mereka mungkin tidak umum dengan baik untuk urutan yang sangat panjang di luar julat kedudukan yang telah ditetapkan model.

Penyelesaian Moden:

• Pembasmian kedudukan relatif: Daripada pengekodan kedudukan mutlak, teknik ini menangkap jarak relatif antara token. Ia membolehkan model untuk mengendalikan urutan panjang yang lebih baik dan menyesuaikan diri dengan konteks yang berbeza tanpa dibatasi oleh kedudukan yang telah ditetapkan.

Posisi Rotary Embedding (Tali):

• Mekanisme: Tali memperkenalkan mekanisme berasaskan putaran untuk mengendalikan pengekodan posisional, yang membolehkan model untuk menyebarkan lebih baik merentasi pelbagai urutan yang berbeza-beza. Putaran ini menjadikannya lebih berkesan untuk urutan yang panjang dan mengelakkan batasan embeddings tradisional.
• Kelebihan: Ia menawarkan fleksibiliti yang lebih besar, prestasi yang lebih baik dengan ketergantungan jarak jauh, dan pengendalian urutan input yang lebih efisien.

Alibi (perhatian dengan bias linear):

• Penjelasan mudah: Alibi memperkenalkan kecenderungan linear secara langsung dalam mekanisme perhatian, yang membolehkan model memberi tumpuan kepada bahagian -bahagian yang berlainan dari urutan berdasarkan kedudukan relatif mereka.
• Bagaimana ia meningkatkan pengendalian jangka panjang: Dengan skor perhatian yang berat sebelah secara linear, Alibi membolehkan model untuk mengendalikan urutan yang panjang tanpa memerlukan pengekodan kedudukan kompleks, meningkatkan kedua-dua penggunaan memori dan kecekapan model untuk input yang panjang.

Perbandingan visual atau jadual dari embeddings tradisional dan moden

Di bawah ini kita akan melihat perbandingan tradisional berbanding embeddings moden di bawah:

Ciri	Embeddings mutlak tradisional	Lembutan moden (tali, alibi, dan lain -lain)
Jenis pengekodan	Tetap (sinusoidal atau dipelajari)	Relatif (tali, alibi)
Mengendalikan urutan panjang	Berjuang dengan ekstrapolasi melebihi latihan panjang	Cekap dengan ketergantungan jarak jauh
Generalisasi	Penyebaran terhad untuk panjang urutan yang tidak kelihatan	Generalisasi yang lebih baik, disesuaikan dengan panjang urutan yang bervariasi
Penggunaan memori	Penggunaan memori yang lebih tinggi disebabkan oleh pengekodan statik	Lebih banyak memori yang cekap, terutamanya dengan alibi
Kerumitan komputasi	Rendah (sinusoidal), sederhana (dipelajari)	Lebih rendah untuk urutan panjang (tali, alibi)
Fleksibiliti	Kurang fleksibel untuk konteks dinamik atau jarak jauh	Sangat fleksibel, dapat menyesuaikan diri dengan saiz urutan yang berbeza -beza
Permohonan	Sesuai untuk urutan yang lebih pendek, tetap panjang	Sesuai untuk tugas dengan input panjang dan berubah-panjang

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.

Atas ialah kandungan terperinci Mengoptimumkan LLM untuk input teks panjang dan aplikasi sembang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!