将强化学习重新引入 RLHF

我们很高兴在 TRL 中介绍 RLOO (REINFORCE Leave One-Out) 训练器。作为一种替代 PPO 的方法,RLOO 是一种新的在线 RLHF 训练算法,旨在使其更易于访问和实施。特别是, RLOO 需要的 GPU 内存更少,并且达到收敛所需的挂钟时间也更短。如下面的图表所示:

  1. 🤑根据模型大小,RLOO 使用的 vRAM 比 PPO 少大约 50-70%;

  2. 🚀对于 1B 参数模型,RLOO 的运行速度比 PPO 快 2 倍,对于 6.9B 参数模型,RLOO 的运行速度比 PPO 快 3 倍

  3. 🔥在响应胜率 (由 GPT4 判断) 方面,RLOO 与 PPO 相当,并且始终优于 DPO 等流行的离线方法。

通过 RLOO,我们将强化学习重新引入 RLHF,使社区能够更轻松地探索在线 RL 方法。这令人兴奋,因为越来越多的研究表明,在线 RL 比 DPO 等离线方法更有效 (https://arxiv.org/abs/2402.04792, https://arxiv.org/abs/2405.08448)。

efd3918d3cd8b4c0c7012086cd852c1f.png

d9521f374da627a7da9af0f26521e4e1.png

这篇博客将解释 RLOO 训练器的背后的动机,它是如何工作的,以及如何在 TRL 中使用它。

动机

PPO 是一种有效的在线 RLHF 训练算法,用于训练最先进的模型,如 GPT-4。然而,由于其对 GPU 内存的高要求,PPO 在实际使用中可能相当具有挑战性。特别是,PPO 需要将模型的 4 个副本加载到内存中: 1) 策略模型,2) 参考策略模型,3) 奖励模型,以及 4) 价值模型,如下面的图所示。PPO 还有许多微妙的实现细节,这些细节可能很难正确把握 (Engstrom 等人; 2020,Huang 等人 2022)。

  • Engstrom 等人; 2020https://openreview.net/forum?id=r1etN1rtPB

  • Huang 等人 2022https://iclr-blog-track.github.io/2022/03/25/ppo-implementation-details/

d60d6d6ff3bb3b755abe997f57520f8b.png

在 Cohere 的一篇新论文中,Ahmadian 等人 (2024)重新审视了 RLHF 训练的基础,并提出了一种更简洁的方法,称为 RLOO,这是一种新的在线训练算法。RLOO 只需要将模型的 3 个副本加载到内存中: 1) 策略模型,2) 参考策略模型,以及 3) 奖励模型,如上图所示。

  • Ahmadian 等人 (2024)https://cohere.com/research/papers/back-to-basics-revisiting-reinforce-style-optimization-for-learning-from-human-feedback-in-llms-2024-02-23

重要的是,RLOO 需要更少的内存,这意味着它更容易:

  1. 在不出现 OOMs (内存不足错误) 的情况下运行

  2. 能够加载更大的批量大小

  3. 运行更高效且更快。

此外,RLOO 将整个补全 token 作为单一动作进行建模,如下图所示。在下一节中,我们将通过代码片段进一步详细介绍。

83c0da9f568d2e5f256bbe1a0f477567.png

RLOO 是如何工作的

RLOO 和 PPO 有几个共同的步骤:

  1. 策略模型会生成一些补全 token ,并获取当前策略和参考策略下的每个 token 的对数概率。

  2. 然后我们计算每个 token 的 KL 惩罚,作为当前策略和参考策略下对数概率的差异。

  3. 接着我们从奖励模型中获得整个补全的得分。

从这里开始,常规的 PPO 和 RLOO 在方法上有所不同。RLOO 有几个关键想法。首先,它将 整个模型补全 视为单一动作,而常规 PPO 将 每个补全 token 视为单独的动作。通常,只有 EOS token 获得真正的奖励,这非常稀疏。常规 PPO 会将奖励归因于 EOS token,而 RLOO 会将 EOS 奖励归因于整个补全,如下所示。

from torch import Tensor
response = Tensor([4., 5., 6.])
per_token_logprobs = Tensor([-12.3, -8.3, -2.3])
reference_per_token_logprobs = Tensor([-11.3, -8.4, -2.0])
kl = per_token_logprobs - reference_per_token_logprobs
score_from_rm = 1.0
print(f"{kl=}") # kl=tensor([-1.0000, 0.1000, -0.3000])
per_token_reward = kl.clone()
per_token_reward[-1] += score_from_rm # assume last token is the EOS token
print(f"{per_token_reward=}") # per_token_reward=tensor([-1.0000, 0.1000, 0.7000])
print(f"{score_from_rm=}") # score_from_rm=1.0
print("#### Modeling each token as an action")
for action, reward in zip(response, per_token_reward):print(f"{action=}, {reward=}")
# action=tensor(4.), reward=tensor(-1.)
# action=tensor(5.), reward=tensor(0.1000)
# action=tensor(6.), reward=tensor(0.7000)
print("#### Modeling the entire response as an action")
entire_generation_reward = per_token_reward.sum()
print(f"action='entire completion', reward={entire_generation_reward}")
# action='entire completion', reward=-0.2000 (-1 + 0.1 + 0.7)

其次,RLOO 使用 REINFORCE 损失,它基本上将 (奖励 - 基线) 与动作的对数概率相乘。在这里,我们突出了每个 token 的 REINFORCE 损失与整个补全的 REINFORCE 损失之间的区别。请注意,对于 PPO 的损失,我们还需要基于价值模型和广义优势估计 (GAE)来计算优势。

  • 广义优势估计 (GAE)https://arxiv.org/abs/1506.02438

from torch import Tensor
response = Tensor([4., 5., 6.])
per_token_logprobs = Tensor([-12.3, -8.3, -2.3])
reference_per_token_logprobs = Tensor([-11.3, -8.4, -2.0])
kl = per_token_logprobs - reference_per_token_logprobs
score_from_rm = 1.0
print(f"{kl=}") # kl=tensor([-1.0000, 0.1000, -0.3000])
per_token_reward = kl.clone()
per_token_reward[-1] += score_from_rm # assume last token is the EOS token
print(f"{per_token_reward=}") # per_token_reward=tensor([-1.0000, 0.1000, 0.7000])
print(f"{score_from_rm=}") # score_from_rm=1.0
print("#### Modeling each token as an action")
for action, reward in zip(response, per_token_reward):print(f"{action=}, {reward=}")
# action=tensor(4.), reward=tensor(-1.)
# action=tensor(5.), reward=tensor(0.1000)
# action=tensor(6.), reward=tensor(0.7000)
print("#### Modeling the entire response as an action")
entire_generation_reward = per_token_reward.sum()
print(f"action='entire completion', reward={entire_generation_reward}")
# action='entire completion', reward=-0.2000 (-1 + 0.1 + 0.7)
baseline = Tensor([0.2, 0.3, 0.4]) # dummy baseline
print("#### Modeling each token as an action")
advantage = per_token_reward - baseline
per_token_reinforce_loss = per_token_logprobs * advantage
print(f"{advantage=}") # advantage=tensor([-1.2000, -0.2000, 0.3000])
print(f"{per_token_reinforce_loss=}") # per_token_reinforce_loss=tensor([14.7600, 1.6600, -0.6900])
print(f"{per_token_reinforce_loss.mean()=}") # per_token_reinforce_loss.mean()=tensor(5.2433)print("#### Modeling the entire response as an action")
advantage = entire_generation_reward - baseline.sum()
reinforce_loss = per_token_logprobs.sum()* advantage
print(f"{advantage=}") # advantage=tensor(-1.1000)
print(f"{reinforce_loss=}") # reinforce_loss=tensor(25.1900)

第三,RLOO 聪明地计算基线。注意我们上面使用了一个虚拟基线。在实际操作中,RLOO 使用批次中所有其他样本的奖励作为基线。下面是一个有 3 个提示和每个提示 4 个补全的例子。我们通过平均同一提示的所有其他补全的奖励来计算每个补全的基线。

import torch
local_batch_size = 3
rloo_k = 4rlhf_reward = torch.tensor([1, 2, 3, # first rlhf reward for three prompts2, 3, 4, # second rlhf reward for three prompts5, 6, 7, # third rlhf reward for three prompts8, 9, 10, # fourth rlhf reward for three prompts
]).float() # here we have 3 prompts which have 4 completions each# slow impl
baseline = (rlhf_reward.sum(0) - rlhf_reward) / (rloo_k - 1)
advantages = torch.zeros_like(rlhf_reward)
for i in range(0, len(advantages), local_batch_size):other_response_rlhf_rewards = []for j in range(0, len(advantages), local_batch_size):if i != j:other_response_rlhf_rewards.append(rlhf_reward[j : j + local_batch_size])advantages[i : i + local_batch_size] = rlhf_reward[i : i + local_batch_size] - torch.stack(other_response_rlhf_rewards).mean(0)
assert (1 - (2 + 5 + 8) / 3 - advantages[0].item()) < 1e-6
assert (6 - (3 + 2 + 9) / 3 - advantages[7].item()) < 1e-6# vectorized impl
rlhf_reward = rlhf_reward.reshape(rloo_k, local_batch_size)
baseline = (rlhf_reward.sum(0) - rlhf_reward) / (rloo_k - 1)
vec_advantages = rlhf_reward - baseline
torch.testing.assert_close(vec_advantages.flatten(), advantages)

向 Arash Ahmadian 致谢,他提供了上述优势计算的向量化实现。

开始使用 TRL 的 RLOO

要开始使用 RLOO,你可以通过 pip install --upgrade trl 安装 TRL 的最新版本,并导入 RLOOTrainer。下面是一个展示一些高级 API 使用的简短代码片段。你可以随时查阅这些文档:

  • https://hf.co/docs/trl/main/en/rloo_trainer

  • https://hf.co/docs/trl/main/en/ppov2_trainer

from transformers import (AutoModelForCausalLM,AutoModelForSequenceClassification,AutoTokenizer,
)from trl.trainer.rloo_trainer import RLOOConfig, RLOOTrainer
from trl.trainer.utils import SIMPLE_QUERY_CHAT_TEMPLATEbase_model_name = "EleutherAI/pythia-1b-deduped"
tokenizer = AutoTokenizer.from_pretrained(base_model_name, padding_side="left")
tokenizer.add_special_tokens({"pad_token": "[PAD]"})
if tokenizer.chat_template is None:tokenizer.chat_template = SIMPLE_QUERY_CHAT_TEMPLATE
reward_model = AutoModelForSequenceClassification.from_pretrained(base_model_name, num_labels=1)
ref_policy = AutoModelForCausalLM.from_pretrained(base_model_name)
policy = AutoModelForCausalLM.from_pretrained(base_model_name)train_dataset = ... # make sure to have columns "input_ids"
eval_dataset = ...trainer = RLOOTrainer(config=RLOOConfig(per_device_train_batch_size=1,gradient_accumulation_steps=64,total_episodes=30000,),tokenizer=tokenizer,policy=policy,ref_policy=ref_policy,reward_model=reward_model,train_dataset=train_dataset,eval_dataset=eval_dataset,
)
trainer.train()

这是一个跟踪权重和偏差实验的例子:

  • 案例地址https://wandb.ai/huggingface/trl/runs/dd2o3g35

e5872e2096619f3d17be2e9ea679479c.png

在编写 RLOO 和 PPOv2 实现时,我们强调使模型开发的透明度更容易提升。特别是,我们已经增强了文档,包括对记录指标的解释以及阅读和调试这些指标的操作指南。例如,我们建议在训练期间密切监控 objective/rlhf_reward,这是 RLHF 训练的最终目标。

e45a55e6fd3bcf4ea1419240b9dbf464.png 3ce58b42711874d00825c9f429d9f975.png

为了帮助可视化训练进度,我们定期记录模型的一些示例补全。这里是一个补全的例子。在一个权重和偏差跟踪运行的示例中,它看起来像下面这样,允许你看到模型在不同训练阶段的响应。默认情况下,我们在训练期间生成 –num_sample_generations 10,但你可以自定义生成的数量。

  • 示例地址https://wandb.ai/huggingface/trl/runs/dd2o3g35

7b41d8cc1f9d2289272b347cd0304e0e.gif

我们如何在 TRL 中实现 RLOO 训练器

我们基于新的实验性 PPOv2Trainer 实现了 RLOO 训练器,后者又是基于 https://arxiv.org/abs/2403.17031。有趣的是,我们实现的 RLOO 训练器仍然使用 PPO 损失。这是因为 REINFORCE 的损失是 PPO 的一个特例 (https://arxiv.org/abs/2205.09123)。请注意,即使对数概率明确出现在 REINFORCE 损失中,它也隐含在 PPO 损失中。眼见为实,所以让我们用一个简单的例子来证明这一点。

import torch.nn.functional as F
from torch import LongTensor, Tensor, gather, no_gradaction = LongTensor([1])
advantage = Tensor([1.0])
logits = Tensor([[1.0, 2.0, 1.0, 1.0]])
logits.requires_grad = True
all_logprob = F.log_softmax(logits, dim=-1)
with no_grad():old_logprob = gather(all_logprob, 1, action.unsqueeze(-1)).squeeze(-1)
logprob = gather(all_logprob, 1, action.unsqueeze(-1)).squeeze(-1)
ratio = (logprob - old_logprob).exp()
ppo_loss = (ratio * advantage).mean() # [πθ(at | st) / πθ_old(at | st)* At]
# when the πθ and πθ_old are the same, the ratio is 1, and PPO's clipping has no effect
ppo_loss.backward()
print(f"{logits.grad=}") # tensor([[-0.1749, 0.5246, -0.1749, -0.1749]])
logits2 = Tensor([[1.0, 2.0, 1.0, 1.0]])
logits2.requires_grad = True
all_logprob2 = F.log_softmax(logits2, dim=-1)
logprob2 = gather(all_logprob2, 1, action.unsqueeze(-1)).squeeze(-1)
reinforce_loss = logprob2 * advantage # [log πθ(at | st)* At]
reinforce_loss.mean().backward()
print(f"{logits2.grad=}") # tensor([[-0.1749, 0.5246, -0.1749, -0.1749]])

实验

为了验证 RLOO 实现的有效性,我们在 Pythia 1B 和 6.9B 模型上进行了实验,并在这里发布了训练后的检查点:

  • 检查点链接https://hf.co/collections/vwxyzjn/rloo-ppov2-tl-dr-summarize-checkpoints-66679a3bfd95ddf66c97420d

我们从Huang 等人,2024直接获取 SFT / RM 模型。为了评估,我们使用 vLLM 加载检查点,并使用 GPT4 作为评判模型来评估生成的 TL;DR 与参考 TL;DR 的对比。我们还查看了 GPU 内存使用情况和运行时间,正如博客开头所示的图表。要重现我们的工作,请随时查看我们文档中的命令:

  • Huang 等人,2024https://arxiv.org/abs/2403.17031

  • https://hf.co/docs/trl/main/en/rloo_trainer#benchmark-experiments

  • https://hf.co/docs/trl/main/en/rloo_trainer#benchmark-experiments

关键结果如下:

  • 🚀高性能 RLOO 检查点: 使用 GPT4 作为评判模型,6.9B 检查点获得了 78.7% (k=2) 的偏好率,这甚至超过了原始论文中报告的最佳性能 77.9% (k=4) 和 74.2 (k=2)。这是一个很好的迹象,表明我们的 RLOO 训练按预期工作。

    论文地址https://arxiv.org/abs/2402.14740

  • RLOO 1B 检查点的胜率为 40.1%,而 SFT 检查点的胜率为 21.3%。这是一个很好的迹象,表明 RLOO 训练按预期工作。

  • 🤑 减少 GPU 内存并运行更快: RLOO 训练使用更少的内存并运行更快,使其成为在线 RL 训练中非常有用的算法。

数值稳定性: 黑暗面

尽管 RLOO 在性能和计算效率方面有优势,但我们想要强调一些数值问题。具体来说,生成过程中获得的响应对数概率与 bf16 下训练前向传递期间获得的对数概率在数值上略有不同。这给 PPO 和 RLOO 都带来了问题,但对于 RLOO 来说,问题更严重,如下所述。

例如,假设我们正在为两个序列生成 10 个 token。在 fp32 精度下,输出如下所示,其中 ratio = (forward_logprob - generation_logprob).exp() ,这是 PPO 用来裁剪的。在第一个周期和第一个小批量中,比率应该是完全相同的,因为模型还没有进行任何更新:

generation_logprob=tensor([[ -0.1527, -0.2258, -3.5535, -3.4805, -0.0519,-2.3097, -2.0275, -0.4597, -0.1687, -0.0000],[ -0.1527, -0.2258, -5.2855, -0.1686, -8.4760,-4.3118, -1.0368, -0.8274, -1.6342, -2.6128]],device='cuda:0')
forward_logprob=tensor([[-0.1527, -0.2258, -3.5535, -3.4805, -0.0519, -2.3097, -2.0275, -0.4597,-0.1687],[-0.1527, -0.2258, -5.2855, -0.1686, -8.4760, -4.3118, -1.0368, -0.8274,-1.6342]], device='cuda:0', grad_fn=<SqueezeBackward1>)
ratio=tensor([[1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000],[1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000]],device='cuda:0', grad_fn=<ExpBackward0>)
ratio.mean()=0.9999998211860657
ratio.std()=6.592738373001339e-06
ratio.max()=1.0000133514404297
ratio.min()=0.9999887943267822

然而,在 bf16 精度下,我们得到结果:

generation_logprob=tensor([[ -0.1426, -0.1904, -3.5938, -3.4688, -0.0618,-2.3906, -2.0781, -0.4375, -0.1562, -0.0000],[ -0.1426, -0.1904, -5.2812, -0.1641, -8.5625,-4.2812, -1.0078, -0.8398, -1.5781, -2.5781]],device='cuda:0', dtype=torch.bfloat16)
forward_logprob=tensor([[-0.1445, -0.1670, -3.5938, -3.5156, -0.0554, -2.2969, -1.9688, -0.5273,-0.1953],[-0.1445, -0.1670, -5.2812, -0.1533, -8.5625, -4.3125, -1.0000, -0.7852,-1.6641]], device='cuda:0', dtype=torch.bfloat16,grad_fn=<SqueezeBackward1>)
ratio=tensor([[1.0000, 0.9766, 1.0000, 1.0469, 0.9922, 0.9102, 0.8945, 1.0938, 1.0391],[1.0000, 0.9766, 1.0000, 0.9883, 1.0000, 1.0312, 0.9922, 0.9453, 1.0859]],device='cuda:0', dtype=torch.bfloat16, grad_fn=<ExpBackward0>)
ratio.mean()=1.0
ratio.std()=0.051025390625
ratio.max()=1.09375
ratio.min()=0.89453125

和在 fp16 精度下,我们得到的结果

generation_logprob=tensor([[ -0.1486, -0.2212, -3.5586, -3.4688, -0.0526,-2.3105, -2.0254, -0.4629, -0.1677, -0.0000],[ -0.1486, -0.2212, -5.2852, -0.1681, -8.4844,-4.3008, -1.0322, -0.8286, -1.6348, -2.6074]],device='cuda:0', dtype=torch.float16)
forward_logprob=tensor([[-0.1486, -0.2212, -3.5586, -3.4805, -0.0529, -2.3066, -2.0332, -0.4629,-0.1676],[-0.1486, -0.2212, -5.2852, -0.1682, -8.4766, -4.3008, -1.0322, -0.8281,-1.6299]], device='cuda:0', dtype=torch.float16,grad_fn=<SqueezeBackward1>)
ratio=tensor([[1.0000, 1.0000, 1.0000, 1.0117, 1.0000, 0.9961, 1.0078, 1.0000, 1.0000],[1.0000, 1.0000, 1.0000, 1.0000, 0.9922, 1.0000, 1.0000, 0.9995, 0.9951]],device='cuda:0', dtype=torch.float16, grad_fn=<ExpBackward0>)
ratio.mean()=1.0
ratio.std()=0.00418853759765625
ratio.max()=1.01171875
ratio.min()=0.9921875

请注意, bf16 的比率由于某种原因非常不稳定。当比率变得很大时,PPO 的裁剪系数 = 0.2 开始发挥作用, 取消 那些比率大于 1.2 或小于 0.8 的 token 的梯度。对于 RLOO,这个问题更为极端,因为我们看到的是 (forward_logprob.sum(1) - generation_logprob.sum(1)).exp() = [ 1.0625, 12.1875] ,这意味着整个第二个序列的梯度被取消了。

在实际操作中,我们注意到 PPO 取消了大约 3% 的批次数据的梯度,而 RLOO 取消了大约 20-40% 的批次数据。从理论上讲,当不使用小批量时,RLOO 应该取消 0 %的批次数据。重要的是,我们观察到,一旦我们增加了在生成新批次之前的梯度步骤数 (通过 num_ppo_epochs 和 num_mini_batches),RLOO 的裁剪比率并没有显著变化; 这提供了实证证据,表明裁剪比率确实是由于 bf16 的数值问题,而不是因为行为和最新策略有很大不同,正如论文中所定位的。

要了解有关最新问题更新的更多信息,请查看GitHub issue: #31267。

  • Issue #31267 链接https://github.com/huggingface/transformers/issues/31267

结论

TRL 中引入的 RLOO (REINFORCE Leave One-Out) 训练器是在线 RLHF 训练中一个令人兴奋的算法,它提供了一个比 PPO 更易访问和高效的替代方案。通过减少 GPU 内存使用和简化训练过程,RLOO 使得可以使用更大的批量大小和更快的训练时间。我们的实验表明,RLOO 在响应胜率方面与 PPO 竞争,并且优于 DPO 检查点,使其成为有效的在线 RLHF 的有力工具。查看我们的文档来开始使用吧!

  • https://hf.co/docs/trl/main/en/rloo_trainer

  • https://hf.co/docs/trl/main/en/ppov2_trainer

致谢和感谢

我们要感谢 Lewis Tunstall, Sara Hooker, Omar Sanseviero 和 Leandro Von Werra 对这篇博客提供的宝贵反馈。


原文链接: https://hf.co/blog/putting_rl_back_in_rlhf_with_rloo

原文作者: Shengyi Costa Huang, Arash Ahmadian

译者: innovation64

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/pingmian/31468.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

前端Vue实现萤石云播放视频

下载依赖 npm install ezuikit-js --save 完整代码 <template><div class"home"><div id"video-container"></div></div> </template> <script> import EZUIKit from "ezuikit-js";export default…

ICAS英格尔引领企业绿色转型之路:深度解析ISO14064温室气体核查与审定服务

在全球范围内&#xff0c;气候变化正迅速成为影响企业战略决策、运营效率及长期可持续发展的关键因素。ICAS英格尔作为全球领先的认证机构&#xff0c;致力于通过ISO14064温室气体核查与审定服务&#xff0c;帮助企业应对这一挑战&#xff0c;实现绿色转型&#xff0c;提升环境…

前端模糊搜索关键字高亮

效果 代码 <template><view class"flexStart new-box"><view class"company"><!-- 输入框样式 --><view class"spaceBetween companyName" click.stop"isCompany true"><input type"text&quo…

如果已经登录,输入白名单路由想访问白名单页面被重定向其他页面

如果用户已经登录&#xff0c;但尝试访问白名单页面时被重定向到了其他页面&#xff0c;这可能是由于路由守卫的逻辑设置不正确。以下是一些可能的原因和解决方案&#xff1a; 可能的原因&#xff1a; 路由守卫逻辑错误&#xff1a;路由守卫可能错误地将已登录用户重定向到登…

C盘满了怎么清理?一招让你远离C盘空间不足的烦恼

C盘满了怎么清理&#xff1f;一招让你远离C盘空间不足的烦恼&#xff0c;当C盘空间满了时&#xff0c;会给我们来一系列烦恼和潜在问题。比如&#xff1a;系统运行缓慢、程序崩溃或无法安装、启动时间变长、系统不稳定、文件管理困难、游戏卡顿、电脑卡顿、系统故障等问题&…

使用css实现打开抽屉效果(css过渡动画)

方法一&#xff0c;使用高度方式&#xff0c;高度从0到展示进行过渡 HTML代码&#xff1a; <div class"container"><div class"menu">菜单</div><div class"box"></div></div>CSS代码&#xff1a; .box {wi…

Linux使用Docker部署mysql5.7

一、拉取镜像 docker pull mysql:5.7 二、查看镜像 docker images 三、创建容器 这里稍微解释下 -p参数是端口映射 -v参数是数据卷挂载 数据卷挂载是Docker中的一种功能&#xff0c;它允许将主机上的目录或文件系统与容器内的目录绑定&#xff0c;实现数据的持久化存储…

代码随想录算法训练营第45天(py)| 动态规划 | 198.打家劫舍、213.打家劫舍II、337.打家劫舍III

198.打家劫舍 力扣链接 你是一个专业的小偷&#xff0c;计划偷窃沿街的房屋。每间房内都藏有一定的现金。 如果两间相邻的房屋在同一晚上被小偷闯入&#xff0c;系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组nums&#xff0c;计算你 不触动警报装置的情况下 &…

短剧片源授权,类目丰富优惠多,抢先一步更新你的短剧系统片库!

前言 如今的短剧作为一种新兴的视听艺术形式&#xff0c;正以其独特的魅力迅速占领市场高地。为了满足广大短剧爱好者和从业者的需求&#xff0c;我们提供短剧片源授权服务&#xff0c;凭借剧场独家提供的丰富片源&#xff0c;助力您轻松更新短剧系统片库&#xff0c;抢占市场…

MySQL小版本升级(8.0.36->8.0.37)

关于MySQL升级的话MySQL官方文档上面介绍了2个方法&#xff0c;’就地升级’和‘逻辑升级’。’就地升级‘就是升级底层的RPM包而‘逻辑升级’就是将旧MySQL数据库上的信息迁移到新MySQL数据库上。 本篇文章介绍到的是RPM包升级 升级MySQL版本的典型步骤包括&#xff1a; 备份&…

算法篇-排序

快排 算法思想&#xff1a;每次找一个基数&#xff0c;然后对数组左右遍历&#xff0c;将小于基数的数据放到左边&#xff0c;大于基数的数放到右边&#xff0c;然后将基数左边&#xff0c;右边进行迭代再排序。 public static void quickSort(int[] nums, int left, int ri…

shell的函数

1、定义 将命令序列按照格式写在一起。 格式指的是函数的固定格式&#xff0c;有两种格式 2、作用 &#xff08;1&#xff09;方便重复使用 形成一个函数库&#xff0c;集中在一起&#xff0c;随时可以传参调用。 &#xff08;2&#xff09;大的工程分割成若干个小的功能…

SCIE与SCI期刊的区别

在学术出版领域&#xff0c;SCI&#xff08;Science Citation Index&#xff09;和SCIE&#xff08;Science Citation Index Expanded&#xff09;是两个关键的索引数据库&#xff0c;它们对科研人员在选择发表论文的期刊时起着至关重要的作用。虽然这两个术语经常被交替使用&a…

linux创建账号

在Linux中创建用户账号通常使用useradd命令。以下是一个基本的示例&#xff1a; sudo useradd -m 用户名这里-m选项意味着创建用户主目录&#xff0c;如果不存在的话。 如果你还想设置用户密码&#xff0c;可以使用passwd命令&#xff1a; sudo passwd 用户名这将提示你输入…

Python100题(含答案)

温馨提示&#xff1a;篇幅有限&#xff0c;已打包文件夹&#xff0c;获取方式在&#xff1a;文末 温馨提示&#xff1a;篇幅有限&#xff0c;已打包文件夹&#xff0c;获取方式在&#xff1a;文末 篇幅有限&#xff0c;这份完整版的Python100题已经上传&#xff0c;朋友们如果…

from import *

项目结构 假设我们的项目结构如下&#xff1a; my_project/ |-- dataset/ | |-- __init__.py | |-- imbalance_cifar.py | |-- balance_cifar.py |-- main.py代码示例 1. dataset/imbalance_cifar.py # dataset/imbalance_cifar.pyclass IMBALANCECIFAR10:def __init…

easyx之图形库复习--自制写轮眼的图形绘制

引子效果图如下&#xff1a; 什么是easyx&#xff1f; EasyX 是针对 C/C 的图形库&#xff0c;可以帮助使用C/C语言的程序员快速上手图形和游戏编程。比如&#xff0c;可以用 VC EasyX 很快的用几何图形画一个房子&#xff0c;或者一辆移动的小车&#xff0c;可以编写俄罗斯方…

软考 系统架构设计师系列知识点之杂项集萃(42)

接前一篇文章&#xff1a;软考 系统架构设计师系列知识点之杂项集萃&#xff08;41&#xff09; 第67题 Windows操作系统在图形界面处理方面采用的核心架构风格是&#xff08; &#xff09;风格。Java语言宣传的“一次编写&#xff0c;到处运行”的特性&#xff0c;从架构风格…

AI PPT生成器,一键在线智能生成PPT工具

PPT作为商业沟通和教育培训中的重要工具&#xff0c;PPT制作对于我们来说并不陌生。但是传统的PPT制作不仅耗时&#xff0c;而且想要做出精美的PPT&#xff0c;需要具备一定的设计技能。下面小编就来和大家分享几款AI PPT工具&#xff0c;只要输入主题&#xff0c;内容就可以在…

学生分组

题目描述 有 n 组学生&#xff0c;给出初始时每组中的学生个数&#xff0c;再给出每组学生人数的上界 R 和下界 L (L≤R)&#xff0c;每次你可以在某组中选出一个学生把他安排到另外一组中&#xff0c;问最少要多少次才可以使 N 组学生的人数都在 [L,R] 中。 输入格式 第一行…