Preparação dos Dados

Para iniciar o fine-tuning do modelo Qwen1.5 (versão 1.5), você precisará de dois arquivos JSON no diretório data. O primeiro deve ser nomeado dataset_info.json (nome fixo, não altere). O segundo pode ter um nome à sua escolha, como train.json.

Exemplo de dataset_info.json

{
  "train": {
    "file_name": "train.json",
    "columns": {
      "prompt": "instruction",
      "query": "input",
      "response": "output"
    }
  }
}

Se quiser usar outro arquivo de treinamento, por exemplo new_train.json, o conteúdo seria:

{
  "new_train": {
    "file_name": "new_train.json",
    "columns": {
      "prompt": "instruction",
      "query": "input",
      "response": "output"
    }
  }
}

Os nomes das colunas em columns devem corresponder exatamente aos campos do seu arquivo de dados. O formato do arquivo de treinamento segue o padrão Alpaca:

Exemplo de train.json

[
  {
    "instruction": "Como podemos reduzir o consumo de água no dia a dia?",
    "input": "",
    "output": "1. Use dispositivos economizadores, como chuveiros e torneiras de baixo fluxo.\n2. Recolha água cinza (da lavagem de louça e banho) para reuso.\n3. Promova a conscientização sobre economia de água na comunidade.\n4. Verifique vazamentos em canos e sistemas de irrigação e corrija-os rapidamente.\n5. Tome banhos mais curtos e utilize chuveiros de baixo fluxo.\n6. Armazene água da chuva para jardinagem ou outros usos não potáveis.\n7. Feche a torneira ao escovar os dentes ou ensaboar as mãos.\n8. Reduza o tempo de irrigação do gramado.\n9. Reutilize água cinza sempre que possível.\n10. Compre apenas máquinas de lavar louça e roupa com eficiência energética."
  },
  {
    "instruction": "Edite o artigo para torná-lo mais atraente para os leitores.",
    "input": "Robôs autônomos são máquinas controladas por computador, programadas para executar tarefas específicas sem nenhuma entrada humana. Robôs autônomos estão sendo cada vez mais usados em várias indústrias, da manufatura à saúde e segurança.",
    "output": "Robôs autônomos são máquinas controladas por computador, programadas para executar tarefas específicas sem entrada humana, alcançando novos níveis de eficiência, precisão e confiabilidade. Eles são amplamente adotados em diversos setores: na manufatura, montam componentes com qualidade consistente; na saúde, auxiliam em testes e procedimentos; na segurança, monitoram grandes áreas protegendo pessoas e patrimônio. Além disso, reduzem erros e aumentam a segurança em ambientes perigosos, como inspeções industriais. Devido à sua versatilidade, os robôs autônomos transformarão a forma como trabalhamos, tornando as tarefas mais simples, rápidas e agradáveis."
  },
  {
    "instruction": "Quais estratégias o governo pode adotar para reduzir a poluição do ar?",
    "input": "",
    "output": "1. Implementar padrões obrigatórios de emissão veicular e programas de incentivo para reduzir a pegada de carbono.\n2. Aumentar o transporte público para diminuir a dependência de veículos particulares.\n3. Conscientizar a população sobre os impactos da poluição do ar e incentivar a redução de poluentes.\n4. Investir em pesquisa e desenvolvimento de energias renováveis, como solar e eólica.\n5. Instalar dispositivos de controle de poluição em fábricas e usinas, como lavadores de gases.\n6. Usar combustíveis limpos em veículos e indústrias.\n7. Melhorar o planejamento urbano e controlar a expansão.\n8. Aumentar a eficiência agrícola, reduzindo o uso de fertilizantes e pesticidas.\n9. Plantar mais árvores para reduzir a poluição do ar.\n10. Reduzir a queima de madeira, carvão e biomassa."
  },
  {
    "instruction": "Qual é o impacto das energias renováveis no meio ambiente?",
    "input": "",
    "output": "As energias renováveis ajudam a reduzir a poluição do ar e as emissões de gases de efeito estufa, pois quase não emitem CO₂, SO₂ ou outros poluentes. Além disso, promovem maior eficiência energética e melhor aproveitamento dos recursos. Reduzem a dependência de combustíveis fósseis, diminuindo emissões e riscos das mudanças climáticas. Por fim, protegem os recursos naturais ao evitar a necessidade de explorar mais terras e recursos para produção de energia."
  },
  {
    "instruction": "Explique como uma rede neural aprende.",
    "input": "",
    "output": "Uma rede neural é um algoritmo de aprendizado de máquina que usa um conjunto de neurônios interconectados para aproximar funções que mapeiam entradas em saídas. Para aprender, o computador ajusta os pesos das conexões entre neurônios, de modo que a rede produza a saída correta para uma dada entrada. Esse processo de ajuste é chamado de aprendizado: compara-se a saída gerada com a esperada e usa-se um algoritmo de otimização para modificar os pesos, aproximando a saída do resultado desejado. Esse ciclo se repete por várias iterações com diferentes entradas até que os pesos estejam ajustados e a saída corresponda ao esperado."
  },
  {
    "instruction": "Dê um exemplo de algoritmo de aprendizado de máquina e explique como funciona.",
    "input": "",
    "output": "Um exemplo popular é a Máquina de Vetores de Suporte (SVM). É um algoritmo de aprendizado supervisionado usado para classificação e regressão. Ele plota os dados em um espaço n-dimensional e os separa por uma fronteira de decisão ou hiperplano. O algoritmo usa margens máximas, que ficam o mais longe possível dos dois grupos de dados. Essas margens ajudam a criar o hiperplano de decisão ideal. Em seguida, ajusta o hiperplano considerando os erros de classificação, modificando-o conforme necessário. No final, a SVM pode realizar tarefas de classificação usando o hiperplano ótimo para prever a classe dos pontos de dados."
  }
]

O arquivo de treinamento deve ser uma lista de dicionários com os campos instruction, input e output. Caso seu conjunto de dados inclua campos adicionais como system ou history, lembre-se de adicioná-los no dataset_info.json em columns.

Configuração do Ambiente (Pulável se já estiver pronto)

Clone o repositório LLaMA-Factory e instale as dependências:

git clone https://github.com/hiyouga/LLaMA-Factory.git
conda create -n llama_factory python=3.10
conda activate llama_factory
cd LLaMA-Factory
pip install -r requirements.txt
pip install modelscope -U

Recomenda-se Python 3.10 (versão estável). Se tiver dificuldades para baixar modelos do Hugging Face, use o ModelScope:

export USE_MODELSCOPE_HUB=1

Treinamento com uma GPU (Instrução Supervisionada de Fine-Tuning - SFT)

Coloque os dois arquivos JSON no diretório data. Substitua o arquivo dataset_info.json existente pelo seu. Execute o comando de treinamento (exemplo com Qwen1.5-1.8B-Chat):

CUDA_VISIBLE_DEVICES=0 python src/train_bash.py \
    --stage sft \
    --do_train \
    --model_name_or_path qwen/Qwen1.5-1.8B-Chat \
    --dataset train \
    --template qwen \
    --finetuning_type lora \
    --lora_target q_proj,v_proj \
    --output_dir output \
    --overwrite_cache \
    --per_device_train_batch_size 2 \
    --gradient_accumulation_steps 32 \
    --lr_scheduler_type cosine \
    --logging_steps 10 \
    --save_steps 1000 \
    --learning_rate 5e-5 \
    --num_train_epochs 3.0 \
    --plot_loss \
    --fp16

Observação: Substitua --dataset train pelo nome que você definiu no dataset_info.json. Não altere o template (--template qwen). Ajuste os demais parâmetros conforme sua necessidade.

Explicação dos principais parâmetros

• --stage sft: etapa de fine-tuning supervisionado.
• --do_train: ativa o treinamento.
• --model_name_or_path: caminho ou identificador do modelo pré-treinado (ex: no ModelScope).
• --finetuning_type lora: técnica LoRA para eficiência.
• --lora_target q_proj,v_proj: módulos alvo para adaptadores LoRA.
• --output_dir output: diretório para salvar checkpoints.
• --per_device_train_batch_size 2: tamanho do lote por dispositivo.
• --gradient_accumulation_steps 32: passos de acumulação de gradiente.
• --learning_rate 5e-5: taxa de aprendizado.
• --num_train_epochs 3.0: número de épocas.
• --fp16: precisão mista para acelerar.

Mesclagem do Modelo

Após o treinamento, combine os adaptadores LoRA com o modelo base:

CUDA_VISIBLE_DEVICES=0 python src/export_model.py \
    --model_name_or_path qwen/Qwen1.5-1.8B-Chat \
    --adapter_name_or_path output \
    --template qwen \
    --finetuning_type lora \
    --export_dir Qwen1.5-1.8B-Chat_fine \
    --export_size 2 \
    --export_legacy_format False

Teste do Modelo

Interface Web

Inicie a demonstração web com os adaptadores treinados:

CUDA_VISIBLE_DEVICES=0 python src/web_demo.py \
    --model_name_or_path qwen/Qwen1.5-1.8B-Chat \
    --adapter_name_or_path output \
    --template qwen \
    --finetuning_type lora

Acesse http://localhost:7680 no navegador.

Teste via Python (Modelo Mesclado)

from modelscope import AutoModelForCausalLM, AutoTokenizer

device = "cuda"
model_path = "Qwen1.5-1.8B-Chat_fine"

model = AutoModelForCausalLM.from_pretrained(model_path, device_map=device)
tokenizer = AutoTokenizer.from_pretrained(model_path)

def chat(messages, max_new_tokens=1024, temperature=0.95, top_p=0.7):
    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    inputs = tokenizer([text], return_tensors="pt").to(device)
    outputs = model.generate(
        inputs.input_ids,
        max_new_tokens=max_new_tokens,
        temperature=temperature,
        top_p=top_p
    )
    response = tokenizer.batch_decode(
        [output[len(inputs.input_ids[0]):] for output in outputs],
        skip_special_tokens=True
    )[0]
    return response

if __name__ == "__main__":
    prompt = "Você pode prever o futuro? Conte-me as tendências da inteligência artificial."
    messages = [
        {"role": "user", "content": prompt}
    ]
    print(chat(messages))

Para adicionar um prompt de sistema:

messages = [
    {"role": "system", "content": "Você é um blogueiro de conhecimento bem-humorado. Fale de forma engraçada."},
    {"role": "user", "content": prompt}
]

Recursos Adicionais

Os dados de teste oficiais estão disponíveis em: https://github.com/liukangjia666/LLM_fine_tuning/tree/main/LLM_data

Para dúvidas, utilize a seção de comentários do artigo original.