原文：https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents

这篇文章由 Anthropic 工程团队于 2026 年 1 月发布，是一篇关于如何系统性地评估（Evaluations / Evals）AI 智能体（AI Agents）的实战指南。文章的核心观点是：“没有评估体系的团队在生产环境中无异于‘盲目飞行’（Flying blind），根本无法区分真正的性能退化（Regression）和系统的随机噪音”。

评估是 AI Agent 走向严肃软件工程的基础。以下是文章的核心要点总结：

1. 为什么 Agent 的评估比传统 LLM 更难？

• 从单轮转向多轮（Multi-turn）：传统大模型的评估通常是“提示词-回复-打分”的单轮模式。而 Agent 涉及多步推理、工具调用（Tool use）、修改环境状态等复杂操作。
• 误差的传播与复合：在多步操作中，早期的一个小错误可能会像滚雪球一样在后续步骤中被放大并导致彻底偏离目标。
• 非确定性（Non-determinism）：Agent 在相同任务下可能表现出不同的行为路径。更棘手的是，它们常常能找到出乎意料的“捷径”或“漏洞”来完成任务，导致死板的基准测试在误判它们“失败”时，用户反而觉得是“成功”的。

2. 推荐的三种评分器（Graders）组合

为了应对复杂性，Anthropic 建议结合使用以下三种评分机制：

• 基于代码的评分器（Code-based graders）：如单元测试、正则匹配、静态分析或状态检查。
  • 特点：速度快、成本低、客观且可复现。
  • 缺点：过于死板，容易对 Agent 找出的有效但非标准的解决方案产生误判。
• 基于模型的评分器（Model-based / LLM-as-a-judge）：让另一个大模型根据评分细则进行打分或进行成对比较。
  • 特点：极其灵活，能处理细微差别和带有主观性质的标准。
  • 缺点：自身具有非确定性，需要不断的人工校准。
• 人类评分员（Human graders）：人工审核。
  • 特点：代表“黄金标准”，保真度最高。
  • 缺点：极其缓慢且昂贵。通常用于小规模抽查、A/B 测试或为模型评分器做校准对齐。

3. 两类不同目标的评估集

评估不应一成不变，文章建议将其分为两种不同目的的测试集：

• 能力评估（Capability Evals）：“这个 Agent 究竟能做到什么？”。这类评估通常面临最具挑战性的前沿任务，初始通过率往往很低，它为你提供了一座“需要攀登的山峰”。
• 回归评估（Regression Evals）：“它原来的功能还没坏吧？”。当 Agent 掌握了能力评估中的某项技能后，该测试用例就会“毕业”进入回归测试集。这里的通过率应保持在近乎 100%，它的作用是作为安全网，防止你在优化新功能时把老系统搞崩溃。

4. 解决“非确定性”的指标设计

由于 Agent 每次运行的轨迹可能不同，简单的单次测试无法反映真实水平。文章推荐针对性地使用不同指标：

• pass@k：在 $k$ 次尝试中只要成功 1 次就算通过。用于衡量模型能力的“上限”和潜力。
• pass^k（连续成功）：连续 $k$ 次尝试必须全部成功。用于衡量模型在生产环境中行为的“绝对可靠性”。

5. 高价值的最佳实践与建议

• 尽早开始，以评测驱动开发（Eval-driven development）：不要等系统庞大时再建评估。建议初期先手写 20-50 个核心任务，明确“成功的定义”（类似测试驱动开发 TDD）。等待的时间越长，构建评估体系的难度就越大。
• 务必阅读执行日志（Read the transcripts!）：这是验证评估质量的唯一方法。不要只看最终的评分，你必须去看 Agent 的执行轨迹。很多时候评估跑出了“失败”，实际上是因为 Agent 找到了比参考答案更好、更聪明的解法，只是评分器没有预料到。
• 构建正反平衡的测试集：不要只测试 Agent“应该做什么”（例如：遇到不懂的问题应该去搜索网页），也要测试它“不该做什么”（例如：问它常识问题时不要过度搜索）。偏科的评估会训练出行为极端的 Agent。
• 区分生成内容与执行路径：通常来说，评估 Agent 最终产生了什么结果（Outcome），比评估它具体通过什么路径完成（Transcript/Path）更加有效且稳健。

总结：

Anthropic 的这篇文章指出，AI 行业的壁垒正在发生转移。模型、提示词和数据正在商品化，而系统性、科学地衡量 Agent 性能的“评估能力”，才是区分一个玩具 Demo 和成熟商业产品的真正护城河。建立可靠的评估体系（Evals）虽然前期枯燥且投入大，但它的价值会在整个 AI Agent 的生命周期中产生复利。

揭开 AI Agent评估的奥秘最先出现在haoblog。

1. 介绍

官方文档：https://docs.langchain.com/oss/python/deepagents/overview

中文文档：https://langchain-doc.cn/v1/python/deepagents/overview.html

DeepAgents 是一个独立库，用于构建能够处理复杂多步骤任务的代理。深度代理基于 LangGraph，灵感来自 Claude Code、Deep Research 和 Manus 等应用程序，具备规划功能、用于上下文管理的文件系统以及生成子代理的能力。

何时使用Deepagents

当你想构建能够：

• 处理需要规划和分解的复杂多步骤任务
• 通过文件系统工具管理大量上下文
• 将工作委托给专门的子代理以实现上下文隔离
• 跨对话和线程持续保存记忆

如果想构建更简单的代理，可以考虑使用 LangChain 的 create_agent 或构建自定义的 LangGraph 工作流程。

2. 安装

pip install deepagents
# 其他依赖: LangChain 模型对象 富文本控制台
pip install langchain_openai rich

3. 第一个例程

agent.py

import argparse
import asyncio
from langchain_openai import ChatOpenAI
from deepagents import create_deep_agent
from langchain_core.messages import SystemMessage, HumanMessage
from deepagents.backends import FilesystemBackend
from console import *

model_config = {
    "model": "YOU_MODEL",
    "base_url": "YOU_BASE_URL",
    "api_key": "YOU_API_KEY",
    "temperature": 0.1,
    "extra_body": {}# {"reasoning_effort": "medium"}
}

async def main(prompt: str):
    agent = create_deep_agent(
        model=ChatOpenAI(**model_config),
        memory=["./AGENTS.md"],
        skills=["./skills"],
        # tools=[],
        backend=FilesystemBackend(root_dir=r"/home/ywh/workspace/deepagent", virtual_mode=True),    # 设置virtual_mode，root_dir才会有效，否则root_dir是根目录
    )
    display = AgentDisplay()
    console.print()

    # Agent执行循环 - 使用 astream 获取流式状态
    with Live(display.spinner, console=console, refresh_per_second=10, transient=True) as live:
        async for chunk in agent.astream(
            {"messages": [("user", prompt)]},
            config={"configurable": {"thread_id": "deepagent-demo"}},
            stream_mode="values",
        ):
            if "messages" in chunk:
                messages = chunk["messages"]
                if len(messages) > display.printed_count:
                    # Temporarily stop spinner to print
                    live.stop()
                    for msg in messages[display.printed_count:]:
                        display.print_message(msg)
                    display.printed_count = len(messages)
                    # Resume spinner
                    live.start()
                    live.update(display.spinner)

    console.print()
    console.print("[bold green]✓ Done![/]")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="agent script.")
    parser.add_argument('-p', '--prompt', type=str, required=True, help='user prompt')
    args = parser.parse_args()
    asyncio.run(main(prompt=args.prompt))

console.py

from rich.console import Console
from rich.live import Live
from rich.markdown import Markdown
from rich.panel import Panel
from rich.spinner import Spinner
from rich.text import Text
from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
console = Console()

class AgentDisplay:
    """Manages the display of agent progress."""

    def __init__(self):
        self.printed_count = 0
        self.current_status = ""
        self.spinner = Spinner("dots", text="Thinking...")

    def update_status(self, status: str):
        self.current_status = status
        self.spinner = Spinner("dots", text=status)

    def print_message(self, msg):
        """Print a message with nice formatting."""
        if isinstance(msg, HumanMessage):
            console.print(Panel(str(msg.content), title="You", border_style="blue"))

        elif isinstance(msg, AIMessage):
            content = msg.content
            if isinstance(content, list):
                text_parts = [p.get("text", "") for p in content if isinstance(p, dict) and p.get("type") == "text"]
                content = "\n".join(text_parts)

            if content and content.strip():
                console.print(Panel(Markdown(content), title="Agent", border_style="green"))

            if msg.tool_calls:
                for tc in msg.tool_calls:
                    name = tc.get("name", "unknown")
                    args = tc.get("args", {})

                    console.print(f"  [bold cyan]>> {name}...[/]")

        elif isinstance(msg, ToolMessage):
            console.print(f"  [bold cyan]✓ {msg.content}[/]")

这样就完成一个类claude code的可定制化agent。

Deepagents学习最先出现在haoblog。

1 深度学习基础

交叉熵损失（Cross-Entropy Loss）是衡量两个概率分布差异的函数，最早由信息论领域的 Claude Shannon 提出。交叉熵损失广泛应用于机器学习和深度学习模型中，尤其在分类任务中用于优化模型性能。
$$
L_{CE}=-\sum_{i=1}^ny_i\log(\hat{y_i})
$$
其中， $y_i$是真实标签， $\hat{y_i}$是模型预测的概率分布，$n$是分类类别的数量。

交叉熵损失度量了模型输出的概率分布$\hat{y_i}$和真实标签分布$y_i$之间的差异。交叉熵越小，表示两个分布越接近，即预测的类别概率分布越接近真实标签。交叉熵损失的目标是最小化该值，使得模型输出的预测概率与真实标签的分布尽可能接近。

梯度下降法
$$
\theta^i=\theta^{i-1}-\eta\nabla C(\theta^{i-1})
$$

反向传播算法：先前馈计算每一层的状态和激活值，直到最后一层；反向传播计算每一层的误差；计算每一层参数的偏导数，并更新参数。
$$
\delta^{L-1}=\sigma^{\prime}(Z^{L-1})\cdot(W^L)^\top\delta^L
$$
其中，$\delta^{L-1}$是我们需要计算的目标，即 第 L-1 层的误差项。$\delta^L$是 第 L 层的误差项，是计算的起点。$\sigma^{\prime}(Z^{L-1})$是激活函数 σ 在第 L-1 层神经元的加权输入$Z^{L-1}$处的导数值。

梯度消失问题：在神经网络中误差反向传播的过程中，其中需要用到激活函数$\sigma(Z^{L-1})$的导数误差从输出层反向传播时每层都要乘激活函数导数。这样当激活函数导数值小于 1 时 ，误差经过每一层传递都会不断衰减，当网络很深时甚至消失。

解决梯度梯度消失问题方法：

• 选择合适的激活函数
• 用复杂的门结构代替激活函数
• 残差结构

解决过拟合问题方法：

• Dropout
• 损失函数加入适当的正则项

CNN有三个结构上的特性：卷积（局部连接、权重共享）、池化（空间或时间上的次采样）。

DNN、CNN 输入、输出定长；处理输入、输出变长问题效率不高。 而自然语言处理中的语句通常其长度不固定。解决方法：RNN（循环神经网络）。

RNN核心思想： 将处理问题在时序上分解为一系列相同的“单元”，单元的神经网络可以在时序上展开，且能将上一时刻的结果传递给下一时刻，整个网络按时 间轴展开。即可变长。

LSTM（长短时记忆神经网络）：LSTM单元不仅接受$x_t$和$h_{t-1}$，还需建立一个机制(维持一个细胞状态$C_t$) 能
保留前面远处结点信息在长距离传播中不会被丢失。LSTM 通过设计“门”结构实现保留信息和选择信息功能。

遗忘门、输入门、输出门

GRU：简化LSTM，输入门和遗忘门合并为更新门（更新门决定隐状态保留放弃部分）。

2 语言模型与词向量

语言模型基本概念：用句子$S=w_1,w_2,…,w_n$ 的概率 $p(S)$ 刻画句子的合理性（统计自然语言处理的基础模型）

隐马尔科夫模型：该模型是一个双重随机过程，我们无法观测具体的状态序列，只知道状态转移的概率，即模型的状态转换过程是不可观察的（隐蔽的） 而可观察事件的随机过程是隐蔽状态转换过程的随机函数。

词向量

词的表示：自然语言问题要用计算机处理时，第一步要找一种方法把这些符号数字化，成为计 算机方便处理的形式化表示。

神经网络词向量：不计算词之间的共现频度，直接用“基于词的上下文词来预测当前词”或“基于当前词预测上下文词”的方法构造构造低维稠密向量作为词的分布式表示。

神经语言模型：用神经网络方法学习语言模型参数（NLP 里程碑成果）

词的 One-Hot 表示：用一个非常长的、只包含一个1和大量0的向量来表示一个词。每个词的 one-hot 向量长度等于词汇表的大小。向量中，只有该词对应索引的位置是1，其他位置全是0。

Look-up 表（查找表，通常指 Embedding Layer/嵌入层）：一个可以学习的“密码本”或“花名册”，它将高维稀疏的 one-hot 向量“翻译”成低维稠密且有意义的向量（即词向量）。

RNNLM 模型可以保留每个词的全部历史信息，不需简化为n-gram。引入词向量作为输入后不需要数据平滑。

Mikolov等人在2013年，同时提出CBOW（Continuous Bag-of-Words）和Skip-gram模型。主要针对NNLM训练复杂度过高的问题进行改进，简化模型，保留核心部分，以更高效的方法获取词向量。

Word2Vec主要包含两种模型：Skip-Gram（跳字模型）和CBOW（Continuous Bag of Words，连续词袋模型）。

Skip-Gram与CBOW模型的主要差异在于训练方式：Skip-Gram 通过中心词预测上下文词汇，类似于“由点及面”的扩展；而CBOW则是利用上下文词汇预测中心词，类似于“由面定点”的填充。前者注重于从局部到整体的推理，后者则强调整体对局部的反映。

模型真正的目标不是完美地完成这个预测任务，而是在完成这个任务的过程中，让模型学会的权重参数能够很好地捕捉词语的语义和语法信息。模型训练好之后，词向量是输入层到隐藏层的权重矩阵。

3 预训练语言模型

动态词向量（ELMo）的核心理念：一个词的向量表示是基于其完整的上下文动态生成的。同一个词在不同的句子中会有不同的向量。

1. Word2Vec是“一个词，一个向量”；ELMo是“一个实例（occurrence）一个向量”。
2. 解决一词多义： 这是ELMo最大的贡献。它能为“我今天吃了一个苹果”和“我买了一部苹果手机”中的两个“苹果”生成不同的向量，准确捕捉其语义差异。

注意力机制

注意力机制是一种模拟人类认知注意力的计算技术，用于处理序列数据（如文本）。其核心思想是：对于给定的查询（Query），模型通过计算查询与一系列键（Key）的相似度（如点积），生成注意力权重（经softmax归一化），然后使用这些权重对对应的值（Value）进行加权求和，从而突出输入中相关信息的重要性。简单来说，它允许模型动态地聚焦于输入的不同部分，而不是平等对待所有元素。

自注意力（Self-Attention）：是注意力机制的特殊形式，其中查询、键和值均来自同一输入序列。这使得每个位置可以直接关注序列中的所有其他位置，从而捕获序列内部的长期依赖关系。例如，在句子中，一个词可以通过自注意力直接与句首或句尾的词交互，无需像RNN那样逐步传递信息。这显著提高了模型对全局上下文的理解能力，避免了梯度消失问题。

多头注意力（Multi-Head Attention）：通过使用多个独立的注意力头（每个头学习不同的查询、键、值投影），模型能够并行地从多个子空间（如语法、语义、语用等角度）捕获多样化的上下文信息。多个头的输出被拼接和线性变换，集成不同视角的注意力模式。这种设计增强了模型的表示能力，使其能更鲁棒地处理复杂语言结构（如歧义或长距离依赖），防止过拟合到单一模式。多头就是做多次同样的事情（参数不共享），然后把结果拼接。

• 长距离依赖建模困难
• 上下文理解

Transformer

Transformer的原始结构。它包含两个主要部分：

• 编码器：双向编码，擅长理解和表征输入。它是双向的，在计算每个词的表示时，可以同时看到其左右上下文的所有词。
• 解码器：单向自回归，擅长生成序列。它是单向的，在计算当前词的表示时，只能看到它左边（之前）的词，这是为了在生成时不会“偷看”到未来的答案。

GPT 模型结构：GPT 采⽤了 Transformer 的 Decoder 部分，并且每个⼦层只有⼀个 Masked Multi Self-Attention（768 维向量和 12 个 Attention Head）和⼀个 Feed Forward，模型共叠加使用了 12 层的 Decoder普通transformer解码器层的编码器-解码器注意力子层。

Bert 模型结构：使用堆叠的双向Transformer Encoder，在所有层中共同依赖于左右上下文基础版是12个Encoder (12层 )；高级版24个Encoder (24层 )。

BART 模型结构：BART采用标准Transformer结构

T5：给整个NLP 预训练模型领域提供了一个通用框架，把所有NLP任务都转化成一种形式(Text-to-Text)，通过这样的方式可以用同样的模型，同样的损失函数，同样的训练过程，同样的解码过程来完成所有 NLP 任务。

4 大语言模型

RAG

基于LLM的检索式生成模型，包括检索器 Retriever、生成式语言模型LLM、知识库 knowledge Base

上下文学习（In-context Learning）是一种学习范式，是现代自然语言处理领域中一种重要的学习方法，尤其在使用大规模，尤其在使用大规模预训练模型时，它允许模型在给定的上下文中进行学习和推理，而无需真正更新模型参数。

Fine-tuning

微调（Fine-tuning）：预训练好的模型然后在特定任务的数据上进行进一步的训练。这个过程通常涉及对模型的权重进行微小的调整，以使其更好地适应特定的任务，得到最终能力各异的模型。

大模型微调的方法：

• 全量微调通过在预训练的大型模型基础上调整所有层和参数，使其适应特定任务。这一过程使用较小的学习率和特定任务的数据进行，可以充分利用预训练模型的通用特征，但可能需要更多的计算资源。
• 参数高效微调（PEFT）技术旨在通过最小化微调参数的数量和计算复杂度，来提高预训练模型在新任务上的性能，从而缓解大型预训练模型的训练成本。PEFT包括LORA、QLoRA、Adapter Tuning、Prefix Tuning、Prompt Tuning、P-Tuning及P-Tuning v2等。

Adapter模块的添加导致模型整体参数量增加，降低了模型推理时的性能。 与全量微调相比Adapter在训练时快60%，但是在推理时慢4%-6%。

Lora没有推理延迟，但需要预先指定每个增量矩阵的秩r ，忽略了在微调预训练模型时，权重矩阵的重要性在不同模块和层之间存在显著差异。LoRA 块大小固定，训练后无法修改，如果需要调整矩阵的秩，只能从头开始训练。优化并找到不同秩下面的最优模型是一个繁琐的过程。

自然语言处理笔记最先出现在haoblog。

1. 前言

在大语言模型进行微调的流程中，一般在监督微调（Supervised Fine-Tuning，SFT）阶段之后，进一步通过强化学习对模型进行优化可以显著提升其性能。而群体相对策略优化（Group Relative Policy Optimization，GRPO），就是使用在该阶段，替换传统的近端策略优化（Proximal Policy Optimization，PPO）算法。

PPO是OpenAI在2017提出的一种强化学习算法，适用于对 LLM 进行微调。PPO 的目标是通过最大化以下替代目标函数来优化策略模型。

GRPO不再需要像PPO那样加入额外的价值函数近似，而是直接使用多个采样输出的平均奖励作为Baseline，显著减少了训练资源的使用。

2. GRPO与PPO的区别

PPO基于优势函数估计和 KL 散度约束的策略优化。

1. 利用价值网络（Critic网络）估计状态价值$V$，使用广义优势函数（GAE ）估计优势$A$。

• 估计优势函数GAE：核心思想是通过时间差分（TD）误差的加权和，估计优势函数。

• $γ$（折扣因子）：$γ$ 越小，智能体越关注即时奖励（短视）；$γ$ 越大，智能体越考虑长期收益（但可能导致训练不稳定）。
• $λ$（GAE权衡参数）：$λ=0$，仅使用单步TD误差（低方差，高偏差），等价于原始策略梯度；$λ=1$：使用无限步MC误差（高方差，低偏差），接近蒙特卡洛估计；

2. 构建带 KL 惩罚的目标函数进行策略更新

• KL散度定义：它衡量的是同一个随机变量X的两个概率分布P和Q之间的差异。注意，它衡量的是用分布Q来近似分布P时所损失的信息量。从信息论的角度解释，KL散度 = 交叉熵 - 信息熵。

• KL惩罚项：策略模型和参考模型之间的KL散度来正则化，有四种。

• PPO使用K1作为惩罚项加入奖励中；GRPO使用K3作为惩罚项直接加到损失中。GRPO目标是省去Critic网络，直接用Reward的统计量（均值和标准差）来替代优势函数，简化计算。

3. 模型结构

1. GRPO模型结构：Policy Model->Reference Model+Reward Model->Group Computation

2. Policy Loss：

• PPO：剪裁后的替代目标函数
  
  在奖励中加入 KL 惩罚项
  
• GRPO：剪裁后的替代目标函数+策略模型和参考模型之间的 KL 散度来正则化
  
  优势函数估计
  

3. Reference Model：基准模型，用于防止训练过程中模型过度偏移原始分布，确保稳定性。

4. Reward Model：

• 最常见的Reward Model有两种：(i) Outcome Reward Model (ORM)：这种模型关注的是最终结果的质量，即模型生成的输出是否满足目标要求。ORM通过对生成的最终答案进行评分，来评估模型的表现。(ii) Process Reward Model (PRM)：与ORM不同，PRM不仅仅关注最终答案，还对模型的推理过程进行评分。PRM在生成答案的过程中逐步激励或惩罚模型，引导模型朝着更可解释、更稳定的推理路径发展。
• 论文arxiv.org区分了三种奖励生成范式（Reward Generation Paradigms）主要方法：标量、半标量和生成式。(a) 标量方法为给定的查询和响应分配标量值。(标量值是一个单一的数值，通常用来表示某种评价或奖励。)(b) 半标量方法生成文本判断，称为“批评”，以及标量奖励值。(批评是一种更详细的反馈，以文本形式呈现。)(c) 生成方法只生成批评作为文本奖励，可以从中提取奖励值。评分模式 (Scoring Patterns) 主要有两种：(i) 点式 (Pointwise)：这种方法独立地为每一个给定的回复分配一个分数。它可以接受单个或多个回复作为输入，并为每个回复都给出一个评估。(ii) 成对 (Pairwise)：这种方法主要考虑两个回复之间的相对偏好。模型通常会判断在给定的两个回复中，哪一个更好。虽然这种方法可以扩展到处理多个回复，但通常需要额外的技术。
• 3种奖励生成范式+2种评分模式组成5种Reward Model(a) 标量 (Scalar) + (i) 点式 (Pointwise) - 代表方法：Bradley-Terry(a) 标量 (Scalar) + (ii) 成对 (Pairwise) - 代表方法：PairRM(b) 半标量 (Semi-Scalar) + (i) 点式 (Pointwise) - 代表方法：CLoud(b)/(c) 生成式 (Generative) + (ii) 成对 (Pairwise) - 代表方法：LLM-as-a-Judge / TokenProb(c) 生成式 (Generative) + (i) 点式 (Pointwise) - 代表方法：GRM

DeepSeek R1 Reward Model由准确性奖励（Accuracy rewards）和格式奖励（Format rewards）组成。

• Accuracy rewards：评估模型的回复是否准确。基于规则的。
• Format rewards：强制模型将思考过程放在'<think>'和'</think>'之间。

DeepSeek 生成式奖励模型（GRM）将自原则批评调整（SPCT）用于逐点GRMs，SPCT 由两个阶段组成：拒绝性微调（RFT），作为冷启动，以及基于规则的在线RL，通过推进生成的原则实现强化通用奖励的生成。SPCT也在GRM中培养这些行为，以实现推理时间缩放。

• 拒绝性微调：核心理念是使 GRM 能够以正确的格式并针对各种输入类型生成原则（Principles）和评论（Critiques）。（通过在微调过程中主动过滤掉低质量或无信息量的训练数据来提高GRM的质量和可靠性。）点式 GRM，对于每个查询和相应的响应，都要进行 NRFT 次采样。以生成可能的轨迹 ？{Principles, Critiques, Raw_Reward}剔除预测奖励（Predicted Reward）与真实奖励（Ground Truth）不一致的轨迹（不正确），以及查询和回复中所有 NRFT 轨迹都正确的轨迹（太容易）。

• 基于规则的在线RL：采用GRPO算法框架，使用基于规则的ORM

1. GRM根据查询x和多个回复y_i，实时生成对应的奖励Principles和Critiques。
2. Predicted Reward，与​​Ground Truth（基于规则生成）进行比对。
3. 只有一个回复（n=1），模型Predicted Reward Sj等于基于规则给的Ground Truth rj，奖励为1。多个回复（n>1），模型Predicted Reward Sj’最大，刚好对应的Ground Truth也是最大的，奖励为1。其他情况，奖励为-1。

参考文献

详解DeepSeek-R1核心强化学习算法：GRPO
GAE 广义优势估计
PPO、GRPO等RL中的KL散度计算方法及实现
Guo D, Yang D, Zhang H, et al. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning[J]. arXiv preprint arXiv:2501.12948, 2025.
Shao Z, Wang P, Zhu Q, et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models[J]. arXiv preprint arXiv:2402.03300, 2024.

大模型后训练强化学习方法-GRPO&PPO最先出现在haoblog。

一、OpenWebUI

1. 安装OpenWebUI

下面内容都是通过PiP部署的，非docker。

# 官方要求python3.11
pip3 install open-webui

2. 开启OpenWebUI服务

open-webui serve

开启后，在127.0.0.1:8080访问openwebui网页。

因为我的云服务只有2G，跑不了这么多服务，我把OpenWebUI部署在本地，通过Frp内网穿透实现外部访问。

二、Pipelines

官方文档：管道 | 开放式 WebUI --- ⚡ Pipelines | Open WebUI

1. 克隆 Pipelines 存储库：

git clone https://github.com/open-webui/pipelines.git
cd pipelines

2. 安装所需的依赖项：

pip install -r requirements.txt

3. 启动 Pipelines 服务器

sh ./start.sh
# 出现Linux 运行 sh 脚本有 \r 字符的问题
# 解决方法：sudo sed -i 's/\r//' test.shsudo sed -i 's/\r//' test.sh

4. 连接Pipelines 服务器

OpenWebUI 设置-外部连接，添加 URL 设置为 http://localhost:9099，将 API 密钥（默认）设置为 0p3n-w3bu!

点击验证，弹出已验证服务器连接的提示，表面Pipelines启动成功。

三、Langgraph

上述步骤，连通OpenWebUI和Pipelines，现在需要在Pipelines中配置Langgraph。

langgraph pipeline案例路径在：pipelines/examples/pipelines/integrations/langgraph_pipeline

里面有两个文件：

1. langgraph_example.py ：langgraph的程序
2. langgraph_stream_pipeline.py：提供与langgraph程序连接的数据管道，里面定义了langgraph的Pipeline类，这个文件不用改，使用的时候需要copy到pipelines/pipelines/目录下，重启pipelines服务即可加载langgraph_example模型。

1. langgraph_example.py

找到其中llm配置，改成自己的API。

llm = ChatOpenAI(
    model="deepseek-r1-250120",
    temperature=0.1,
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key='***********************************'
)

启动langgraph程序，steam里面默认是9000。

uvicorn langgraph_example:app --reload --port 9000 --host 127.0.0.1

启动成功。

2. langgraph_stream_pipeline.py

把pipelines/examples/pipelines/integrations/langgraph_pipeline/langgraph_stream_pipeline.py复制到pipelines/pipelines/下。

重启Pipelines，自动加载Pipelines/Pipelines/下的所有module，加载成功。

并产生一个新的文件夹langgraph_stream_pipeline

四、Frp

Releases · fatedier/frp

根据系统内核选择相应的frp

# linux查看内核 x86_64, AMD64, i386->AMD | aarch64, arm64, ARM->​​ARM​
uname -m
# windows查看内核，cmd
echo %PROCESSOR_ARCHITECTURE%

1. 服务端

frps配置，还可以配置http服务等等

启动frps

./frps -c frps.toml

2. 客户端

启动frpc

frpc -c frpc.toml

在服务器端反向代理6000端口，就可以实现外部访问了。

五、效果

可以自定义langgraph实现更强的功能。

OpenWebUI配置Pipelines连接自定义Langgraph模型最先出现在haoblog。

1 多模态数据融合

模态表示是将不同感官或交互方式的数据（如文本、图像、声音等）转换为计算机可理解和处理的形式，以便进行后续的计算、分析和融合。多模态融合能够充分利用不同模态之间的互补性，它将抽取自不同模态的信息整合成一个稳定的多模态表征。从数据处理的层次角度将多模态融合分为数据级融合、特征级融合和目标级融合。

• （a）数据级融合，也称为像素级融合或原始数据融合，是在最底层的数据级别上进行融合。这种融合方式通常发生在数据预处理阶段，即将来自不同模态的原始数据直接合并或叠加在一起，形成一个新的数据集。
• （b）特征级融合是在特征提取之后、决策之前进行的融合。不同模态的数据首先被分别处理，提取出各自的特征表示，然后将这些特征表示在某一特征层上进行融合。
• （c）目标级融合，也称为决策级融合或后期融合，是在各个单模态模型分别做出决策之后进行的融合。每个模态的模型首先独立地处理数据并给出自己的预测结果（如分类标签、回归值等），然后将这些预测结果进行整合以得到最终的决策结果。

多模态人工智能（Multimodal Artificial Intelligence）涉及各种类型的数据（如图像、文本或从不同传感器收集的数据）、特征工程（如提取、组合/融合）和决策（如多数票）。随着架构越来越复杂，多模态神经网络可以将特征提取、特征融合和决策过程整合到一个模型中。这些过程之间的界限越来越模糊。[1]提出了一种新的细粒度分类法，将最先进的（SOTA）模型分为五类：编码器-解码器方法、注意机制方法、图神经网络方法（GNN）、生成神经网络方法（GenNN）和其他基于约束的方法。

2 华为智驾系统ADS

华为ADS采用"激光雷达（Lidar）+毫米波雷达（Radar）+视觉摄像头（Camera）+超声波传感器（IMU）"的多模态融合方案。决策层，基于深度学习的混合决策模型，融合规则驱动与数据驱动方法。

ADS3.0架构仅车端，采用端到端大模型，其中感知部分使用GOD（通用障碍物识别）大感知网络，而决策规划部分通过PDP（预测-决策-规划）网络来实现，同时添加本能安全网络提升表现。

ADS4架构增加云端的世界引擎，难例扩散生成模型，安全强化学习。车端为全模态感知、MoE混合专家模型。

Tokenizer 是一种将原始数据（如文字、图像或视频）转化为模型可以处理的基础单位（即 Token）的工具。Token是否能够代表原始数据的含义，直接影响模型的输入质量和后续处理效率。

• 文字由于其离散性，主要以基于词表的方法构建Tokenizer，因此变体较少。
• 图像或者视频没有类似文字的“离散语义单位”，需要通过人工设计或模型提取来划分为 token 表示。主要代表模型：VIT（Vision Transformer）。

3 华为鸿蒙座舱

参考

一文彻底搞懂多模态：模态表示、多模态融合、跨模态对齐-CSDN博客
华为乾崑智能汽车解决方案
华为乾崑ADS1.0到4.0全面梳理，D5激光雷达2025 年将发布 - 知乎
多模态Tokenizer总结 - 知乎
[1] Fei Zhao, Chengcui Zhang, and Baocheng Geng. 2024. Deep Multimodal Data Fusion. ACM Comput. Surv. 56, 9, Article 216 (September 2024), 36 pages. https://doi.org/10.1145/3649447

华为乾崑智能汽车解决方案-学习最先出现在haoblog。

好久没更新了，这次借国科大深度学习作业来更新一下，挺有意思的。

1 模型训练

1.1 图像数据获取

要想做自己的目标检测，得找相关的数据集，可以自己采集和标注，也可以找开源的，这里我找了个开源的CS2警匪标注数据。

CS2警匪标注数据Yolov8-CS2-detection/data at main · ZeeChono/Yolov8-CS2-detection

新建一个数据集文件夹dataset，把images和labels放到dataset里。

1.2 配置训练参数

数据集配置文件cs2.yaml

• 修改path、train、val、test的目录路径为自定义数据集路径
• 类别为CT、T、CTh、Th

# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# COCO128 dataset https://www.kaggle.com/datasets/ultralytics/coco128 (first 128 images from COCO train2017) by Ultralytics
# Example usage: python train.py --data coco128.yaml
# parent
# ├── yolov5
# └── datasets
#     └── coco128  ← downloads here (7 MB)

# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
path: ./datasets # dataset root dir
train: images/train # train images (relative to 'path') 128 images
val: images/val # val images (relative to 'path') 128 images
test: # test images (optional)

# Classes
names:
  0: CT
  1: T
  2: CTh
  3: Th

# Download script/URL (optional)
#download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco128.zip

模型配置文件yolov5m_CS2.yaml

在models目录下，拷贝yolov5m.yaml为自定义，修改

• nc改为4

1.3 训练

python train.py --cfg models/yolov5m_CS2.yaml --data datasets/cs2.yaml --weights yolov5m6.pt --epoch 150 --batch-size 32

我用的北京超算云平台，pytorch环境配置

# 创建虚拟环境
conda create -n py39 python=3.9
# 激活/退出
conda activate text
conda deactivate text
# 设置源
pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/
# 下载依赖包
pip install -r requirements.txt

任务脚本run.sh

#!/bin/bash

module load anaconda/2020.11
module load cuda/11.7
source activate py39dlywh

python train.py --cfg models/yolov5m_CS2.yaml --data datasets/cs2.yaml --weights yolov5m6.pt --epoch 150 --batch-size 32

提交任务

sbatch --gpus=1 ./run.sh

查看日志

tail -f slurm-[id].out

训练结果

run/train/exp最后一个，最好的模型权重weight/best.pt

验证集效果

2 屏幕实时检测

2.1 思路

• 使用 mss 实时抓屏
• 使用 YOLOv5 做目标检测
• 使用 PyQt5 创建一个透明全屏窗口（无边框、置顶、不干扰鼠标）
• 每帧更新绘图（检测框和标签），实现自动刷新、不残留

# screendetect.py

import sys
import cv2
import torch
import numpy as np
import mss
import time
import pathlib
temp = pathlib.PosixPath
pathlib.PosixPath = pathlib.WindowsPath

from PyQt5.QtWidgets import QApplication, QWidget
from PyQt5.QtGui import QPainter, QColor, QPen, QFont
from PyQt5.QtCore import Qt, QTimer

# === 模型路径 ===
MODEL_PATH = 'runs/train/exp20/weights/best.pt'

# === YOLOv5 设置 ===
from models.common import DetectMultiBackend
from utils.general import non_max_suppression, scale_boxes
from utils.torch_utils import select_device
from utils.augmentations import letterbox

# === 初始化模型 ===
device = select_device('')
model = DetectMultiBackend(MODEL_PATH, device=device)
stride, names = model.stride, model.names
imgsz = (640, 640)

# === 屏幕区域 ===
monitor = {"top": 0, "left": 0, "width": 1920, "height": 1080}
sct = mss.mss()

# === 检测框数据 ===
detections = []  # 每帧更新


# === PyQt5 覆盖窗口类 ===
class Overlay(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('Screen Overlay')
        self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint | Qt.Tool)
        self.setAttribute(Qt.WA_TranslucentBackground)
        self.setAttribute(Qt.WA_TransparentForMouseEvents)  # 鼠标穿透

        screen_geometry = QApplication.desktop().screenGeometry()
        self.setGeometry(screen_geometry)

        # 定时器：每 30ms 更新一次
        self.timer = QTimer()
        self.timer.timeout.connect(self.update_overlay)
        self.timer.start(30)

    def update_overlay(self):
        self.update()  # 触发 paintEvent 重绘

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)

        # 设置字体
        font = QFont()
        font.setPointSize(10)
        painter.setFont(font)

        # 绘制所有检测框
        for det in detections:
            x1, y1, x2, y2, label = det
            pen = QPen(QColor(0, 255, 0), 2)
            painter.setPen(pen)
            painter.drawRect(x1, y1, x2 - x1, y2 - y1)

            painter.drawText(x1, y1 - 5, label)

        painter.end()


# === 后台检测循环 ===
def detect_loop():
    global detections

    while True:
        screenshot = np.array(sct.grab(monitor))[:, :, :3]
        im0 = np.ascontiguousarray(screenshot)

        img = letterbox(im0, imgsz, stride=stride, auto=True)[0]
        img = img.transpose((2, 0, 1))  # HWC to CHW
        img = np.ascontiguousarray(img)
        img = torch.from_numpy(img).to(device)
        img = img.float() / 255.0
        if img.ndimension() == 3:
            img = img.unsqueeze(0)

        pred = model(img, augment=False, visualize=False)
        pred = non_max_suppression(pred, conf_thres=0.4, iou_thres=0.45)

        new_detections = []
        for det in pred:
            if len(det):
                det[:, :4] = scale_boxes(img.shape[2:], det[:, :4], im0.shape).round()
                for *xyxy, conf, cls in det:
                    label = f'{names[int(cls)]} {conf:.2f}'
                    x1, y1, x2, y2 = map(int, xyxy)
                    new_detections.append((x1, y1, x2, y2, label))

        detections = new_detections
        time.sleep(0.03)  # 降低 CPU 占用


# === 主入口 ===
if __name__ == '__main__':
    from threading import Thread

    # 后台启动检测线程
    thread = Thread(target=detect_loop, daemon=True)
    thread.start()

    # 启动 PyQt5 覆盖窗口
    app = QApplication(sys.argv)
    overlay = Overlay()
    overlay.show()
    sys.exit(app.exec_())

2.2 效果

声明：仅可用于个人学习、研究、离线演示等合法场景，不能用于破坏游戏公平性。

Yolov5实时检测CS2中警和匪最先出现在haoblog。

一、引言

1.1 研究背景与意义

股票市场作为经济的重要组成部分，其走势的准确预测一直是投资者、金融机构和研究者关注的焦点。股票价格受到众多复杂因素的影响，如宏观经济状况、公司财务状况、政策法规、行业竞争以及投资者情绪等。这些因素相互交织，使得股票市场具有高度的不确定性和波动性，给股票走势预测带来了巨大的挑战。传统的股票走势预测方法主要基于基本面分析和技术分析。基本面分析通过研究宏观经济数据、公司财务报表等信息，评估股票的内在价值，从而预测其价格走势。然而，基本面分析往往需要大量的专业知识和时间精力，且对宏观经济环境的变化较为敏感。技术分析则主要通过研究股票的历史价格和成交量等数据，运用各种技术指标和图表形态，来预测股票价格的未来走势。虽然技术分析在一定程度上能够捕捉到股票价格的短期波动规律，但对于长期趋势的预测能力相对有限。

深入研究情感分析在股票预测中的应用具有重要的理论与实践意义。一方面，从理论层面拓展了金融市场研究的边界，打破传统仅依赖基本面与技术面分析的局限，将投资者情绪这一主观因素纳入研究范畴，完善对金融市场价格形成机制的理解。另一方面，在实践中，能够为投资者提供更全面、精准的决策依据，辅助其制定科学合理的投资策略，降低投资风险，提高收益水平；同时，也有助于金融监管部门更好地把握市场情绪动态，及时察觉潜在的市场异常波动，维护金融市场的稳定与健康发展。近年来，随着互联网技术的飞速发展，社交媒体平台上涌现出了大量与股票相关的信息，如股吧中的股民讨论、分析师的评论等。这些信息中蕴含着丰富的投资者情感和市场情绪，为股票走势预测提供了新的视角。情感分析作为自然语言处理的一个重要分支，旨在通过对文本数据的分析，挖掘其中所表达的情感倾向和态度。将情感分析应用于股票市场，能够从投资者的情感角度出发，揭示市场情绪对股票价格的影响，从而为股票走势预测提供更全面的信息。本研究旨在结合LSTM（长短期记忆网络）和股吧情感分析，构建一种新的股票走势预测模型。通过对股吧文本数据进行情感分析，提取投资者的情感特征，并将其与股票的历史价格数据相结合，输入到LSTM模型中进行训练和预测。这种方法能够充分利用LSTM在处理时间序列数据方面的优势，以及情感分析所挖掘出的投资者情感信息，提高股票走势预测的准确性和可靠性。

1.2 相关研究工作

在股票走势预测领域，国内外学者进行了大量的研究工作。早期的研究主要集中在基本面分析和技术分析方法上，随着机器学习和深度学习技术的发展，越来越多的学者开始尝试运用这些技术来预测股票走势。如支持向量机（SVM）、神经网络（NN）、决策树等机器学习算法在股票预测中得到了广泛应用。这些算法在一定程度上提高了预测的准确性，但对于股票市场的复杂非线性关系和长期依赖关系的处理能力有限。为了更好地处理时间序列数据中的长期依赖问题，Hochreiter和Schmidhuber于1997年提出了LSTM模型。LSTM是一种特殊的循环神经网络（RNN），它通过引入门控机制，能够有效地解决传统RNN中存在的梯度消失和梯度爆炸问题，从而在时间序列预测任务中表现出优异的性能。研究表明，LSTM在处理基于时序数据的股票预测问题时性能优于RNN和传统的机器学习算法[1]。近年来，LSTM在股票走势预测中得到了越来越多的应用。一些研究将LSTM与其他技术相结合，如卷积神经网络（CNN）、注意力机制等，进一步提高了预测的准确性。

现有基于LSTM的股票预测模型主要通过分析文本信息的情感极性特征，如[2]使用了判断趋势是上升还是下降的方法。正面新闻往往会导致上升趋势，而负面新闻往往会导致下降趋势。将媒体新闻的情感极性与历史交易数据作为股票预测算法的输入，需要考虑的问题。财经新闻中的情感极性并不明显,大多是对客观事件的总结和报道,使得财经新闻的情感极性分析准确率并不高,影响股票走势的预测准确率。[3]提出一种基于CNN-BiLSTM多特征融合的股票走势预测模型,通过融入新闻事件类型和情感极性提高股票走势预测的准确率。一方面，采用从新闻报道中提取出客观的财经事件,如中标事件、上市事件、停牌事件等；另一方面，采用Bi-LSTM对新闻报道的情感极性进行分析，计算新闻文本的情感分值。通过预测两只个股（家电行业的格力电器和电子电器行业的中兴通讯）准确率比现有算法分别高出 11.6% 和 25.6%，表明新闻事件及其情绪取向可能导致股票价格波动。

随着社交媒体的兴起，股吧作为投资者交流和分享信息的重要平台，其中蕴含的投资者情感信息逐渐受到关注。一些学者开始将情感分析应用于股票市场，研究投资者情感与股票价格之间的关系。如Bollen等人通过对Twitter上的情感数据进行分析，发现投资者的情感倾向与股票市场的波动之间存在一定的相关性。本文通过对东方财富股吧的帖文进行情感分析，构建股市投资者情绪指数，将LSTM和股吧股民的情感分析相结合进行A股走势预测。

二、相关理论与技术

2.1 LSTM原理与优势

2.1.1 LSTM基本结构

LSTM（Long Short-Term Memory）是一种特殊的循环神经网络（RNN），专为解决长序列数据中的长期依赖问题而设计。与传统RNN不同，LSTM通过引入门控机制和细胞状态，能够有效控制信息的流动和存储，从而更好地捕捉时间序列中的长期依赖关系。LSTM的核心结构是记忆单元（Memory Cell），它由一个或多个神经元组成，负责在整个序列处理过程中保持和更新长期依赖信息。记忆单元的状态通过时间步传递，并且仅通过线性方式更新，这使得它能够避免传统RNN中梯度消失或爆炸的问题。

在LSTM中，门控机制起着关键作用，主要包括遗忘门（Forget Gate）、输入门（Input Gate）和输出门（Output Gate）。遗忘门决定从记忆单元中丢弃哪些信息。它通过一个sigmoid函数生成一个0到1之间的值，表示每个状态值的保留程度。当遗忘门开启（激活值接近1）时，对应的记忆单元内容将被显著削弱甚至完全清除；当遗忘门关闭（激活值接近0）时，则相应信息得以保留。数学上，遗忘门的计算公式为：

$$
f_t = \sigma(W_f \cdot [h_{t - 1}, x_t] + b_f)
$$

其中，$f_t$是遗忘门在时间步$t$的输出，$sigma$是sigmoid函数，$W_f$是权重矩阵，$[h_{t - 1}, x_t]$是前一时间步的隐藏状态$h_{t - 1}$和当前时间步的输入$x_t$的拼接，$b_f$是偏置项。

当前时刻新输入信息哪些部分应被添加到记忆单元中。它由两部分构成：一个sigmoid层决定哪些值将被更新，一个tanh层生成新的候选值向量。输入门的sigmoid层和tanh层的输出相乘，得到更新后的候选值。输入门的计算公式为：

输入门决定

$$
i_t = \sigma(W_i \cdot [h_{t - 1}, x_t] + b_i)
$$

$$
\widetilde{C}_t = \tanh(W_c \cdot [h_{t - 1}, x_t] + b_c)
$$

其中，$i_t$是输入门在时间步$t$的输出，$\widetilde{C}_t$是候选记忆单元状态，$W_i$、$W_c$是权重矩阵，$b_i$、$b_c$是偏置项。

记忆单元状态更新是通过遗忘门的输出和输入门的输出相加得到的。这样可以确保网络能够记住重要的长期信息，并遗忘不相关的信息。记忆单元状态更新公式为：

$$
C_t = f_t \cdot C_{t - 1} + i_t \cdot \widetilde{C}_t
$$

其中，$C_t$是时间步$t$的记忆单元状态，$C_{t - 1}$是前一时间步的记忆单元状态。

输出门决定记忆单元状态的哪一部分将被输出到隐藏状态。它通过一个sigmoid层决定哪些单元状态将被输出，然后通过tanh层生成输出状态的候选值，最后将这两部分结合起来形成最终的输出。输出门的计算公式为：

$$
o_t = \sigma(W_o \cdot [h_{t - 1}, x_t]+ b_o)
$$

$$
h_t = o_t \cdot \tanh(C_t)
$$

其中，$o_t$是输出门在时间步$t$的输出，$h_t$是时间步$t$的隐藏状态，$W_o$是权重矩阵，$b_o$是偏置项。

2.1.2 处理时间序列数据的能力

在处理时间序列数据时，LSTM能够有效捕捉数据中的长期依赖关系，这是其相较于其他模型的显著优势。传统的RNN在处理长序列数据时，由于梯度消失或爆炸问题，很难学习到远距离的依赖信息。而LSTM通过门控机制和细胞状态，能够选择性地保留和更新信息，使得重要的信息能够在长时间内传播，从而准确捕捉时间序列中的长期依赖关系。例如，在股票价格预测中，股票价格的波动往往受到过去多个时间点的多种因素影响，这些因素之间的关系可能在较长时间内保持一定的稳定性。LSTM能够通过记忆单元和门控机制，记住过去重要的价格信息、市场情况以及投资者情绪等因素，并根据当前的输入信息对这些记忆进行更新和调整，从而更准确地预测未来的股票价格走势。具体来说，遗忘门可以根据当前信息决定是否遗忘过去的某些信息，输入门可以控制新信息的输入，而输出门则决定哪些信息将被输出用于当前的预测。这种机制使得LSTM能够在处理时间序列数据时，充分利用历史信息，提高预测的准确性。

2.2 股吧情感分析方法

股吧情感分析旨在从股吧中的文本数据中提取投资者的情感倾向，判断其对股票的看法是积极、消极还是中性。本实验采用snownlp库进行股吧情感分析。snownlp是一个基于Python的自然语言处理工具包，它提供了简单易用的情感分析功能。在snownlp中，情感分析是基于训练好的情感分类模型实现的。该模型通过对大量带有情感标签的文本数据进行训练，学习到文本中词语与情感倾向之间的关系。当输入一篇股吧文本时，snownlp首先对文本进行分词处理，将文本分割成一个个词语。然后，根据训练好的模型，计算每个词语的情感得分，并综合考虑整个文本中词语的情感得分，得出该文本的情感倾向。具体而言，snownlp会返回一个介于0到1之间的情感得分，得分越接近1表示文本的情感越积极，得分越接近0表示文本的情感越消极。例如，当分析一篇股吧帖子时，如果帖子中包含大量积极词汇，如"上涨" "利好" "看好"等，snownlp计算出的情感得分可能会较高，表明投资者对该股票持积极态度；反之，如果帖子中出现较多消极词汇，如"下跌" "利空" "看好"等，情感得分则会较低，反映出投资者的消极情绪。除了snownlp，文本情感分析还有其他常用技术。词袋模型（Bag-of-Words）是一种简单的文本表示方法，它将文本中的词语看作是一个无序的集合，忽略词语的顺序和语法结构。通过统计每个词语在文本中出现的频率，构建文本的特征向量，然后利用机器学习算法，如朴素贝叶斯、支持向量机等，对文本的情感进行分类。然而，词袋模型没有考虑词语之间的语义关系，可能会丢失一些重要信息。深度学习模型在情感分析中也得到了广泛应用，如循环神经网络（RNN）及其变体LSTM、门控循环单元（GRU），以及卷积神经网络（CNN）等。这些模型能够自动学习文本的特征表示，捕捉词语之间的上下文关系，从而提高情感分析的准确性。例如，基于LSTM的情感分析模型可以通过门控机制处理文本中的长距离依赖关系，更好地理解文本的语义和情感。不同的情感分析方法各有优缺点，在实际应用中需要根据具体情况选择合适的方法或结合多种方法来提高分析的准确性和可靠性。

三、A 股市场特点及趋势分析

3.1 2020 - 2025 年 A 股整体走势回顾

在 2020 年初，受新冠疫情全球爆发的影响，A 股市场经历了短暂的大幅下跌。随后，在各国政府出台的一系列经济刺激政策下，市场逐渐企稳回升。2020 年下半年至 2021 年上半年，A 股市场呈现出结构性牛市行情，部分行业板块（如新能源、半导体等）表现强劲，带动指数上涨。2021 年下半年至 2022 年，市场面临经济增速放缓、流动性收紧等压力，整体呈现震荡下行态势。2023 年，随着国内经济复苏预期增强，市场出现一定程度的反弹，但仍受到全球经济不稳定因素的影响，波动较大。2024 年，在政策利好不断释放的背景下，市场逐步回暖，部分优质股票表现突出。到 2025 年初，市场延续了复苏的趋势，但不同板块之间的分化依然明显。

3.2 影响 A 股市场走势的因素

1. 宏观经济因素：国内生产总值（GDP）增速、通货膨胀率、利率水平等宏观经济指标对 A 股市场走势有着重要影响。例如，GDP 增速的提高通常预示着企业盈利的增加，会推动股票价格上涨；而利率上升则会增加企业的融资成本，对股票市场形成压力。
2. 政策因素：货币政策和财政政策的调整会直接影响市场的资金面和企业的经营环境。宽松的货币政策会增加市场流动性，有利于股票价格上涨；积极的财政政策如加大基础设施建设投资，会带动相关行业的发展，提升企业的盈利预期。
3. 行业发展因素：不同行业在不同时期的发展前景和竞争格局差异较大。新兴行业如人工智能、生物医药等，由于具有较高的成长性和创新能力，往往受到市场的青睐，股票价格表现较好；而传统行业如钢铁、煤炭等，可能会受到行业周期和市场竞争的影响，股价波动较大。

四、实验设计

本实验旨在探究 2020 - 2025年期间，结合 A 股市场数据与利用 snownlp 库对股吧评论进行情感分析的结果，对股票走势预测的有效性。

4.1 数据收集与整理

4.1.1 A股历史交易数据来源

本实验的A股历史交易数据来源于akshare金融数据接口库。akshare是一个基于Python的开源金融数据接口库，它提供了丰富的金融数据，包括股票、期货、基金、债券等市场的历史交易数据和实时行情数据。其优势在于数据获取方便、免费且数据更新较为及时。在本实验中，我们使用akshare的股票日线行情接口，获取了特定股票在一段时间内的历史交易数据，包括开盘价、收盘价、最高价、最低价、成交量和成交额等信息。具体代码如下：

import akshare as ak

e = {
        "code": "000001",
        "start": "20200113",
        "end": "20250114"
}
df = ak.index_zh_a_hist(symbol=e["code"], period="daily", start_date=e["start"], end_date=e["end"])

上述代码中，symbol参数指定了要获取数据的股票代码，start_date和end_date参数分别指定了数据的起始日期和结束日期。通过调用index_zh_a_hist函数，我们可以获取到该股票在指定时间范围内的日线行情数据，并将其存储在df数据框中。获取的数据格式如图：

4.1.2 股吧文本数据抓取

股吧文本数据的抓取通过编写Python爬虫程序实现。我们使用了requests库和BeautifulSoup库来发送HTTP请求并解析网页内容。具体步骤如下：

确定目标股吧网页的URL结构。例如，东方财富网股吧中某股票的讨论页面URL格式为https://gubaf10.eastmoney.com/list,zssh000001,f.html，其中000001为股票代码。

发送HTTP请求获取网页内容。使用requests.get()函数发送请求，并检查响应状态码以确保请求成功。代码如下：

import requests
from bs4 import BeautifulSoup
from headfile import *

def get_comment(page_numb=1):
    """
    从股吧获取评论
    :return:    评论列表
    """
    # URL 地址
    url = "https://gubaf10.eastmoney.com/list,zssh000001,f.html" if page_numb == 1 else f"https://gubaf10.eastmoney.com/list,zssh000001,f_{page_numb}.html"
    # 请求头
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
    }
    # 发送请求
    response = requests.get(url, headers=headers)
    response.encoding = 'utf-8'  # 确保中文显示正确
    # 解析 HTML
    soup = BeautifulSoup(response.text, "html.parser")
    # 提取评论部分
    comments = soup.find("div", class_="all").find_all("div", class_="articleh")
    result = [[], []]
    # 遍历每条评论
    for comment in comments:
        # 提取标题
        title_div = comment.find("span", class_="l3")
        if title_div:
            title = title_div.get_text(strip=True)
            result[0].append(title)
        time_div = comment.find("span", class_="l5")
        if time_div:
            time = time_div.get_text(strip=True)
            result[1].append(time)
    return result

if __name__ == '__main__':
    # 2020-01-13到2025-01-13的评论
    total_pages = [80, 55135]
    comments = np.array([[], []])
    for i in trange(total_pages[0], total_pages[1]):
        comments_i = np.array(get_comment(page_numb=i))
        comments = np.hstack((comments, comments_i))
    df = pd.DataFrame(np.array(comments).T, columns=["评论", "时间"])
    print(df.head())
    df.to_csv(f"data\comments.csv")

使用BeautifulSoup库解析网页内容，提取所需的评论文本和发表时间。通过分析网页的HTML结构，找到包含评论和时间信息的HTML标签和类名。例如，评论内容在<div class="articleh">标签内，发表时间在<span class="l5">标签内。代码如下：

为了获取更多的评论数据，需要遍历多页股吧网页。可以通过分析URL的页码参数，构造不同页码的URL并重复上述步骤。例如，第二页的URL为https://gubaf10.eastmoney.com/list,zssh000001,f_2.html。获取的数据格式如图：

4.1.3 数据预处理

股吧文本数据处理：对抓取的股吧文本数据进行去重，为每个评论按顺序添加相应的年份。

情感特征提取：在股吧文本数据方面，我们通过情感分析提取了情感特征。具体而言，我们为每个评论计算了情感得分，然后将每天的所有评论情感得分进行汇总，得到当天的情感特征。考虑到不同评论的重要性可能不同，我们选择了中位数作为当天情感得分的代表值。这是因为中位数能够减少极端值的影响，更稳健地反映整体的情感倾向。例如，如果某一天的评论中存在少数极端积极或消极的评论，使用中位数可以避免这些极端评论对整体情感判断的过度影响。

数据整合：将处理后的交易数据和股吧文本数据按照时间顺序进行整合。确保每个交易日都对应有相应的股吧评论情感数据。最终形成一个包含交易数据、股吧情感数据和标签的数据集。

通过上述方法，我们从交易数据和股吧文本数据中提取了丰富的特征，这些特征将作为模型的输入，用于训练和预测股票走势。

4.2 模型构建

4.2.1 LSTM模型架构设计

本实验构建的LSTM模型包含以下几个主要部分：

输入层：输入层接收经过预处理后的特征数据。输入参数包括输入特征维度input_size，数据形状(batch, seq_len, input_size)，batch 是同时处理的序列数量，可根据硬件资源和数据规模调整；seq_len 是时间序列的长度，取决于所处理数据的时间跨度。在本实验中，我们设置时间步长为7，即考虑过去7天的历史数据。

LSTM层：我们使用了三层LSTM层，以增强模型对时间序列数据中复杂依赖关系的学习能力。隐藏层大小为32，LSTM层的隐藏层大小是一个重要的超参数，它决定了模型的学习能力和复杂度。通过实验和调优，我们发现这三个层数和隐藏层大小的设置能够在本实验数据集上取得较好的性能。模型代码如下：

class lstm(nn.Module):
    def __init__(self, input_size=8, hidden_size=32, num_layers=3, output_size=1, dropout=0, batch_first=True):
        super(lstm, self).__init__()
        # lstm的输入 #batch, seq_len, input_size
        self.hidden_size = hidden_size
        self.input_size = input_size
        self.num_layers = num_layers
        self.output_size = output_size
        self.dropout = dropout
        self.batch_first = batch_first
        self.rnn = nn.LSTM(input_size=self.input_size, hidden_size=self.hidden_size, num_layers=self.num_layers,
                           batch_first=self.batch_first, dropout=self.dropout)
        self.linear = nn.Linear(self.hidden_size, self.output_size)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        out, (hidden, cell) = self.rnn(x)
        out = self.linear(hidden[-1])
        out = self.sigmoid(out)
        return out

3. 全连接层：LSTM层的输出通过一个全连接层进行处理，将其映射到最终的输出维度。全连接层的作用是对LSTM层提取的特征进行进一步的整合和转换，以适应预测任务的要求。在本实验中，全连接层的输出维度为1，使用nn.Linear函数定义全连接层，代码如下：

self.linear = nn.Linear(self.hidden_size, self.output_size)

输出层：输出层采用Sigmoid激活函数，将全连接层的输出转换为0到1之间的概率值，表示股票价格上涨的可能性。如果概率值大于0.5，则预测股票价格上涨，否则预测股票价格下跌。在PyTorch中，使用nn.Sigmoid函数定义输出层的激活函数，代码如下：

def forward(self, x):
        out, (hidden, cell) = self.rnn(x)
        out = self.linear(hidden[-1])
        out = self.sigmoid(out)
        return out

4.2.2 数据划分

我们将数据集划分为训练集、验证集和测试集，其中训练集用于训练模型，验证集用于训练时验证模型，测试集用于评估模型的性能。

def getData(corpusFile, sequence_length, batchSize):
    """
    获取数据
    :param corpusFile:
    :param sequence_length:
    :param batchSize:
    :return:
    """
    df, close_max, close_min = dataPreprocessing(corpusFile)  # 获取标准化后的数据和最大最小值
    # 构造X和Y
    # 根据前n天的数据，预测未来一天的收盘价(close)
    sequence = sequence_length
    X = []
    Y = []
    for i in range(df.shape[0] - sequence):
        X.append(np.array(df.iloc[i:(i + sequence), ].values, dtype=np.float32))
        Y.append(np.array(df.iloc[(i + sequence), 0], dtype=np.float32))
    # 构建数据集划分
    total_len = len(Y)
    train_len = int(args.train_size * total_len)  # 动态训练集比例
    val_len = int(args.val_size * total_len)  # 动态验证集比例
    test_len = total_len - train_len - val_len  # 动态测试集比例

    # 划分训练集、验证集和测试集
    trainx, trainy = X[:train_len], Y[:train_len]
    valx, valy = X[train_len:train_len + val_len], Y[train_len:train_len + val_len]
    testx, testy = X[train_len + val_len:], Y[train_len + val_len:]

    # 创建DataLoader
    train_loader = DataLoader(dataset=Mydataset(trainx, trainy, transform=transforms.ToTensor()),
                              batch_size=batchSize, shuffle=True)
    val_loader = DataLoader(dataset=Mydataset(valx, valy),
                            batch_size=batchSize, shuffle=True)
    test_loader = DataLoader(dataset=Mydataset(testx, testy),
                             batch_size=batchSize, shuffle=False)

    return close_max, close_min, train_loader, val_loader, test_loader

4.2.3 模型训练与优化

优化器选择：为了训练LSTM模型，我们选择了Adam优化器。Adam优化器是一种自适应学习率的优化算法，它能够根据每个参数的梯度自适应地调整学习率，从而在训练过程中更快地收敛到最优解。Adam优化器的优点是计算效率高、内存需求小，并且对不同类型的问题都有较好的适应性。代码如下：

optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)  # Adam梯度下降  学习率=0.0001

其中，model.parameters()表示需要优化的模型参数，lr为学习率，设置为0.001。学习率是一个重要的超参数，它决定了优化器在每次迭代中更新参数的步长。通过实验，我们发现0.001的学习率在本实验中能够取得较好的训练效果。

2. 损失函数选择：选择均方误差（Mean Squared Error）作为损失函数。均方误差损失函数是一种适用于回归任务的损失函数，通过计算预测值和真实值之间的平方差的平均值，为模型训练提供了一个可量化的优化目标。代码如下：

criterion = nn.MSELoss()  # 定义损失函数

模型训练：训练过程如下：

close_max, close_min, train_loader, val_loader, test_loader = getData(args.corpusFile, args.sequence_length, args.batch_size)
# 用于保存损失
train_losses = []
val_losses = []
for epoch in range(args.epochs):
    model.train()
    total_loss = 0
    # 使用 tqdm 显示训练进度条
    with tqdm(train_loader, desc=f'Epoch {epoch}/{args.epochs}', unit='batch') as pbar:
        for idx, (data, label) in enumerate(pbar):
            if args.useGPU:
                data1 = data.squeeze(1).cuda()
                pred = model(Variable(data1).cuda())
                label = label.unsqueeze(1).cuda()
            else:
                data1 = data.squeeze(1)
                pred = model(Variable(data1))
                label = label.unsqueeze(1)
            loss = criterion(pred, label)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            total_loss += loss.item()
            # 更新进度条的损失显示
            pbar.set_postfix(loss=total_loss)
    train_losses.append(total_loss)  # 保存训练损失
    # 每10个epoch保存一次模型
    if epoch % 10 == 0:
        torch.save({'state_dict': model.state_dict()}, args.save_file)

在每个训练 epoch 中，首先将模型设置为训练模式，然后遍历训练数据加载器中的每个批次。在每个批次中，先将输入数据传入模型得到预测结果，然后计算损失值，再将优化器的梯度清零，反向传播更新参数。

五、实验结果与分析

训练参数如下：

# TODO 常改动参数
parser.add_argument('--gpu', default=0, type=int)  # gpu 卡号
parser.add_argument('--epochs', default=500, type=int)  # 训练轮数
parser.add_argument('--layers', default=3, type=int)  # LSTM层数
parser.add_argument('--input_size', default=9, type=int)  # 输入特征的维度
parser.add_argument('--hidden_size', default=64, type=int)  # 隐藏层的维度64
parser.add_argument('--lr', default=0.0001, type=float)  # learning rate 学习率
parser.add_argument('--sequence_length', default=7, type=int)  # sequence的长度，默认是用前七天的数据来预测下一天的收盘价
parser.add_argument('--batch_size', default=64, type=int)   # 批大小
parser.add_argument('--useGPU', default=False, type=bool)  # 是否使用GPU
parser.add_argument('--batch_first', default=True, type=bool)  # 是否将batch_size放在第一维
parser.add_argument('--dropout', default=0.001, type=float)
parser.add_argument('--save_file', default='model/stock.pkl')  # 模型保存位置
parser.add_argument('--train_size', default=0.85, type=float)  # 训练集的大小
parser.add_argument('--val_size', default=0.05, type=float)  # 验证集的大小
parser.add_argument('--test_size', default=0.1, type=float)  # 测试集的大小

经过500轮训练，得到训练和验证损失曲线。

在测试中，我们得到了LSTM模型对A股走势的预测结果。以下以图表的形式展示模型在测试集上的部分预测结果与实际值的对比情况，其中横坐标表示时间（以交易日为单位），纵坐标表示股票价格涨跌的预测值与实际值。

从图中可以看出，在大部分时间段内，模型能够较为准确地预测股票价格的涨跌。例如，在某些时间点，模型预测的上涨或下跌趋势与实际情况相符。然而，也存在一些预测不准确的情况，模型预测的涨跌与实际走势出现偏差。这可能是由于股票市场的复杂性，受到多种因素的综合影响，即使考虑了历史价格数据和股吧情感分析，仍难以完全准确地捕捉到所有的变化因素。

六、结论与展望

6.1 研究结论总结

本研究通过结合LSTM与股吧情感分析，构建了A股走势预测模型。实验结果表明，该模型在一定程度上能够有效预测股票价格的涨跌。通过对股吧文本数据进行情感分析，提取的投资者情感特征为模型提供了有价值的信息，有助于提高预测的准确性。

6.2 研究的局限性

数据方面：本实验使用的数据在时间跨度和样本数量上存在一定的局限性。股票市场受到众多复杂因素的影响，历史数据的时间跨度不够长可能导致模型无法充分学习到各种市场状态下的规律。此外，股吧文本数据的抓取可能存在不全面的情况，部分重要信息可能被遗漏，从而影响情感分析的准确性和模型的预测效果。

模型方面：虽然LSTM模型在处理时间序列数据方面具有优势，但股票市场的复杂性使得任何单一模型都难以完全准确地捕捉所有影响因素。本研究中LSTM模型的结构和参数设置可能并非最优，仍有进一步优化的空间。此外，模型假设投资者的情感能够直接反映在股票价格走势中，但实际情况可能更为复杂，投资者情感与股票价格之间的关系可能受到多种因素的干扰。

情感分析方面：snownlp库的情感分析方法虽然简单易用，但对于金融领域文本的情感分析可能存在一定的局限性。金融文本具有专业性和复杂性，其中的一些词汇和表达方式可能具有特定的含义，普通的情感分析工具可能无法准确理解其情感倾向。此外，情感分析结果可能受到文本的上下文、语境等因素的影响，目前的方法可能无法充分考虑这些因素。

6.3 未来研究方向

数据拓展：收集更长时间跨度、更多样本的股票历史交易数据和股吧文本数据，以提高模型的泛化能力和稳定性。同时，可以考虑拓展数据来源，如收集更多金融媒体的评论、分析师报告等，以获取更全面的市场信息。

模型改进：尝试改进LSTM模型的结构，如引入注意力机制等，以更好地捕捉数据中的重要信息和长期依赖关系。此外，可以结合其他机器学习或深度学习算法，构建集成模型，提高预测的准确性。

情感分析优化：针对金融领域文本的特点，改进情感分析方法。可以利用深度学习模型，如基于Transformer的模型，进行情感分析，以提高分析的准确性和鲁棒性。同时，可以考虑结合知识图谱等技术，更好地理解金融文本中的语义和情感。

多因素融合：进一步研究股票市场的其他影响因素，如宏观经济指标、行业动态、公司财务状况等，并将这些因素与投资者情感和历史价格数据进行更深入的融合，以构建更全面、准确的股票走势预测模型。

参考文献

[1] Zhang Y S, Yang S T. Prediction on the Highest Price of the Stock Based on PSO-LSTM Neural Network[C]// Proceedings of the 3rd International Conference on Electronic Information Technology and Computer Engineering (EITCE). 2019: 1565-1569.

[2] Xing FZ, Cambria E, Welsch RE (2018) Natural language based financial forecasting: a survey. Artif Intell Rev 50(1):49–73

[3] Xu Yuemei, Wang Zihou, Wu Zixin. Predicting Stock Trends with CNN-BiLSTM Based Multi-Feature Integration Model[J]. Data Analysis and Knowledge Discovery, 2021, 5(7): 126-138

基于LSTM与股吧情感分析的A股走势预测研究与实践最先出现在haoblog。

作业：词向量训练

一、 实验目的

1. 掌握课堂所讲词向量的基本概念和训练方法。
2. 加强对pytorch、tensorflow等深度学习框架的使用能力。

二、 实验要求

请写明选择的词向量模型结构（可以参考课程PPT，也可以自由选择一些主流的论文中提到的模型）

三、 任务说明

请使用任意一种深度学习框架（推荐pytorch），利用给定的语料训练词向量即可，中文和英文都需要训练，中文语料位于data文件夹下的zh.txt中，已经分好词。英文语料位于data文件夹下的en.txt中。（给定的语料规模较小，如果有充足的计算资源，也可自己选用更大的语料来训练，但需在报告中写明）。

四、 实验过程

1、模型选择

skip-gram模型，输入是一个词汇，输出则是该词汇的上下文。

2、模型超参数

3、数据预处理

空格分割读取的数据，如果是中文数据需过滤停用词，选择常用地MAX_VOCAB_SIZE个单词作为词典，不常用地词统一用unk表示。

def load_stop_words(file_stopwords):
    """
        加载停用词
    """
    with open(file_stopwords, "r", encoding="utf-8") as f:
        return f.read().split("n")

def dataPreprocess(file, iszh):
    """
    数据预处理
    :param iszh: 是否为中文
    :return:
    """
    if iszh:
        stop_words = load_stop_words(file_stopwords)
        with open(file, 'r', encoding="utf-8") as f:
            text = f.read()
            text = text.split()  # 空格分割
            text = list(filter(lambda word: word not in stop_words, text))  # 过滤停用词
    else:
        with open(file) as f:
            text = f.read()
            text = text.split()  # 空格分割
    vocab = dict(Counter(text).most_common(MAX_VOCAB_SIZE - 1))  # 选择常用地MAX_VOCAB_SIZE个单词
    vocab['<unk>'] = len(text) - np.sum(list(vocab.values()))  # 不常用地词统一用unk表示
    return text, vocab

4、模型结构

使用灵活得方式去定义模型，继承nn.Module类。

class EmbeddingModel(nn.Module):
    def __init__(self, vocab_size, embed_size):
        # 初始化输入和输出得embedding
        super(EmbeddingModel, self).__init__()
        self.vocab_size = vocab_size
        self.embed_size = embed_size

        # 初始化
        initrange = 0.5 / self.embed_size
        self.out_embed = nn.Embedding(self.vocab_size, self.embed_size, sparse=False)
        self.out_embed.weight.data.uniform_(-initrange, initrange)

        self.in_embed = nn.Embedding(self.vocab_size, self.embed_size, sparse=False)
        self.in_embed.weight.data.uniform_(-initrange, initrange)  # 这是在范围直接均匀分布采样

    def forward(self, input_labels, pos_labels, neg_labels):
        """
        input_labels:中心词,[batch_size]
        pos_labels:中心词周围context window 出现过得单词[batch_size * (window_size * 2)]
        neg_labels:中心词周围没有出现过得单词，从negative sampling得到[batch_size, (window_size*2*K)]

        return:loss,[batch_size]
        """
        batch_size = input_labels.size(0)
        input_embedding = self.in_embed(input_labels)  # batchsize*embed_size
        pos_embedding = self.out_embed(pos_labels)  # batchsize*(2*c)*embed_size
        neg_embedding = self.out_embed(neg_labels)  # batchsize*(2*c*k)*embed_size

        # 计算损失
        input_embedding = input_embedding.unsqueeze(2)  # [batchsize, embed_size, 1]
        log_pos = torch.bmm(pos_embedding, input_embedding).squeeze()  # [batchsize, 2*C]
        log_neg = torch.bmm(neg_embedding, -input_embedding).squeeze()  # [batchsize, 2*c*100]

        log_pos = F.logsigmoid(log_pos).sum(1)
        log_neg = F.logsigmoid(log_neg).sum(1)

        loss = log_pos + log_neg
        return -loss

    def input_embedding(self):
        return self.in_embed.weight.data.cpu().numpy()

5、模型训练

训练步骤：前向传播，计算损失，梯度清零，反向传播，参数更新

def train(model):
    """
    训练
    :return:
    """
    optimizer = torch.optim.SGD(model.parameters(), lr=LEARNING_RATE)
    for epoch in range(NUM_EPOCHS):
        pbar = tqdm(total=100, desc=f"epoch:{epoch}")
        for i, (input_labels, pos_labels, neg_labels) in enumerate(dataloader):
            # 先保证都是longTensor
            input_labels = input_labels.long()
            pos_labels = pos_labels.long()
            neg_labels = neg_labels.long()
            if use_cuda:
                input_labels = input_labels.cuda()
                pos_labels = pos_labels.cuda()
                neg_labels = neg_labels.cuda()
            optimizer.zero_grad()
            loss = model(input_labels, pos_labels, neg_labels).mean()
            loss.backward()
            optimizer.step()
            pbar.update(100/len(dataloader))
        pbar.close()

6、模型测试

寻找距离最近的几个单词，看看训练得这个词向量矩阵得效果。

英文数据：['present', 'food', 'can', 'specifically']

中文数据：['中国', '粮食', '至今', '山川']

国科大NLP课程-词向量训练报告最先出现在haoblog。

1 背景

为了提升用户对文本的准确理解，我们设计并实现了一个多音字与易读错字标注系统。通过上传Word文档，程序将自动检测文中的多音字和易错字，并为其添加拼音注释。输出的结果会以Word文件形式返回，注释信息会在字词后以圆括号形式标注，方便用户阅读和展示。

2 目的

通过训练双向LSTM模型、逻辑回归、g2pM、调用大模型API等方法实现对文本的多音字和易读错字标注。

通过Django框架实现在线系统，方便用户通过网页上传和下载文档，实现实时检测与注音。

3 系统实现框架

3.1 前端

用户通过网页上传Word文档。

然后向后端接口发起POST请求，返回处理结果。

// 处理文档
function DealDoc(e){
    // 处理选项
    var radios = document.querySelector('input[name="gender"]:checked').value;
    reader = document.getElementById("input").value
    document.getElementById("output").value = "Loading...";
    var url = 'https://nlp.bithao.com.cn/deal';
    // 发起POST请求
    fetch(url, {
        method: 'POST',
        headers: {
            'Accept': 'application/json',
            'Content-Type':'application/x-www-form-urlencoded'
        },
        body: `input=${reader}&radios=${radios}`
    })
    .then(response => response.json())
    .then(data => {
        console.log('Success:', data);
        // 显示输出结果
        document.getElementById("output").value = data.result;
    })
    .catch(error => {
        console.error('Error:', error);
    });
}

用户点击下载，将处理好的数据保存为docx文件，直接在客户端完成，无需占用服务端资源。

3.2 后端

view层，数据处理接口，根据不同选项以Json格式返回不同方法的处理结果。

def deal(request):
    if request.method == 'POST':
        data = request.POST["input"]
        radios = int(request.POST["radios"])
        if radios == 1: # LSTM
            result = LSTMDealDoc(data)
        elif radios == 2:   # 逻辑回归
            result = LGDealDoc(data)
        elif radios == 3:   # g2pm
            result = g2pmDealDoc(data)
        elif radios == 4:   # 大模型
            result = AIDealDoc(data)
        content = {
            "result": result
        }
        return JsonResponse(content)

4 双向LSTM模型

功能-BiLSTM

双向长短时记忆网络（BiLSTM）在多音字消歧中的应用，主要是因为它具备从两个方向（前向和后向）处理序列数据的能力。具体来说，BiLSTM 相比于单向的 LSTM 可以更好地处理语言中的依赖关系，因为它不仅能够考虑到多音字前面的词语（前向信息），还能够结合后续的词语（后向信息）来做出判断。这种双向处理使得模型在消岐时能够利用更多的上下文信息，从而更准确地确定多音字的正确读音。

4.1 数据来源

一、汉字拼音库，使用《现代汉语词典》中的拼音数据，汉字数：11017，多音字个数：1217；

（来自pinyin-data）

二、人民日报1988年一月的新闻语料，一共有19374条新闻，包含5593个多音字，其中有85种不同的多音字；来自（pkuopendata）

4.2 数据预处理

数据统计：

1. 统计了多音字的读音个数，了解多音字的分布情况。
2. 对新闻语料中的多音字进行统计，包括出现次数和含多音字的句子数量等。
3. 对短语中的多音字进行统计和分析。

语料划分：

将语料划分为训练集、验证集和测试集。

train.csv（训练集，29928 条短语，30041 个多音字）

valid.csv（验证集，8723 条短语，12696 个多音字）

test.csv（测试集，8638 条短语，19198 个多音字）

数据预处理：

1. 使用 torchtext 库对文本进行处理。
2. 对句子和读音进行 tokenize（分词），建立词典。
3. 设定 batch size 和生成迭代器，以便将数据送入模型进行训练。

4.3 模型搭建

仿照词性标注问题的分类方法：

1. 仿照词性标注的处理思路，将训练数据编码为特定格式，其中 “NA” 代表非多音字，多音字则使用读音来编码。

2. 已将短语数据送入模型并进行训练，然后使用测试集计算准确率，将标注正确的语句和标注错误的语句输出到相应文件中（correct.csv 和 wrong.csv）。

# 用于消岐的神经网络
class DisambiguationLSTM(nn.Module):
 def __init__(self, n_word, word_dim, word_hidden, n_pronounce):
 super(DisambiguationLSTM, self).__init__()
 self.word_embedding = nn.Embedding(n_word, word_dim)
 self.lstm = nn.LSTM(
 input_size=word_dim,
 hidden_size=word_hidden,
 num_layers=configure.num_layer,
 batch_first=True,
 bidirectional=True
 )
 self.linear1 = nn.Linear(word_hidden*2, n_pronounce)

 def forward(self, x):
 x = self.word_embedding(x)
 x, _ = self.lstm(x) 
 x = x.squeeze(0) 
 x = self.linear1(x) 
 return x

3. 使用optuna库寻找最优参数；

#寻找最优参数
import optuna
def objective(trial):
 trn_rate = trial.suggest_float('trn_rate', 0.4, 0.8)
 val_rate = trial.suggest_float('val_rate', 0.1, 0.4)
 batch_size = trial.suggest_categorical('batch_size', [256, 512, 1024])
 num_layer = trial.suggest_int('num_layer', 1, 3)
 # 更新配置中的参数
 configure.trn_rate = trn_rate
 configure.val_rate = val_rate
 configure.batch_size = batch_size
 old_acc = 0
......

4.4 word文档注音

假设已经有了一个处理 Word 文档并进行多音字注音的函数 annotate_word_document，其思路如下：

4.4.1 易读错字

除多音字外，还要求程序能够识别易读错字。通过网络信息检索获得400个易错字词，包括容易平翘舌不分、前后鼻音不分、h/f不分、鼻边音不分等难点发音字词，轻声儿化等需变调词语，以及一部分较生僻的字，例如摈（bìn）弃、疮（chuāng）疤、舂（chōng）等等。程序运行时，直接从目标文章中识别并注音即可。

1. 读取 Word 文档内容,将其转换为文本并导入易错字，多音字JSON词典;

def word_doc_to_text(file_path):
 doc = docx.Document(file_path)
 text = ""
 for paragraph in doc.paragraphs:
 text += paragraph.text
 return text

#读取约400个易错字，注意csv编码格式为UTF-8
def read_mispronounced_words(file_path):
 df = pd.read_csv(file_path)
 return dict(zip(df['text'], df['label']))

# 读取多音字 JSON 文件
with open('../data/polyphones.json', 'r', encoding='utf-8') as f:
 polyphone_data = json.load(f)
polyphone_list = list(polyphone_data.keys())

2. 使用jieba对文本进行分词，得到单词列表。

3. 对于每个单词，判断是否包含多音字：

def is_word_contain_polyphone(word):
 for char in word:
 if char in polyphone_list:
 return True
 return False

4. 分词词语转化为适配模型输入的张量，并根据模型输出确定读音；

#分词词语转化为模型输入的张量，进行预处理，如填充和截断
def word_to_tensor(word, vocab):
 word_index = vocab.stoi.get(word, vocab.stoi['<unk>'])
 return torch.tensor(word_index).unsqueeze(0)

def words_to_tensor_list(word_list, vocab, max_length):
 tensor_list = [word_to_tensor(word, vocab) for word in word_list]
 padded_tensor_list = torch.nn.utils.rnn.pad_sequence(tensor_list, batch_first=True)
 if len(padded_tensor_list) > max_length:
 return padded_tensor_list[:max_length]
 else:
 return padded_tensor_list

def determine_pronunciation(output, label_vocab):
 # 根据模型输出确定读音
 predicted_label_index = torch.argmax(output).item()
 pronunciation_label = label_vocab.itos[predicted_label_index]
 # 根据标注体系，提取读音信息并返回
 if pronunciation_label == "NA": #NA表示非多音字
 word = label_vocab.itos[predicted_label_index]
 if word in mispronounced_words: #如果是易错字词，返回读音
 return mispronounced_words[word]
 else:
 return ""
 else:
 return pronunciation_label

5. 如果单词包含多音字，使用训练好的LSTM模型进行预测，如果模型能够确定读音，则在单词中的多音字后面标注读音；如果模型未识别，则使用多音字JSON文件中的读音信息进行标注,如果单词不包含多音字，直接添加到结果中；

整体思路是通过对不同来源的数据进行统计和预处理，搭建多音字消歧模型，并将其应用于 Word 文档的多音字注音任务中。在模型搭建过程中，尝试了不同的方法，并选择了较为有效的仿照词性标注问题的分类方法进行训练和测试。

验证集上准确率达到85-90%，测试集准确率为75%-88%

4.4.2 模型改进-其他词性

由于训练语料库主要由短语或词语构成，将多音字消歧模型应用于长文本时，短语级别的训练限制了模型对更复杂语境中多义词的判断，无法充分利用句子或段落中的全局上下文信息。例如“的”作为助词时在长文本中及其常见，但在训练短语中仅出现67次，且不少作为固定短语，如“狗娘养的”、“一矢中的”。

为了改进模型，考虑通过识别常见的副词、助词、方位词、连词和介词中的多音字，并根据长文本上下文判断词性，再在原有模型基础上对这些字进行二次注音。不同词性下，某些多音字的发音是固定的，因此可以利用这一点进行二次注音，降低模糊性。此外，词性判断依赖于上下文，可以有效地利用句子和段落级别的信息，而不是仅依赖于短语。

以副词为例，常见的副词包括“非常、绝对、极度、十分、最、顶级、太、更、极其、格外、分外、一直、才、总 、也、都、全部、总体、总共、共、统统、又、仅仅、只、光、一概 、已经、曾经、早已、刚刚、正、正在、就、就要、将、将要、曾、刚、才、在 、不、非、没、没有、不用（甭）、必、必须、必定、准、的确、未、别、忽然、猛然、公然、特意、亲自、大肆、肆意、难道、决、岂、反正、也许、大约、大概、果然、居然、竟然、究竟 、家、这里、那里、每一处、楼”，其中包含多音字的有以下几个，且作为副词时读音固定，分别是“才（cái）、都（dōu）、将（jiāng）、没（méi）”。同理，手工找出常见助词、方位词、连词和介词中的多音字。最后汇总的这些词性的多音字一共有17个，分别为

副词：才（cái）、都（dōu）、将（jiāng）、没（méi）

助词：了（le）、着（zhe）、过（guo）、地（de）、的（de）、得（de）

方位词：中（zhōng）

介词：从（cóng）、当（dāng）、为（wèi）、给（gěi）

连词：和（hé）、便（biàn）

使用jieba库的pseg模块，对长文本进行分词及词性标注，并对上述特定词性的多音字二次标注。代码示例如下：

import jieba.posseg as pseg
# 定义要加注音的字及其拼音
pinyin_dict = {
'才': 'cái',
'都': 'dōu',
'将': 'jiāng',
'没': 'méi',
'了': 'le',
'着': 'zhe',
'过': 'guo',
'地': 'de',
'的': 'de',
'得': 'de',
'中': 'zhōng',
'从': 'cóng',
'当': 'dāng',
'为': 'wèi',
'给': 'gěi',
'和': 'hé',
'便': 'biàn'
}
# 定义目标词性集合（副词、助词、方位词、介词、连词）
target_pos = {'d', 'p', 'f', 'c', 'uv', 'ul', 'uj'}
# 处理句子的函数
def add_pinyin(sentence):
    words = pseg.cut(sentence) # 使用 jieba 分词并获取词性
    result = []
    for word, flag in words:
        if word in pinyin_dict and flag in target_pos:
            result.append(f"{word}({pinyin_dict[word]})") # 如果满足条件，添加拼音注释
        else:
            result.append(word) # 否则直接保留原字
    return ''.join(result)
# 示例
text = "才知道，你在雨中飞快地跑，我走了。"
# 输出加注音的句子
annotated_text = add_pinyin(text)
print(annotated_text)
# words = pseg.lcut(text)
# 打印每个词及其词性
# for word, flag in words:
# print(f"{word}: {flag}")

4.5 模型评估

输入输出案例:

5 逻辑回归

功能-逻辑回归

主要思想：

把多音字注音分解为每个多音字的读音识别，即分解为六百多个简单分类任务。利用多音字在不同句子中的词性，及其前后词语的词性作为特征训练模型，得到六百多个模型。使用的时候从前到后遍历word文档，如果遍历到多音字字典里的字，则调用对应的模型进行预测。

数据集：

CPP (Chinese Polyphones with Pinyin)

https://paperswithcode.com/dataset/cpp

拥有99000条中文多音字数据，数据格式如下：

项目流程：

1. 处理数据：

79100条作为训练集，9800条作为验证集，10250条作为测试集。

利用THULAC进行分词，经处理得到如下训练输入和输出：

2. 训练模型：

将输入输出数据进行编码后进行训练。

# 训练模型并评估验证集
for epoch in range(10):  # 假设我们进行10个epoch的训练
    model.fit(X_train_encoded, y_train_encoded)
    y_val_pred_encoded = model.predict(X_val_encoded)
    accuracy_val = accuracy_score(y_val_encoded, y_val_pred_encoded)

    # 如果验证集表现更好，保存当前的最佳模型
    if accuracy_val > best_accuracy:
        best_accuracy = accuracy_val
        best_model = model

# 保存最佳模型和编码器
if best_model:
    model_save_path = os.path.join(folder_path, 'best_model.pkl')
    encoder_save_path = os.path.join(folder_path, 'encoders.pkl')

    joblib.dump(best_model, model_save_path)
    joblib.dump({'onehot_encoder': onehot_encoder, 'label_encoder': label_encoder}, encoder_save_path)

3. 测试结果：

该数据集部分多音字只标注了一个读音。综合正确率等于整体预测正确数目除以预测条数。

如果默认只有一个注音的多音字都预测正确：在测试集上综合正确率97.14%

如果不考虑只有一个注音的多音字，综合正确率为94.81%

写文档针对性进行测试效果如下图：

分析总结：

逻辑回归训练的模型在测试集上表现较好，但是实际应用效果比较一般。分析可能有如下几点原因：

1. 数据集同一个字的不同读音数据量失衡。
2. 部分多音字不同发音所组成的词用法区别不大，无法有效通过词性进行判断。

该方法实现起来比较简单，且对训练设备要求不高。但是这个方法只是浅显的通过词性训练，且每个字各有一个模型，没有建立理解语义的大模型。

6 g2pm

功能-g2pm

G2pM使用方法：

from g2pM import G2pM
model = G2pM()
sentence = "输入要注音的文本"
Pinyin=model(sentence, tone=True, char_split=False)

1. 创建多音字字典文档
2. 输入word文档，裁剪文本利用G2pM模型识别
3. 处理返回的拼音数据，只截取多音字的注音并按要求输出word文档

效果展示：

7 大模型API调用

功能-大模型

这里选择Kimi大模型，通过添加提示词，让AI返回结果。

from openai import OpenAI
client = OpenAI(
    api_key = "sk-########################################",
    base_url = "https://api.moonshot.cn/v1",
)
history = [
    {"role": "system", "content": "你是 Kimi，由 Moonshot AI 提供的人工智能助手，你更擅长中文和英文的对话。你会为用户提供安全，有帮助，准确的回答。同时，你会拒绝一切涉及恐怖主义，种族歧视，黄色暴力等问题的回答。Moonshot AI 为专有名词，不可翻译成其他语言。"}
]
def chat(query, history):
    history.append({
    "role": "user", 
    "content": query
    })
    completion = client.chat.completions.create(
        model="moonshot-v1-32k",
        messages=history,
        temperature=0.3,
    )
    result = completion.choices[0].message.content
    history.append({
    "role": "assistant",
    "content": result
    })
    return result
def MakeBiaozhu(input_data):
    output_data = f"你是一位骨灰级国语大师，对下面段落文字中多音字、易读错字，加上注音，放在圆括号内，不需要做出任何解释：'{input_data}'"
    return output_data
def AIDealDoc(input_doc):
    return chat(MakeBiaozhu(input_doc), history)

输入输出案例:

本方法调用大模型API做垂直领域的应用是可行的，但效果依赖于提示词的使用，同时成本较高。

国科大NLP课程-多音字与易读错字标注在线系统最先出现在haoblog。