Platform For AI:Train, evaluate, compress, and deploy Qwen2.5-Coder

Visão geral do modelo

O Qwen2.5-Coder é uma série de modelos avançados e focados em código que suportam comprimento de contexto de até 128 mil tokens e são compatíveis com 92 linguagens de programação. Esses modelos apresentam excelente desempenho em várias tarefas relacionadas a código, incluindo geração multilíngue, conclusão e reparo de código. A variante ajustada por instruções, Qwen2.5-Coder-Instruct, aprimora o modelo base para oferecer melhor desempenho nessas tarefas e excelente generalização.

Os principais recursos incluem:

• Capacidade de programação multilíngue: O Qwen2.5-Coder-Instruct apresenta desempenho excepcional no benchmark McEval, que abrange mais de 40 linguagens, incluindo linguagens de programação de nicho.

• Capacidade de raciocínio de código: O modelo alcança resultados impressionantes no benchmark CRUXEval, demonstrando sólidas habilidades de raciocínio de código. Esse raciocínio aprimorado também se correlaciona com melhor desempenho em tarefas complexas de seguimento de instruções.

• Capacidade matemática: Como disciplina fundamental para a programação, a matemática é outra área em que o modelo se destaca, demonstrando capacidades abrangentes em campos STEM.

• Capacidades gerais: O Qwen2.5-Coder-Instruct herda as poderosas capacidades gerais do modelo base Qwen2.5, garantindo estabilidade e ampla aplicabilidade em uma vasta gama de tarefas.

Requisitos de ambiente

Implantar e chamar o modelo

from openai import OpenAI
# 1. Configure the client.
# Replace <EAS_TOKEN> with the Token from the Invocation Information panel.
openai_api_key = "<EAS_TOKEN>"
# Replace <EAS_ENDPOINT> with the Public Endpoint from the Invocation Information panel.
openai_api_base = "<EAS_ENDPOINT>/v1"
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)
# 2. Get the model name.
# For BladeLLM, set model = "". BladeLLM does not require the model parameter and does not support using client.models.list() to get the model name. Set it to an empty string to comply with the mandatory parameter requirement of the OpenAI SDK.
models = client.models.list()
model = models.data[0].id
print(model)
# 3. Initiate a chat completion request.
# Both streaming (stream=True) and non-streaming (stream=False) outputs are supported.
stream = True
chat_completion = client.chat.completions.create(
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "hello"},          
    ],
    model=model,
    top_p=0.8,
    temperature=0.7,
    max_tokens=1024,
    stream=stream,
)
if stream:
    for chunk in chat_completion:
        print(chunk.choices[0].delta.content, end="")
else:
    result = chat_completion.choices[0].message.content
    print(result)

Ajuste fino do modelo

O Model Gallery fornece dois algoritmos de ajuste fino prontos para uso para o modelo Qwen2.5-Coder-32B-Instruct: ajuste fino supervisionado (SFT) e otimização direta de preferência (DPO).

[
  {
    "instruction": "Create a function to calculate the sum of a sequence of integers.",
    "output": "# Python code\ndef sum_sequence(sequence):\n  sum = 0\n  for num in sequence:\n    sum += num\n  return sum"
  },
  {
    "instruction": "Generate a Python code for crawling a website for a specific type of data.",
    "output": "import requests\nimport re\n\ndef crawl_website_for_phone_numbers(website):\n    response = requests.get(website)\n    phone_numbers = re.findall('\\d{3}-\\d{3}-\\d{4}', response.text)\n    return phone_numbers\n    \nif __name__ == '__main__':\n    print(crawl_website_for_phone_numbers('www.example.com'))"
  }
]

[
  {
    "prompt": "Create a function to calculate the sum of a sequence of integers.",
    "chosen": "# Python code\ndef sum_sequence(sequence):\n  sum = 0\n  for num in sequence:\n    sum += num\n  return sum",
    "rejected": "[x*x for x in [1, 2, 3, 5, 8, 13]]"
  },
  {
    "prompt": "Generate a Python code for crawling a website for a specific type of data.",
    "chosen": "import requests\nimport re\n\ndef crawl_website_for_phone_numbers(website):\n    response = requests.get(website)\n    phone_numbers = re.findall('\\d{3}-\\d{3}-\\d{4}', response.text)\n    return phone_numbers\n    \nif __name__ == '__main__':\n    print(crawl_website_for_phone_numbers('www.example.com'))",
    "rejected": "def remove_duplicates(string): \n    result = \"\" \n    prev = '' \n\n    for char in string:\n        if char != prev: \n            result += char\n            prev = char\n    return result\n\nresult = remove_duplicates(\"AAABBCCCD\")\nprint(result)"
  }
]

1. Na página do Model Gallery, clique no cartão do modelo Qwen2.5-Coder-32B-Instruct para acessar a página de detalhes do modelo.

2. Na página de detalhes do modelo, clique em Train no canto superior direito. Configure os seguintes parâmetros:

   • Configuração de conjunto de dados: Após preparar seus dados, faça upload para um bucket do Object Storage Service (OSS) ou selecione um conjunto de dados no NAS ou CPFS especificando um objeto de conjunto de dados. Você também pode usar um conjunto de dados público fornecido pelo PAI para enviar um job e testar o algoritmo.

   • Configuração de recursos de computação: O algoritmo requer uma GPU com 80 GB ou mais de VRAM. Certifique-se de ter recursos de computação suficientes na cota de recursos selecionada. Para as especificações de recursos exigidas por outros tamanhos de modelo, consulte Environment requirements.

   • Configuração de hiperparâmetros: A tabela a seguir lista os hiperparâmetros de treinamento. Ajuste esses valores ou use os padrões.

     Configuração de hiperparâmetros

     Hiperparâmetro	Tipo	Padrão	Obrigatório	Descrição
     training_strategy	String	sft	Sim	Algoritmo de treinamento. Valores válidos: SFT e DPO.
     learning_rate	Float	5e-5	Sim	Taxa de aprendizado, que controla a magnitude dos ajustes de peso do modelo.
     num_train_epochs	Integer	1	Sim	Número de épocas de treinamento.
     per_device_train_batch_size	Integer	1	Sim	Número de amostras processadas por cada GPU por iteração de treinamento. Um tamanho de lote maior pode melhorar a eficiência, mas também aumenta os requisitos de VRAM.
     seq_length	Integer	128	Sim	Comprimento máximo da sequência (em tokens) para entradas do modelo.
     lora_dim	Integer	32	Não	Dimensão LoRA. Se lora_dim > 0, o treinamento leve LoRA ou QLoRA será utilizado.
     lora_alpha	Integer	32	Não	Peso LoRA. Este parâmetro fica ativo quando lora_dim > 0 (treinamento LoRA ou QLoRA é usado).
     dpo_beta	Float	0,1	Não	Controla a dependência do modelo nas informações de preferência durante o treinamento.
     load_in_4bit	Boolean	false	Não	Define se o modelo deve ser carregado com precisão de 4 bits. Se lora_dim > 0, load_in_4bit estiver definido como true e load_in_8bit como false, isso ativa o treinamento leve QLoRA de 4 bits.
     load_in_8bit	Boolean	false	Não	Define se o modelo deve ser carregado com precisão de 8 bits. Se lora_dim > 0, load_in_4bit estiver definido como false e load_in_8bit como true, isso ativa o treinamento leve QLoRA de 8 bits.
     gradient_accumulation_steps	Integer	8	Não	Número de etapas para acumulação de gradiente.
     apply_chat_template	Boolean	true	Não	Define se o modelo de chat padrão deve ser aplicado aos dados de treinamento. Para modelos da série Qwen2, o formato é o seguinte: Pergunta:<|im_end|>\n<|im_start|>user\n + instruction + <|im_end|>\n Resposta: <|im_start|>assistant\n + output + <|im_end|>\n
     system_prompt	String	You are a helpful assistant	Não	Prompt de sistema usado para o treinamento do modelo.

3. Clique em Train. O Model Gallery redireciona automaticamente para a página de detalhes do job, onde você pode monitorar o status do treinamento e visualizar logs.

O modelo treinado é registrado automaticamente no AI Asset - Model Management, onde você pode visualizar ou implantar o modelo. Para obter mais informações, consulte Register and Manage Models.

Avaliação do modelo

O PAI fornece um algoritmo de avaliação integrado para o modelo Qwen2.5-Coder-32B-Instruct. Use este algoritmo para avaliar o desempenho do modelo original e de suas versões com ajuste fino. Para obter mais informações, consulte Model Evaluation e Best Practices for Large Language Model Evaluation.

Compressão do modelo

Após o treinamento, quantize (comprima) o modelo antes da implantação para reduzir seus requisitos de armazenamento e computação. Para obter mais informações, consulte Model Compression.

Referências

• Introdução ao Modelo Qwen2.5-Coder

• Billing for Quick Start