LongRoPE
1.0.0
| tag | kumpulan data | metrik | ||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
|
Makalah ini memperkenalkan LongRoPE, sebuah metode untuk memperluas jendela konteks model bahasa besar (LLM) melebihi 2 juta token.
Ide-ide utamanya adalah:
Identifikasi dan manfaatkan dua bentuk ketidakseragaman dalam penyematan posisi untuk meminimalkan kehilangan informasi selama interpolasi. Ini memungkinkan perluasan konteks 8x tanpa penyesuaian.
Gunakan strategi penyuluhan progresif yang efisien dengan penyesuaian 256 ribu untuk mencapai konteks 2048 ribu, daripada langsung menyempurnakan konteks yang sangat luas.
Sesuaikan penyematan untuk konteks yang lebih pendek guna memulihkan kinerja dalam ukuran jendela asli.
Metode ini diterapkan pada LLaMA2 dan Mistral. Eksperimen di berbagai tugas menunjukkan efektivitas LongRoPE dalam mempertahankan kinerja dari panjang konteks 4k hingga 2048k.
Arsitektur Transformer berjuang dengan kompleksitas komputasi kuadrat dari perhatian diri dan kurangnya generalisasi terhadap posisi token yang tidak terlihat pada waktu pelatihan. Untuk menskalakan perhitungan perhatian mandiri ke dalam konteks yang luas, berbagai metode telah diusulkan, seperti RoPE, AliBi, penyerap perhatian, dll. Meskipun demikian, tidak satu pun dari solusi ini yang dapat secara efektif menskalakan konteks dengan jutaan token sambil menjaga keakuratan model. .
Makalah ini menyajikan teknik baru, LongRoPE, yang memperluas jendela konteks LLM menjadi lebih dari 2 juta token.
LongRoPE menggunakan strategi penyuluhan progresif untuk mencapai jendela konteks 2048k tanpa memerlukan penyesuaian langsung pada teks yang sangat panjang, yang jarang dan sulit diperoleh. Strategi ini dimulai dengan ekstensi 256k pada LLM terlatih, diikuti dengan penyesuaian pada panjang ini.
Untuk mengatasi potensi penurunan kinerja dalam jendela konteks asli (yang lebih pendek), LongRoPE selanjutnya menyesuaikan faktor penskalaan ulang RoPE pada LLM yang diperluas, memperkecil ke jendela konteks 4k dan 8k pada LLM 256k yang disempurnakan menggunakan algoritma pencariannya untuk meminimalkan interpolasi posisi. Selama inferensi untuk rangkaian yang panjangnya kurang dari 8k, RoPE diperbarui dengan faktor penskalaan ulang yang dicari dengan cermat ini.
Pengujian di berbagai LLM dan tugas yang memerlukan konteks panjang telah memvalidasi kemanjuran LongRoPE. Metode ini secara signifikan mempertahankan tingkat kebingungan yang rendah di seluruh panjang evaluasi dari token 4k hingga 2048k, mencapai akurasi di atas 90% dalam pengambilan kunci sandi, dan memberikan akurasi yang sebanding dengan tolok ukur standar dalam jendela konteks 4096
Pandangan mendalam tentang modifikasi struktural dan implikasinya terhadap kinerja model.
Arsitektur model LongRoPE dirancang untuk memperluas jendela konteks model bahasa besar (LLM) hingga lebih dari 2 juta token, mengatasi keterbatasan arsitektur Transformer tradisional. Inovasi utamanya terletak pada strategi perluasan progresif dan penyesuaian penempatan posisi.
Komponen utamanya meliputi:
class RoPEPositionalEncoding ( nn . Module ):
def __init__ ( self , d_model , max_len = 1000000 , base = 10000 ):
super (). __init__ ()
self . d_model = d_model
self . max_len = max_len
self . base = base
self . theta = torch . tensor ([ base ** ( - 2 * ( i // 2 ) / d_model ) for i in range ( d_model )])
def forward ( self , positions ):
angles = positions . unsqueeze ( - 1 ) * self . theta
sin_cos = torch . stack ([ angles . cos (), angles . sin ()], dim = - 1 )
return sin_cos . view ( * sin_cos . shape [: - 2 ], - 1 ) def non_uniform_interpolation ( pos_embed , extension_ratio , lambda_factors , n_hat ):
d_model = pos_embed . shape [ - 1 ]
interpolated_pos = pos_embed . clone ()
for i in range ( d_model // 2 ):
mask = torch . arange ( pos_embed . shape [ - 2 ], device = pos_embed . device ) < n_hat
scale = torch . where ( mask , torch . ones_like ( pos_embed [..., 0 ], device = pos_embed . device ),
1 / ( lambda_factors [ i ] * extension_ratio ))
interpolated_pos [..., 2 * i ] *= scale
interpolated_pos [..., 2 * i + 1 ] *= scale
return interpolated_pos def progressive_extension ( model , data , base_length , target_length , population_size , num_mutations , num_crossovers , max_iterations ):
# Extend to 128k
lambda_factors_128k , n_hat_128k = search_lambda_factors ( model , data , 128000 / base_length , population_size , num_mutations , num_crossovers , max_iterations )
model = fine_tune ( model , data , 128000 , lambda_factors_128k , n_hat_128k , steps = 400 )
# Extend to 256k
lambda_factors_256k , n_hat_256k = search_lambda_factors ( model , data , 256000 / base_length , population_size , num_mutations , num_crossovers , max_iterations )
model = fine_tune ( model , data , 256000 , lambda_factors_256k , n_hat_256k , steps = 600 )
# Extend to target length
if target_length > 256000 :
final_lambda_factors , final_n_hat = search_lambda_factors ( model , data , target_length / base_length , population_size // 2 , num_mutations // 2 , num_crossovers // 2 , max_iterations // 2 )
model . lambda_factors [ "2048k" ] = final_lambda_factors
model . n_hat [ "2048k" ] = final_n_hat
return model , final_lambda_factors , final_n_hat , lambda_factors_256k , n_hat_256kArsitekturnya dimulai dengan LLM terlatih dan memperluas jendela konteksnya secara bertahap. Awalnya, model ini disesuaikan untuk menangani panjang konteks 256 ribu token. Pendekatan progresif ini menghindari perlunya penyesuaian langsung pada teks yang sangat panjang, yang jarang dan mahal secara komputasi untuk diproses. Dengan meningkatkan panjang konteks secara bertahap, model dapat beradaptasi secara lebih efektif pada rangkaian yang lebih panjang.
Untuk mempertahankan kinerja di berbagai panjang konteks, LongRoPE menyesuaikan Rotary Positional Embeddings (RoPE). Model ini mengidentifikasi dan mengeksploitasi ketidakseragaman dalam penyematan posisi untuk meminimalkan kehilangan informasi selama interpolasi. Hal ini memungkinkan perluasan konteks 8x tanpa perlu penyesuaian. Selain itu, model ini menggunakan algoritma pencarian untuk menemukan faktor penskalaan ulang yang optimal untuk konteks yang lebih pendek (misalnya, token 4k dan 8k) pada 256k LLM yang telah disesuaikan. Penyesuaian ini memastikan bahwa model mempertahankan performa tinggi bahkan dalam ukuran jendela konteks aslinya.
Arsitekturnya menggabungkan beberapa modifikasi struktural untuk menangani peningkatan panjang konteks secara efisien:
Penskalaan Lapisan : Penyesuaian dilakukan pada penskalaan lapisan untuk memastikan stabilitas dan kinerja seiring bertambahnya jendela konteks.
Manajemen Memori : Teknik manajemen memori yang efisien digunakan untuk menangani ukuran konteks yang besar tanpa membebani sumber daya sistem.
Mekanisme Perhatian : Mekanisme perhatian yang ditingkatkan diintegrasikan untuk memastikan bahwa model dapat fokus pada bagian yang relevan dari rangkaian masukan, bahkan dengan konteks yang diperluas.
Perhatian berdasarkan token : Mekanisme perhatian berdasarkan token diperkenalkan untuk menangkap hubungan kontekstual antar token, memungkinkan model untuk lebih memahami makna semantik dari masukan.
Eksperimen menunjukkan bahwa LongRoPE mempertahankan tingkat kebingungan yang rendah di seluruh panjang evaluasi dari token 4k hingga 2048k dan mencapai akurasi tinggi dalam tugas yang memerlukan konteks panjang. Hal ini membuatnya cocok untuk berbagai aplikasi, termasuk pembelajaran dalam konteks, peringkasan dokumen yang panjang, dan pembelajaran beberapa langkah.
Untuk informasi lebih detail, silakan merujuk makalah lengkapnya di sini.
Wawasan tentang pengkodean dan spesifikasi operasional yang memungkinkan fungsionalitas LongRoPE. Ini mungkin termasuk cuplikan atau kodesemu yang menggambarkan komponen utama.
Untuk informasi lebih rinci, silakan merujuk ke makalah.
Contoh komprehensif yang menunjukkan cara memanfaatkan LongRoPE untuk berbagai aplikasi, mulai dari analisis teks hingga menghasilkan dokumen ekstensif.
# Example usage
data_path = "path/to/your/dataset"
d_model = 512
n_heads = 8
num_layers = 6
base_length = 4096
target_length = 2048 * 1024
data = load_data ( data_path )
model = LongRoPEModel ( d_model , n_heads , num_layers , base_length )
model = model . extend_context ( data , target_length )
input_ids = torch . randn ( 2 , target_length , d_model )
output = model ( input_ids )
print ( output . shape ) # Expected shape: (batch_size, target_length, d_model) Pelatihan Set Data Khusus
Untuk melatih kumpulan data khusus:
Penyetelan Hyperparameter Performa LongRoPE bisa jadi sensitif terhadap hyperparameter. Parameter utama yang perlu disesuaikan meliputi:
population_size , num_mutations , dan num_crossovers dalam pencarian faktor lambda Kecepatan pembelajaran dan parameter penjadwal untuk menyempurnakan gradient_accumulation_steps untuk stabilitas pelatihan
Implementasi LongRoPE saya mencapai hasil berikut:
Kebingungan:
Akurasi Pengambilan Kunci Sandi:
Ketepatan:
Perbandingan dengan model dasar:
@article { ding2024longrope ,
title = { LongRoPE: Extending LLM Context Window Beyond 2 Million Tokens } ,
author = { Ding, Yiran and Zhang, Li Lyna and Zhang, Chengruidong and Xu, Yuanyuan and Shang, Ning and Xu, Jiahang and Yang, Fan and Yang, Mao } ,
journal = { arXiv preprint arXiv:2402.13753 } ,
year = { 2024 }
}Catatan: Repositori ini masih dalam proses dan belum siap untuk penggunaan produksi. Silakan merujuk ke makalah untuk lebih jelasnya.
