深度学习 2月 8,2025

DeepSeek-R1论文中文翻译及通俗解释

最近火遍全网，功能媲美OpenAI等国外最强大模型的DeepSeek，

R1论文链接以放在下面，供大家学习参考。
论文链接：https://github.com/deepseek-ai/DeepSeek-R1/blob/main/DeepSeek_R1.pdf

考虑到很多人英文阅读起来还是有点障碍，翻译成中文并附上通俗解释。

摘要

我们推出了第一代推理模型 DeepSeek-R1-Zero 和 DeepSeek-R1。DeepSeek-R1-Zero 是通过大规模强化学习（RL）训练出来的模型，它在训练时没有将监督微调（SFT）作为初步步骤，却展现出了卓越的推理能力。在强化学习的过程中，DeepSeek-R1-Zero 自然而然地产生了许多强大且有趣的推理行为。不过，它也面临一些问题，比如生成内容的可读性差、存在语言混合现象。为了解决这些问题并进一步提升推理性能，我们推出了 DeepSeek-R1，该模型在强化学习之前加入了多阶段训练和冷启动数据。DeepSeek-R1 在推理任务上的表现与 OpenAI-o1-1217 相当。为了支持研究社区，我们开源了 DeepSeek-R1-Zero、DeepSeek-R1，以及基于 Qwen 和 Llama 从 DeepSeek-R1 中提炼出来的六个稠密模型（15 亿、70 亿、80 亿、140 亿、320 亿、700 亿参数规模）。

通俗解释

这部分主要讲了团队搞出了两个超厉害的推理模型，叫 DeepSeek-R1-Zero 和 DeepSeek-R1。DeepSeek-R1-Zero 是靠大规模强化学习训练出来的，没经过监督微调，就能自己 “琢磨” 出好多厉害的推理方法。但它也有点小毛病，像写出来的东西不太好懂，还会把不同语言混在一起。所以团队又搞出了 DeepSeek-R1，这个模型训练的时候加了些 “冷启动数据”，还分好几个阶段训练，就解决了前面那些问题，在推理能力上和 OpenAI 的一个超厉害的模型（OpenAI-o1-1217 ）差不多厉害。最后，为了让大家一起研究，团队把这些模型还有基于它们做出来的一些小模型都开源了，谁都能拿去用。

1. 引言

近年来，大语言模型（LLMs）经历了快速的迭代和发展（Anthropic, 2024; Google, 2024; OpenAI, 2024a），与通用人工智能（AGI）之间的差距逐渐缩小。
最近，后训练成为完整训练流程的重要组成部分。研究表明，后训练可以提高推理任务的准确性，使模型符合社会价值观，并适应用户偏好，同时与预训练相比，所需的计算资源相对较少。在推理能力方面，OpenAI 的 o1（OpenAI, 2024b）系列模型率先通过增加思维链推理过程的长度来实现推理时的扩展。这种方法在数学、编码和科学推理等各种推理任务中取得了显著的改进。然而，如何在测试时有效地进行扩展，仍然是研究界有待解决的问题。此前有多项研究探索了各种方法，包括基于过程的奖励模型（Lightman 等人，2023; Uesato 等人，2022; Wang 等人，2023）、强化学习（Kumar 等人，2024）以及蒙特卡洛树搜索和束搜索等搜索算法（Feng 等人，2024; Trinh 等人，2024; Xin 等人，2024）。但这些方法中，没有一种能在通用推理性能上与 OpenAI 的 o1 系列模型相媲美。
在本文中，我们迈出了利用纯强化学习（RL）提升语言模型推理能力的第一步。我们的目标是探索大语言模型在没有任何监督数据的情况下发展推理能力的潜力，重点关注它们如何通过纯强化学习过程实现自我进化。具体来说，我们以 DeepSeek-V3-Base 为基础模型，采用 GRPO（Shao 等人，2024）作为强化学习框架，以提高模型在推理任务中的性能。在训练过程中，DeepSeek-R1-Zero 自然地展现出许多强大且有趣的推理行为。经过数千次强化学习步骤后，DeepSeek-R1-Zero 在推理基准测试中表现卓越。例如，在 2024 年美国数学邀请赛（AIME 2024）上，其单次回答正确（pass@1）的得分从 15.6% 提升到了 71.0%，通过多数投票法，得分进一步提高到 86.7%，与 OpenAI-o1-0912 的性能相当。
然而，DeepSeek-R1-Zero 也面临着诸如可读性差和语言混合等挑战。为了解决这些问题并进一步提升推理性能，我们推出了 DeepSeek-R1，它结合了少量冷启动数据和多阶段训练流程。具体而言，我们首先收集数千条冷启动数据，对 DeepSeek-V3-Base 模型进行微调。之后，像训练 DeepSeek-R1-Zero 一样，进行面向推理的强化学习。在强化学习过程接近收敛时，我们通过对强化学习检查点进行拒绝采样，结合来自 DeepSeek-V3 在写作、事实性问答和自我认知等领域的监督数据，创建新的监督微调（SFT）数据，然后重新训练 DeepSeek-V3-Base 模型。用新数据微调后，该检查点再进行一轮强化学习，同时考虑所有场景的提示。经过这些步骤，我们得到了一个名为 DeepSeek-R1 的检查点，其性能与 OpenAI-o1-1217 相当。
我们进一步探索从 DeepSeek-R1 向较小的稠密模型进行知识蒸馏。以 Qwen2.532B（Qwen, 2024b）为基础模型，直接从 DeepSeek-R1 进行蒸馏的效果优于在其基础上应用强化学习。这表明，较大基础模型发现的推理模式对于提高推理能力至关重要。我们开源了基于 Qwen 和 Llama（Dubey 等人，2024）系列的蒸馏模型。值得注意的是，我们蒸馏得到的 140 亿参数模型大幅超越了当前最先进的开源模型 QwQ-32B-Preview（Qwen, 2024a），而蒸馏得到的 320 亿和 700 亿参数模型在稠密模型的推理基准测试中创下了新纪录。

1.1 研究贡献

后训练：在基础模型上进行大规模强化学习：我们直接将强化学习应用于基础模型，而不依赖监督微调（SFT）作为初步步骤。这种方法使模型能够探索思维链（CoT）来解决复杂问题，从而开发出 DeepSeek-R1-Zero。DeepSeek-R1-Zero 展示了自我验证、反思和生成长思维链等能力，为研究界树立了重要的里程碑。值得注意的是，这是首次通过公开研究验证，大语言模型的推理能力可以纯粹通过强化学习来激发，而无需监督微调。这一突破为该领域未来的发展铺平了道路。
我们介绍了开发 DeepSeek-R1 的流程。该流程包含两个强化学习阶段，旨在发现更好的推理模式并符合人类偏好，还包含两个监督微调阶段，为模型的推理和非推理能力奠定基础。我们相信这个流程将有助于行业开发出更优秀的模型。
知识蒸馏：小模型也能有强大能力：我们证明了可以将大模型的推理模式蒸馏到小模型中，与小模型通过强化学习发现的推理模式相比，这样能带来更好的性能。开源的 DeepSeek-R1 及其应用程序编程接口（API）将有助于研究社区在未来蒸馏出更好的小模型。
利用 DeepSeek-R1 生成的推理数据，我们对研究社区中广泛使用的几个稠密模型进行了微调。评估结果表明，蒸馏得到的较小稠密模型在基准测试中表现出色。DeepSeek-R1-Distill-Qwen-7B 在 2024 年美国数学邀请赛（AIME 2024）上的得分达到 55.5%，超过了 QwQ-32B-Preview。此外，DeepSeek-R1-Distill-Qwen-32B 在 AIME 2024 上的得分达到 72.6%，在 MATH-500 上的得分达到 94.3%，在 LiveCodeBench 上的得分达到 57.2% 。这些结果显著超越了以前的开源模型，与 o1-mini 相当。我们向社区开源了基于 Qwen2.5 和 Llama3 系列的 15 亿、70 亿、80 亿、140 亿、320 亿和 700 亿参数规模的蒸馏模型检查点。

1.2 评估结果总结

推理任务：（1）DeepSeek-R1 在 2024 年美国数学邀请赛（AIME 2024）上的单次回答正确（Pass@1）得分达到 79.8%，略高于 OpenAI-o1-1217。在 MATH-500 测试中，它取得了令人瞩目的 97.3% 的高分，与 OpenAI-o1-1217 表现相当，且显著超越其他模型。（2）在与编码相关的任务中，DeepSeek-R1 在代码竞赛任务中展现出专家水平，在 Codeforces 平台上获得 2029 的 Elo 评级，超过了竞赛中 96.3% 的人类参与者。在与工程相关的任务中，DeepSeek-R1 的表现略优于 DeepSeek-V3，这对开发者在实际工作中会有所帮助。
知识水平：在 MMLU、MMLU-Pro 和 GPQA Diamond 等基准测试中，DeepSeek-R1 取得了出色的成绩，在 MMLU 上得分为 90.8%，在 MMLU-Pro 上得分为 84.0%，在 GPQA Diamond 上得分为 71.5%，显著超越 DeepSeek-V3。虽然在这些基准测试中，其性能略低于 OpenAI-o1-1217，但 DeepSeek-R1 超越了其他闭源模型，展示了其在教育任务中的竞争优势。在事实性基准测试 SimpleQA 上，DeepSeek-R1 的表现优于 DeepSeek-V3，证明了它处理基于事实的查询的能力。在这个基准测试中，OpenAI-o1 也超越了 GPT-4o，呈现出类似的趋势。
其他方面：DeepSeek-R1 在广泛的任务中也表现出色，包括创意写作、通用问答、编辑、总结等。它在 AlpacaEval 2.0 上的长度控制胜率达到 87.6%，在 ArenaHard 上的胜率达到 92.3%，展示了其智能处理非考试类查询的强大能力。此外，DeepSeek-R1 在需要长上下文理解的任务中表现卓越，在长上下文基准测试中大幅超越 DeepSeek-V3。

通俗解释

大语言模型这几年发展特别快，和通用人工智能的距离越来越近。后训练在提升模型能力上很有用，OpenAI 的 o1 系列模型通过增加推理步骤让模型在很多推理任务上表现变好，但怎么让模型在测试的时候也能这么厉害，大家还在研究。
这篇论文里，团队想用纯强化学习来提升模型的推理能力。他们用 DeepSeek-V3-Base 做基础模型，通过强化学习训练出了 DeepSeek-R1-Zero。这个模型训练的时候自己就琢磨出好多厉害的推理方法，在 AIME 2024 测试里成绩提高特别多。不过它也有问题，写出来的东西不好懂，还会把不同语言混在一起。
所以团队又搞出了 DeepSeek-R1，训练的时候先给模型一些 “冷启动数据”，再分阶段训练，最后这个模型的表现和 OpenAI-o1-1217 差不多。而且，团队还把 DeepSeek-R1 的推理能力 “教” 给了一些小模型，这些小模型在测试里成绩也很好，超过了很多以前的开源模型。
从测试结果来看，DeepSeek-R1 在推理任务上特别厉害，像数学和编码任务成绩都很好；在知识类测试里也不错，比 DeepSeek-V3 好很多；在其他任务，像写作、问答这些方面也表现很棒，理解长文章的能力也很强。

2. 方法

2.1 概述

以往的研究大多依赖大量的监督数据来提升模型性能。在本研究中，我们证明了即使不使用监督微调（SFT）作为冷启动，通过大规模强化学习（RL）也能显著提升模型的推理能力。此外，加入少量冷启动数据可以进一步提升模型性能。在接下来的章节中，我们将介绍：（1）DeepSeek-R1-Zero，它直接在基础模型上应用强化学习，不使用任何监督微调数据；（2）DeepSeek-R1，它从用数千个长思维链（CoT）示例微调后的检查点开始应用强化学习；（3）将 DeepSeek-R1 的推理能力蒸馏到小型稠密模型中。

2.2 DeepSeek-R1-Zero：基础模型上的强化学习

强化学习在推理任务中已显示出显著的有效性，我们之前的研究（Shao 等人，2024；Wang 等人，2023）已证实了这一点。然而，这些研究严重依赖监督数据，而收集监督数据非常耗时。在本节中，我们探索大语言模型在无任何监督数据的情况下发展推理能力的潜力，重点关注其通过纯强化学习过程的自我进化。我们先简要介绍我们的强化学习算法，然后展示一些令人振奋的结果，希望能为研究社区提供有价值的见解。

2.2.1 强化学习算法：组相对策略优化

为节省强化学习的训练成本，我们采用组相对策略优化（GRPO）（Shao 等人，2024）。该方法舍弃了通常与策略模型规模相同的价值网络，而是通过组得分来估计基线。具体来说，对于每个问题，

用户与助手进行对话。用户提出问题，助手进行解答。助手先在脑海中思考推理过程，然后为用户提供答案。推理过程和答案分别包含在<think></think>和<answer></answer>标签内，即<think>推理过程在此处</think><answer>答案在此处</answer>。用户：提示。助手：

用户	助手
提示	<think>推理过程在此处</think><answer>答案在此处</answer>

表 1 DeepSeek-R1-Zero 的模板。训练过程中，提示部分会被具体的推理问题替代。

2.2.2 奖励建模

奖励是训练信号的来源，它决定了强化学习的优化方向。为训练 DeepSeek-R1-Zero，我们采用基于规则的奖励系统，主要包含两种类型的奖励：

准确率奖励：准确率奖励模型用于评估回答是否正确。例如，对于有确定答案的数学问题，要求模型以指定格式（如在方框内）给出最终答案，以便基于规则可靠地验证答案的正确性。同样，对于 LeetCode 问题，可以使用编译器根据预定义的测试用例生成反馈。
格式奖励：除准确率奖励模型外，我们还采用格式奖励模型，强制模型将其思考过程置于<think>和</think>标签之间。
在开发 DeepSeek-R1-Zero 时，我们没有应用结果或过程神经奖励模型，因为我们发现神经奖励模型在大规模强化学习过程中可能会遭受奖励作弊问题，并且重新训练奖励模型需要额外的训练资源，还会使整个训练流程变得复杂。

2.2.3 训练模板

为训练 DeepSeek-R1-Zero，我们首先设计了一个简单的模板，引导基础模型遵循我们指定的指令。如表 1 所示，该模板要求 DeepSeek-R1-Zero 首先生成推理过程，然后给出最终答案。我们有意将约束限制在这种结构格式上，避免任何特定内容的偏差，例如强制要求反思性推理或推崇特定的问题解决策略，以确保我们能准确观察模型在强化学习过程中的自然发展。

2.2.4 DeepSeek-R1-Zero 的性能、自我进化过程和顿悟时刻

DeepSeek-R1-Zero 的性能：图 2 展示了 DeepSeek-R1-Zero 在 2024 年美国数学邀请赛（AIME 2024）基准测试中，整个强化学习训练过程中的性能变化轨迹。如图所示，随着强化学习训练的推进，DeepSeek-R1-Zero 的性能稳步提升。值得注意的是，AIME 2024 上的平均单次回答正确（pass@1）得分显著提高，从最初的 15.6% 跃升至令人瞩目的 71.0%，达到了与 OpenAI-o1-0912 相当的性能水平。这一显著改进凸显了我们的强化学习算法随着时间推移优化模型性能的有效性。
表 2 对 DeepSeek-R1-Zero 和 OpenAI 的 o1-0912 模型在各种推理相关基准测试中的表现进行了对比分析。结果显示，强化学习使 DeepSeek-R1-Zero 在无需任何监督微调数据的情况下获得了强大的推理能力。这是一项值得关注的成就，因为它强调了模型仅通过强化学习就能有效学习和泛化的能力。此外，通过多数投票法，DeepSeek-R1-Zero 的性能还可以进一步提升。例如，在 AIME 基准测试中采用多数投票法时，DeepSeek-R1-Zero 的性能从 71.0% 提升至 86.7%，超过了 OpenAI-o1-0912 的性能。DeepSeek-R1-Zero 在使用和不使用多数投票法的情况下都能取得如此有竞争力的性能，凸显了其强大的基础能力以及在推理任务中进一步提升的潜力。
DeepSeek-R1-Zero 的自我进化过程：DeepSeek-R1-Zero 的自我进化过程生动展示了强化学习如何驱动模型自主提升推理能力。通过直接从基础模型启动强化学习，我们可以在不受监督微调阶段影响的情况下，密切监测模型的发展。这种方法清晰呈现了模型随时间的演变，尤其是在处理复杂推理任务的能力方面。
如图 3 所示，DeepSeek-R1-Zero 的思考时间在整个训练过程中持续改善。这种改善并非外部调整的结果，而是模型内部的自然发展。DeepSeek-R1-Zero 通过利用更长的测试时计算资源，自然而然地获得了解决日益复杂推理任务的能力。这种计算过程从生成数百到数千个推理令牌不等，使模型能够更深入地探索和优化其思维过程。
这种自我进化最显著的特点之一是，随着测试时计算量的增加，模型会出现复杂的行为。例如，模型会自发地进行反思（重新审视和评估之前的步骤），并探索解决问题的替代方法。这些行为并非预先编程设定，而是模型与强化学习环境交互的结果。这种自发的发展显著增强了 DeepSeek-R1-Zero 的推理能力，使其能够更高效、准确地处理更具挑战性的任务。
DeepSeek-R1-Zero 的顿悟时刻：在训练 DeepSeek-R1-Zero 的过程中，观察到一个特别有趣的现象 ——“顿悟时刻”。如表 3 所示，这个时刻出现在模型的一个中间版本中。在此阶段，DeepSeek-R1-Zero 学会了通过重新评估初始方法，为一个问题分配更多思考时间。这种行为不仅证明了模型推理能力的不断提升，也是强化学习能够产生意想不到的复杂结果的生动例证。
这个时刻不仅对模型来说是一个 “顿悟时刻”，对于观察其行为的研究人员而言也是如此。它凸显了强化学习的力量与魅力：我们并非直接教模型如何解决问题，而只是为其提供正确的激励，它就能自主开发出先进的问题解决策略。“顿悟时刻” 有力地提醒我们，强化学习具有解锁人工智能系统新智能水平的潜力，为未来开发更自主、自适应的模型铺平了道路。
DeepSeek-R1-Zero 的缺点：尽管 DeepSeek-R1-Zero 展现出强大的推理能力，并自主发展出了意想不到的强大推理行为，但它也面临一些问题。例如，DeepSeek-R1-Zero 存在可读性差和语言混合等挑战。为了使推理过程更具可读性并与开放社区共享，我们探索了 DeepSeek-R1，这是一种利用强化学习并结合对人类友好的冷启动数据的方法。

通俗解释

以前提升模型能力大多靠大量的监督数据，这篇论文则证明了用大规模强化学习，就算不用监督微调，也能提升模型推理能力，加点冷启动数据效果还会更好。接下来就介绍了三种方法，这里先讲 DeepSeek-R1-Zero。
强化学习在推理任务里本来就挺好用，但以前收集监督数据太费时间。这次用的 GRPO 算法能省点训练成本，它不用和策略模型一样大的价值网络，通过一组数据的得分来估算基线，然后优化策略模型。
训练的时候，奖励很重要。DeepSeek-R1-Zero 用的是基于规则的奖励系统，一方面看答案对不对，对了就给准确率奖励，像数学题按要求格式答对了、LeetCode 问题通过测试用例就给分；另一方面要求模型按规定格式写推理过程，符合格式就给格式奖励。因为神经奖励模型容易出问题，还费资源，所以没采用。
训练模板就是让模型按规定来，先写推理过程，再写答案，这样能看看模型自己在强化学习过程中是怎么发展的。
从结果来看，DeepSeek-R1-Zero 在 AIME 2024 测试里成绩越来越好，和 OpenAI-o1-0912 差不多，用多数投票法还能超过它。而且在训练过程中，它思考时间越来越长，自己就学会解决更难的问题，还能反思、找新方法，就像突然 “开窍” 了一样。不过它也有问题，写的东西不好懂，还会混着多种语言，所以就有了后面的 DeepSeek-R1 。

2.3 DeepSeek-R1：基于冷启动的强化学习

受 DeepSeek-R1-Zero 令人鼓舞的结果启发，自然产生了两个问题：1）通过引入少量高质量数据作为冷启动，能否进一步提高推理性能或加快收敛速度？2）如何训练一个既能够生成清晰、连贯的思维链（CoT），又具备强大通用能力的用户友好型模型？为了解决这些问题，我们设计了一个训练 DeepSeek-R1 的流程，该流程包含四个阶段，具体如下。

2.3.1 冷启动

与 DeepSeek-R1-Zero 不同，为避免从基础模型进行强化学习训练时早期冷启动阶段的不稳定性，对于 DeepSeek-R1，我们构建并收集了少量长思维链数据，对模型进行微调，以此作为初始的强化学习执行者。为收集此类数据，我们探索了多种方法：使用带有长思维链示例的少样本提示；直接促使模型生成带有反思和验证的详细答案；收集格式易读的 DeepSeek-R1-Zero 输出；以及通过人工标注进行后处理来优化结果。
在本研究中，我们收集了数千条冷启动数据，对 DeepSeek-V3-Base 进行微调，作为强化学习的起点。与 DeepSeek-R1-Zero 相比，冷启动数据具有以下优势：

可读性：DeepSeek-R1-Zero 的一个关键局限在于其内容往往不便于阅读。生成的回答可能会混合多种语言，或者缺少用于突出答案的 Markdown 格式，不便于用户查看。相比之下，在为 DeepSeek-R1 创建冷启动数据时，我们设计了一种易读的模式，在每个回答的末尾添加总结，并过滤掉对读者不友好的回答。这里，我们将输出格式定义为 | 特殊标记 |<推理过程>| 特殊标记 |< 总结 >，其中推理过程是针对查询的思维链，总结用于概括推理结果。
潜力：通过结合人类先验知识精心设计冷启动数据的模式，我们发现其性能优于 DeepSeek-R1-Zero。我们认为迭代训练对于推理模型而言是一种更好的方式。

2.3.2 面向推理的强化学习

在利用冷启动数据对 DeepSeek-V3-Base 进行微调后，我们采用与 DeepSeek-R1-Zero 相同的大规模强化学习训练过程。这个阶段专注于提升模型的推理能力，特别是在编码、数学、科学和逻辑推理等推理密集型任务中，这些任务通常具有明确的问题和清晰的解决方案。在训练过程中，我们发现思维链经常出现语言混合的情况，尤其是当强化学习提示涉及多种语言时。为缓解语言混合问题，我们在强化学习训练过程中引入了语言一致性奖励，该奖励通过计算思维链中目标语言词汇的比例来衡量。尽管消融实验表明，这种调整会导致模型性能略有下降，但该奖励符合人类偏好，使生成的内容更具可读性。最后，我们将推理任务的准确率与语言一致性奖励直接相加，形成最终的奖励。然后，对微调后的模型进行强化学习训练，直至其在推理任务上达到收敛。

2.3.3 拒绝采样与监督微调

当面向推理的强化学习收敛后，我们利用得到的检查点为下一轮收集监督微调（SFT）数据。与最初主要聚焦于推理的冷启动数据不同，这个阶段整合了来自其他领域的数据，以增强模型在写作、角色扮演和其他通用任务方面的能力。具体而言，我们按照以下方式生成数据并微调模型：

推理数据：我们整理推理提示，并通过对上述强化学习训练得到的检查点进行拒绝采样，生成推理轨迹。在之前的阶段，我们仅纳入了可以使用基于规则的奖励进行评估的数据。然而在这个阶段，我们通过纳入更多数据来扩展数据集，其中部分数据使用生成式奖励模型，将真实答案和模型预测输入 DeepSeek-V3 进行判断。此外，由于模型输出有时较为混乱且难以阅读，我们过滤掉了包含混合语言的思维链、冗长的段落和代码块。对于每个提示，我们采样多个回答，仅保留正确的回答。总体而言，我们收集了约 60 万个与推理相关的训练样本。
非推理数据：对于写作、事实性问答、自我认知和翻译等非推理数据，我们采用 DeepSeek-V3 的流程，并复用了 DeepSeek-V3 的部分监督微调数据集。对于某些非推理任务，在回答问题之前，我们通过提示促使 DeepSeek-V3 生成潜在的思维链。然而，对于诸如 “你好” 这类简单查询，我们则不提供思维链作为回应。最终，我们总共收集了约 20 万个与推理无关的训练样本。
我们使用上述整理的约 80 万个样本的数据集，对 DeepSeek-V3-Base 进行了两个轮次的微调。

2.3.4 全场景强化学习

为了进一步使模型符合人类偏好，我们实施了第二个强化学习阶段，旨在提升模型的实用性和无害性，同时优化其推理能力。具体而言，我们结合奖励信号和多样化的提示分布来训练模型。对于推理数据，我们遵循 DeepSeek-R1-Zero 中概述的方法，利用基于规则的奖励来指导数学、代码和逻辑推理领域的学习过程。对于通用数据，我们借助奖励模型来捕捉复杂和微妙场景中的人类偏好。我们基于 DeepSeek-V3 的流程，采用类似的偏好对和训练提示分布。在评估实用性时，我们仅关注最终的总结，确保评估重点在于回答对用户的实用性和相关性，同时尽量减少对底层推理过程的干扰。在评估无害性时，我们评估模型的整个回答，包括推理过程和总结，以识别并减轻生成过程中可能出现的任何潜在风险、偏差或有害内容。最终，奖励信号和多样化数据分布的整合使我们能够训练出一个在推理方面表现出色，同时注重实用性和无害性的模型。

通俗解释

DeepSeek-R1-Zero 表现不错，但是大家还想让模型更好，就有了两个新问题：用点高质量数据做冷启动，能不能让模型推理能力更强、训练更快？能不能训练出既会清晰推理，又有很多通用能力，对用户很友好的模型？所以就设计了 DeepSeek-R1 的训练流程，有四个阶段。
第一个阶段是冷启动。DeepSeek-R1-Zero 从基础模型直接训练，前期不太稳定。DeepSeek-R1 就先收集一些长思维链数据，微调模型。收集数据的方法有好几种，像用带长思维链的例子提示模型、让模型自己生成详细答案再优化等。冷启动数据有两个好处，一是更可读，以前模型回答的内容不好懂，现在设计了新格式，回答完还有总结；二是性能更好，结合了人的经验设计的数据，训练效果更好。
第二个阶段是面向推理的强化学习。用冷启动数据微调完模型后，就用和训练 DeepSeek-R1-Zero 一样的强化学习方法训练。这个阶段主要提升模型在一些推理任务上的能力。训练时发现思维链会混语言，就加了个语言一致性奖励，虽然对性能有点影响，但是生成的内容更符合人的习惯，更好懂。把准确率和这个奖励加起来作为最终奖励，一直训练到模型在推理任务上表现稳定。
第三个阶段是拒绝采样与监督微调。前面强化学习训练稳定后，就用得到的模型收集新数据来微调。这次的数据不只是推理的，还有写作、问答这些其他领域的数据。推理数据通过拒绝采样得到，还扩展了数据集，去掉不好的内容；非推理数据用 DeepSeek-V3 的流程收集，简单问题就不用思维链回答。最后用这些收集到的 80 万个样本的数据，微调模型两轮。
最后一个阶段是全场景强化学习。为了让模型更符合人的喜好，又进行了一次强化学习训练。对推理数据和以前一样用基于规则的奖励训练；对通用数据，用奖励模型来符合人的偏好。评估的时候，实用性只看总结有没有用、相不相关，无害性则检查整个回答有没有问题。这样训练出来的模型，推理厉害，还好用、安全。

2.4 知识蒸馏：赋予小模型推理能力

为了使更高效的小模型也具备像 DeepSeek-R1 那样的推理能力，我们使用为 DeepSeek-R1 整理的 80 万个样本，直接对 Qwen（Qwen, 2024b）和 Llama（AI@Meta, 2024）等开源模型进行微调，具体细节见 2.3.3 节。我们的研究结果表明，这种简单的知识蒸馏方法能够显著提升小模型的推理能力。这里使用的基础模型包括 Qwen2.5-Math-1.5B、Qwen2.5-Math-7B、Qwen2.5-14B、Qwen2.5-32B、Llama-3.1-8B 和 Llama-3.3-70B-Instruct。我们选择 Llama-3.3，是因为其推理能力略优于 Llama-3.1。
对于蒸馏后的模型，我们仅进行监督微调，不包含强化学习阶段，尽管加入强化学习可以大幅提升模型性能。我们在此的主要目的是展示知识蒸馏技术的有效性，将强化学习阶段的探索留给更广泛的研究社区。

通俗解释

团队想让小模型也能像 DeepSeek-R1 一样会推理，就用 DeepSeek-R1 整理的 80 万个样本去微调 Qwen、Llama 这些开源模型。结果发现，这样简单的操作就能让小模型推理能力变强。用的基础模型有不同参数规模的，像 15 亿、70 亿参数的等，选 Llama-3.3 是因为它推理能力相对好一点。
蒸馏后的小模型只做了监督微调，没做强化学习，虽然做强化学习能让模型性能更好，但团队这次主要是想看看蒸馏方法好不好用，强化学习就留给其他研究人员去探索了。

3. 实验

3.1 DeepSeek-R1 评估

基准测试（指标）	Claude-3.5-Sonnet-1022	GPT-4o-0513	DeepSeek V3	OpenAI o1-mini	OpenAI o1-1217	DeepSeek R1
架构	混合专家（MoE）	混合专家（MoE）
激活参数数量	370 亿	370 亿
参数总数	6710 亿	6710 亿
英语	MMLU（单次准确率）	88.3	87.2	88.5	85.2	91.8	90.8
MMLU-Redux（精确匹配率）	88.9	88.0	89.1	86.7	92.9
MMLU-Pro（精确匹配率）	78.0	72.6	75.9	80.3	84.0
DROP（3 次提示 F1 值）	88.3	83.7	91.6	83.9	90.2	92.2
IF-Eval（严格提示）	86.5	84.3	86.1	84.8	83.3
GPQA Diamond（单次准确率）	65.0	49.9	59.1	60.0	75.7	71.5
SimpleQA（正确率）	28.4	38.2	24.9	7.0	47.0	30.1
FRAMES（准确率）	72.5	80.5	73.3	76.9	82.5
AlpacaEval2.0（长度控制胜率）	52.0	51.1	70.0	57.8	87.6
ArenaHard（GPT-4-1106 评判）	85.2	80.4	85.5	92.0	92.3
代码	LiveCodeBench（思维链单次准确率）	38.9	32.9	36.2	53.8	63.4	65.9
Codeforces（百分比排名）	20.3	23.6	58.7	93.4	96.6	96.3
Codeforces（评级）	717	759	1134	1820	2061	2029
SWE Verified（问题解决率）	50.8	38.8	42.0	41.6	48.9	49.2
Aider-Polyglot（准确率）	45.3	16.0	49.6	32.9	61.7	53.3
数学	AIME 2024（单次准确率）	16.0	9.3	39.2	63.6	79.2	79.8
MATH-500（单次准确率）	78.3	74.6	90.2	90.0	96.4	97.3
CNMO 2024（单次准确率）	13.1	10.8	43.2	67.6	78.8
中文	CLUEWSC（精确匹配率）	85.4	87.9	90.9	89.9	92.8
C-Eval（精确匹配率）	76.7	76.0	86.5	68.9	91.8
C-SimpleQA（正确率）	55.4	58.7	68.0	40.3	63.7

表 4 DeepSeek-R1 与其他代表性模型的比较
在 MMLU、MMLU-Pro 和 GPQA Diamond 等面向教育的知识基准测试中，DeepSeek-R1 相较于 DeepSeek-V3 展现出更优的性能。这种提升主要归因于在 STEM 相关问题上准确率的提高，这得益于大规模强化学习。此外，DeepSeek-R1 在 FRAMES（一个依赖长上下文的问答任务）上表现出色，展示了其强大的文档分析能力。这凸显了推理模型在人工智能驱动的搜索和数据分析任务中的潜力。在事实性基准测试 SimpleQA 上，DeepSeek-R1 的表现优于 DeepSeek-V3，证明了它处理基于事实的查询的能力。在该基准测试中，OpenAI-o1 优于 GPT-4o，DeepSeek-R1 也呈现出类似的超越趋势。不过，DeepSeek-R1 在中文 SimpleQA 基准测试上的表现比 DeepSeek-V3 差，这主要是因为在经过安全性强化学习后，它倾向于拒绝回答某些查询。如果不进行安全性强化学习，DeepSeek-R1 在该测试上的准确率能超过 70%。
DeepSeek-R1 在 IF-Eval（一个用于评估模型遵循格式指令能力的基准测试）上也取得了令人瞩目的成绩。这些改进可归因于在监督微调（SFT）和强化学习训练的最后阶段纳入了指令遵循数据。此外，在 AlpacaEval2.0 和 ArenaHard 上，DeepSeek-R1 表现卓越，这表明它在写作任务和开放域问答方面具有优势。它大幅超越 DeepSeek-V3 的表现，突出了大规模强化学习的泛化优势，不仅提升了推理能力，还改善了模型在不同领域的性能。而且，DeepSeek-R1 生成的总结长度简洁，在 ArenaHard 上平均为 689 个词元，在 AlpacaEval 2.0 上平均为 2218 个字符。这表明 DeepSeek-R1 在基于 GPT 的评估中避免了引入长度偏差，进一步巩固了其在多个任务上的稳健性。
在数学任务上，DeepSeek-R1 的表现与 OpenAI-o1-1217 相当，大幅超越其他模型。在编码算法任务（如 LiveCodeBench 和 Codeforces）中也呈现出类似趋势，以推理为核心的模型在这些基准测试中占据主导地位。在面向工程的编码任务上，OpenAI-o1-1217 在 Aider 测试中表现优于 DeepSeek-R1，但在 SWE Verified 测试中二者性能相当。我们认为，随着相关强化学习训练数据量的增加，DeepSeek-R1 的工程性能将在后续版本中得到提升。

通俗解释

研究人员对 DeepSeek-R1 进行了各种测试，和好多厉害的模型对比。从表格里能看到，在知识类测试里，像 MMLU 这些，DeepSeek-R1 比 DeepSeek-V3 考得好，特别是在 STEM 相关的问题上，因为大规模强化学习让它更会做这类题。在处理长文章问答的 FRAMES 测试里，它也表现不错，说明分析文档能力强。在 SimpleQA 这个测试里，它比 DeepSeek-V3 厉害，能更好地回答事实类问题，和 OpenAI-o1 比 GPT-4o 表现好是一个道理。不过在中文 SimpleQA 测试里，它比 DeepSeek-V3 差，是因为做了安全性强化学习后，有些问题它不愿意回答，如果没这个限制，准确率能更高。
在测试模型按格式回答问题能力的 IF-Eval 测试里，DeepSeek-R1 成绩很好，这是因为训练后期加了相关的数据。在写作和开放域问答的测试（AlpacaEval2.0 和 ArenaHard）里，它表现也很棒，比 DeepSeek-V3 强很多，说明大规模强化学习让它在好多领域都更厉害。而且它生成的总结不长，在评估的时候不会因为长度问题影响结果，很稳定。
在数学任务和编码算法任务测试里，DeepSeek-R1 和 OpenAI-o1-1217 水平差不多，比其他模型好很多。在工程编码任务上，OpenAI-o1-1217 在 Aider 测试里比它好一点，但在 SWE Verified 测试里二者差不多。以后随着训练数据变多，DeepSeek-R1 在工程方面的能力还能提升。

3.2 蒸馏模型评估

模型	AIME 2024	MATH-500 单次准确率	GPQA Diamond 单次准确率	LiveCodeBench 单次准确率	CodeForces 评级
单次准确率	64 次采样多数投票准确率
GPT-4o-0513	9.3	13.4	74.6	49.9	32.9	759
Claude-3.5-Sonnet-1022	16.0	26.7	78.3	65.0	38.9	717
OpenAI-o1-mini	63.6	80.0	90.0	60.0	53.8	1820
QwQ-32B-Preview	50.0	60.0	90.6	54.5	41.9	1316
DeepSeek-R1-Distill-Qwen-1.5B	28.9	52.7	83.9	33.8	16.9	954
DeepSeek-R1-Distill-Qwen-7B	55.5	83.3	92.8	49.1	37.6	1189
DeepSeek-R1-Distill-Qwen-14B	69.7	80.0	93.9	59.1	53.1	1481
DeepSeek-R1-Distill-Qwen-32B	72.6	83.3	94.3	62.1	57.2	1691
DeepSeek-R1-Distill-Llama-8B	50.4	80.0	89.1	49.0	39.6	1205
DeepSeek-R1-Distill-Llama-70B	70.0	86.7	94.5	65.2	57.5	1633

表 5 DeepSeek-R1 蒸馏模型与其他可比模型在推理相关基准测试中的比较
如表 5 所示，仅仅通过蒸馏 DeepSeek-R1 的输出，高效的 DeepSeek-R1-7B（即 DeepSeek-R1-Distill-Qwen-7B，以下简称类似）就能在所有方面超越像 GPT-4o-0513 这样的非推理模型。DeepSeek-R1-14B 在所有评估指标上都超过了 QwQ-32B-Preview，而 DeepSeek-R1-32B 和 DeepSeek-R1-70B 在大多数基准测试中显著超越 o1-mini。这些结果展示了知识蒸馏的强大潜力。此外，我们发现对这些蒸馏模型应用强化学习会带来进一步的显著提升。我们认为这值得进一步探索，因此在此仅展示简单监督微调蒸馏模型的结果。

通俗解释

研究人员还测试了从 DeepSeek-R1 蒸馏出来的小模型。从表格数据能看出，这些小模型表现很不错。就拿 DeepSeek-R1-Distill-Qwen-7B 来说，它在各个测试里都比 GPT-4o-0513 考得好。DeepSeek-R1-14B 比 QwQ-32B-Preview 厉害，DeepSeek-R1-32B 和 DeepSeek-R1-70B 在大部分测试里比 o1-mini 还好。这说明把大模型的能力蒸馏到小模型里这个方法很有用。而且如果再给这些蒸馏后的小模型做强化学习，它们还能变得更厉害，不过这次研究人员没展示这部分结果，以后可以继续研究。

4. 讨论

4.1 知识蒸馏与强化学习

在 3.2 节中可以看到，通过对 DeepSeek-R1 进行知识蒸馏，小模型能取得令人瞩目的成绩。然而，仍有一个问题：模型不经过知识蒸馏，通过本文中讨论的大规模强化学习训练，能否达到类似的性能？
为回答这个问题，我们使用数学、代码和 STEM 数据，对 Qwen-32B-Base 进行了超过 10,000 步的大规模强化学习训练，得到了 DeepSeek-R1-Zero-Qwen-32B。实验结果如表 6 所示，经过大规模强化学习训练的 320 亿参数基础模型，其性能与 QwQ-32B-Preview 相当。然而，从 DeepSeek-R1 蒸馏得到的 DeepSeek-R1-Distill-Qwen-32B，在所有基准测试中的表现都显著优于 DeepSeek-R1-Zero-Qwen-32B。
因此，我们可以得出两个结论：第一，将更强的模型知识蒸馏到较小模型中能产生优异的效果，而较小模型依靠本文提到的大规模强化学习则需要巨大的计算资源，甚至可能无法达到知识蒸馏的性能。第二，虽然知识蒸馏策略既经济又有效，但要突破智能的边界，可能仍需要更强大的基础模型和大规模强化学习。

模型	AIME 2024	MATH-500 单次准确率	GPQA Diamond 单次准确率	LiveCodeBench 单次准确率
单次准确率	64 次采样多数投票准确率
QwQ-32B-Preview	50.0	60.0	90.6	54.5	41.9
DeepSeek-R1-Zero-Qwen-32B	47.0	60.0	91.6	55.0	40.2
DeepSeek-R1-Distill-Qwen-32B	72.6	83.3	94.3	62.1	57.2

表 6 知识蒸馏模型与强化学习模型在推理相关基准测试中的比较

通俗解释

前面看到知识蒸馏让小模型成绩很好，大家就想知道，小模型不蒸馏，直接用大规模强化学习训练，能不能有同样好的表现呢？于是研究人员就用 Qwen-32B-Base 这个模型，用数学、代码等数据进行大规模强化学习训练，训练了 10000 多步，得到了 DeepSeek-R1-Zero-Qwen-32B 这个模型。
对比发现，这个经过强化学习训练的模型，和 QwQ-32B-Preview 表现差不多。但是从 DeepSeek-R1 蒸馏出来的 DeepSeek-R1-Distill-Qwen-32B，在各项测试里都比 DeepSeek-R1-Zero-Qwen-32B 好很多。
这就说明，把大模型的知识 “传” 给小模型的知识蒸馏方法效果很好，小模型要是想用大规模强化学习达到同样效果，不仅特别费计算资源，可能还做不到。虽然知识蒸馏又省钱又好用，但想要让模型更聪明，可能还是得靠更厉害的大模型和大规模强化学习。

4.2 失败尝试

在开发 DeepSeek-R1 的早期阶段，我们也经历了失败和挫折。在此分享这些失败经验以供参考，但这并不意味着这些方法无法用于开发有效的推理模型。

过程奖励模型（PRM）：过程奖励模型是一种引导模型寻找更好推理任务解决方法的合理途径（Lightman 等人，2023；Uesato 等人，2022；Wang 等人，2023）。然而在实际应用中，PRM 存在三个主要局限性，可能会阻碍其最终成功。第一，在一般推理中，明确定义精细的推理步骤具有挑战性。第二，判断当前中间步骤是否正确是一项艰巨的任务。使用模型进行自动标注可能无法得到令人满意的结果，而人工标注不利于大规模应用。第三，一旦引入基于模型的 PRM，不可避免地会导致奖励作弊（Gao 等人，2022），重新训练奖励模型需要额外的训练资源，并且会使整个训练流程变得复杂。总之，虽然 PRM 在对模型生成的前 N 个响应进行重新排序或辅助引导搜索方面（Snell 等人，2024）表现出良好的能力，但在我们的实验中，与大规模强化学习过程中引入的额外计算开销相比，其优势有限。
蒙特卡洛树搜索（MCTS）：受 AlphaGo（Silver 等人，2017b）和 AlphaZero（Silver 等人，2017a）的启发，我们探索使用蒙特卡洛树搜索（MCTS）来提高测试时计算的可扩展性。这种方法将答案分解为较小的部分，使模型能够系统地探索解决方案空间。为实现这一点，我们促使模型生成多个与搜索所需的特定推理步骤相对应的标签。在训练过程中，我们首先使用收集到的提示，通过由预训练价值模型引导的 MCTS 来寻找答案。随后，我们使用得到的问答对来训练策略模型和价值模型，迭代优化这个过程。

然而，在扩大训练规模时，这种方法遇到了几个挑战。第一，与国际象棋不同，在国际象棋中搜索空间相对明确，而令牌生成的搜索空间呈指数级增大。为解决这个问题，我们为每个节点设置了最大扩展限制，但这可能导致模型陷入局部最优解。第二，价值模型直接影响生成的质量，因为它引导搜索过程的每一步。训练一个精细的价值模型本身就很困难，这使得模型难以通过迭代得到改进。虽然 AlphaGo 的核心成功在于训练价值模型以逐步提升性能，但由于令牌生成的复杂性，在我们的设置中难以复制这一原理。
总之，虽然 MCTS 与预训练价值模型结合可以在推理时提高性能，但通过自我搜索迭代提升模型性能仍然是一个巨大的挑战。

通俗解释

在研究 DeepSeek-R1 的时候，团队也试过一些方法但没成功。
有一种叫过程奖励模型（PRM）的方法，本来想着用它能引导模型更好地推理。但实际用的时候发现有问题：一是在推理过程中，很难把每一步都规定得很清楚；二是判断中间步骤对不对很难，用模型自动标注不准，人工标注又没办法大规模做；三是用了这个模型容易出现奖励作弊的情况，重新训练奖励模型又费资源又让训练过程变复杂。虽然它在给模型的回答排序、引导搜索这些方面有点用，但总体来说，在大规模强化学习里，它带来的麻烦比好处多。
还有蒙特卡洛树搜索（MCTS）方法，是从 AlphaGo 这些成功的例子里得到的启发，想用它让模型在测试的时候计算能力更强。这个方法就是把答案拆成小部分，让模型慢慢找解决方案，训练的时候用预训练的价值模型帮忙找答案，再用这些答案训练模型。
但是扩大训练规模的时候就不行了。一方面，和国际象棋比起来，模型生成内容的搜索范围大太多了，限制搜索节点又容易让模型卡在局部最优解里；另一方面，价值模型对生成结果影响很大，但是很难训练好，所以模型很难通过不断训练变得更好。虽然 MCTS 和预训练价值模型一起用，在推理的时候有点用，但想靠它让模型一直进步太难了。

5. 结论、局限性与未来工作

在本研究中，我们分享了通过强化学习提升模型推理能力的历程。DeepSeek-R1-Zero 代表了一种不依赖冷启动数据的纯强化学习方法，在各种任务中都取得了优异的性能。DeepSeek-R1 则更强大，它利用冷启动数据和迭代强化学习微调。最终，DeepSeek-R1 在一系列任务上的表现与 OpenAI-o1-1217 相当。
我们进一步探索了将推理能力蒸馏到小型稠密模型中。以 DeepSeek-R1 为教师模型生成 80 万个训练样本，对几个小型稠密模型进行微调。结果很有前景：DeepSeek-R1-Distill-Qwen-1.5B 在数学基准测试中表现超过 GPT-4o 和 Claude-3.5-Sonnet，在 AIME 测试中得分为 28.9%，在 MATH 测试中得分为 83.9%。其他稠密模型也取得了令人瞩目的成绩，显著超越了基于相同基础检查点的其他指令微调模型。
未来，我们计划在以下几个方向对 DeepSeek-R1 进行研究：

通用能力：目前，DeepSeek-R1 在函数调用、多轮对话、复杂角色扮演和 JSON 输出等任务上的能力不如 DeepSeek-V3。未来，我们计划探索如何利用长思维链来提升这些领域的任务表现。
语言混合：DeepSeek-R1 目前针对中文和英文进行了优化，在处理其他语言的查询时可能会出现语言混合问题。例如，即使查询使用的是非中文或英文的其他语言，DeepSeek-R1 也可能会用英文进行推理和回答。我们旨在在未来的更新中解决这一局限性。
提示工程：在评估 DeepSeek-R1 时，我们发现它对提示很敏感。少样本提示始终会降低其性能。因此，我们建议用户直接描述问题，并使用零样本设置指定输出格式，以获得最佳结果。
软件工程任务：由于评估时间长，影响了强化学习过程的效率，大规模强化学习在软件工程任务中尚未得到广泛应用。因此，DeepSeek-R1 在软件工程基准测试上相比 DeepSeek-V3 并没有显著改进。未来版本将通过对软件工程数据实施拒绝采样，或在强化学习过程中纳入异步评估来提高效率，从而解决这一问题。

通俗解释

这篇研究主要是讲怎么用强化学习让模型更会推理。DeepSeek-R1-Zero 是直接用强化学习训练的，不用冷启动数据，在很多任务里表现都不错。DeepSeek-R1 更厉害，用了冷启动数据，还反复用强化学习微调，最后和 OpenAI 很厉害的 o1-1217 模型表现差不多。
团队还把 DeepSeek-R1 的推理能力教给了小模型，用它生成的 80 万个样本去训练小模型，结果小模型成绩很好，比一些以前的模型考得都好。
不过，DeepSeek-R1 也有不足的地方，以后团队打算从这几个方面继续研究改进。在通用能力方面，它在函数调用这些任务上不如 DeepSeek-V3，以后看看能不能用长思维链让它在这些任务里表现更好。在语言方面，它对中文和英文优化得比较好，处理其他语言容易混，之后要解决这个问题。在提示方面，它对提示很敏感，少样本提示会让它发挥不好，所以建议用户直接描述问题、用零样本设置。在软件工程任务方面，因为评估时间长，大规模强化学习用得少，它在这方面进步不大，以后会用拒绝采样、异步评估这些方法来提高效率。

作者 east

智能体 9月 29,2024

好用到爆，用扣子（coze.cn)搭建自己第一个提升工作效率工具（Hive SQL转Impala SQL助手）过程分享

工作经常要写离线数仓的SQL，由于历史项目很多是用Hive SQL写的，而在调试阶段，用Hive查询实在是太慢了。跟Impala查询对比起来，真是一个天一个地。于是有想把Hive SQL转化为Impala SQL的想法。

不过Impala SQL虽然大部分跟Hive是相同的，但有部分语法是有差异的。一个复杂Hive SQL，要手动来改太繁琐和费脑。试了一些大模型来自动改，效果并不是十分理想。于是有用扣子(coze.cn)增加知识库来解决问题。

根据自己工作总结和用ChatGPT的总结，第一个版本的知识库如下：

Impala和hive语法不同


字符串分割
Hive: split
Impala: split_part
实例：
Hive: split('hello world', ' ')[1]
Impala: split_part('hello world', ' ', 2)

当前日期
Hive: current_timestamp()
Impala: now()
实例：
Hive: SELECT current_timestamp();
Impala: SELECT now();                     

数组大小函数
Hive: 使用 size() 函数来获取数组或映射的大小
Impala: 使用 array_length() 函数来获取数组的大小
实例：
Hive:
SELECT size(array(1, 2, 3));
Impala:
SELECT array_length([1, 2, 3]);

把这一份word文档上传到扣子知识库后，发现调用hive 的split函数后要求转化为impala，扣子提示知识库无召回。

记得之前网友说excel文档效果更好。把这个word文档修改为excel文档。

由于自己是用sql，如果用语义搜索觉得效果并不是很好，把搜索策略修改为混合，最小匹配度进行调低。

修改后果然匹配到知识库返回了，在自己知识库增强后，测了几个例子，回答的结果也从原来不正确的到现在的完全正确。以后工作可以不自己苦逼改sql，直接丢给扣子来自动完成了。

作者 east

智能体 8月 8,2024

储能系统中BMU板与其他电池管理系统组件的区别

在储能系统中，BMU板（电池管理单元）与其他电池管理系统组件的主要区别在于其功能定位和在系统中的角色。BMU板主要负责基础数据的监测，而其他组件如BCU（电池簇管理单元）和BAU（电池阵列管理单元）则基于BMU提供的数据执行更高级的控制策略和系统管理功能。以下是详细介绍：

BMU板与其他电池管理系统组件的区别

BMU板的功能：BMU板主要负责监测电池单体或电池模块的基本参数，如电压、电流、温度等，为整个电池管理系统提供基础数据支持。
BCU的功能：BCU基于BMU提供的数据，执行电池的控制策略，包括充电电流和电压的调节、放电截止电压的设置等，并负责电池组的均衡管理。
BAU的功能：BAU对整个电池系统进行综合管理和协调，整合了BMU和BCU的功能，并具备更高级的功能，如故障诊断与预警、系统状态评估等。

BMU板在储能系统中的重要性

BMU板是储能系统中不可或缺的部分，它确保了电池组的安全、高效、稳定运行。通过精确的监测和控制，BMU板延长了电池的使用寿命，提高了储能系统的整体性能和可靠性。

通过上述分析，我们可以看到BMU板在储能系统中的核心作用，以及它在确保电池安全和提高系统性能方面的重要性。

作者 east

chatgpt 6月 18,2024

腾讯云 AI 代码助手保姆级使用教程

腾讯云 AI 代码助手是一款基于先进的代码大模型开发的智能编码辅助工具，它能够帮助开发者提高编码效率，实现技术沟通、代码补全、自动生成单元测试等功能。

基于腾讯混元代码模型：腾讯表示内部超过 50% 的研发在使用
支持多种语言：支持 Python, JavaScript / TypeScript, Java, C / C++, Go, C#, Rust, Swift, Lua, Kotlin, TSX / JSX, Vue, Proto, PHP 等语言 / 框架
支持主流 IDE：支持 VS Code 和 JetBrains 全家桶
提升研发效率：通过技术对话与代码补全，辅助生成业务代码、注释、单元测试等内容，提高开发效率
加速开发流程：辅助补全、BUG 诊断、生成测试，释放机械性工作，专注代码创作
体验开发无障碍：对话学习、快速理解、规范编写、缩短学习曲线, 开发少走弯路

支持的IDE

Visual Studio Code
JetBrains IDEs（如 IntelliJ IDEA、PyCharm 等）

下载与安装

从 Visual Studio Code 插件市场安装

打开 Visual Studio Code。
点击左侧导航栏上的扩展图标，或使用快捷键 Ctrl+Shift+X（在 macOS 上是 Cmd+Shift+X）。
在搜索框中输入“腾讯云 AI 代码助手”。
找到插件后，点击“Install”按钮进行安装。
安装完成后，重启 Visual Studio Code。

从 JetBrains IDEs 安装

打开 JetBrains IDE（例如 IntelliJ IDEA）。
转到 “File” > “Settings”（Windows/Linux）或 “IntelliJ IDEA” > “Preferences”（macOS）。
在设置窗口中，选择 “Plugins”。
点击 “Marketplace” 标签，搜索“腾讯云 AI 代码助手”。
找到插件后，点击 “Install” 按钮进行安装。
安装完成后，重启 IDE。

腾讯云AI代码助手需要登录，并在腾讯云安全实名认证才可以使用。

二、核心功能介绍及实战演示

1. 代码补全：加速编码流程

功能说明： 基于上下文理解，腾讯云AI代码助手能够自动推荐最可能的代码片段，包括但不限于方法调用、变量声明、循环结构等，显著减少键盘敲击次数。

实例演示：

假设我们正在编写一个Python程序，用于计算两个数的和：

def add_numbers(a, b):
    return a +

当键入到return a +时，腾讯云AI代码助手会立即提示补全为b，实现如下：

def add_numbers(a, b):
    return a + b

2. 优化代码：提升执行效率与可读性

功能说明： 该功能能够分析现有代码，提出重构建议，如循环优化、变量重命名、冗余代码删除等，确保代码既高效又易于维护。

实例演示：

原始代码存在循环内重复计算问题：

numbers = [1, 2, 3, 4, 5]
sum = 0
for num in numbers:
    sum += num * num
print(sum)

腾讯云AI代码助手建议优化为：

numbers = [1, 2, 3, 4, 5]
squared_sum = sum(x*x for x in numbers)
print(squared_sum)

通过列表推导式直接计算平方和，减少了计算步骤，提高了代码效率。

3. 补全注释：自动化文档生成

功能说明： 自动根据函数或模块的逻辑生成详细的注释说明，帮助团队成员理解代码逻辑，促进知识共享。

实例演示：

对于函数add_numbers，只需在函数定义下方添加注释起始符号"""，AI助手即能自动生成注释：

def add_numbers(a, b):
    """
    Calculate the sum of two numbers.

    Args:
        a (int): The first number.
        b (int): The second number.

    Returns:
        int: The sum of `a` and `b`.
    """
    return a + b

Python1def add_numbers(a, b):
2    """
3    Calculate the sum of two numbers.
4
5    Args:
6        a (int): The first number.
7        b (int): The second number.
8
9    Returns:
10        int: The sum of `a` and `b`.
11    """
12    return a + b

4. 解释代码：新手友好，快速上手

功能说明： 鼠标选择代码行上时，右键选择腾讯云AI助手的解释代码，就能提供当前行代码的功能解释，特别适合新人学习和理解代码逻辑。

5. 生成单元测试：自动化测试框架构建

功能说明： 根据现有代码结构，自动生成对应的单元测试案例，确保代码变更时功能的稳定性。

实例演示：

对于上面的add_numbers函数，AI助手能生成如下单元测试代码：

import unittest
from my_module import add_numbers

class TestAddNumbers(unittest.TestCase):
    def test_add_positive_numbers(self):
        self.assertEqual(add_numbers(2, 3), 5)

    def test_add_negative_numbers(self):
        self.assertEqual(add_numbers(-1, -1), -2)

if __name__ == '__main__':
    unittest.main()

Python1import unittest
2from my_module import add_numbers
3
4class TestAddNumbers(unittest.TestCase):
5    def test_add_positive_numbers(self):
6        self.assertEqual(add_numbers(2, 3), 5)
7
8    def test_add_negative_numbers(self):
9        self.assertEqual(add_numbers(-1, -1), -2)
10
11if __name__ == '__main__':
12    unittest.main()

6. 定位代码缺陷：提前发现潜在错误

功能说明： 实时分析代码，标记潜在的语法错误、逻辑漏洞或不符合最佳实践的地方，防患于未然。

实例演示：

考虑下面的错误代码片段：

if x > y:
    result = divide(x, y)
else:
    print("y should be greater than x.")

Python1if x > y:
2    result = divide(x, y)
3else:
4    print("y should be greater than x.")

如果divide函数未定义，腾讯云AI代码助手将高亮显示divide(x, y)，并提示“未定义的名称‘divide’”。

作者 east

提示词, 运维 4月 25,2024

利用kimi等大模型进行运维参数解析和调优

在运维时，经常遇到很多参数，有些参数不知道意义，知道意义的也有些不知道合理参考值是多少。利用kimi等大模型来当老司机，轻松解决运维难题。

例如在运维hive参数时，有些不知道作用，提示次如下

你的角色是运维专家，逐个解析每个配置的作用，并看是否合理：【运维参数】

为了获取某个参数的合理值，还可以进一步追问：

作者 east

chatgpt, 大模型 10月 12,2023

NLP民工的乐园: 最全最新的大模型（ChatGPT)中文NLP资源库

引用自：
fighting41love/funNLP

The Most Powerful NLP-Weapon Arsenal

NLP民工的乐园: 几乎最全的中文NLP资源库

在入门到熟悉NLP的过程中，用到了很多github上的包，遂整理了一下，分享在这里。

很多包非常有趣，值得收藏，满足大家的收集癖！如果觉得有用，请分享并star⭐，谢谢！

长期不定时更新，欢迎watch和fork！❤️❤️❤️

🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥
* 类ChatGPT的模型评测对比 * 类ChatGPT的资料 * 类ChatGPT的开源框架 * LLM的训练_推理_低资源_高效训练 * 提示工程 * 类ChatGPT的文档问答 * 类ChatGPT的行业应用 * 类ChatGPT的课程资料 * LLM的安全问题 * 多模态LLM * LLM的数据集

🍆 🍒 🍐 🍊	🌻 🍓 🍈 🍅 🍍
* 语料库 * 词库及词法工具 * 预训练语言模型 * 抽取 * 知识图谱 * 文本生成 * 文本摘要 * 智能问答 * 文本纠错	* 文档处理 * 表格处理 * 文本匹配 * 文本数据增强 * 文本检索 * 阅读理解 * 情感分析 * 常用正则表达式 * 语音处理
* 常用正则表达式 * 事件抽取 * 机器翻译 * 数字转换 * 指代消解 * 文本聚类 * 文本分类 * 知识推理 * 可解释NLP * 文本对抗攻击	* 文本可视化 * 文本标注工具 * 综合工具 * 有趣搞笑工具 * 课程报告面试等 * 比赛 * 金融NLP * 医疗NLP * 法律NLP * 文本生成图像 * 其他

类ChatGPT的模型评测对比

资源名（Name）	描述（Description）	链接
ChatALL：可以同时与多个AI聊天机器人（含清华、讯飞的产品）	可以同时与多个AI聊天机器人（如ChatGPT、Bing Chat、Bard、Alpaca、Vincuna、Claude、ChatGLM、MOSS、iFlytek Spark、ERNIE等）进行对话的工具。它可以并行发送提示给不同的AI机器人，帮助用户找到最好的回答	github-ChatALL
Chatbot Arena	实际场景用Elo rating对 LLM 进行基准测试 – 介绍了 Chatbot Arena，一种针对大型语言模型 (LLM) 的基准平台，采用匿名、随机的方式进行对抗评测，评测方式基于国际象棋等竞技游戏中广泛使用的 Elo rating system。发布了9个流行的开源 LLM 模型的 Elo rating 并推出排行榜。平台采用 FastChat 多模型服务系统，在多个语言下提供交互式界面，数据来源于用户投票。总结了 Chatbot Arena 的优点并计划提供更好的采样算法、排名和服务系统	截止2023年5月3日
类ChatGPT模型评测总结	大型语言模型(LLM)受到广泛关注，这些强大的模型能够理解复杂的信息，并对各种问题提供类人的回应。其中GPT-3和GPT-4表现最好，Flan-t5和Lit-LLaMA表现也不错。但要注意，模型商用可能需要付费和数据共享	blog
大型语言模型（LLMs）大盘点	blog
大模型评测方面的最新研究	长文本建模一直是ChaGPT令人惊艳的能力之一，我们以【篇章翻译】为实验场景，对大模型的篇章建模能力进行全面、细粒度的测试。	paper
中文大模型评测工具&排行榜	C-Eval是一个全面的中文评估套件，适用于基础模型。它包含13948个多项选择题，涵盖52个不同的学科和四个难度级别，具体如下所示。请访问我们的网站或查阅我们的论文获取更多详细信息。	github paper
OpenCompass 大模型评测	OpenCompass 上海人工智能实验室开发的一款开源、高效、全面的评测大模型体系及开放平台，提供完整开源可复现的评测框架，支持大语言模型、多模态模型各类模型的一站式评测。利用分布式技术，即使面对千亿参数模型也能在数小时内完成评测。基于多个不同维度的高认可度数据集开放多样化的评测方式，包括零样本评测、小样本评测和思维链评测，全方位量化模型各个维度能力。	github website

类ChatGPT的资料

资源名（Name）	描述（Description）	链接
Open LLMs：可供商业使用的开放大型语言模型(LLM)	A list of open LLMs available for commercial use	github
LLM Zoo: 大型语言模型的数据、模型和基准集市	LLM Zoo: democratizing ChatGPT – a project that provides data, models, and evaluation benchmark for large language models	github
大型语言模型(LLM)资料合集	相关论文列表，包括指导、推理、决策、持续改进和自我提升等方面的研究工作	LLM资料合集
DecryptPrompt	总结Prompt&LLM论文，开源数据&模型，AIGC应用	github
SmartGPT	旨在为大型语言模型(尤其是GPT-3.5和GPT-4)提供完成复杂任务的能力，通过将它们分解成更小的问题，并使用互联网和其他外部来源收集信息。特点包括模块化设计，易于配置，以及对插件的高度支持。SmartGPT的运作基于”Autos”的概念，包括”Runner”和”Assistant”两种类型，都配有处理计划、推理和任务执行的LLM代理。此外，SmartGPT还具有内存管理系统，以及可以定义各种命令的插件系统	github-SmartGPT
OpenGPT	用于创建基于指令的数据集并训练对话领域专家大型语言模型(LLMs)的框架。已经成功应用于训练健康护理对话模型NHS-LLM，利用来自英国国家卫生服务体系(NHS)网站的数据，生成了大量的问答对和独特对话	github-OpenGPT
PaLM 2技术报告	Google最新发布PaLM 2，一种新的语言模型，具有更好的多语言和推理能力，同时比其前身PaLM更节省计算资源。PaLM 2综合了多项研究进展，包括计算最优的模型和数据规模、更多样化和多语言的数据集、以及更有效的模型架构和目标函数。PaLM 2在多种任务和能力上达到了最先进的性能，包括语言水平考试、分类和问答、推理、编程、翻译和自然语言生成等。PaLM 2还展示了强大的多语言能力，能够处理数百种语言，并在不同语言之间进行翻译和解释。PaLM 2还考虑了负责任的使用问题，包括推理时控制毒性、减少记忆化、评估潜在的伤害和偏见等	PaLM 2 Technical Report
DB-GPT	于vicuna-13b和FastChat的开源实验项目，采用了langchain和llama-index技术进行上下文学习和问答。项目完全本地化部署，保证数据的隐私安全，能直接连接到私有数据库处理私有数据。其功能包括SQL生成、SQL诊断、数据库知识问答等	github-DB-GPT
Transformers相关文献资源大列表	包含了各种各样的Transformer模型，例如BERT、GPT、Transformer-XL等，这些模型已经在许多自然语言处理任务中得到了广泛应用。此外，该列表还提供了这些模型的相关论文和代码链接，为自然语言处理领域的研究人员和开发者提供了很好的参考资源	github
GPT-4终极指南	一份关于如何使用GPT3和GPT4的指南，其中包括100多个资源，可以帮助学习如何用它来提高生活效率。包括如何学习ChatGPT基础知识、如何学习ChatGPT高级知识、如何在语言学习中使用GPT-3、如何在教学中使用GPT-3、如何使用GPT-4等，还提供了如何升级到ChatGPT+计划以使用GPT-4以及如何免费使用GPT-4的方法等内容。同时，还提供了如何在业务、生产力、受益、金钱等方面使用ChatGPT的指南	link
基于LoRA的LLM参数高效微调	link
复杂推理：大语言模型的北极星能力	在 GPT-4 发布博客中，作者写道：“在一次随意的谈话中，GPT-3.5 和 GPT-4 之间的区别可能是微妙的。当任务的复杂程度达到足够的阈值时，差异就会显现出来。”这意味着复杂任务很可能是大型和小型语言模型的关键差异因素。在这篇文章中，我们将仔细分析讨论如何让大语言模型拥有强大的复杂推理能力。	blog
大型语言模型的涌现能力是否是海市蜃楼？	大语言模型的涌现能力一直是被大家视作很神奇的现象，似乎是一种大力出奇迹，但这篇论文认为这可能只是一种错觉。	paper
大语言模型的概率总结	非常详尽的LLM科学解释和总结	paper
LLaMA 模型简史	LLaMA是Meta发布的语言模型，采用Transformer架构，有多个版本，最大为65B参数。与GPT类似，可用于进一步微调，适用于多种任务。与GPT不同的是，LLaMA是开源的，可以在本地运行。现有的LLaMA模型包括：Alpaca、Vicuna、Koala、GPT4-x-Alpaca和WizardLM。每个模型都有不同的训练数据和性能表现	blog
大型语言模型的复杂推理	讨论了如何训练具有强大复杂推理能力的语言模型，并探讨了如何有效地提示模型以充分释放其潜力；针对语言模型和编程的训练相似性，提出了三阶段的训练：持续训练、监督微调和强化学习；介绍了评估大型语言模型推理能力的一套任务集合；讨论了如何进行提示工程，通过提供各种学习机会使模型获得更好的学习效果，最终实现智能化	link
大语言模型进化树	paper
李宏毅：穷人如何低资源复刻自己的ChatGPT	blog
训练ChatGPT的必备资源：语料、模型和代码库完全指南	资源链接论文地址
GitHub宝藏库，里面整理了GPT相关的各种开源项目	github
ChatGPT中文指南	gitlab
探讨了ChatGPT在自然语言处理中的应用、优势、限制以及未来发展方向	强调了在使用该技术时的伦理道德考量和提示工程技术。	paper
大型语言模型相关文献资源列表	github
大型语言模型文献综述–中文版	github
ChatGPT 相关资源大列表	github
Pre-Training to Learn in Context	paper
Langchain架构图	image
LLM开发人员都应该知道的数字	github
大语言模型如何构建强大的复杂推理能力	blog
LLMs九层妖塔	分享打怪(ChatGLM、Chinese-LLaMA-Alpaca、MiniGPT-4、FastChat、LLaMA、gpt4all等)实战与经验	github

类ChatGPT的开源框架

资源名（Name）	描述（Description）	链接
LLM-As-Chatbot	这个项目把市面上有的LLM全部做成了Chatbot，直接可以在google colab运行，不需要自己搭建，非常适用于想体验LLM的朋友们。我刚试了，真的超简单。有些LLM需要的显存比较多，所以最好是要有colab pro订阅。	github
OpenBuddy	一款强大的开源多语言聊天机器人模型，目标是全球用户，重点是对话AI和流畅的多语言支持，包括英文、中文等多种语言。基于Facebook的LLAMA模型，进行了微调，包括扩展词汇表、增加常用字符和增强的token embeddings。通过这些改进和多轮对话数据集，OpenBuddy提供了一个强大的模型，能回答问题并在各种语言之间进行翻译任务。OpenBuddy的使命是提供一个免费、开放且可离线使用的AI模型，该模型可以在用户的设备上运行，无论他们的语言或文化背景如何。目前，OpenBuddy-13B的演示版本可以在Discord服务器上找到。其关键功能包括多语言对话AI(包括中文、英文、日文、韩文、法文等)、增强的词汇表和对常见CJK字符的支持，以及两种模型版本：7B和13B	github-OpenBuddy
Panda: 海外中文开源大语言模型	基于 Llama-7B, -13B, -33B, -65B 进行中文领域上的持续预训练，使用了接近15M条数据，并针对推理能力在中文benchmark上进行了评测	github-PandaLM
Dromedary：一个开源的自对齐语言模型，只需少量人工监督即可进行训练	github-Dromedary
LaMini-LM 蒸馏的小型、高效的语言模型集合	从 ChatGPT 蒸馏的小型、高效的语言模型集合，在2.58 M 指令大规模数据集上进行训练	github
LLaMA-Adapter V2	上海人工智能实验室 LLaMA-Adapter V2，仅注入14M参数，1小时时间即可完成训练，对比较果确实很惊艳，且具有多模态功能（对图像进行解释和问答）	github
HuggingChat	Hugging Face 推出第一个 ChatGPT 开源替代品：HuggingChat。基于 Open Assistant 大模型搭建，支持中文对话与编写代码，但暂不支持中文回复。应用已上线，无需代理，打开即可访问	link
Open-Chinese-LLaMA	基于 LLaMA-7B 经过中文数据集增量预训练产生的中文大语言模型基座	github
OpenLLaMA	LLaMA模型的开源复现，在RedPajama数据集上训练，使用了与LLaMA相同的预处理步骤和超参数，模型结构，上下文长度，训练步骤，学习率调度和优化器。OpenLLaMA的PyTorch和Jax权重可以在Huggingface Hub上获得。OpenLLaMA在各种任务中展现出与LLaMA和GPT-J相似的表现，部分任务表现优异	github
replit-code-v1-3b	BY-SA 4.0授权发布，这意味着允许商业使用	link
MOSS	MOSS是一个支持中英双语和多种插件的开源对话语言模型，moss-moon系列模型具有160亿参数，在FP16精度下可在单张A100/A800或两张3090显卡运行，在INT4/8精度下可在单张3090显卡运行。MOSS基座语言模型在约七千亿中英文以及代码单词上预训练得到，后续经过对话指令微调、插件增强学习和人类偏好训练具备多轮对话能力及使用多种插件的能力。	github
RedPajama	1.2 万亿tokens数据集	link
chinese_llama_alpaca_lora 抽取框架	github
Scaling Transformer to 1M tokens and beyond with RMT	该论文提出一种名为 RMT 的新技术，或许可将 Transform 的 Token 上限扩展至 100 万，甚至更多。	github
Open Assistant	包含大量AI生成的、人工标注的语料库和包括基于LLaMA和基于Pythia的多种模型可选。发布的数据集包括超过161K较高质量的，多达35种语言的人工助手型交互对话语料库	data model
ChatGLM Efficient Tuning	基于 PEFT 的高效 ChatGLM 微调	github
Dolly介绍	news
Baize：一种对自聊天数据进行参数高效调优的开源聊天模型	Baize是一个开源的聊天模型，可以进行多轮对话。它是通过使用ChatGPT自我对话生成高质量的多轮聊天语料库，并使用参数高效调整来增强LLaMA（一个开源的大型语言模型）而创建的。Baize模型在具有最小潜在风险的情况下表现出良好的多轮对话性能。它可以在单个GPU上运行，使更广泛的研究人员可以使用它。Baize模型和数据仅用于研究目的。	论文地址源码地址
GPTrillion–未找到开源代码	包含1.5万亿（1.5T）参数的大模型GPTrillion开源了，号称是目前世界上最大的开源LLM	google_doc
Cerebras-GPT-13B(可商用)	hugging_face
Chinese-ChatLLaMA	中文ChatLLaMA对话模型；预训练/指令微调数据集，基于 TencentPretrain 多模态预训练框架构建，支持简繁体中文、英文、日文等多语言	github
Lit-LLaMA	基于Apache 2.0许可证完全开源的LLaMA独立实现，建立在nanoGPT之上，旨在解决原始LLaMA代码采用GPL许可证的限制，以实现更广泛的学术和商业应用	github
MosaicML	MPT-7B-StoryWriter，65K tokens，可以把《了不起的盖茨比》都一次性扔进去。	huggingface
Langchain	大型语言模型（LLMs）正在成为一项具有变革性的技术，使开发者能够构建以前无法实现的应用程序。然而，仅仅使用这些独立的LLMs通常不足以创建一个真正强大的应用程序 – 真正的力量来自于能够将它们与其他计算或知识来源相结合。	github
Guidance	引导能够比传统的提示或链接更有效地控制现代语言模型，并且更高效。引导程序允许您将生成、提示和逻辑控制交错到单一连续流中，与语言模型实际处理文本的方式相匹配。像”Chain of Thought”及其许多变体（例如ART、Auto-CoT等）这样的简单输出结构已被证明能改善语言模型的性能。更强大的语言模型（如GPT-4）的出现使得更丰富的结构成为可能，而引导则使得构建这种结构变得更加容易和经济。	github
WizardLM	赋予大型预训练语言模型遵循复杂指令的能力，使用完整进化指令（约300k）训练的WizardLM-7B模型	github

LLM的训练_推理_低资源_高效训练

资源名（Name）	描述（Description）	链接
QLoRA–Guanaco	一种高效的微调方法，可以在单个48GB的GPU上微调一个拥有65B参数的模型，同时保持完整的16位微调任务性能，并通过QLoRA将梯度反向传播通过一个冻结的、4位量化的预训练语言模型到低秩适配器（LoRA）	github
Chinese-Guanaco	一个中文低资源的量化训练/部署方案	github
DeepSpeed Chat: 一键式RLHF训练	github
LLMTune: 在消费级GPU上微调大型65B+LLM	可以在普通消费级GPU上进行4位微调，例如最大的65B LLAMA模型。LLMTune还实现了LoRA算法和GPTQ算法来压缩和量化LLM，并通过数据并行处理大型模型。此外，LLMTune提供了命令行界面和Python库的使用方式	github
基于ChatGLM-6B+LoRA在指令数据集上进行微调	基于deepspeed支持多卡微调，速度相比单卡提升8-9倍具体设置可见微调3 基于DeepSpeed进行Lora微调	github
微软发布RLHF训练工具DeepSpeed Chat	github
LlamaChat：Mac上基于LLaMa的聊天机器人	github
ChatGPT/GPT4开源“平替”们	github
训练大型机器学习模型的实用建议和技巧	帮助您训练大型模型（>1B 参数）、避免不稳定性、保存开始失败的实验而不从 0 重新开始	link
Instruction Tuning with GPT-4	paper
xturing	一个Python软件包，用于高效、快速、简单地微调LLM模型，支持LLaMA、GPT-J、GPT-2等多种模型，可使用单GPU和多GPU训练，使用LoRA等高效微调技术可将硬件成本降低高达90%，并在短时间内完成模型训练	github
GPT4All	一个允许在Macbook本地运行GPT的开源项目。基于LLaMa-7B大语言模型打造，包括数据、代码和demo都是开源的，对话风格偏向AI助理	github
用Alpaca-LoRA微调ChatGPT类模型	link
LMFlow	可扩展、方便有效的工具箱，用于微调大型机器学习模型	github
闻达：大型语言模型调用平台	目前支持chatGLM-6B、chatRWKV、chatYuan和chatGLM-6B模型下的chatPDF（自建知识库查找）’	github
Micro Agent	小型自主智能体开源项目，由LLM(OpenAI GPT-4)提供动力，可以为你编写软件，只需设置一个“目的”，让它自己工作	github
Llama-X	开源的学术研究项目，通过社区共同努力，逐步将LLaMA的性能提高到SOTA LLM水平，节省重复工作，共同创造更多、更快的增量	github
Chinese-LLaMA-Alpaca	中文LLaMA&Alpaca大语言模型+本地部署 (Chinese LLaMA & Alpaca LLMs) – 开源了经过中文文本数据预训练的中文LLaMA大模型；开源了进一步经过指令精调的中文Alpaca大模型；快速地使用笔记本电脑（个人PC）本地部署和体验量化版大模型	github
Efficient Alpaca	基于LLaMA实现的开源项目，旨在通过微调 LLaMA-7B模型在资源消耗更少、推理速度更快、更适合研究者使用方面提高Stanford Alpaca的性能	github
ChatGLM-6B-Slim	裁减掉20K图片Token的ChatGLM-6B，完全一样的性能，占用更小的显存	github
Chinese-Vicuna	一个中文低资源的llama+lora方案	github
Alpaca-LoRA	用LoRA在消费级硬件上复现斯坦福Alpaca的结果	github
LLM Accelerator	让基础大模型更聪明的LLM Accelerator来了！基础大模型正在诸多应用中发挥着日益重要的作用。大多数大语言模型的训练都是采取自回归的方式进行生成，虽然自回归模型生成的文本质量有所保证，但却导致了高昂的推理成本和长时间的延迟。由于大模型的参数量巨大、推理成本高，因此如何在大规模部署大模型的过程中降低成本、减小延迟是一个关键课题。针对此问题，微软亚洲研究院的研究员们提出了一种使用参考文本无损加速大语言模型推理的方法 LLM Accelerator，在大模型典型的应用场景中可以取得两到三倍的加速。	blog
大语言模型（LLM）微调技术笔记	github
PyLLMs	简洁的 Python 库，用于连接各种 LLM(OpenAI、Anthropic、Google、AI21、Cohere、Aleph Alpha、HuggingfaceHub)，内置模型性能基准。非常适合快速原型设计和评估不同模型，具有以下特点：通过少量代码连接顶级 LLM；响应元数据包括处理的Token、成本和延迟，对各个模型进行标准化；支持多模型：同时从不同模型获取补全；LLM 基准：评估模型的质量、速度和成本	github
用混合精度加速大型语言模型	通过使用低精度浮点数运算，可以将训练和推断速度提升多达3倍，同时不影响模型准确性	blog
新的LLM训练方法 Federate	杜克大学和微软一起发布了一个新的LLM训练方法 Federated GPT，这个训练方法是将原本中心化的训练方法分散到不同的边缘设备里面（edge device），然后训练完成后，再上传到中心去将各子模型合并。	github

提示工程

资源名（Name）	描述（Description）	链接
OpenBuprompt-engineering-note	提示工程笔记(课程总结)》介绍了面向开发者的 ChatGPT Prompt Engineering Learning Notes 课程，该课程提供了语言模型的工作原理和提示工程实践，并展示了如何将语言模型 API 应用于各种任务的应用程序中。课程包括总结、推断、转换、扩展和打造聊天机器人等方面的内容，并讲述了如何设计好的提示和构建自定义聊天机器人。	github-OpenBuprompt
提示工程指南	link
AIGC提示工程学习站 Learn Prompt	ChatGPT/Midjourney/Runway	link
Prompts 精选 – ChatGPT 使用指南	ChatGPT 使用指南，提升 ChatGPT 可玩性和可用性	github
非官方的ChatGPT资源聚合列表，旨在汇总使用ChatGPT	旨在汇总使用ChatGPT的应用、Web应用、浏览器扩展、CLI工具、机器人、集成、软件包、文章等资源	github
Snack Prompt：ChatGPT Prompt提示分享社区	link
ChatGPT提问技巧	如何向 ChatGPT 提问以获得高质量答案：提示技巧工程完全指南	github
rompt-Engineering-Guide-Chinese – 提示工程师指南	源自英文版，但增加了AIGC的prompt部分	github
OpenPrompt	一个开放的共享Prompt社区，大家一起推荐好用的prompt	github
GPT-Prompts	教你如何用GPT生成Prompts	github

类ChatGPT的文档问答

资源名（Name）	描述（Description）	链接
privateGPT	基于GPT4All-J的私有化部署文档问答平台，无需联网，能100%保证用户的隐私不泄露。提供了一个API，用户可以使用自己的文档进行交互式问答和生成文本。此外，平台支持自定义训练数据和模型参数，以满足个性化需求	github-privateGPT
Auto-evaluator	文档问答的自动评估；、	github
PDF GP	一个基于 GPT 实现的开源 PDF 文档聊天方案,主要实现以下功能：跟 PDF 文档进行一对一对话；自动切割内容，并使用强大的深度平均网络编码器来生成嵌入；对 PDF 内容执行语义搜索，并将最相关的嵌入传递给 Open AI；自定义逻辑，生成更精确的响应信息，速度要比 OpenAI 的快。	github
Redis-LLM-Document-Chat	用LlamaIndex、Redis和OpenAI与PDF文档进行交互，包含一个Jupyter笔记本，演示了如何使用Redis作为向量数据库来存储和检索文档向量，还展示了如何使用LlamaIndex在文档中执行语义搜索，以及如何利用OpenAI提供类似聊天机器人的体验	github
doc-chatbot	GPT-4 + Pinecone + LangChain + MongoDB实现的文档聊天机器人，可多文件、多话题和多窗口聊天，聊天历史由MongoDB保存	github
document.ai	基于向量数据库与GPT3.5的通用本地知识库方案(A universal local knowledge base solution based on vector database and GPT3.5)	github
DocsGPT	DocsGPT是一种尖端的开源解决方案，可以简化在项目文档中查找信息的过程。通过集成强大的GPT模型，开发人员可以轻松地提出关于项目的问题并获得准确的答案。	github
ChatGPT Retrieval Plugin	ChatGPT检索插件存储库提供了一种灵活的解决方案，可以使用自然语言查询对个人或组织文档进行语义搜索和检索。	github
LamaIndex	lamaIndex（GPT索引）是您的LLM应用程序的数据框架。	github
chatWeb	ChatWeb可以爬取任意网页或PDF，DOCX，TXT文件并提取正文，可以生成嵌入式概要，可以根据正文内容回答你的问题。基于gpt3.5的chatAPI和embeddingAPI，以及向量数据库实现。	github

类ChatGPT的行业应用

资源名（Name）	描述（Description）	链接
新闻报道进行情感分析	用ChatGPT通过对上市公司的新闻报道进行情感分析，在15个月时间内在股票市场(交易期权)产生了500%的回报（在历史数据中测试得出的结果）——探讨了ChatGPT在利用新闻标题的情感分析来预测股市回报方面的潜力。发现ChatGPT的情感分析能力超过了传统的方法，并且与股市回报呈正相关。提出ChatGPT在金融经济领域有很大的价值，并对未来的研究和应用提出了一些启示和建议	paper
编程语言生成模型 StarCoder	BigCode是 ServiceNow Inc. 和 Hugging Face Inc. 合作成立的。StarCoder 有多个版本。核心版本 StarCoderBase 具有 155 亿个参数，支持80多种编程语言，8192个token的上下文。视频为其vscode插件效果	github
CodeGen2: Lessons for Training LLMs on Programming and Natural Languages	code generation	paper
MedicalGPT-zh：中文医疗通用语言模型	中文医疗通用语言模型，基于28个科室的医疗共识与临床指南文本，提高模型的医疗领域知识与对话能力	github
MagicSlides	不少人梦寐以求的AI自作PPT，免费版每月能做3个PPT，支持2500字输入	link
SalesGPT	使用LLM实现上下文感知的销售助手，可自动化销售拓展代表的活动，如外呼销售电话	github
华驼(HuaTuo): 基于中文医学知识的LLaMA微调模型	github
ai-code-translator	帮助你把代码从一种语言翻译成另一种语言，这事对ChatGPT来说简直太擅长了，尤其是GPT-4，翻译质量相当高，而且tokens长度也可以更长。	github
ChatGenTitle	使用百万arXiv论文信息在LLaMA模型上进行微调的论文题目生成模型	github
Regex.ai	一款所见即所得的，基于 AI 的正则表达式自动生成工具，只需要选择出数据，它就能帮你写正则表达式，并提供多种提取数据的方式	video
ChatDoctor	一个基于医学领域知识微调LLaMA的医学聊天模型，其中医学数据包含大约700种疾病的数据、以及大约5000段医生和病人的对话记录	paper
CodeGPT	提高编程能力的关键在于数据。CodeGPT是通过GPT生成的用于GPT的代码对话数据集。现在公开了32K条中文数据，让模型更擅长编程	github
LaWGPT	一系列基于中文法律知识的开源大语言模型	github
LangChain-ChatGLM-Webui	受langchain-ChatGLM启发, 利用LangChain和ChatGLM-6B系列模型制作的Webui, 提供基于本地知识的大模型应用.目前支持上传 txt、docx、md、pdf等文本格式文件, 提供包括ChatGLM-6B系列、Belle系列等模型文件以及GanymedeNil/text2vec-large-chinese、nghuyong/ernie-3.0-base-zh、nghuyong/ernie-3.0-nano-zh等Embedding模型.	github

类ChatGPT的课程资料

资源名（Name）	描述（Description）	链接
Databricks	（Dolly模型的作者）在edX发布了两个免费课程程，其中第二个是关于LLM是如何构建的。	link
大语言模型技术分享系列	东北大学自然语言处理实验室	video
GPT-4是如何工作的？如何利用GPT-4打造智能程序？	哈佛大学CS50公开课	video
提示工程最佳实践：Andrew Ng 提示工程新课摘要+LangChain经验总结	medium_blog
微调LLM模型	如果你对微调LLM模型感兴趣，一定要关注这个油管博主，他把几乎世面上所有的LLM模型都公开了微调的方法。	油管博主 Sam Witteveen
Transformer的架构解读	通俗易懂的介绍	youtube1 youtube2 youtube3
Transformer multi head机制的视频	如果想要真正理解整个Transform的每一个细节，包括里面的数学原理，可以看一下这个视频，真的是剖析地非常详细	youtube
Introduction to Large Language Models	大语言模型介绍	介绍了大型语言模型（Large Language Models，LLMs）的概念、使用场景、提示调整以及Google的Gen AI开发工具。

LLM的安全问题

资源名（Name）	描述（Description）	链接
LLM模型安全研究	link
Chatbot Injections & Exploit	收集了一些Chatbot注入和漏洞的例子，以帮助人们了解Chatbot的潜在漏洞和脆弱性。注入和攻击的方式包括命令注入、字符编码、社交工程、表情符号、Unicode等。仓库提供了一些示例，其中一些包括可用于攻击Chatbot的表情符号列表	github
GPTSecurity	一个涵盖了前沿学术研究和实践经验分享的社区，集成了生成预训练 Transformer（GPT）、人工智能生成内容（AIGC）以及大型语言模型（LLM）等安全领域应用的知识。在这里，您可以找到关于GPT/AIGC/LLM最新的研究论文、博客文章、实用的工具和预设指令（Prompts）。	github

多模态LLM

资源名（Name）	描述（Description）	链接
DeepFloyd IF	高度逼真且具有语言理解能力的最新开源文本到图像模型，由一个冻结文本编码器和三个连续的像素扩散模块组成，是一个高效的模型，性超越了当前最先进的模型，在COCO数据集上实现了零样本的FID得分为6.66	github
Multi-modal GPT	用多模态GPT训练一个能同时接收视觉和语言指令的聊天机器人。基于OpenFlamingo多模态模型，使用各种开放数据集创建各种视觉指导数据，联合训练视觉和语言指导，有效提高模型性能	github
AudioGPT	Understanding and Generating Speech, Music, Sound, and Talking Head’ by AIGC-Audio	github
text2image-prompt-generator	基于GPT-2用25万条Midjourney的promps训练出来的小模型，可以生成高质量的Midjourney prompt	link data
汇总6个Midjourney以外的免费以文生图服务：	Bing Image Creator Playground AI DreamStudio Pixlr Leonardo AI Craiyon
BARK	一个非常强大的TTS（文字转语音）项目，这个项目的特点是，它可以在文字中加入提示词，比如“大笑”。这个提示词会变成笑的声音，然后合成到语音里去。它也可以混合“男声”，“女声”，这样再做就可以不用再做拼接操作了	github
whisper	在语音转文字（STT，也称ASR）方面，whisper是我用过的最好的，最快的库。没想到，这么快的模型，还能70x的优化空间。我准备部署这个模型，并开放给大家使用，可以用来转录大的语音文件，和进行翻译。这个模型是多语言的，而且能自动识别是什么语言，真的非常强大	github
OFA-Chinese：中文多模态统一预训练模型	transformers结构的中文OFA模型	github
文生图开源模型试炼场	可根据输入文字同时用stable-diffusion 1.5、stable-diffusion 2.1、DALL-E、kandinsky-2等模型生成图像，方便测试比较	link
LLMScore	LLMScore是一种全新的框架，能够提供具有多粒度组合性的评估分数。它使用大语言模型（LLM）来评估文本到图像生成模型。首先，将图像转化为图像级别和对象级别的视觉描述，然后将评估指令输入到LLM中，以衡量合成图像与文本的对齐程度，并最终生成一个评分和解释。我们的大量分析显示，LLMScore在众多数据集上与人类判断的相关性最高，明显优于常用的文本-图像匹配度量指标CLIP和BLIP。	paper github
VisualGLM-6B	VisualGLM-6B 是一个开源的，支持图像、中文和英文的多模态对话语言模型，语言模型基于 ChatGLM-6B，具有 62 亿参数；图像部分通过训练 BLIP2-Qformer 构建起视觉模型与语言模型的桥梁，整体模型共78亿参数。	github

LLM的数据集

资源名（Name）	描述（Description）	链接
歧义数据集	能否正确的消除歧义是衡量大语言模型的一个重要指标。不过一直没有一个标准化的衡量方法，这篇论文提出了一个包含1,645个具有不同种类歧义的数据集及对应的评估方法。	github paper
thu指令训练数据	设计了一套流程来自动产生多样化高质量的多轮指令对话数据UltraChat，并进行了细致的人工后处理。现已将英文数据全部开源，共计150余万条，是开源社区数量最多的高质量指令数据之一	github
多模态数据集MMC4	5.8亿图片，1亿文档，400亿token	github
EleutherAI 数据	800g的文本语料给你整合好了免费下载，不知道trian出来的model质量如何，打算试试：	pile data paper
UltraChat	大规模、信息丰富、多样化的多轮对话数据	github
ConvFinQA金融数据问答	github
The botbots dataset	一个包含对话内容的数据集，对话内容来自于两个ChatGPT实例(gpt-3.5-turbo)，CLT命令和对话提示来自GPT-4，覆盖多种情境和任务，生成成本约为35美元，可用于研究和训练更小的对话模型(如Alpaca)	github
alpaca_chinese_dataset – 人工精调的中文对话数据集	github
CodeGPT-data	提高编程能力的关键在于数据。CodeGPT是通过GPT生成的用于GPT的代码对话数据集。现在公开了32K条中文数据，让模型更擅长编程	github

语料库

资源名（Name）	描述（Description）	链接
人名语料库	wainshine/Chinese-Names-Corpus
Chinese-Word-Vectors	各种中文词向量	github repo
中文聊天语料	该库搜集了包含豆瓣多轮, PTT八卦语料, 青云语料, 电视剧对白语料, 贴吧论坛回帖语料,微博语料,小黄鸡语料	link
中文谣言数据	该数据文件中，每一行为一条json格式的谣言数据	github
中文问答数据集	链接提取码 2dva
微信公众号语料	3G语料，包含部分网络抓取的微信公众号的文章，已经去除HTML，只包含了纯文本。每行一篇，是JSON格式，name是微信公众号名字，account是微信公众号ID，title是题目，content是正文	github
中文自然语言处理语料、数据集	github
任务型对话英文数据集	【最全任务型对话数据集】主要介绍了一份任务型对话数据集大全，这份数据集大全涵盖了到目前在任务型对话领域的所有常用数据集的主要信息。此外，为了帮助研究者更好的把握领域进展的脉络，我们以Leaderboard的形式给出了几个数据集上的State-of-the-art实验结果。	github
语音识别语料生成工具	从具有音频/字幕的在线视频创建自动语音识别(ASR)语料库	github
LitBankNLP数据集	支持自然语言处理和计算人文学科任务的100部带标记英文小说语料	github
中文ULMFiT	情感分析文本分类语料及模型	github
省市区镇行政区划数据带拼音标注	github
教育行业新闻自动文摘语料库	github
中文自然语言处理数据集	github
维基大规模平行文本语料	85种语言、1620种语言对、135M对照句	github
古诗词库	github repo 更全的古诗词库
低内存加载维基百科数据	用新版nlp库加载17GB+英文维基语料只占用9MB内存遍历速度2-3 Gbit/s	github
对联数据	700,000 couplets, 超过70万对对联	github
《配色辞典》数据集	github
42GB的JD客服对话数据(CSDD)	github
70万对联数据	link
用户名黑名单列表	github
依存句法分析语料	4万句高质量标注数据	Homepage
人民日报语料处理工具集	github
虚假新闻数据集 fake news corpus	github
诗歌质量评价/细粒度情感诗歌语料库	github
中文自然语言处理相关的开放任务	数据集以及当前最佳结果	github
中文缩写数据集	github
中文任务基准测评	代表性的数据集-基准(预训练)模型-语料库-baseline-工具包-排行榜	github
中文谣言数据库	github
CLUEDatasetSearch	中英文NLP数据集搜索所有中文NLP数据集，附常用英文NLP数据集	github
多文档摘要数据集	github
让人人都变得“彬彬有礼”礼貌迁移任务	在保留意义的同时将非礼貌语句转换为礼貌语句，提供包含139M + 实例的数据集	paper and code
粤语/英语会话双语语料库	github
中文NLP数据集列表	github
类人名/地名/组织机构名的命名体识别数据集	github
中文语言理解测评基准	包括代表性的数据集&基准模型&语料库&排行榜	github
OpenCLaP多领域开源中文预训练语言模型仓库	民事文书、刑事文书、百度百科	github
中文全词覆盖BERT及两份阅读理解数据	DRCD数据集：由中国台湾台达研究院发布，其形式与SQuAD相同，是基于繁体中文的抽取式阅读理解数据集。 CMRC 2018数据集:哈工大讯飞联合实验室发布的中文机器阅读理解数据。根据给定问题，系统需要从篇章中抽取出片段作为答案，形式与SQuAD相同。	github
Dakshina数据集	十二种南亚语言的拉丁/本地文字平行数据集合	github
OPUS-100	以英文为中心的多语(100种)平行语料	github
中文阅读理解数据集	github
中文自然语言处理向量合集	github
中文语言理解测评基准	包括代表性的数据集、基准(预训练)模型、语料库、排行榜	github
NLP数据集/基准任务大列表	github
LitBankNLP数据集	支持自然语言处理和计算人文学科任务的100部带标记英文小说语料	github
70万对联数据	github
文言文（古文）-现代文平行语料	短篇章中包括了《论语》、《孟子》、《左传》等篇幅较短的古籍，已和《资治通鉴》合并	github
COLDDateset，中文冒犯性语言检测数据集	涵盖了种族、性别和地区等话题内容，数据待论文发表后放出	paper
GAOKAO-bench：以中国高考题目作为数据集	以中国高考题目作为数据集，评估大语言模型的语言理解能力和逻辑推理能力的测评框架，包含1781道选择题、218道填空题和812道解答题	github
zero to nlp – 中文nlp应用数据、模型、训练、推理	github

词库及词法工具

资源名（Name）	描述（Description）	链接
textfilter	中英文敏感词过滤	observerss/textfilter
人名抽取功能	中文（现代、古代）名字、日文名字、中文的姓和名、称呼（大姨妈、小姨妈等）、英文->中文名字（李约翰）、成语词典	cocoNLP
中文缩写库	全国人大: 全国人民代表大会; 中国: 中华人民共和国;女网赛: 女子/n 网球/n 比赛/vn	github
汉语拆字词典	漢字拆法 (一) 拆法 (二) 拆法 (三) 拆手斥扌斥才斥	kfcd/chaizi
词汇情感值	山泉水:0.400704566541 充沛: 0.37006739587	rainarch/SentiBridge
中文词库、停用词、敏感词	dongxiexidian/Chinese
python-pinyin	汉字转拼音	mozillazg/python-pinyin
zhtools	中文繁简体互转	skydark/nstools
英文模拟中文发音引擎	say wo i ni #说：我爱你	tinyfool/ChineseWithEnglish
chinese_dictionary	同义词库、反义词库、否定词库	guotong1988/chinese_dictionary
wordninja	无空格英文串分割、抽取单词	wordninja
汽车品牌、汽车零件相关词汇	data
THU整理的词库	IT词库、财经词库、成语词库、地名词库、历史名人词库、诗词词库、医学词库、饮食词库、法律词库、汽车词库、动物词库	link
罪名法务名词及分类模型	包含856项罪名知识图谱, 基于280万罪名训练库的罪名预测,基于20W法务问答对的13类问题分类与法律资讯问答功能	github
分词语料库+代码	百度网盘链接 – 提取码 pea6
基于Bi-LSTM + CRF的中文分词+词性标注	keras实现	link
基于Universal Transformer + CRF 的中文分词和词性标注	link
快速神经网络分词包	java version
chinese-xinhua	中华新华字典数据库及api，包括常用歇后语、成语、词语和汉字	github
SpaCy 中文模型	包含Parser, NER, 语法树等功能。有一些英文package使用spacy的英文模型的，如果要适配中文，可能需要使用spacy中文模型。	github
中文字符数据	github
Synonyms中文近义词工具包	github
HarvestText	领域自适应文本挖掘工具（新词发现-情感分析-实体链接等）	github
word2word	方便易用的多语言词-词对集62种语言/3,564个多语言对	github
多音字词典数据及代码	github
汉字、词语、成语查询接口	github
103976个英语单词库包	（sql版，csv版，Excel版）	github
英文脏话大列表	github
词语拼音数据	github
186种语言的数字叫法库	github
世界各国大规模人名库	github
汉字字符特征提取器 (featurizer)	提取汉字的特征（发音特征、字形特征）用做深度学习的特征	github
char_featurizer – 汉字字符特征提取工具	github
中日韩分词库mecab的Python接口库	github
g2pC基于上下文的汉语读音自动标记模块	github
ssc, Sound Shape Code	音形码 – 基于“音形码”的中文字符串相似度计算方法	version 1 version 2 blog/introduction
基于百科知识库的中文词语多词义/义项获取与特定句子词语语义消歧	github
Tokenizer快速、可定制的文本词条化库	github
Tokenizers	注重性能与多功能性的最先进分词器	github
通过同义词替换实现文本“变脸”	github
token2index与PyTorch/Tensorflow兼容的强大轻量词条索引库	github
繁简体转换	github
粤语NLP工具	github
领域词典库	涵盖68个领域、共计916万词的专业词典知识库	github

预训练语言模型&大模型

资源名（Name）	描述（Description）	链接
BMList	大模型大列表	github
bert论文中文翻译	link
bert原作者的slides	link
文本分类实践	github
bert tutorial文本分类教程	github
bert pytorch实现	github
bert pytorch实现	github
BERT生成句向量，BERT做文本分类、文本相似度计算	github
bert、ELMO的图解	github
BERT Pre-trained models and downstream applications	github
语言/知识表示工具BERT & ERNIE	github
Kashgari中使用gpt-2语言模型	github
Facebook LAMA	用于分析预训练语言模型中包含的事实和常识知识的探针。语言模型分析，提供Transformer-XL/BERT/ELMo/GPT预训练语言模型的统一访问接口	github
中文的GPT2训练代码	github
XLMFacebook的跨语言预训练语言模型	github
海量中文预训练ALBERT模型	github
Transformers 20	支持TensorFlow 20 和 PyTorch 的自然语言处理预训练语言模型(BERT, GPT-2, RoBERTa, XLM, DistilBert, XLNet…) 8种架构/33种预训练模型/102种语言	github
8篇论文梳理BERT相关模型进展与反思	github
法文RoBERTa预训练语言模型	用138GB语料训练的法文RoBERTa预训练语言模型	link
中文预训练 ELECTREA 模型	基于对抗学习 pretrain Chinese Model	github
albert-chinese-ner	用预训练语言模型ALBERT做中文NER	github
开源预训练语言模型合集	github
中文ELECTRA预训练模型	github
用Transformers(BERT, XLNet, Bart, Electra, Roberta, XLM-Roberta)预测下一个词(模型比较)	github
TensorFlow Hub	40+种语言的新语言模型(包括中文)	link
UER	基于不同语料、编码器、目标任务的中文预训练模型仓库（包括BERT、GPT、ELMO等）	github
开源预训练语言模型合集	github
多语言句向量包	github
Language Model as a Service (LMaaS)	语言模型即服务	github
开源语言模型GPT-NeoX-20B	200亿参数，是目前最大的可公开访问的预训练通用自回归语言模型	github
中文科学文献数据集（CSL）	包含 396,209 篇中文核心期刊论文元信息（标题、摘要、关键词、学科、门类）。CSL 数据集可以作为预训练语料，也可以构建许多NLP任务，例如文本摘要（标题预测）、关键词生成和文本分类等。	github
大模型开发神器	github

抽取

资源名（Name）	描述（Description）	链接
时间抽取	已集成到 python package cocoNLP中，欢迎试用	java version python version
神经网络关系抽取 pytorch	暂不支持中文	github
基于bert的命名实体识别 pytorch	暂不支持中文	github
关键词(Keyphrase)抽取包 pke	github
BLINK最先进的实体链接库	github
BERT/CRF实现的命名实体识别	github
支持批并行的LatticeLSTM中文命名实体识别	github
构建医疗实体识别的模型	包含词典和语料标注，基于python	github
基于TensorFlow和BERT的管道式实体及关系抽取	– Entity and Relation Extraction Based on TensorFlow and BERT 基于TensorFlow和BERT的管道式实体及关系抽取，2019语言与智能技术竞赛信息抽取任务解决方案。Schema based Knowledge Extraction, SKE 2019	github
中文命名实体识别NeuroNER vs BertNER	github
基于BERT的中文命名实体识别	github
中文关键短语抽取工具	github
bert	用于中文命名实体识别 tensorflow版本	github
bert-Kashgari	基于 keras 的封装分类标注框架 Kashgari，几分钟即可搭建一个分类或者序列标注模型	github
cocoNLP	人名、地址、邮箱、手机号、手机归属地等信息的抽取，rake短语抽取算法。	github
Microsoft多语言数字/单位/如日期时间识别包	github
百度开源的基准信息抽取系统	github
中文地址分词（地址元素识别与抽取），通过序列标注进行NER	github
基于依存句法的开放域文本知识三元组抽取和知识库构建	github
基于预训练模型的中文关键词抽取方法	github
chinese_keyphrase_extractor (CKPE)	A tool for chinese keyphrase extraction 一个快速从自然语言文本中提取和识别关键短语的工具	github
简单的简历解析器，用来从简历中提取关键信息	github
BERT-NER-Pytorch三种不同模式的BERT中文NER实验	github

知识图谱

资源名（Name）	描述（Description）	链接
清华大学XLORE中英文跨语言百科知识图谱	百度、中文维基、英文维基	link
文档图谱自动生成	github
基于医疗领域知识图谱的问答系统	github 该repo参考了github
中文人物关系知识图谱项目	github
AmpliGraph 知识图谱表示学习(Python)库知识图谱概念链接预测	github
中文知识图谱资料、数据及工具	github
基于百度百科的中文知识图谱	抽取三元组信息，构建中文知识图谱	github
Zincbase 知识图谱构建工具包	github
基于知识图谱的问答系统	github
知识图谱深度学习相关资料整理	github
东南大学《知识图谱》研究生课程(资料)	github
知识图谱车音工作项目	github
《海贼王》知识图谱	github
132个知识图谱的数据集	涵盖常识、城市、金融、农业、地理、气象、社交、物联网、医疗、娱乐、生活、商业、出行、科教	link
大规模、结构化、中英文双语的新冠知识图谱(COKG-19)	link
基于依存句法与语义角色标注的事件三元组抽取	github
抽象知识图谱	目前规模50万，支持名词性实体、状态性描述、事件性动作进行抽象	github
大规模中文知识图谱数据14亿实体	github
Jiagu自然语言处理工具	以BiLSTM等模型为基础，提供知识图谱关系抽取中文分词词性标注命名实体识别情感分析新词发现关键词文本摘要文本聚类等功能	github
medical_NER – 中文医学知识图谱命名实体识别	github
知识图谱相关学习资料/数据集/工具资源大列表	github
LibKGE面向可复现研究的知识图谱嵌入库	github
基于mongodb存储的军事领域知识图谱问答项目	包括飞行器、太空装备等8大类，100余小类，共计5800项的军事武器知识库，该项目不使用图数据库进行存储，通过jieba进行问句解析，问句实体项识别，基于查询模板完成多类问题的查询，主要是提供一种工业界的问答思想demo。	github
京东商品知识图谱	github
基于远监督的中文关系抽取	github
基于医药知识图谱的智能问答系统	github
BLINK最先进的实体链接库	github
一个小型的证券知识图谱/知识库	github
dstlr非结构化文本可扩展知识图谱构建平台	github
百度百科人物词条属性抽取	用基于BERT的微调和特征提取方法来进行知识图谱	github
新冠肺炎相关数据	新冠及其他类型肺炎中文医疗对话数据集；清华大学等机构的开放数据源（COVID-19）	github github
DGL-KE 图嵌入表示学习算法	github
因果关系图谱	method data
基于多领域文本数据集的因果事件对	link

文本生成

资源名（Name）	描述（Description）	链接
Texar	Toolkit for Text Generation and Beyond	github
Ehud Reiter教授的博客	link 北大万小军教授强力推荐，该博客对NLG技术、评价与应用进行了深入的探讨与反思。
文本生成相关资源大列表	github
开放域对话生成及在微软小冰中的实践	自然语言生成让机器掌握自动创作的本领	link
文本生成控制	github
自然语言生成相关资源大列表	github
用BLEURT评价自然语言生成	link
自动对联数据及机器人	代码 link 70万对联数据
自动生成评论	用Transformer编解码模型实现的根据Hacker News文章标题生成评论	github
自然语言生成SQL语句（英文）	github
自然语言生成资源大全	github
中文生成任务基准测评	github
基于GPT2的特定主题文本生成/文本增广	github
编码、标记和实现一种可控高效的文本生成方法	github
TextFooler针对文本分类/推理的对抗文本生成模块	github
SimBERT	基于UniLM思想、融检索与生成于一体的BERT模型	github
新词生成及造句	不存在的词用GPT-2变体从头生成新词及其定义、例句	github
由文本自动生成多项选择题	github
合成数据生成基准	github

文本摘要

资源名（Name）	描述（Description）	链接
中文文本摘要/关键词提取	github
基于命名实体识别的简历自动摘要	github
文本自动摘要库TextTeaser	仅支持英文	github
基于BERT等最新语言模型的抽取式摘要提取	github
Python利用深度学习进行文本摘要的综合指南	link
(Colab)抽象文本摘要实现集锦(教程	github

智能问答

资源名（Name）	描述（Description）	链接
中文聊天机器人	根据自己的语料训练出自己想要的聊天机器人，可以用于智能客服、在线问答、智能聊天等场景	github
有趣的情趣robot qingyun	qingyun 训练出来的中文聊天机器人	github
开放了对话机器人、知识图谱、语义理解、自然语言处理工具及数据	github
qa对的机器人	Amodel-for-Retrivalchatbot – 客服机器人，Chinese Retreival chatbot（中文检索式机器人）	git
ConvLab开源多域端到端对话系统平台	github
基于最新版本rasa搭建的对话系统	github
基于金融-司法领域(兼有闲聊性质)的聊天机器人	github
端到端的封闭域对话系统	github
MiningZhiDaoQACorpus	580万百度知道问答数据挖掘项目，百度知道问答语料库，包括超过580万的问题，每个问题带有问题标签。基于该问答语料库，可支持多种应用，如逻辑挖掘	github
用于中文闲聊的GPT2模型GPT2-chitchat	github
基于检索聊天机器人多轮响应选择相关资源列表(Leaderboards、Datasets、Papers)	github
微软对话机器人框架	github
chatbot-list	行业内关于智能客服、聊天机器人的应用和架构、算法分享和介绍	github
Chinese medical dialogue data 中文医疗对话数据集	github
一个大规模医疗对话数据集	包含110万医学咨询，400万条医患对话	github
大规模跨领域中文任务导向多轮对话数据集及模型CrossWOZ	paper & data
开源对话式信息搜索平台	github
情境互动多模态对话挑战2020(DSTC9 2020)	github
用Quora问题对训练的T5问题意译(Paraphrase)	github
Google发布Taskmaster-2自然语言任务对话数据集	github
Haystack灵活、强大的可扩展问答(QA)框架	github
端到端的封闭域对话系统	github
Amazon发布基于知识的人-人开放领域对话数据集	github
基于百度webqa与dureader数据集训练的Albert Large QA模型	github
CommonsenseQA面向常识的英文QA挑战	link
MedQuAD(英文)医学问答数据集	github
基于Albert、Electra，用维基百科文本作为上下文的问答引擎	github
基于14W歌曲知识库的问答尝试	功能包括歌词接龙，已知歌词找歌曲以及歌曲歌手歌词三角关系的问答	github

文本纠错

资源名（Name）	描述（Description）	链接
中文文本纠错模块代码	github
英文拼写检查库	github
python拼写检查库	github
GitHub Typo Corpus大规模GitHub多语言拼写错误/语法错误数据集	github
BertPunc基于BERT的最先进标点修复模型	github
中文写作校对工具	github
文本纠错文献列表	Chinese Spell Checking (CSC) and Grammatical Error Correction (GEC)	github
文本智能校对大赛冠军方案	已落地应用，来自苏州大学、达摩院团队	link

多模态

资源名（Name）	描述（Description）	链接
中文多模态数据集「悟空」	华为诺亚方舟实验室开源大型，包含1亿图文对	github
中文图文表征预训练模型Chinese-CLIP	中文版本CLIP预训练模型，开源多个模型规模，几行代码搞定中文图文表征提取 & 图文检索	github

语音处理

资源名（Name）	描述（Description）	链接
ASR 语音数据集 + 基于深度学习的中文语音识别系统	github
清华大学THCHS30中文语音数据集	data_thchs30tgz-OpenSLR国内镜像 data_thchs30tgz test-noisetgz-OpenSLR国内镜像 test-noisetgz resourcetgz-OpenSLR国内镜像 resourcetgz Free ST Chinese Mandarin Corpus Free ST Chinese Mandarin Corpus AIShell-1 开源版数据集-OpenSLR国内镜像 AIShell-1 开源版数据集 Primewords Chinese Corpus Set 1-OpenSLR国内镜像 Primewords Chinese Corpus Set 1
笑声检测器	github
Common Voice语音识别数据集新版	包括来自42,000名贡献者超过1,400小时的语音样本，涵github	link
speech-aligner	从“人声语音”及其“语言文本”，产生音素级别时间对齐标注的工具	github
ASR语音大辞典/词典	github
语音情感分析	github
masr	中文语音识别，提供预训练模型，高识别率	github
面向语音识别的中文文本规范化	github
语音质量评价指标(MOSNet, BSSEval, STOI, PESQ, SRMR)	github
面向语音识别的中文/英文发音辞典	github
CoVoSTFacebook发布的多语种语音-文本翻译语料库	包括11种语言(法语、德语、荷兰语、俄语、西班牙语、意大利语、土耳其语、波斯语、瑞典语、蒙古语和中文)的语音、文字转录及英文译文	github
Parakeet基于PaddlePaddle的文本-语音合成	github
(Java)准确的语音自然语言检测库	github
CoVoSTFacebook发布的多语种语音-文本翻译语料库	github
TensorFlow 2 实现的文本语音合成	github
Python音频特征提取包	github
ViSQOL音频质量感知客观、完整参考指标，分音频、语音两种模式	github
zhrtvc	好用的中文语音克隆兼中文语音合成系统	github
aukit	好用的语音处理工具箱，包含语音降噪、音频格式转换、特征频谱生成等模块	github
phkit	好用的音素处理工具箱，包含中文音素、英文音素、文本转拼音、文本正则化等模块	github
zhvoice	中文语音语料，语音更加清晰自然，包含8个开源数据集，3200个说话人，900小时语音，1300万字	github
audio面向语音行为检测	、二值化、说话人识别、自动语音识别、情感识别等任务的音频标注工具	github
深度学习情感文本语音合成	github
Python音频数据增广库	github
基于大规模音频数据集Audioset的音频增强	github
语声迁移	github

文档处理

资源名（Name）	描述（Description）	链接
LayoutLM-v3文档理解模型	github
PyLaia面向手写文档分析的深度学习工具包	github
单文档非监督的关键词抽取	github
DocSearch免费文档搜索引擎	github
fdfgen	能够自动创建pdf文档，并填写信息	link
pdfx	自动抽取出引用参考文献，并下载对应的pdf文件	link
invoice2data	发票pdf信息抽取	invoice2data
pdf文档信息抽取	github
PDFMiner	PDFMiner能获取页面中文本的准确位置，以及字体或行等其他信息。它还有一个PDF转换器，可以将PDF文件转换成其他文本格式(如HTML)。还有一个可扩展的解析器PDF，可以用于文本分析以外的其他用途。	link
PyPDF2	PyPDF 2是一个python PDF库，能够分割、合并、裁剪和转换PDF文件的页面。它还可以向PDF文件中添加自定义数据、查看选项和密码。它可以从PDF检索文本和元数据，还可以将整个文件合并在一起。	link
PyPDF2	PyPDF 2是一个python PDF库，能够分割、合并、裁剪和转换PDF文件的页面。它还可以向PDF文件中添加自定义数据、查看选项和密码。它可以从PDF检索文本和元数据，还可以将整个文件合并在一起。	link
ReportLab	ReportLab能快速创建PDF 文档。经过时间证明的、超好用的开源项目，用于创建复杂的、数据驱动的PDF文档和自定义矢量图形。它是免费的，开源的，用Python编写的。该软件包每月下载5万多次，是标准Linux发行版的一部分，嵌入到许多产品中，并被选中为Wikipedia的打印/导出功能提供动力。	link
SIMPdfPython写的简单PDF文件文字编辑器	github
pdf-diff	PDF文件diff工具可显示两个pdf文档的差别	github

表格处理

资源名（Name）	描述（Description）	链接
用unet实现对文档表格的自动检测，表格重建	github
pdftabextract	用于OCR识别后的表格信息解析，很强大	link
tabula-py	直接将pdf中的表格信息转换为pandas的dataframe，有java和python两种版本代码
camelot	pdf表格解析	link
pdfplumber	pdf表格解析
PubLayNet	能够划分段落、识别表格、图片	link
从论文中提取表格数据	github
用BERT在表格中寻找答案	github
表格问答的系列文章	简介模型完结篇
使用GAN生成表格数据（仅支持英文）	github
carefree-learn(PyTorch)	表格数据集自动化机器学习(AutoML)包	github
封闭域微调表格检测	github
PDF表格数据提取工具	github
TaBERT理解表格数据查询的新模型	paper
表格处理	Awesome-Table-Recognition	github

文本匹配

资源名（Name）	描述（Description）	链接
句子、QA相似度匹配MatchZoo	文本相似度匹配算法的集合，包含多个深度学习的方法，值得尝试。	github
中文问题句子相似度计算比赛及方案汇总	github
similarity相似度计算工具包	java编写,用于词语、短语、句子、词法分析、情感分析、语义分析等相关的相似度计算	github
中文词语相似度计算方法	综合了同义词词林扩展版与知网（Hownet）的词语相似度计算方法，词汇覆盖更多、结果更准确。	gihtub
Python字符串相似性算法库	github
基于Siamese bilstm模型的相似句子判定模型,提供训练数据集和测试数据集	提供了10万个训练样本	github

文本数据增强

资源名（Name）	描述（Description）	链接
中文NLP数据增强（EDA）工具	github
英文NLP数据增强工具	github
一键中文数据增强工具	github
数据增强在机器翻译及其他nlp任务中的应用及效果	link
NLP数据增广资源集	github

常用正则表达式

资源名（Name）	描述（Description）	链接
抽取email的正则表达式	已集成到 python package cocoNLP中，欢迎试用
抽取phone_number	已集成到 python package cocoNLP中，欢迎试用
抽取身份证号的正则表达式	IDCards_pattern = r’^([1-9]\d{5}[12]\d{3}(0[1-9]\|1[012])(0[1-9]\|[12][0-9]\|3[01])\d{3}[0-9xX]) IDs = re.findall(IDCards_pattern, text, flags=0)
IP地址正则表达式	(25[0-5]\| 2[0-4]\d\| [0-1]\d{2}\| [1-9]?\d).(25[0-5]\| 2[0-4]\d\| [0-1]\d{2}\| [1-9]?\d).(25[0-5]\| 2[0-4]\d\| [0-1]\d{2}\| [1-9]?\d).(25[0-5]\| 2[0-4]\d\| [0-1]\d{2}\| [1-9]?\d)
腾讯QQ号正则表达式	[1-9]([0-9]{5,11})
国内固话号码正则表达式	[0-9-()（）]{7,18}
用户名正则表达式	[A-Za-z0-9_-\u4e00-\u9fa5]+
国内电话号码正则匹配（三大运营商+虚拟等）	github
正则表达式教程	github

文本检索

资源名（Name）	描述（Description）	链接
高效模糊搜索工具	github
面向各语种/任务的BERT模型大列表/搜索引擎	link
Deepmatch针对推荐、广告和搜索的深度匹配模型库	github
wwsearch是企业微信后台自研的全文检索引擎	github
aili – the fastest in-memory index in the East 东半球最快并发索引	github
高效的字符串匹配工具 RapidFuzz	a fast string matching library for Python and C++, which is using the string similarity calculations from FuzzyWuzzy	github

阅读理解

资源名（Name）	描述（Description）	链接
高效模糊搜索工具	github
面向各语种/任务的BERT模型大列表/搜索引擎	link
Deepmatch针对推荐、广告和搜索的深度匹配模型库	github
allennlp阅读理解支持多种数据和模	github

情感分析

资源名（Name）	描述（Description）	链接
方面情感分析包	github
awesome-nlp-sentiment-analysis	情感分析、情绪原因识别、评价对象和评价词抽取	github
情感分析技术让智能客服更懂人类情感	github

事件抽取

资源名（Name）	描述（Description）	链接
中文事件抽取	github
NLP事件提取文献资源列表	github
PyTorch实现的BERT事件抽取(ACE 2005 corpus)	github
新闻事件线索抽取	github

机器翻译

资源名（Name）	描述（Description）	链接
无道词典	有道词典的命令行版本，支持英汉互查和在线查询	github
NLLB	支持200+种语言任意互译的语言模型NLLB	link
Easy-Translate	在本地翻译大文本文件的脚本，基于Facebook/Meta AI的 M2M100模型和NLLB200模型，支持200+种语言	github

数字转换

资源名（Name）	描述（Description）	链接
最好的汉字数字(中文数字)-阿拉伯数字转换工具	github
快速转化「中文数字」和「阿拉伯数字」	github
将自然语言数字串解析转换为整数和浮点数	github

指代消解

资源名（Name）	描述（Description）	链接
中文指代消解数据	github baidu ink code a0qq

文本聚类

资源名（Name）	描述（Description）	链接
TextCluster短文本聚类预处理模块 Short text cluster	github

文本分类

资源名（Name）	描述（Description）	链接
NeuralNLP-NeuralClassifier腾讯开源深度学习文本分类工具	github

知识推理

资源名（Name）	描述（Description）	链接
GraphbrainAI开源软件库和科研工具，目的是促进自动意义提取和文本理解以及知识的探索和推断	github
(哈佛)讲因果推理的免费书	pdf

可解释自然语言处理

资源名（Name）	描述（Description）	链接
文本机器学习模型最先进解释器库	github

文本攻击

资源名（Name）	描述（Description）	链接
TextAttack自然语言处理模型对抗性攻击框架	github
OpenBackdoor: 文本后门攻防工具包	OpenBackdoor基于Python和PyTorch开发，可用于复现、评估和开发文本后门攻防的相关算法	github

文本可视化

资源名（Name）	描述（Description）	链接
Scattertext 文本可视化(python)	github
whatlies词向量交互可视化	spacy工具
PySS3面向可解释AI的SS3文本分类器机器可视化工具	github
用记事本渲染3D图像	github
attnvisGPT2、BERT等transformer语言模型注意力交互可视化	github
Texthero文本数据高效处理包	包括预处理、关键词提取、命名实体识别、向量空间分析、文本可视化等	github

文本标注工具

资源名（Name）	描述（Description）	链接
NLP标注平台综述	github
brat rapid annotation tool 序列标注工具	link
Poplar网页版自然语言标注工具	github
LIDA轻量交互式对话标注工具	github
doccano基于网页的开源协同多语言文本标注工具	github
Datasaurai 在线数据标注工作流管理工具	link

语言检测

资源名（Name）	描述（Description）	链接
langid	97种语言检测	https://github.com/saffsd/langid.py
langdetect	语言检测	https://code.google.com/archive/p/language-detection/

综合工具

资源名（Name）	描述（Description）	链接
jieba	jieba
hanlp	hanlp
nlp4han	中文自然语言处理工具集(断句/分词/词性标注/组块/句法分析/语义分析/NER/N元语法/HMM/代词消解/情感分析/拼写检	github
仇恨言论检测进展	link
基于Pytorch的Bert应用	包括命名实体识别、情感分析、文本分类以及文本相似度等	github
nlp4han中文自然语言处理工具集	断句/分词/词性标注/组块/句法分析/语义分析/NER/N元语法/HMM/代词消解/情感分析/拼写检查	github
一些关于自然语言的基本模型	github
用BERT进行序列标记和文本分类的模板代码	github
jieba_fast 加速版的jieba	github
StanfordNLP	纯Python版自然语言处理包	link
Python口语自然语言处理工具集(英文)	github
PreNLP自然语言预处理库	github
nlp相关的一些论文及代码	包括主题模型、词向量(Word Embedding)、命名实体识别(NER)、文本分类(Text Classificatin)、文本生成(Text Generation)、文本相似性(Text Similarity)计算等，涉及到各种与nlp相关的算法，基于keras和tensorflow	github
Python文本挖掘/NLP实战示例	github
Forte灵活强大的自然语言处理pipeline工具集	github
stanza斯坦福团队NLP工具	可处理六十多种语言	github
Fancy-NLP用于建设商品画像的文本知识挖掘工具	github
全面简便的中文 NLP 工具包	github
工业界常用基于DSSM向量化召回pipeline复现	github
Texthero文本数据高效处理包	包括预处理、关键词提取、命名实体识别、向量空间分析、文本可视化等	github
nlpgnn图神经网络自然语言处理工具箱	github
Macadam	以Tensorflow(Keras)和bert4keras为基础，专注于文本分类、序列标注和关系抽取的自然语言处理工具包	github
LineFlow面向所有深度学习框架的NLP数据高效加载器	github
Arabica：Python文本数据探索性分析工具包	github
Python 压力测试工具：SMSBoom	github

有趣搞笑工具

资源名（Name）	描述（Description）	链接
汪峰歌词生成器	phunterlau/wangfeng-rnn
女友情感波动分析	github
NLP太难了系列	github
变量命名神器	github link
图片文字去除，可用于漫画翻译	github
CoupletAI – 对联生成	基于CNN+Bi-LSTM+Attention 的自动对对联系统	github
用神经网络符号推理求解复杂数学方程	github
基于14W歌曲知识库的问答机器人	功能包括歌词接龙，已知歌词找歌曲以及歌曲歌手歌词三角关系的问答	github
COPE – 格律诗编辑程序	github
Paper2GUI	一款面向普通人的AI桌面APP工具箱，免安装即开即用，已支持18+AI模型，内容涵盖语音合成、视频补帧、视频超分、目标检测、图片风格化、OCR识别等领域	github
礼貌程度估算器（使用新浪微博数据训练）	github paper
草蟒（Python 中文版）入门指南	中文编程语言	homepage gitee

课程报告面试等

资源名（Name）	描述（Description）	链接
自然语言处理报告	link
知识图谱报告	link
数据挖掘报告	link
自动驾驶报告	link
机器翻译报告	link
区块链报告	link
机器人报告	link
计算机图形学报告	link
3D打印报告	link
人脸识别报告	link
人工智能芯片报告	link
cs224n深度学习自然语言处理课程	link 课程中模型的pytorch实现 link
面向深度学习研究人员的自然语言处理实例教程	github
《Natural Language Processing》by Jacob Eisenstein	github
ML-NLP	机器学习(Machine Learning)、NLP面试中常考到的知识点和代码实现	github
NLP任务示例项目代码集	github
2019年NLP亮点回顾	download
nlp-recipes微软出品–自然语言处理最佳实践和范例	github
面向深度学习研究人员的自然语言处理实例教程	github
Transfer Learning in Natural Language Processing (NLP)	youtube
《机器学习系统》图书	link github

比赛

资源名（Name）	描述（Description）	链接
NLPer-Arsenal	NLP竞赛，含当前赛事信息、过往竞赛方案等，持续更新中	github
复盘所有NLP比赛的TOP方案	github
2019年百度的三元组抽取比赛，“科学空间队”源码(第7名)	github

金融自然语言处理

资源名（Name）	描述（Description）	链接
BDCI2019金融负面信息判定	github
开源的金融投资数据提取工具	github
金融领域自然语言处理研究资源大列表	github
基于金融-司法领域(兼有闲聊性质)的聊天机器人	github
小型金融知识图谱构流程示范	github

医疗自然语言处理

资源名（Name）	描述（Description）	链接
中文医学NLP公开资源整理	github
spaCy 医学文本挖掘与信息提取	github
构建医疗实体识别的模型	包含词典和语料标注，基于python	github
基于医疗领域知识图谱的问答系统	github 该repo参考了github
Chinese medical dialogue data 中文医疗对话数据集	github
一个大规模医疗对话数据集	包含110万医学咨询，400万条医患对话	github
新冠肺炎相关数据	新冠及其他类型肺炎中文医疗对话数据集；清华大学等机构的开放数据源（COVID-19）	github github

法律自然语言处理

资源名（Name）	描述（Description）	链接
Blackstone面向非结构化法律文本的spaCy pipeline和NLP模型	github
法务智能文献资源列表	github
基于金融-司法领域(兼有闲聊性质)的聊天机器人	github
罪名法务名词及分类模型	包含856项罪名知识图谱, 基于280万罪名训练库的罪名预测,基于20W法务问答对的13类问题分类与法律资讯问答功能	github
法律NLP相关资源大列表	github

文本生成图像

资源名（Name）	描述（Description）	链接
Dalle-mini	根据文本提示生成图片的迷你版DALL·E	github

其他

资源名（Name）	描述（Description）	链接
phone	中国手机归属地查询	ls0f/phone
phone	国际手机、电话归属地查询	AfterShip/phone
ngender	根据名字判断性别	observerss/ngender
中文对比英文自然语言处理NLP的区别综述	link
各大公司内部里大牛分享的技术文档 PDF 或者 PPT	github
comparxiv 用于比较arXiv上两提交版本差异的命令	pypi
CHAMELEON深度学习新闻推荐系统元架构	github
简历自动筛选系统	github
Python实现的多种文本可读性评价指标	github

作者 east

智能体 10月 5,2023

清华开源ChatGPT自动编程ChatDev项目phase.py代码解读

首先，在__init__方法中，初始化了Phase类的一些属性，包括：

assistant_role_name：接收对话的角色名称
user_role_name：开始对话的角色名称
phase_prompt：本阶段的提示内容
role_prompts：所有角色的提示内容
phase_name：本阶段的名称
model_type：模型类型
log_filepath：日志文件路径

然后，在chatting方法中，定义了处理对话并生成阶段总结的逻辑。该方法的参数包括：

chat_env：全局对话环境，用于员工检测（可以忽略）
task_prompt：建立软件的用户查询提示
assistant_role_name：接收对话的角色名称
user_role_name：开始对话的角色名称
phase_prompt：本阶段的提示内容
phase_name：本阶段的名称
assistant_role_prompt：助手角色的提示内容
user_role_prompt：用户角色的提示内容
task_type：任务类型
need_reflect：是否需要进行自我反思
with_task_specify：是否具有任务说明
model_type：模型类型
placeholders：用于生成阶段提示的占位符
chat_turn_limit：每次对话的最大轮数

在该方法中，首先检查必要的参数，并初始化角色扮演的会话role_play_session。

接下来，开始对话，并处理多轮对话。通过调用role_play_session.step方法进行助手和用户之间的交互，并记录对话细节。

然后，根据对话的结果判断是否生成了阶段总结。如果助手或用户的回复消息具有特殊的”<INFO>”标记，则将该回复作为阶段总结。否则，将助手最后的回复消息作为阶段总结。

解析self_reflection方法的作用和注释：

这个方法用于执行角色扮演会话的自省阶段。
参数列表：
- task_prompt：构建软件的用户查询提示
- role_play_session：需要自省的角色扮演会话
- phase_name：需要自省的聊天阶段的名称
- chat_env：全局聊天环境
返回值：
- reflected_content：字符串，自省结果
方法内部逻辑：
- 首先，通过比较用户和助手存储的消息数量，确定要用于自省的消息列表。
- 然后，将消息列表中的每条消息格式化为 “角色名: 内容” 的形式，并使用换行符连接起来。
- 根据不同的聊天阶段名称，设置相应的问题。
- 调用 self.chatting 方法执行聊天，得到自省结果。
- 最后，根据阶段名称返回相应的结果，如果是 “recruiting” 阶段，则根据结果回答 “Yes” 或 “No”。

接下来是两个抽象方法 update_phase_env 和 update_chat_env，这两个方法在这里只是简单的定义了函数体，需要在自定义的聊天阶段中实现具体逻辑。

最后是 execute 方法：

这个方法用于执行聊天阶段。
参数列表：
- chat_env：全局聊天环境
- chat_turn_limit：每个聊天中的轮次限制
- need_reflect：是否需要自省的标志
返回值：
- chat_env：使用本阶段执行结果更新的全局聊天环境
方法内部逻辑：
- 调用 update_phase_env 方法更新阶段环境。
- 调用 self.chatting 方法执行聊天，并将结果保存到 self.seminar_conclusion。
- 调用 update_chat_env 方法更新全局聊天环境。
- 返回更新后的全局聊天环境。

首先是DemandAnalysis类：

这个类继承自 Phase 类，并实现了 update_phase_env 和 update_chat_env 两个抽象方法。
在 update_chat_env 方法中，如果 self.seminar_conclusion 非空，则从中提取出 <INFO> 标记后的内容，并将其转换为小写形式并去除句号和空格。然后将该内容保存到 chat_env 的环境字典中的 modality 键对应的值中。
最后，返回更新后的 chat_env。

接下来是LanguageChoose类：

这个类同样继承自 Phase 类，并实现了 update_phase_env 和 update_chat_env 两个抽象方法。
在 update_phase_env 方法中，使用 chat_env 的环境字典中的一些值更新 self.phase_env 字典。
在 update_chat_env 方法中，首先判断 self.seminar_conclusion 是否非空，且其中是否包含 <INFO> 标记。
- 如果是，则从 self.seminar_conclusion 中提取出 <INFO> 标记后的内容，并将其转换为小写形式并去除句号和空格。然后将该内容保存到 chat_env 的环境字典中的 language 键对应的值中。
- 如果不是，则判断 self.seminar_conclusion 是否非空，如果是，则直接将其保存到 chat_env 的环境字典中的 language 键对应的值中。
- 如果都不满足上述条件，则将 language 设置为 “Python”。
最后，返回更新后的 chat_env。

然后是Coding类和ArtDesign类，它们的实现逻辑与上述两个类类似，都继承自 Phase 类，并分别实现了 update_phase_env 和 update_chat_env 两个抽象方法。这里略过具体内容的解释，可根据注释进行理解。

这些阶段类都用于更新聊天环境的阶段信息，从用户和助手的对话中提取有关任务、语言选择、代码和艺术设计等方面的信息，并将其保存到聊天环境的环境字典中。

ArtIntegration阶段类：该类用于将chat_env中的环境信息更新到phase_env中，主要更新了任务、语言、代码以及图像等信息。
CodeComplete阶段类：该类也是将chat_env中的环境信息更新到phase_env中，更新了任务、模态、观点、语言、代码以及未实现的文件等信息。其中，还检查是否有未实现的文件，如果有且尝试次数未超过最大次数，则记录下该文件名，并更新计数器。
CodeReviewComment阶段类：同样将chat_env中的环境信息更新到phase_env中，更新了任务、模态、观点、语言、代码以及图像等信息。
CodeReviewModification阶段类：将chat_env中的环境信息更新到phase_env中，更新了任务、模态、观点、语言、代码以及评论等信息。如果评论中包含代码块标识”“`”，则更新chat_env中的代码，并重新生成代码。
CodeReviewHuman阶段类：该阶段需要人工介入，通过输入提供反馈意见。将chat_env中的环境信息更新到phase_env中，更新了任务、模态、观点、语言、代码以及评论等信息。

这部分代码是ChatDev开源项目中的一些阶段（Phase）类。每个阶段类都是一个用于处理对话环境（chat_env）的特定阶段，它们分别为TestErrorSummary、TestModification、EnvironmentDoc和Manual。

首先，让我们逐个解析每个阶段类的作用和注释：

TestErrorSummary：
- 作用：处理软件测试中的错误摘要阶段，生成测试报告，并根据报告中的错误信息执行相应的修复操作。
- 添加注释：
  - update_phase_env()：更新阶段环境，将测试报告、任务提示、模态、构想、编程语言和源代码等信息存储在阶段环境中。
  - update_chat_env()：更新对话环境，将错误摘要和测试报告存储在对话环境的环境字典中。
  - execute()：执行阶段任务，更新阶段环境和对话环境，并返回更新后的对话环境。
TestModification：
- 作用：处理软件修改阶段，根据讨论的结果，更新源代码，并生成新的代码版本。
- 添加注释：
  - update_phase_env()：更新阶段环境，将任务提示、模态、构想、编程语言、测试报告、错误摘要和源代码等信息存储在阶段环境中。
  - update_chat_env()：更新对话环境，根据讨论结果更新源代码，并重新生成代码。
EnvironmentDoc：
- 作用：处理环境文档阶段，更新项目的需求文档，并根据讨论结果生成新的文档版本。
- 添加注释：
  - update_phase_env()：更新阶段环境，将任务提示、模态、构想、编程语言和源代码等信息存储在阶段环境中。
  - update_chat_env()：更新对话环境，根据讨论结果更新需求文档，并重新生成文档。
Manual：
- 作用：处理操作手册阶段，更新项目的操作手册，并根据讨论结果生成新的手册版本。
- 添加注释：
  - update_phase_env()：更新阶段环境，将任务提示、模态、构想、编程语言、源代码和需求文档等信息存储在阶段环境中。
  - update_chat_env()：更新对话环境，根据讨论结果更新操作手册，并重新生成手册。

每个阶段类都实现了update_phase_env()和update_chat_env()方法来更新阶段环境和对话环境。同时，它们还实现了execute()方法来执行特定的阶段任务并返回更新后的对话环境。

源代码如下：

import os
import re
from abc import ABC, abstractmethod

from camel.agents import RolePlaying
from camel.messages import ChatMessage
from camel.typing import TaskType, ModelType
from chatdev.chat_env import ChatEnv
from chatdev.statistics import get_info
from chatdev.utils import log_and_print_online, log_arguments


class Phase(ABC):

    def __init__(self,
                 assistant_role_name,
                 user_role_name,
                 phase_prompt,
                 role_prompts,
                 phase_name,
                 model_type,
                 log_filepath):
        """

        Args:
            assistant_role_name: who receives chat in a phase
            user_role_name: who starts the chat in a phase
            phase_prompt: prompt of this phase
            role_prompts: prompts of all roles
            phase_name: name of this phase
        """
        self.seminar_conclusion = None
        self.assistant_role_name = assistant_role_name
        self.user_role_name = user_role_name
        self.phase_prompt = phase_prompt
        self.phase_env = dict()
        self.phase_name = phase_name
        self.assistant_role_prompt = role_prompts[assistant_role_name]
        self.user_role_prompt = role_prompts[user_role_name]
        self.ceo_prompt = role_prompts["Chief Executive Officer"]
        self.counselor_prompt = role_prompts["Counselor"]
        self.timeout_seconds = 1.0
        self.max_retries = 3
        self.reflection_prompt = """Here is a conversation between two roles: {conversations} {question}"""
        self.model_type = model_type
        self.log_filepath = log_filepath

    @log_arguments
    def chatting(
            self,
            chat_env,
            task_prompt: str,
            assistant_role_name: str,
            user_role_name: str,
            phase_prompt: str,
            phase_name: str,
            assistant_role_prompt: str,
            user_role_prompt: str,
            task_type=TaskType.CHATDEV,
            need_reflect=False,
            with_task_specify=False,
            model_type=ModelType.GPT_3_5_TURBO,
            placeholders=None,
            chat_turn_limit=10
    ) -> str:
        """

        Args:
            chat_env: global chatchain environment TODO: only for employee detection, can be deleted
            task_prompt: user query prompt for building the software
            assistant_role_name: who receives the chat
            user_role_name: who starts the chat
            phase_prompt: prompt of the phase
            phase_name: name of the phase
            assistant_role_prompt: prompt of assistant role
            user_role_prompt: prompt of user role
            task_type: task type
            need_reflect: flag for checking reflection
            with_task_specify: with task specify
            model_type: model type
            placeholders: placeholders for phase environment to generate phase prompt
            chat_turn_limit: turn limits in each chat

        Returns:

        """

        if placeholders is None:
            placeholders = {}
        assert 1 <= chat_turn_limit <= 100

        if not chat_env.exist_employee(assistant_role_name):
            raise ValueError(f"{assistant_role_name} not recruited in ChatEnv.")
        if not chat_env.exist_employee(user_role_name):
            raise ValueError(f"{user_role_name} not recruited in ChatEnv.")

        # init role play
        role_play_session = RolePlaying(
            assistant_role_name=assistant_role_name,
            user_role_name=user_role_name,
            assistant_role_prompt=assistant_role_prompt,
            user_role_prompt=user_role_prompt,
            task_prompt=task_prompt,
            task_type=task_type,
            with_task_specify=with_task_specify,
            model_type=model_type,
        )

        # log_and_print_online("System", role_play_session.assistant_sys_msg)
        # log_and_print_online("System", role_play_session.user_sys_msg)

        # start the chat
        _, input_user_msg = role_play_session.init_chat(None, placeholders, phase_prompt)
        seminar_conclusion = None

        # handle chats
        # the purpose of the chatting in one phase is to get a seminar conclusion
        # there are two types of conclusion
        # 1. with "<INFO>" mark
        # 1.1 get seminar conclusion flag (ChatAgent.info) from assistant or user role, which means there exist special "<INFO>" mark in the conversation
        # 1.2 add "<INFO>" to the reflected content of the chat (which may be terminated chat without "<INFO>" mark)
        # 2. without "<INFO>" mark, which means the chat is terminated or normally ended without generating a marked conclusion, and there is no need to reflect
        for i in range(chat_turn_limit):
            # start the chat, we represent the user and send msg to assistant
            # 1. so the input_user_msg should be assistant_role_prompt + phase_prompt
            # 2. then input_user_msg send to LLM and get assistant_response
            # 3. now we represent the assistant and send msg to user, so the input_assistant_msg is user_role_prompt + assistant_response
            # 4. then input_assistant_msg send to LLM and get user_response
            # all above are done in role_play_session.step, which contains two interactions with LLM
            # the first interaction is logged in role_play_session.init_chat
            assistant_response, user_response = role_play_session.step(input_user_msg, chat_turn_limit == 1)

            conversation_meta = "**" + assistant_role_name + "<->" + user_role_name + " on : " + str(
                phase_name) + ", turn " + str(i) + "**\n\n"

            # TODO: max_tokens_exceeded errors here
            if isinstance(assistant_response.msg, ChatMessage):
                # we log the second interaction here
                log_and_print_online(role_play_session.assistant_agent.role_name,
                                     conversation_meta + "[" + role_play_session.user_agent.system_message.content + "]\n\n" + assistant_response.msg.content)
                if role_play_session.assistant_agent.info:
                    seminar_conclusion = assistant_response.msg.content
                    break
                if assistant_response.terminated:
                    break

            if isinstance(user_response.msg, ChatMessage):
                # here is the result of the second interaction, which may be used to start the next chat turn
                log_and_print_online(role_play_session.user_agent.role_name,
                                     conversation_meta + "[" + role_play_session.assistant_agent.system_message.content + "]\n\n" + user_response.msg.content)
                if role_play_session.user_agent.info:
                    seminar_conclusion = user_response.msg.content
                    break
                if user_response.terminated:
                    break

            # continue the chat
            if chat_turn_limit > 1 and isinstance(user_response.msg, ChatMessage):
                input_user_msg = user_response.msg
            else:
                break

        # conduct self reflection
        if need_reflect:
            if seminar_conclusion in [None, ""]:
                seminar_conclusion = "<INFO> " + self.self_reflection(task_prompt, role_play_session, phase_name,
                                                                      chat_env)
            if "recruiting" in phase_name:
                if "Yes".lower() not in seminar_conclusion.lower() and "No".lower() not in seminar_conclusion.lower():
                    seminar_conclusion = "<INFO> " + self.self_reflection(task_prompt, role_play_session,
                                                                          phase_name,
                                                                          chat_env)
            elif seminar_conclusion in [None, ""]:
                seminar_conclusion = "<INFO> " + self.self_reflection(task_prompt, role_play_session, phase_name,
                                                                      chat_env)
        else:
            seminar_conclusion = assistant_response.msg.content

        log_and_print_online("**[Seminar Conclusion]**:\n\n {}".format(seminar_conclusion))
        seminar_conclusion = seminar_conclusion.split("<INFO>")[-1]
        return seminar_conclusion

    def self_reflection(self,
                        task_prompt: str,
                        role_play_session: RolePlaying,
                        phase_name: str,
                        chat_env: ChatEnv) -> str:
        """

        Args:
            task_prompt: user query prompt for building the software
            role_play_session: role play session from the chat phase which needs reflection
            phase_name: name of the chat phase which needs reflection
            chat_env: global chatchain environment

        Returns:
            reflected_content: str, reflected results

        """
        messages = role_play_session.assistant_agent.stored_messages if len(
            role_play_session.assistant_agent.stored_messages) >= len(
            role_play_session.user_agent.stored_messages) else role_play_session.user_agent.stored_messages
        messages = ["{}: {}".format(message.role_name, message.content.replace("\n\n", "\n")) for message in messages]
        messages = "\n\n".join(messages)

        if "recruiting" in phase_name:
            question = """Answer their final discussed conclusion (Yes or No) in the discussion without any other words, e.g., "Yes" """
        elif phase_name == "DemandAnalysis":
            question = """Answer their final product modality in the discussion without any other words, e.g., "PowerPoint" """
        # elif phase_name in [PhaseType.BRAINSTORMING]:
        #     question = """Conclude three most creative and imaginative brainstorm ideas from the whole discussion, in the format: "1) *; 2) *; 3) *; where '*' represents a suggestion." """
        elif phase_name == "LanguageChoose":
            question = """Conclude the programming language being discussed for software development, in the format: "*" where '*' represents a programming language." """
        elif phase_name == "EnvironmentDoc":
            question = """According to the codes and file format listed above, write a requirements.txt file to specify the dependencies or packages required for the project to run properly." """
        else:
            raise ValueError(f"Reflection of phase {phase_name}: Not Assigned.")

        # Reflections actually is a special phase between CEO and counselor
        # They read the whole chatting history of this phase and give refined conclusion of this phase
        reflected_content = \
            self.chatting(chat_env=chat_env,
                          task_prompt=task_prompt,
                          assistant_role_name="Chief Executive Officer",
                          user_role_name="Counselor",
                          phase_prompt=self.reflection_prompt,
                          phase_name="Reflection",
                          assistant_role_prompt=self.ceo_prompt,
                          user_role_prompt=self.counselor_prompt,
                          placeholders={"conversations": messages, "question": question},
                          need_reflect=False,
                          chat_turn_limit=1,
                          model_type=self.model_type)

        if "recruiting" in phase_name:
            if "Yes".lower() in reflected_content.lower():
                return "Yes"
            return "No"
        else:
            return reflected_content

    @abstractmethod
    def update_phase_env(self, chat_env):
        """
        update self.phase_env (if needed) using chat_env, then the chatting will use self.phase_env to follow the context and fill placeholders in phase prompt
        must be implemented in customized phase
        the usual format is just like:
        ```
            self.phase_env.update({key:chat_env[key]})
        ```
        Args:
            chat_env: global chat chain environment

        Returns: None

        """
        pass

    @abstractmethod
    def update_chat_env(self, chat_env) -> ChatEnv:
        """
        update chan_env based on the results of self.execute, which is self.seminar_conclusion
        must be implemented in customized phase
        the usual format is just like:
        ```
            chat_env.xxx = some_func_for_postprocess(self.seminar_conclusion)
        ```
        Args:
            chat_env:global chat chain environment

        Returns:
            chat_env: updated global chat chain environment

        """
        pass

    def execute(self, chat_env, chat_turn_limit, need_reflect) -> ChatEnv:
        """
        execute the chatting in this phase
        1. receive information from environment: update the phase environment from global environment
        2. execute the chatting
        3. change the environment: update the global environment using the conclusion
        Args:
            chat_env: global chat chain environment
            chat_turn_limit: turn limit in each chat
            need_reflect: flag for reflection

        Returns:
            chat_env: updated global chat chain environment using the conclusion from this phase execution

        """
        self.update_phase_env(chat_env)
        self.seminar_conclusion = \
            self.chatting(chat_env=chat_env,
                          task_prompt=chat_env.env_dict['task_prompt'],
                          need_reflect=need_reflect,
                          assistant_role_name=self.assistant_role_name,
                          user_role_name=self.user_role_name,
                          phase_prompt=self.phase_prompt,
                          phase_name=self.phase_name,
                          assistant_role_prompt=self.assistant_role_prompt,
                          user_role_prompt=self.user_role_prompt,
                          chat_turn_limit=chat_turn_limit,
                          placeholders=self.phase_env,
                          model_type=self.model_type)
        chat_env = self.update_chat_env(chat_env)
        return chat_env


class DemandAnalysis(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        pass

    def update_chat_env(self, chat_env) -> ChatEnv:
        if len(self.seminar_conclusion) > 0:
            chat_env.env_dict['modality'] = self.seminar_conclusion.split("<INFO>")[-1].lower().replace(".", "").strip()
        return chat_env


class LanguageChoose(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        self.phase_env.update({"task": chat_env.env_dict['task_prompt'],
                               "modality": chat_env.env_dict['modality'],
                               "ideas": chat_env.env_dict['ideas']})

    def update_chat_env(self, chat_env) -> ChatEnv:
        if len(self.seminar_conclusion) > 0 and "<INFO>" in self.seminar_conclusion:
            chat_env.env_dict['language'] = self.seminar_conclusion.split("<INFO>")[-1].lower().replace(".", "").strip()
        elif len(self.seminar_conclusion) > 0:
            chat_env.env_dict['language'] = self.seminar_conclusion
        else:
            chat_env.env_dict['language'] = "Python"
        return chat_env


class Coding(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        gui = "" if not chat_env.config.gui_design \
            else "The software should be equipped with graphical user interface (GUI) so that user can visually and graphically use it; so you must choose a GUI framework (e.g., in Python, you can implement GUI via tkinter, Pygame, Flexx, PyGUI, etc,)."
        self.phase_env.update({"task": chat_env.env_dict['task_prompt'],
                               "modality": chat_env.env_dict['modality'],
                               "ideas": chat_env.env_dict['ideas'],
                               "language": chat_env.env_dict['language'],
                               "gui": gui})

    def update_chat_env(self, chat_env) -> ChatEnv:
        chat_env.update_codes(self.seminar_conclusion)
        if len(chat_env.codes.codebooks.keys()) == 0:
            raise ValueError("No Valid Codes.")
        chat_env.rewrite_codes()
        log_and_print_online("**[Software Info]**:\n\n {}".format(get_info(chat_env.env_dict['directory'],self.log_filepath)))
        return chat_env


class ArtDesign(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        self.phase_env = {"task": chat_env.env_dict['task_prompt'],
                          "language": chat_env.env_dict['language'],
                          "codes": chat_env.get_codes()}

    def update_chat_env(self, chat_env) -> ChatEnv:
        chat_env.proposed_images = chat_env.get_proposed_images_from_message(self.seminar_conclusion)
        log_and_print_online("**[Software Info]**:\n\n {}".format(get_info(chat_env.env_dict['directory'],self.log_filepath)))
        return chat_env


class ArtIntegration(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        self.phase_env = {"task": chat_env.env_dict['task_prompt'],
                          "language": chat_env.env_dict['language'],
                          "codes": chat_env.get_codes(),
                          "images": "\n".join(
                              ["{}: {}".format(filename, chat_env.proposed_images[filename]) for
                               filename in sorted(list(chat_env.proposed_images.keys()))])}

    def update_chat_env(self, chat_env) -> ChatEnv:
        chat_env.update_codes(self.seminar_conclusion)
        chat_env.rewrite_codes()
        # chat_env.generate_images_from_codes()
        log_and_print_online("**[Software Info]**:\n\n {}".format(get_info(chat_env.env_dict['directory'],self.log_filepath)))
        return chat_env


class CodeComplete(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        self.phase_env.update({"task": chat_env.env_dict['task_prompt'],
                               "modality": chat_env.env_dict['modality'],
                               "ideas": chat_env.env_dict['ideas'],
                               "language": chat_env.env_dict['language'],
                               "codes": chat_env.get_codes(),
                               "unimplemented_file": ""})
        unimplemented_file = ""
        for filename in self.phase_env['pyfiles']:
            code_content = open(os.path.join(chat_env.env_dict['directory'], filename)).read()
            lines = [line.strip() for line in code_content.split("\n") if line.strip() == "pass"]
            if len(lines) > 0 and self.phase_env['num_tried'][filename] < self.phase_env['max_num_implement']:
                unimplemented_file = filename
                break
        self.phase_env['num_tried'][unimplemented_file] += 1
        self.phase_env['unimplemented_file'] = unimplemented_file

    def update_chat_env(self, chat_env) -> ChatEnv:
        chat_env.update_codes(self.seminar_conclusion)
        if len(chat_env.codes.codebooks.keys()) == 0:
            raise ValueError("No Valid Codes.")
        chat_env.rewrite_codes()
        log_and_print_online("**[Software Info]**:\n\n {}".format(get_info(chat_env.env_dict['directory'],self.log_filepath)))
        return chat_env


class CodeReviewComment(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        self.phase_env.update(
            {"task": chat_env.env_dict['task_prompt'],
             "modality": chat_env.env_dict['modality'],
             "ideas": chat_env.env_dict['ideas'],
             "language": chat_env.env_dict['language'],
             "codes": chat_env.get_codes(),
             "images": ", ".join(chat_env.incorporated_images)})

    def update_chat_env(self, chat_env) -> ChatEnv:
        chat_env.env_dict['review_comments'] = self.seminar_conclusion
        return chat_env


class CodeReviewModification(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        self.phase_env.update({"task": chat_env.env_dict['task_prompt'],
                               "modality": chat_env.env_dict['modality'],
                               "ideas": chat_env.env_dict['ideas'],
                               "language": chat_env.env_dict['language'],
                               "codes": chat_env.get_codes(),
                               "comments": chat_env.env_dict['review_comments']})

    def update_chat_env(self, chat_env) -> ChatEnv:
        if "```".lower() in self.seminar_conclusion.lower():
            chat_env.update_codes(self.seminar_conclusion)
            chat_env.rewrite_codes()
            log_and_print_online("**[Software Info]**:\n\n {}".format(get_info(chat_env.env_dict['directory'],self.log_filepath)))
        self.phase_env['modification_conclusion'] = self.seminar_conclusion
        return chat_env


class CodeReviewHuman(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        print(
            f"You can participate in the development of the software {chat_env.env_dict['task_prompt']}. Please input your feedback. (\"End\" to quit the involvement.)")
        provided_comments = input()
        self.phase_env.update({"task": chat_env.env_dict['task_prompt'],
                               "modality": chat_env.env_dict['modality'],
                               "ideas": chat_env.env_dict['ideas'],
                               "language": chat_env.env_dict['language'],
                               "codes": chat_env.get_codes(),
                               "comments": provided_comments})

    def update_chat_env(self, chat_env) -> ChatEnv:
        if "```".lower() in self.seminar_conclusion.lower():
            chat_env.update_codes(self.seminar_conclusion)
            chat_env.rewrite_codes()
            log_and_print_online("**[Software Info]**:\n\n {}".format(get_info(chat_env.env_dict['directory'],self.log_filepath)))
        return chat_env


class TestErrorSummary(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        chat_env.generate_images_from_codes()
        (exist_bugs_flag, test_reports) = chat_env.exist_bugs()
        self.phase_env.update({"task": chat_env.env_dict['task_prompt'],
                               "modality": chat_env.env_dict['modality'],
                               "ideas": chat_env.env_dict['ideas'],
                               "language": chat_env.env_dict['language'],
                               "codes": chat_env.get_codes(),
                               "test_reports": test_reports,
                               "exist_bugs_flag": exist_bugs_flag})
        log_and_print_online("**[Test Reports]**:\n\n{}".format(test_reports))

    def update_chat_env(self, chat_env) -> ChatEnv:
        chat_env.env_dict['error_summary'] = self.seminar_conclusion
        chat_env.env_dict['test_reports'] = self.phase_env['test_reports']

        return chat_env

    def execute(self, chat_env, chat_turn_limit, need_reflect) -> ChatEnv:
        self.update_phase_env(chat_env)
        if "ModuleNotFoundError" in self.phase_env['test_reports']:
            chat_env.fix_module_not_found_error(self.phase_env['test_reports'])
            log_and_print_online(
                f"Software Test Engineer found ModuleNotFoundError:\n{self.phase_env['test_reports']}\n")
            pip_install_content = ""
            for match in re.finditer(r"No module named '(\S+)'", self.phase_env['test_reports'], re.DOTALL):
                module = match.group(1)
                pip_install_content += "{}\n```{}\n{}\n```\n".format("cmd", "bash", f"pip install {module}")
                log_and_print_online(f"Programmer resolve ModuleNotFoundError by:\n{pip_install_content}\n")
            self.seminar_conclusion = "nothing need to do"
        else:
            self.seminar_conclusion = \
                self.chatting(chat_env=chat_env,
                              task_prompt=chat_env.env_dict['task_prompt'],
                              need_reflect=need_reflect,
                              assistant_role_name=self.assistant_role_name,
                              user_role_name=self.user_role_name,
                              phase_prompt=self.phase_prompt,
                              phase_name=self.phase_name,
                              assistant_role_prompt=self.assistant_role_prompt,
                              user_role_prompt=self.user_role_prompt,
                              chat_turn_limit=chat_turn_limit,
                              placeholders=self.phase_env)
        chat_env = self.update_chat_env(chat_env)
        return chat_env


class TestModification(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        self.phase_env.update({"task": chat_env.env_dict['task_prompt'],
                               "modality": chat_env.env_dict['modality'],
                               "ideas": chat_env.env_dict['ideas'],
                               "language": chat_env.env_dict['language'],
                               "test_reports": chat_env.env_dict['test_reports'],
                               "error_summary": chat_env.env_dict['error_summary'],
                               "codes": chat_env.get_codes()
                               })

    def update_chat_env(self, chat_env) -> ChatEnv:
        if "```".lower() in self.seminar_conclusion.lower():
            chat_env.update_codes(self.seminar_conclusion)
            chat_env.rewrite_codes()
            log_and_print_online("**[Software Info]**:\n\n {}".format(get_info(chat_env.env_dict['directory'],self.log_filepath)))
        return chat_env


class EnvironmentDoc(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        self.phase_env.update({"task": chat_env.env_dict['task_prompt'],
                               "modality": chat_env.env_dict['modality'],
                               "ideas": chat_env.env_dict['ideas'],
                               "language": chat_env.env_dict['language'],
                               "codes": chat_env.get_codes()})

    def update_chat_env(self, chat_env) -> ChatEnv:
        chat_env._update_requirements(self.seminar_conclusion)
        chat_env.rewrite_requirements()
        log_and_print_online("**[Software Info]**:\n\n {}".format(get_info(chat_env.env_dict['directory'],self.log_filepath)))
        return chat_env


class Manual(Phase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def update_phase_env(self, chat_env):
        self.phase_env.update({"task": chat_env.env_dict['task_prompt'],
                               "modality": chat_env.env_dict['modality'],
                               "ideas": chat_env.env_dict['ideas'],
                               "language": chat_env.env_dict['language'],
                               "codes": chat_env.get_codes(),
                               "requirements": chat_env.get_requirements()})

    def update_chat_env(self, chat_env) -> ChatEnv:
        chat_env._update_manuals(self.seminar_conclusion)
        chat_env.rewrite_manuals()
        return chat_env

作者 east

chatgpt, python 9月 11,2023

清华开源ChatGPT自动编程ChatDev项目chat_chain.py解读

ChatChain类是一个用于实现软件开发的多智能体协作系统，它可以根据用户的自然语言描述来创建定制的软件。
__init__()方法是类的构造函数，它接受以下几个参数：
- config_path: 一个字符串，表示ChatChainConfig.json文件的路径，这个文件包含了ChatChain的基本配置信息，例如智能体链、招聘条件、是否清理结构、是否进行头脑风暴等。
- config_phase_path: 一个字符串，表示PhaseConfig.json文件的路径，这个文件包含了软件开发的各个阶段的配置信息，例如阶段名称、阶段目标、阶段角色、阶段限制等。
- config_role_path: 一个字符串，表示RoleConfig.json文件的路径，这个文件包含了软件开发的各个角色的配置信息，例如角色名称、角色描述、角色提示等。
- task_prompt: 一个字符串，表示用户输入的软件想法，例如“我想要一个五子棋游戏”。
- project_name: 一个字符串，表示用户输入的软件名称，例如“Gomoku”。
- org_name: 一个字符串，表示用户所属的组织名称，例如“OpenBMB”。
- model_type: 一个枚举类型，表示使用的大型语言模型（LLM）的类型，例如ModelType.GPT_3_5_TURBO。
__init__()方法首先将这些参数保存在类的属性中，然后使用open()函数和json模块来打开和解析这些配置文件，并将配置信息保存在类的属性中。接着它根据配置信息初始化了ChatChain的智能体链和招聘条件，并设置了默认的最大对话轮数为10。然后它根据配置信息创建了一个ChatEnvConfig对象和一个ChatEnv对象，用于管理软件开发的环境和资源。接下来它将用户输入的软件想法保存在类的属性中，并根据配置信息决定是否对其进行自我改进（这个过程在类的preprocess()方法中实现）。然后它根据配置信息创建了一个字典对象self.role_prompts，用于存储各个角色的提示信息。最后它调用类的get_logfilepath()方法来获取日志文件的路径，并将其保存在类的属性中。
check_bool()函数是一个辅助函数，用于将字符串转换为布尔值。它接受一个参数s，表示一个字符串。它将s转换为小写，并判断是否等于”true”。如果是，则返回True，否则返回False。
get_logfilepath()方法用于获取日志文件的路径，并返回一个元组(start_time, log_filepath)，其中start_time表示开始时间，log_filepath表示日志文件路径。这个方法首先使用datetime模块来获取当前时间，并将其格式化为”%Y-%m-%d %H:%M:%S”形式，并赋值给start_time变量。然后它使用os模块来获取当前工作目录，并将其与”logs”和start_time拼接起来，得到log_filepath变量。最后它返回(start_time, log_filepath)元组。

make_recruitment()方法用于招聘合适的智能体，并将他们加入到ChatEnv对象中。它遍历配置信息中定义的招聘条件（self.recruitments属性），对于每个条件（即智能体名称），它调用ChatEnv对象的recruit()方法，将智能体名称作为参数传递，表示招聘该智能体。
execute_step()方法用于执行单个软件开发阶段，它接受一个参数phase_item，表示配置信息中定义的单个阶段信息。它首先获取阶段的名称、类型等信息，并根据不同的类型来执行不同的操作。如果阶段类型是”SimplePhase”，则表示这是一个简单的阶段，它会从self.phases属性中获取相应的SimplePhase对象，并调用其execute()方法，将ChatEnv对象、最大对话轮数、是否需要反思等参数传递给该方法，并将返回的新的ChatEnv对象赋值给self.chat_env属性。如果阶段类型是”ComposedPhase”，则表示这是一个复合的阶段，它会从self.compose_phase_module模块中获取相应的ComposedPhase类，并创建一个ComposedPhase对象，将阶段名称、循环次数、组成部分、配置信息、模型类型、日志文件路径等参数传递给其构造函数，并将该对象赋值给compose_phase_instance变量。然后它调用compose_phase_instance对象的execute()方法，将ChatEnv对象作为参数传递，并将返回的新的ChatEnv对象赋值给self.chat_env属性。如果阶段类型是其他类型，则抛出一个异常，表示未实现该类型。
execute_chain()方法用于执行整个软件开发过程，它遍历配置信息中定义的智能体链（self.chain属性），对于每个阶段信息，它调用execute_step()方法来执行该阶段。
get_logfilepath()方法用于获取日志文件的路径，并返回一个元组(start_time, log_filepath)，其中start_time表示开始时间，log_filepath表示日志文件路径。这个方法首先使用datetime模块来获取当前时间，并将其格式化为”%Y-%m-%d %H:%M:%S”形式，并赋值给start_time变量。然后它使用os模块来获取当前工作目录，并将其与”logs”和start_time拼接起来，得到log_filepath变量。最后它返回(start_time, log_filepath)元组。

pre_processing()方法用于进行预处理，例如删除无用的文件和记录一些全局的配置信息。它不接受任何参数，也不返回任何值。它首先判断ChatEnv对象的配置信息中是否需要清理结构（self.chat_env.config.clear_structure属性），如果是，则使用os模块来遍历WareHouse目录中的所有文件，并删除除了.py和.log以外的文件，并打印出删除的文件路径。然后它获取软件保存的目录（由项目名称、组织名称和开始时间拼接而成），并调用ChatEnv对象的set_directory()方法，将该目录作为参数传递，表示设置该目录为软件目录。接着它使用shutil模块的copy()函数来将配置文件复制到软件目录中，并使用open()函数和write()方法来将用户输入的软件想法写入到软件目录中的一个.prompt文件中。然后它创建一个字符串preprocess_msg，并赋值为”[Preprocessing]\n\n”，表示开始预处理。接着它创建一个ChatGPTConfig对象，并将其赋值给chat_gpt_config变量，表示LLM的配置信息。然后它在preprocess_msg字符串后面追加一些信息，例如开始时间、配置文件路径、软件想法、项目名称、日志文件路径、ChatDevConfig对象、ChatGPTConfig对象等，并使用log_and_print_online()函数来将preprocess_msg字符串记录到日志文件中，并打印出来。最后它判断配置信息中是否需要进行自我改进（self.config[‘self_improve’]属性），如果是，则调用self.self_task_improve()方法，将用户输入的软件想法作为参数传递，并将返回的更完善的想法赋值给self.chat_env.env_dict[‘task_prompt’]属性。如果不是，则直接将用户输入的软件想法赋值给self.chat_env.env_dict[‘task_prompt’]属性。
post_processing()方法用于进行后处理，例如总结产出和移动日志文件到软件目录中。它不接受任何参数，也不返回任何值。它首先调用ChatEnv对象的write_meta()方法，用于写入元数据信息到软件目录中。然后它使用os模块来获取当前工作目录，并将其赋值给filepath变量。接着它使用os模块来获取当前工作目录的父目录，并将其赋值给root变量。然后它创建一个字符串post_info，并赋值为”[Post Info]\n\n”，表示开始后处理。接着它使用datetime模块来获取当前时间，并将其格式化为”%Y%m%d%H%M%S”形式，并赋值给now_time变量。然后它使用datetime模块和strptime()函数来将开始时间和当前时间转换为datetime对象，并分别赋值给datetime1和datetime2变量。接着它使用total_seconds()方法来计算两个datetime对象之间的差异，并将其赋值给duration变量，表示软件开发所花费的时间。然后它在post_info字符串后面追加”Software Info: {}“.format(get_info(self.chat_env.env_dict[‘directory’], self.log_filepath) + “\n\n🕑duration={:.2f}s\n\n”.format(duration))，表示显示软件的信息和开发时间。接着它在post_info字符串后面追加”ChatDev Starts ({})”.format(self.start_time) + “\n\n”，表示显示开始时间。最后它在post_info字符串后面追加”ChatDev Ends ({})”.format(now_time) + “\n\n”，表示显示结束时间。

这段代码定义了一个self_task_improve()方法，用于对用户输入的软件想法进行自我改进，让LLM更好地理解这些想法。它接受一个参数task_prompt，表示用户输入的软件想法。它返回一个字符串revised_task_prompt，表示经过改进的软件想法。
这个方法首先创建一个字符串self_task_improve_prompt，并赋值为一段提示信息，表示要求用户将一个简短的软件设计需求重写为一个详细的提示，让LLM能够根据这个提示来更好地制作这个软件。这个提示信息中包含了用户输入的软件想法（task_prompt参数），以及一些注意事项，例如提示的长度、格式等。然后它创建一个RolePlaying对象role_play_session，并将其赋值给role_play_session变量，表示一个角色扮演的会话。它将以下几个参数传递给RolePlaying类的构造函数：
- assistant_role_name: 一个字符串，表示助理的角色名称，为”Prompt Engineer”。
- assistant_role_prompt: 一个字符串，表示助理的角色描述，为”You are an professional prompt engineer that can improve user input prompt to make LLM better understand these prompts.”。
- user_role_prompt: 一个字符串，表示用户的角色描述，为”You are an user that want to use LLM to build software.”。
- user_role_name: 一个字符串，表示用户的角色名称，为”User”。
- task_type: 一个枚举类型，表示任务类型，为TaskType.CHATDEV。
- task_prompt: 一个字符串，表示任务描述，为”Do prompt engineering on user query”。
- with_task_specify: 一个布尔值，表示是否需要指定任务类型，为False。
- model_type: 一个枚举类型，表示使用的LLM的类型，为self.model_type属性。
接着它调用role_play_session对象的init_chat()方法，将None、None和self_task_improve_prompt作为参数传递，并将返回的两个值赋值给_和input_user_msg变量。这个方法用于初始化角色扮演的会话，并返回助理和用户的第一轮对话。其中input_user_msg变量表示用户输入的重写后的软件想法。然后它调用role_play_session对象的step()方法，将input_user_msg和True作为参数传递，并将返回的两个值赋值给assistant_response和user_response变量。这个方法用于进行角色扮演的一步对话，并返回助理和用户的回复。其中assistant_response变量表示助理回复的内容。接着它使用split()方法和strip()方法来从助理回复中提取出改进后的软件想法，并将其赋值给revised_task_prompt变量。然后它调用log_and_print_online()函数来记录并打印助理回复的内容。最后它调用log_and_print_online()函数来记录并打印原始和改进后的软件想法，并返回revised_task_prompt变量。

chat_chain.py的源代码如下：

import importlib
import json
import os
import shutil
from datetime import datetime
import logging
import time

from camel.agents import RolePlaying
from camel.configs import ChatGPTConfig
from camel.typing import TaskType, ModelType
from chatdev.chat_env import ChatEnv, ChatEnvConfig
from chatdev.statistics import get_info
from chatdev.utils import log_and_print_online, now


def check_bool(s):
    return s.lower() == "true"


class ChatChain:

    def __init__(self,
                 config_path: str = None,
                 config_phase_path: str = None,
                 config_role_path: str = None,
                 task_prompt: str = None,
                 project_name: str = None,
                 org_name: str = None,
                 model_type: ModelType = ModelType.GPT_3_5_TURBO) -> None:
        """

        Args:
            config_path: path to the ChatChainConfig.json
            config_phase_path: path to the PhaseConfig.json
            config_role_path: path to the RoleConfig.json
            task_prompt: the user input prompt for software
            project_name: the user input name for software
            org_name: the organization name of the human user
        """

        # load config file
        self.config_path = config_path
        self.config_phase_path = config_phase_path
        self.config_role_path = config_role_path
        self.project_name = project_name
        self.org_name = org_name
        self.model_type = model_type

        with open(self.config_path, 'r', encoding="utf8") as file:
            self.config = json.load(file)
        with open(self.config_phase_path, 'r', encoding="utf8") as file:
            self.config_phase = json.load(file)
        with open(self.config_role_path, 'r', encoding="utf8") as file:
            self.config_role = json.load(file)

        # init chatchain config and recruitments
        self.chain = self.config["chain"]
        self.recruitments = self.config["recruitments"]

        # init default max chat turn
        self.chat_turn_limit_default = 10

        # init ChatEnv
        self.chat_env_config = ChatEnvConfig(clear_structure=check_bool(self.config["clear_structure"]),
                                             brainstorming=check_bool(self.config["brainstorming"]),
                                             gui_design=check_bool(self.config["gui_design"]),
                                             git_management=check_bool(self.config["git_management"]))
        self.chat_env = ChatEnv(self.chat_env_config)

        # the user input prompt will be self-improved (if set "self_improve": "True" in ChatChainConfig.json)
        # the self-improvement is done in self.preprocess
        self.task_prompt_raw = task_prompt
        self.task_prompt = ""

        # init role prompts
        self.role_prompts = dict()
        for role in self.config_role:
            self.role_prompts[role] = "\n".join(self.config_role[role])

        # init log
        self.start_time, self.log_filepath = self.get_logfilepath()

        # init SimplePhase instances
        # import all used phases in PhaseConfig.json from chatdev.phase
        # note that in PhaseConfig.json there only exist SimplePhases
        # ComposedPhases are defined in ChatChainConfig.json and will be imported in self.execute_step
        self.compose_phase_module = importlib.import_module("chatdev.composed_phase")
        self.phase_module = importlib.import_module("chatdev.phase")
        self.phases = dict()
        for phase in self.config_phase:
            assistant_role_name = self.config_phase[phase]['assistant_role_name']
            user_role_name = self.config_phase[phase]['user_role_name']
            phase_prompt = "\n\n".join(self.config_phase[phase]['phase_prompt'])
            phase_class = getattr(self.phase_module, phase)
            phase_instance = phase_class(assistant_role_name=assistant_role_name,
                                         user_role_name=user_role_name,
                                         phase_prompt=phase_prompt,
                                         role_prompts=self.role_prompts,
                                         phase_name=phase,
                                         model_type=self.model_type,
                                         log_filepath=self.log_filepath)
            self.phases[phase] = phase_instance



    def make_recruitment(self):
        """
        recruit all employees
        Returns: None

        """
        for employee in self.recruitments:
            self.chat_env.recruit(agent_name=employee)

    def execute_step(self, phase_item: dict):
        """
        execute single phase in the chain
        Args:
            phase_item: single phase configuration in the ChatChainConfig.json

        Returns:

        """

        phase = phase_item['phase']
        phase_type = phase_item['phaseType']
        # For SimplePhase, just look it up from self.phases and conduct the "Phase.execute" method
        if phase_type == "SimplePhase":
            max_turn_step = phase_item['max_turn_step']
            need_reflect = check_bool(phase_item['need_reflect'])
            if phase in self.phases:
                self.chat_env = self.phases[phase].execute(self.chat_env,
                                                           self.chat_turn_limit_default if max_turn_step <= 0 else max_turn_step,
                                                           need_reflect)
            else:
                raise RuntimeError(f"Phase '{phase}' is not yet implemented in chatdev.phase")
        # For ComposedPhase, we create instance here then conduct the "ComposedPhase.execute" method
        elif phase_type == "ComposedPhase":
            cycle_num = phase_item['cycleNum']
            composition = phase_item['Composition']
            compose_phase_class = getattr(self.compose_phase_module, phase)
            if not compose_phase_class:
                raise RuntimeError(f"Phase '{phase}' is not yet implemented in chatdev.compose_phase")
            compose_phase_instance = compose_phase_class(phase_name=phase,
                                                         cycle_num=cycle_num,
                                                         composition=composition,
                                                         config_phase=self.config_phase,
                                                         config_role=self.config_role,
                                                         model_type=self.model_type,
                                                         log_filepath=self.log_filepath)
            self.chat_env = compose_phase_instance.execute(self.chat_env)
        else:
            raise RuntimeError(f"PhaseType '{phase_type}' is not yet implemented.")

    def execute_chain(self):
        """
        execute the whole chain based on ChatChainConfig.json
        Returns: None

        """
        for phase_item in self.chain:
            self.execute_step(phase_item)

    def get_logfilepath(self):
        """
        get the log path (under the software path)
        Returns:
            start_time: time for starting making the software
            log_filepath: path to the log

        """
        start_time = now()
        filepath = os.path.dirname(__file__)
        # root = "/".join(filepath.split("/")[:-1])
        root = os.path.dirname(filepath)
        # directory = root + "/WareHouse/"
        directory = os.path.join(root, "WareHouse")
        log_filepath = os.path.join(directory, "{}.log".format("_".join([self.project_name, self.org_name,start_time])))
        return start_time, log_filepath

    def pre_processing(self):
        """
        remove useless files and log some global config settings
        Returns: None

        """
        if self.chat_env.config.clear_structure:
            filepath = os.path.dirname(__file__)
            # root = "/".join(filepath.split("/")[:-1])
            root = os.path.dirname(filepath)
            # directory = root + "/WareHouse"
            directory = os.path.join(root, "WareHouse")
            for filename in os.listdir(directory):
                file_path = os.path.join(directory, filename)
                # logs with error trials are left in WareHouse/
                if os.path.isfile(file_path) and not filename.endswith(".py") and not filename.endswith(".log"):
                    os.remove(file_path)
                    print("{} Removed.".format(file_path))

        software_path = os.path.join(directory, "_".join([self.project_name, self.org_name, self.start_time]))
        self.chat_env.set_directory(software_path)

        # copy config files to software path
        shutil.copy(self.config_path, software_path)
        shutil.copy(self.config_phase_path, software_path)
        shutil.copy(self.config_role_path, software_path)

        # write task prompt to software path
        with open(os.path.join(software_path, self.project_name + ".prompt"), "w") as f:
            f.write(self.task_prompt_raw)

        preprocess_msg = "**[Preprocessing]**\n\n"
        chat_gpt_config = ChatGPTConfig()

        preprocess_msg += "**ChatDev Starts** ({})\n\n".format(self.start_time)
        preprocess_msg += "**Timestamp**: {}\n\n".format(self.start_time)
        preprocess_msg += "**config_path**: {}\n\n".format(self.config_path)
        preprocess_msg += "**config_phase_path**: {}\n\n".format(self.config_phase_path)
        preprocess_msg += "**config_role_path**: {}\n\n".format(self.config_role_path)
        preprocess_msg += "**task_prompt**: {}\n\n".format(self.task_prompt_raw)
        preprocess_msg += "**project_name**: {}\n\n".format(self.project_name)
        preprocess_msg += "**Log File**: {}\n\n".format(self.log_filepath)
        preprocess_msg += "**ChatDevConfig**:\n {}\n\n".format(self.chat_env.config.__str__())
        preprocess_msg += "**ChatGPTConfig**:\n {}\n\n".format(chat_gpt_config)
        log_and_print_online(preprocess_msg)

        # init task prompt
        if check_bool(self.config['self_improve']):
            self.chat_env.env_dict['task_prompt'] = self.self_task_improve(self.task_prompt_raw)
        else:
            self.chat_env.env_dict['task_prompt'] = self.task_prompt_raw

    def post_processing(self):
        """
        summarize the production and move log files to the software directory
        Returns: None

        """

        self.chat_env.write_meta()
        filepath = os.path.dirname(__file__)
        # root = "/".join(filepath.split("/")[:-1])
        root = os.path.dirname(filepath)

        post_info = "**[Post Info]**\n\n"
        now_time = now()
        time_format = "%Y%m%d%H%M%S"
        datetime1 = datetime.strptime(self.start_time, time_format)
        datetime2 = datetime.strptime(now_time, time_format)
        duration = (datetime2 - datetime1).total_seconds()

        post_info += "Software Info: {}".format(
            get_info(self.chat_env.env_dict['directory'], self.log_filepath) + "\n\n🕑**duration**={:.2f}s\n\n".format(duration))

        post_info += "ChatDev Starts ({})".format(self.start_time) + "\n\n"
        post_info += "ChatDev Ends ({})".format(now_time) + "\n\n"

        if self.chat_env.config.clear_structure:
            directory = self.chat_env.env_dict['directory']
            for filename in os.listdir(directory):
                file_path = os.path.join(directory, filename)
                if os.path.isdir(file_path) and file_path.endswith("__pycache__"):
                    shutil.rmtree(file_path, ignore_errors=True)
                    post_info += "{} Removed.".format(file_path) + "\n\n"

        log_and_print_online(post_info)

        logging.shutdown()
        time.sleep(1)

        shutil.move(self.log_filepath,
                    os.path.join(root + "/WareHouse", "_".join([self.project_name, self.org_name, self.start_time]),
                                 os.path.basename(self.log_filepath)))

    # @staticmethod
    def self_task_improve(self, task_prompt):
        """
        ask agent to improve the user query prompt
        Args:
            task_prompt: original user query prompt

        Returns:
            revised_task_prompt: revised prompt from the prompt engineer agent

        """
        self_task_improve_prompt = """I will give you a short description of a software design requirement, 
please rewrite it into a detailed prompt that can make large language model know how to make this software better based this prompt,
the prompt should ensure LLMs build a software that can be run correctly, which is the most import part you need to consider.
remember that the revised prompt should not contain more than 200 words, 
here is the short description:\"{}\". 
If the revised prompt is revised_version_of_the_description, 
then you should return a message in a format like \"<INFO> revised_version_of_the_description\", do not return messages in other formats.""".format(
            task_prompt)
        role_play_session = RolePlaying(
            assistant_role_name="Prompt Engineer",
            assistant_role_prompt="You are an professional prompt engineer that can improve user input prompt to make LLM better understand these prompts.",
            user_role_prompt="You are an user that want to use LLM to build software.",
            user_role_name="User",
            task_type=TaskType.CHATDEV,
            task_prompt="Do prompt engineering on user query",
            with_task_specify=False,
            model_type=self.model_type,
        )

        # log_and_print_online("System", role_play_session.assistant_sys_msg)
        # log_and_print_online("System", role_play_session.user_sys_msg)

        _, input_user_msg = role_play_session.init_chat(None, None, self_task_improve_prompt)
        assistant_response, user_response = role_play_session.step(input_user_msg, True)
        revised_task_prompt = assistant_response.msg.content.split("<INFO>")[-1].lower().strip()
        log_and_print_online(role_play_session.assistant_agent.role_name, assistant_response.msg.content)
        log_and_print_online(
            "**[Task Prompt Self Improvement]**\n**Original Task Prompt**: {}\n**Improved Task Prompt**: {}".format(
                task_prompt, revised_task_prompt))
        return revised_task_prompt

作者 east

chatgpt 9月 11,2023

清华开源ChatGPT自动编程ChatDev项目结构和关键代码解析

这个项目的详细解析如下：

项目概述：ChatDev是一个使用自然语言描述的想法来创建定制软件的项目，它通过多智能体协作的方式来实现软件开发的各个阶段，包括设计、编码、测试和文档 ¹ 。ChatDev的目标是提供一个易于使用、高度可定制和可扩展的框架，基于大型语言模型（LLM），作为研究集体智能的理想场景 ¹。
项目作用：ChatDev可以让用户通过简单的自然语言描述来构建自己想要的软件，无需编程知识或技能。用户只需要提供一个简单的想法，例如“我想要一个五子棋游戏”，就可以让ChatDev的智能体们协同工作，生成一个完整的五子棋软件，包括界面、逻辑、功能和文档 ¹ 。用户可以在过程中与智能体们进行交互，提供反馈或修改需求，从而得到更满意的结果 ¹。
项目结构：ChatDev的项目结构如下：
项目关键代码详细解析：
- run.py：这个文件是项目运行时最先执行的代码，它首先导入了chatdev模块中定义的Company类，并创建了一个Company对象company。然后它调用company.init()方法来初始化公司配置，并打印出公司名称和使命。接下来它调用company.start()方法来启动公司的运行，这个方法会创建一个新的线程来执行company.run()方法，这个方法是公司运行的主循环。然后它调用company.input()方法来接收用户输入，并将用户输入传递给company.handle_input()方法，这个方法会根据用户输入的内容来执行相应的操作，例如创建新的软件项目、查看已有的软件项目、切换在线日志模式或回放模式等。最后它调用company.stop()方法来停止公司的运行，并释放资源。
- chatdev/company.py：这个文件定义了Company类，这个类是ChatDev的核心类，代表了一个虚拟的软件公司。Company类有以下几个主要属性和方法：
  - __init__()：这个方法是Company类的构造函数，它接受一个参数config，表示公司配置文件的路径。它首先调用load_config()方法来加载配置文件，并将配置信息保存在self.config属性中。然后它创建了一个空列表self.projects，用于存储公司创建的软件项目。接着它创建了一个空字典self.agents，用于存储公司拥有的智能体。最后它创建了一个空队列self.queue，用于存储智能体之间的消息。
  - load_config()：这个方法用于加载配置文件，并返回一个字典对象，包含了配置信息。它首先使用json模块打开配置文件，并将其解析为一个Python对象。然后它检查配置信息是否合法，例如是否包含了必要的字段，是否符合预期的格式等。如果配置信息合法，它就返回这个对象，否则它就抛出一个异常。
  - init()：这个方法用于初始化公司，根据配置信息创建智能体并分配角色。它首先遍历配置信息中的agents字段，对于每个智能体，它根据其类型和名称创建一个Agent对象，并将其添加到self.agents字典中，以名称为键，对象为值。然后它遍历配置信息中的roles字段，对于每个角色，它根据其名称和成员列表创建一个Role对象，并将其添加到self.agents字典中，以名称为键，对象为值。最后它遍历配置信息中的relations字段，对于每个关系，它根据其类型和成员列表创建一个Relation对象，并将其添加到self.agents字典中，以类型为键，对象为值。
  - start()：这个方法用于启动公司的运行，它创建了一个新的线程来执行self.run()方法，并将其保存在self.thread属性中。
  - stop()：这个方法用于停止公司的运行，它向self.queue队列中发送一个特殊的消息”STOP”，表示终止信号，并等待self.thread线程结束。
  - run()：这个方法是公司运行的主循环，它不断地从self.queue队列中获取消息，并根据消息内容进行处理。如果消息是”STOP”，表示终止信号，它就退出循环并结束线程。如果消息是一个元组(msg, sender, receiver)，表示智能体之间的通信消息，它就调用handle_message()方法来处理这个消息。如果消息是其他类型，表示异常情况，它就打印出错误信息并忽略这个消息。
  - handle_message()：这个方法用于处理智能体之间的通信消息，它接受三个参数msg, sender, receiver，分别表示消息内容

作者 east

mysql, 大数据开发, 提示词 9月 7,2023

java批量生成海量测试数据及用ChatGPT提示语一键生成的方法

在做大数据开发时，为了测试性能等，需要上千万，甚至TB或PB级别的，在测试环境可能没有那么多数据，这时可以考虑进行造测试数据。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.Random;

public class TestDataGenerator {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/your_database";
        String username = "your_username";
        String password = "your_password";
        int batchSize = 1000; // 每批次插入的数据量
        int totalRecords = 1000000; // 总共要生成的数据量

        try {
            Connection connection = DriverManager.getConnection(url, username, password);
            connection.setAutoCommit(false);

            String insertQuery = "INSERT INTO test (id, callid, type, ...其他列...) VALUES (?, ?, ?, ...其他值...)";
            PreparedStatement preparedStatement = connection.prepareStatement(insertQuery);

            Random random = new Random();

            for (int i = 1; i <= totalRecords; i++) {
                // 设置每个字段的值，根据表结构设置对应的数据生成逻辑
                preparedStatement.setLong(1, i);
                preparedStatement.setString(2, "CallSheet" + i);
                preparedStatement.setString(3, "Type" + (random.nextInt(5) + 1));
                // 设置其他字段的值...

                preparedStatement.addBatch();

                if (i % batchSize == 0) {
                    preparedStatement.executeBatch();
                    connection.commit();
                }
            }

            preparedStatement.executeBatch();
            connection.commit();

            preparedStatement.close();
            connection.close();

            System.out.println("测试数据生成完成！");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

请将上述示例中的数据库连接信息和插入逻辑根据您的数据库设置和表结构进行相应的修改。此程序将会在数据库中插入海量测试数据。

更方便的方法是在ChatGPT等大模型，输入下面提示语：

根据下面的表结构，生成100万的测试数据，给出详细的java实现代码或存储过程代码：【表结构】

亲测在New Bing是可以生成可以运行的代码。

作者 east

分类归档人工智能