1. introdução

Dois meses atrás, a equipe da Qwen atualizou o Qwen2.5-Turbo para suportar comprimentos de contexto de até um milhão de tokens. Hoje, a Qwen lançou oficialmente o modelo de código aberto Qwen2.5-1M e seu suporte à estrutura de inferência correspondente. Aqui estão os destaques do lançamento:

Modelos de código aberto: Dois novos modelos de código aberto foram lançados, que são Qwen2.5-7B-Instruct-1M responder cantando Qwen2.5-14B-Instruct-1MEsta é a primeira vez que a Qwen estende o contexto do modelo Qwen de código aberto para 1M de comprimento.

Estrutura de raciocínio: Para ajudar os desenvolvedores a implantar a família de modelos Qwen2.5-1M com mais eficiência, a equipe do Qwen abriu totalmente o código aberto da estrutura de inferência baseada em vLLM e integrou a abordagem de atenção esparsa, o que torna a estrutura mais rápida no processamento de 1 milhão de entradas marcadas por 3x a 7x.

Relatório técnico: A equipe da Qwen também compartilhou os detalhes técnicos por trás da série Qwen2.5-1M, incluindo o design thinking por trás das estruturas de treinamento e inferência e os resultados dos experimentos de ablação.

Link do modelo:https://www.modelscope.cn/collections/Qwen25-1M-d6cf9fd33f0a40

Relatório técnico:https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen2.5-1M/Qwen2_5_1M_Technical_Report.pdf

Links de experiência:https://modelscope.cn/studios/Qwen/Qwen2.5-1M-Demo

2. desempenho do modelo

Primeiro, vamos dar uma olhada no desempenho da família de modelos Qwen2.5-1M em tarefas de contexto longo e tarefas de texto curto.

tarefa de contexto longo

Na tarefa Passkey Retrieval com um contexto de 1 milhão de tokens, a família de modelos Qwen2.5-1M recupera com precisão informações ocultas de documentos de 1 milhão de tokens, com apenas alguns erros no modelo 7B.

Para tarefas mais complexas de compreensão de contextos longos, foram escolhidos os conjuntos de testes RULER, LV-Eval e LongbenchChat.

A partir desses resultados, é possível chegar às seguintes conclusões importantes:

• Supera significativamente o desempenho da versão de 128K:A família de modelos Qwen2.5-1M supera significativamente o desempenho da versão anterior de 128K para a maioria das tarefas de contexto longo, especialmente quando se trata de tarefas com mais de 64K de comprimento.
• As vantagens de desempenho são óbvias:O modelo Qwen2.5-14B-Instruct-1M não apenas supera o Qwen2.5-Turbo, mas também supera consistentemente o GPT-4o-mini em vários conjuntos de dados, fornecendo um modelo de código aberto preferido para tarefas de contexto longo.

tarefa sequencial curta

Além do desempenho em tarefas de sequências longas, o desempenho do modelo em sequências curtas é igualmente importante. A série de modelos Qwen2.5-1M e as versões anteriores de 128K foram comparadas em benchmarks acadêmicos amplamente utilizados, e o GPT-4o-mini foi adicionado para comparação.

Ele pode ser encontrado:

• O desempenho do Qwen2.5-7B-Instruct-1M e do Qwen2.5-14B-Instruct-1M na tarefa de texto curto é comparável ao de suas versões de 128K, garantindo que os recursos básicos não foram comprometidos pela adição de recursos de processamento de sequências longas.
• Em comparação com o GPT-4o-mini, o Qwen2.5-14B-Instruct-1M e o Qwen2.5-Turbo alcançam desempenho semelhante na tarefa de texto curto, enquanto o comprimento do contexto é oito vezes maior que o do GPT-4o-mini.

3. principais tecnologias

Treinamento de contexto longo

O treinamento de sequências longas exige muitos recursos computacionais, portanto, uma expansão gradual do comprimento foi usada para estender o comprimento do contexto do Qwen2.5-1M de 4K para 256K em vários estágios:

A partir de um ponto de verificação intermediário do Qwen2.5 pré-treinado, o comprimento do contexto é 4K nesse ponto.

Durante a fase de pré-treinamentoAlém disso, o comprimento do contexto foi gradualmente aumentado de 4K para 256K, enquanto a frequência base do RoPE foi aumentada de 10.000 para 10.000.000 usando o esquema de frequência base ajustada.

Durante a fase de ajuste fino do monitoramentoem dois estágios para manter o desempenho em sequências curtas:

   Fase I: O ajuste fino é feito somente em instruções curtas (até 32K de comprimento), em que os mesmos dados e número de etapas são usados como na versão de 128K do Qwen2.5.

   Fase II: Uma combinação de instruções curtas (até 32K) e longas (até 256K) é implementada para aprimorar o desempenho de tarefas longas e, ao mesmo tempo, manter a qualidade das tarefas curtas.

Na fase de aprendizado intensivoque treina o modelo em textos curtos (até 8 mil tokens). Descobrimos que, mesmo quando treinado em livros didáticos curtos, o aumento no alinhamento preferido por humanos se generaliza bem para tarefas de contexto longo. Com o treinamento acima, temos um modelo Instruct que pode lidar com sequências de até 256 mil tokens.

Com o treinamento acima, obtém-se um modelo de ajuste fino de instrução com comprimento de contexto de 256K.

Extrapolação de comprimento

No processo de treinamento acima, o comprimento do contexto do modelo é de apenas 256 mil tokens. Para dimensioná-lo para 1 milhão de tokens, é usada uma técnica de extrapolação de comprimento.

Atualmente, os modelos de linguagem em grande escala baseados na codificação de posição rotacional produzem degradação do desempenho em tarefas de contexto longo, o que se deve principalmente à grande distância de posição relativa entre Query e Key, que não é vista durante o processo de treinamento, ao calcular os pesos de atenção. Para resolver esse problema, o Qwen2.5-1M usa a abordagem Dual Chunk Attention (DCA), que resolve esse desafio pegando as posições relativas excessivamente grandes e remapeando-as para valores menores.

O modelo Qwen2.5-1M e a versão anterior de 128K foram avaliados com e sem o método de extrapolação de comprimento.

Os resultados mostram que mesmo os modelos treinados apenas em 32 mil tokens, como o Qwen2.5-7B-Instruct, não conseguem lidar com o contexto de 1 milhão de tokens do Passkey Recuperação A tarefa também atinge uma precisão quase perfeita. Isso demonstra a capacidade do DCA de expandir significativamente o comprimento dos contextos suportados sem treinamento adicional.

mecanismo de atenção esparsa (em física de partículas)

Para modelos de linguagem de contexto longo, a velocidade de inferência é crucial para a experiência do usuário. Para acelerar a fase de pré-população, a equipe de pesquisa introduz um mecanismo de atenção esparsa com base na MInference. Além disso, são propostos vários aprimoramentos:

• Preenchimento em pedaços: se o modelo for usado diretamente para processar sequências de até 1 milhão de comprimento, os pesos de ativação da camada MLP incorrerão em uma enorme sobrecarga de memória, de até 71 GB no caso do Qwen2-5-7B. Tomando o Qwen2.5-7B como exemplo, essa parte da sobrecarga chega a 71 GB. Adaptando o Chunked Prefill com Sparse Attention, a sequência de entrada pode ser dividida em pedaços de 32768 comprimentos e pré-preenchida uma a uma, e o uso de memória dos pesos de ativação na camada MLP pode ser reduzido em 96,7%, o que pode reduzir significativamente o requisito de memória do dispositivo.
• Esquema de extrapolação de comprimento integrado: além disso, integramos um esquema de extrapolação de comprimento baseado em DCA ao mecanismo de atenção esparsa, o que permite que nossa estrutura de inferência tenha maior eficiência e precisão de inferência para tarefas de sequências longas.
• Otimização de esparsidade: o método MInference original requer uma pesquisa off-line para determinar a configuração de esparsificação ideal para cada cabeça de atenção. Essa pesquisa geralmente é realizada em sequências curtas e não necessariamente funciona bem com sequências mais longas devido aos grandes requisitos de memória dos pesos de atenção total. Propomos um método que pode otimizar a configuração de esparsificação em sequências de 1 milhão de comprimentos, reduzindo significativamente a perda de precisão devido à atenção esparsa.
• Outras otimizações: introduzimos outras otimizações, como a otimização da eficiência do operador e o paralelismo dinâmico do pipeline de fragmentação, a fim de explorar todo o potencial de toda a estrutura.

Com esses aprimoramentos, a estrutura de inferência é capaz de reduzir o número de 1M token A velocidade de pré-população de sequências de comprimento foi aumentada de 3,2 vezes para 6,7 vezes.

4. implantação do modelo

Preparação do sistema

Para obter o melhor desempenho, é recomendável usar uma GPU com arquitetura Ampere ou Hopper que ofereça suporte a núcleos otimizados.

Certifique-se de que os seguintes requisitos sejam atendidos:

• Versão CUDA: 12.1 ou 12.3
• Versão do Python: >=3.9 e <=3.12

Requisitos de memória para processar sequências de 1 milhão de comprimentos:

• Qwen2.5-7B-Instruct-1M: requer pelo menos 120 GB de memória de vídeo (soma de várias GPUs).
• Qwen2.5-14B-Instruct-1M: requer pelo menos 320 GB de memória de vídeo (soma de várias GPUs).

Se a memória da GPU não atender a esses requisitos, você ainda poderá usar o Qwen2.5-1M para tarefas mais curtas.

Instalação de dependências

Por enquanto, você precisa clonar o repositório vLLM de uma ramificação personalizada e instalá-lo manualmente. A equipe de pesquisa está trabalhando para confirmar essa ramificação no projeto vLLM.

git clone -b dev/dual-chunk-attn git@github.com:QwenLM/vllm.git
cd vllm
pip install -e . -v

Iniciando um serviço de API compatível com OpenAI

Especifica que o modelo deve ser baixado do ModelScope

exportar VLLM_USE_MODELSCOPE=True

Lançamento de serviços de API compatíveis com a OpenAI

vllm serve Qwen/Qwen2.5-7B-Instruct-1M \
  --tensor-parallel-size 4 \
  --max-model-len 1010000 \
  --enable-chunked-prefill
 --max-num-batched-tokens 131072 \
  --enforce-eager \
  ---max-num-seqs 1

Descrição do parâmetro:

• • --tensor-parallel-size
    • A configuração é o número de GPUs que você usa. Os modelos 7B suportam até 4 GPUs e os modelos 14B suportam até 8 GPUs.
  • --max-model-len
    • Define o comprimento máximo da sequência de entrada. Reduza esse valor se tiver problemas de falta de memória.
  • --max-num-batched-tokens
    • Define o tamanho do bloco do Chunked Prefill. Um valor menor reduz o uso da memória de ativação, mas pode tornar o raciocínio mais lento.
    • O valor recomendado é 131072 para um desempenho ideal.
  • --max-num-seqs
    • Limitar o número de sequências processadas simultaneamente.

Interagindo com modelos

Os métodos a seguir podem ser usados para interagir com o modelo implantado:

Opção 1.

curl http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "modelo": "Qwen/Qwen2.5-7B-Instruct-1M", "mensagens": [
  "messages": [
    {
      "role": "user", "content".
      "content": "Tell me something about large language models."
    }
  ], "temperature": 0,7
  
  
  "repetition_penalty": 1,05, "max_tokens": 512,0
  "max_tokens": 512
}'

Opção 2: usar Python

from openai import OpenAI

openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8000/v1"

cliente = OpenAI(
    api_key=openai_api_key, base_url=openai_api_base, openai_api_base = "")
    base_url=openai_api_base, )
)

prompt = (
    """Há uma informação importante escondida em um monte de texto irrelevante.
    Encontre-as e memorize-as. Farei um teste com você sobre as informações importantes que estão lá.\n\n
    A chave de acesso é 28884. Lembre-se dela. 28884 é a chave de acesso.\n""""
    + "A grama é verde, o céu é azul, o sol é amarelo, aqui vamos nós, para lá e para cá." * 800
    + "\nQual é a chave de acesso?"
" * 800 + "\nQual é a chave de acesso?")

# O prompt tem 20k de comprimento. Você pode tentar um prompt mais longo substituindo 800 por 40000.
chat_response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct-1M",
    messages=[
        {"role": "user", "content": prompt}, [
    ],, temperature=0.7,, }, }, }, }, }, }, }, }
    temperature=0.7,
    top_p=0.8, max_tokens=512
    top_p=0.8, max_tokens=512,
    extra_body={
        "repetition_penalty": 1,05,
    }
)

print("Resposta do chat:", chat_response)

Você também pode explorar outras estruturas, como o Qwen-Agent, para permitir que os modelos leiam arquivos PDF, etc.

5) Use o Magic Hitch API-Inference para chamá-lo diretamente.

A API-Inference da plataforma Magic Match também oferece suporte para os modelos Qwen2.5-7B-Instruct-1M e Qwen2.5-14B-Instruct-1M pela primeira vez. Os usuários do Magic Hitch podem usar o modelo diretamente por meio de chamadas de API. O uso específico da API-Inference pode ser descrito na página do modelo (por exemplo, https://modelscope.cn/models/Qwen/Qwen2.5-14B-Instruct-1M):

Ou consulte a documentação da API-Inference: https://www.modelscope.cn/docs/model-service/API-Inference/intro

Agradecemos à AliCloud Hundred Refinement Platform por fornecer suporte aritmético nos bastidores.

Uso de Ollama e llamafile

Para facilitar seu uso local, o Magic Hitch fornece a versão GGUF e a versão llamafile do modelo Qwen2.5-7B-Instruct-1M pela primeira vez. Ele pode ser chamado pela estrutura Ollama ou usar o llamafile diretamente.

1. chamada de Ollama

Primeiro, configure o ollama em enable:

ollama servir

Em seguida, você pode executar o modelo GGUF no Magic Hitch diretamente usando o comando ollama run:

ollama run modelscope.co.uk/modelscope/Qwen2.5-7B-Instruct-1M-GGUF

Resultados da corrida:

2. modelo llamafile pull-up diretamente

Llamafile Fornece uma solução em que o modelo grande e o ambiente de tempo de execução são todos encapsulados em um único arquivo executável. Por meio da integração da linha de comando do Magic Ride e do llamafile, você pode realmente executar o modelo grande com um clique em diferentes ambientes de sistema operacional, como Linux/Mac/Windows:

escopo do modelo llamafile --modelo Qwen-Llamafile/Qwen2.5-7B-Instruct-1M-llamafile

Resultados da corrida:

Mais documentação está disponível em https://www.modelscope.cn/docs/models/advanced-usage/llamafile

6. ajuste fino do modelo

Aqui apresentamos o ajuste fino do Qwen/Qwen2.5-7B-Instruct-1M usando o ms-swift.

Antes de começar a fazer o ajuste fino, certifique-se de que seu ambiente esteja instalado corretamente:

# Instalando o ms-swift
git clone https://github.com/modelscope/ms-swift.git
cd ms-swift
pip install -e .

Fornecemos demonstrações e estilos de ajuste fino executáveis para conjuntos de dados personalizados, e os scripts de ajuste fino são os seguintes:

CUDA_VISIBLE_DEVICES=0

swift sft \
    --modelo Qwen/Qwen2.5-7B-Instruct-1M \
    ---train_type lora \
    --dataset 'AI-ModelScope/alpaca-gpt4-data-zh#500' \
             'AI-ModelScope/alpaca-gpt4-data-en#500' \
             'swift/self-cognition#500' \
    ---torch_dtype bfloat16 \
    --num_train_epochs 1 \
    --per_device_train_batch_size 1 \
    --per_device_eval_batch_size 1 \
    --learning_rate 1e-4 \
    --lora_rank 8 \
    --lora_alpha 32 \
    ---target_modules all-linear \
    --gradient_accumulation_steps 16 \
    --eval_steps 50 \
    ---save_steps 50 \
    ---save_total_limit 5 \\
    --logging_steps 5 \\
    ---max_length 2048 \
    --output_dir output \\
    --warmup_ratio 0.05 \\
    --dataloader_num_workers 4 \
    ---model_author swift \
    ---model_name swift-robot

Uso da memória de vídeo de treinamento:

Formato de conjunto de dados personalizado: (basta especificá-lo diretamente usando `--dataset `)

{"messages": [{"role": "user", "content":""}, {"role": "assistant", "content":""}, {"role": "user", "content":""}]}, } {"role": "assistant", "content": ""}]}

Script de raciocínio:

CUDA_VISIBLE_DEVICES=0 \
swift infer \
    --adapters output/vx-xxx/checkpoint-xxx \
    --stream true \
    ---max_new_tokens 2048

Empurre o modelo para o ModelScope:

CUDA_VISIBLE_DEVICES=0 swift export \
    --adapters output/vx-xxx/checkpoint-xxx \
    --push_to_hub true \
    --hub_model_id '' \
    --hub_token ''

7. o que vem a seguir?

Embora a família Qwen2.5-1M traga excelentes opções de código aberto para tarefas de processamento de sequências longas, a equipe de pesquisa está totalmente ciente de que os modelos de contexto longo ainda têm muito espaço para melhorias. Nosso objetivo é criar modelos que se sobressaiam em tarefas curtas e longas para garantir que eles sejam realmente úteis em cenários de aplicações do mundo real. Para isso, a equipe está trabalhando em métodos de treinamento mais eficientes, arquiteturas de modelos e abordagens de raciocínio para permitir a implantação eficiente e o desempenho ideal desses modelos, mesmo em ambientes com recursos limitados. A equipe está confiante de que esses esforços abrirão novas possibilidades para os modelos de contexto longo, expandindo drasticamente seu escopo de aplicação e continuando a ampliar os limites do campo.