LongRoPE
1.0.0
| etiquetas | conjuntos de dados | métricas | ||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
|
O artigo apresenta o LongRoPE, um método para estender a janela de contexto de grandes modelos de linguagem (LLMs) além de 2 milhões de tokens.
As ideias principais são:
Identifique e explore duas formas de não uniformidade em incorporações posicionais para minimizar a perda de informações durante a interpolação. Isso permite extensão de contexto 8x sem ajuste fino.
Use uma estratégia de extensão progressiva eficiente com ajuste fino de 256k para atingir o contexto de 2.048k, em vez de ajustar diretamente um contexto extremamente grande.
Ajuste os embeddings para contextos mais curtos para recuperar o desempenho dentro do tamanho original da janela.
O método é aplicado ao LLaMA2 e ao Mistral. Experimentos em várias tarefas demonstram a eficácia do LongRoPE em manter o desempenho de comprimentos de contexto de 4k a 2.048k.
A arquitetura do Transformer luta com a complexidade computacional quadrática da autoatenção e sua falta de generalização para posições simbólicas não vistas no momento do treinamento. Para dimensionar o cálculo da autoatenção para um contexto grande, vários métodos foram propostos, como RoPE, AliBi, coletores de atenção, etc. No entanto, nenhuma dessas soluções pode ser dimensionada efetivamente para o contexto com milhões de tokens, preservando a precisão do modelo. .
Este artigo apresenta uma nova técnica, LongRoPE, expandindo a janela de contexto dos LLMs para mais de 2 milhões de tokens.
LongRoPE utiliza uma estratégia de extensão progressiva para atingir uma janela de contexto de 2.048k sem a necessidade de ajuste direto em textos excessivamente longos, que são raros e difíceis de obter. Esta estratégia começa com uma extensão de 256k em um LLM pré-treinado, seguida de um ajuste fino nesse comprimento.
Para lidar com potenciais quedas de desempenho na janela de contexto original (mais curta), o LongRoPE ajusta ainda mais os fatores de redimensionamento RoPE no LLM estendido, reduzindo para janelas de contexto de 4k e 8k no LLM ajustado de 256k usando seu algoritmo de pesquisa para minimizar a interpolação posicional. Durante a inferência para sequências com menos de 8k de comprimento, o RoPE é atualizado com esses fatores de redimensionamento meticulosamente pesquisados.
Os testes em vários LLMs e tarefas que exigem contextos longos validaram a eficácia do LongRoPE. O método mantém significativamente a baixa perplexidade em comprimentos de avaliação de 4k a 2.048k tokens, atinge mais de 90% de precisão na recuperação de chave de acesso e oferece precisão comparável a benchmarks padrão em uma janela de contexto de 4.096
Uma análise aprofundada das modificações estruturais e suas implicações no desempenho do modelo.
A arquitetura do modelo LongRoPE foi projetada para estender a janela de contexto de grandes modelos de linguagem (LLMs) para mais de 2 milhões de tokens, abordando as limitações das arquiteturas tradicionais do Transformer. A principal inovação reside na estratégia de extensão progressiva e no ajuste dos encaixes posicionais.
Os principais componentes incluem:
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_256kA arquitetura começa com um LLM pré-treinado e estende sua janela de contexto de forma incremental. Inicialmente, o modelo é ajustado para lidar com um comprimento de contexto de 256 mil tokens. Esta abordagem progressiva evita a necessidade de ajuste direto em textos extremamente longos, que são raros e computacionalmente caros para processar. Ao aumentar gradualmente o comprimento do contexto, o modelo pode adaptar-se de forma mais eficaz a sequências mais longas.
Para manter o desempenho em diferentes comprimentos de contexto, o LongRoPE ajusta os Rotary Positional Embeddings (RoPE). O modelo identifica e explora não uniformidades em incorporações posicionais para minimizar a perda de informações durante a interpolação. Isso permite uma extensão de contexto de 8x sem a necessidade de ajuste fino. Além disso, o modelo emprega um algoritmo de busca para encontrar fatores de redimensionamento ideais para contextos mais curtos (por exemplo, tokens de 4k e 8k) no LLM ajustado de 256k. Esses ajustes garantem que o modelo retenha alto desempenho mesmo dentro do tamanho original da janela de contexto.
A arquitetura incorpora diversas modificações estruturais para lidar com o aumento do comprimento do contexto de forma eficiente:
Dimensionamento de camadas : ajustes são feitos no dimensionamento de camadas para garantir estabilidade e desempenho à medida que a janela de contexto cresce.
Gerenciamento de memória : técnicas eficientes de gerenciamento de memória são empregadas para lidar com grandes tamanhos de contexto sem sobrecarregar os recursos do sistema.
Mecanismos de Atenção : Mecanismos de atenção aprimorados são integrados para garantir que o modelo possa focar em partes relevantes da sequência de entrada, mesmo com o contexto estendido.
Atenção por token : mecanismos de atenção por token são introduzidos para capturar as relações contextuais entre tokens, permitindo que o modelo entenda melhor o significado semântico da entrada.
Experimentos demonstram que o LongRoPE mantém baixa perplexidade em comprimentos de avaliação de 4k a 2.048k tokens e atinge alta precisão em tarefas que exigem contextos longos. Isso o torna adequado para diversas aplicações, incluindo aprendizado em contexto, resumo de documentos longos e aprendizado rápido.
Para informações mais detalhadas, consulte o artigo completo aqui.
Insights sobre a codificação e especificações operacionais que habilitam a funcionalidade do LongRoPE. Isso pode incluir trechos ou pseudocódigo ilustrando os principais componentes.
Para informações mais detalhadas, consulte o artigo.
Exemplos abrangentes que demonstram como aproveitar o LongRoPE para diversas aplicações, desde análise de texto até geração de documentos extensos.
# 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) Treinamento de conjunto de dados personalizado
Para treinar em um conjunto de dados personalizado:
Ajuste de hiperparâmetros O desempenho do LongRoPE pode ser sensível a hiperparâmetros. Os principais parâmetros a serem ajustados incluem:
population_size , num_mutations e num_crossovers na pesquisa do fator lambda Taxa de aprendizado e parâmetros do agendador para ajuste fino de gradient_accumulation_steps para estabilidade de treinamento
Minha implementação do LongRoPE alcança os seguintes resultados:
Perplexidade:
Precisão de recuperação de senha:
Precisão:
Comparação com modelos de base:
@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 }
}Nota: Este repositório é um trabalho em andamento e ainda não está pronto para uso em produção. Consulte o artigo para obter mais detalhes.
