devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

ChatGLM源码解析 main.py_tokenizer.bos_token_id

作者：繁依Fanyi0 | 2024-02-25 00:38:07

赞

踩

tokenizer.bos_token_id

这个代码块是用于训练transformer序列到序列模型的一个脚本。下面是对每行代码的解释：

 

pythonCopy code
 

import transformers from transformers import ( AutoConfig, AutoModel, AutoTokenizer, DataCollatorForSeq2Seq, HfArgumentParser, Seq2SeqTrainingArguments, set_seed, ) from trainer_seq2seq import Seq2SeqTrainer 
 

上面的代码导入了需要的库。transformers是一个用于处理transformer模型的库。AutoConfig，AutoModel和AutoTokenizer是用于自动获取特定模型的配置，模型和分词器的类。DataCollatorForSeq2Seq是用于将多个数据样本整理成一个批次，供Seq2Seq模型训练或测试使用的工具。HfArgumentParser是一个用于处理命令行参数的解析器。Seq2SeqTrainingArguments是用于设置训练参数的类。set_seed是用于设置随机数种子，以保证实验的可重复性。
 

 

pythonCopy code
 

from arguments import ModelArguments, DataTrainingArguments 
 

这行代码导入了定义模型参数和数据训练参数的类。
 

 

pythonCopy code
 

logger = logging.getLogger(__name__) 
 

这行代码创建了一个日志记录器，用于在执行过程中记录重要信息。
 

 

pythonCopy code
 

def main(): 
 

这行代码定义了主函数。
 

 

pythonCopy code
 

parser = HfArgumentParser((ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments)) 
 

这行代码创建了一个解析器对象，它将从命令行接收的参数转化为ModelArguments，DataTrainingArguments和Seq2SeqTrainingArguments这三种类型的对象。
 

以下的代码段是用于解析命令行参数或从json文件中读取参数。
 

 

pythonCopy code
 

logging.basicConfig( format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", datefmt="%m/%d/%Y %H:%M:%S", handlers=[logging.StreamHandler(sys.stdout)], ) 
 

这行代码设置了日志的基本配置，包括日志信息的格式，日期的格式，以及日志处理器。
 

以下的代码段主要设置了日志的级别和格式。
 

 

pythonCopy code
 

set_seed(training_args.seed) 
 

这行代码设置了随机数种子。
 

以下的代码段是用于加载数据集。
 

 

pythonCopy code
 

config = AutoConfig.from_pretrained(model_args.model_name_or_path, trust_remote_code=True) config.pre_seq_len = model_args.pre_seq_len config.prefix_projection = model_args.prefix_projection tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, trust_remote_code=True) 
 

这些代码加载了预训练模型的配置和分词器，并对配置进行了一些额外的设置。
 

以下的代码段是用于加载模型。
 

 

pythonCopy code
 

if model_args.quantization_bit is not None: print(f"Quantized to {model_args.quantization_bit} bit") model = model.quantize(model_args.quantization_bit) if model_args.pre_seq_len is not None: # P-tuning v2 model = model.half() model.transformer.prefix_encoder.float() else: # Finetune model = model.float() 
 

这部分代码对模型进行了一些额外的设置，包括量化和设置数据类型。
 

 

pythonCopy code
 

prefix = data_args.source_prefix if data_args.source_prefix is not None else "" 
 

这行代码设置了数据的前缀。
 

以下的代码段是用于对数据进行预处理。
 

 

pythonCopy code
 

else: logger.info("There is nothing to do. Please pass `do_train`, `do_eval` and/or `do_predict`.") return 
 

最后这部分代码检查了是否有需要执行的任务，如果没有，就打印信息并退出
 

 

 

pythonCopy code
 

if training_args.do_train: column_names = raw_datasets["train"].column_names elif training_args.do_eval: column_names = raw_datasets["validation"].column_names elif training_args.do_predict: column_names = raw_datasets["test"].column_names else: logger.info("There is nothing to do. Please pass `do_train`, `do_eval` and/or `do_predict`.") return 
 

此部分代码检查训练参数中是否包含do_train，do_eval或do_predict标志，这些标志分别代表是否进行训练、评估或预测。该代码将对应的数据集列名赋值给column_names，如果没有需要执行的任务，则输出信息并退出。
 

由于这段代码被截断了，所以我无法为你提供进一步的解释。如果你有完整的代码段，我可以帮助你理解后续的部分。
 

 

  1. def preprocess_function_eval(examples):
  2.         inputs, targets = [], []
  3.         for i in range(len(examples[prompt_column])):
  4.             if examples[prompt_column][i] and examples[response_column][i]:
  5.                 query = examples[prompt_column][i]
  6.                 if history_column is None or len(examples[history_column][i]) == 0:
  7.                     prompt = query
  8.                 else:
  9.                     prompt = ""
  10.                     history = examples[history_column][i]
  11.                     for turn_idx, (old_query, response) in enumerate(history):
  12.                         prompt += "[Round {}]\n问：{}\n答：{}\n".format(turn_idx, old_query, response)
  13.                     prompt += "[Round {}]\n问：{}\n答：".format(len(history), query)
  14.                 inputs.append(prompt)
  15.                 targets.append(examples[response_column][i])
  16.  
  17.         inputs = [prefix + inp for inp in inputs]
  18.         model_inputs = tokenizer(inputs, max_length=data_args.max_source_length, truncation=True, padding=True)
  19.         labels = tokenizer(text_target=targets, max_length=max_target_length, truncation=True)
  20.  
  21.         if data_args.ignore_pad_token_for_loss:
  22.             labels["input_ids"] = [
  23.                 [(l if l != tokenizer.pad_token_id else -100) for l in label] for label in labels["input_ids"]
  24.             ]
  25.         model_inputs["labels"] = labels["input_ids"]
  26.  
  27.         return model_inputs
  28.  
  29.     def preprocess_function_train(examples):
  30.         max_seq_length = data_args.max_source_length + data_args.max_target_length
  31.  
  32.         model_inputs = {
  33.             "input_ids": [],
  34.             "labels": [],
  35.         }
  36.         for i in range(len(examples[prompt_column])):
  37.             if examples[prompt_column][i] and examples[response_column][i]:
  38.                 query, answer = examples[prompt_column][i], examples[response_column][i]
  39.  
  40.                 if history_column is None:
  41.                     prompt = query
  42.                 else:
  43.                     prompt = ""
  44.                     history = examples[history_column][i]
  45.                     for turn_idx, (old_query, response) in enumerate(history):
  46.                         prompt += "[Round {}]\n问：{}\n答：{}\n".format(turn_idx, old_query, response)
  47.                     prompt += "[Round {}]\n问：{}\n答：".format(len(history), query)
  48.  
  49.                 prompt = prefix + prompt
  50.                 a_ids = tokenizer.encode(text=prompt, add_special_tokens=False)
  51.                 b_ids = tokenizer.encode(text=answer, add_special_tokens=False)
  52.  
  53.                 if len(a_ids) > data_args.max_source_length - 1:
  54.                     a_ids = a_ids[: data_args.max_source_length - 1]
  55.  
  56.                 if len(b_ids) > data_args.max_target_length - 2:
  57.                     b_ids = b_ids[: data_args.max_target_length - 2]
  58.  
  59.                 input_ids = tokenizer.build_inputs_with_special_tokens(a_ids, b_ids)
  60.  
  61.                 context_length = input_ids.index(tokenizer.bos_token_id)
  62.                 mask_position = context_length - 1
  63.                 labels = [-100] * context_length + input_ids[mask_position+1:]
  64.                 
  65.                 pad_len = max_seq_length - len(input_ids)
  66.                 input_ids = input_ids + [tokenizer.pad_token_id] * pad_len
  67.                 labels = labels + [tokenizer.pad_token_id] * pad_len
  68.                 if data_args.ignore_pad_token_for_loss:
  69.                     labels = [(l if l != tokenizer.pad_token_id else -100) for l in labels]
  70.  
  71.                 model_inputs["input_ids"].append(input_ids)
  72.                 model_inputs["labels"].append(labels)
  73.  
  74.         return model_inputs
 

这段代码中定义了两个函数，preprocess_function_eval和preprocess_function_train，用于预处理用于评估和训练的数据。
 

首先，我们看一下preprocess_function_eval函数：
 

 

pythonCopy code
 

def preprocess_function_eval(examples): inputs, targets = [], [] for i in range(len(examples[prompt_column])): if examples[prompt_column][i] and examples[response_column][i]: ... 
 

该函数以数据样本集为参数。函数中定义了两个列表，inputs和targets，用于存储输入和目标数据。然后对样本集中的每个样本进行遍历，只有当样本中的提问和回答都存在时，才进行处理。
 

以下代码生成对话提示。如果历史列为空或没有历史记录，提示就是当前的查询。否则，提示将包含历史对话轮次的查询和回应，最后一轮为当前查询。
 

 

pythonCopy code
 

if history_column is None or len(examples[history_column][i]) == 0: prompt = query else: ... inputs.append(prompt) targets.append(examples[response_column][i]) 
 

生成提示后，将其添加到inputs列表中，并将相应的回答添加到targets列表中。
 

 

pythonCopy code
 

inputs = [prefix + inp for inp in inputs] model_inputs = tokenizer(inputs, max_length=data_args.max_source_length, truncation=True, padding=True) labels = tokenizer(text_target=targets, max_length=max_target_length, truncation=True) 
 

这部分代码首先给每个输入添加前缀，然后使用分词器对输入进行处理，包括分词、截断和填充，得到模型的输入数据。同样地，对目标数据进行处理，得到标签。
 

 

pythonCopy code
 

if data_args.ignore_pad_token_for_loss: labels["input_ids"] = [ [(l if l != tokenizer.pad_token_id else -100) for l in label] for label in labels["input_ids"] ] model_inputs["labels"] = labels["input_ids"] return model_inputs 
 

这部分代码根据ignore_pad_token_for_loss参数的值来决定是否在计算损失时忽略填充的token。如果选择忽略，那么将标签中所有的填充token的id都替换为-100。最后将处理后的标签添加到模型的输入数据中，并返回。
 

下面是preprocess_function_train函数，这个函数的作用和preprocess_function_eval类似，不过处理方式略有不同：
 

 

pythonCopy code
 

  1. def preprocess_function_train(examples):
  2.         max_seq_length = data_args.max_source_length + data_args.max_target_length
  3.  
  4.         model_inputs = {
  5.             "input_ids": [],
  6.             "labels": [],
  7.         }
  8.         for i in range(len(examples[prompt_column])):
  9.             if examples[prompt_column][i] and examples[response_column][i]:
  10.                 query, answer = examples[prompt_column][i], examples[response_column][i]
  11.  
  12.                 if history_column is None:
  13.                     prompt = query
  14.                 else:
  15.                     prompt = ""
  16.                     history = examples[history_column][i]
  17.                     for turn_idx, (old_query, response) in enumerate(history):
  18.                         prompt += "[Round {}]\n问：{}\n答：{}\n".format(turn_idx, old_query, response)
  19.                     prompt += "[Round {}]\n问：{}\n答：".format(len(history), query)
  20.  
  21.                 prompt = prefix + prompt
  22.                 a_ids = tokenizer.encode(text=prompt, add_special_tokens=False)
  23.                 b_ids = tokenizer.encode(text=answer, add_special_tokens=False)
  24.  
  25.                 if len(a_ids) > data_args.max_source_length - 1:
  26.                     a_ids = a_ids[: data_args.max_source_length - 1]
  27.  
  28.                 if len(b_ids) > data_args.max_target_length - 2:
  29.                     b_ids = b_ids[: data_args.max_target_length - 2]
  30.  
  31.                 input_ids = tokenizer.build_inputs_with_special_tokens(a_ids, b_ids)
  32.  
  33.                 context_length = input_ids.index(tokenizer.bos_token_id)
  34.                 mask_position = context_length - 1
  35.                 labels = [-100] * context_length + input_ids[mask_position+1:]
  36.                 
  37.                 pad_len = max_seq_length - len(input_ids)
  38.                 input_ids = input_ids + [tokenizer.pad_token_id] * pad_len
  39.                 labels = labels + [tokenizer.pad_token_id] * pad_len
  40.                 if data_args.ignore_pad_token_for_loss:
  41.                     labels = [(l if l != tokenizer.pad_token_id else -100) for l in labels]
  42.  
  43.                 model_inputs["input_ids"].append(input_ids)
  44.                 model_inputs["labels"].append(labels)
  45.  
  46.         return model_inputs
 

首先，函数定义了最大的序列长度，这是由源序列的最大长度和目标序列的最大长度之和得出的。然后，创建一个字典，用于存储模型的输入数据。
 

 

以下代码对每个样本进行处理，只有当样本中的提问和回答都存在时，才进行处理。
 

 

pythonCopy code
 

  1.         for i in range(len(examples[prompt_column])):
  2.             if examples[prompt_column][i] and examples[response_column][i]:
  3.                 query, answer = examples[prompt_column][i], examples[response_column][i]
  4.                 ...
 

生成提示的方式与preprocess_function_eval函数中的方法相同。然后对提示和回答进行分词，并处理长度超过最大限制的情况。
 

 

pythonCopy code
 

a_ids = tokenizer.encode(text=prompt, add_special_tokens=False) b_ids = tokenizer.encode(text=answer, add_special_tokens=False) if len(a_ids) > data_args.max_source_length - 1: a_ids = a_ids[: data_args.max_source_length - 1] if len(b_ids) > data_args.max_target_length - 2: b_ids = b_ids[: data_args.max_target_length - 2] 
 

接下来，使用分词器的build_inputs_with_special_tokens方法，将处理过的提问和回答token的id连接起来，形成模型的输入。
 

 

pythonCopy code
 

input_ids = tokenizer.build_inputs_with_special_tokens(a_ids, b_ids) 
 

然后，计算context的长度，并生成标签，标签是由-100和回答部分的token id组成。
 

 

pythonCopy code
 

context_length = input_ids.index(tokenizer.bos_token_id) mask_position = context_length - 1 labels = [-100] * context_length + input_ids[mask_position+1:] 
 

接下来的代码处理了输入和标签长度不足最大序列长度的情况，通过添加填充token来进行填充。
 

 

pythonCopy code
 

pad_len = max_seq_length - len(input_ids) input_ids = input_ids + [tokenizer.pad_token_id] * pad_len labels = labels + [tokenizer.pad_token_id] * pad_len 
 

然后根据ignore_pad_token_for_loss参数的值来决定是否在计算损失时忽略填充的token。如果选择忽略，那么将标签中所有的填充token的id都替换为-100。
 

 

pythonCopy code
 

if data_args.ignore_pad_token_for_loss: labels = [(l if l != tokenizer.pad_token_id else -100) for l in labels] 
 

最后将处理后的输入和标签添加到模型的输入数据中，并返回。
 

 

pythonCopy code
 

model_inputs["input_ids"].append(input_ids) model_inputs["labels"].append(labels) return model_inputs 
 

总的来说，这两个函数都是用来处理数据的，只不过它们处理数据的方式稍有不同。
 

  1.     if training_args.do_train:
  2.         if "train" not in raw_datasets:
  3.             raise ValueError("--do_train requires a train dataset")
  4.         train_dataset = raw_datasets["train"]
  5.         if data_args.max_train_samples is not None:
  6.             train_dataset = train_dataset.select(range(data_args.max_train_samples))
  7.         train_dataset = train_dataset.map(
  8.             preprocess_function_train,
  9.             batched=True,
  10.             num_proc=data_args.preprocessing_num_workers,
  11.             remove_columns=column_names,
  12.             load_from_cache_file=not data_args.overwrite_cache,
  13.         )
  14.  
  15.     if training_args.do_eval:
  16.         if "validation" not in raw_datasets:
  17.             raise ValueError("--do_eval requires a validation dataset")
  18.         eval_dataset = raw_datasets["validation"]
  19.         if data_args.max_eval_samples is not None:
  20.             eval_dataset = eval_dataset.select(range(data_args.max_eval_samples))
  21.         eval_dataset = eval_dataset.map(
  22.             preprocess_function_eval,
  23.             batched=True,
  24.             num_proc=data_args.preprocessing_num_workers,
  25.             remove_columns=column_names,
  26.             load_from_cache_file=not data_args.overwrite_cache,
  27.         )
 

这段代码主要用于数据预处理和数据集的选择。如果参数do_train设置为True，它将从raw_datasets中获取训练数据集，并根据需要选取最大训练样本数量的数据。然后，它使用上面定义的preprocess_function_train函数对训练数据集进行处理。数据集处理时使用的并行工作进程数量由preprocessing_num_workers参数控制。在处理完成后，会从数据集中删除原始列。
 

同样地，如果参数do_eval设置为True，这段代码将从raw_datasets中获取验证数据集，并根据需要选取最大验证样本数量的数据。然后，使用preprocess_function_eval函数进行处理。
 

  1.     # Initialize our Trainer
  2.     trainer = Seq2SeqTrainer(
  3.         model=model,
  4.         args=training_args,
  5.         train_dataset=train_dataset if training_args.do_train else None,
  6.         eval_dataset=eval_dataset if training_args.do_eval else None,
  7.         tokenizer=tokenizer,
  8.         data_collator=DataCollatorForSeq2Seq(tokenizer, model=model),
  9.     )
 

这段代码用于初始化训练器。Seq2SeqTrainer是一个为序列到序列模型量身定制的训练器，它接收模型、训练参数、训练数据集、评估数据集、分词器和数据处理器作为参数。
 

 

pythonCopy code
 

  1.     # Training
  2.     if training_args.do_train:
  3.         train_result = trainer.train(
  4.             model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path) else None
  5.         )
  6.         trainer.save_model()  # Saves the tokenizer too for easy upload
  7.  
  8.         output_train_file = os.path.join(training_args.output_dir, "train_results.txt")
  9.         if trainer.is_world_process_zero():
  10.             with open(output_train_file, "w") as writer:
  11.                 logger.info("***** Train results *****")
  12.                 for key, value in sorted(train_result.metrics.items()):
  13.                     logger.info(f"  {key} = {value}")
  14.                     writer.write(f"{key} = {value}\n")
  15.  
  16.         # Need to save the state, since Trainer.save_model saves only the tokenizer with the model
  17.         trainer.state.save_to_json(os.path.join(training_args.output_dir, "trainer_state.json"))
 

 

这段代码用于模型的训练。如果do_train参数被设置为True，训练器开始训练，训练完毕后，保存模型和分词器。然后将训练结果写入到一个txt文件中，并保存训练器的状态。
 

以上代码片段主要用于训练模型，处理训练和验证数据，并将训练的结果进行保存。希望这些解释能对你有所帮助。如果你有其他问题，欢迎提问。
 

让我们逐行解释一下：
 

 

pythonCopy code
 

for key, value in sorted(train_result.metrics.items()): 
 

这行代码遍历了train_result.metrics字典中的每一个键值对。这个字典可能包含了训练过程中产生的各种度量指标，例如训练的准确度，损失值等。sorted()函数保证了结果是按照键的字母顺序排列的。
 

 

pythonCopy code
 

logger.info(f" {key} = {value}") 
 

这行代码使用logger.info函数将每个指标的名称（键）和对应的值输出到日志信息中。这样的话，在运行脚本的过程中，就可以在命令行终端或者日志文件中查看这些指标的具体数值。
 

 

pythonCopy code
 

writer.write(f"{key} = {value}\n") 
 

这行代码则是将每个指标的名称和对应的值写入到一个文件中。这样做的好处是，训练过程结束之后，可以直接打开这个文件查看训练的结果，而不需要重新运行整个脚本。
 

总的来说，这段代码的目的是把训练过程中的关键指标值记录下来，方便后续分析模型的性能。

                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/137245
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号