万张成文教你如何做出 ChatGPT

3 秀出的广告词就是“道别变非常的 GPT3”，它可以通过不可用一条样例的 Zero-shot、仅可用一条样例的 One-shot 和可用少量样例的 Few-shot 来进行推理护航。上头是对比变非常仿真和 GPT3 三种相当程度不同的抽样推理形式图。 ChatGPT

ChatGPT 可用了类似 InstructGPT 的作法来专业训练仿真，该步骤也被称作 Learning from Human Feedback。主要划分三个步骤：

用有行政官员数据库精调 GPT-3.5；对于仿真负载的候选结果（因为频域都会建成同一负载有相当程度不同负载）顺利进行最非常好成绩，从而专业训练取得一个表扬仿真；可用这个表扬仿真，用 PPO 时域来进一步对仿真顺利进行专业训练。 如何专业训练一个 GPT

每一次我们来动手实践一下如何专业训练一个 GPT 仿真出来，这那时候以从头专业训练一个code模版的 GPT 仿真为例。

code模版有什么用呢，比如我们给仿真一个提示：

from transformers import AutoTokenizer, AutoModelForSequenceClassification# build a BERT classifier

然后仿真就只能负载：

tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')model = AutoModelForSequenceClassification.from_pretrained('bert-base-uncased')

帮我们理论上为了一个基于 Bert 的分类器出来。

为了专业训练这样一个仿真，首先行我们只能准备可用专业训练的数据库，少用的code模版的数据库为 codeparrot。

这那时候随便打印一条数据库（截断了，不然绝非长了）出来就让，可以看见本来跟我们正常写就的code是一样的。

然而仿真是不必同样送达这样的“译文”个人信息的，所以专业训练 NLP 仿真年前上都会只能对其顺利进行“过去时”，转变成为由一串数本字回应，可以创始人一个过去时器：

tokenizer = AutoTokenizer.from_pretrained("./code-search-net-tokenizer")

对上头的code顺利进行过去时转变成，就可以取得如下的一串 id：

[3, 41082, 17023, 26, 11334, 13, 24, 41082, 173, 2745, 756, 173, 2745, 4397, 173, 2745, 1893, 173, 2745, 3857, 442, 2604, 173, 973, 7880, 978, 3399, 173, 973, 10888, 978, 4582, 173, 173, 973, 309, 65, 552, 978, 6336, 4391, 173, 295, 6472, 8, ...

上头的举例来话说演示了对单条抽样顺利进行过去时的结果；上都会我们都会把过去时变量理论上为好（当中间都会关乎到比如需不必够截断、第二大大小不一多少等细节的设计这那时候就不详细一触即发了），然后同样对整个数据库集顺利进行 map 就可以对整个数据库集顺利进行过去时了。

def tokenize(element): outputs = tokenizer( element["content"], truncation=True, max_length=context_length, return_overflowing_tokens=True, return_length=True, ) input_batch = [] for length, input_ids in zip(outputs["length"], outputs["input_ids"]): if length == context_length: input_batch.append(input_ids) return {"input_ids": input_batch}tokenized_datasets = raw_datasets.map( tokenize, batched=True, remove_columns=raw_datasets["train"].column_names)

搞定数据库后，每一次就只能创始人（初始化）一个仿真了，GPT 的构建本来就是由 transformer 组成的，留言板的轮子早已很多了，这那时候就不再建轮子了，最少用的同样用的 transformers 库，通过的设计的作法就只能快速理论上为一个仿真出来了。

from transformers import AutoTokenizer, GPT2LMHeadModel, AutoConfigconfig = AutoConfig.from_pretrained( "gpt2", vocab_size=len(tokenizer), n_ctx=context_length, bos_token_id=tokenizer.bos_token_id, eos_token_id=tokenizer.eos_token_id,)model = GPT2LMHeadModel(config)model_size = sum(t.numel() for t in model.parameters())print(f"GPT-2 size: {model_size/1000**2:.1f}M parameters")

这是一个 124.2M 仿真模板的 GPT2，仿真的code构建打给大家就让（详细的code充分借助可以选读 transformers 库的GCC），本来主要就是上头有个 embedding 层，当中间 12 个 transformer block，再次有个时域层。

GPT2LMHeadModel( (transformer): GPT2Model( (wte): Embedding(50000, 768) (wpe): Embedding(1024, 768) (drop): Dropout(p=0.1, inplace=False) (h): ModuleList( (0): GPT2Block( (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True) (attn): GPT2Attention( (c_attn): Conv1D() (c_proj): Conv1D() (attn_dropout): Dropout(p=0.1, inplace=False) (resid_dropout): Dropout(p=0.1, inplace=False) ) (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True) (mlp): GPT2MLP( (c_fc): Conv1D() (c_proj): Conv1D() (act): NewGELUActivation() (dropout): Dropout(p=0.1, inplace=False) ) ) ################# 当中间省略重复的10层Block ################# (11): GPT2Block( (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True) (attn): GPT2Attention( (c_attn): Conv1D() (c_proj): Conv1D() (attn_dropout): Dropout(p=0.1, inplace=False) (resid_dropout): Dropout(p=0.1, inplace=False) ) (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True) (mlp): GPT2MLP( (c_fc): Conv1D() (c_proj): Conv1D() (act): NewGELUActivation() (dropout): Dropout(p=0.1, inplace=False) ) ) ) (ln_f): LayerNorm((768,), eps=1e-05, elementwise_affine=True) ) (lm_head): Linear(in_features=768, out_features=50000, bias=False))

这那时候也得出 GPT2 和 GPT 的仿真构建图，不感兴趣的同学可以慎重就让，可以发现，GPT2 的仿真构建(右)较 GPT 的仿真构建(右方)相当程度修改。在 GPT2 当中的一个 Transformer Block 层当中，第一个 LayerNormalization 模组被移转到了 Msaked-Multi-Self-Attention 模组在此之后, 第二个 LayerNormalization 模组也被移转到了 Feed-Forward 模组在此之后；同时 Residual-connection 的位置也相应到了 Msaked-Multi-Self-Attention 模组与 Feed-Forward 模组之后。

数据库和仿真构建都确定下来后，每一次我们只能有一个专业训练的程序或者框架，最有用的那就是同样子程序 transformers 提供的专业训练器，假定一些的设计，仿真、过去时器、数据库集。

from transformers import Trainer, TrainingArgumentsargs = TrainingArguments( output_dir="codeparrot-ds", per_device_train_batch_size=32, per_device_eval_batch_size=32, evaluation_strategy="steps", eval_steps=5_000, logging_steps=5_000, gradient_accumulation_steps=8, num_train_epochs=1, weight_decay=0.1, warmup_steps=1_000, lr_scheduler_type="cosine", learning_rate=5e-4, se_steps=5_000, fp16=True, push_to_hub=True,)trainer = Trainer( model=model, tokenizer=tokenizer, args=args, data_collator=data_collator, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["valid"],)

然后就可以一键专业训练了：

trainer.train()

自由度非常高一点的专业训练作法也可以自行打建，依次拿到每个 batch 数据库、转送仿真、算出 loss、反向传扬；对于大仿真来话说，少用的用 accelerate 库来顺利进行减缓，比如混合精度、局部累积等操作。

上述的这些code（可用专业训练器或者 accelerate 库顺利进行专业训练）在 transformers 的在此在此之后教程那时候都有，不感兴趣的可以自己走一走哦。

专业训练放仿真后我们可以来看一下它的code聚合技能，那就先行来跟大家 hello world 一下。

假定 prompt：

def print_hello_world(): """Print 'Hello World!'."""

取得：

def print_hello_world(): """Print 'Hello World!'.""" print('Hello World!')

假定 prompt：

import numpy as

它告诉我们都用的英文名称就就是：

import numpy as np

假定 prompt：

import numpy as npfrom sklearn.ensemble import RandomForestClassifier# create training dataX = np.random.randn(100, 100)y = np.random.randint(0, 1, 100)# setup train test split

它只能帮我们划分专业训练和测试数据库集：

import numpy as npfrom sklearn.ensemble import RandomForestClassifier# create training dataX = np.random.randn(100, 100)y = np.random.randint(0, 1, 100)# setup train test splitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

这一节当中我们回头了一遍专业训练 GPT 的一个程序，这那时候和专业训练 ChatGPT 的第一步的不同点在于：ChatGPT 第一步引入人工写就题目的作法取得的语料对先行为专业训练好的 GPT 顺利进行了精调，而本节只是对一个小语料顺利进行了一波先行为专业训练。

这样好好的再次一目标也是易于明白的，绝非同样拿留言板的各种语料来好好先行为专业训练，假定着很多干净数据库。

如何专业训练一个表扬仿真

每一次我们来看一下专业训练 ChatGPT 的第二步：

只能话说“钞技能”真毫无疑问，openai 同样请求了一群人，给 GPT 聚合的多个问到顺利进行次序最非常好成绩，然后再次根据这个最非常好成绩专业训练一个表扬仿真（GPT 聚合的结果越少好，总分越少少），有了这样一个仿真后，就可以用来指导 GPT 聚合尽有可能非常好成绩的问到了。

没钱也没精力，但不妨碍我们自学如何专业训练一个表扬仿真，表扬仿真的自学只不过就是一个句子分类或者紧接的护航。

这那时候找一个数据库集来演示一下整个程序，比如 IMDB 评论数据库集，常可用情感分析，也就是给译文的情感最非常好成绩，负载就是评论，负载就是总分（鼓励或消极对应 1 或 0），那就能专业训练一个表扬仿真了（比如可以用来指导 GPT 聚合总分越少少，也就是非常沙鼓励的译文）。

首先行导入一下数据库集（App关键本字：~amaas/data/sentiment/）

def read_imdb_split(split_dir): split_dir = Path(split_dir) texts = [] labels = [] for label_dir in ["pos", "neg"]: for text_file in (split_dir/label_dir).iterdir(): texts.append(text_file.read_text(encoding='utf-8')) labels.append(0 if label_dir is "neg" else 1) return texts, labelstrain_texts, train_labels = read_imdb_split("./DataSmall/aclImdb/train")test_texts, test_labels = read_imdb_split("./DataSmall/aclImdb/test")

看大吃一惊数据库就是长这样，一段译文对应一个标签：

举例来话说的我们只能对其顺利进行过去时，转为一串 id，理论上为过去时器，并构建数据库集：

print("Tokenizing train, validate, test text ")tokenizer = DistilBertTokenizerFast.from_pretrained('distilbert-base-uncased')train_encodings = tokenizer(train_texts, truncation=True, padding=True)test_encodings = tokenizer(test_texts, truncation=True, padding=True)class IMDbDataset(torch.utils.data.Dataset): def originallyinitoriginally(self, encodings, labels): self.encodings = encodings self.labels = labels def originallygetitemoriginally(self, idx): item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()} item['labels'] = torch.tensor(self.labels[idx]) return item def originallylenoriginally(self): return len(self.labels)print("Loading tokenized text into Pytorch Datasets ")train_dataset = IMDbDataset(train_encodings, train_labels)test_dataset = IMDbDataset(test_encodings, test_labels)train_loader = DataLoader(train_dataset, batch_size=10, shuffle=True)

每一次理论上为一个可用理论上为总分的仿真，以及最佳化器：

print("Loading pre-trained DistilBERT model ")model = DistilBertForSequenceClassification.from_pretrained('distilbert-base-uncased')model.to(device)model.train()optim = AdamW(model.parameters(), lr=5e-5)

每一次就可以开始仿真的专业训练了：

for epoch in range(3): for (b_ix, batch) in enumerate(train_loader): optim.zero_grad() input_ids = batch['input_ids'].to(device) attention_mask = batch['attention_mask'].to(device) labels = batch['labels'].to(device) outputs = model(input_ids, attention_mask=attention_mask, labels=labels) loss = outputs[0] loss.backward() optim.step()

专业训练放仿真后，我们就可以对取值译文来顺利进行情感的最非常好成绩了，比如：

显然这是一句很 positive 的话，仿真的最非常好成绩为：

本章的放整code可以参见 James D. McCaffrey 的博客：

PS：仿真的选择弊端，这那时候作为演示频域了一个 distilbert 作为表扬仿真，但也就是话说上 ChatGPT 用的表扬仿真的规模应该是和聚合仿真差不多大小不一的仿真。

到目年前为止，我们早已只能专业训练一个只能聚合译文的 GPT，一个只能对译文最非常好成绩的表扬仿真，每一次就只能权衡如果用表扬仿真来基督徒 GPT 聚合非常好成绩译文了。权衡到很多同学有可能未精进自学的为基础，这那时候将填入一章精进自学的概述。

（最深处）精进自学简介

精进自学的章节本来很多，背后关乎的微积分也挺多，身边很多人在进阶反复就被劝退，为了让大家非常易于给与，这那时候主要概述一些俱全的基本知识，以及从战略局部步骤到 PPO 时域的转变。

精进术语

在精进自学当中，智能化基底和周边环境顺利进行交互并基于一定的表扬必要来提非常高自身的水平；智能化基底的决策，一般称为战略（policy）决定了在当年前周边环境状况下智能化基底应该去拟定什么单手；拟定放单手后，智能化基底都会随着周边环境进入下一个状况，并获取相应的表扬或强迫。这那时候附上两页 slides 协助大家明白（图片来源为 wangshusen 家教的精进教学）。

精进自学的再次一再次一目标就是要协都会一个使得智能化基底只能第二大化借此回报的 policy，其当中的回报就是对表扬顺利进行衰减求和：

和借此回报的关系相关的还有两个定义，一个是单手状况价倍数变量（校准到状况 ，好好放决策，选当中单手 ）：

另一个是状况价倍数变量（可以明白为比如下围棋时评价当年前状况 的胜率）：

认识了上头的理论上为后我们可以停下来思考一下，精进自学学什么？

主要想要学的无疑就是战略 policy 变量，也就大概状况到单手的一个映射，如果同样自学它，那就只能拿来可用了，这类步骤也被称作基于 policy 的步骤；如果引入间接点的作法，也可以自学倍数变量，然后根据倍数的大小不一来选择单手，这类步骤也被称作基于 value 的步骤。当然，上都会基于 policy 的步骤也都会关乎到倍数变量的相符合。

从战略局部到 PPO

我们要学一个战略变量，但是并不告诉战略变量长什样，怎么去理论上为它才是合适的。好在有了最深处自学这一工具，我们可以出头用一个神经的网络来相符合战略变量，然后通过最佳化神经的网络模板的作法来自学取得一个战略变量。

最佳化神经的网络的模板只能有个再次一目标变量，如果一个战略极好，那么状况价倍数的均倍数应当绝非大，因此我们理论上为再次一目标变量：

这个再次一目标变量排除进去了状况 的各种因素，只相关联战略的网络 的模板 ；战略越少好，则 越少好。所以战略自学可以描绘为这样一个最佳化弊端：

我们希望通过对战略的网络模板 的升级，使得再次一目标变量 非常沙大，也就意味着战略 的网络非常沙强劲。想要要求出第二大化弊端，显然可以用局部上升升级仿真的模板。倍数得就让的是，战略变量的局部还能被解析出来：

战略局部猜想要的详细解析这那时候就不一触即发了，我们只能记起的是能算出出再次一目标变量关于模板的局部，那就能用来升级模板，也就能自学出战略变量了。

当然这那时候面还关乎单手价倍数变量 的有约，如果用也就是话说校准的回报来相符合，那就是 REINFORE 时域，如果再次用一个神经的网络来相符合这个价倍数变量，那就是女演员-评论界时域。PS：在也就是话说可用当中，战略局部当中的 Q 有各不相同的替代形式，少用精准度比较好的形式是引入竞争者变量 （状况单手倍数变量 减去状况倍数变量 ）来替代。

传统的战略局部时域的上都在于它是 sample-inefficient 的，也就是话说每次换取的专业训练数据库只被用来升级一次仿真的模板后就碰到了，因此 PPO 时域的主要改进在于构建了新的再次一目标变量（避免不大的模板波动），使得每次换取的专业训练数据库只能被可用多次的模板升级。

其当中比倍数变量为当年前战略和近现代战略在状况 下拟定单手 的几率的比倍数

通过这一比倍数也就只能评估新旧战略的共同点，从而只能保证战略变量在升级模板时不都会跟旧战略的差异绝非大。有时间的同学也可以对比倍数在相当程度不同直通时再次一目标变量的情况顺利进行权衡，也就是如下表的情况（上头的 就是上头写到的比倍数变量 ）。

此外，我们告诉在精进自学当中上都会还只能去让智能化基底只能具备 exploratory 的表现，这样才能挖出非常多具备非常高价倍数的过激行为，所以 PPO 时域在专业训练战略的网络时还在再次一目标变量当中沙上了和物理量相关的一项表扬 ：

这那时候以均匀分布单手为例，可以看见如果拟定单手的几率大部分到相当程度不同的单手中校具备巨大的物理量。

上头概述战略局部时告诉战略局部当中还关乎价倍数变量/竞争者变量的有约，在 PPO 时域当中也是引入神经的网络来有约状况价倍数变量，专业训练价倍数的网络的再次一目标变量上都会仅只能最小化价倍数的网络的理论上为和再次一目标的平方误差就可以了

综上所述，PPO 时域放整的最佳化再次一目标变量由三部份组成，为

PPO 时域code解读

认识放原理后，我们来看一下精进的code一般怎么写就的。

专业训练智能化基底年前一般只能理论上为一个周边环境

envs = xxxx

周边环境只能具备两个主要的功能变量，一个是 step，它的负载是单手，负载是下一步的校准、表扬、以及回应周边环境是否终止等额外个人信息

next_obs, reward, done, info = envs.step(action)

另一个是 reset，主要用来重置周边环境。

然后只能理论上为一个智能化基底，智能化基底包含战略的网络和价倍数的网络两部份（也就是女演员和评论界），get_value 变量可用价倍数的网络评估状况的价倍数，get_action_and_value 变量可用战略的网络得出了某个状况下单手的几率分布（以及指数函数几率）、几率分布频域取得的单手，几率分布的物理量、以及状况的价倍数。

class Agent(nn.Module): def originallyinitoriginally(self, envs): super().originallyinitoriginally() self.critic = nn.Sequential( layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 64)), nn.Tanh(), layer_init(nn.Linear(64, 64)), nn.Tanh(), layer_init(nn.Linear(64, 1), std=1.0), ) self.actor = nn.Sequential( layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 64)), nn.Tanh(), layer_init(nn.Linear(64, 64)), nn.Tanh(), layer_init(nn.Linear(64, envs.single_action_space.n), std=0.01), ) def get_value(self, x): return self.critic(x) def get_action_and_value(self, x, action=None): logits = self.actor(x) probs = Categorical(logits=logits) if action is None: action = probs.sample() return action, probs.log_prob(action), probs.entropy(), self.critic(x)

每一次就只只能权衡如何收集数据库和专业训练的网络了：

收集数据库在此之后主要仅限于两个部份，一部份是用智能化基底去和周边环境好好交互，并存放相应的状况、单手等个人信息，另一部份主要是根据两步的表扬来算出两步的回报，从而算出可用评估单手好坏的竞争者变量倍数。for step in range(0, args.num_steps): obs[step] = next_obs dones[step] = next_done with torch.no_grad(): action, logprob, _, value = agent.get_action_and_value(next_obs) values[step] = value.flatten() actions[step] = action logprobs[step] = logprob next_obs, reward, done, info = envs.step(action.cpu().numpy()) rewards[step] = torch.tensor(reward).to(device).view(-1)with torch.no_grad(): next_value = agent.get_value(next_obs).reshape(1, -1) returns = torch.zeros_like(rewards).to(device) for t in reversed(range(args.num_steps)): if t == args.num_steps - 1: nextnonterminal = 1.0 - next_done next_return = next_value else: nextnonterminal = 1.0 - dones[t + 1] next_return = returns[t + 1] returns[t] = rewards[t] + args.gamma * nextnonterminal * next_return advantages = returns - values专业训练的网络部份主要就是根据在此之后写到的三部份再次一目标变量，依次算出新旧战略的差异从而算出战略的网络的重大损失、价倍数的网络的重大损失 以及 关于单手多样性的物理量表扬；累沙后再次顺利进行反向传扬就可以升级的网络的模板了。for epoch in range(args.update_epochs): np.random.shuffle(b_inds) for start in range(0, args.batch_size, args.minibatch_size): end = start + args.minibatch_size mb_inds = b_inds[start:end] # 算出新旧战略的差异 _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds]) logratio = newlogprob - b_logprobs[mb_inds] ratio = logratio.exp() mb_advantages = b_advantages[mb_inds] # 战略的网络重大损失 pg_loss1 = -mb_advantages * ratio pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef) pg_loss = torch.max(pg_loss1, pg_loss2).mean() # 价倍数的网络重大损失 newvalue = newvalue.view(-1) v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean() entropy_loss = entropy.mean() loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef optimizer.zero_grad() loss.backward() nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm) optimizer.step()

PPO 的放整code可以参见

也建议大家有空可以选读一下这前言，并能沙强劲对精进的明白：

_2021_BickD.pdf

借助表扬仿真精进 GPT：迈进 ChatGPT

看见了这那时候，我们早已协都会啦如何专业训练一个 GPT，专业训练一个表扬仿真，以及精进自学时域 PPO 的专业训练反复，将它们混搭一起，就只能好好出一个 ChatGPT 了！

这那时候我们先行理论上为两个 GPT 仿真，一个可用精进，一个可用参见（因为我们上都会也不希望精进的仿真放全朝着非常非常高的表扬去最佳化，所以可以拘束一下精进的仿真和原始仿真仍然具备一定的“相似之处”），参见仿真不可用最佳化，所以设为为 eval 方式也即可。

model = GPT()ref_model = GPT()ref_model.eval()

只能无疑的是为了为了让精进这个框架，我们还只能对原来的 GPT 仿真顺利进行一定的封装，本来主要就是沙一层 value head（时域层），让它理论上为每一个 token 的价倍数（明白为倍数变量，将 token 的隐藏状况转变成为一个标量倍数）。

为了让大家非常沙清楚地认识专业训练的反复，我们以一条抽样为例来演示明确指出数据库的发送到反复。

理论上为我们有一个 query（就是转送 gpt 的负载），上头话说过仿真的负载一般经过过去时器转变成为一串 id，比如：

转送 GPT 后，聚合仿真都会接着负载顺利进行“续写就”，取得一条问到 response：

然后我们可以把这 query 和 response 裁剪一起并解码为译文后转送表扬仿真，取得一个 rewards（可以明白 chatgpt 的问到好，就意味这把发表意见和仿真的问到拼在一起看是合理的），每一次就可以权衡可用 PPO 时域来对 GPT 顺利进行精进了。

首先行第一步我们就是把“发表意见”和“问到”裁剪一起，赠送给表扬仿真，让它给 GPT 的问到打个分：

texts = [q + r for q, r in zip(query, response)]score = reward_model(texts)[1]["score"]

有了这个总分后，就可以让 GPT 仿真朝着尽有可能非常好成绩的正向去最佳化了。

把裁剪后的译文转送仿真，并抽出对应 token 的（指数函数）几率，这那时候并不必够局部的传扬，主要是获取“旧”的单手（仿真的问到），以及可用算出每一个 token 的表扬：

with torch.no_grad(): logits, _, v = self.model(**input_kwargs) ref_logits, _, _ = self.ref_model(**input_kwargs)old_logprobs = logprobs_from_logits(logits[:, :-1, :], input_ids[:, 1:])ref_logprobs = logprobs_from_logits(ref_logits[:, :-1, :], input_ids[:, 1:])

算出表扬这那时候权衡两个部份，一部份是可用精进的 GPT 仿真的问到和参见仿真问到的 KL 散度（如上头所话说，不必让仿真作对朝着表扬非常高的正向最佳化），另一部份就是表扬仿真得出的评分：

kl = old_logprobs - ref_logprobreward = -klreward[-1] += score

每一次顺利进行仿真的年前向传扬（这那时候是只能局部的），并数据库出 response 部份的单手几率和倍数变量：

logits, _, vpred = self.model(**input_kwargs)logprob = logprobs_from_logits(logits[:, :-1, :], model_input[:, 1:])logprob, vpred = logprob[:, -gen_len:], vpred[:, -gen_len:]

算出 loss 在此之后我们只能有约一下竞争者变量和回报，竞争者变量可用升级战略的网络，回报可用升级价倍数的网络，这那时候引入经典作品的 GAE 步骤（可以必要减低战略局部的有约标准差）来有约竞争者变量：

lastgaelam = 0advantages_reversed = []for t in reversed(range(gen_len)): nextvalues = values[:, t + 1] if t < gen_len - 1 else 0.0 delta = rewards[:, t] + self.config.gamma * nextvalues - values[:, t] lastgaelam = delta + self.config.gamma * self.config.lam * lastgaelam advantages_reversed.append(lastgaelam)advantages = torch.stack(advantages_reversed[::-1]).transpose(0, 1)returns = advantages + values

算出战略的网络的重大损失：

ratio = torch.exp(logprob - old_logprobs)pg_losses = -advantages * torch.clamp(ratio, 1.0 - self.config.cliprange, 1.0 + self.config.cliprange)pg_loss = torch.mean(pg_losses)

价倍数变量的重大损失：

vf_losses = (vpred - returns) ** 2vf_loss = 0.5 * torch.mean(vf_losses)

整基底误差反向传扬：

loss = pg_loss + self.config.vf_coef * vf_lossoptimizer.zero_grad()accelerator.backward(loss)optimizer.step()

这样就进行了可用 PPO 来精进 GPT 的一个 step 了，也就是 ChatGPT 充分借助的当中心思想要。

可以看上头的通过精进 GPT 再次可用聚合的一个精准度：

以及将结果再次用表扬仿真最非常好成绩的年前后对比：

mean:rewards (before) 0.156629rewards (after) 1.686487median:rewards (before) -0.547091rewards (after) 2.479868

可以看见 GPT 聚合结果的整基底总分都有比不大的提升，这也明确指出如果表扬仿真专业训练得好，那用来好好 ChatGPT 的精准度自然也就只能充分借助。

本章的放整code可以参见开放GCC项目：

写就在再次，本来个人话说道 ChatGPT 只能这么火（或者话说精准度只能好好得这么好）主要还是来自于大量非常高质量的人工标示出数据库（第一步的行政官员，第二步的表扬仿真的专业训练），验证了一段话，人工智能化就是只能“人工”才能回头向“智能化”哈哈。

Reference

_understanding_paper.pdf_doc/gpt2_2021_BickD.pdf。

类风湿关节僵硬用什么治疗
新冠特效药
英太青凝胶和扶他林软膏哪个效果好
广州最好的男科排名
扬州男科