这个问题很真实。因为在今天，写一个 Python CLI、补几个模块、改几个 bug、加一些测试，Codex / Claude Code 确实已经非常强了。甚至可以说，如果目标只是“把代码写出来”，Hermes 并不是最核心的工具。

但 PassiveAgent 做到初具规模之后，我对这个问题的答案逐渐清晰了：

Codex / Claude Code 更像施工队，负责把一个个功能实现出来；Hermes 更像这个项目的长期操作系统，负责记住项目、编排工具、沉淀经验，并让这个系统在真实环境里长期活下去。

这篇文章想分享的，不只是 PassiveAgent 这个项目本身，也包括我在用 Hermes 开发它的过程中，对 Agent 工具分工、自进化、长期个人系统的一些体会。

这篇文章可以按两条线看：一条线是 PassiveAgent 作为个人注意力调度系统的项目介绍；另一条线是 Hermes 在这个项目中扮演的角色——它不是替代 Codex/Claude Code，而是把一次性 coding 能力放进长期可记忆、可验证、可演化的工程闭环里。

PassiveAgent 是什么

PassiveAgent 是我给自己做的一个“个人注意力调度系统”。

现在资料太多了：Zotero 里有论文，Obsidian 里有摘录和临时链接，GitHub Stars 里有项目，HuggingFace Daily Papers 每天也有新论文。真正的问题不是“没有资料”，而是每天不知道应该先看哪几个。

PassiveAgent 要解决的问题就是：

每天从多个信息池里挑出少量真正值得看的内容，摘要、打分、排序，然后推送给我。

它的基础流程大概是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Zotero / Obsidian / HuggingFace Daily / GitHub Stars
        ↓
采集与标准化
        ↓
去重
        ↓
LLM 摘要与多维度打分
        ↓
Rank Top N
        ↓
飞书推送 / CLI 查看
        ↓
看、忽略、加入周末、生成面试卡或技术笔记
        ↓
反馈影响后续推荐

它适合的场景很明确：不是替我刷信息流，而是替我减少信息流；不是每天推一堆“可能有用”的东西，而是只推少量和当前目标高度相关的内容。

当前我的主要目标是 Agent / LLM / 算法工程方向的学习和面试准备，所以 PassiveAgent 的打分逻辑会围绕这些主题进行。

项目结构：一个小型但完整的 Agent 应用

PassiveAgent 不是一个单文件脚本，而是一个完整的小型 Agent 应用。当前项目结构大致是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

PassiveAgent/
├── config.yaml.example      # 配置模板
├── .env.example             # 环境变量模板，不提交真实密钥
├── prompts/                 # LLM prompt 模板
├── docs/                    # 配置、飞书、定时任务、排障文档
├── scripts/                 # launchd 安装脚本和 plist 模板
├── src/passive_agent/
│   ├── main.py              # CLI 入口
│   ├── pipeline.py          # 每日处理流水线
│   ├── collectors/          # 数据采集器
│   ├── processors/          # 去重、摘要、打分、排序
│   ├── actions/             # 用户操作处理
│   ├── feishu/              # 飞书 Bot、卡片、回调、命令
│   ├── integrations/        # LLM、Obsidian、Zotero 等外部集成
│   └── storage/             # SQLite 数据库和模型
└── tests/

技术栈比较朴素：Python 3.11+、SQLite、Click、Jinja2、OpenAI-compatible LLM API、飞书开放平台。它没有复杂的 Web 前端，也没有刻意追求“平台化”，核心目标就是每天稳定地帮我筛选内容。

配置集中在 config.yaml，大致分成 8 类：

1
2
3
4
5
6
7
8

runtime:          # 数据库、报告、prompt 路径
llm:              # LLM provider、model、base_url、并发、重试
goals:            # 当前目标、优先级主题、低优先级主题
sources:          # Zotero / Obsidian / GitHub Stars / HF Daily
display:          # dashboard、推送、报告展示数量
recommendations:  # 推荐生命周期与关联条目数量
feishu:           # 飞书异步超时等
scoring:          # 打分权重、daily_limit、负反馈降权

这样做的好处是：这个项目不是“我自己电脑上碰巧能跑的脚本”，而是一个可以解释、可以迁移、可以排障的系统。

怎么使用

最短路径其实很简单：

1
2
3
4
5
6
7

git clone https://github.com/CoderJackZhu/PassiveAgent.git
cd PassiveAgent
uv sync
cp config.yaml.example config.yaml
cp .env.example .env
uv run passive-agent init-db
uv run passive-agent daily

然后可以用这些命令查看结果：

1
2
3

uv run passive-agent status
uv run passive-agent dashboard
uv run passive-agent list --stage recommended

如果接入飞书，则可以主动推送：

1

uv run passive-agent feishu-push --stage recommended --limit 5

日常使用时，我更希望它不是一个“需要我主动打开的工具”，而是一个低打扰的系统：每天晚上定时跑一次，挑出 3 条左右值得看的内容推给我；周末再推一个适合深读的队列。

在飞书卡片里，我可以对每条内容做操作：

• 展开详情；
• 加入周末阅读；
• 忽略并记录负反馈；
• 在展开后生成面试卡；
• 生成技术笔记；
• 标记已读。

其中“面试卡”和“技术笔记”不是只在飞书里展示一下，而是会写入本地 Obsidian vault。例如：

1
2

01-Interview/{topic}/{title}.md
03-Tech-Notes/{topic}/{title}.md

这点对我很重要。因为 PassiveAgent 不应该只是一个推荐器，它还应该把有价值的信息沉淀到我的知识系统里。

一个推荐样例

一个典型的推送条目会包含这些信息：

1
2
3
4
5
6

标题：某篇关于 Agent 记忆机制 / Tool Use / RAG 评测的论文或文章
来源：Zotero / HuggingFace Daily / Obsidian / GitHub Stars
摘要：用几句话解释它解决的问题、核心方法和可能价值
评分：目标相关性、新颖性、可操作性、难度匹配、来源质量、时效性
推荐理由：为什么今天值得看
可执行动作：展开 / 周末 / 忽略 / 生成面试卡 / 技术笔记

例如，如果它发现一篇和 Agent memory 相关的论文，它不会只是告诉我“这篇论文很新”，而是会尝试回答：

• 它和我当前准备 Agent 算法岗面试有什么关系？
• 它适合今天快速浏览，还是适合周末深读？
• 它能不能转成一道面试题？
• 它能不能沉淀成一张技术笔记？

这也是我做 PassiveAgent 的初衷：不是追热点，而是让信息进入“学习—理解—沉淀”的链路。

那为什么不用 Codex / Claude Code 就行？

回到开头的问题。

如果只是写 PassiveAgent 的某个模块，比如实现一个 HuggingFace Daily collector、写一个 Feishu card、修一个 SQLite 迁移 bug，Codex 和 Claude Code 完全够用，而且非常适合。

所以我并不认为 Hermes 的价值是“比 Codex 更会写代码”。这不是它的核心定位。

我现在更愿意这样理解它们的分工：

Codex / Claude Code 像施工队。你告诉它：“把这里修一下”“加一个功能”“重构一下这个模块”，它可以快速完成。

Hermes 更像项目的长期工作台。它知道：

• PassiveAgent repo 在哪里；
• 怎么跑测试；
• 怎么跑 daily pipeline；
• 飞书推送需要哪些权限；
• launchd 有哪些坑；
• .env 和继承环境变量可能冲突；
• Zotero 分类应该用 collection，而不是靠 tag 乱贴；
• 之前为什么没有推送；
• 之前哪些 bug 已经修过；
• 这些经验下次应该怎么复用。

如果每次都从零开始，Codex/CC 当然也能做。但一旦项目进入长期维护状态，“从零开始”本身就是成本。

Hermes 在这里提供的不是一次性智能，而是连续性。

Hermes 在开发过程里具体做了什么

1. 项目记忆：从“一个 repo”变成“一个长期对象”

在开发 PassiveAgent 的过程中，Hermes 逐渐形成了一个项目级记忆：

• 这个项目叫 PassiveAgent；
• 它是个人注意力调度系统；
• 核心输入源是 Zotero、Obsidian、HF Daily、GitHub Stars；
• 核心输出是飞书卡片和 Obsidian 笔记；
• 当前目标是 Agent / LLM / 面试准备；
• 运行方式是 CLI + macOS launchd + Feishu long connection；
• 配置和密钥不能混在一起；
• 文档要面向新用户，而不是只堆配置项。

这些内容后来被沉淀到了专门的 passive-agent-development skill 里。于是之后我再问 PassiveAgent 相关问题时，Hermes 不需要重新探索一遍项目，它可以直接带着项目上下文开始工作。

这和普通聊天最大的区别是：项目不再是一段临时上下文，而是一个长期对象。

2. 工程排障：处理真实环境里的非代码问题

PassiveAgent 真正麻烦的地方，很多都不是代码本身。

比如飞书：

• 主动发消息需要 im:message:send_as_bot 或 im:message；
• 接收消息需要订阅 im.message.receive_v1；
• 卡片按钮需要 card.action.trigger；
• 权限或事件改完以后还要发布新版本，并在租户侧升级；
• FEISHU_CHAT_ID 必须来自机器人所在的真实目标聊天。

这些不是“写一个函数”能解决的，它们是系统集成问题。

再比如 launchd：

• macOS 的 ~/Documents、Desktop、Downloads 会受 TCC 保护；
• user LaunchAgent 错过定时点后不会像 systemd Persistent=true 那样自动补跑；
• 环境变量来自 launchctl / plist / .env，不同执行路径可能不一致；
• 代理环境变量可能影响飞书长连接。

这些问题如果只交给 coding agent，很容易变成“改了代码但实际没跑通”。Hermes 的优势是它能在一个会话里查日志、读配置、跑命令、结合历史经验，然后给出可验证的判断。

比如有一次 6.3 没有正常推送，最后定位不是 Feishu 失败，也不是 pipeline 报错，而是 Mac 在 21:00 定时点时用户 LaunchAgent 不在可执行状态，后来开机/登录后 launchd 没有补跑错过的任务。

这个结论只有把日志、数据库记录、报告文件、launchd 状态和系统启动时间放在一起看，才比较可靠。

3. 工作流沉淀：从“改一下”到 audit → fix → verify → commit

开发过程中逐渐形成了一个固定流程：

1

audit → fix → verify → commit

先审查真实代码和日志，再定位根因；做最小修改；跑测试或真实命令验证；确认后提交。这个流程后来也成为我用 Hermes 处理 PassiveAgent 问题的默认方式。

这件事看起来普通，但很重要。

因为 Agent 工具最容易出问题的地方不是“不会写代码”，而是“太快给出看似合理的改动，但没有验证”。Hermes 在我的使用里承担了一个“完成前验证”的角色：不只是改完，还要确认它真的跑过。

4. 技能进化：把踩坑写回系统

PassiveAgent 过程中踩过的坑，后来都被写进了 skill 或文档：

• LLM provider 从 DeepSeek 切到 OpenAI-compatible / MiMo 时，不是只改 YAML，还要确认 LLM factory 是否支持；
• WebUI 能用某个 provider，不代表 launchd daily job 也能用同一套环境；
• python-dotenv 默认不覆盖已经存在的环境变量，所以从 Hermes/WebUI 里手动跑 PassiveAgent 时，可能继承到 Hermes 自己的飞书环境变量；
• 所有新采集内容都被去重后，也不能直接结束 pipeline，而应该从 existing recommendations 里继续推送；
• Feishu 卡片上“面试卡”按钮和展开后的“生成面试卡”重复，会造成交互困惑，应该把生成动作放到详情页之后。

这些经验如果只停留在一次对话里，很快就会消失。Hermes 的意义是把它们变成下一次可加载的 procedure memory。

我理解的“自进化”

这里的自进化不是说模型权重变强了，也不是说 Agent 突然能自己完成一切。

在 PassiveAgent 这个案例里，自进化更像是：

每一次真实开发和排障之后，系统都会把经验写回自己的工作流。下一次面对类似问题时，它不再从零开始，而是带着上一次的经验继续工作。

我觉得可以分成四层。

第一层：记忆进化

一开始 Hermes 只知道“有个 PassiveAgent 项目”。后来它知道项目路径、运行方式、常见命令、部署方式、数据源、飞书交互、Zotero 分类习惯、用户目标和偏好。

这让后续维护不再是冷启动。

第二层：技能进化

项目中反复出现的操作，被沉淀成 skill：

• 如何运行测试；
• 如何手动触发 daily；
• 如何排查飞书；
• 如何检查 launchd；
• 如何做 Zotero taxonomy dry-run；
• 如何迁移 LLM provider；
• 如何写面向用户的 README。

Skill 本质上是 Agent 的操作手册。它不是知识库里的静态资料，而是下一次执行任务时会真的进入上下文的工作规程。

第三层：流程进化

从“帮我改一下”，变成“先审查、再修复、再验证、再提交”。

这其实是我对 Agent 工程最深的体会之一：Agent 要可靠，不能只靠更强的模型，还要靠更稳定的流程。

第四层：系统进化

PassiveAgent 自己也在这个过程中变得更成熟：

• 配置从硬编码走向显式 YAML；
• LLM 输出增加类型校验和兜底；
• 推荐逻辑支持无新增时从 existing pool 推送；
• 飞书按钮交互变清晰；
• data 目录区分业务报告和运行日志；
• README、配置文档、Feishu 文档、定时任务文档逐渐补齐。

所以自进化不是玄学，而是一个很工程化的闭环：

1

真实使用 → 暴露问题 → 修复问题 → 验证结果 → 沉淀经验 → 下一次更快更稳

这个过程给我的几个感受

1. 不要把 Hermes 当“另一个 Coding Agent”

如果把 Hermes 和 Codex/CC 放在同一个维度比较，它并没有明显优势。

但如果把 Hermes 放在“长期个人 Agent 环境”的维度，它的定位就清楚很多：它不是替代 coding agent，而是承接 coding agent 的产物，并负责长期运行、记忆和演化。

一句话概括：

Codex 帮我造零件，Hermes 帮我养系统。

2. 真正有价值的 Agent 项目，通常不是一次性任务

PassiveAgent 的价值不在于某个单点功能多复杂，而在于它每天进入我的信息流。

这类项目需要长期运行、长期调参、长期排障、长期根据反馈变化。它更像一个个人系统，而不是一个 demo。

Hermes 适合的也正是这种场景：有状态、有历史、有工具、有运行环境、有反馈闭环。

3. Agent 的难点经常不在模型，而在边界条件

LLM 摘要和打分只是中间一环。真正花时间的是：

• 数据源质量；
• 去重；
• 评分权重；
• 负反馈；
• 推送节奏；
• 飞书权限；
• launchd 环境；
• 配置与密钥隔离；
• 失败后的可观测性。

这些都是 Agent 应用工程化的一部分。

4. 自进化的前提是“把经验写回系统”

如果每次只是让 Agent 改完代码，然后关掉窗口，那么不会有什么自进化。

自进化发生在这些动作里：

• 把踩坑写进 skill；
• 把稳定流程写进文档；
• 把用户偏好写进 memory；
• 把反复出现的问题变成检查项；
• 把一次性排障变成下一次的默认知识。

这也是 Hermes 相比普通一次性问答工具更有意义的地方。

后续想继续做什么

PassiveAgent 现在只是初具规模，后面还有很多可以继续演进的方向：

1. 补偿机制：如果 macOS 错过 daily 定时任务，登录后自动检测并补跑。
2. 更细的反馈学习：不仅记录忽略，还区分“不相关”“太简单”“重复”“暂时不看”。
3. 更强的知识沉淀：从推荐条目自动生成 Obsidian 结构化笔记，并建立和已有笔记的链接。
4. 面试准备闭环：把高价值内容进一步转成面试题、回答卡、追问链路。
5. 推荐质量评估：定期回看过去一周推送，统计真正被阅读、被沉淀、被忽略的比例。

这些方向都不是单纯“再加一个功能”，而是让 PassiveAgent 更像一个能陪我长期学习和筛选信息的个人系统。

结语

做 PassiveAgent 让我重新理解了 Hermes 的价值。

它不是用来证明“我也有一个 coding agent”。写代码这件事，Codex 和 Claude Code 已经做得很好。Hermes 真正有意思的地方，是它让一个项目拥有长期记忆，让开发过程能沉淀为技能，让排障经验能进入下一次执行，让一个个人 Agent 系统在真实环境里持续演化。

PassiveAgent 管理的是我的信息注意力；Hermes 管理的是这个项目的工程记忆。

前者帮我每天少看一点没那么重要的东西，后者帮我下次少重复一次已经踩过的坑。

这就是我目前理解的 Hermes 实践价值：

不是替代 Codex/CC，而是把一次性 coding 能力放进一个长期可记忆、可执行、可调度、可演化的个人工程环境里。

引子：Agent 工程师的”吃狗粮”实验

作为一名 Agent 算法工程师，我每天都在调优模型的 reasoning 链路、设计工具调用策略、处理多步规划的回滚。但有一个问题始终困扰着我：我自己的 Agent，我自己真的在用吗？

于是我做了一个实验：把自己最常做的机械性劳动——写技术博客——彻底交给 Agent 来驱动。不是简单让 LLM 代写一篇文章丢上去，而是真正搭建一套从选题到部署的完整自动化流水线。每次执行只需几十分钟，产出一篇结构完整、配有暗色 SVG 图表的中文技术文章，自动 push 到 GitHub Pages 并上线 CDN。

这篇文章就是这个实验的第一篇产物——它本身就是 Hermes 写出来的，包括你现在看到的封面图。

选型：为什么不是 Claude Code 或 OpenClaw？

在搭建之前，我对比了三个当前主流的开源 Agent 框架：

三个框架各有侧重。Claude Code 的定位很清晰——它是一个编码 Agent，擅长代码补全、重构、PR review，但它没有持久记忆，也不支持定时触发，更别提自进化能力了。对博客自动化这种需要跨 session 积累经验的场景，它不适用。

OpenClaw 则是一个通用 Agent 框架，支持 Telegram 和 Web 输入、有完善的插件系统，看起来似乎非常适合。但实际评估后发现几个硬伤：它没有持久记忆（每次 session 都是全新的上下文）、没有 cron 定时任务引擎、部署需要 Docker + 多服务协调，维护成本不低。最关键的是——它没有自进化机制。每次任务执行完毕，知识就随着 context window 的关闭消散了。下次执行同样的任务，它还是会踩同样的坑。

而 Hermes 是唯一同时具备以下能力的框架：

1. 持久记忆：跨 session 保留用户偏好、环境信息、历史教训
2. Cron 定时引擎：内置定时任务系统，真正做到无人值守
3. 自进化 Skill 系统：每次任务完成后自动沉淀 Skill，下次更稳更快
4. 零维护部署：pip install 一行搞定，不需要 Docker 集群

这正是我选择 Hermes 来驱动博客引擎的核心原因。

架构：Pipeline 全景

整个流水线分为五个阶段，每一阶段都完全由 Hermes Agent 驱动：

1. 选题策划：Agent 根据持久记忆中记录的阅读偏好和技术栈，结合当前热点，自动生成选题建议
2. AI 写作：大模型按照预设的章节结构（引子→选型→架构→机制→展望→总结）生成正文，自动控制字数在 3000-4000 字
3. 图表生成：直接生成 SVG 格式的暗色配图——流程图、对比表、架构图，全部用代码完成而非调用图片生成 API
4. Git 部署：自动 commit + push 到 GitHub Pages 仓库，3 分钟内上线 CDN
5. CDN 上线：通过 jsDelivr 全球 CDN 分发，访问 jackzhu.top 即可看到

最妙的是第 6 步——自进化回路。每次流水线执行完成后，Agent 会把本次执行中踩到的坑、发现的优化点、用户反馈的修正自动写入 Skill 文件。下一次执行时，这些经验会自动加载到 context 中，让流水线变得更稳、更快、更精准。

自进化机制：不只是”自动化”，是”越用越好”

很多人把 Agent 和”自动化脚本”划等号，这是一个误解。普通自动化脚本是配置驱动的：一次编写，万年不变，场景稍有变化就需要人类介入修改。

而 Hermes 的自进化机制完全不同：

举个例子：第一次写博客时，Agent 生成的 SVG 图表可能在布局上有些瑕疵——图表间距不够、文字溢出、颜色对比度不够。这些反馈我不会手动去修代码，而是在回复中指出。Hermes 会把我的修正意见写入 Skill，下次再生成 SVG 时自动应用这些改进。三次迭代之后，生成的图表质量已经可以媲美专业设计师。

Skill 沉淀：从 v1.0 到 v1.3 的进化之路

博客引擎的 Skill 经历了三次关键迭代：

• v1.0：基础流水线——能跑通，但图表丑、排版偶尔翻车、字数控制不稳定
• v1.1：SVG 定义沉淀——暗色主题模板、间距规范、配色方案全部固化到 Skill，图表从”能用”变成”好看”
• v1.2：Hexo 规范适配——frontmatter 格式、分类体系、CDN 引用路径全部标准化，不再出现部署后图片 404
• v1.3：自检与回滚——每次发布前自动检查图片 CDN 可访问性，发现问题时自动回滚并重试

这三个版本只用了不到一周的迭代时间。如果不是自进化机制，光 v1.0 到 v1.1 的 SVG 调优工作，靠手动改 CSS 至少需要一整个下午。

为什么不用 OpenClaw：一个务实的取舍

这里有必要坦诚地说明为什么我没有选 OpenClaw。OpenClaw 的插件生态（40+ 插件）和通用性确实令人印象深刻，但它设计哲学是”一次性的自动化任务”——每个 session 是独立的，没有跨 session 的知识传承。

打个比方：OpenClaw 像一个非常能干的实习生，每次交给他任务都能完成，但他不会做笔记。下次再给他同样的任务，他还是要从头摸索。而 Hermes 像一个会写 SOP 的资深工程师——每次完成任务后会把经验写成标准操作流程，下次拿到类似任务直接调用，越做越顺手。

对于博客自动化这种 “长期稳定运行 + 需要持续优化” 的场景，有没有自进化能力几乎是质的差别。

复用展望：不止于博客

这套流水线的核心能力——定时触发、多模态生成、Git 自动化、自进化沉淀——远不止能用于博客。我已经在规划几个扩展方向：

• 日报/周报生成器：自动抓取项目进度、PR 记录、会议纪要，汇总成结构化的日报
• 竞品监控 Agent：定时抓取竞品更新、定价变化、新功能发布，生成分析简报
• 技术文档维护：代码仓库的 README、CHANGELOG 随代码提交自动更新

每一个新场景只需要创建一个新的 skill 文件，框架层完全复用。这就是自进化 Agent 的真正威力——基础设施一次搭建，垂直场景无限扩展。

总结

这次”吃狗粮”实验验证了我的核心信念：Agent 不只是回答问题或写代码的工具，它可以是一套完整的生产系统。从选题、写作、配图到部署，几十分钟内全自动闭环。每次执行都是一次学习，每个 Skill 都是一次进化。

如果你也在做 Agent 相关的开发，我建议你也试试”吃自己的狗粮”——把你最日常的任务交给你的 Agent，看看它能做到什么程度。你可能会发现，你的 Agent 比你想象的更强大。

本文由 Hermes Agent 全程驱动完成——从选题策划到 SVG 图表生成到 Git 部署，人类仅在最终审阅环节介入。这正是 “自进化博客引擎” 的第一篇自证之作。

想象这样一个场景：你让 Agent 帮你调研一个开源项目。第一轮，你告诉它「只关注 Python 实现，忽略 JS 版本」。第三轮，它兴高采烈地给你推荐了一个 Node.js 库。你纠正了它。到了第五轮，它又忘了。

你忍不住问：你的记性为什么这么差？

这个问题背后，是 AI Agent 领域一个被严重低估的核心挑战——上下文工程（Context Engineering）。大多数人以为，只要上下文窗口足够大（比如 Gemini 的 1M tokens），Agent 就能「记住一切」。但真实情况是：上下文窗口是 Agent 的 RAM，记忆系统才是 Agent 的硬盘——两者缺一不可，且各自有各自的工程难题。

本文将系统性地拆解 Agent 记忆系统，从问题定义到工程方案，分为六个层次逐步深入。

1. 问题定义：上下文窗口的幻觉

长上下文是必要条件，但它带来的问题远比解决的问题多。我们来看四个核心挑战：

1.1 注意力稀释：Lost in the Middle

2023 年，Liu 等人在论文 Lost in the Middle: How Language Models Use Long Contexts 中揭示了一个反直觉的发现：当信息位于上下文窗口的中间位置时，模型的检索准确率会显著下降。

这个发现的重要性怎么强调都不为过。模型不是均匀地「注意」所有上下文——它天然倾向于关注开头（首因效应）和结尾（近因效应），中间部分的信息被严重稀释。当你把 100K tokens 的上下文一股脑塞给模型时，中间 40K-60K 位置的关键指令可能已经被「淹没」了。

1.2 成本爆炸

以 GPT-4 级别模型为例，输入价格为 $10/1M tokens。1M token 上下文的一次推理就要 $10，而一个复杂的 Agent 任务可能需要十几轮甚至几十轮对话。成本不是线性增长，而是飞轮效应——每轮都把历史带上，上下文越来越长，成本越来越高。

1.3 幻觉加剧

上下文越长，无关信息越多。模型在多轮对话中会逐渐被早期噪声干扰，产生「上下文幻觉」——用错误的记忆覆盖正确的信息。这不是模型本身的幻觉问题，而是上下文工程的问题。

1.4 延迟不可控

KV Cache 的大小与上下文长度成正比。1M token 上下文的 prefilling 阶段可能需要数秒甚至数十秒，首 token 延迟（TTFT）从毫秒级膨胀到秒级。对于需要快速响应的 Agent 场景，这是致命的。

结论： 上下文窗口大 ≠ 记忆好。你需要一套工程体系来管理 Agent 的「注意力预算」。

2. 上下文分层架构

Agent 记忆系统的核心设计理念是分层——不是一层记忆，而是三层。

2.1 工作记忆（Working Memory）

定义： 当前对话窗口中的全部信息，4K–32K tokens，严格顺序保留。

工作记忆是 Agent 的「意识」。它包含系统提示（角色定义、行为规则）、对话历史（用户输入和 Agent 回复的完整序列）、工具定义（函数签名和参数 schema），以及从长期记忆中检索到的相关上下文。

关键工程挑战：

• 触发压缩的时机： 当 token 预算达到阈值（如 70%）时，必须触发压缩，而不是等 OOM 再处理
• 压缩策略选择： 摘要（保留语义，丢失精确细节）vs 截断（保留最新信息，丢失历史）vs 关键对话提取（保留决策点和纠正，丢弃过程噪音）
• 压缩粒度： 对早期轮次进行激进压缩（只保留摘要），对近期轮次保持原始内容

2.2 情景记忆（Episodic Memory）

定义： 历史会话的结构化摘要，向量化存储，支持语义检索。

情景记忆是 Agent 的「短期记忆」。当一次会话结束后，不是把原始对话全部丢掉，而是提取关键信息——决策、纠正、偏好变化——并以向量的形式存储。

存储什么：

• 用户在这次会话中的偏好表达（「以后用 pytest 不要用 unittest」）
• Agent 在这次会话中的关键决策及其原因
• 用户对 Agent 行为的纠正（「上次你说 X，实际是 Y」）
• 会话最终产出的摘要

不存储什么：

• 过程性讨论和试探性尝试
• 工具调用的中间结果
• 用户明确表示「不要记」的内容

2.3 语义记忆（Semantic Memory）

定义： 长期累积的结构化知识，包含用户画像、领域知识、工具经验和固化技能。

语义记忆是 Agent 的「长期记忆」，也是最稳定的一层。它不随会话结束而消失，而是逐步累积和更新。

核心原则： 语义记忆必须是结构化的，不能是纯文本堆砌。因为它在每次推理时都会被注入到系统提示中，结构化的信息更容易被模型有效利用。

3. Token 预算管理

如果把上下文窗口比作 Agent 的「预算」，那么 Token 就是 Agent 的「货币」。你需要一个精打细算的财务管理系统。

3.1 静态预算分配

以 128K 上下文窗口为例，建议的分配策略：

3.2 动态调度机制

静态分配只是起点。真正的挑战在于动态调度：

工具返回截断： 当工具调用结果超过预留空间时，不直接截断到固定长度，而是提取关键信息——比如从 10000 行的日志中只保留 ERROR 和 WARNING 级别的内容。

递进式压缩： 不是一次性压缩所有历史，而是递进式处理。早期轮次（第 1-5 轮）高度压缩为摘要，中期轮次（第 6-10 轮）保留关键对话，近期轮次（最近 5 轮）完整保留。

记忆外化： 当上下文即将耗尽时，主动将部分信息「外化」到外部存储，并在需要时通过检索召回。这类似于操作系统的虚拟内存机制。

3.3 实践建议

1
2
3
4
5
6
7
8
9
10

# 伪代码：Token 预算检查
def before_each_turn():
    tokens_used = count_tokens(system_prompt + history + tools)
    tokens_left = max_context - tokens_used - RESERVE
    
    if tokens_left < SAFETY_THRESHOLD:
        if oldest_rounds_not_compressed():
            compress_oldest_rounds()  # 递进式压缩
        else:
            externalize_to_memory()   # 记忆外化

重要提示： 不要信任模型自报的 token 计数。始终使用独立的 tokenizer 维护精确计数，在每次工具调用前后检查预算。

4. 记忆检索：Agent 的搜索引擎

存得好不如取得好。如果检索系统不能在海量记忆中精准召回相关信息，那记忆系统就是个昂贵的摆设。

4.1 Agent 场景的检索特殊性

相比传统 RAG，Agent 的记忆检索有三个独特挑战：

• 时间敏感性： 上一条消息中用户说的「不要用 unittest」比三个月前说过的话重要得多
• 上下文依赖性： 同样的查询「跑一下测试」，在不同项目、不同阶段含义完全不同
• 精确匹配需求： 用户可能明确提到实体名（如「那个叫 hermes-agent 的项目」），需要关键词级别的精确匹配

4.2 混合检索公式

单一维度无法满足 Agent 的需求。我们需要混合检索：

1

score = α × 语义相似度 + β × 时间衰减 + γ × 关键词匹配 + δ × 重要性权重

各维度详解：

• α × 语义相似度（权重 0.40）： 基于 embedding 的 cosine similarity，捕捉语义层面的相似性
• β × 时间衰减（权重 0.25）： 指数衰减函数 e^(-λ × Δt)，让近期记忆有更高的召回率
• γ × 关键词匹配（权重 0.20）： 使用 BM25 算法，确保用户提到的精确实体能被命中
• δ × 重要性权重（权重 0.15）： 在存储时由 LLM 对记忆的重要性进行预打分

4.3 检索时机

Agent 不应该只在用户明确要求时才去检索记忆。三种触发时机：

1. 主动检索： 每轮对话开始时，根据用户最新输入检索相关记忆，注入工作记忆
2. 被动检索： 当 Agent 对自己的回答不确定时，主动查询记忆进行校验
3. 触发词检索： 用户说「上次」「之前」「我记得你说过」时，强制触发跨会话检索

5. 终身学习：让 Agent 越用越聪明

三层记忆架构解决的是「记住什么」和「怎么取」的问题。但还有一个更深刻的问题：Agent 能不能从经验中学习，而不是每次都需要用户重新教一遍？

这就是终身学习（Lifelong Learning）——Agent 记忆系统的最上层。

5.1 学习什么

Agent 可以从以下几个维度持续学习：

5.2 学习机制

显式学习： 用户明确纠正 Agent → 立即更新相关记忆。这是最高优先级的学习信号。

隐式学习： Agent 从成功完成的任务中提取模式。不需要用户干预，但需要足够多的样本（连续 3-5 次相同模式）才会触发固化。

反思学习： 任务失败后，Agent 进行根因分析（Root Cause Analysis），将教训以「反模式」的形式存入记忆，避免下次犯同样的错误。

5.3 防止灾难性遗忘

记忆系统最大的敌人不是「记不住」，而是「记错了」或者「新知识覆盖了旧知识」。

三大防御机制：

1. 冲突检测： 新记忆与旧记忆矛盾时，优先信任用户最新表达，但保留旧记忆作为上下文参考
2. 衰减而非删除： 长期未使用的记忆降低检索权重，但不删除。因为「很久没用的知识」可能只是暂时不需要
3. 定期审计： 定期让 Agent 自查记忆一致性。例如：用户说他是「Python 开发者」，但某条记忆写的是「主要写 Rust」——这种矛盾应该标记出来

6. 工程实践与总结

6.1 架构全景

完整的 Agent 记忆系统架构可以总结为三层 + 两个管道：

• 三层： 工作记忆 → 情景记忆 → 语义记忆
• 向下管道（压缩沉淀）： 工作记忆过期 → 压缩为情景记忆 → 长期知识提取为语义记忆
• 向上管道（检索召回）： 语义记忆 + 情景记忆通过混合检索 → 注入工作记忆

6.2 选型建议

6.3 关键启示

回顾全文，我想强调三个核心理念：

• 「上下文窗口是 Agent 的 RAM，记忆系统是 Agent 的硬盘」——两者缺一不可，且各自需要精心设计
• 「好的记忆系统让 Agent 从工具变成伙伴」——它不需要你反复交代，能从过往交互中学习成长
• 「不要等到上下文不够用了才想记忆——在设计的第一天就要考虑三层架构」

6.4 展望

Agent 记忆系统还远未成熟。展望未来，有几个值得关注的方向：

• 多模态记忆： Agent 不仅要记住文本，还要记住图片、代码片段、结构化数据
• 联邦记忆： 多个 Agent 共享部分记忆，形成集体智能
• 自适应记忆架构： 根据用户使用模式自动调整各层容量和检索策略
• 隐私感知记忆： 用户可以选择性地「遗忘」某些信息，符合 GDPR 等隐私法规

本文首发于 jackzhu.top。如果你在大厂 Agent 团队工作或有相关实践经验，欢迎在评论区交流讨论。

为什么要使用uv

现在的包管理工具有很多，conda，pip，poetry，pipenv 等等，功能各有千秋，但都存在一些问题，而uv则可以在很大程度上解决了这些问题。

自从接触到uv之后我几乎不再使用其他包管理工具，只有部分情况是例外的，比如个别仓库默认的包管理工具是conda或者poetry，而且这个项目用uv会存在bug，比如ComfyUI，使用uv就会有问题，这种就会使用conda。或者个别比较老的代码，有些时候就存在一些问题，这种还是求稳定最好。

uv的优势

1. 极致性能

• 安装速度提升：这是非常重要的一点，UV 在无缓存的冷启动情况下，安装速度比 pip 快约 8～10 倍；uv在已有缓存的情况下，速度提升可达 80～100 倍。这一点看似不明显，但是亲身体验之后就回不去了，命令刚输完就执行完了，简直不要太爽。pip是单线程串行下载，且每安装一个包就校验一次，速度受限；解析依赖时是递归深度优先，每次都重新 resolve，IO+CPU双重瓶颈。而uv完全异步并行下载（利用 Rust 的 tokio runtime），同时批量多线程拉取 wheel 文件。依赖解析一次性建树，在内存中直接解析出完整依赖树，再按优先级并行处理。大量减少 I/O 阻塞、减少不必要校验轮次。

• 并行下载与解析：​利用 Rust 的并发能力，UV 实现了高效的依赖解析和并行下载，大幅减少了安装时间。uv在解析阶段同时并发处理多条依赖关系。下载阶段是异步 HTTP 客户端，同时并发多达 32+ 连接从镜像源拉取 .whl 文件。在安装阶段：解压 wheel 包时并行 IO + CPU 分摊。最近几年很多rust的项目都表现不错，未来可期。

• 全局缓存机制：UV 使用全局包缓存，避免重复下载和构建，提高了资源利用率。这一点其实还是很重要的，因为conda也可以进行全局缓存，但是conda由于本身就非常慢，这样效率其实也没有快哪里去。同时uv的依赖解析缓存也更加细粒度，非常快，全局统一缓存目录管理更加智能，冷启动性能好。pip 的 cache只是简单放 .whl 文件。UV的 cache更加复杂，针对不同源（PyPI、国内镜像等）独立管理缓存目录；wheel/binary/source包缓存分离；pip-style .whl 缓存 + 自有 build cache（本地打包 artifacts）；还有软链接/硬链接优化（安装时尽量链接，不拷贝）

2. 统一的项目管理

• 集成虚拟环境管理：​UV 内置虚拟环境管理功能，自动在项目中创建和管理虚拟环境，避免了手动操作，非常方便，而且还方便切换python多个版本，避免了本地环境污染。

• 支持 pyproject.toml：UV 使用 pyproject.toml 作为项目配置文件，统一管理依赖和项目元数据。这是一种现代化的依赖管理方法，负责定义项目的元数据、依赖关系、构建系统以及 UV 的特定配置。

• 生成锁定文件：​UV 自动生成 uv.lock 文件，精确记录每个包的版本和校验信息，确保环境的可重复性。​

3. 灵活的依赖解析

• 多种解析策略：​UV 提供多种依赖解析策略，如选择最新兼容版本或最低版本组合，满足不同需求。​

• 支持多 Python 版本：​UV 允许指定目标 Python 版本进行依赖解析，即使当前环境中未安装该版本的 Python。​

依赖覆盖机制：​UV 引入了“依赖覆盖”机制，允许用户修改某些包声明的依赖版本，解决上游包的依赖冲突问题。​

4. 丰富的功能集
   命令行工具管理：​UV 提供类似于 pipx 的功能，可以在隔离的环境中安装 Python 工具，同时使它们的命令行接口全局可用。​

Python 版本管理：​UV 支持安装和管理不同版本的 Python，方便在项目中使用特定版本的解释器。​

脚本运行支持：​UV 支持运行脚本，并支持内联的依赖元数据，简化了脚本的依赖管理。

基本使用和常用命令

一段很简单的安装：

pip install uv

快速创建项目：

uv init my_project
cd my_project

添加包：

uv add requests

删除包：

uv remove requests

同步安装依赖：

uv sync

重新解析依赖并生成锁定文件：

uv lock

创建虚拟环境：

uv venv .venv

跟 pip 使用方式类似：

uv pip install flask

运行脚本：

uv run python app.py

清理缓存：

uv cache clean

pyproject.toml 包管理文件使用

UV 采用标准的 pyproject.toml，统一管理项目信息和依赖：

基础结构：

[project]
name = “my_project”
version = “0.1.0”
dependencies = [
“requests>=2.31”,
“numpy~=1.24”
]

[project.optional-dependencies]
dev = [“pytest”, “black”]

[build-system]
requires = [“hatchling”]
build-backend = “hatchling.build”

UV 特有配置：

[tool.uv]
managed = true
package = true

[[tool.uv.index]]
url = “https://pypi.tuna.tsinghua.edu.cn/simple“
default = true

[tool.uv] 表示是否由 UV 管理虚拟环境、打包等

index 可以指定镜像源（如清华 PyPI）

同时 UV 会生成 uv.lock，锁定给定环境下的确定包版本和校验信息，保证可重复性。

常见问题和解决方法

1. 使用 –system-site-packages 后包无效

UV 创建虚拟环境时，当使用 –system-site-packages，运行可以访问系统包，但不会在解析时考虑。

建议自己在虚拟环境内重新安装所需包，保证环境简洁可控。

2. 删除包后剩余依赖

uv remove xxx 不会自动删除其依赖包

需要手动执行：

uv lock
uv sync

依赖分析后自动清理

3. 网络慢，下载失败

使用国内镜像：

uv config set index-url https://pypi.tuna.tsinghua.edu.cn/simple

4. uv.lock 未自动更新

进行依赖改动后，需自动执行：

uv lock

在 UV 中管理 PyTorch

1. 基础安装：

默认：Windows/Mac 安装 CPU-only 版，Linux 安装 CUDA 12.4 版

uv init –python 3.12
uv add torch torchvision torchaudio

2. 安装指定 CUDA 版（如 12.6）：

修改 pyproject.toml：

[[tool.uv.index]]
name = “pytorch-cu126”
url = “https://download.pytorch.org/whl/cu126“
explicit = true

[tool.uv.sources]
torch = { index = “pytorch-cu126” }
torchvision = { index = “pytorch-cu126” }
torchaudio = { index = “pytorch-cu126” }

后执行：

uv sync

不过后面官方有了支持，现在好像不用这么配自动了，直接 uv add torch torchvision torchaudio 就会自动安装对应 CUDA 版本的包了

3. 验证 CUDA 支持

新建脚本：

import torch
print(torch.cuda.is_available())
print(torch.cuda.get_device_name(0))

运行：

uv run python check_cuda.py

常见问题：

如果直接用 uv pip install 安装，pyproject.toml 不会更新，建议终究使用 uv add

如遇到网络慢，同样可配置用国内镜像源

总结

UV 是一款超高性能、全配套、很合于环境及大型项目管理的新世代工具，特别适合对环境素质有严格要求的开发者和研究人员。

无论是日常开发，进行快速指定版本部署，还是复杂的模型训练，UV 都完全能上场，是很值得推荐的 Python 包管理方案。

这次秋招前期一直0offer，直到11月多才逐渐有差不多几家，最后开出来了一些，最终还是决定去钱多的地方，毕竟现在工作都不稳，钱多才是王道。

面试前的内容

算法 vs 开发

对于算法和开发的选择，我还是选择了算法，他们都说算法要有顶会，但是其实这个因素影响没有那么大的，我觉得不一定需要顶会，但是论文还是要有的，毕竟算法岗。没有顶会的情况下最重要的就是实习了，实习一定要把握住，这个可比顶会好拿到多了。我看往前几届的师兄师姐都去的开发岗，基本都是Java，但是这块我又不擅长，突击几个月还不一定有本科生学的好，干脆all in 算法了。毕竟算法还是比开发高很多的，还是可以冲下的。

另外一个选择的区别就是个人选择和未来规划，如果本科双非，同时没有科研论文，还没有实习，而且不打算后面卷，而是打算过几年回老家附近的地方，或者直接一步到位去二线城市，肯定直接Java，毕竟选择面非常广，Java的岗位数量遥遥领先，而且去国企银行运营商都好找工作。

如果还更有些追求，打算去大厂干几年，算法还是更好的，只是本科双非其实不算主要的问题，前提是有比较好的论文或者顶会，再想办法弄个实习，这样基本还是能找的，但要是都没有，那就不太容易了。

对于算法的准备，主要从以下几个方面展开，大致有力扣，简历，实习，秋招等。

力扣

力扣这是最基本的准备，毕竟除了人才计划，其他无论算法开发岗位都有力扣的考察，所以这个是一定要准备的。力扣的内容基本刷几遍hot100就差不多了，基本面试的手撕都是hot100这个难度，基本从前一年的12月就可以开始每天一道题了，开始的时候会很慢，后面慢慢熟练了就快了。之所以要开始这么早是因为实习是第二年三月就开始了，提前三个月准备刷题还是有必要的。很多人刷300题，基本肯定是够用了，有的人甚至刷了600题，其实不是特别有必要，力扣题主要起到的是一个门槛的作用，笔试不过直接pass，过的情况下主要看面试了。

简历

简历是非常重要的，决定了简历筛选后面能不能进笔试和面试，我简历凑合吧，投了90家，进面大概30家，正常水平吧。简历一般是先教育经历，之后最好是要有实习经历，然后是论文和科研部分，后面是项目可以放几个，后面是比赛获奖那些，主体就这些吧，具体根据不同人，优势不同，做的好的放前面一些。根据篇幅，后面可以加一些个人技能，比如编程语言和计算机工具比如Git、Linux什么的掌握情况，最后篇幅不够可以放自我评价，这个不是必须，可有可无。

对于简历的排版来说，也可直接按照不同模块的顺序，也有按照一个一个项目，然后每个项目后面跟着其中的产出论文成果以及技术栈，不同的都是可以的，根据自己实际情况来，总之自己最突出的地方要尽可能的放到比较显眼的前面。

对于简历是一页还是两页，我看不同HR喜好并不同，有的认为一页简单明了，有的觉得一页太单薄。总之校招一般不超过两页（博士除外），实际来看如果确实有内容建议充实两页，排版不要过于空旷，适当紧凑一些。

面试内容

一般一面或者二面技术面，自我介绍之后，如果有比较有含金量的实习或者论文会先讲这部分，之后会问项目之类的，之后有的会问一些八股，这个八股有的是算法八股比如Transformer、CNN、RNN卷积等什么的，这块需要背下。有的会问到计算机基础比如进程线程还有Python基础比如装饰器，线程锁啥的，这块只是有时候会问到。

然后就是面试中的手撕了，这个不是必须，有的面试会有手撕，这个因岗位和公司不同，手撕大部分是力扣，当然也有例外，比如淘天，投实习的时候手撕是手写多头注意力，交叉熵等题目，还有k-means的，这个不提前准备的话想快速写出来也不太容易。比如华子正式面试二面就出了个数字图像处理的手撕，很难，就蚌埠住了，这种题不多见。

技术面之后一般主管面，这块可能的问题很多，从个人信息到家里情况，到抗压测试，了解新信息的途径，其他还有比如人工智能对各行各业的影响，大模型在不同行业的应用，甚至包括盈利模式啥的等产品问题，不同的侧重点也不同，需要随机应变。这个部分不可小视，相关问题要整理下，大致想想如何回答。有的公司比如华子是技术面了可以捞，但是主管面挂了就不行。

实习

实习的重要程度可以说是第一了，毕竟一般如果组内条件不具备的话，是发不出来顶会的，尤其对于硕士，所以实习就成为了性价比最高而且最可以获取到的了。

准备实习第一步是要提前刷力扣题，然后准备简历润色，之后到三月下实习基本就开始了，四五月是最主要的时间，六月基本就不多了，建议尽早投递，一般越早越容易拿到Offer，前期看哪些先开，最开始的可以不投特别大的厂，因为没有相关经验，如果面的很差的话确实会影响面评，影响后面，不过大部分好像影响不大的，可以先从小厂开始，虽然很多时候大厂先开。在面试的过程中不断复盘，总结经验，不断提高，投递尽量不要拖太后，后面很多没有hc，即使准备的好也没用了。

我前面投递实习的时候技术面其实不会特别难，不过也有例外，比如淘天的，还有腾讯AILab这种，不过多面还是有好处的，对于秋招面试也是积累经验的过程。

如果实在没有实习经历，也是可以把一些横向的项目加进去，包括校企合作，实践活动，这种有的也是算实习的。

实习看能不能转正，如果能转正就要好好准备，不能的话就趁早想想后路，实习的经历如何整理成体系，面试的时候问答到相关的问题如何回答，把工作点整理好，面试的时候就不慌。

除此之外，如果没有特别好的成果的话实习投递也有可能不容易找到，但是这也是一个打怪升级的过程，有实习还是远远大于没有实习的，没有大厂就先去小厂，后面有机会再去大厂，先找一个能去的。

秋招

如果有实习的话一般八九月就要回去准备秋招了，除非对自己非常自信能实习转正。对于有实习的有经历，但是秋招的准备会少一些时间，因为实习很多时候也挺忙的，个别实习好像能直接在公司刷力扣，不过这种极少，看部门和主管。没有实习的人秋招七八月的时候有比较完整的时间准备秋招的内容比如力扣八股，把项目好好复盘。

建议还是尽早投递，确实是越早越容易，所以早点开始准备秋招的时候就可以占有不少优势，前后期难度确实不同，基本上八月份面试的都容易进。然后整理一个表格，不同公司的啥时候开始投递，有些相关的群要关注下，有的学长学姐会进行整理，自己这个表格记录好公司、投递时间、岗位、base地，笔试面试情况和时间啥的，方便自己查看。

算法方向

对于算法方向，目前岗位很多是算法工程师或者AI工程师，这块需要的技能很多时候不是只限一个方面的，很多岗位问的时候是既有传统算法也有大模型，所以技能肯定是越多越好，绝大部分算法都不是研究型的算法，而是业务型的算法，这样的算法主要是以解决实际问题来的，无论传统算法还是深度学习或者大模型，根据实际问题选择，所以都会最好。当然也有不少是直接的大模型算法工程师，虽然这种岗问的时候也还是有一般的算法。具体来说，主要从以下几个方向展开。

视觉方向

这个方向也是前面做的人最多的方向，虽然很多人现在做的还是视觉的项目或者科研，但是确实不建议用这个来找工作，除非你能发CCF-C及以上的论文吧，虽然C也很勉强。现在视觉的岗位太少了，所以必须是做的比较深，有一定的研究才行，不然相关的算法都很成熟了，不太好用来找工作。

这个方向现在不适合单独作为一个方向找工作，但是也是算法工程师基本必不可少的一个基础，还是要会一些相关内容更好的。

以下是两个半可以做的方向，说是两个半是因为第三个方向部署推理这块的hc远远不如前面两个的。

大模型

这个方向是目前算法最好找工作的方向了，大语言模型和AIGC这块的需求很多。很多人都说自己没做过，可问题是22年11月底ChatGPT出来之前，有几个人是做大模型的？现在做大模型的人99.9%的都是大模型出来之后开始学的，这块的上手门槛没有那么高的。很多人准备一两个月做一个大致像样的项目，用来参加比如书生浦语浦源大模型挑战赛，或者阿里这种的大模型比赛，差不多获奖就可以拿来简历用了，只要被问到的时候能讲清楚就还是可以的。现在各行各业都在用大模型做一遍，仍然是个可以做的风口，虽然风口过去并不知道能做成啥样，但是这几年自己能赚到就可以了。

学习这个并不需要一上来直接看论文，看看相关的项目，和一些相对比较容易的开源课程，先上手了解整个体系，然后尝试做个玩具微调下，之后再去认真研究，是个比较好的学习方法。

搜广推

这个方向作为互联网的基础，有非常稳定的基础，但是对于应届生来说学校期间往往不做这块的内容，不过要是突击两个月还是可以做下的，不算特别热，但是hc还可以，互联网都招。

部署推理

这个方向涉及模型的量化、剪枝、蒸馏、推理、部署、推理框架、推理引擎，还要AI Infra这些，这些方向其实还是可以做的，尤其现在大模型落地对这块的需求还是不少的，即使不是大模型的部署，小模型的部署也是有需求的。不过这块就要深挖下了，很多时候涉及C++，难度就上来了，不过这块的hc数就远比不上前面了，而且相对不太好转方向，有的开的价还可以，有的不如算法，但是还是比开发高的，也算是一个可以尝试的方向。tensorrt、ncnn、tvm、onnnx，还有vllm、turbomind、triton这些都是可以学习的。

这个方向因为hc极少，只攻这一个方向还是不好找工作，但是问题在于，算法工程师的技能点之一是CPP和量化部署这块，包括AI研发岗，我秋招面的很多家都会问到这块学的如何，也问相关的细节，所以这块如果会一些也是有好处的。

面试内容总结

简历学习内容

大模型

实习相关

实验评价指标

• 正则匹配如何做的
• 类别非常不均的情况下 acc 指标是否足够，不足使用了什么
• 语义理解的评价指标
• 具体指标
• 为什么这样用
• 这一指标达到多少，什么意义
• badcase 有多少，是什么原因，如何处理的

如何根据实验结果调整 prompt

数据构造

• 数据量
• 构造方法
• 实际上下文长度是多少
• 数据截断是什么问题

数据如何标注的

• 真值从哪里来
• 标注的数据有什么问题

采用大模型而不是之前的机器学习方法的意义、优点

改进和上线所需措施

• 模型是否满足上线需要
• 如果不满足是因为什么，效果或速度还是其他
• 上线需要解决其他什么问题，后续需要做什么

相关理论

• 主流的大模型参数、量级、结构、最大上下文长度，如何选取
  • Llama 系列
  • 千问
  • 盘古智子
  • chatglm
  • internlm
  • 其他
  • openai o1
• 大模型评测方法
• CoT 和实习中的应用
• 微调方法
  • LoRA、QLoRA 等多种方法
    • 多头 LoRA
    • LoRA
    • QLoRA
  • 训练了哪些层
  • 设置了哪些超参数，如 r、 alpha等
  • 如何根据实际情况调整这些参数
• 分布式训练方法
  • deepspeed
  • zero

RAG 相关

• 原理
• 解决什么问题，为什么用 RAG
• RAG 的向量表征方法都有哪些，怎么做的

视觉

目标检测

• 模型
  • YOLOv1~v11
  • 各代演进和区别
  • 总体发展理论
  • DETR 等无 nms 的模型
• 模型架构
  • 主干网络的变化和区别
  • 金字塔融合方式的多种
  • 中间模块和处理方法
• 图像增强
  • 一般的几种
  • mosaic 等多种方法
• 量化
  • 量化方法
  • 参数量
  • 速度精度
• 剪枝
  • 方法
  • 对网络什么部分进行剪枝
  • 参数量变化
  • 速度变化
• CPP 部分主要包括哪些
  • 具体这部分如何用的

人脸识别

• 人脸识别和检测部分
• 构建索引和检索理论
• 向量表征
• 相似度检索
• 活体识别

算法八股

理论

• Transformer 模型讲解
• LayerNorm 等多种 norm 方式如 BatchNorm
• Encoder 和 Decoder 相关
• RNN、LSTM、Transformer 变化
• 大模型中激活函数等多种常用的结构
  • GQA
  • MQA
  • RMSNorm
  • SwiGLU
  • RoPE
• 激活函数
  • ReLU
  • Leaky ReLU
  • GELU
  • tanh
  • sigmoid
  • swish
  • ELU
• 特征工程包括什么，如何做
  • 常见的数据预处理方法有哪些
• 分布式数据处理原理（如 Hadoop）
• 计算机理论相关（如堆和栈的区别）

手撕

• Transformer
• 注意力
• LayerNorm
• KMeans
• NMS
• IOU 计算

最后补个学习的内容：算法工程师面试常考手撕题

引用链接https://mp.weixin.qq.com/s/TAFvUlqdyqP-W6C10F1Hzw

• 算法工程师面试常考手撕题
  • 注意力（Attention）篇
    • 手撕单头注意力机制（ScaledDotProductAttention）函数
    • 手撕多头注意力（MultiHeadAttention）
    • 手撕自注意力机制函数（SelfAttention）
  • 基础机器学习算法篇
    • 手撕 k-means 算法
  • 手撕 Layer Normalization 算法
  • 手撕 Batch Normalization 算法
  • 解码算法篇
    • 手撕 贪心搜索 （greedy search）
  • 神经网络篇
    • 手撕 卷积神经网络(CNN)法
    • 手撕 二维卷积 算法
  • 位置编码篇
    • 手撕 绝对位置编码 算法
    • 手撕 可学习位置编码 算法
    • 手撕 相对位置编码 算法
    • 手撕 rope 算法
  • 面试题汇总
  • 致谢

注意力（Attention）篇

手撕单头注意力机制（ScaledDotProductAttention）函数

输入是query和 key-value，注意力机制首先计算query与每个key的关联性（compatibility），每个关联性作为每个value的权重（weight），各个权重与value的乘积相加得到输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class ScaledDotProductAttention(nn.Module):
    """ Scaled Dot-Product Attention """


    def __init__(self, scale):
        super().__init__()


        self.scale = scale
        self.softmax = nn.Softmax(dim=2)


    def forward(self, q, k, v, mask=None):
        u = torch.bmm(q, k.transpose(1, 2)) # 1.Matmul
        u = u / self.scale # 2.Scale


        if mask is not None:
            u = u.masked_fill(mask, -np.inf) # 3.Mask


        attn = self.softmax(u) # 4.Softmax
        output = torch.bmm(attn, v) # 5.Output


        return attn, output




if __name__ == "__main__":
    n_q, n_k, n_v = 2, 4, 4
    d_q, d_k, d_v = 128, 128, 64


    q = torch.randn(batch, n_q, d_q)
    k = torch.randn(batch, n_k, d_k)
    v = torch.randn(batch, n_v, d_v)
    mask = torch.zeros(batch, n_q, n_k).bool()


    attention = ScaledDotProductAttention(scale=np.power(d_k, 0.5))
    attn, output = attention(q, k, v, mask=mask)


    print(attn)
    print(output)

手撕多头注意力（MultiHeadAttention）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

class MultiHeadAttention(nn.Module):
    """ Multi-Head Attention """


    def __init__(self, n_head, d_k_, d_v_, d_k, d_v, d_o):
        super().__init__()


        self.n_head = n_head
        self.d_k = d_k
        self.d_v = d_v


        self.fc_q = nn.Linear(d_k_, n_head * d_k)
        self.fc_k = nn.Linear(d_k_, n_head * d_k)
        self.fc_v = nn.Linear(d_v_, n_head * d_v)


        self.attention = ScaledDotProductAttention(scale=np.power(d_k, 0.5))


        self.fc_o = nn.Linear(n_head * d_v, d_o)


    def forward(self, q, k, v, mask=None):


        n_head, d_q, d_k, d_v = self.n_head, self.d_k, self.d_k, self.d_v


        batch, n_q, d_q_ = q.size()
        batch, n_k, d_k_ = k.size()
        batch, n_v, d_v_ = v.size()


        q = self.fc_q(q) # 1.单头变多头
        k = self.fc_k(k)
        v = self.fc_v(v)
        q = q.view(batch, n_q, n_head, d_q).permute(2, 0, 1, 3).contiguous().view(-1, n_q, d_q)
        k = k.view(batch, n_k, n_head, d_k).permute(2, 0, 1, 3).contiguous().view(-1, n_k, d_k)
        v = v.view(batch, n_v, n_head, d_v).permute(2, 0, 1, 3).contiguous().view(-1, n_v, d_v)


        if mask is not None:
            mask = mask.repeat(n_head, 1, 1)
        attn, output = self.attention(q, k, v, mask=mask) # 2.当成单头注意力求输出


        output = output.view(n_head, batch, n_q, d_v).permute(1, 2, 0, 3).contiguous().view(batch, n_q, -1) # 3.Concat
        output = self.fc_o(output) # 4.仿射变换得到最终输出


        return attn, output




if __name__ == "__main__":
    n_q, n_k, n_v = 2, 4, 4
    d_q_, d_k_, d_v_ = 128, 128, 64


    q = torch.randn(batch, n_q, d_q_)
    k = torch.randn(batch, n_k, d_k_)
    v = torch.randn(batch, n_v, d_v_)    
    mask = torch.zeros(batch, n_q, n_k).bool()


    mha = MultiHeadAttention(n_head=8, d_k_=128, d_v_=64, d_k=256, d_v=128, d_o=128)
    attn, output = mha(q, k, v, mask=mask)


    print(attn.size())
    print(output.size())

手撕自注意力机制函数（SelfAttention）

Self-Attention。和Attention类似，他们都是一种注意力机制。不同的是Attention是source对target，输入的source和输出的target内容不同。例如英译中，输入英文，输出中文。而Self-Attention是source对source，是source内部元素之间或者target内部元素之间发生的Attention机制，也可以理解为Target=Source这种特殊情况下的注意力机制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

class SelfAttention(nn.Module):
    """ Self-Attention """


    def __init__(self, n_head, d_k, d_v, d_x, d_o):
        self.wq = nn.Parameter(torch.Tensor(d_x, d_k))
        self.wk = nn.Parameter(torch.Tensor(d_x, d_k))
        self.wv = nn.Parameter(torch.Tensor(d_x, d_v))


        self.mha = MultiHeadAttention(n_head=n_head, d_k_=d_k, d_v_=d_v, d_k=d_k, d_v=d_v, d_o=d_o)


        self.init_parameters()


    def init_parameters(self):
        for param in self.parameters():
            stdv = 1. / np.power(param.size(-1), 0.5)
            param.data.uniform_(-stdv, stdv)


    def forward(self, x, mask=None):
        q = torch.matmul(x, self.wq)   
        k = torch.matmul(x, self.wk)
        v = torch.matmul(x, self.wv)


        attn, output = self.mha(q, k, v, mask=mask)


        return attn, output




if __name__ == "__main__":
    n_x = 4
    d_x = 80


    x = torch.randn(batch, n_x, d_x)
    mask = torch.zeros(batch, n_x, n_x).bool()


    selfattn = SelfAttention(n_head=8, d_k=128, d_v=64, d_x=80, d_o=80)
    attn, output = selfattn(x, mask=mask)


    print(attn.size())
    print(output.size())

基础机器学习算法篇

手撕 k-means 算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import numpy as np
def kmeans(data, k, thresh=1, max_iterations=100):
  # 随机初始化k个中心点
  centers = data[np.random.choice(data.shape[0], k, replace=False)]


  for _ in range(max_iterations):
    # 计算每个样本到各个中心点的距离
    distances = np.linalg.norm(data[:, None] - centers, axis=2)


    # 根据距离最近的中心点将样本分配到对应的簇
    labels = np.argmin(distances, axis=1)


    # 更新中心点为每个簇的平均值
    new_centers = np.array([data[labels == i].mean(axis=0) for i in range(k)])


    # 判断中心点是否收敛，多种收敛条件可选
    # 条件1：中心点不再改变
    if np.all(centers == new_centers):
      break
    # 条件2：中心点的阈值小于某个阈值
    # center_change = np.linalg.norm(new_centers - centers)
    # if center_change < thresh:
    #     break
    centers = new_centers


  return labels, centers


# 生成一些随机数据作为示例输入
data = np.random.rand(100, 2)  # 100个样本，每个样本有两个特征


# 手动实现K均值算法
k = 3  # 聚类数为3
labels, centers = kmeans(data, k)


# 打印簇标签和聚类中心点
print("簇标签:", labels)
print("聚类中心点:", centers)

手撕 Layer Normalization 算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

import torch
from torch import nn
 
class LN(nn.Module):
    # 初始化
    def __init__(self, normalized_shape,  # 在哪个维度上做LN
                 eps:float = 1e-5, # 防止分母为0
                 elementwise_affine:bool = True):  # 是否使用可学习的缩放因子和偏移因子
        super(LN, self).__init__()
        # 需要对哪个维度的特征做LN, torch.size查看维度
        self.normalized_shape = normalized_shape  # [c,w*h]
        self.eps = eps
        self.elementwise_affine = elementwise_affine
        # 构造可训练的缩放因子和偏置
        if self.elementwise_affine:  
            self.gain = nn.Parameter(torch.ones(normalized_shape))  # [c,w*h]
            self.bias = nn.Parameter(torch.zeros(normalized_shape))  # [c,w*h]
 
    # 前向传播
    def forward(self, x: torch.Tensor): # [b,c,w*h]
        # 需要做LN的维度和输入特征图对应维度的shape相同
        assert self.normalized_shape == x.shape[-len(self.normalized_shape):]  # [-2:]
        # 需要做LN的维度索引
        dims = [-(i+1) for i in range(len(self.normalized_shape))]  # [b,c,w*h]维度上取[-1,-2]维度，即[c,w*h]
        # 计算特征图对应维度的均值和方差
        mean = x.mean(dim=dims, keepdims=True)  # [b,1,1]
        mean_x2 = (x**2).mean(dim=dims, keepdims=True)  # [b,1,1]
        var = mean_x2 - mean**2  # [b,c,1,1]
        x_norm = (x-mean) / torch.sqrt(var+self.eps)  # [b,c,w*h]
        # 线性变换
        if self.elementwise_affine:
            x_norm = self.gain * x_norm + self.bias  # [b,c,w*h]
        return x_norm
 
# ------------------------------- #
# 验证
# ------------------------------- #
 
if __name__ == '__main__':
 
    x = torch.linspace(0, 23, 24, dtype=torch.float32)  # 构造输入层
    x = x.reshape([2,3,2*2])  # [b,c,w*h]
    # 实例化
    ln = LN(x.shape[1:])
    # 前向传播
    x = ln(x)
    print(x.shape)

手撕 Batch Normalization 算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

class MyBN:
    def __init__(self, momentum=0.01, eps=1e-5, feat_dim=2):
        """
        初始化参数值
        :param momentum: 动量，用于计算每个batch均值和方差的滑动均值
        :param eps: 防止分母为0
        :param feat_dim: 特征维度
        """
        # 均值和方差的滑动均值
        self._running_mean = np.zeros(shape=(feat_dim, ))
        self._running_var = np.ones((shape=(feat_dim, ))
        # 更新self._running_xxx时的动量
        self._momentum = momentum
        # 防止分母计算为0
        self._eps = eps
        # 对应Batch Norm中需要更新的beta和gamma，采用pytorch文档中的初始化值
        self._beta = np.zeros(shape=(feat_dim, ))
        self._gamma = np.ones(shape=(feat_dim, ))


    def batch_norm(self, x):
        """
        BN向传播
        :param x: 数据
        :return: BN输出
        """
        if self.training:
            x_mean = x.mean(axis=0)
            x_var = x.var(axis=0)
            # 对应running_mean的更新公式
            self._running_mean = (1-self._momentum)*x_mean + self._momentum*self._running_mean
            self._running_var = (1-self._momentum)*x_var + self._momentum*self._running_var
            # 对应论文中计算BN的公式
            x_hat = (x-x_mean)/np.sqrt(x_var+self._eps)
        else:
            x_hat = (x-self._running_mean)/np.sqrt(self._running_var+self._eps)
        return self._gamma*x_hat + self._beta

解码算法篇

手撕 贪心搜索 （greedy search）

贪心搜索（greedy search）在每个时间步 t 都选取当前概率分布中概率最大的词，即

直到 yt 为或达到预设最大长度时停止生成。
贪心搜索本质上是局部最优策略，但并不能保证最终结果一定是全局最优的。由于贪心搜索在解码的任意时刻只保留一条候选序列，所以在搜索效率上，贪心搜索的复杂度显著低于穷举搜索。

1
2
3
4
5
6
7
8
9
10
11

def greedy_decoding(input_ids, max_tokens=300):
 with torch.inference_mode():
 for _ in range(max_tokens):
            outputs = model(input_ids)
            next_token_logits = outputs.logits[:, -1, :]
            next_token = torch.argmax(next_token_logits, dim=-1)
 if next_token == tokenizer.eos_token_id:
 break
            input_ids = torch.cat([input_ids, rearrange(next_token, 'c -> 1 c')], dim=-1)
        generated_text = tokenizer.decode(input_ids[0])
 return generated_text

手撕 Top-K Sampling算法

Top-K 采样（在每个时间步选择条件概率排名前 K 的词语，然后在这 K 个词语中进行随机采样。这种方法既能保持一定的生成质量，又能增加文本的多样性，并且可以通过限制候选词语的数量来控制生成文本的多样性。
这个过程使得生成的文本在保持一定的生成质量的同时，也具有一定的多样性，因为在候选词语中仍然存在一定的竞争性。

1
2
3
4
5
6
7
8
9
10
11
12

def top_k_sampling(input_ids, max_tokens=100, top_k=50, temperature=1.0):
 for _ in range(max_tokens):
 with torch.inference_mode():
            outputs = model(input_ids)
            next_token_logits = outputs.logits[:, -1, :]
            top_k_logits, top_k_indices = torch.topk(next_token_logits, top_k)
            top_k_probs = F.softmax(top_k_logits / temperature, dim=-1)
            next_token_index = torch.multinomial(top_k_probs, num_samples=1)
            next_token = top_k_indices.gather(-1, next_token_index)
            input_ids = torch.cat([input_ids, next_token], dim=-1)
    generated_text = tokenizer.decode(input_ids[0])
 return generated_text

神经网络篇

手撕 卷积神经网络(CNN)法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import torch
import torch.nn.functional as F #使用functional中的ReLu激活函数


#CNN模型
class CNNNet(torch.nn.Module):
    def __init__(self):
        super(CNNNet, self).__init__()
        #两个卷积层
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)  #1为in_channels 10为out_channels
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=5)
        #池化层
        self.pooling = torch.nn.MaxPool2d(2)  #2为分组大小2*2
        #全连接层 320 = 20 * 4 * 4
        self.fc = torch.nn.Linear(320, 10)


    def forward(self, x):
        #先从x数据维度中得到batch_size
        batch_size = x.size(0)
        #卷积层->池化层->激活函数
        x = F.relu(self.pooling(self.conv1(x)))
        x = F.relu(self.pooling(self.conv2(x)))
        x = x.view(batch_size, -1)  #将数据展开，为输入全连接层做准备
        x = self.fc(x)
        return x
model = CNNNet()

手撕 二维卷积 算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import numpy as np 
def conv2d(img, in_channels, out_channels ,kernels, bias, stride=1, padding=0):
    N, C, H, W = img.shape 
    kh, kw = kernels.shape
    p = padding
    assert C == in_channels, "kernels' input channels do not match with img"


    if p:
        img = np.pad(img, ((0,0),(0,0),(p,p),(p,p)), 'constant') # padding along with all axis


    out_h = (H + 2*padding - kh) // stride + 1
    out_w = (W + 2*padding - kw) // stride + 1


    outputs = np.zeros([N, out_channels, out_h, out_w])
    # print(img)
    for n in range(N):
        for out in range(out_channels):
            for i in range(in_channels):
                for h in range(out_h):
                    for w in range(out_w):
                        for x in range(kh):
                            for y in range(kw):
                                outputs[n][out][h][w] += img[n][i][h * stride + x][w * stride + y] * kernels[x][y]
                if i == in_channels - 1:
                    outputs[n][out][:][:] += bias[n][out]
    return outputs

位置编码篇

手撕 绝对位置编码 算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class SinPositionEncoding(nn.Module):
    def __init__(self, max_sequence_length, d_model, base=10000):
        super().__init__()
        self.max_sequence_length = max_sequence_length
        self.d_model = d_model
        self.base = base


    def forward(self):
        pe = torch.zeros(self.max_sequence_length, self.d_model, dtype=torch.float)  # size(max_sequence_length, d_model)
        exp_1 = torch.arange(self.d_model // 2, dtype=torch.float)  # 初始化一半维度，sin位置编码的维度被分为了两部分
        exp_value = exp_1 / (self.d_model / 2)


        alpha = 1 / (self.base ** exp_value)  # size(dmodel/2)
        out = torch.arange(self.max_sequence_length, dtype=torch.float)[:, None] @ alpha[None, :]  # size(max_sequence_length, d_model/2)
        embedding_sin = torch.sin(out)
        embedding_cos = torch.cos(out)


        pe[:, 0::2] = embedding_sin  # 奇数位置设置为sin
        pe[:, 1::2] = embedding_cos  # 偶数位置设置为cos
        return pe


SinPositionEncoding(d_model=4, max_sequence_length=10, base=10000).forward()

手撕 可学习位置编码 算法

1
2
3
4
5
6
7
8
9
10
11

class TrainablePositionEncoding(nn.Module):
    def __init__(self, max_sequence_length, d_model):
        super().__init__()
        self.max_sequence_length = max_sequence_length
        self.d_model = d_model


    def forward(self):
        pe = nn.Embedding(self.max_sequence_length, self.d_model)
        nn.init.constant(pe.weight, 0.)
        return pe

手撕 相对位置编码 算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

class RelativePosition(nn.Module):
    def __init__(self, num_units, max_relative_position):
        super().__init__()
        self.num_units = num_units
        self.max_relative_position = max_relative_position
        self.embeddings_table = nn.Parameter(torch.Tensor(max_relative_position * 2 + 1, num_units))
        nn.init.xavier_uniform_(self.embeddings_table)


    def forward(self, length_q, length_k):
        range_vec_q = torch.arange(length_q)
        range_vec_k = torch.arange(length_k)
        distance_mat = range_vec_k[None, :] - range_vec_q[:, None]
        distance_mat_clipped = torch.clamp(distance_mat, -self.max_relative_position, self.max_relative_position)
        final_mat = distance_mat_clipped + self.max_relative_position
        final_mat = torch.LongTensor(final_mat).cuda()
        embeddings = self.embeddings_table[final_mat].cuda()


        return embeddings


class RelativeMultiHeadAttention(nn.Module):
    def __init__(self, d_model, n_heads, dropout=0.1, batch_size=6):
        "Take in model size and number of heads."
        super(RelativeMultiHeadAttention, self).__init__()
        self.d_model = d_model
        self.n_heads = n_heads
        self.batch_size = batch_size


        assert d_model % n_heads == 0
        self.head_dim = d_model // n_heads


        self.linears = _get_clones(nn.Linear(d_model, d_model), 4)
        self.dropout = nn.Dropout(p=dropout)
        self.relative_position_k = RelativePosition(self.head_dim, max_relative_position=16)
        self.relative_position_v = RelativePosition(self.head_dim, max_relative_position=16)


        self.scale = torch.sqrt(torch.FloatTensor([self.head_dim])).cuda()


    def forward(self, query, key, value):
        # embedding
        # query, key, value = [batch_size, len, hid_dim]
        query, key, value = [l(x).view(self.batch_size, -1, self.d_model) for l, x in
                             zip(self.linears, (query, key, value))]


        len_k = query.shape[1]
        len_q = query.shape[1]
        len_v = value.shape[1]


        # Self-Attention
        # r_q1, r_k1 = [batch_size, len, n_heads, head_dim]
        r_q1 = query.view(self.batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
        r_k1 = key.view(self.batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
        attn1 = torch.matmul(r_q1, r_k1.permute(0, 1, 3, 2))


        r_q2 = query.permute(1, 0, 2).contiguous().view(len_q, self.batch_size * self.n_heads, self.head_dim)
        r_k2 = self.relative_position_k(len_q, len_k)
        attn2 = torch.matmul(r_q2, r_k2.transpose(1, 2)).transpose(0, 1)
        attn2 = attn2.contiguous().view(self.batch_size, self.n_heads, len_q, len_k)
        attn = (attn1 + attn2) / self.scale


        attn = self.dropout(torch.softmax(attn, dim=-1))
        # attn = [batch_size, n_heads, len, len]
        r_v1 = value.view(self.batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
        weight1 = torch.matmul(attn, r_v1)
        r_v2 = self.relative_position_v(len_q, len_v)
        weight2 = attn.permute(2, 0, 1, 3).contiguous().view(len_q, self.batch_size * self.n_heads, len_k)
        weight2 = torch.matmul(weight2, r_v2)
        weight2 = weight2.transpose(0, 1).contiguous().view(self.batch_size, self.n_heads, len_q, self.head_dim)


        x = weight1 + weight2
        # x = [batch size, n heads, query len, head dim]


        x = x.permute(0, 2, 1, 3).contiguous()
        # x = [batch size, query len, n heads, head dim]


        x = x.view(self.batch_size * len_q, self.d_model)
        # x = [batch size * query len, hid dim]


        return self.linears[-1](x)

手撕 rope 算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

import torch
import torch.nn as nn
import torch.nn.functional as F
import math


# %%


def sinusoidal_position_embedding(batch_size, nums_head, max_len, output_dim, device):
    # (max_len, 1)
    position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(-1)
    # (output_dim//2)
    ids = torch.arange(0, output_dim // 2, dtype=torch.float)  # 即公式里的i, i的范围是 [0,d/2]
    theta = torch.pow(10000, -2 * ids / output_dim)


    # (max_len, output_dim//2)
    embeddings = position * theta  # 即公式里的：pos / (10000^(2i/d))


    # (max_len, output_dim//2, 2)
    embeddings = torch.stack([torch.sin(embeddings), torch.cos(embeddings)], dim=-1)


    # (bs, head, max_len, output_dim//2, 2)
    embeddings = embeddings.repeat((batch_size, nums_head, *([1] * len(embeddings.shape))))  # 在bs维度重复，其他维度都是1不重复


    # (bs, head, max_len, output_dim)
    # reshape后就是：偶数sin, 奇数cos了
    embeddings = torch.reshape(embeddings, (batch_size, nums_head, max_len, output_dim))
    embeddings = embeddings.to(device)
    return embeddings


# %%
def RoPE(q, k):
    # q,k: (bs, head, max_len, output_dim)
    batch_size = q.shape[0]
    nums_head = q.shape[1]
    max_len = q.shape[2]
    output_dim = q.shape[-1]


    # (bs, head, max_len, output_dim)
    pos_emb = sinusoidal_position_embedding(batch_size, nums_head, max_len, output_dim, q.device)


    # cos_pos,sin_pos: (bs, head, max_len, output_dim)
    # 看rope公式可知，相邻cos，sin之间是相同的，所以复制一遍。如(1,2,3)变成(1,1,2,2,3,3)
    cos_pos = pos_emb[...,  1::2].repeat_interleave(2, dim=-1)  # 将奇数列信息抽取出来也就是cos 拿出来并复制
    sin_pos = pos_emb[..., ::2].repeat_interleave(2, dim=-1)  # 将偶数列信息抽取出来也就是sin 拿出来并复制


    # q,k: (bs, head, max_len, output_dim)
    q2 = torch.stack([-q[..., 1::2], q[..., ::2]], dim=-1)
    q2 = q2.reshape(q.shape)  # reshape后就是正负交替了


    # 更新qw, *对应位置相乘
    q = q * cos_pos + q2 * sin_pos


    k2 = torch.stack([-k[..., 1::2], k[..., ::2]], dim=-1)
    k2 = k2.reshape(k.shape)
    # 更新kw, *对应位置相乘
    k = k * cos_pos + k2 * sin_pos


    return q, k


# %%
def attention(q, k, v, mask=None, dropout=None, use_RoPE=True):
    # q.shape: (bs, head, seq_len, dk)
    # k.shape: (bs, head, seq_len, dk)
    # v.shape: (bs, head, seq_len, dk)


    if use_RoPE:
        q, k = RoPE(q, k)


    d_k = k.size()[-1]


    att_logits = torch.matmul(q, k.transpose(-2, -1))  # (bs, head, seq_len, seq_len)
    att_logits /= math.sqrt(d_k)


    if mask is not None:
        att_logits = att_logits.masked_fill(mask == 0, -1e9)  # mask掉为0的部分，设为无穷大


    att_scores = F.softmax(att_logits, dim=-1)  # (bs, head, seq_len, seq_len)


    if dropout is not None:
        att_scores = dropout(att_scores)


    # (bs, head, seq_len, seq_len) * (bs, head, seq_len, dk) = (bs, head, seq_len, dk)
    return torch.matmul(att_scores, v), att_scores


if __name__ == '__main__':
    # (bs, head, seq_len, dk)
    q = torch.randn((8, 12, 10, 32))
    k = torch.randn((8, 12, 10, 32))
    v = torch.randn((8, 12, 10, 32))


    res, att_scores = attention(q, k, v, mask=None, dropout=None, use_RoPE=True)


    # (bs, head, seq_len, dk),  (bs, head, seq_len, seq_len)

print(res.shape, att_scores.shape)

面试题汇总

• 大模型微调的经验与感想分享
• 百度-NLP算法工程师面经
• 美团-大模型算法工程师面经
• 小米-NLP算法工程师面试题
• 好未来-NLP算法工程师面经
• 百度大模型算法工程师面经
• 昆仑天工大模型算法工程师
• 阿里大模型算法工程师一面
• 算法工程师面试常考手撕题
• 搜狐大模型算法工程师
• 字节大模型算法实习生
• 理想汽车大模型算法实习生
• 百度大模型算法实习生面试题
• 腾讯大模型算法实习生面试题
• 阿里大模型算法工程师一面
• 某大厂大模型算法工程师面试题
• 说说百度大模型算法工程师二面经历
• 阿里大模型算法工程师面试小结

致谢

• LLMs 千面郎君 更新版 https://mp.weixin.qq.com/s/C6NdO_Ebj3DQx2AVAAgQRQ
• LLMs九层妖塔 https://mp.weixin.qq.com/s/Eh0tY1zx2FqXQqIGa2dIBA
• NLP 面无不过 https://github.com/km1994/NLP-Interview-Notes

来自: 算法工程师面试常考手撕题（更新）

今天9.30面的金山，金山这个面试基本是我面试过程最难的几个了，本来面试计划时间半小时，结果面了一个小时，面试官非常深挖项目，问的非常细，而且非常的耐心，里面就问了两个八股，看来要准备的还真的需要很多。

首先是自我介绍，然后问了下我的实习，第一部分主要是针对实习的具体内容展开，我先讲完做了啥，

用了什么模型，参数是多少，量级是多少，为什么用千问，盘古智子，千问大模型版本，结构，最大上下文长度是多少，怎么评测，选取哪个大模型。大模型训练出来的结果如何评价，用的什么指标。

LoRA微调原理，训练哪些层，都哪些超参数，超参数怎么设置的。

前面这块我了解的不是特别深入，然后就开始讲Prompt这块关于具体任务的内容，数据集怎么构造的，为什么这么构建，标注数据有什么问题，数据量多少，这个项目最终的好坏如何评价。

后面上线需要解决什么问题，是效果达不到，还是速度达不到，还是其他问题，千问的模型是否可以上线，解决方案是什么，后续怎么做。

还问了大模型的分布式这块了解不，我问是不是deepspeed这种，是，这块说了两句，不是特别懂。

然后问我后面哪个项目感觉做的比较深入，然后我说了第一个项目做的深入而且有论文，然后他就开始问了我最后一个项目，这个项目做的比较浅。问到这个项目，量化和剪枝如何做的，参数量是多少，剪枝之后是多少，速度提升多少。量化如何做的，量化之后的参数量是多少，速度提升多少。其中的CPP需要写哪些部分。

最后是八股，问了下现在各个大模型的架构是啥，主流都是哪些模型，都是啥样的。除了Transformer之外还了解mamba和kan不。

反问问了他们主要是大模型还是传统，说都有。

被拷打的很惨，感觉这次面试是最难的，感觉肯定G了。

结果没想到，过了，这次面试真的是很难，感觉自己很多地方都答的不好，但是还是过了，感觉有点意外。

二面

10.15今天金山二面，面了一个小时，过去自我介绍，然后面试官说让找一个印象最深的项目深入的讲。

然后我就讲了我做的第一个项目，也有论文，就屏幕共享讲论文，这次讲比第一次讲论文好多了，大致是讲清楚了，虽然后面面试官说可延展性不太行，不过确实，一个横向项目论文，确实挺水的，但也没办法。

然后是手撕，还是屏幕共享，让打开IDE，然后我Pycharm手撕一道题，这次问的是数组中找两个数之和，使其和target之差最小，然后用的双指针，说了下思路，然后写了出来，然后问算法复杂度，是O(nlogn)，然后是延伸，是否能用二分查找法做，如果这样做如何来设计，然后我说了下，应该说的没问题，这块也追问了好几个，比如两个数的时候有没有啥问题，边界条件是不是对，差不多都答上来了。

然后是一个八股，问大模型和小模型的区别，这块见得多了，从实用角度，可解释性，成本，大模型幻觉啥的展开讲，基本没啥问题，面试官差不多还夸了下。

然后是反问环节，问部门做啥，大模型还是小模型，都有，然后是base，问我报的哪里，他们这边有珠海、武汉、北京，后面会培训然后协商部门和base地。

然后是问我有没有其他offer，我说有几个在排序中，还在看。

总体来说感觉也还行，应该是过了吧。

三面HR面

11.5HR打电话，问我有没有时间，我说有，然后就直接电话面了。

首先问了下我实习7~9月华子实习，问结束了没，是结束了。然后问为什么没有华子内部转正，我说华子的不能转正，而且只有特别的可以评A直通三面，但是我一起的都是C9的，然后问那个部门招多少人，这个我不清楚。然后问华子比例多少，我说那个比例不超过20%。然后问实习为什么时间短，没想着转正或者没有机会吗，还是不喜欢工作内容。我说一方面前面在学校老师安排的活和毕设中期，就拖到了7.3；另一方面九月份就要秋招了，后面就没时间了，而且华子本身也不能转正。

然后问都拿到了哪些公司的offer或者哪家公司已经走到了后面的流程了，我说现在有几家已经到二面三面了，但是地方还没看好，更想去粤港澳地方。然后问头的是珠海，是什么原因呢有家里家人朋友在这边吗？我说不是，因为更看好这边的发展，我家里是河南，但是不是很想回去，粤港澳这边中国发展比较好，从未来考虑。然后问哪些公司比较后面了，我说讯飞理想都在后面了，但是还没有发offer，然后问他们的地点是哪里，我说还没仔细看。

然后问对未来工作的规划，你应聘的是算法，我说一直在做AI相关的，这块也比较了解。一方面从发展维度来说，进去前两年做技术，后面再考虑带团队，从学校和公司的差异。另一方面从就业的具体内容来说也希望更好的用到前面学的人工智能方面的知识，其他的也是可以快速学习的。然后我问这边工作是偏研发还是工程，他们说偏向工程产品落地。

然后问前面面试的过程中觉得他们关注的一些方向以及他们去问的一些问题跟您未来的那个发展的规划相符吗。我说基本还是可以。对于他们关注等一些内容有哪些方面女士没有涉及到或者是没有了解和学习接触过的吗？我说主要是从学校和公司的差异，对于性能效率方面的一些差异吧，这个我举了个例子来说的。

然后问：目前在学校期间的话是在做毕业论文还是做一些什么样的方向的一些学习吗？目前主要是秋招，后面做毕设，也是AI方面的。最近的话最近肯定是还是以秋为主，就是现在还没有就是还没有拿到不错的offer，暂时还没有走到那个offer这一步。

然后问薪酬的预期，我说我也不知道下面咱们这个行情到底应该是个什么情况。那你身边的同学有啊拿到什么样的一些offer你有了解到吗？我大致说了下，很多在等华为。然后问我为什么不是很想去华子，我说华子应该不算互联网。然后问我身边小米美团他们的薪酬大致多少，我说年三十多到四十多，具体也要看地方。然后问我珠海如何，我说年薪也要30多以上吧，也不知道行情如何。然后问珠海的薪资和深圳的薪资比较比较下来的话会有什么样的差异吗？我说肯定比深圳低。

然后HR说这边暂时没有其他问题了，晚一点确定录取和信息待遇什么的回尽快打电话，然后反问环节，我就问了下地方，武汉珠海是一样的，可以后面转，然后就结束了。

oc

11.6早晨HR打电话，谈了下薪酬福利，工作时间，这种类似的。

11.1下午这次面的是中金所的子公司，总共就面了15分钟，几乎没问技术。

过去首先自我介绍，然后问了下华为实习是不是能转正，我说不能，然后说现在华子秋招还没开。

然后问我是否了解这个公司，我说是金融方面的，具体还不是很了解。

问我最近在看什么书，我说最近秋招，所以在看人工智能方面的书，根据不不同的阶段和任务看书。

然后问我找工作有多个offer的时候看重什么，我说第一看公司的发展，第二个人能力的培养，第三个是薪资福利。

然后让我找一个印象深刻的经历，展开讲讲，我就讲了下实习的内容，讲完他都没问问题，直接就到了反问环节。

我就反问部门具体是什么业务，哪方面的，他说前沿技术岗，一个是跟踪行业发展，探索落地，各种大模型区块链都有涉及，这个部门是运维的，就是前沿技术在这块的应用。

然后我问了下后面还有几面，他说如果一面过了的话二面是具体岗位相关的技术，三面是HR面。

总体来说还是太简短了，相比上午面一个小时还是差很多。

这次面的是蔚来，开始面试官很热情，上来介绍他们部门是自动驾驶的芯片的，然后我自我介绍，然后就开始问问题了。这次面了一个小时，可以说底裤都被扒的干干净净，好多问题都没回答上来，感觉是要G了。

这次没问实习，毕竟实习是做大模型的，这边完全不做大模型了，纯视觉，所以问的我的项目。

首先第一个项目，这个是我研究生做的第一个项目，讲完问了效果误差如何，是否满足需要，我说误差1%差不多是可以用了，而且成本低，这块简单问了下，还问了整个过程都用了哪些模型。又问了我用的MMPose框架内部是怎么实现的，这个框架我还真不是特别了解，只是用过，所以回答的不是很好。然后问我这块目标检测用的模型，这块是项目中很小的一个点，我都没准备，结果问到了，我就回答不好了。

然后第二个项目，这个讲完主体后，让我讲下这个过程用了什么模型，我讲了下还有效果。然后问实时性什么的是否满足需要，我就讲了下整体的流程架构。然后问这个项目的难点是什么，我说主要应该是解决具体的问题。然后问我有没有做边缘部署，我说这个本来有这个需求，但是后面没谈好，就没做了。还问了项目指标到多少，评价指标如何设计的，这块也是回答了个大概。

然后问第三个项目，这个项目做的浅，问了前面部分用的什么做的，这块用的接口做的，只做了后面的不难的部分，大致说了下，也是说的很水。

然后问第四个项目，我把整个流程说了下，然后说了下主要的难点和处理方法，也是大致说了下就完了。

然后开始问卷积内部实现和计算，这块我大致说了，然后又问了参数量规模，大致说了下，回答的一般。然后问我NMS怎么算的，我大致把理论说了下，然后问IOU怎么算的，这个比较容易，我还会手写。

然后问Python相关的，问了下*args和**kargs什么区别，这块大致说出来了。

然后问浅拷贝和深拷贝有什么区别，python中有哪些数据类型是浅拷贝，哪些是深拷贝。第一个浅拷贝和深拷贝大致说了下，第二个还真不知道。

然后问CPP相关的，问虚函数和纯虚函数什么区别，泛型编程是什么，模板是什么。这些就真不会了。

然后反问，我就问了下部门业务，然后他问我愿不愿意做这种比较底层的，我说还是很有兴趣的，然后就结束了。

感觉这次面试官开始还是很热情的，但是我回答的不太行，感觉是要G了，这些问题都太底层了，还有很多八股，我都没准备，感觉是要准备下这些问题了。

30下午面试的广联达，这是个做建筑设计的公司，过去自我介绍完，他们好像主要是偏视觉一些，所以先问了我第一个项目，讲完之后追问了一些细节，包括问用的什么模型，模型的结构是什么。然后其他的问了下实习的内容，我就把实习的内容讲了一遍，他就问了下相比之前的效果如何，我说主要是业务流程上的改进，用大模型来完成这些事情。

之后他想问八股，我说计组计网操作系统编译原理都没学过，他就问了下如何处理类别不均的问题，这个我举了我实习时候的例子，再结合了之前做一般小模型时候的一些处理方法，给出了一些回答。

然后是问他们部门，他介绍了下他们公司主要偏视觉一些，是建筑信息化方面的公司，涉及图文生成和3DGS之类的，我也聊了下先关的内容。

虽然是AI面试，但是还是记录一下，面试的内容，这个相当于是综合面试的题提前到了技术面之前了。这些内容还是需要总结一下，也是后面面试可能会问的问题。

具体有7个题分别需要录制两分钟的视频，第一个是自我介绍，包含学校、实习、项目、技能、兴趣爱好这些部分。

后面有印象最深的项目是什么，具体哪个？

第五个题目是如何促成他人意见和自己达成一致，会因此感到压力吗？

第六个题目是你制定过最成功的计划是什么？

最后一个题目是简述自己的优势和劣势和未来的职业规划？

这些题目有30秒的思考时间，难度有一些的，还是要提前准备一下的。

二面人工面

这次面试大概35分钟，基本问的也算全，不过后面的都没问。线上腾讯会议面试，有两个面试官，第一个面的时候第二个听。

第一个面试官，过去先自我介绍，然后讲实习做的啥，先讲了背景，然后按照要求说了输入输出和目的，只讲了一个点，中间问了很多细节，数据多少条，正负样本配比是否合适。用的啥模型训练的，现在主流的大模型结构是什么样的，这个我都没回答完，就打断了。然后问我大模型在银行场景中如何应用，我就说了下目前主要在知识库和智能客服结合RAG和Agent这块做的，其他倒是不太多。然后问了我是否会开发，问技术栈，我说主要会Python和Pytorch，C++只会一点，还有就是机器学习和深度学习算法，比如Kmeans啥的。Java不太会，不过学起来应该也问题不大。然后问我是否了解SQL，我说本科用过，速成了一下增删查改，后面没有用过就不太懂了，不过要学应该挺快的。

然后让第二个面试官问，面试官首先说你既然比较了解Pytorch，那Pytorch中的基本数据结构是什么，我说了下Tensor，他问和numpy中的有什么区别，我说主要是需要计算梯度和更新参数，所以主要是梯度累计记录这块的区别。然后问我前向传播和反向传播有什么区别，简单说了下更新参数和梯度这块的内容。然后说你刚才说Kmeans，那你说一下这个算法，我就介绍了下原理，然后问我距离计算有哪些类型，我就说了下L1和L2欧式距离，还有0范数和无穷范数啥的。然后他问我如何确定聚类数目，我说这是个超参数，不过其他聚类如DBSCAN不需要指定聚类个数，如果Kmeans需要预估的话，需要进行数据分析一下，大致预估。然后是问我大模型在银行中如何应用落地，这块我也是只能从知识库智能客服这块说了下，然后就是结合华为实习的风控场景类似银行场景中也可以进行应用。这个开放性问题其实我回答的不算出彩，感觉这个问题很多领导还是很看重的，还是需要重点准备一下。

然后是反问，我就说了下我技术栈过去是否适配适应，面试官说这个数据岗主要细分数据分析和人工智能大模型算法应用，然后就结束了。

这次面试是电话面试，大概40分钟。

首先自我介绍，然后问实习，讲完问的问题有，大模型相比传统业务的优势， 样本的评测标准是否和之前的一样，这个项目后面是否可以做成纯大模型提取学习，等等之类的。问了这些就是八股了，现在主流都有哪些大模型，他们的结构是啥样的，我介绍完问ChatGLM为什么不是纯Decoder的，具体是采用了什么结构，这块我就答不上来了。

然后是问后面的第一个项目，有论文这个，把大致的内容讲了下，这块没怎么问。

然后就问到最后一个项目，说其中的量化剪枝这块怎么做的，这块我讲的不太清楚，涉及CPP的这块讲了下，还有部署和服务这块怎么做的大致讲了下。

然后反问，问具体部门做啥，具体是大模型的工程应用团队，然后就结束了。

这次面了33分钟，过去他先简单介绍他们情况，搜广推部门啥的，自我介绍完，先问了实习做的啥，然后我讲完了点，然后面试官说后面不用讲了，然后开始问，相对之前相比的优点，也问了一些里面的细节，主要还是业务流程方面的，没有仔细问模型本身相关的东西。然后是关于后面是否能上线，有啥问题。还问了大模型实际提高速度如何做，我说选用性能足够的小模型，量化剪枝蒸馏。

后面的项目好像没问，毕竟确实也不怎么相关。

然后说既然是搜广推，出个算法题，模型预测的一个排序和实际的排序，如[1,3,2,5,4]和实际的顺序[1,2,3,4,5]，设计一个函数给模型的输出打分，这块我大致思考了下，说了个思路，然后让实现，我就开始写

1
2
3
4
5
6
7
8
9
10
11
12
13

def main():
    n = len(rank1)


    rank1_dict = {value: idx for idx, value in enumerate(rank1)}
    rank2_dict = {value: idx for idx, value in enumerate(rank2)}


    loss_sum = 0
    for value in rank1:
        loss = rank1_dict[value] - rank2_dict[value]  # 计算排名差
        loss_sum += loss ** 2  # 差值平方累计

写了这些，然后分数差不多就是损失归一化然后反过来，然后就差不多了。

然后反问环节，我就问了下我技术栈过去转换是否大，面试官说他们也有大模型岗位，我说大模型不一定能火多少年，不过搜广推是互联网的基础，更看好一些，面试官让回去了解一下搜广推，上手做下项目啥的，毕竟是不能只靠兴趣，我说回去看看。

总体来看，这是第一个投搜广推给面的，虽然我也基本没怎么投搜广推，感觉面的也凑合，不过匹配程度确实是个问题。

这次面试的时间还挺短的，应该是22分钟，过去自我介绍完，先问了实习做的啥，然后大致讲了讲，然后问效果和之前的比如何，然后问了一些细节，是否上线。

然后问哪个项目做的深，第一个项目讲了讲，讲了大致背景和做法，都没有讲具体的结构流程，问了几个问题，包括数据、标注，和之前的比做的意义，做出的效果啥的，还有这个项目是不是自己做的，在其中什么角色。

然后问我如何职业规划和方向，想做啥，我说这些都比较通，都可以做。然后是城市的问题，这些城市我都差不多可以接受。

然后问我了不了解他们公司，这块我还真不怎么了解。然后问我有没有其他的offer，我说有几个在流程中。

最后反问，问了公司具体的业务，他们这个包括的比较多，CV、NLP大模型、语音这些都做。

15号的比较早，9：30左右，等了一会，叫号，过去面试，自我介绍完，先拿出来了笔试时候的题目让复盘一下，我用的还是投实习时候过的，正式批就没有笔试，简单看下，大致说出了思路。

然后说重点讲三个项目，我就讲一个实习+两个项目了。

开始问实习，也是介绍完之后问细节，具体也问了不少，然后讲第一个和第二个项目，讲完让手撕个题目，题目是一段01的比特流字符串，给一个target是0或者1，然后比特流只能变一位，求最多多少个连续的target，想了几分钟双指针写了出来。总体来说，一面还是比较友好的。

二面

等了一会就二面了，二面过去自我介绍完，我讲完实习，就问了几个套路性的常用问题，大概不到十分钟，然后就给一个手撕题目，场景题，用卷积算二阶导，对图像做边缘检测。这个没怎么见过，没想出来，要用题目给定的方法做，大致写了下，然后就结束了，写的应该不太对。面试官直接说今天面试结束了可以回去了，然后就短信通知今天的结束了，进入系统一看，果然挂了。

这种手撕场景题不太好准备，没得办法，二面都没怎么问，手撕g就g了，这题真没见过，太难了，全程都没问八股，二面一堆项目都没问，实习问的比一面还浅，没办法。

我回头问了我我同学们，还没有见过有二面挂的，他们题目都可以三选一，而且基本都是力扣，还都不是很难的那种，出这个题他们也都不会，让面试官给提示也不给，只报还剩下多少时间。毕竟连项目和八股都不问的面试我还是第一次见，一面的面试官就好的多。

我回去复盘了一下，这个题大致应该是这样的，总体来说也不能算完全的hard，但是难就难在开始这部分，如何用[1,-1]和$[1,-1]^T$计算拉普拉斯算子，后面的就很容易了。

ChatGPT给的答案是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

def edge_detection_laplacian(image):
    # 获取图像尺寸
    rows, cols = len(image), len(image[0])
    
    # 定义Laplacian卷积核g
    g = [[0, -1, 0],
         [-1, 4, -1],
         [0, -1, 0]]
    
    # 添加padding, 初始化f为图像+2边框的0矩阵
    f = [[0 for _ in range(cols + 2)] for _ in range(rows + 2)]
    
    # 将原始图像数据填充到f的中心部分
    for i in range(rows):
        for j in range(cols):
            f[i + 1][j + 1] = image[i][j]
    
    # 创建结果矩阵，用于存储边缘检测的结果
    result = [[0 for _ in range(cols)] for _ in range(rows)]
    
    # 主卷积循环，遍历图像中的每一个像素
    for i in range(1, rows + 1):
        for j in range(1, cols + 1):
            # 进行卷积操作
            conv_sum = 0
            for m in range(3):
                for n in range(3):
                    conv_sum += f[i + m - 1][j + n - 1] * g[m][n]
            
            # 将卷积结果存入结果矩阵
            result[i - 1][j - 1] = conv_sum
    
    return result

# 示例输入
image = [
    [1, 2, 1, 0],
    [4, 5, 6, 1],
    [7, 8, 9, 2],
    [3, 4, 5, 6]
]

# 调用Laplacian边缘检测函数
edge_result = edge_detection_laplacian(image)

# 输出结果
for row in edge_result:
    print(row)

但是他这个回答没有给出拉普拉斯算子怎么算的，其实这个算子我也是知道，也会用，其实早在投实习的时候一面就问了这个算子，我直接手写了出来，但是如果不给算子，而是用[1,-1]和$[1,-1]^T$计算拉普拉斯算子，再算的话，就不太容易了。我当时只算了水平的，没有算垂直的，水平垂直的叠加其实就可以了，有算子之后后面就容易了。

chatgpt给出了推导过程：

1. 一阶导数的离散化

在连续情况下，函数 f(x) 的一阶导数是：

$$
f’(x) = \frac{d}{dx}f(x)
$$

在离散情况下，我们用差分来近似一阶导数。在离散网格上，假设 f(x) 是一组离散的数值表示（如图像中的像素值），我们可以用向前差分或向后差分来近似一阶导数。

向前差分表示为：

$$
f’(x) \approx f(x+1) - f(x)
$$

这相当于卷积核 [1, -1]，它计算当前点与下一个点的差值。

向后差分表示为：

$$
f’(x) \approx f(x) - f(x-1)
$$

这相当于卷积核 [-1, 1]。

如果我们想取中间值（中心差分），可以将这两个差分的平均值作为一阶导数的离散近似：

$$
f’(x) \approx \frac{f(x+1) - f(x-1)}{2}
$$

这一中心差分可以表示为卷积核 [1, 0, -1]，它计算左右相邻点的差异。

2. 二阶导数的离散化

二阶导数表示的是函数变化的变化率。二阶导数是通过对一阶导数再次求导数得到的。在连续情况下，二阶导数是：

$$
f’’(x) = \frac{d^2}{dx^2}f(x)
$$

对于离散网格，我们可以用差分的形式来近似二阶导数。

3. 从一阶导数推导二阶导数

假设我们已经知道一阶导数的离散近似表示为 f'(x) = f(x+1) - f(x)，那么二阶导数可以通过对一阶导数再次取差分来计算：

$$
f’’(x) \approx f’(x+1) - f’(x)
$$

将一阶导数的表达式代入：

$$
f’’(x) \approx (f(x+2) - f(x+1)) - (f(x+1) - f(x))
$$

展开后得到：

$$
f’’(x) \approx f(x+2) - 2f(x+1) + f(x)
$$

这就是二阶导数的离散近似形式。其卷积核为 [1, -2, 1]，它计算当前像素值及其左右两个像素值的加权和，能够检测到亮度变化的速率，也就是图像中的曲率。

4. 解读 [1, -2, 1]

• 1：代表距离当前像素一个单位距离的前后像素值的贡献。
• -2：代表当前像素的值，权重大，表示它与左右两个像素的关系。
• 1：再次代表左右相邻像素的贡献。

这个差分算子 [1, -2, 1] 通过结合当前像素与其左右像素的值，近似计算二阶导数，检测出图像中变化最剧烈的部分（例如边缘或轮廓）。

5. 二维情况：Laplacian 算子

在二维图像处理的场景下，类似的二阶导数可以推广到多个方向。我们可以分别对 x 方向和 y 方向应用上述 [1, -2, 1] 的差分算子，得到图像在这两个方向的二阶导数。然后通过将两个方向的二阶导数合并，我们得到 Laplacian 算子，其标准形式是：

$$
g = \begin{bmatrix} 0 & -1 & 0 \ -1 & 4 & -1 \ 0 & -1 & 0 \end{bmatrix}
$$

其中：

• 中心位置的 4 对应着当前像素值的权重。
• -1 表示与上下左右像素的二阶差分贡献。

这一卷积核检测的是像素与其邻域的二阶亮度变化，从而可以用于边缘检测。

总结

总之，这个题不算拉普拉斯的推导就是easy，但是算上的话，就不太容易，我当时算出来了水平的梯度了$[-1,2,-1]$，垂直的应该也是一样的，但是把垂直的和水平的合并就不会了，合并了就是拉普拉斯算子了，后面就没啥了。

血亏

10.16下午一面，这次面试体验很差，面试官过去之后不开摄像头，然后先自我介绍。

然后面试官让讲实习，就讲了下，后面问了几个问题，主要是指标相比之前的业务是否有提升，还有如何判断效果如何，和之前的比较有啥区别，这块也问了几个问题。

然后是讲第一个项目，到这面试官就已经开始不耐烦了，讲完就没问问题，然后开始八股，先问了池化层是什么作用，简单回答了下，然后问平均池化和最大池化的区别，回答完问了解SQL不，我说曾经做过一点，但不是太会，然后给了个SQL题目，我确实不太会，就让改成算法题，然后简单写了下，写完喊面试官几次都不应答，后面基本也都是嗯一下答复。

然后反问了下部门，面试官说了下，然后就结束了，感觉这次面试官不太耐烦，可能是我回答的不太好，希望能过吧。

这次是预定半小时的线上面试，最后面了35分钟，总体还行，首先过去在等候线上会议室签到，签到之后等下进去特定的会议，然后查验学生证和身份证。

自我介绍，然后面试官说时间紧咱们挑三个项目讲，就挑了实习+两个横向的项目。

首先问实习，也是先介绍背景和做了啥，然后是问细节，badcase怎么处理的，用大模型做这个流程相比之前的意义和优势，然后问我是否了解多头LoRA，我说不知道。

然后问了发了论文的项目，讲完主要内容，然后细节，各个模块是如何做的，都用了什么模型，是否进行了创新，然后问是否可以优化更改，我说可以，不过成本会更高，然后面试官问是否可以那样说更好，我说可以。最后问发的论文是不是人工智能领域的，我说是的。

然后是第二个横向的项目，这个时候时间不多了，让快点讲，我就快速讲完背景和主要方法和思路，问用了什么做的，我说分割，然后问具体用了什么模型，是否自己训练了，我说用的框架啥的，进行了训练，再问了一点细节。

最后又问了我是不是会CPP，我说会一点，但不多，涉及部署的用到一点会一些。

没有手撕环节。

然后反问是问了他们部分是做啥的，都有哪些业务，后面会不会进行部门匹配，就讲了他部门，然后说后续应该还是会进行业务匹配的。

二面

二面就是主管面了，就完全不问技术了，时间也不是很长，大概也就半小时。

自我介绍完，问我将来进去想做AI哪方面的，我说之前视觉、大模型、NLP都做过，一方面看个人能力，还看行业发展趋势和需要。

问研究生期间遇到了什么困难，如何解决的。

问研究生期间什么时候压力最大，怎么解决的。

问自己的优点和缺点是什么。

然后说我填报的是上海，我说一线城市也都是可以的，年轻要多努力打拼。

然后问我期望薪酬是多少，我说上海的话要年40以上吧，毕竟是算法类，感觉是不是要的有点高了，应该说可以商量的。

最后问分配部门的情况和进去做什么的内容，说还要后续匹配。

中间还有其他问题，但是我没有什么印象特别深的，没有特别难的问题，都是之前被问到过的，回答起来也比较顺畅。

总的来说，倒是不难，没有问什么特别回答不上来的问题，第二天看还没挂，和理想一样都是二面就主管面，几乎不问技术了。

过了几天看，已经挂了，看样子大概率是我要价太高了，应该评级不到，40以上应该是ssp，但应该不到，所以直接G。

这次的面试和之前的都不一样，这次问的非常宏观，这应该也和我投的岗位有关，我投的是AI研发工程师，这个和之前投的大部分都是算法工程师还是很不一样的，按照他自己的说法，这个岗是做除了模型性能之外的其他事，模型性能当然是网络结构，调参，其他部分应该就包括他们做的数据自动预处理框架，机器学习平台，推理框架，还有推理引擎，吞吐量和服务部署，还有量化剪枝TensorRT、Openvino这种了。

面试首先问的还是我的最后一个项目，这个项目涉及一些CPP和量化剪枝，这个问法和前面的也很不一样，问数据从哪里来的，如何处理的，模型是用的创新性的还是网上找的，性能调优调了哪些参数，具体部署如何做的，cpp部分有哪些，量化剪枝是否自己做的。项目包括几个人，自己在其中是什么角色，最后部署服务如何做的。

然后问前面的一个项目，问这个项目是如何设计的，流程是啥样的，还是几个人，自己在其中做的啥，然后部署怎么做的，这个具体涉及几个部分，我就讲了讲这个服务的设计和数据的流程，最终部署上线的情况，在其中如何根据具体的场景做了针对性的改进。他还是问了问这个平台包括什么部分，我做的具体是那块的平台还是其中的一部分，这块讲清楚之后就问部署之后各个模块之间如何写作，http服务如何做的，都传递哪些参数。最后问了问最后的推理时间是多少，我说了后面试官问是否想过要进行性能优化，我说项目没要求就没做。

然后问第一个项目，也是问了问pipeline包括几个模块，也是不问模型本身的那些八股，然后我说这块没有多少创新，主要是根据任务设计了利用几个模型连起来做了个系统，然后问这个东西最终是否投入使用，我说这个是最终上线了，然后就是关于系统本身的一些问题，这块没有问太多。

之后就是几乎每个面试都会问的实习经历了，这块问了不少，关于前面的机器学习系统是如何做的，大模型是如何做的，他们之前的业务流程是什么样的，我做了之后业务流程是什么样的，评价指标是什么。然后是最经典的问题，和机器学习模型相比效果如何，然后是关于业务相关的一些问题。

最后问了问我是否了解python的gc，我说不太懂，然后问了一个东西我没听过，之后问多线程协程，我说这块我处理数据的时候用过，但是没有仔细研究过，然后是给了一个小场景题，有6个cpu，然后一个几百张图片需要处理，如何设计，一个进程和cpu之间的关系对应，这块我就完全不太懂了，这块跟我前面做的还是很不一样的，特别偏向底层了。

然后是反问，我就问了问算法工程师、AI工程师、AI研发工程师有什么区别，然后这块大致讲了讲，就结束了。

总的来说，关于模型部署和系统底层这块我了解的还是不太多，关于量化剪枝部署这块还是要好好学习一下，毕竟从纯算法角度我可能优势不大，这次面试关于这块问的还是挺多的，回答的不太行，感觉面试官也是有点失望的样子，不过这次面试问的问题还是很有意思的，也是我之前没有接触过的。

不过没想到的是一面竟然过了。

二面

10.17晚上七点二面，面试官也很忙，面试首先自我介绍，然后跳过了实习，直接问哪个项目认为做的比较深，然后我就讲了第一个项目，从头讲到尾，然后也是不问模型细节，而是关注流程，然后是问效果，还有怎么部署的，然后我就讲了下fastapi和flask启动服务这些，涉及推理部署这块做的不多，但是整体流程还是都做过的。

然后是问大模型方面都做过哪些，然后我说实习，就讲了下实习做的工作，第一个点讲了一些，也问了数据，评价指标，和之前的对比效果如何，等等，第二个点没讲完面试官就不让讲了，然后问其他还做过哪些，其他的我倒是没怎么做过，也是学了相关的知识。

然后是问我后面说的做了RAG相关的，就问让我讲讲，我大致讲了下概念和应用，优劣啥的，然后面试官问向量表示这些工具了解如何，这块我只能简单的介绍了下那些milvus、chroma、faiss这些我了解的不是很多，没有系统的研究过。

然后问Cpp了解的如何，这块我也是初步会用一些，但是不多，然后问我会不会Java、Golong这些，这些开发的我自然是不会的。

然后问我是想做哪方面的，是效果还是效率，效果就是模型调优，效率是机器学习平台、推理框架这种，我还是更喜欢效率这块，毕竟在学校做改网络调参的活我是不太喜欢的。

然后是问我对于挑选工作offer看重哪些地方，我说从公司的长期发展、个人具体做的事情和内容、薪酬这些角度来说，然后面试官问我期望薪酬是多少，我说这个要看城市，综合多家比较来看，大城市更高一些，生活成本也是要考虑的。

然后问我对科大讯飞了解多少，我说语音这块做的比较好，问其他，我说星火大模型也了解一些，然后从未来发展角度来说，语音这个业务总体还是很看好的。

然后说我github还经常更新，我说有博客，之前会写一些技术博客，现在主要是面试复盘。

然后反问，我就问了部门具体的内容和技术栈，这块大致说了下，然后就结束了，然后面试官说会综合一面和二面的情况，等HR联系。

说到这不得不说科大讯飞了，九月中的线下面试，提前打电话说线下没有我这个岗的面试官了，然后说后面线上，结果过了三周了都没动静了，估计那边也不缺人了吧，应该也是直接g了。

一面

拼多多这次面试我面的也比较一般，过去自我介绍完然后开始问实习的内容，讲完之后开始问细节，大模型测评用的什么标准，具体是什么，如何衡量好坏，样本构造正负样本如何设置的，效果如何评价，然后我说主要用的精确率，极度不平衡的情况下结果是否有可参考性。对语义解释部分如何正则化提取，遇到无法提取的多吗，有多少，如何处理的。

然后是问的LoRA微调是否了解，原理是啥，如何做的，显存和速度是否有提升，如何体现，在推理过程中显存和速度是否有提升。

然后是八股，问我微调用的什么模型，我说盘古智子，然后让我讲下模型结构，这块我说都差不多，简单说了下，但是说的不详细。然后问我是否了解注意力机制，这块大致讲了讲，不是很细，然后追问QK相乘为什么要scale，为什么除以根号下向量长度。然后问大模型处理的整个流程是什么。

最后手撕，先给题目，然后说完思路再做，这次是依次给了两道题。

第一道是有1，2，5三种硬币若干，求组成价值为21的组合有多少种，这是个背包问题，用动态规划做，然后面试官问了问初始化1什么意义，两层循环是否可以调换。

第二道题是实现一个开根号的函数，保留n位有效数字，这个题目我写了，不过好像有一点小问题。面试官问了我是否确认这个能实现这个功能

最后问我是否了解拼多多的工作强度，是否可以接受，可以。然后反问，我问了问部门具体做啥，他们具体根据商家和客户需求找到可能有问题的，然后及时给出平台的措施，也是结合多模态的信息处理，涉及推荐。然后就结束了。

总体来说感觉面试中答的比较一般，好多问题都准备的不太好，感觉这次面试也是G了。

这次面的滴滴，刚好赶上交大线下双选会，就在交大的楼里面了下，面完十分钟就过了。

过去自我介绍完之后，面试官就问了下我之前的实习主要做的内容，也问了不少细节，不过大体也答了上来。

然后问了特征工程是如何做的，具体这块我讲了下数据预处理和筛选相关这些，实际场景一般怎么做的。

问是否做过大规模的分布式的数据处理，我说实验室没有这个条件，这块估计问的可能是hadoop这种，理论估计还是要了解下。

然后问了一些八股，过拟合如何处理，需要如何调节。

LoRA微调是什么，需要调节什么参数，啥时候调节啥参数，为啥要这样调节。

最后是手撕一道算法题，这个是个场景题，题目还很长，已知n个员工每个员工的工资，钱币有100 50 20 10 5 1六种，每个员工的工资都是这六种钱币的组合，现在要找出这n个员工的工资的组合，使得这n个员工的工资的组合的钱币数量最少，然后手撕了出来。

面完三天写的复盘，面试的时候问的哪些已经忘得差不多了，看后面约二面的时间。

二面

10.17二面的还行吧，过去自我介绍完让我选一个印象最深的项目讲，我就没讲实习，讲了第一个项目，然后就问细节，这块问的也挺多的，比如路线是啥样，相比传统方法的优势，遇到了什么问题，怎么解决的，这些都问了。

然后是八股，问了几个问题

1. YOLOv1到现在v11都有什么变化，大致说了说变化和大体的结构框架。

2. 遇到过拟合欠拟合的时候如何做的，我讲了下小模型情况下从数据、预处理和增强方式、模型、训练方式这些展开讲了讲，还讲了大模型情况下LoRA调节遇到的如何解决这些问题。

3. 优化器用的什么，如何调节的，我就从梯度衰减和优化器自动调节这些展开讲了讲。

然后是手撕阶段，出了一个题，给定一个字符串s和一个字符串数组words，（串联字串是指words中所有字符串以任意顺序排列起来的，而不是words中所有元素随机排列），然后求串联字串在s中的起始位置，我就用滑动窗口解决了。

然后就反问，问部门有哪些需要和技术栈，面试官就讲了下部门情况，然后问我有没有其他offer，我说有几个在排序中，然后就结束了。

开始投的机器学习，最后被调到LLM了，本来以为会问很多大模型八股，实际也没有那么多，还行，面试了38分钟。

过去首先自我介绍，然后开始问算法八股，第一个是介绍一下特征工程，我就先从传统特征工程来说的，然以在面试官的提示下也说了数据预处理相关的内容。问RNN、LSTM、Transformer的区别，这块是经典八股了，差不多答了。

然后是问大模型的实习具体做了啥，这块我讲了好多，感觉后面面试官都不是很耐烦了，毕竟这块东西还挺多。然后是经典的问题，既然机器学习方法能做，为什么用大模型做，这块大致答了下。然后面试官问了解CoT不，我说了解一点，面试官说这个任务也是可以用CoT来做的，然后我也简单回答了具体做的相关性。

最后是手撕，给了个经典题，word1到word2最少的操作，插入、删除、替换，然后手撕了出来。

最后反问，问部门做啥，不同岗位之间的区别和调整，面试官说虽然这个岗是LLM，不过还是有很多机器学校方法等的内容，然后就结束了。

总体答的大差不差，不过感觉有一点KPI面，不过也可能是我自己感觉的，毕竟面试官也是很忙的。

二面

10.23二面，面了差不多40分钟吧，这次面的感觉还行，这次是主管面，没怎么问技术。

过去自我介绍完，然后面试官说视觉做的多，我说大模型这块也做了一些，就问目前主流都有哪些大语言模型和视觉大模型，大语言模型我大致介绍和点评了下，然后视觉大模型就不太了解了，多模态大模型简单说了一点。

然后问我更想做大语言模型还是视觉大模型，我这块犯了个忌讳，我说他们底层都差不多，其实CV和NLP差别还是过大了，直接说差不多还是不太合适，这块我又解释了下我都能做，这块回答的不太好。然后我说的目前技术栈偏向大语言模型，但是从长期发展更看好视觉大模型，视觉大模型的发展还处于比较早期。

然后是问关于大模型如何赚钱落地和商业模型这块如何看待，这个问题就比较宏观了，就不是技术，而是如何赚钱了。这块我首先谈了下RAG、Agent啥的，面试官说不是技术，而是盈利模式这块。我就大致谈了谈目前大模型各行各业的应用，然后说了下商业模式的一些看法，对于个人、开发者、以及做产品的角度如何看待，关于做产品我还是从交互方式的角度谈了下，大模型可能和新一代的硬件，改变交互方式有关。这块的回答应该还是很不错的，面试官说本来前面的回答让他很不满意想直接给我挂了，但是这个回答他还是很高兴的。然后就是谈了下这个关于这个领域和行业发展后面可能的一些方向之类的，这块感觉还是很不错的。

然后还是聊关于部门内部两个细分大语言模型和视觉大模型的组，面试官说视觉大模型这块都是博士和院士团队在做，我履历达不到，所以进去还是会给我安排大语言模型这块。

然后反问，我就问的我过去是否需要什么技术上的学习和准备，面试官说不用，反正进来还是会有相关培训，然后就结束了。

总体来说，面试前面面的不太行，中后期回答基本还算可以，感觉还是有希望的。

HR面

11.27面直接过过了，然后问问题。

1. 是理想北京，是否接受
2. 毕业时间
3. 西电本硕否
4. 是否都全日制
5. 是否签三方
6. 薪酬保密，给不错的薪酬，年终奖
7. 六险一金
8. 工作时间和加班情况
9. 租房情况
10. 有食堂需要自费
11. 工作内容和晋升机制
12. 是否有末位淘汰
13. 家乡在哪，是否支持
14. 加微信

昨天有人加我，说是网商银行的智能引擎部门，主要基于蚂蚁集团大规模数据结合大模型，提升数据的感知和认知能力，帮助千万小商家的信用成长。部门包括多个NLP、大模型、时序和图方向，技术自由度高，且有业务价值。

然后约了今天上午的一面，今天上午到点是个电话面试，之前还没电话面过。面试首先自我介绍，然后主要讲实习的工作，他们这边应该是大模型比较相关的，所以实习相对契合一点。然后就开始非常细致的讨论实习做的内容，包括很多细节，文件如何处理的，如何表示的，如何训练的，任务是怎么样的，系统的架构，用了哪些机器学习方法，改进使用大模型的意义都有哪些方面，还有如何微调的，用了哪些方面，具体参数如何调整和设置的。然后问到LoRA，问为什么用，原理是什么，需要调整什么，啥时候怎么调整。总之这个问的细致程度基本是其他面试二面的强度，深挖一个项目，还是非常深入的。

然后面试官说看你简历里面有了解RAG相关内容，然后开始问相关的问题，原理是什么，为什么用RAG，解决了什么问题，还有相关的一些问题，最后问到向量表征都有哪些方法，如何做的，这个确实不是很懂，没怎么研究过。

然后反问，问了下后面有几面怎么安排，然后就结束了。后面看果然G了

这次面试的岗位是机器学习算法，面了一个小时，这次面试也算有质量。

过去先简单自我介绍，面试官说你这专业算计算机是吧，那计算机相关的理论你应该会，我说我专业属于计算机，不过学的还是偏向电子信息，然后让讲一下堆和栈的区别，这块没怎么讲清楚，只是简单讲了下定义，这块应该从内存中的开辟使用管理啥的开始说的。毕竟这块也是算基础吧，还是要准备下的，前面这块的都没背。

然后面试官说有论文，是不是人工智能领域的，我说是的。让讲一下论文，然后我翻出来自己的论文，从前到后讲了一遍，不过前面部分我用的时间太多，讲的有点乱，后面讲的就挺快了，讲完面试官说讲的有点乱，听的不是很清楚。

然后说去实习了就讲下实习的内容，然后我大致讲了讲，面试官简单问了两个小问题，比如效果不好的时候，如何判断是哪里的问题导致的，怎么改正。

之后面试官说给个数学题你想下：一个圆上取三点，构成锐角三角形的概率是多少，这个我尬住了，想了半天没思路，然后面试官说构成直角三角形的概率是多少，然后再到锐角，最后还是没回答出来。这块答的感觉不太行，没有体现出遇到未知问题解决问题的能力，这个思考过程不够清晰。

然后让手撕一道题，找无序数组中第K大的数，这个是一个很经典的题了，我用python堆来做的，写出来自然很简单，写完面试官说你用库实现的太简单，要不换个方法，然后说要不你自己用数组实现一个堆，然后我写不出来，又尬住了半天，然后面试官说让用快排的方法写，写了出来了。

然后反问环节，问他们部门具体做啥，然后哪方面的，说是搜广推的，还有一点具体的方向，然后刚好一个小时，就结束了。

然后晚上看，果然已经挂了。

这次面试的岗位是图像算法工程师，就面了15分钟7秒，特别短，面的不太行，应该也G了。

过去先自我介绍，介绍完之后面试官说看你简历里面有cpp，面试官说你会C++是吧，然后我说我只是在前面的一个项目中用到了一点，也是去年初了，后面几乎没怎么用到，所以也不是特别会。然后问CPP基础，第一个问题问值传递和引用有什么区别，第二个问题问虚函数定义是什么，这些都不会，毕竟cpp真很久不用了。

然后问其中一个项目，问是怎么做的，讲了讲，然后问做了什么创新点，当然是没有，把技术路线讲了讲，问这个项目的难点是什么。之后又问了一个项目，这个也问的不多，简单问问就够了。然后问训练模型都调节什么超参数，过拟合和欠拟合如何处理，注意力机制是什么。

然后反问，问他们这边是偏应用还是开发啥的，说开发的多一点，很多地方要用cpp，所以这块比较需要。

这个才是目前线上问的时间最短的，实习都没问，毕竟这边是图像算法。感觉不是很契合，第二天通知果然挂了。

这次是线下面，就在南校区C楼面了，过去也不用叫号啥的，就是随便看人自己排队，这个面试就是人事面，相当于填简历的面试。

过去先看证件，给简历，然后看本硕学历证明，成绩单，四六级，还要本科的成绩单，我没打印，就给记录上没本科成绩单，然后问有没有挂科，当然没有；然后挨个问，问完记录 ，就是纯粹当面填简历信息，问论文，然后把英文论文翻译成中文录进去，问简历号，然后是竞赛有啥，然后记录专利是啥名字；然后挨个问项目是做的啥，记完名字一句话描述做的啥，然后录系统，挨个问完之后问编程语言，然后是研究方向是啥，也是简历上有的信息。

然后问了问实习，她好像都没看简历，简历上写的有实习，他还问我有没有，我给他指出来她才看到然后对着把信息填系统。

问完这些然后问家是哪里的，父母是什么工作，将来想去哪里工作，将来想做啥方面的，我说人工智能这块都比较通，这块都可以做。

后面还是说本科成绩单的事，所以只好加上微信，后面发过去，然后反问，问他们后面有几面，是不是分配，说一面是人事面，二面技术面，然后也是根据人匹配岗位啥的，然后就结束了。

后面就发现挂了，进入人才库。

后面10.10被软开捞了，电话打过来问对开发有没有兴趣，我完全没有学过开发，前后端啥的完全不会，问cpp的也不太会，问了数据结构，还有堆栈、ArrayList、LinkedList这些就问了一二十分钟吧，然后就完了。

然后10.15就直接给offer了，但是13k，这个价在深圳只能说有点离谱，*1.36也没有太大意义。

offer是高级系统开发工程师。

这次面试进去面试官就说时间紧，咱们尽快，晚上七点半的面试，看起来这公司还是要加班很多的。

进去先自我介绍，然后问了我最后面的一个项目，谈谈做的啥，然后问了下细节，数据处理，标注，处理啥的。然后问有啥项目感觉比较有内容的，然后我说了下第一个项目，讲讲背景和具体怎么做的，讲了一些，但是创新性不够，问这个项目的难点在哪里。后面又问了问实习做的啥，然后我就讲具体做的什么，这块也追问了一些细节，然后没讲完，面试官就说时间不多了，然后反问，我问进去是做啥，他说一面只是初筛，具体的方向和部分还是会具体分配，然后就结束了。

总的来说，得物这个一面是目前线上面试的里面时间最短的，没有之一，部分线下面试有不超过半小时的，这个面试都不到半小时，就问了下项目和实习，没有八股和手撕部分，像淘天这种，八股和手撕是主要，风格还很不一样，不过我八股和手撕都准备的不太好，所以这种风格也不能算太差吧，至少比手撕不出来好。

面完后面看果然已经挂了。

9.19面试的，前面投实习的时候再加秋招前面简历挂了好多次了，这次面的时候就感觉大概率也g了，果然面完半小时就挂了。

面试过去首先面试官介绍了他们部门是做什么的，然后我做了自我介绍，然后面试官说给你三十分钟，让手撕三个力扣题，第一个是写一个查找字符串数组中的最长公共前缀；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def longest_common_prefix(strs):
    if not strs:
        return ""
    
    # 取第一个字符串作为基准进行比较
    prefix = strs[0]
    
    # 遍历数组中剩下的字符串
    for s in strs[1:]:
        # 逐渐缩短前缀，直到找到公共前缀
        while s[:len(prefix)] != prefix:
            prefix = prefix[:-1]
            if not prefix:
                return ""
    
    return prefix

# 测试用例
strs = ["flower", "flow", "flight"]
result = longest_common_prefix(strs)
print("Longest common prefix:", result)

时间复杂度：O(S)，其中 S 是数组中所有字符串的字符总数。在最坏情况下，算法需要逐个字符比较每个字符串的前缀。
空间复杂度：O(1)，除了输入数据外，额外使用的空间主要用于存储前缀。

关于这点我就说的很差，时间空间复杂度说的完全不对，我还以为是$O(mn)$， g

第二个是找出数组中所有可以使得数字和为target的组合，每个元素只能出现一次；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

def combination_sum(nums, target):
    # 先对数组排序，这样可以更容易地进行剪枝操作
    nums.sort()
    result = []

    # 定义回溯函数
    def backtrack(start, path, remaining_target):
        # 当剩余的target为0时，说明我们找到了一个有效的组合
        if remaining_target == 0:
            result.append(path[:])  # 将当前路径加入结果中
            return
        
        # 遍历从当前索引开始的每个数字
        for i in range(start, len(nums)):
            # 如果当前数字大于剩余的target，则无需继续搜索
            if nums[i] > remaining_target:
                break
            
            # 为了避免重复的组合，我们跳过相同的数字
            if i > start and nums[i] == nums[i - 1]:
                continue

            # 选择当前数字，继续递归搜索
            path.append(nums[i])
            # 递归，i + 1表示每个元素只能使用一次
            backtrack(i + 1, path, remaining_target - nums[i])
            # 回溯，撤销选择
            path.pop()

    # 调用回溯函数
    backtrack(0, [], target)
    return result

# 测试示例
nums = [10, 1, 2, 7, 6, 1, 5]
target = 8
combinations = combination_sum(nums, target)
print(combinations)

时间复杂度是指数级的 $O(2^n)$，属于递归经典的时间复杂度了，我这里说成了$O(N^2)$， 明显的直接g了， 这里的空间复杂度好像不太好算，应该是$O(k*2^n + n)$， k 是每个组合的平均长度， n是数组的长度。

第三题是一个链表数组，其中每个已经按照升序排列，合并成一个升序链表。写完后说时间和空间复杂度，这块没说清楚，对于第三题，问我为什么用堆，有什么优势，堆的几种基本操作的时间复杂度是多少。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

import heapq

# 定义链表节点的类
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def merge_k_sorted_lists(lists):
    # 创建一个最小堆
    heap = []
    
    # 将每个链表的头节点加入最小堆
    for i, lst in enumerate(lists):
        if lst:
            heapq.heappush(heap, (lst.val, i, lst))
    
    # 哨兵节点，用于构建最终的合并链表
    dummy = ListNode()
    current = dummy
    
    # 进行堆的操作，直到堆为空
    while heap:
        # 弹出堆中的最小值
        val, i, node = heapq.heappop(heap)
        
        # 将弹出的节点连接到最终结果链表中
        current.next = node
        current = current.next
        
        # 如果弹出的节点还有后续节点，将它的后续节点加入堆中
        if node.next:
            heapq.heappush(heap, (node.next.val, i, node.next))
    
    # 返回合并后的链表
    return dummy.next

# 测试用例
# 构建几个升序链表
list1 = ListNode(1, ListNode(4, ListNode(5)))
list2 = ListNode(1, ListNode(3, ListNode(4)))
list3 = ListNode(2, ListNode(6))

lists = [list1, list2, list3]

# 合并链表
merged_list = merge_k_sorted_lists(lists)

# 输出合并后的链表
while merged_list:
    print(merged_list.val, end=" -> ")
    merged_list = merged_list.next
print("None")

第三题这个不算特别难的，感觉比第二题还好一点，但是对于堆的相关概念说的不是很清楚，这个时间复杂度是$O(Nlogk)$，N是所有链表的节点总数，k是链表的个数，空间复杂度是$O(k)$，k是链表的个数。

然后让我讲下transformer结构，大致说了下，然后问transformer相比RNN有什么优势。这块实习的时候淘天就问过这个问题，当时说的模糊，思路不是很清晰，现在秋招了这块也没怎么看过，仍然说的不是很清楚，八股还是要背的，这种基础知识都说不好的肯定不行。

GPT总结了一些：

1. 并行计算能力
   RNN：RNN 是一种序列模型，必须按时间步依次处理输入数据。也就是说，第 t 时刻的输出依赖于第 t-1 时刻的计算结果，因此不能并行化处理序列中的元素，这导致训练时间较长。
   Transformer：Transformer 利用自注意力机制（Self-Attention），使得每个输入位置的处理可以与其他位置的元素并行进行。这意味着 Transformer 能够在同一时间处理整个输入序列，从而大大加快了训练和推理速度。这种并行化特性使 Transformer 非常适合在 GPU 上运行，尤其对于长序列，训练速度相较 RNN 显著提升。

   2. 捕捉长距离依赖关系的能力
      RNN：RNN 的主要缺点之一是难以有效捕捉长距离依赖关系。由于其每个时间步的状态依赖于上一个时间步的状态，随着序列的增长，长距离的依赖可能被遗忘（梯度消失问题）。虽然 LSTM 和 GRU 在一定程度上缓解了这个问题，但仍然存在限制。
      Transformer：通过自注意力机制，Transformer 可以直接建模序列中任意两个位置之间的依赖关系，无论这两个位置相隔多远。这意味着 Transformer 在处理长序列时，能够高效且准确地捕捉长距离的依赖关系，而不会像 RNN 那样受到序列长度的限制。

      3. 消除递归结构，提升效率
         RNN：RNN 的递归结构需要依次处理序列中的每个元素，这种顺序性导致模型无法并行执行，尤其在长序列任务中，RNN 的训练和推理效率较低。
         Transformer：Transformer 通过完全消除递归结构，取而代之的是基于全局自注意力机制的并行计算，这大大提升了计算效率。每个位置的输出只需通过矩阵运算来计算，无需逐个时间步依赖前一个输出，极大地提升了效率。

         4. 更好的记忆和上下文捕捉
            RNN：RNN 的记忆是通过隐状态（hidden state）来传递的，每一步的状态依赖于前一步的信息传递。这种方式在处理长序列时会因为过多的信息传递而产生信息损失，导致模型难以保留远距离的上下文信息。
            Transformer：Transformer 使用自注意力机制，使得每个词或元素能够直接与其他所有元素建立联系。这种全局视角能够让模型在同一层次上捕捉到整个输入序列的全局信息，从而更好地保留上下文信息。

            5. 避免梯度消失问题
               RNN：RNN 依赖于逐步传递的隐状态，训练时容易遇到梯度消失或梯度爆炸的问题，尤其是在处理长序列时，梯度的传播会变得非常困难。
               Transformer：Transformer 没有依赖于序列传递的隐状态，而是通过自注意力机制和前馈神经网络来计算输出。这样就避免了在长序列上梯度消失或爆炸的问题，训练更为稳定，尤其在长文本或长序列任务中表现尤为显著。

               6. 更强的表示能力
                  RNN：RNN 只能通过顺序计算来处理序列信息，这种线性的计算方式在处理复杂序列依赖时可能有局限。
                  Transformer：通过多头自注意力机制（Multi-Head Attention），Transformer 可以从多个子空间同时处理信息，每个注意力头关注不同的信息模式，增强了模型的表示能力。多头自注意力机制允许模型同时关注输入序列中的不同部分，获取不同层次的特征。

                  7. 适应性更强的输入表示
                     RNN：RNN 的输入表示是通过序列顺序传递的，缺乏对输入元素之间关系的灵活表示。
                     Transformer：Transformer 通过**位置编码（Positional Encoding）**来为序列中的每个位置引入位置信息。这种设计使得 Transformer 在处理文本等有序数据时，不会像 RNN 一样依赖于输入的顺序，还可以灵活适应各种输入长度和结构。

                     8. 更容易并行扩展
                        RNN：RNN 的递归结构天然不适合并行处理，尤其在训练非常深层的 RNN 模型时，计算资源的利用效率较低。
                        Transformer：Transformer 的并行性和层级结构使其更容易扩展到大规模数据和模型，特别适合深层模型的并行计算。因为没有递归关系，Transformer 可以利用 GPU 进行大规模的并行计算，大幅提升训练效率和处理能力。

                        9. 更适合预训练和迁移学习
                           RNN：尽管 RNN 可以在特定任务上进行预训练，但其能力有限，尤其在处理大规模数据和迁移学习时，效果不如 Transformer。
                           Transformer：Transformer 的架构非常适合大规模预训练模型，如 BERT、GPT 系列。这些模型通过在大规模数据上进行无监督预训练，能够很好地迁移到各种下游任务中，并且预训练的表示可以用于不同领域的任务，大大提高了模型的泛化能力和迁移学习能力。

之后是问简历上的实习经历，大致问了下，讲了背景，然后说具体是做了哪方面的工作，经典的一个问题就是，这个任务用大模型做有什么优势，这块我说我就是预研的一个探索，用大模型端到端的做这件事，实际上需要的数据什么的还是用的传统方法获得的，这块其实这样说还是不太好。另外涉及具体的工作，他们这边好像也是有做类似的东西，但是我也没讲的很出彩，然后中间问到了一个问题，我听的不是很明白，面试官就没什么兴趣了，我这块还没说完然后差不多就一个小时了，就让反问，然后就结束了。

面完就感觉不行了，过一会去看就挂了，淘天还是这么喜欢让手撕代码，这块还是要准备下。总之投实习的时候就淘天面的最差，现在秋招了，淘天还是面的最差的，问题还是有很多，面完要复盘总结经验。

这次面试是秋招正式批的第一个线下面试，问的比较浅显，我查了下，一面应该是技术面，不过好像技术的东西问的不多。

过去首先检查学生证和身份证，然后给简历，自我介绍，然后就要看成绩单，问有没有论文，我说有论文，之后让介绍实习做了啥，难点是啥，大致说下我的工作。其他的项目都没怎么问到。

然后问我是想做哪方面的，是大模型研发微调还是应用，我说尽可能的偏向研发，然后问从哪个项目可以提现这个能力，我说前面做的项目应用的比较多，但是倾向还是偏向更技术一些的。

然后反问，然后我问了问部门是做啥的，他说看我意愿分配到适合的部门，面试二十多分钟就结束了，也没有力扣环节。

二面

一面完很快就发了二面的预约，9.18 上午的面试，这次人巨多， 等了好久，过去还是先检查学生证和身份证，然后给简历，自我介绍，这次涉及技术的更少了。问了爱好，实习的收获有哪些，然后我就详细讲了讲这块关于实习和在学校。

之后是问对中兴了解如何，如何看待加班，期望薪酬是多少，有没有其他的offer，我说了下，然后问我有没有问题，我问了问部门是做啥的，然后面试官说一面没问吗，确实没问，然后问意向地点去哪里，我说杭州或者北上广深这种一线城市，大致也就这些。

没想到面这么随意，后面就挂了，进入了人才库

这次面试是秋招正式批的第一个面试，八股什么的也都没有准备，就直接开始面试了。

首先介绍一下自己，介绍完之后问实习的经历，然后我就讲了讲业务背景是什么，自己在里面干了什么，但是面试官应该不是做这个的，所以也不是很感兴趣。

然后开始问我的第一个项目，这个发了论文的，问这个项目是背景和做了什么，问了下细节，把大致的流程讲了差不多，然后问这个项目的难点是什么，这个我倒是没有怎么总结，因为都没有说很难的地方。

然后面试官开始问八股了，YOLO相关的内容，按说我做的视觉项目比较多，这块应该比较懂，不过这块确实很久没看过了，连续问了三个问题回答的都一般，首先让我讲yolo的大致结构，我讲到提特征用darknet，然后讲为什么用darknet不用resnet，这块我就已经忘了，然后讲池化金字塔融合有哪些形式是什么样的，我就简单讲了下，也说的不是很清楚，然后后面的模块简单说了下，之后问发展过程的演变我也是只简单说了下。然后问了下yolo的图像增强方法都有哪些，我简单说了一两个，不太行，回去还是要准备下。

之后是问第二个项目是做什么的，然后我大致讲了下背景和具体怎么做的，然后这块也没有问太多，毕竟这个含金量也不是很高。

之后就直接让手撕了，这次考的题目是求最长的斐波那契数列子序列的长度，想了会也写了出来。

然后是反问环节，我问了问他们部门具体是做什么的，然后这块我也简单聊了聊3dgs和无人机相关那些东西，然后面试官说感谢你的参与，然后就结束了。

二面

9.18号下午三点的面试，这次面的挺延伸的。

过去首先自我介绍，然后让我挑一个认为做的深的项目讲一下，我就讲了下第一个项目，然后首先讲背景，这里就讲了好久，我说这个可以降温增效，面试官就要很清楚的了解，到底降低了什么成本，是在性能的改进，还是成本的改进，还是时间的改进，这个明确之后，才继续讲。然后是讲技术方案，这块也是细致的扣，技术如何这样做会不会有误差，如何保证，具体怎么做。然后是问认为这个项目的难点是什么，我说主要是把这个整个体系实现出来，然后大致讲讲如何看待这个事，是因为在学校和公司的差异。之后就是一个问题，关于测量的真实值如何获得，我简单说了下。然后是开放性问题，问给很多很多钱的情况下如何找到精准真实值，我说找很多专业人士，然后用好的仪器，然后面试官问还有啥，我说不知道了，然后面试官给了点提示，无人驾驶的，然后我说多模态融合激光雷达什么的，也算是答的差不多。后面也是开放的聊了一些。

之后是代码环境，要求实现一个容器，其中两个函数实现增加元素和删除元素，然后一开始懵逼，提示了下大致写了下思路，时间不够就把大致怎么实现的说了下，也算是差不多说清楚了，就是代码写的还不太完整。

总体来说，这种很延伸的还是很难的。

今天周一我六点多下班就回来面试，面试官首先让我自我介绍，然后我自我介绍完，然后是简单问一下我项目情况以及简历上各种内容的情况，然后展开论文讲解，然后我就把论文的背景和内容，然后创新点什么的讲解了一下，然后突出自己的优势，做的比较多学习新东西比较快。

然后问了问自己在华为实习，这段时间都做了什么？然后我也是简单讲了讲背景，然后讲自己在做的东西这块儿内容有些单薄，后面要丰富一下，这块儿我都没有怎么准备，所以说着坑坑巴巴的。

然后面试官问自己，在之前遇到什么困难，然后怎么解决的，然后我就换方向这个内容展开讲了讲，说之前遇到这些困难，当然现在解决了，现在做新东西学东西新东西都挺快。

然后面试官说让手撕代码，然后我说这块儿还没怎么开始准备秋招，然后给了一个题，对于一个长度为六的链表，然后如何反转456项，然后我就按照最简单粗暴的方法，然后他说长度不定，用通用的方法来做，然后我就用一般的方法做基本思路，还是说出来了，先找到一半的节点的头节点，然后面试官说，既然有思路，那就让本地IDE写了。我简单写了写，然后卡住了，翻转这块。想了一会儿，想出来了，这块儿也花了一会儿，还是不是很熟练。

然后面试官问还有什么想问的，我看面试官都有点不耐烦了，然后简单问了问他们部门儿是做什么的，然后因为我投的是语音部门，所以感觉还是不太match，最后说完面试官说感谢你的参与，全程面了一个小时，这样回答感觉大概率是G了，问题不大就第一场，后面还有机会慢慢准备先把实习做好。

2024.8.19二面

这次面试问的非常细，让自己选一个项目，然后深挖。首先讲了讲自己的项目大致背景、流程、以及主要用到的模型，然后提问这个数据是什么，要提特征，然后讲用了什么模型，模型输入输出是什么，架构是什么，我简单说了之后面试官让详细讲，我就讲了讲思路，但是整个模型的结构就忘了。之后问主体模型是啥，输入输出，架构是啥，为啥用这个模型，然后这个模型是单向还是双向的，为什么，然后单向双向网络有什么区别，感觉可以从模型设计的区别和代理任务的区别展开。然后问了问，这个项目你做了两年了，现在回过头来看，你会用什么来做，如何设计训练，输入输出是什么，预训练的话用什么做，对应的任务如何设置。这些还是挺难的，而且还不是那种能查出来的问题。

然后问了问未来发展如何想，是只做算法还是什么，然后我说因为本硕都学的这个，所以选这个感觉适合，后面做其他的学习能力也很强可以快速学好。

然后是简单的编程，写一个排序算法，然后我写了个插入排序。

最后是提问，我问了我部门做啥，具体什么场景。

2024.9.2三面

二面完本来约上周，但是上周都抽不出时间，只好这周，还是周一。这次面试主要还是聊聊天，首先做自我介绍，然后就问实习这段时间有什么收获，和学校有什么不同，我说一方面是技术上的，另一方面是从学生到职场转换这一过渡；在学校是一个人做项目，在企业分工合作做一个大的，然后问这两个哪个好，我说看根据具体的项目来定，大项目合作分工，小项目单人做。然后就是聊现在技术发展趋势和未来职业规划，我说跟着时代趋势走，同时积累自己的核心能力，然后面试官就在说时代趋势和语音这块发发展。
后面到反问环节，我问部门主要做什么，然后主要就是语音交互，相关的技术。最后我问了问部门升职和培养机制。

其他还问了有没有拿到其他offer， 投了哪些了，我就如实说，还没offer，也基本没开始投。

总的来说，比较偏向于聊天，但是具体要不要我真看不出来，希望能过吧，然后就说联系HR了。后面如果过的话应该就进池子了，不知道啥时候能泡出来。

2024.12.17HR面

本来以为开不出来了，没想到打电话过来，首先问我签了哪里，我说已经签了一家中厂了，并问了问方向，然后问了问毁约到什么时间可以。之后问了问我后续投递计划以及现在的年终奖月份了。

然后问我是否还有其他offer，之后问我关于方向的问题，以及预期薪酬。

第二天就给我确定了薪酬和工作内容，让我等着发offer就行，审批中，之后过了几天offer就发下来了。

本来投的计算机视觉，但是一直在简历筛选中，5.26我看腾讯实习都快结束了，视觉这块肯定做不了，改投了机器学习，然后昨天就接到了约面，今天上午面，腾讯的算法好像就叫技术研究-机器学习方向。

面试

面试首先让做自我介绍，之后让选一个项目深入讲解，我做的通用项目比较多，然后大致概括了下，之后选了一个项目，然后问这个项目做的啥，技术亮点是啥，这里问的也是很细，然后我说主要还是任务上应用到这个领域，然后问如何衡量效果，设计什么指标，效果如何，误差是多少；然后是问数据量多少，是否足够，如何判断数据量足够，质量如何，进行了什么预处理；讲具体用了mmseg这个框架，然后问具体用了什么模型，为什么选这个模型，这个模型结构是什么，模型的优缺点是什么。

然后让讲解一下YOLO系列，这块我没法详细的讲解，只能说个大体框架，然后每一代的改进简单提了一点，也没详细讲出来。

然后让讲transformer的结构，我大致讲了下，然后问qkv的物理意义，问为什么现在大模型都是decoder结构的，大致说了下和bert的区别，然后其中讲的比较宏观。

所以面试官问了SAM了解的如何，这块我还真不太了解，然后说用了下，感觉太慢，效果还行。然后问关于大模型理论这块的看法，然后我说现在视觉大模型还不太够，主要还是基于LLM，然后简单问了下LLM相关。

之后就是手撕，一个字符串求最大的无重复字符串长度，这个不算难，用的滑动窗口法，面试官说复杂度O(n)太高，有没有优化空间，不知道。

之后就是反问环节了，我问了问他们部门是做什么的，说是游戏和强化学习相关的，我说这块感觉是未来的方向。之后问我啥时候能去，我说六月多到九月多可以三个月，然后问老师放不放，我说没问题。

总结

总的来说感觉问题跳跃度非常高，从一个问题回答中间提到了其他技术，就继续追问，很多新技术我了解的并不深入，比如SAM这样。但是我在项目准备上略有欠缺，YOLO系列也没有系统的整理，这次面试官也只问了一个项目，让捡着一个详细说然后不断发散，前面的钉钉和淘天的视觉面就问的特别细，几乎每个项目，论文，竞赛等等都问了一遍。

一个问题就是我做的项目虽然多，但是大部分都是含金量不太够的项目，一深挖就会发现很工程，嗑盐创新点不够，不够深入，还是要有至少一个项目做的非常深，这样每次面试的时候只需要对这一个做的非常好的项目做准备就可以了，毕竟大部分面试也不会把每个项目都拷问一遍，贪多没用，简历写了一大堆也就那样。

这可是腾讯AI Lab，我也是太勇了，这种感觉几乎没有可能过，level太高了，这应该是我面试这么多以来最高的了。

最后

非常合理的面试挂了，毕竟面试开始前我就预估不通过率能有95%，这要是能过我只能说腾讯是真没人了，没有意外的非常合理。

本来阿里国际投的算法工程，结果简历筛选就没过，然后给调到了大模型应用开发，这块我没做过具体项目，感觉是要G了。

果然G了

面试

这块首先是做了两分钟的自我介绍，然后问哪个项目印象深刻，然后讲了下，之后问论文，然后简单讲下，然后说有没有网络模型的创新，我说这块没有；然后简单问下大模型知道多少，我简单说了一点理论和应用上的了解；关于项目和论文，也基本没有追问，没有仔细考察，可能毕竟和大模型差的也很多吧，然后就是反问环节，问了部门是做啥的，然后说主要是做大模型的应用开发，然后具体说是做应用，设计一些模型改进和调整什么的。

手撕代码

力扣这块我做的确实还是不到位，大部分手撕都做不出来，这次出的是对一个$\m \times n$的矩阵，从每行中取出一个数然后相加，使得总和与一个target值的绝对差最小，绝对差是值两个数之差的绝对值，然后我就想半天也没想出来，然后就结束了。

总结

这次面试感觉还是挺差的，毕竟大模型这块我没做过，也没怎么了解，力扣这块也是要多刷题，总之这次感觉是有点KPI面，问的也比较粗略，感觉肯定是G了。

本来今天中午是打算面钉钉的，前面推了三次，终于约到了今天中午，结果提前淘天打电话让直接面试了，所以今天就先面了淘天

淘天面试

在之前的时候淘天的视觉已经G了

事实证明，视觉这块真不行，要求太高了，真做不了，不是简历挂就是面试挂，今天给调到了机器学习。

面试首先就是自我介绍，然后开始问项目，问哪个项目印象深刻，然后就重点讲了第三个项目，讲了之后问论文做了啥，大致都讲了下，然后是比赛，问做的过程中用了什么方法，前几名是用的什么方法，有什么差距，具体是哪里的差距；然后我用的什么方法，有什么亮点，我说前几名用的主要方法都差不太多，重点在于策略和具体的应用调整。反正这块主要就是拷问简历上的项目了，毕竟前面笔试啥的都弄了，算法八股倒是没问。

之后是反问环节，然后问他们部门是做什么的，然后说他们主要是做搜广推的，主要是搜索和广告，然后大致讲了做啥。

已经G了

钉钉面试

刚面完淘天就是面钉钉，钉钉的这个笔试和面试挨着的，这个笔试不是力扣算法题，而是深度学习方面的题，首先手撕三选二：

1. 层归一化
2. 多头注意力
3. kmeans

层归一化我确实不太会理论，就没写，多头注意力是经典手撕了，凑合写了下，kmeans我是很熟悉的，毕竟大三第一次写这种算法就是kmeans， 手撕完之后让逐行讲解，凑合讲了下，不过细节还是有点漏，这块可以再看看。

之后是说怎么项目都是去年的，我说前面也有个，然后问了问论文，也问的详细，相比前人贡献是啥，我说这块前人工作很少，我主要是开辟了这样一个流程和处理方法，然后各种细节问了下，这块问的很细，具体来说，这个部分包括一个流程，其中视频部分具体用了什么模型，为什么用这个模型，这个模型架构是什么样的，具体是如何实现这个功能的，对比效果如何；检测和关键点部分用了什么模型，相应的模型架构是什么样的，卷积神经网络和transformer相比特点分别是什么。

然后问常见的激活函数都有哪些，然后都介绍一下，这块比较新的我都没怎么记，就只说了下之前的激活函数。

然后问最喜欢的网络模型是什么，为什么喜欢这个模型，讲一下结构，然后相比前人工作改进是什么，我大致讲了下，不过模型结构讲的不够细节。

之后是说看我简历上写了多模态大模型啥的，我说这块了解了些，但是发现算力什么的差很多，然后主要是做老师的项目，所以这块只是了解。

然后问职业规划，这块我没准备，也没经验，只能凑合说下，后面还是要准备下。

之后是说我学习能力强，各种项目都做，所以迁移到学习新东西也很快，然后问具体如何体现，这块我就不是很知道怎么回答了。

最后反问环节，我也是问了部门是做的什么，说部门主要三个方向，第一是风控，第二个是啥我给忘了，第三个就是大模型文生文，图生成文，语言和图文多模态啥的。

总结

这两场面完仍然是汗流浃背，总之还是比上次淘天的要好一点吧，至少手撕八股准备了下。具体这次问项目和论文的细节也是非常的细致，具体很多问题已经记不清了，总之简历上的东西还是要详细到问每个细节都能答得上来。

估计没有二面了，这次被拷打的狠狠的，估计是无了，第一次视觉面，没有准备相关内容,第二天去看，果然已经流程结束

自我介绍

和前面一样先自我介绍。

项目拷打

这次我投的计算机视觉算法，面试的比较对口，面试官就问的很细，面试首先是问了几个项目的内容，我前面做的任务主要是通用视觉目标检测、姿态估计、分割等这些的项目，这些项目都没什么深度，主要是用，然后问的很细，就很难受，被拷打出来了没做啥有深度的内容，主要是应用，这块就不太行了。前面的面试面试官不是研究视觉的，就只大致问问做项目过程中遇到的难点，困难如何解决的，这次要先把做的任务说清楚，不清楚就会继续不断追问，然后说清楚做了什么，涉及较难的部分还会重点追问。但是这部分我往往都是只应用，并没有结构上的创新，然后具体用的什么模型，如何训练，如何处理，等等都会追问，问的非常细，项目虽然是自己做的，但是很多东西也没怎么想到，就非常难受。这里面除了一个配准的专利面试官可能没做过没问，其他所有项目比赛都非常仔细的抠细节。

现在想想，前面做过的项目也没有系统的整理里面的亮点和创新点等等，而且做的时候也很多时候只是用现有的技术做了，但是没有去想过创新点，含金量就不太够，还是要把做过的东西包装一下。

简单的数据处理脚本

然后面试官说让做题，首先是一个简单的路径字符串列表变成文件树的任务，这个非常简单的，这种类似的见得多了，但是当时太紧张了，然后这个我就没写出来，实在是不应该，其实另外一个写不出来的问题在于，平时写代码都有Github Copilot辅助，基本都是只需要写个大致的思路，辅助编程就能自动补全了，具体某个函数名字和参数什么的真不怎么记住，这个也是一个问题，以后要多写多记住一些基础的东西。

具体题目是：

1
2
3
4

news/car/suv
news/car/mpv
news/sport/basketball
news/sport/football

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

def tree(str_list):
    n = len(str_list)
    category_dict = {}
    for i in range(n):
        strs = str_list[i].split('/')
        category, name = strs[1], strs[2]
        if category not in category_dict:
            # 这一步我都没想起来，实在是太离谱了
            category_dict[category] = [name]
        else:
            category_dict[category].append(name)
    return category_dict

def print_tree(category_dict, depth=1):
    print('news')
    for key, value in category_dict.items():
        print('\t' * depth + key)
        if isinstance(value, dict):
            print_tree(value, depth + 1)
        else:
            for v in value:
                print('\t' * (depth + 1) + v)
if __name__ == '__main__':
    str_list = ['news/car/suv', 'news/car/mpv', 'news/sport/basketball', 'news/sport/football']
    category_dict = tree(str_list)
    print_tree(category_dict)

logistic回归

让说一下logistic回归，我就说了下公式，然后说前些年用，因为方便求导，简单说了下，具体用来更新模型的参数没说。这相关的算法也是学过的，但是要清晰讲出来还是要准备的。

手撕注意力

然后让写一个attention的公式，然后也没写出来，就简单说了下原理，肯定是不行的，这种都是算法的八股，我应该提前准备下的。

chatgpt答案

注意力机制是一种让模型能够在处理信息时自动地聚焦于最重要信息的技术。在深度学习中，注意力机制通常用于序列模型，特别是在自然语言处理领域。最常见的注意力机制是由 Vaswani 等人在 2017 年提出的“Scaled Dot-Product Attention”。

注意力机制的数学公式

基础的注意力机制可以表示为三个核心组件：查询（Query），键（Key），值（Value）。给定查询 ( Q )，键 ( K )，和值 ( V )，注意力权重计算通常包括以下步骤：

1. 注意力得分（Score）计算：
   [ \text{Score}(Q, K) = QK^T ]

2. 缩放（Scaling）：
   [ \text{Scaled Score} = \frac{\text{Score}}{\sqrt{d_k}} ]
   其中 ( d_k ) 是键向量的维度，这一步骤是为了避免计算中的梯度过小。

3. Softmax 归一化：
   [ \text{Attention Weights} = \text{softmax}(\text{Scaled Score}) ]

4. 输出计算：
   [ \text{Output} = \text{Attention Weights} \cdot V ]

代码实现

在 Python 中，可以使用 PyTorch 这样的深度学习框架来实现注意力机制。下面是一个简单的 Scaled Dot-Product Attention 的实现示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import torch
import torch.nn.functional as F

def scaled_dot_product_attention(Q, K, V, mask=None):
    """
    实现 Scaled Dot-Product Attention。
    参数:
    Q: 查询张量 [batch_size, num_heads, query_len, key_dim]
    K: 键张量 [batch_size, num_heads, key_len, key_dim]
    V: 值张量 [batch_size, num_heads, value_len, value_dim]
    mask: 掩码张量，用于遮蔽不需要的值 [batch_size, 1, 1, key_len]
    
    返回:
    output: 注意力机制的结果 [batch_size, num_heads, query_len, value_dim]
    attention_weights: 注意力权重 [batch_size, num_heads, query_len, key_len]
    """
    d_k = Q.size(-1)
    
    # 计算 Q 和 K 的点积，然后除以 sqrt(d_k)
    scores = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.tensor(d_k, dtype=torch.float32))
    
    # 如果有掩码，将掩码加到 scores 上
    if mask is not None:
        scores = scores.masked_fill(mask == 0, float('-inf'))
    
    # 应用 Softmax 函数获取注意力权重
    attention_weights = F.softmax(scores, dim=-1)
    
    # 计算最终的输出
    output = torch.matmul(attention_weights, V)
    
    return output, attention_weights

这段代码实现了 Scaled Dot-Product Attention，其中 Q, K, V 是输入的张量，可来自相同的或不同的输入源。mask 参数用于可选的掩码操作，通常用在处理变长序列时忽略填充项。注意力权重通过点积、缩放、Softmax 计算得出，最后使用这些权重对值 V 进行加权求和，得到每个查询的输出。

手撕Attention

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class Attention(nn.Module):
    def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
        super().__init__()
        self.num_heads = num_heads
        head_dim = dim // num_heads
        # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights
        self.scale = qk_scale or head_dim ** -0.5

        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
        self.attn_drop = nn.Dropout(attn_drop)
        self.proj = nn.Linear(dim, dim)
        self.proj_drop = nn.Dropout(proj_drop)

    def forward(self, x):
        B, N, C = x.shape
        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
        q, k, v = qkv[0], qkv[1], qkv[2]  # make torchscript happy (cannot use tensor as tuple)

        attn = (q @ k.transpose(-2, -1)) * self.scale
        attn = attn.softmax(dim=-1)
        attn = self.attn_drop(attn)

        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
        x = self.proj(x)
        x = self.proj_drop(x)
        return x

MLP的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Mlp(nn.Module):
    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
        super().__init__()
        out_features = out_features or in_features
        hidden_features = hidden_features or in_features
        self.fc1 = nn.Linear(in_features, hidden_features)
        self.act = act_layer()
        self.fc2 = nn.Linear(hidden_features, out_features)
        self.drop = nn.Dropout(drop)

    def forward(self, x):
        x = self.fc1(x)
        x = self.act(x)
        x = self.drop(x)
        x = self.fc2(x)
        x = self.drop(x)
        return x

扩散模型

然后问扩散模型知道不，然后我说没做过，这里也是改准备下的，毕竟这么著名的模型，我虽然大致了解原理还有DDPM什么的，但是如果认真的讲出来，不成体系，我也就没敢说，这块还是要准备下。

chatgpt回答

扩散模型是一种新兴的深度学习方法，特别是在生成模型领域中表现出色。这种模型基于随机过程理论，特别是扩散过程，通过逐步增加随机性来转换数据，然后再逐步学习如何逆转这一过程，从而生成高质量的数据样本。这一方法在图像和声音生成中尤其流行。

扩散模型的基本原理

扩散模型包括两个主要阶段：正向过程（forward process）和反向过程（reverse process）。

1. 正向过程（噪声添加过程）：
   在正向过程中，模型逐步地将噪声引入到原始数据中。这通常通过多个时间步骤实现，每个时间步骤都会向数据添加更多的高斯噪声，直到数据完全转变为纯噪声。这个过程可以用以下等式表示：
   [
   x_{t} = \sqrt{\alpha_t} x_{t-1} + \sqrt{1-\alpha_t} \epsilon_t
   ]
   其中，( x_t ) 是在时间 ( t ) 的数据，( \alpha_t ) 是时间步骤中噪声的比例，而 ( \epsilon_t ) 是从标准正态分布中采样的噪声。

2. 反向过程（噪声去除过程）：
   反向过程旨在学习如何从纯噪声数据逐步恢复出原始数据。这是通过一个参数化的神经网络模型实现的，该模型试图预测给定噪声数据的前一时间步骤的状态。反向过程的目标是逐渐减少数据中的噪声，最终恢复出接近原始数据的状态。

训练扩散模型

扩散模型的训练通常依赖于变分下界（ELBO，Evidence Lower Bound）的优化。模型的目标是最小化重构数据和原始数据之间的差异，同时也优化生成数据的概率分布。训练过程需要大量的计算资源，因为它涉及到大量的正向和反向模拟步骤。

FM算法

然后问机器学习算法FM算法，然后我说不知道，这个我还真没听说过，查了下，是推荐的算法，因子分解机，真不懂，现学记住吧，chatgpt说：

chatgpt回答

FM（Factorization Machines，因子分解机）是一种广泛用于推荐系统和预测任务的机器学习算法。它被设计用来处理具有极大稀疏性的数据集，特别是在用户-物品交互数据中常见的那种稀疏性。

基本原理: 因子分解机模型主要是为了解决传统线性模型（如线性回归、逻辑回归）在处理大规模稀疏数据集时的不足。在传统的线性模型中，每个特征的权重是独立学习的，这使得模型难以捕捉特征间的交互作用。FM通过引入隐向量来为每个特征学习潜在的交互效应，这样可以有效地捕捉到特征之间的相互作用。
数学表示: 给定一个包含$n$个特征的数据集，FM模型的预测$\hat{y}$由下式给出：
$$
\hat{y}(\mathbf{x}) = w_0 + \sum_{i=1}^{n}w_i x_i + \sum_{i=1}^{n} \sum_{j=i+1}^{n} \langle \mathbf{v}_i, \mathbf{v}_j \rangle x_i x_j
$$
其中：

• $w_0$ 是模型的全局偏置。
• $w_i$ 是第$i$个特征的权重。
• $\mathbf{x}$ 是输入特征向量。
• $\mathbf{v}_i$ 和 $\mathbf{v}_j$ 是特征$i$和$j$的隐向量，隐向量的维度$k$通常远小于特征数量$n$。
• $\langle \mathbf{v}_i, \mathbf{v}_j \rangle$ 表示特征$i$和$j$的隐向量的点积，用于模拟这两个特征的交互效果。

优势:

1. 高效性：虽然FM模型包含二阶特征交互项，但是它可以在$O(kn)$的时间复杂度内完成计算，其中$k$是隐向量的维度，$n$是特征的数量。这种高效性主要来源于隐向量的点积运算方式，使得算法适用于大规模的数据集。

2. 灵活性：FM模型不仅适用于任何实数特征，还可以很容易地扩展到高阶交互，如三阶或更高阶的交互。

3. 泛化能力：由于特征间的交互是通过低维隐向量学习的，FM可以很好地泛化到新的、未见过的特征组合，尤其是在数据稀疏的场景下。

应用场景：

• 推荐系统：FM广泛用于推荐系统，能有效处理用户和物品的特征交互。
• 点击率预测：在线广告和搜索引擎优化中，FM可以用来预测用户点击广告或搜索结果的概率。
• 排名和分类任务：通过适当的目标函数和优化方法，FM可以适用于各种排名和分类问题。

因子分解机因其在处理稀疏数据和特征交互中的优势而被广泛研究和应用。

手写交叉熵损失

然后让写CrossEntropy，我还是没写出来，然后简单说了下公式的思想，

chatgpt回答

交叉熵损失（Cross-Entropy Loss）是用于衡量模型预测概率分布与真实标签概率分布之间的差异的一个常用损失函数。它在分类任务中特别常见，尤其是在处理二分类或多分类问题时。

交叉熵损失的公式

对于二分类问题，交叉熵损失可以表示为：

[ L = -\frac{1}{N} \sum_{i=1}^N [y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i)] ]

其中：

• ( N ) 是样本的数量。
• ( y_i ) 是第 ( i ) 个样本的真实标签，通常为 0 或 1。
• ( \hat{y}_i ) 是模型预测第 ( i ) 个样本为正类的概率。

对于多分类问题，公式扩展为：

[ L = -\frac{1}{N} \sum_{i=1}^N \sum_{c=1}^C y_{i,c} \log(\hat{y}_{i,c}) ]

其中：

• ( C ) 是类别的总数。
• ( y_{i,c} ) 是一个指示变量，如果样本 ( i ) 属于类别 ( c )，则为 1，否则为 0。
• ( \hat{y}_{i,c} ) 是模型预测第 ( i ) 个样本属于类别 ( c ) 的概率。

代码实现

如果不使用库函数，可以手动实现交叉熵损失函数。这里我们将以 Python 为例展示如何实现多分类交叉熵损失函数。这将涉及到计算模型输出的对数概率，然后根据真实标签计算损失。

二分类交叉熵损失

首先，我们从较简单的二分类交叉熵损失开始：

1
2
3
4
5
6
7
8
9
10
11
12
13

import numpy as np

def binary_cross_entropy_loss(y_true, y_pred):
    # 防止 log(0) 导致数值问题，所以加上一个非常小的值 epsilon
    epsilon = 1e-12
    y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
    loss = -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
    return loss

# 示例
y_true = np.array([0, 1, 1, 0])
y_pred = np.array([0.1, 0.9, 0.8, 0.2])
print("Binary Cross Entropy Loss:", binary_cross_entropy_loss(y_true, y_pred))

多分类交叉熵损失

对于多分类问题，我们通常使用独热编码的方式来表示真实的标签，然后计算每个类别的交叉熵损失：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

def categorical_cross_entropy_loss(y_true, y_pred):
    # 防止 log(0) 导致数值问题，所以加上一个非常小的值 epsilon
    epsilon = 1e-12
    y_pred = np.clip(y_pred, epsilon, 1.0 - epsilon)
    # 计算交叉熵
    loss = -np.sum(y_true * np.log(y_pred)) / y_true.shape[0]
    return loss

# 示例
y_true = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0], [0, 1, 0]])
y_pred = np.array([
    [0.05, 0.9, 0.05],
    [0.1, 0.1, 0.8],
    [0.7, 0.2, 0.1],
    [0.1, 0.8, 0.1]
])
print("Categorical Cross Entropy Loss:", categorical_cross_entropy_loss(y_true, y_pred))

在这些示例中，y_pred 中的值必须是有效的概率分布，即所有预测概率的和应为1，且各概率值应在0到1之间。在实际应用中，模型的输出通常通过 softmax 函数来保证这一点。np.clip 用于防止数值问题，如计算对数时输入值为0。这些实现提供了对交叉熵损失计算的直接控制，避免了依赖外部库函数的需求。

U-Net相关

我说研究方向主要是医学影像分割分类，然后面试官说前面做的这些和这个也没什么关系，然后问医学影像出了什么成果，然后我也没，然后问U-Net，我说了下，然后问U-Net的原理，我说了下，然后后上下采样是如何做的，残差连接是如何做的，我说是拼接，这块要说原理我也是说的不太清楚，也没系统准备过。

然后问那个医学影像的竞赛，说用到nnUNet了，然后介绍下，也说不清。

然后问科研医学影像现在做到什么阶段了，我就说是分割分类任务的大致框架，具体仍然说不系统。

反问

然后就是反问，我问了实习那边任务是应用还是偏科研，然后面试官说不会以发论文为目的，是算法在具体任务重应用和优化，然后就结束了。

总结

总之这个面试是最差的一次，属于是项目没啥东西被拷打，后面问八股我也一点没准备，直接凉透，面完直接胳膊下面全是汗，湿透了，估计是凉了，不过也是一次经验，以后要多准备一些基础知识，吃一堑长一智，加油吧。

最后补个学习的内容：算法工程师面试常考手撕题

引用链接https://mp.weixin.qq.com/s/TAFvUlqdyqP-W6C10F1Hzw

• 算法工程师面试常考手撕题
  • 注意力（Attention）篇
    • 手撕单头注意力机制（ScaledDotProductAttention）函数
    • 手撕多头注意力（MultiHeadAttention）
    • 手撕自注意力机制函数（SelfAttention）
    • GPT2 解码中的KV Cache
    • 手撕 MQA 算法
  • 基础机器学习算法篇
    • 手撕 numpy写线性回归的随机梯度下降（stochastic gradient descent，SGD）
    • 手撕 k-means 算法
  • 手撕 Layer Normalization 算法
  • 手撕 Batch Normalization 算法
  • 解码算法篇
    • 手撕 贪心搜索 （greedy search）
    • 手撕 集束搜索 beamsearch 算法
    • 手撕 温度参数采样（Temperature Sampling）算法
    • 手撕 Top-K Sampling算法
    • 手撕 Top-P (Nucleus) Sampling 算法
  • 神经网络篇
    • 手撕反向传播(backward propagation，BP)法
    • 手撕 卷积神经网络(CNN)法
    • 手撕 循环神经网络(RNN)法
    • 手撕 LSTM法
    • 手撕 二维卷积 算法
  • 位置编码篇
    • 手撕 绝对位置编码 算法
    • 手撕 可学习位置编码 算法
    • 手撕 相对位置编码 算法
    • 手撕 rope 算法
  • 面试题汇总
  • 致谢

注意力（Attention）篇

手撕单头注意力机制（ScaledDotProductAttention）函数

输入是query和 key-value，注意力机制首先计算query与每个key的关联性（compatibility），每个关联性作为每个value的权重（weight），各个权重与value的乘积相加得到输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class ScaledDotProductAttention(nn.Module):
    """ Scaled Dot-Product Attention """


    def __init__(self, scale):
        super().__init__()


        self.scale = scale
        self.softmax = nn.Softmax(dim=2)


    def forward(self, q, k, v, mask=None):
        u = torch.bmm(q, k.transpose(1, 2)) # 1.Matmul
        u = u / self.scale # 2.Scale


        if mask is not None:
            u = u.masked_fill(mask, -np.inf) # 3.Mask


        attn = self.softmax(u) # 4.Softmax
        output = torch.bmm(attn, v) # 5.Output


        return attn, output




if __name__ == "__main__":
    n_q, n_k, n_v = 2, 4, 4
    d_q, d_k, d_v = 128, 128, 64


    q = torch.randn(batch, n_q, d_q)
    k = torch.randn(batch, n_k, d_k)
    v = torch.randn(batch, n_v, d_v)
    mask = torch.zeros(batch, n_q, n_k).bool()


    attention = ScaledDotProductAttention(scale=np.power(d_k, 0.5))
    attn, output = attention(q, k, v, mask=mask)


    print(attn)
    print(output)

手撕多头注意力（MultiHeadAttention）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

class MultiHeadAttention(nn.Module):
    """ Multi-Head Attention """


    def __init__(self, n_head, d_k_, d_v_, d_k, d_v, d_o):
        super().__init__()


        self.n_head = n_head
        self.d_k = d_k
        self.d_v = d_v


        self.fc_q = nn.Linear(d_k_, n_head * d_k)
        self.fc_k = nn.Linear(d_k_, n_head * d_k)
        self.fc_v = nn.Linear(d_v_, n_head * d_v)


        self.attention = ScaledDotProductAttention(scale=np.power(d_k, 0.5))


        self.fc_o = nn.Linear(n_head * d_v, d_o)


    def forward(self, q, k, v, mask=None):


        n_head, d_q, d_k, d_v = self.n_head, self.d_k, self.d_k, self.d_v


        batch, n_q, d_q_ = q.size()
        batch, n_k, d_k_ = k.size()
        batch, n_v, d_v_ = v.size()


        q = self.fc_q(q) # 1.单头变多头
        k = self.fc_k(k)
        v = self.fc_v(v)
        q = q.view(batch, n_q, n_head, d_q).permute(2, 0, 1, 3).contiguous().view(-1, n_q, d_q)
        k = k.view(batch, n_k, n_head, d_k).permute(2, 0, 1, 3).contiguous().view(-1, n_k, d_k)
        v = v.view(batch, n_v, n_head, d_v).permute(2, 0, 1, 3).contiguous().view(-1, n_v, d_v)


        if mask is not None:
            mask = mask.repeat(n_head, 1, 1)
        attn, output = self.attention(q, k, v, mask=mask) # 2.当成单头注意力求输出


        output = output.view(n_head, batch, n_q, d_v).permute(1, 2, 0, 3).contiguous().view(batch, n_q, -1) # 3.Concat
        output = self.fc_o(output) # 4.仿射变换得到最终输出


        return attn, output




if __name__ == "__main__":
    n_q, n_k, n_v = 2, 4, 4
    d_q_, d_k_, d_v_ = 128, 128, 64


    q = torch.randn(batch, n_q, d_q_)
    k = torch.randn(batch, n_k, d_k_)
    v = torch.randn(batch, n_v, d_v_)    
    mask = torch.zeros(batch, n_q, n_k).bool()


    mha = MultiHeadAttention(n_head=8, d_k_=128, d_v_=64, d_k=256, d_v=128, d_o=128)
    attn, output = mha(q, k, v, mask=mask)


    print(attn.size())
    print(output.size())

手撕自注意力机制函数（SelfAttention）

Self-Attention。和Attention类似，他们都是一种注意力机制。不同的是Attention是source对target，输入的source和输出的target内容不同。例如英译中，输入英文，输出中文。而Self-Attention是source对source，是source内部元素之间或者target内部元素之间发生的Attention机制，也可以理解为Target=Source这种特殊情况下的注意力机制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

class SelfAttention(nn.Module):
    """ Self-Attention """


    def __init__(self, n_head, d_k, d_v, d_x, d_o):
        self.wq = nn.Parameter(torch.Tensor(d_x, d_k))
        self.wk = nn.Parameter(torch.Tensor(d_x, d_k))
        self.wv = nn.Parameter(torch.Tensor(d_x, d_v))


        self.mha = MultiHeadAttention(n_head=n_head, d_k_=d_k, d_v_=d_v, d_k=d_k, d_v=d_v, d_o=d_o)


        self.init_parameters()


    def init_parameters(self):
        for param in self.parameters():
            stdv = 1. / np.power(param.size(-1), 0.5)
            param.data.uniform_(-stdv, stdv)


    def forward(self, x, mask=None):
        q = torch.matmul(x, self.wq)   
        k = torch.matmul(x, self.wk)
        v = torch.matmul(x, self.wv)


        attn, output = self.mha(q, k, v, mask=mask)


        return attn, output




if __name__ == "__main__":
    n_x = 4
    d_x = 80


    x = torch.randn(batch, n_x, d_x)
    mask = torch.zeros(batch, n_x, n_x).bool()


    selfattn = SelfAttention(n_head=8, d_k=128, d_v=64, d_x=80, d_o=80)
    attn, output = selfattn(x, mask=mask)


    print(attn.size())
    print(output.size())

GPT2 解码中的KV Cache

无论是encoder-decoder结构，还是现在我们最接近AGI的decoder-only的LLM，解码生成时都是自回归auto-regressive的方式。
也就是，解码的时候，先根据当前输入 ，生成下一个 ，然后把新生成的 拼接在 后面，获得新的输入 ，再用 生成 ，依此迭代，直到生成结束。
我们可以注意到，下一个step的输入其实包含了上一个step的内容，而且只在最后面多了一点点（一个token）。那么下一个step的计算应该也包含了上一个step的计算。
但是模型在推理的时候可不管这些，无论你是不是只要最后一个字的输出，它都把所有输入计算一遍，给出所有输出结果。
也就是说中间有很多我们用不到的计算，这样就造成了浪费。
而且随着生成的结果越来越多，输入的长度也越来越长，上面这个例子里，输入长度就从step0的10个，每步增长1，直到step5的15个。如果输入的instruction是让模型写作文，那可能就有800个step。这个情况下，step0被算了800次，step1被算了799次…这样浪费的计算资源确实不容忽视。
有没有什么办法可以重复利用上一个step里已经计算过的结果，减少浪费呢？
答案就是KV Cache，利用一个缓存，把需要重复利用的中间计算结果存下来，减少重复计算。
而 k 和 v 就是我要缓存的对象。
想象一下，在上面的例子中，假设我们一开始的输入就是3个字，我们第一次预测就是预测第4个字，那么由于一开始没有任何缓存，所有我们每一层还是要老实地计算一遍。然后把 k 、 v 值缓存起来。
则有

kv cache的下标l表示模型层数。
在进行第二次预测，也就是预测第5个字的时候，在第l层的时候，由于前面我们缓存了每层的ku 值，那本层就只需要算新的 o3，而不用算 o0、o1、o2。
因为第l层的 o0、o1、o2本来会经过FNN层之后进到 l十1 层，再经过新的投影变换，成为 l + 1 层的 k、υ 值，但是l十 1 层的 k、υ值我们已经缓存过了!
然后我们把本次新增算出来的 k、υ 值也存入缓存。

这样就节省了attention和FFN的很多重复计算。
transformers中，生成的时候传入use_cache=True就会开启KV Cache。
也可以简单看下GPT2中的实现，中文注释的部分就是使用缓存结果和更新缓存结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64