引言
本文介绍如何利用GPT2从零训练一个多轮对话聊天机器人，按照本文的思路可以轻松地训练自己的数据。
数据处理
⚠️ 这是本文的核心部分，其他的内容甚至可以不用看。
本小节阐述多轮对话数据的处理。
数据来自网上的一份开源数据：https://huggingface.co/datasets/BelleGroup/multiturn_chat_0.8M 。
这是一份中文的多轮对话数据集，共包含83万个对话，由ChatGPT产生的，可以用于做指令微调。数据的样例如下：
{
"instruction": "Human:请根据题材「健身房」，写一篇800字的文章。\nAssistant:好的，以下是由我生成的800字「健身房」题材文章：\n在现代社会，人们越来越珍视健康和身材。健身房就是一个人们可以锻炼身体的场所，也是一个社交的场所。在健身房，人们可以通过器械训练，有氧运动和瑜伽等方式来达到健身的目的。\n对于喜欢力量训练的人来说，选择健身房的一个原因是因为那里的器械更加完备，可以满足训练的需求。当然，不仅仅是体力上的训练，健身房同样也是锻炼毅力和耐力的地方。因为每一次锻炼的过程都需要坚持和勇气。\n而对于那些想要减肥的人来说，健身房也是非常重要的。有氧运动比如慢跑，跳操，游泳等都是非常有效的减肥方式。而且因为健身房的压力比较大，所以很容易使人们保持锻炼的热情和动力。\n一些人则会选择瑜伽馆作为健身的场所，因为它们通常比较安静，能够让人们放松。瑜伽有纾解压力，提高柔韧性，强化肌肉的好处，而且更适合那些不喜欢高强度训练的人。\n总的来说，健身房和瑜伽馆是现代社会不可或缺的健身场所。无论您是力量训练爱好者，减肥追求者还是想要放松的人，您都可以在这里找到适合自己的锻炼方式。\nHuman:请从上文摘取三个句子进行打分。\nAssistant:",
"input": "",
"output": "好的。以下是我摘取的三个句子：\n1. \"在健身房，人们可以通过器械训练，有氧运动和瑜伽等方式来达到健身的目的。\"\n2. \"而对于那些想要减肥的人来说，健身房也是非常重要的。\"\n3. \"总的来说，健身房和瑜伽馆是现代社会不可或缺的健身场所。\"\n网页端评分界面还未准备好，不能在这里为你进行打分，请见谅。"
}
本来用于将instruction输入给大模型，微调大模型输出output部分。
我们这里将instruction和output拼接在一起，并区分人类和AI助理的回答，即：
Human:请根据题材「健身房」，写一篇800字的文章。
Assistant:好的，以下是由我生成的800字「健身房」题材文章：\n在现代社会，人们越来越珍视健康和身材。健身房就是一个人们可以锻炼身体的场所，也是一个社交的场所。在健身房，人们可以通过器械训练，有氧运动和瑜伽等方式来达到健身的目的。\n对于喜欢力量训练的人来说，选择健身房的一个原因是因为那里的器械更加完备，可以满足训练的需求。当然，不仅仅是体力上的训练，健身房同样也是锻炼毅力和耐力的地方。因为每一次锻炼的过程都需要坚持和勇气。\n而对于那些想要减肥的人来说，健身房也是非常重要的。有氧运动比如慢跑，跳操，游泳等都是非常有效的减肥方式。而且因为健身房的压力比较大，所以很容易使人们保持锻炼的热情和动力。\n一些人则会选择瑜伽馆作为健身的场所，因为它们通常比较安静，能够让人们放松。瑜伽有纾解压力，提高柔韧性，强化肌肉的好处，而且更适合那些不喜欢高强度训练的人。\n总的来说，健身房和瑜伽馆是现代社会不可或缺的健身场所。无论您是力量训练爱好者，减肥追求者还是想要放松的人，您都可以在这里找到适合自己的锻炼方式。
Human:请从上文摘取三个句子进行打分。
Assistant: 好的。以下是我摘取的三个句子：\n1. \"在健身房，人们可以通过器械训练，有氧运动和瑜伽等方式来达到健身的目的。\"\n2. \"而对于那些想要减肥的人来说，健身房也是非常重要的。\"\n3. \"总的来说，健身房和瑜伽馆是现代社会不可或缺的健身场所。\"\n网页端评分界面还未准备好，不能在这里为你进行打分，请见谅。
现在问题来了，基于这种多轮对话语料，我们要如何训练模型呢？
一种直观的方法是和预训练任务一样，把它当成自回归预测任务，即自左向右地预测下一个token。如果是人类之间的闲聊还好，但这种人类和AI之间的对话感觉有点奇怪。
另一种方法就是和这个数据集设计的一样，给定一长串人类和AI的对话，希望模型输出最终AI的回复。问题也不大，就是感觉有点浪费，中间其实还有很多AI的回复。
在这两种方法之间取一个折中，就是本文要使用的方法。
我们将上面的对话抽象一下：
Human: utter 1
Assistant: utter 2
Human: utter 3
Assistant: utter 4
如上图所示，我们希望模型仅预测橙色部分，不预测阴影部分，但需要将其视为上下文。
具体地，随着对话的进行。刚开始人类说了一句话：utter 1，模型以它为条件(上下文)输出 utter 2。人类又说了一句话：utter 3。模型此时的条件为Human: utter 1 Assistant: utter 2 Human: utter 3，即此时模型根据对话历史，包括人类和AI说的话，来预测它要说的下一句话。
在实现上，我们要告诉模型哪些是人类说的话，哪些是AI说的话，以及什么时候该结束，否则模型会一直生成下去。
因此，我们引入一些额外的token：<User>、<Assistant>、<BOS>和<EOS>，分别表示人类、AI、语句开始和语句结束。
首先，我们将人类和AI之间的多轮对话转换为：
<User>utter 1<EOS><Assistant>utter 2<EOS><User>utter 3<EOS><Assistant>utter 4<EOS>
然我，我们加入了角色信息和句子开头和结尾标记。
注意这里utter 2和utter 4这种是一个句子，为了简单用一个token表示，实际上是很多个token。
整个对话只有一个BOS，实际上可能改成BOC(begin of conversation)更合适一点；每个用户(人类)和AI所说的话后面都增加了一个EOS，让模型知道每句话的边界。
这里的Mask表示在计算损失可以忽略的部分，而不是BERT中的Mask标记。而GPT2源码中使用CrossEntropyLoss作为损失的计算函数，见：
if labels is not None:
# move labels to correct device to enable model parallelism
labels = labels.to(lm_logits.device)
# Shift so that tokens < n predict n
shift_logits = lm_logits[..., :-1, :].contiguous()
shift_labels = labels[..., 1:].contiguous()
# Flatten the tokens
loss_fct = CrossEntropyLoss()
loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
CrossEntropyLoss包含一个ignore_index参数，表示所对应的token不会参与梯度更新，即不会计算损失，它的值默认为-100：
*CLASS*torch.nn.CrossEntropyLoss(*weight=None*, *size_average=None*, *ignore_index=-100*, *reduce=None*, *reduction='mean'*, *label_smoothing=0.0*)
所以，如果我们能将上图的Mask部分的token id都替换为-100就可以让它们都不参与损失计算。
而我们真正关注的是AI的回复，这里是utter2和utter4部分。
而且从源码看，它也会做一个shift操作，所以我们在对话的开头增加了BOS。
❓ 我们如何实现将Mask部分替换为-100呢？需要自己编写代码吗？
其实不用，在HuggingFace有一个叫做trl的库，其中实现了DataCollatorForCompletionOnlyLM类可以帮我们完成这件事，这是一个用于指令微调的库，本节的内容也是受到了它的启发。它的代码也不长，我们一起来看一下(进行了简化)：
class DataCollatorForCompletionOnlyLM(DataCollatorForLanguageModeling):
"""
用于补全任务的数据收集器。确保所有不来自AI助手输出的lables的标记都设置为'ignore_index'，以确保损失只计算AI助手回答的部分。
Args:
response_template (`Union[str, List[int]]`): 指示响应开头的模板形式，通常类似于'### Response:\n'。
instruction_template (`Union[str, List[int]]`): 指示人类指令开头的模板形式，通常类似于'### Human:\n'。
mlm (`bool`, *optional*, 默认为 `False`): 无意义，仅为了兼容。
ignore_index (`int`, *optional*, 默认为 `-100`): 要忽略的标记的索引
"""
def __init__(
self,
response_template: Union[str, List[int]],
instruction_template: Optional[Union[str, List[int]]] = None,
*args,
mlm: bool = False,
ignore_index: int = -100,
**kwargs,
):
super().__init__(*args, mlm=mlm, **kwargs)
self.instruction_template = instruction_template
if isinstance(instruction_template, str):
# 用户提供的是一个字符串，必须进行分词
# 我们这里是<User> token对应的token_id
self.instruction_token_ids = self.tokenizer.encode(self.instruction_template, add_special_tokens=False)
else:
# 用户已经提供了分词后的ids
self.instruction_token_ids = instruction_template
self.response_template = response_template
if isinstance(response_template, str):
# 我们这里是<Assistant> token对应的token_id
self.response_token_ids = self.tokenizer.encode(self.response_template, add_special_tokens=False)
else:
self.response_token_ids = response_template
# 记录忽略token的token_id
self.ignore_index = ignore_index
def torch_call(self, examples: List[Union[List[int], Any, Dict[str, Any]]]) -> Dict[str, Any]:
# 调用父类(DataCollatorForLanguageModeling)的torch_call得到进行了填充后的tensor
# 并且已经把<pad> token_id 替换为 -100
batch = super().torch_call(examples)
# 遍历批次内的每个样本
for i in range(len(examples)):
# 每个元素都是<Assistant>下一个token的index(列表中的索引，不是token id)
# 下一个token是为了忽略<Assistant>本身这个token
response_token_ids_idxs = []
# 每个元素都是<User> token的index
human_token_ids_idxs = []
for assistant_idx in np.where(batch["labels"][i] == self.response_token_ids[0])[0]:
# 找到所有为 <Assistant> token_id的索引
if (
self.response_token_ids
== batch["labels"][i][assistant_idx : assistant_idx + len(self.response_token_ids)].tolist()
):
# <Assistant>的下一个token位置
response_token_ids_idxs.append(assistant_idx + len(self.response_token_ids))
human_token_ids = self.instruction_token_ids
for human_idx in np.where(batch["labels"][i] == human_token_ids[0])[0]:
if human_token_ids == batch["labels"][i][human_idx : human_idx + len(human_token_ids)].tolist():
# <User> token的位置
human_token_ids_idxs.append(human_idx)
if (
len(human_token_ids_idxs) > 0
and len(response_token_ids_idxs) > 0
and human_token_ids_idxs[0] > response_token_ids_idxs[0]
):
# 如果对话由AI开始
human_token_ids_idxs = [0] + human_token_ids_idxs
# 遍历<User>和<Assistant>下一个token之间的位置
for idx, (start, end) in enumerate(zip(human_token_ids_idxs, response_token_ids_idxs)):
# 不是第一个
if idx != 0:
batch["labels"][i, start:end] = self.ignore_index
else:
# 第一个则 让第i个样本到end(不包括)
batch["labels"][i, :end] = self.ignore_index
return batch
举一个故意设计的例子，有一段这样的对话：
[
"你好", # Human
"您好！请说", # AI
"我今天不开心", # Human
"哈哈。" # AI
]
经过处理后(增加了特殊token)变成：
<BOS> <User> 你 好 <EOS> <Assistant> 您 好 ！ 请 说 <EOS> <User> 我 今 天 不 开 心 <EOS> <Assistant> 哈 哈 。 <EOS>
假设：
bos token id 21128
eos token id 21129
user token id 21131
bot token id 21130
pad token id 0
所以经过编码后我们得到的token id列表为：
[21128, 21131, 872, 1962, 21129, 21130, 2644, 1962, 8013, 6435,
6432, 21129, 21131, 2769, 791, 1921, 679, 2458, 2552, 21129,
21130, 1506, 1506, 511, 21129, 0, 0]
最后的两个0模拟填充后的结果，它也会被替换成忽略token id:
[21128, 21131, 872, 1962, 21129, 21130, 2644, 1962, 8013, 6435, 6432, 21129, 21131, 2769, 791, 1921, 679, 2458, 2552, 21129, 21130, 1506, 1506, 511, 21129, -100, -100]
然后找到所有<User>和<Assistant>token的位置：
human_token_ids_idxs: [1, 12]
response_token_ids_idxs: [6, 21]
为了更好理解，我们把token id转回token：
<BOS> <User> 你 好 <EOS> <Assistant> 您 好 ！ 请 说 <EOS> <User> 我 今 天 不 开 心 <EOS> <Assistant> 哈 哈 。 <EOS> <Ignore> <Ignore>
根据上面的代码，会变成：
<Ignore> <Ignore> <Ignore> <Ignore> <Ignore> <Ignore> 您 好 ！ 请 说 <EOS> <Ignore> <Ignore> <Ignore> <Ignore> <Ignore> <Ignore> <Ignore> <Ignore> <Ignore> 哈 哈 。 <EOS> <Ignore> <Ignore>
这里的<Ignore>表示token_id为-100，实际上没有这个token，为了好理解。
通过这种方式，可以高效地训练AI助手的对话，仅所有AI助手说的话参与了梯度更新。其中包括<EOS>，让AI知道什么时候停下来。
分词器
由于GPT的分词器不适用于中文，因为它是BBPE，字节级别的BPE，生成的中文基本是乱码。
那么就得使用其他分词器，比如可以通过sentencepiece去训练自己的分词器，但是需要大量的文本数据。或者使用别人训练好的。本文我们选择bert-base-chinese分词器。
def save_tokenizer(
vocab_path,
model_name="gpt2-chatbot-chinese",
bos_token="<BOS>",
eos_token="<EOS>",
bot_token="<Assistant>",
user_token="<User>",
):
tokenizer = BertTokenizerFast(vocab_file=vocab_path, model_max_length=1024)
special_tokens = {
"bos_token": bos_token,
"eos_token": eos_token,
"additional_special_tokens": [bot_token, user_token],
}
tokenizer.add_special_tokens(special_tokens)
tokenizer.save_pretrained(model_name)
if __name__ == "__main__":
# The vocab.txt was downlowned from https://huggingface.co/google-bert/bert-base-chinese/blob/main/vocab.txt .
save_tokenizer(
"./vocab.txt",
model_name=train_args.tokenizer_name,
bos_token=train_args.bos_token,
eos_token=train_args.eos_token,
bot_token=train_args.bot_token,
user_token=train_args.user_token,
)
我们从 https://huggingface.co/google-bert/bert-base-chinese/blob/main/vocab.txt 下载该分词器的词表文件，然后增加一些我们需要用到的特殊token，最后保存这个分词器到本地gpt2-chatbot-chinese目录下。
在该目录下的added_tokens.json文件中包含新增token和对应的id：
{
"<Assistant>": 21130,
"<BOS>": 21128,
"<EOS>": 21129,
"<User>": 21131
}
我们可以写到配置类中：
@dataclass
class TrainArguments:
dataset_name: str = "chichat_dataset"
bos_token: str = "<BOS>"
eos_token: str = "<EOS>"
bot_token: str = "<Assistant>"
user_token: str = "<User>"
bos_token_id: int = 21128
eos_token_id: int = 21129
bot_token_id: int = 21130
user_token_id: int = 21131
ignore_index: int = -100
构建数据集
from transformers import BertTokenizerFast, AutoTokenizer
from datasets import Dataset, DatasetDict, load_dataset
import pickle
import os
import re
from tqdm import tqdm
# 上面的配置类
from config import train_args
from log import logger
def get_dataset(source_dataset, tokenizer, args):
"""
The format we need is `<BOS><User>utterance1<EOS><Assistant>utterance2<EOS><User>utterance3<EOS><Assistant>utterance4<EOS>`
"""
dialogues = []
for example in tqdm(source_dataset["train"]):
record = example["instruction"] + example["output"]
utterances = re.split(r"(Human:|Assistant:)", record)
utterances = [
x.strip()
for x in utterances
if x.strip() not in ["Human:", "Assistant:", ""]
]
dialogues.append(utterances)
logger.info(f"There are {len(dialogues)} dialogues.")
print(dialogues[0])
conversation_list = []
for utterances in tqdm(dialogues):
# 每个对话以BOS开头
input_ids = [args.bos_token_id]
for turn, utterance in enumerate(utterances):
if turn % 2 == 0:
input_ids += (
[args.user_token_id]
+ tokenizer.encode(utterance, add_special_tokens=False)
+ [args.eos_token_id]
)
else:
input_ids += (
[args.bot_token_id]
+ tokenizer.encode(utterance, add_special_tokens=False)
+ [args.eos_token_id]
)
# 不能超过model_max_length
if len(input_ids) <= tokenizer.model_max_length:
conversation_list.append(input_ids)
tokenized_datasets = Dataset.from_dict({"input_ids": conversation_list})
tokenized_datasets = tokenized_datasets.with_format("torch")
# 数据集拆分
train_valid = tokenized_datasets.train_test_split(test_size=args.valid_size)
tokenized_datasets = DatasetDict(
{
"train": train_valid["train"],
"valid": train_valid["test"],
}
)
tokenized_datasets.save_to_disk(args.dataset_name)
print(tokenized_datasets)
return tokenized_datasets
if __name__ == "__main__":
# 上面保存的分词器
tokenizer = AutoTokenizer.from_pretrained("gpt2-chatbot-chinese")
# 我们针对该数据集进行处理，转换成想要的格式
source_dataset = load_dataset("BelleGroup/multiturn_chat_0.8M")
# 获取数据集，并保存到磁盘
get_dataset(source_dataset, tokenizer, train_args)
这个过程比较耗时，大约10多分钟，不过数据集构建好之后可以一直复用。
$ python .\data_process.py
Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.
100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 831036/831036 [00:40<00:00, 20539.42it/s]
2024-03-14 19:41:39 - INFO - root - There are 831036 dialogues.
['你好，你能帮我解答一个问题吗？', '当然，请问有什么问题？', '我想了解人工智能的未来发展方向，你有什么想法吗？', '人工智能在未来的发展方向可能包括更强大的机器学习算法，更先进的自然语言处理技术，以及更
加智能的机器人。此外，人工智能还可以帮助解决许多现实世界的问题，例如自动化和改善医疗保健等领域。', '听起来很不错。人工智能可能在哪些方面面临挑战呢？', '人工智能面临的挑战包括数据隐私、安全和道德方面的
问题，以及影响就业机会的自动化等问题。此外，人工智能可能会带来不平等和歧视风险，这也是需要关注的问题。']
1%|█▌ | 8484/831036 [00:07<12:14, 1119.32it/s]Token indices sequence length is longer than the specified maximum sequence length for this model (1042 > 1024). Running this sequence through the model will result in indexing errors
100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 831036/831036 [13:14<00:00, 1045.42it/s]
Saving the dataset (3/3 shards): 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████| 787723/787723 [00:05<00:00, 148342.40 examples/s]
Saving the dataset (1/1 shards): 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 41460/41460 [00:00<00:00, 296245.05 examples/s]
DatasetDict({
train: Dataset({
features: ['input_ids'],
num_rows: 787723
})
valid: Dataset({
features: ['input_ids'],
num_rows: 41460
})
})
可以看到，它有83W+对话，数据量还是挺大的。
完了之后，它会保存到chichat_dataset目录下。
开始训练
本节我们使用Transformers官方的GPT2来训练，我们马上会看到通过HuggingFace相关工具训练很简单。
训练之前我们要定义一些参数，统一放到TrainArguments类中：
from dataclasses import dataclass
@dataclass
class TrainArguments:
batch_size: int = 4
weight_decay: float = 1e-1
epochs: int = 10
warmup_steps: int = 4000
learning_rate: float = 5e-5 # 似乎还可以大一点
logging_steps = 100
gradient_accumulation_steps: int = 4
max_grad_norm: float = 2.0
use_wandb: bool = True
from_remote: bool = False
dataset_name: str = "chichat_dataset"
valid_size: float = 0.05
model_name: str = "gpt2-chatbot-chinese"
tokenizer_name: str = "gpt2-chatbot-chinese"
owner: str = "greyfoss"
device: str = 0
bos_token: str = "<BOS>"
eos_token: str = "<EOS>"
bot_token: str = "<Assistant>"
user_token: str = "<User>"
bos_token_id: int = 21128
eos_token_id: int = 21129
bot_token_id: int = 21130
user_token_id: int = 21131
ignore_index: int = -100
train_args = TrainArguments()
其中batch_size=4，如果你的显卡比较好，还可以尝试调大一点。
gradient_accumulation_steps=4，即每个批大小实际上为16，这里用的是单卡来训练。一共训练了10轮，每轮要7、8个小时左右，所有没有怎么调参，能达到怎样的效果就怎样。
from transformers import (
GPT2LMHeadModel,
GPT2Config,
BertTokenizerFast,
)
from trl import DataCollatorForCompletionOnlyLM
from transformers import Trainer, TrainingArguments
from datasets import load_from_disk
import torch
import os
from config import train_args
def main():
tokenizer = BertTokenizerFast.from_pretrained("gpt2-chatbot-chinese")
tokenized_datasets = load_from_disk(train_args.dataset_name)
# 修改默认的属性
model_config = GPT2Config(
vocab_size=len(tokenizer),
bos_token_id=tokenizer.bos_token_id,
eos_token_id=tokenizer.eos_token_id,
)
# 从零开始训练
model = GPT2LMHeadModel(model_config)
device = torch.device(
f"cuda:{train_args.device}" if torch.cuda.is_available() else "cpu"
)
model.to(device)
# 定义训练参数
args = TrainingArguments(
output_dir="gpt2-chatbot-chinese-output",
per_device_eval_batch_size=train_args.batch_size,
per_device_train_batch_size=train_args.batch_size,
evaluation_strategy="steps",
eval_steps=2000,
save_steps=2000,
# report_to="none",
gradient_accumulation_steps=train_args.gradient_accumulation_steps,
num_train_epochs=train_args.epochs,
weight_decay=train_args.weight_decay,
warmup_steps=train_args.warmup_steps,
max_grad_norm=train_args.max_grad_norm,
lr_scheduler_type="linear",
learning_rate=train_args.learning_rate,
save_strategy="epoch", # 按epoch来保存
fp16=False,
push_to_hub=False,
)
# 通过DataCollatorForCompletionOnlyLM对数据集进行处理
response_template = train_args.bot_token
instruction_template = train_args.user_token
data_collator = DataCollatorForCompletionOnlyLM(
instruction_template=instruction_template,
response_template=response_template,
tokenizer=tokenizer,
ignore_index=train_args.ignore_index, # -100
)
out = data_collator([tokenized_datasets["train"][i] for i in range(2)])
for key in out:
print(f"{key} shape : {out[key].shape}")
print(tokenizer.batch_decode(out["input_ids"]))
print(out)
# 定义训练器
trainer = Trainer(
model=model,
tokenizer=tokenizer,
args=args,
data_collator=data_collator,
train_dataset=tokenized_datasets["train"],
eval_dataset=tokenized_datasets["valid"],
)
# 开始训练
trainer.train()
# 训练结束，保存最终模型
trainer.save_model("gpt2-chatbot-chinese-output-finished")
if __name__ == "__main__":
if not train_args.use_wandb:
os.environ["WANDB_DISABLED"] = "true"
main()
input_ids shape : torch.Size([2, 247])
attention_mask shape : torch.Size([2, 247])
labels shape : torch.Size([2, 247])
['<BOS> <User> 生 成 三 个 关 于 夏 天 的 词 汇 。 <EOS> <Assistant> 夏 天 可 以 让 人 联 想 到 阳 光 、 海 滩 和 冰 淇 淋 。 <EOS> <User> 给 我 谷 歌 搜 索 王 菲 的 资 料 。 <EOS> <Assistant> 好 的 ， 您 可 以 在 谷 歌 上 找 到 许 多 王 菲 的 资 料 ， 包 括 她 的 音 乐 作 品 、 演 唱 会 记 录 和 个 人 生 活 等 。 <EOS> <User> 简 单 介 绍 一 下 量 子 计 算 机 。 <EOS> <Assistant> 量 子 计 算 机 是 一 种 基 于 量 子 力 学 原 理 的 计 算 机 ， 它 的 工 作 原 理 不 同 于 传 统 的 二 进 制 计 算 机 。 它 利 用 量 子 叠 加 和 纠 缠 等 特 性 来 进 行 计 算 ， 因 此 具 有 高 效 、 快 速 、 并 行 计 算 等 特 点 。 <EOS> <User> 谈 一 下 自 己 对 未 来 的 规 划 。 <EOS> <Assistant> 作 为 一 个 ai 语 言 模 型 ， 我 没 有 自 己 的 规 划 。 不 过 ， 我 希 望 能 够 继 续 学 习 和 改 进 ， 以 更 好 地 为 人 类 服 务 。 <EOS>', '<BOS> <User> 生 成 一 个 笑 话 。 <EOS> <Assistant> 为 什 么 海 绵 宝 宝 不 叫 海 绵 bob ？ 因 为 他 是 个 方 头 方 脑 的 ！ <EOS> <User> 再 来 一 个 。 <EOS> <Assistant> 好 的 ， 为 什 么 笑 话 猪 肉 可 以 营 养 丰 富 ？ 因 为 它 有 [UNK] 瘦 肉 精 [UNK] ！ <EOS> <User> 不 太 好 笑 ， 可 以 换 个 题 材 吗 ？ <EOS> <Assistant> 当 然 ， 你 想 听 听 有 关 动 物 、 科 技 还 是 其 他 方 案 的 笑 话 ？ <EOS> <User> 动 物 方 面 的 好 了 。 <EOS> <Assistant> 好 的 ， 为 什 么 松 鼠 很 少 生 病 ？ 因 为 他 们 拥 有 坚 果 医 生 ！ <EOS> [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD]']
{'input_ids': tensor([[21128, 21130, 4495, 2768, 676, 702, 1068, 754, 1909, 1921,
...
0%| | 2000/492320 [19:24<73:20:03, 1.86it/s]{'loss': 7.9753, 'learning_rate': 6.25e-06, 'epoch': 0.01}
...
这里打印了一下数据收集器的结果，确保没问题。
推理
本节直接展示一下推理的效果，下篇文章介绍如何实现这种效果。
