chinese_llm_sft

chinês_llm_sft

Use a instrução Fine Tuning para ajustar o grande modelo. O código de execução principal é copiado do chinês-llama-alpaca e fez algumas modificações:

• A maneira de salvar o modelo usando o LORA foi modificada e o método original não pode salvar os parâmetros completos do modelo. Ao mesmo tempo, apenas uma cópia dos parâmetros LORA é salva.
• Modifique o modelo suportado para chatglm-6b.

Nota : ainda existem problemas.

• RuntimeError: elemento 0 dos tensores não requer graduação e não possui um grad_fn

Verifique as informações relevantes posteriormente e adicione loss.requires_grad_(True) a Modeling_Chatgl.py para executar com sucesso. para

A exclusão do ChatGLM não é suportada e o mesmo modelo no mesmo modelo em Chinese-Llama-Alpaca ainda tem esse problema. Não importa como você diga, é modificado

Ainda pode ser executado com sucesso depois.

• Embora não haja nenhum problema com todo o processo, o modelo não parece ser capaz de ser treinado de maneira eficaz. A perda foi por volta das 4 horas, e o mesmo problema ainda existe depois de tentar taxas de aprendizado diferentes e treinar por mais tempo.

• O projeto é principalmente:

  • sentença espet_chinese_bpe: como fazer o modelo de idioma inglês apoiar chinês? (I) Construção de tokenização chinesa
  • Chinês_llm_pretringen: Como fazer o modelo de inglês suportar chinês? (Ii) Continue antes do treinamento

  A terceira parte do modelo pré-treinada é ajustada. O principal objetivo é explicar todo o processo. Para introdução detalhada, você pode verificar o Zhihu: https://zhuanlan.zhihu.com/p/640086409. Se você deseja usá -lo na prática, pode consultar outros projetos publicados: [Taishan1994 (xiximamayo) (github.com)] (https://github.com/taishan1994).

confiar

 mpi4py
transformers == 4.28 . 1
peft == 0.3 . 0
icetk
deepspeed == 0.9 . 2
accelerate
cpm_kernels
sentencepiece == 0.1 . 99
peft = 0.3 . 0
torch = 2.0 . 0 
datasets

A versão mais recente do pacote deve estar bem.

processo

• 1. Faça o download do modelo ChatGlm-6b para Model_Hub/Chatglm-6b

• 2. Prepare os dados, como o formato dos dados em dados/msra/treinamento.txt, com uma amostra em um comportamento, e a amostra é semelhante:

  { "instruct" : "你现在是一个实体识别模型，你需要提取文本里面的人名、地名、机构名，如果存在结果，返回'实体_实体类型'，不同实体间用n分隔。如果没有结果，回答'没有'。" , "query" : "文本：一位郑州学人说，越秀学术讲座对郑州学界而言堪称功德之举。" , "answer" : "郑州_地名n越秀_机构名" }

• 3. Depois de preparar os dados, você pode usar instruções para treinar:

   torchrun - - nnodes 1 - - nproc_per_node 1 run_clm_sft_with_peft . py 
      - - deepspeed ds_zero2_no_offoad . json 
      - - model_name_or_path model_hub / chatglm - 6 b 
      - - tokenizer_name_or_path model_hub / chatglm - 6 b 
      - - dataset_dir data / msra / 
      - - per_device_train_batch_size 8 
      - - per_device_eval_batch_size 8 
      - - do_train 
      - - seed $ RANDOM 
      - - fp16 
      - - num_train_epochs 3 
      - - learning_rate 3e-5 
      - - warmup_ratio 0.01 
      - - weight_decay 0 
      - - logging_strategy steps 
      - - logging_steps 10 
      - - save_strategy steps 
      - - save_total_limit 3 
      - - save_steps 200 
      - - gradient_accumulation_steps 1 
      - - preprocessing_num_workers 8 
      - - max_seq_length 256 
      - - output_dir output_dir 
      - - overwrite_output_dir 
      - - ddp_timeout 30000 
      - - logging_first_step True 
      - - lora_rank 8 
      - - lora_alpha 32 
      - - trainable query_key_value 
      - - lora_dropout 0.05 
      - - torch_dtype float16 
      - - gradient_checkpointing 
      - - ddp_find_unused_parameters False

• 4. Após a conclusão do treinamento, você pode usar test_sft_model.py para prever:

   import os
  import torch
  from transformers import AutoTokenizer , AutoModel
  from peft import PeftModel
  tokenizer = AutoTokenizer . from_pretrained ( "model_hub/chatglm-6b" , trust_remote_code = True )
  model = AutoModel . from_pretrained ( "model_hub/chatglm-6b" , trust_remote_code = True ). half ()
  
  model_vocab_size = model . get_output_embeddings (). weight . size ( 0 )
  model . resize_token_embeddings ( len ( tokenizer ))
  
  model = PeftModel . from_pretrained ( model , os . path . join ( "output_dir" , "adapter_model" ))
  model . cuda ()
  model . eval ()
  
  response , history = model . chat ( tokenizer , "你好" , history = [])
  print ( response )
  response , history = model . chat ( tokenizer , "晚上睡不着应该怎么办" , history = [])
  print ( response )
  response , history = model . chat ( tokenizer , "你现在是一个实体识别模型，你需要提取文本里面的人名、地名、机构名，如果存在结果，返回'实体_实体类型'，不同实体间用n分隔。如果没有结果，回答'没有'。文本：我们是受到郑振铎先生、阿英先生著作的启示，从个人条件出发，瞄准现代出版史研究的空白，重点集藏解放区、国民党毁禁出版物。" , history = [])
  print ( response )

• 5. Outros, como definir a camada treinável de Lora, podem ser visualizados usando fin_lora_names.py. Você pode usar test_datset.py para testar dados. Teste segmentador de palavras usando test_toenizer.py. Teste o modelo original com test_model.py.

consulte

Ymcui/chinês-llama-alpaca: Modelo de Lançamento grande e alpaca chinês + implantação local de treinamento da CPU/GPU (llama e Alpaca LLMs chineses) (github.com)