基于Ziya-LLaMA-13B-V1的中医古籍知识问答大模型.zip

import os import sys import torch import hashlib from itertools import chain from typing import List, Literal, Optional, Tuple import transformers from transformers import ( AutoConfig, AutoModelForCausalLM, AutoTokenizer, HfArgumentParser, Seq2SeqTrainingArguments, BitsAndBytesConfig ) from transformers.utils import check_min_version from transformers.utils.versions import require_version from transformers.modeling_utils import PreTrainedModel from transformers.tokenization_utils import PreTrainedTokenizer import datasets from datasets import Dataset, concatenate_datasets, load_dataset from peft import ( PeftModel, TaskType, LoraConfig, get_peft_model ) from peft.utils import CONFIG_NAME from trl import AutoModelForCausalLMWithValueHead from .config import ( ModelArguments, DataTrainingArguments, FinetuningArguments, GeneratingArguments ) from .template import Template from .other import ( get_logger, load_trainable_params, load_valuehead_params, print_trainable_params, prepare_model_for_training, IGNORE_INDEX ) check_min_version("4.29.1") require_version("datasets>=2.12.0", "To fix: pip install datasets>=2.12.0") require_version("accelerate>=0.19.0", "To fix: pip install accelerate>=0.19.0") require_version("peft>=0.3.0", "To fix: pip install peft>=0.3.0") require_version("trl>=0.4.4", "To fix: pip install trl>=0.4.4") logger = get_logger(__name__) def _init_adapter( model: PreTrainedModel, model_args: ModelArguments, finetuning_args: FinetuningArguments, is_trainable: bool, is_mergeable: bool ) -> PreTrainedModel: r""" Initializes the adapters. Support full-parameter, freeze and LoRA training. Note that the trainable parameters must be cast to float32. """ if finetuning_args.finetuning_type == "none" and is_trainable: raise ValueError("You cannot use finetuning_type=none while training.") if finetuning_args.finetuning_type == "full": logger.info("Fine-tuning method: Full") model = model.float() if finetuning_args.finetuning_type == "freeze": logger.info("Fine-tuning method: Freeze") for name, param in model.named_parameters(): if not any(trainable_layer in name for trainable_layer in finetuning_args.trainable_layers): param.requires_grad_(False) else: param.data = param.data.to(torch.float32) if model_args.checkpoint_dir is not None: if finetuning_args.finetuning_type != "lora": assert is_mergeable and len(model_args.checkpoint_dir) == 1, "Only LoRA tuning accepts multiple checkpoints." assert load_trainable_params(model, model_args.checkpoint_dir[0]), "Model checkpoint is not correctly loaded." else: assert is_mergeable or len(model_args.checkpoint_dir) == 1, "Quantized model only accepts a single checkpoint." if finetuning_args.finetuning_type == "lora": logger.info("Fine-tuning method: LoRA") lastest_checkpoint = None if model_args.checkpoint_dir is not None: assert os.path.exists(os.path.join(model_args.checkpoint_dir[0], CONFIG_NAME)), \ "The given checkpoint is not a LoRA checkpoint, please specify `--finetuning_type full/freeze` instead." if (is_trainable and model_args.resume_lora_training) or (not is_mergeable): # continually train on the lora weights checkpoints_to_merge, lastest_checkpoint = model_args.checkpoint_dir[:-1], model_args.checkpoint_dir[-1] else: checkpoints_to_merge = model_args.checkpoint_dir for checkpoint in checkpoints_to_merge: model = PeftModel.from_pretrained(model, checkpoint) model = model.merge_and_unload() if len(checkpoints_to_merge) > 0: logger.info("Merged {} model checkpoint(s).".format(len(checkpoints_to_merge))) if lastest_checkpoint is not None: # resume lora training or quantized inference model = PeftModel.from_pretrained(model, lastest_checkpoint, is_trainable=is_trainable) if is_trainable and lastest_checkpoint is None: # create new lora weights while training lora_config = LoraConfig( task_type=TaskType.CAUSAL_LM, inference_mode=False, r=finetuning_args.lora_rank, lora_alpha=finetuning_args.lora_alpha, lora_dropout=finetuning_args.lora_dropout, target_modules=finetuning_args.lora_target ) model = get_peft_model(model, lora_config) if model_args.checkpoint_dir is not None: logger.info("Loaded fine-tuned model from checkpoint(s): {}".format(",".join(model_args.checkpoint_dir))) return model def load_pretrained( model_args: ModelArguments, finetuning_args: FinetuningArguments, is_trainable: Optional[bool] = False, stage: Optional[Literal["pt", "sft", "rm", "ppo"]] = "sft" ) -> Tuple[PreTrainedModel, PreTrainedTokenizer]: r""" Loads pretrained model and tokenizer. Support both training and inference. """ if (not is_trainable) and model_args.checkpoint_dir is None: logger.warning("Checkpoint is not found at evaluation, load the original model.") finetuning_args = FinetuningArguments(finetuning_type="none") assert stage in ["pt", "sft"] or finetuning_args.finetuning_type == "lora", \ "RM and PPO training can only be performed with the LoRA method." config_kwargs = { "trust_remote_code": True, "cache_dir": model_args.cache_dir, "revision": model_args.model_revision, "use_auth_token": True if model_args.use_auth_token else None, } tokenizer = AutoTokenizer.from_pretrained( model_args.model_name_or_path, use_fast=model_args.use_fast_tokenizer, padding_side="left", **config_kwargs ) tokenizer.pad_token_id = 0 if tokenizer.pad_token_id is None else tokenizer.pad_token_id # set as the <unk> token config = AutoConfig.from_pretrained(model_args.model_name_or_path, **config_kwargs) is_mergeable = True # Quantization configurations (using bitsandbytes library). if model_args.quantization_bit is not None: if model_args.quantization_bit == 8: require_version("bitsandbytes>=0.37.0", "To fix: pip install bitsandbytes>=0.37.0") config_kwargs["load_in_8bit"] = True config_kwargs["quantization_config"] = BitsAndBytesConfig( load_in_8bit=True, llm_int8_threshold=6.0 ) elif model_args.quantization_bit == 4: require_version("bitsandbytes>=0.39.0", "To fix: pip install bitsandbytes>=0.39.0") require_version("transformers>=4.30.1", "To fix: pip install transformers>=4.30.1") require_version("accelerate>=0.20.3", "To fix: pip install accelerate>=0.20.3") require_version("peft>=0.4.0.dev0", "To fix: pip install git+https://github.com/huggingface/peft.git") config_kwargs["load_in_4bit"] = True config_kwargs["quantization_config"] = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_compute_dtype=model_args.compute_dtype, bnb_4bit_use_double_quant=model_args.double_quantization, bnb_4bit_quant_type=model_args.quantization_type ) is_mergeable = False config_kwargs["device_map"] = {"": int(os.environ.get("LOCAL_RANK", "0"))} logger.info("Quantizing model to {} bit.".format(model_args.quantization_bit)) if not is_trainable: # `device_map=auto` should be used for inference only config_kwargs["device_map"] = "auto" # Load and prepare pretrained models (without valuehead). model = Auto