[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"$f8j56jrMVcSyTFYwjClXqoiVUVJfRrgYCMJmVMIJhBOA":3,"$fti1CSE9eMya3xJaamd_A4p_lPFMUq68Ld9Vl4rn6U68":52},[4],{"id":5,"type":6,"title":7,"slug":8,"summary":9,"body":10,"coverUrl":11,"productScreenshots":12,"productLinks":13,"authorName":14,"authorUrl":15,"authorSubject":16,"category":17,"tags":22,"sourceLabel":43,"sourceName":44,"sourceUrl":44,"status":45,"seoTitle":44,"seoDescription":44,"canonicalUrl":44,"isFeatured":46,"sno":47,"sortOrder":48,"publishedAt":49,"updatedAt":50,"createdAt":51},"14a78d02-d08a-4cc1-b4b4-5f86f632d90c","article","DeepSeek-V4-Flash：跑得快没奖励，跑得慢有惩罚","deepseek-v4-flash","DeepSeek-V4-Flash 正式版，是怎么把整个 AI 行业逼到墙角的","2026 年 7 月 31 日下午，DeepSeek 干了一件很\"DeepSeek\"的事。\n\n没有发布会，没有倒计时海报，没有 CEO 站在聚光灯下说\"这是我们迄今为止最激动人心的模型\"。他们只是在 API 文档的更新日志里，**加了一行字**：DeepSeek-V4-Flash 正式版 API 上线公测。\n\n然后全球开发者社区就炸了。\n\n有意思的是，就在前一天，OpenAI 刚刚紧急宣布 GPT-5.6 Luna 全线降价 80%——上线才三周的模型，输入价格从 1 美元砍到 0.2 美元，输出从 6 美元砍到 1.2 美元。这个时间点巧得让人起疑：一边是硅谷连夜挥刀自砍，一边是杭州轻描淡写更新日志。\n\n结果是：**OpenAI 砍完 80% 之后，跑同样的任务，还是比 DeepSeek 贵大约 60%。**\n\n这就很尴尬了。\n\n## 模型没换，脑子换了\n\n在讲行业影响之前，得先把技术上那个\"反直觉\"的点说清楚，因为它是后面一切的地基。\n\n**V4-Flash 正式版（版本号 0731），和 4 月发的预览版，是同一个模型。**\n\n不是\"架构微调\"，不是\"扩了点参数\"，是**完全一样**：\n\n| 项目 | V4-Flash-Preview（4月） | V4-Flash-0731（正式版） |\n|---|---|---|\n| 总参数 | 2840 亿 | 2840 亿 |\n| 激活参数 | 130 亿 | 130 亿 |\n| 架构 | MoE | MoE |\n| 上下文 | 100 万 token | 100 万 token |\n| 价格 | 输入 $0.14 \u002F 输出 $0.28 | **一分钱没涨** |\n\n那到底改了什么？官方说得很朴素：**重新做了一遍后训练（Post-Training）。**\n\n就这。骨架没动，发动机没换，只是重新调了一遍油路和电控。\n\n然后成绩单变成了这样：\n\n| 基准测试 | 预览版 | 正式版 | 变化 |\n|---|---|---|---|\n| **DeepSWE**（真实代码仓库修复） | 7.3 | **54.4** | 涨了 **6 倍多** |\n| **Terminal Bench 2.1**（终端连续操作） | 61.8 | **82.7** | +20.9 |\n| Cybergym（网络安全攻防） | — | 76.7 | — |\n| Toolathlon Verified（多工具协同） | — | 70.3 | — |\n| DSBench-FullStack（全栈开发） | — | 68.7 | — |\n| DSBench-Hard（高难编码） | — | 59.6 | — |\n\nDeepSWE 从 7.3 涨到 54.4 是什么概念？打个不太严谨的比方：一个学生上学期期末考 7 分，这学期考了 54 分，中间他没换脑子、没补课本，只是**终于学会了怎么答题**。\n\n更炸裂的是横向对比。官方公布的**九项 Agent 与代码基准，V4-Flash 正式版全部超过了自家的 V4-Pro 预览版**——那个总参数 1.6 万亿、激活 490 亿的旗舰。\n\n也就是说：**用 Pro 六分之一的总参数、不到四分之一的激活参数，把自家旗舰按在地上摩擦。** 在 DeepSWE 这一项上，分差高达 41.6 分。\n\n行业里\"Pro 强、Flash 弱\"的分层信仰，当场碎了一地。\n\n### 这说明了什么？\n\n一个被严重低估的事实：**预训练决定能力上限，后训练决定这个上限能兑现多少。**\n\n过去两年，所有人都在卷预训练——卷参数、卷算力、卷数据量。2026 年上半年更是进入\"万亿参数时代\"：4 月 DeepSeek V4-Pro 预览版 1.6 万亿开局，7 月阿里 Qwen 3.8-Max 推到 2.4 万亿，同月月之暗面 Kimi K3 以 2.8 万亿登顶开源模型规模之王。\n\n大家默认的逻辑是：**更大 = 更强**。\n\nV4-Flash-0731 说：不一定。它在 4 月的时候，脑子里其实**已经装着**这些能力了，只是不知道怎么用。后训练做的事情，是教它\"打开终端 → 调用工具 → 改代码 → 跑测试 → 修 Bug → 继续改\"这套 Agent 完整链路——从\"回答问题\"变成\"完成任务\"。\n\n同时首次亮相的还有 DeepSeek 自研的 Agent 测试框架 **DeepSeek Harness**，用极简模式跑分。工程侧的优化和训练侧的优化产生了协同效应。\n\n用一位分析师的说法：**AI 发展不只需要大力出奇迹，还得慢工出细活。**\n\n## 真正的核弹：价格表\n\n技术上的惊喜是\"哇好厉害\"，价格上的冲击才是\"卧槽这怎么活\"。\n\n**V4-Flash 正式版定价（每百万 Token）：**\n\n| 类型 | 美元 | 人民币 |\n|---|---|---|\n| 输入（缓存未命中） | $0.14 | 约 1 元 |\n| 输入（缓存命中） | $0.0028 | 约 0.02 元 |\n| 输出 | $0.28 | 约 2 元 |\n\n注意那个**缓存命中价**：0.02 元\u002F百万 Token。缓存折扣高达 **98%**，而行业大多数厂商是 90%。在 Agent 场景下——固定系统提示词反复复用、多轮工具调用——这个折扣是能吃满的。\n\n现在把它和\"厉害的那些\"放一起：\n\n| 模型 | 输入（$\u002FM） | 输出（$\u002FM） | 智能指数 (AAII) |\n|---|---|---|---|\n| **DeepSeek V4-Flash** | **0.14** | **0.28** | **50** |\n| GPT-5.6 Luna（已降价80%） | 0.20 | 1.20 | 51 |\n| Anthropic Haiku 4.5 | 1.00 | 5.00 | — |\n| Claude Opus 4.8 | — | 约 **85 倍** V4-Flash | 约 56 |\n| Gemini 3.6 Flash | — | — | 50（打平） |\n\n第三方评测机构 **Artificial Analysis** 给 V4-Flash 的智能指数打了 **50 分**，比自己上一代高 10 分，比 V4-Pro 预览版高 6 分，追平 Gemini 3.6 Flash，**只落后 GPT-5.6 Luna 一分**。\n\n而在 ALE 基准上，V4-Flash 和全球顶级的 **Claude Opus 4.8 只差半分**。\n\n半分。价格差 85 倍。\n\n再翻译一遍：**Opus 多拿了那 6 分综合智能，但跑完同一套评测的账单，高出约 52 倍。**\n\n这已经不是性价比的差距了，这是**计量单位级别的错位**。就像有人跟你比谁跑得快，你报的是\"秒\"，他报的是\"分钟\"。\n\n### 开发者的真实账单，比参数表更有说服力\n\n跑分终究是实验室数据，真正让海外开发者集体破防的，是他们自己刷卡时看到的数字：\n\n- **@tonbistudio**：整整一天，用 V4-Flash 跑了一堆多小时的复杂任务，**总共花了 0.31 美元**。而上周同样的任务用 Kimi K3 之类的模型，花了 **35 美元**。\"剧透一下：贵的那些也没强 100 倍。\"\n- **@CommandCodeAI**：同一个游戏设计提示词，Kimi K3 单次调用 0.0740 美元，GLM 5.2 是 0.0480 美元，**V4-Flash 是 0.0005 美元——便宜 150 倍**。（诚实地说，V4-Flash 在边缘细节上确实糙了点。）\n- **@SciTechera**：在 Terminal-Bench 2.1 上完成单个基准任务，**估算成本 0.03 美元**。\n- **@RoundtableSpace**：对比刚发布的 Opus 5——Opus 一次成功，DeepSeek 试了三次。但 **Opus 输出了 3000 行代码，DeepSeek 用约 900 行就搞定了，单次成本约 1 美分。**\n\n最后这条特别有意思：贵的模型一次搞定，便宜的模型试三次。但便宜的模型试三次的总成本，还不到贵模型的百分之一——而且代码更精简。\n\n**在 Agent 时代，\"一次做对\"不再是唯一的美德，\"错了也无所谓，反正重来一次只要一分钱\"变成了一种全新的工程哲学。**\n\nBold Metrics 的 CTO Morgan Linton 说得更直白：对于需要成千上万次 API 调用的工业级 Agent 工作流，**这种价格让\"大批量自动化试错\"第一次具备了财务可行性。**\n\n以前你不敢让 AI 反复尝试，因为每一次尝试都在烧钱。现在你可以了。这不是省钱，这是**换了一种做事方式**。\n\n## \"斩杀线\"：这个词是怎么来的，又为什么这么准\n\n发布之后，中英文社区不约而同地造出了同一个概念。\n\n中文叫**斩杀线**，英文叫 **Kill Line**。\n\n它的定义特别精确，值得逐字读：\n\n> **斩杀线不是性能分水岭，而是性能与价格的平衡临界值。**\n>\n> - 同一能力梯队中，定价显著高于 DeepSeek 的模型，将持续流失中小开发者；\n> - 性能弱于 DeepSeek、成本却更高的产品，生存空间快速萎缩。\n\n北京市社会科学院副研究员王鹏在接受《环球时报》采访时的表述更简洁：**Codex 和 Claude 划定上限，DeepSeek 划定\"斩杀线\"——追平它，你就没有溢价空间了；落后它，你就出局了。**\n\n这就回到了本文开头那句话。用一个游戏化的说法：\n\n### **跑得快没奖励，跑得慢有惩罚**\n\n这是一个残酷到近乎优雅的博弈结构：\n\n**如果你比 DeepSeek 强一点点（跑得快）：**\n- 你得证明\"多出来的那几分能力\"，值得客户多付 50 倍的钱\n- 但 80% 的日常任务根本用不上那几分\n- 所以你拿不到与投入成正比的市场份额 → **没奖励**\n\n**如果你比 DeepSeek 弱、还比它贵（跑得慢）：**\n- 你没有任何存在的理由\n- 中小开发者用脚投票，一夜之间迁移完毕\n- → **有惩罚，而且是死刑**\n\n**如果你和它差不多贵、差不多强：**\n- 恭喜，你成了一个可被随时替换的商品（commodity）\n\n海外社区把这个感受表达得更生动。X 用户 @FoxRick01 说：\n\n> \"Anthropic 被 Codex 打了一整周，现在又被便宜 100 倍的 DeepSeek 打。他们现在看起来像是**卖菲亚特、收法拉利价钱的销售员**。\"\n\n于是\"**法拉利的性能，自行车的价格**\"成了这次发布的标志性调侃。\n\n一位从事 AI 创业孵化的人士说得更狠：\n\n> \"梁文锋似乎站在了市面上所有模型玩家的对立面。所有 AI 公司都在他前面奔跑——不管用什么方式，**它们必须跑到 DeepSeek 前面，才能活着**。\"\n\n## 48 小时之内，整个行业开始重新算账\n\n嘴上说说是一回事，Token 流向是另一回事。数据不会撒谎。\n\n### 调用量：一个模型，打赢了一群模型\n\nOpenRouter（全球最大的模型聚合平台）7 月 27 日 – 8 月 2 日的周度数据：\n\n| 排名 | 模型 | 周调用量 |\n|---|---|---|\n| 🥇 1 | **DeepSeek-V4-Flash** | **7.22 万亿 Token** |\n| 🥈 2 | 小米 MiMo-V2.5 | 6.30 万亿 |\n| 🥉 3 | 腾讯 HY3 | 4.82 万亿 |\n| 4 | DeepSeek-V4-Pro | 3.28 万亿 |\n| 5 | 智谱 GLM-5.2 | 2.89 万亿 |\n\n**前五名，全部是中国模型。**\n\n再看总量：全球总调用 56.8 万亿 Token，其中上榜的中国大模型周调用量 **28.13 万亿**，美国大模型 **4.38 万亿**。中国模型的周调用量已经**连续 14 周**超过美国。\n\n编程平台 OpenCode 的 CEO Jay 在 8 月 1 日发文：V4-Flash 上线后，平台**单日调用量增长 30%**，OpenCode Go 的新订阅用户也增长了 **30%**。\"DeepSeek 一天消耗 8 万亿\"直接冲上热搜——不是烧掉 8 万亿资金，是单日处理 8 万亿 Token。\n\n**单一模型、单一入口的单日消耗，超过了海外数百款模型加起来的日均总和。**\n\n### 硅谷的反应：连夜改价格表\n\n这波价格战的猛烈程度，是 AI 史上前所未见的：\n\n| 厂商 | 动作 |\n|---|---|\n| **OpenAI** | GPT-5.6 Luna 降价 **80%**（上线仅三周）；Terra 降 20%；旗舰 Sol 维持不动 |\n| **Anthropic** | Claude Opus 5 降价 |\n| **Google** | 推出低价 Gemini Flash 系列应对 |\n| **Mistral** | 重新调整商业化方案，靠开源免费 + 云端优惠守住开发者盘 |\n| **中小开源服务商** | 被迫重算成本，放弃\"靠 API 毛利盈利\"的幻想 |\n\nOpenAI 的策略写在脸上：**旗舰 Sol 的溢价一分不让，用中低端产品的激进降价，拦截客户流失。** 保住高端护城河，把中端市场当防线来打。\n\n问题是——这条防线，砍完 80% 之后依然比 DeepSeek 贵 60%。\n\n### 企业侧：Token 经济学的崩塌\n\n真正的压力其实来自更早，V4-Flash 只是压垮骆驼的最后一根稻草：\n\n- **Uber**：5000 名工程师中 84% 启用了 Agent 式编码，人均月度 API 成本飙到 500–2000 美元区间，**四个月烧光全年 AI 预算**。CTO Praveen Neppalli Naga 坦言\"原定预算已被彻底击穿\"。\n- **Lindy**（旧金山，25 人 AI 创业公司）：把 **100% 的流量**从 Anthropic 全面切向 DeepSeek，预计省下数百万美元。\n- **微软**：悄悄把 DeepSeek 塞进了 Copilot 底层引擎的评估名单。\n- **CNBC 调查**：自 2026 年 2 月 8 日起，中国模型在 OpenRouter 上的**美国企业** Token 用量占比每周稳定在 30% 以上，峰值 **46%**。\n\n为什么企业撑不住了？因为 Agent 改变了消耗结构。OpenRouter 数据显示：**Agent 式工作流每个请求的 Token 消耗量，是人机对话的 15 倍。**\n\n一个看似简单的自然语言指令，实际要拆解成：意图理解 → 环境感知 → 文件检索 → 工具调用 → 代码生成 → 自我修正 → 再来一遍。**乘数效应瞬间放大 Token 消耗。**\n\n在这个结构下，单价的微小差异会被放大成账单上的天文数字。于是\"能力溢价\"的旧范式，输给了\"成本效率\"的新范式。\n\n## 它到底扮演什么角色？\n\n聊到这里，可以给 V4-Flash 在 AI 产业里的位置下个判断了。它不是\"最强模型\"，也不只是\"最便宜的模型\"，它同时扮演着三个更微妙的角色。\n\n### 角色一：定价的\"锚\"，而不是性能的\"顶\"\n\n顶不是它的。上限依然由 Claude Opus 4.8、GPT-5.6 Sol、Kimi K3 这些巨兽划定。\n\n但**底**是它划的。而且这个底一旦划下来，就变成了所有人的参照系。\n\n这才是最要命的地方：**一个定价锚点，比一个性能冠军更能改变行业结构。** 性能冠军只影响\"最难的那 5% 任务\"，定价锚点影响\"所有任务\"。\n\nDeepSeek 走的也不是烧钱补贴的路子。它的低价来自底层工程优化——高效推理架构、动态 KV 缓存、流量峰谷调度、长文本优化——是把成本真的做下来了，不是亏钱换市场。这意味着这条线**不会因为补贴结束而回弹**。\n\n《财富》杂志还指出，V4 系列的研发与华为底层芯片生态做了紧密适配。随着昇腾系列软硬件协同效率提升，**推理成本还有进一步下探空间**。\n\n### 角色二：默认选项的重新分配者\n\n\"斩杀线\"真正斩掉的，不是所有高端模型，而是——\n\n> **对旗舰模型\"不计成本\"的默认调用习惯。**\n\n这句话值得再读一遍。\n\n以前的工作流是：默认上最强的，反正能力越强越保险。\n现在的工作流是：**先问一句，这活儿真的需要旗舰吗？**\n\n写一段代码、改一份文案、整理会议纪要、跑一轮自动化测试——先交给低成本且完成率足够的模型；只有遇到复杂推理、长链路 Agent、高风险场景，才升级到昂贵旗舰。\n\n**高价模型仍然有位置，但它必须证明：多出来的那点能力差距，足以覆盖多出来的调用成本。**\n\n这就是\"跑得快没奖励\"的精确含义——不是快没用，而是**快的边际收益，被巨大的边际成本吃掉了**。\n\n一个合理的生产架构长这样：\n\n```\n┌─────────────────────────────────────────┐\n│  80% 高频常态任务  →  V4-Flash（$0.28\u002FM）│\n│  ├─ 代码补全、重构、测试                  │\n│  ├─ 终端运维、批量处理                    │\n│  └─ 文本分类、格式转换                    │\n├─────────────────────────────────────────┤\n│  15% 中等复杂任务  →  中端模型 \u002F Flash高档 │\n├─────────────────────────────────────────┤\n│  5%  极难推理任务  →  Opus \u002F Sol \u002F K3     │\n│  └─ 高难算法、长逻辑链、高风险决策         │\n└─────────────────────────────────────────┘\n```\n\n一位开发者的实践更精妙：V4-Flash 目前不支持原生视觉输入，于是 **@hqmank** 先让 Kimi K3 读参考图、提取布局与颜色规范，再把结构化文本交给 V4-Flash 生成代码。布局与间距还原得不错，**整体成本远低于全程调用顶级多模态模型**。\n\n跨模型组合，正在成为一门新手艺。\n\n### 角色三：AI 普惠的\"降门槛器\"\n\n这一层可能是最被低估的。\n\n天风证券计算机团队在发布当天给出\"大超预期\"的定调，并做了一个反常识的判断：**看好软件公司受益**。\n\n反常在哪？过去市场普遍认为 AI 模型越强，越利空 SaaS 类企业——AI 会把它们吃掉。\n\n但现在逻辑反过来了：**DeepSeek 的性价比已经足够让软件公司自己用起来提效**。更重要的是，那些过去因为 Token 账单太贵而不敢碰 AI 的公司，现在可以开发高性价比的 AI 服务了。**过去无法被满足的 Agent 需求，第一次变成了可以被满足的。**\n\n0xSupergemma 创始人宋骏从全球经济视角补了一刀：全球有大量低收入群体和初创团队，根本负担不起高昂的模型订阅费。DeepSeek 极低的 API 定价，会**通过下游开发者转化成极便宜的 SaaS 工具与服务**，让更广泛的终端用户间接享受技术红利。\n\n一位微博用户的比喻更远：AI 最终可能不是一个独立工具，而是像**电力**一样的基础设施层——嵌入工厂、医院、车辆、办公系统，成为每个行业的默认能力。它最大的影响，也许不是给人们又一个聊天机器人，而是提供了重塑社会运作方式的算力底座。\n\n而电力普及的前提，从来都是**便宜**。\n\n## 并不万能\n\nV4-Flash 的边界同样清晰，而且比很多人想象的明显。\n\n### 1. 硬推理能力，差距是真实存在的\n\n- **HLE**（博士级推理基准）：V4-Flash **8.1%**，Claude Sonnet 5 是 **57.4%**。这不是差一点，这是差一个物种。\n- 在那九项它\"全面反超 Pro\"的基准上，**它依然全部输给 Claude Opus 4.8**，平均落后 5.7 分。仓库生成类任务上，差距超过 15 分。\n- 开发者 @OmedVibeCodes 实测：面对 GPT-5.6 Sol、Kimi K3 这类顶级模型，V4-Flash 在**极其复杂的长逻辑链求解**上仍有明显差距。\n\n所以那句\"厉害的没它便宜，也没厉害多少\"——**在 80% 的日常任务上成立，在最后 5% 的硬骨头上，不成立。**\n\n### 2. 跑分本身要打折看\n\n- 九项基准是 **DeepSeek 自己报的**，用的是自研的 DeepSeek Harness 框架，**该框架尚未公开**，目前无法独立复现。\n- 第三方复现显示，Terminal-Bench 分数与厂商自报值有约 **4 分**的差距。\n- Terminal Bench 2.0 与 2.1 并非同一版本，直接跨版本对比不完全公平。\n- 公开基准存在过拟合风险，**跑分 ≠ 真实业务表现**。\n\n### 3. 工程上的坑\n\n- 部分海外开发者反映：**输入缓存命中率偏低、安全分类器经常超时**。这在一定程度上说明，算力和参数储备不足，仍然是能力上限的瓶颈。\n- **98% 的缓存折扣是平台机制口径，不是你的实际成本。** 真实命中率取决于 prompt 前缀复用率——Agent 多轮调用、固定系统提示的场景容易吃满；一对一开放式对话可能差得很远。别拿\"成本低 60%\"直接套自家预算。\n- **峰谷差异化定价**：官方公布高峰时段（北京时间 9:00–12:00、14:00–18:00）价格会上浮。对欧美时区团队，这对应的是美东晚上 9 点至凌晨、凌晨 2–6 点，成本模型需要重算。\n- **Artificial Analysis 测出它比较\"话痨\"**：跑完整个智能指数消耗 2.06–2.1 亿输出 Token，而中位数约 1 亿。单价便宜但输出更多，实际账单要按 token 总量算，不能只看单价。\n- **暂不支持原生视觉输入**，图文混排任务需要外部模型前置解析。\n- 目前**仅 API 开放**，App 和网页端还用不上，普通用户暂时体验不到。\n\n### 4. 也别把\"Scaling Law 失灵\"当结论\n\n这可能是最容易被误读的一点。\n\n看到\"2840 亿打赢 1.6 万亿\"，很容易得出\"规模法则失效了\"的结论。但没人真的这么认为——包括 DeepSeek 自己。\n\n梁文锋在一份流传甚广的融资会议纪要中说得很明确：\n\n> \"**规模法则远未到上限，国内模型规模受限只是算力不足，不是规律走到尽头。**\"\n\n但他补了一句关键的：**规模不再是唯一杠杆，思维链和智能体将会是下一个杠杆。**\n\n市场也是这么反应的：V4-Flash 上线后，英伟达、博通、AMD 在 7 月 31 日的股价**并未出现剧烈波动**。这和 2025 年 1 月 R1 发布后英伟达单日蒸发 5000 亿美元市值形成鲜明对比。\n\n市场已经学会了：**AI 工程效率的提升，不是算力需求的利空。** 摩根大通的判断是，DeepSeek 强化了\"算力供应扩张、定价纪律、结构性成本曲线压缩\"三大支柱，对行业是**顺风，不是零和**。\n\n便宜了，用得起的人多了，总消耗反而涨了。这就是杰文斯悖论在 AI 上的演绎。\n\n### 5. 一个未解的插曲\n\n正在小范围灰度的 V4-Pro 正式版，有部分开发者反馈其生成的复杂代码风格与某些高价旗舰模型相似，甚至触发过疑似特定模型的安全拒绝响应，引发\"是否使用了混合路由\"的猜测。社区调侃为\"**矿泉水瓶里掺茅台**\"。\n\n需要说明：这些目前**都是社区反馈，官方尚无进一步复现说明**。技术专家 @TeksCreate 从架构层面分析认为，V4-Pro 的 1.6 万亿 MoE 架构 + 混合注意力系统（CSA 历史压缩 + HCA 超长文本压缩 + SWA 全保真跟踪），使处理 100 万上下文时计算量降至前代 27%，本身就具备达到该水平的技术条件（Codeforces 3206 分、SWE-bench Verified 80.6%、1M 长上下文 MRCR 83.5%）。\n\n真相如何，等官方回应。\n\n## 一台永不停止的收割机\n\n回到最开始那句话。\n\n> **便宜的模型没它厉害，厉害的模型没它便宜，也没厉害多少。**\n> **跑得快没奖励，跑得慢有惩罚。**\n\n这句话之所以精准，是因为它描述的不是一个模型，而是**一种市场结构**。\n\n在这个结构里，DeepSeek V4-Flash 不是赛道上跑得最快的那个选手。它是**站在赛道中间，用一根杆子把及格线抬到所有人头顶**的那个人。\n\n你比它快？恭喜，但观众不一定为那点速度买单。\n你比它慢？抱歉，出局。\n你和它一样快、一样便宜？那你就是个可替代品。\n\n有人调侃：\"梁文锋的 DeepSeek 成了一台永不停止的收割机。\"\n\n某种程度上，这句话对每个人都成立——它收割的是行业的定价权，是\"AI 就该很贵\"的默认假设，也是所有靠信息差和成本不透明赚的钱。\n\n但换个角度看，被\"收割\"掉的这些，本来也不该由用户来承担。\n\n**2025 年春天，DeepSeek 让世界重新思考\"AI 需要多少算力\"。**\n**2026 年夏天，它让世界重新思考\"AI 应该卖多少钱\"。**\n\n这两个问题，最终指向的是同一件事：**智能，究竟应该属于少数人，还是属于所有人。**\n\n至于这条斩杀线会不会被别人越过——\n\nKimi K3 的 2.8 万亿参数还在那儿，Qwen 3.8-Max 的 2.4 万亿也在那儿，V4-Pro 正式版还没发布，OpenAI 的刀刚砍完第一轮。\n\n**没人知道下一个 48 小时会发生什么。这大概就是 2026 年的 AI 行业最有意思的地方。**\n\n### 主要资料来源\n\n- DeepSeek 官方 API 文档更新日志（2026-07-31）\n- 21 世纪经济报道《DeepSeek 又发重磅更新，行业梦回 2025 年春天》\n- Global Times《DeepSeek V4 Flash hailed as 'Ferrari at bicycle prices'》\n- 凤凰网科技《口碑持续逆转，DeepSeek 成全球 AI 斩杀线》\n- 网易科技《DeepSeek V4 Flash 刷屏海外，\"像魔法一样\"的 AI，只卖几分钱》\n- 新浪财经《85 倍价差：DeepSeek 逼着硅谷巨头重算\"性价比\"》\n- TechFlow《OpenAI 上线三周降价 80%》、CNBC 相关调查报道\n- 北京日报、环球网、潮新闻、太平洋科技相关报道\n\n> *本文数据截至 2026 年 8 月 5 日。基准测试分数多为厂商自报或第三方初步评测，实际业务表现请以自有场景实测为准。价格随时可能变动，决策前请核对官方最新定价。*","\u002Fuploads\u002F2026-08-05\u002Fc4b0e276-bfcb-4796-8da7-aa8ff5df8253.jpg",[],[],"Foundit AI","https:\u002F\u002Ffoundit.cn","f39339b1-aaa6-4e86-b0c2-a6e6a21113b5",{"id":18,"name":19,"slug":20,"description":21},"8649729c-92bf-4ec7-b98b-3bae4271318b","思考","thought","从项目或实操经验中延伸出的思考",[23,27,31,35,39],{"id":24,"name":25,"slug":26},"a2ccffe0-49b2-458b-baf6-a83a1b20443d","大语言模型","llm",{"id":28,"name":29,"slug":30},"63b56667-dcdb-4b8b-bcbe-c405143a7ec2","测评","test",{"id":32,"name":33,"slug":34},"144abe77-0dc6-4f66-a176-20bddb1c0bfa","编程","coding",{"id":36,"name":37,"slug":38},"7c76bfc2-f80f-4ee0-a95d-27bd8708b434","技术","slug",{"id":40,"name":41,"slug":42},"4c2bbea6-eab7-40a8-8447-1de478ff7749","分析","analyse","资料来源",null,"published",true,1,0,"2026-08-05T00:00:00.000Z","2026-08-05T04:10:26.142Z","2026-08-05T03:24:39.350Z",[53,80,104],{"id":54,"type":6,"title":55,"slug":56,"summary":57,"body":58,"coverUrl":59,"productScreenshots":60,"productLinks":61,"authorName":62,"authorUrl":63,"authorSubject":16,"category":64,"tags":65,"sourceLabel":44,"sourceName":44,"sourceUrl":44,"status":45,"seoTitle":44,"seoDescription":44,"canonicalUrl":44,"isFeatured":46,"sno":76,"sortOrder":48,"publishedAt":77,"updatedAt":78,"createdAt":79},"63c04eca-1ea9-4eca-a993-e359f24f4e2c","MicroGPT解读&思考","microgpt","Andrej Karpathy 的 MicroGPT 展示了在已有的真实名字中学习规律，并通过优化训练编出新名字的过程，揭示了AI大模型训练的底层逻辑","> Andrej Karpathy 的 MicroGPT 展示了在已有的真实名字中学习规律，并通过优化训练编出新名字的过程，揭示了AI大模型训练的底层逻辑。\n# 一、项目概述\n\nAndrej Karpathy 的 MicroGPT 项目以极简的代码（200余行）构建出了AI大模型训练的底层架构，涵盖了从数据准备、自定义自动微分引擎（Value 类）、Transformer 单层架构（多头注意力、MLP、RMSNorm）、Adam 优化器到训练与推理的完整流程。\n\n项目以名字生成为例，从真实名字数据集中学习字符分布，训练后能够自主生成符合语言规律的新名字。\n\u003Cdiv align=\"center\">\n\u003Cimg width=\"1100\" src=\"https:\u002F\u002Fs41.ax1x.com\u002F2026\u002F02\u002F20\u002FpZXDRg0.png\" alt=\"Karpathy's post\" \u002F>\n\u003C\u002Fdiv>\n\n项目代码（文末附中文注释版）：https:\u002F\u002Fgist.github.com\u002Fkarpathy\u002F8627fe009c40f57531cb18360106ce95\n\n省流：\n1. **准备名字列表**：下载名字列表，打乱，建立字母表。\n2. **造大脑**：初始化许多小旋钮（参数），每个旋钮是一个小纸条（Value），能记录数字和计算关系。\n3. **定义思考方式**：写函数 `gpt`，描述大脑如何根据当前字母和位置，利用记忆（keys\u002Fvalues）推测下一个字母。\n4. **训练**：反复看名字，每看一个名字，让大脑猜，算猜错的程度（损失），然后通过小纸条的反向传播算出每个旋钮该往哪个方向拧一点，再用 Adam 方法拧动旋钮。这样训练的效果会越来越好。\n5. **创作**：训练完，让大脑自己一个字一个字地编名字，打印出来看看它学会了没有。\n# 二、项目构建\n\n## 2.1 导入工具包\n\n```\nimport os       # 用于检查文件是否存在\nimport math     # 用于数学计算（对数、指数等）\nimport random   # 用于生成随机数、打乱顺序等\nrandom.seed(42) # 固定随机种子，让每次运行结果一样\n```\n## 2.2 获取名字列表\n\n电脑先从网上下载一个名字列表，里面有很多真实的名字，每行一个。  \n\n```\n# 如果当前目录没有 input.txt 文件，就从网上下载名字列表\nif not os.path.exists('input.txt'):\n    import urllib.request\n    names_url = 'https:\u002F\u002Fraw.githubusercontent.com\u002Fkarpathy\u002Fmakemore\u002Frefs\u002Fheads\u002Fmaster\u002Fnames.txt'\n    urllib.request.urlretrieve(names_url, 'input.txt')\n```\n## 2.3 读取文件并打乱顺序\n\n读取全部名字然后打乱顺序，这样它就不会只盯着前几个名字学，而是随机看，学得更全面。\n\n```\n# 读取文件，按行分割，去掉空行和首尾空格，得到名字列表 docs\ndocs = [l.strip() for l in open('input.txt').read().strip().split('\\n') if l.strip()]\nrandom.shuffle(docs)  # 打乱名字顺序\nprint(f\"名字总数: {len(docs)}\")\n```\n# 三、定义字母\n\n## 3.1 构建字母表\n\n名字都是由字母组成的。电脑需要先知道它要学哪些字母，因此需要把所有的名字拼在一起，找出所有不同的字母（比如 a,b,c,…,A,B,C…），然后给每个字母编一个号（比如 a=0，b=1，c=2……），这样电脑就能用数字来代表字母了。\n\n```\n# 找出所有不重复的字符，排序后作为字母表\nuchars = sorted(set(''.join(docs)))\n```\n## 3.2 添加符号并定义表大小\n\n另外还需要一个特殊的“开始”符号（类似作文开头空两格）。电脑看到这个符号，就知道“名字要开始了”。这个符号也编一个号，比如 26（如果前面字母有 0~25 的话）。\n\n```\n# 定义特殊的“开始”符号 BOS，编号为字母表长度\nBOS = len(uchars)\n# 词汇表大小 = 字母数量 + BOS\nvocab_size = len(uchars) + 1\nprint(f\"词汇表大小: {vocab_size}\")\n```\n\n现在，电脑的“词汇表”里一共有：所有字母 + 开始符号。以后电脑猜下一个字母，就是从这些里面选一个。\n# 四、造一个“大脑”\n\n电脑要学习，得有一个“大脑”。\n\n这个大脑里有很多很多小旋钮（可以想象成收音机上的调频旋钮）。  \n\n一开始，这些小旋钮都是随便转到一个位置的，所以大脑什么也不会。\n\n大脑的任务是：看到当前字母和它在名字里的位置（比如第几个字），然后猜下一个字母是什么。  \n\n猜的时候，它会用到这些旋钮，把当前字母和位置变成一些数字（可以叫做“想法”），再经过一些计算，最后从词汇表里选一个字母作为答案。\n\n4.1-4.5 内容较为复杂，只为了解逻辑可跳过。\n## 4.1 定义小纸条\n\n初始化节点，存储数值、梯度、子节点和局部导数；重载加法运算；重载乘法运算；重载幂运算（指数为常数）；定义对数运算；定义指数运算；定义 ReLU 激活函数；定义其他运算（负数、减法、除法等）；反向传播（计算梯度）。\n\n```\n# 定义自动微分的小纸条类 Value\nclass Value:\n    \"\"\"存储一个标量值和它的梯度，作为计算图中的一个节点\"\"\"\n    def __init__(self, data, children=(), local_grads=()):\n        self.data = data                # 前向计算得到的数值\n        self.grad = 0                   # 损失对该节点的梯度，反向传播时计算\n        self._children = children       # 生成该节点所依赖的子节点\n        self._local_grads = local_grads # 该节点对每个子节点的局部导数\n    def __add__(self, other):\n        other = other if isinstance(other, Value) else Value(other)\n        return Value(self.data + other.data, (self, other), (1, 1))\n    def __mul__(self, other):\n        other = other if isinstance(other, Value) else Value(other)\n        return Value(self.data * other.data, (self, other), (other.data, self.data))\n    def __pow__(self, other):\n        return Value(self.data ** other, (self,), (other * self.data ** (other - 1),))\n    def log(self):\n        return Value(math.log(self.data), (self,), (1 \u002F self.data,))\n    def exp(self):\n        return Value(math.exp(self.data), (self,), (math.exp(self.data),))\n    def relu(self):\n        return Value(max(0, self.data), (self,), (float(self.data > 0),))\n    def __neg__(self):\n        return self * -1\n    def __radd__(self, other):\n        return self + other\n    def __sub__(self, other):\n        return self + (-other)\n    def __rsub__(self, other):\n        return other + (-self)\n    def __rmul__(self, other):\n        return self * other\n    def __truediv__(self, other):\n        return self * other ** -1\n    def __rtruediv__(self, other):\n        return other * self ** -1\n    def backward(self):\n        # 拓扑排序，得到计算顺序\n        topo = []\n        visited = set()\n        def build_topo(v):\n            if v not in visited:\n                visited.add(v)\n                for child in v._children:\n                    build_topo(child)\n                topo.append(v)\n        build_topo(self)\n        # 从当前节点开始反向传播\n        self.grad = 1\n        for v in reversed(topo):\n            for child, local_grad in zip(v._children, v._local_grads):\n                child.grad += local_grad * v.grad\n```\n## 4.2 设定大脑的规格\n\n```\nn_embd = 16      # 每个字母用16个数字表示（嵌入维度）\nn_head = 4       # 注意力头的数量\nn_layer = 1      # 层数（这里只用一层）\nblock_size = 8   # 最大序列长度\nhead_dim = n_embd \u002F\u002F n_head  # 每个注意力头负责的维度\n```\n## 4.3 辅助函数\n\n创建随机初始化的矩阵，每个元素是一个小纸条。\n\n```\n# 辅助函数：创建一个矩阵，每个元素是一个服从高斯分布的小纸条\nmatrix = lambda nout, nin, std=0.02: [[Value(random.gauss(0, std)) for _ in range(nin)] for _ in range(nout)]\n```\n## 4.4 初始化模型参数\n\n模型参数即为大脑里的各种表格。\n\n```\nstate_dict = {\n    'wte': matrix(vocab_size, n_embd),       # 字母特征表\n    'wpe': matrix(block_size, n_embd),       # 位置特征表\n    'lm_head': matrix(vocab_size, n_embd),   # 输出层\n}\nfor i in range(n_layer):\n    state_dict[f'layer{i}.attn_wq'] = matrix(n_embd, n_embd)          # 注意力 query 投影矩阵\n    state_dict[f'layer{i}.attn_wk'] = matrix(n_embd, n_embd)          # 注意力 key 投影矩阵\n    state_dict[f'layer{i}.attn_wv'] = matrix(n_embd, n_embd)          # 注意力 value 投影矩阵\n    state_dict[f'layer{i}.attn_wo'] = matrix(n_embd, n_embd, std=0)   # 注意力输出投影矩阵（初始化为0）\n    state_dict[f'layer{i}.mlp_fc1'] = matrix(4 * n_embd, n_embd)      # MLP 第一层\n    state_dict[f'layer{i}.mlp_fc2'] = matrix(n_embd, 4 * n_embd, std=0) # MLP 第二层（初始化为0）\n# 把所有参数（小纸条）展平到一个列表里，方便优化\nparams = [p for mat in state_dict.values() for row in mat for p in row]\nprint(f\"参数总数: {len(params)}\")\n```\n## 4.5 定义思考方式\n\n定义大脑的思考方式，即模型前向传播函数。\n\n```\ndef linear(x, w):\n    \"\"\"线性层：输入向量x，权重矩阵w，输出x与w每行的点积\"\"\"\n    return [sum(wi * xi for wi, xi in zip(wo, x)) for wo in w]\ndef softmax(logits):\n    \"\"\"将分数转换为概率分布\"\"\"\n    max_val = max(val.data for val in logits)\n    exps = [(val - max_val).exp() for val in logits]\n    total = sum(exps)\n    return [e \u002F total for e in exps]\ndef rmsnorm(x):\n    \"\"\"RMSNorm 归一化\"\"\"\n    ms = sum(xi * xi for xi in x) \u002F len(x)\n    scale = (ms + 1e-5) ** -0.5\n    return [xi * scale for xi in x]\ndef gpt(token_id, pos_id, keys, values):\n    \"\"\"GPT 模型的前向传播\"\"\"\n    # 取出当前字母的特征和位置特征\n    tok_emb = state_dict['wte'][token_id]\n    pos_emb = state_dict['wpe'][pos_id]\n    x = [t + p for t, p in zip(tok_emb, pos_emb)]  # 相加得到综合表示\n    x = rmsnorm(x)\n    for li in range(n_layer):\n        # 1) 多头注意力块\n        x_residual = x\n        x = rmsnorm(x)\n        q = linear(x, state_dict[f'layer{li}.attn_wq'])\n        k = linear(x, state_dict[f'layer{li}.attn_wk'])\n        v = linear(x, state_dict[f'layer{li}.attn_wv'])\n        # 将当前 key 和 value 存入缓存\n        keys[li].append(k)\n        values[li].append(v)\n        x_attn = []\n        for h in range(n_head):\n            hs = h * head_dim\n            q_h = q[hs:hs + head_dim]\n            k_h = [ki[hs:hs + head_dim] for ki in keys[li]]\n            v_h = [vi[hs:hs + head_dim] for vi in values[li]]\n            # 计算注意力分数\n            attn_logits = [sum(q_h[j] * k_h[t][j] for j in range(head_dim)) \u002F head_dim ** 0.5\n                           for t in range(len(k_h))]\n            attn_weights = softmax(attn_logits)\n            # 加权求和得到头输出\n            head_out = [sum(attn_weights[t] * v_h[t][j] for t in range(len(v_h))) for j in range(head_dim)]\n            x_attn.extend(head_out)\n        x = linear(x_attn, state_dict[f'layer{li}.attn_wo'])\n        x = [a + b for a, b in zip(x, x_residual)]  # 残差连接\n        # 2) MLP 块\n        x_residual = x\n        x = rmsnorm(x)\n        x = linear(x, state_dict[f'layer{li}.mlp_fc1'])\n        x = [xi.relu() ** 2 for xi in x]           # ReLU² 激活\n        x = linear(x, state_dict[f'layer{li}.mlp_fc2'])\n        x = [a + b for a, b in zip(x, x_residual)]  # 残差连接\n    # 输出层，得到词汇表大小的分数\n    logits = linear(x, state_dict['lm_head'])\n    return logits\n```\n\n# 五、训练大脑\n\n拿一个名字：比如 “Emma”。电脑先把它变成数字：E→4，m→12，m→12，a→0。\n\n然后在开头和结尾加上“开始”符号（比如 26）。 最后得到：[26, 4, 12, 12, 0, 26]。 \n\n让大脑猜： 先看第一个符号 26（开始），大脑要猜下一个字母是谁。正确答案是 4（E）。 \n\n如果大脑猜对了，就表扬；猜错了，就告诉它“你猜错了，正确答案是 E”。 \n\n然后看 26 和 4，大脑要猜再下一个字母，正确答案是 12（m）。 \n\n依此类推，一直猜到最后一个字母，大脑要猜结束符号 26。 \n\n调整旋钮：每猜完一个名字，电脑就会根据大脑猜得对不对，稍微转动一下那些小旋钮。 转动的方向是：如果猜错了，就朝能猜对的方向转一点点。 \n\n这样，下次再看类似的名字时，大脑就会更接近正确答案。 重复练习：电脑不停地拿新的名字，一个一个地猜，然后调整旋钮。 \n\n总共练习 500 次（代码里的 500 步）。 \n\n每次练习完，电脑都会打印一个数字（损失），这个数字越小，说明大脑猜得越准。 这个数字会越来越小，说明大脑正在学习进步。\n\n以下为相关代码，只为了解逻辑可跳过。\n## 5.1 设置优化器及缓存\n\n- `learning_rate = 0.01`：初始学习率，控制每次调整的步长。\n- `beta1 = 0.9`、`beta2 = 0.95`：两个记忆系数，决定记住多少历史信息。\n- `eps_adam = 1e-8`：一个很小的数，防止除零。\n- `m` 和 `v` 是两个记忆列表，长度和参数个数一样，初始全 0，用来存储每个参数的“一阶动量”（梯度的平均）和“二阶动量”（梯度平方的平均）。\n\n```\n# Adam 优化器参数\nlearning_rate, beta1, beta2, eps_adam = 1e-2, 0.9, 0.95, 1e-8\nm = [0.0] * len(params)  # 一阶动量缓存\nv = [0.0] * len(params)  # 二阶动量缓存\n\n```\n## 5.2 开始训练循环\n\n设定训练循环为500步。\n\n```\nnum_steps = 500  # 训练步数\nfor step in range(num_steps):\n```\n\n拿一个名字，转换为数字列表，首尾加上 BOS。\n\n```\n    # 取一个名字，转换为数字列表，首尾加上 BOS\n    doc = docs[step % len(docs)]\n    tokens = [BOS] + [uchars.index(ch) for ch in doc] + [BOS]\n    n = min(block_size, len(tokens) - 1)  # 有效预测长度\n```\n\n初始化每层的记忆缓存和损失列表。\n\n```\n    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]\n    losses = []\n```\n\n让大脑逐个位置猜下一个字母。\n\n```\n    # 对每个位置进行预测\n    for pos_id in range(n):\n        token_id, target_id = tokens[pos_id], tokens[pos_id + 1]\n        logits = gpt(token_id, pos_id, keys, values)\n        probs = softmax(logits)\n        loss_t = -probs[target_id].log()  # 负对数似然损失\n        losses.append(loss_t)\n```\n\n计算平均损失。\n\n```\n    # 平均损失\n    loss = (1 \u002F n) * sum(losses)\n```\n\n反向传播，计算所有参数的梯度。\n\n```\n    # 反向传播，计算梯度\n    loss.backward()\n```\n\n用余弦退火计算当前步的学习率，这样模型会逐步趋于稳定。\n\n```\n    # 余弦退火学习率\n    lr_t = learning_rate * 0.5 * (1 + math.cos(math.pi * step \u002F num_steps))\n```\n\n用 Adam 优化器更新所有参数（转动小旋钮）。\n\n```\n    # 用 Adam 更新所有参数\n    for i, p in enumerate(params):\n        m[i] = beta1 * m[i] + (1 - beta1) * p.grad\n        v[i] = beta2 * v[i] + (1 - beta2) * p.grad ** 2\n        m_hat = m[i] \u002F (1 - beta1 ** (step + 1))\n        v_hat = v[i] \u002F (1 - beta2 ** (step + 1))\n        p.data -= lr_t * m_hat \u002F (v_hat ** 0.5 + eps_adam)\n        p.grad = 0  # 梯度清零\n```\n\n打印当前步数和损失。\n\n```\n    print(f\"步数 {step + 1:4d} \u002F {num_steps:4d} | 损失 {loss.data:.4f}\")\n```\n\n---\n# 六、输出结果\n\n训练 500 次之后，大脑已经学得差不多了，现在可以让它自己编名字。\n\n开始：给大脑一个“开始”符号。大脑根据“开始”符号，猜第一个字母是谁。它不会直接选最可能的那一个，而是随机选，但猜对概率高的字母更容易被选到（这叫“有点创意，但又不乱来”）。  \n## 6.1 设置温度参数\n\n代码里有个“温度”参数，温度低就保守（选最可能那个），温度高就爱冒险（可能选冷门的字母）。\n\n```\ntemperature = 0.5  # 温度参数，控制随机性\n```\n## 6.2 生成并打印样本\n\n继续猜：把猜到的字母作为新的当前字母，继续猜下一个。  \n\n这样一字一字往下猜，直到大脑猜出“结束”符号，或者猜够了 8 个字母（因为名字一般不会太长）。\n\n看结果：电脑会编出 20 个新名字，打印出来。\n\n```\nprint(\"\\n--- 推理生成 ---\")\nfor sample_idx in range(20):\n    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]\n    token_id = BOS\n    sample = []\n    for pos_id in range(block_size):\n        logits = gpt(token_id, pos_id, keys, values)\n        # 温度调整\n        probs = softmax([l \u002F temperature for l in logits])\n        # 按概率随机采样下一个 token\n        token_id = random.choices(range(vocab_size), weights=[p.data for p in probs])[0]\n        if token_id == BOS:\n            break\n        sample.append(uchars[token_id])\n    print(f\"样本 {sample_idx + 1:2d}: {''.join(sample)}\")\n```\n# 七、理解与思考\n\n虽然 MicroGPT 是一个只有单层 Transformer、16 维嵌入、500 步训练的微型模型，但它与当今前沿的大模型有着完全相同的核心架构和训练方式。\n\nMicroGPT 剥去了深度学习框架的封装，直接展示了 Transformer 的每一行数学运算：线性层（linear）就是矩阵乘法，注意力机制就是查询（Q）与键（K）的点积缩放再加权求和，无论多大的模型，其核心只是这些基本操作的组合与堆叠。\n\n由此可见，大模型的本质是“矩阵运算 + 非线性”。\n\n虽然 MicroGPT 规模极小，但它的设计可以无缝扩展到更大的规模（增加层数、维度、数据量）。这样我们就理解了 OpenAI 等企业将 Transformer 扩展到千亿参数的基本原理——无非是“更多的层、更多的头、更多的数据、更强的算力”，而核心逻辑保持不变。\n# 八、完整代码（注释）\n\n```\n# 第一步：给电脑看名字\n\nimport os       # 用于检查文件是否存在\nimport math     # 用于数学计算（对数、指数等）\nimport random   # 用于生成随机数、打乱顺序等\nrandom.seed(42) # 固定随机种子，让每次运行结果一样\n\n# 如果当前目录没有 input.txt 文件，就从网上下载名字列表\nif not os.path.exists('input.txt'):\n    import urllib.request\n    names_url = 'https:\u002F\u002Fraw.githubusercontent.com\u002Fkarpathy\u002Fmakemore\u002Frefs\u002Fheads\u002Fmaster\u002Fnames.txt'\n    urllib.request.urlretrieve(names_url, 'input.txt')\n\n# 读取文件，按行分割，去掉空行和首尾空格，得到名字列表 docs\ndocs = [l.strip() for l in open('input.txt').read().strip().split('\\n') if l.strip()]\nrandom.shuffle(docs)  # 打乱名字顺序\nprint(f\"名字总数: {len(docs)}\")\n\n# 第二步：让电脑认识字母\n\n# 找出所有不重复的字符，排序后作为字母表\nuchars = sorted(set(''.join(docs)))\n# 定义特殊的“开始”符号 BOS，编号为字母表长度\nBOS = len(uchars)\n# 词汇表大小 = 字母数量 + BOS\nvocab_size = len(uchars) + 1\nprint(f\"词汇表大小: {vocab_size}\")\n\n# 第三步：给电脑造一个“大脑”\n\n# 定义自动微分的小纸条类 Value\nclass Value:\n    \"\"\"存储一个标量值和它的梯度，作为计算图中的一个节点\"\"\"\n\n    def __init__(self, data, children=(), local_grads=()):\n        self.data = data                # 前向计算得到的数值\n        self.grad = 0                   # 损失对该节点的梯度，反向传播时计算\n        self._children = children       # 生成该节点所依赖的子节点\n        self._local_grads = local_grads # 该节点对每个子节点的局部导数\n\n    def __add__(self, other):\n        other = other if isinstance(other, Value) else Value(other)\n        return Value(self.data + other.data, (self, other), (1, 1))\n\n    def __mul__(self, other):\n        other = other if isinstance(other, Value) else Value(other)\n        return Value(self.data * other.data, (self, other), (other.data, self.data))\n\n    def __pow__(self, other):\n        return Value(self.data ** other, (self,), (other * self.data ** (other - 1),))\n\n    def log(self):\n        return Value(math.log(self.data), (self,), (1 \u002F self.data,))\n\n    def exp(self):\n        return Value(math.exp(self.data), (self,), (math.exp(self.data),))\n\n    def relu(self):\n        return Value(max(0, self.data), (self,), (float(self.data > 0),))\n\n    def __neg__(self):\n        return self * -1\n\n    def __radd__(self, other):\n        return self + other\n\n    def __sub__(self, other):\n        return self + (-other)\n\n    def __rsub__(self, other):\n        return other + (-self)\n\n    def __rmul__(self, other):\n        return self * other\n\n    def __truediv__(self, other):\n        return self * other ** -1\n\n    def __rtruediv__(self, other):\n        return other * self ** -1\n\n    def backward(self):\n        # 拓扑排序，得到计算顺序\n        topo = []\n        visited = set()\n\n        def build_topo(v):\n            if v not in visited:\n                visited.add(v)\n                for child in v._children:\n                    build_topo(child)\n                topo.append(v)\n\n        build_topo(self)\n\n        # 从当前节点开始反向传播\n        self.grad = 1\n        for v in reversed(topo):\n            for child, local_grad in zip(v._children, v._local_grads):\n                child.grad += local_grad * v.grad\n\n# 设定大脑的规格\nn_embd = 16      # 每个字母用16个数字表示（嵌入维度）\nn_head = 4       # 注意力头的数量\nn_layer = 1      # 层数（这里只用一层）\nblock_size = 8   # 最大序列长度\nhead_dim = n_embd \u002F\u002F n_head  # 每个注意力头负责的维度\n\n# 辅助函数：创建一个矩阵，每个元素是一个服从高斯分布的小纸条\nmatrix = lambda nout, nin, std=0.02: [[Value(random.gauss(0, std)) for _ in range(nin)] for _ in range(nout)]\n\n# 初始化模型参数（大脑里的各种表格）\nstate_dict = {\n    'wte': matrix(vocab_size, n_embd),       # 字母特征表\n    'wpe': matrix(block_size, n_embd),       # 位置特征表\n    'lm_head': matrix(vocab_size, n_embd),   # 输出层\n}\n\nfor i in range(n_layer):\n    state_dict[f'layer{i}.attn_wq'] = matrix(n_embd, n_embd)          # 注意力 query 投影矩阵\n    state_dict[f'layer{i}.attn_wk'] = matrix(n_embd, n_embd)          # 注意力 key 投影矩阵\n    state_dict[f'layer{i}.attn_wv'] = matrix(n_embd, n_embd)          # 注意力 value 投影矩阵\n    state_dict[f'layer{i}.attn_wo'] = matrix(n_embd, n_embd, std=0)   # 注意力输出投影矩阵（初始化为0）\n    state_dict[f'layer{i}.mlp_fc1'] = matrix(4 * n_embd, n_embd)      # MLP 第一层\n    state_dict[f'layer{i}.mlp_fc2'] = matrix(n_embd, 4 * n_embd, std=0) # MLP 第二层（初始化为0）\n\n# 把所有参数（小纸条）展平到一个列表里，方便优化\nparams = [p for mat in state_dict.values() for row in mat for p in row]\nprint(f\"参数总数: {len(params)}\")\n\n# 定义大脑的思考方式（模型前向传播）\n\ndef linear(x, w):\n    \"\"\"线性层：输入向量x，权重矩阵w，输出x与w每行的点积\"\"\"\n    return [sum(wi * xi for wi, xi in zip(wo, x)) for wo in w]\n\ndef softmax(logits):\n    \"\"\"将分数转换为概率分布\"\"\"\n    max_val = max(val.data for val in logits)\n    exps = [(val - max_val).exp() for val in logits]\n    total = sum(exps)\n    return [e \u002F total for e in exps]\n\ndef rmsnorm(x):\n    \"\"\"RMSNorm 归一化\"\"\"\n    ms = sum(xi * xi for xi in x) \u002F len(x)\n    scale = (ms + 1e-5) ** -0.5\n    return [xi * scale for xi in x]\n\ndef gpt(token_id, pos_id, keys, values):\n    \"\"\"GPT 模型的前向传播\"\"\"\n    # 取出当前字母的特征和位置特征\n    tok_emb = state_dict['wte'][token_id]\n    pos_emb = state_dict['wpe'][pos_id]\n    x = [t + p for t, p in zip(tok_emb, pos_emb)]  # 相加得到综合表示\n    x = rmsnorm(x)\n\n    for li in range(n_layer):\n        # 1) 多头注意力块\n        x_residual = x\n        x = rmsnorm(x)\n\n        q = linear(x, state_dict[f'layer{li}.attn_wq'])\n        k = linear(x, state_dict[f'layer{li}.attn_wk'])\n        v = linear(x, state_dict[f'layer{li}.attn_wv'])\n\n        # 将当前 key 和 value 存入缓存\n        keys[li].append(k)\n        values[li].append(v)\n\n        x_attn = []\n        for h in range(n_head):\n            hs = h * head_dim\n            q_h = q[hs:hs + head_dim]\n            k_h = [ki[hs:hs + head_dim] for ki in keys[li]]\n            v_h = [vi[hs:hs + head_dim] for vi in values[li]]\n\n            # 计算注意力分数\n            attn_logits = [sum(q_h[j] * k_h[t][j] for j in range(head_dim)) \u002F head_dim ** 0.5\n                           for t in range(len(k_h))]\n            attn_weights = softmax(attn_logits)\n\n            # 加权求和得到头输出\n            head_out = [sum(attn_weights[t] * v_h[t][j] for t in range(len(v_h))) for j in range(head_dim)]\n            x_attn.extend(head_out)\n\n        x = linear(x_attn, state_dict[f'layer{li}.attn_wo'])\n        x = [a + b for a, b in zip(x, x_residual)]  # 残差连接\n\n        # 2) MLP 块\n        x_residual = x\n        x = rmsnorm(x)\n        x = linear(x, state_dict[f'layer{li}.mlp_fc1'])\n        x = [xi.relu() ** 2 for xi in x]           # ReLU² 激活\n        x = linear(x, state_dict[f'layer{li}.mlp_fc2'])\n        x = [a + b for a, b in zip(x, x_residual)]  # 残差连接\n\n    # 输出层，得到词汇表大小的分数\n    logits = linear(x, state_dict['lm_head'])\n    return logits\n\n# 第四步：教大脑学习（训练）\n\n# Adam 优化器参数\nlearning_rate, beta1, beta2, eps_adam = 1e-2, 0.9, 0.95, 1e-8\nm = [0.0] * len(params)  # 一阶动量缓存\nv = [0.0] * len(params)  # 二阶动量缓存\n\nnum_steps = 500  # 训练步数\nfor step in range(num_steps):\n    # 取一个名字，转换为数字列表，首尾加上 BOS\n    doc = docs[step % len(docs)]\n    tokens = [BOS] + [uchars.index(ch) for ch in doc] + [BOS]\n    n = min(block_size, len(tokens) - 1)  # 有效预测长度\n\n    # 初始化每层的记忆缓存和损失列表\n    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]\n    losses = []\n\n    # 对每个位置进行预测\n    for pos_id in range(n):\n        token_id, target_id = tokens[pos_id], tokens[pos_id + 1]\n        logits = gpt(token_id, pos_id, keys, values)\n\n        probs = softmax(logits)\n        loss_t = -probs[target_id].log()  # 负对数似然损失\n        losses.append(loss_t)\n\n    # 平均损失\n    loss = (1 \u002F n) * sum(losses)\n\n    # 反向传播，计算梯度\n    loss.backward()\n\n    # 余弦退火学习率\n    lr_t = learning_rate * 0.5 * (1 + math.cos(math.pi * step \u002F num_steps))\n\n    # 用 Adam 更新所有参数\n    for i, p in enumerate(params):\n        m[i] = beta1 * m[i] + (1 - beta1) * p.grad\n        v[i] = beta2 * v[i] + (1 - beta2) * p.grad ** 2\n        m_hat = m[i] \u002F (1 - beta1 ** (step + 1))\n        v_hat = v[i] \u002F (1 - beta2 ** (step + 1))\n        p.data -= lr_t * m_hat \u002F (v_hat ** 0.5 + eps_adam)\n        p.grad = 0  # 梯度清零\n\n    print(f\"步数 {step + 1:4d} \u002F {num_steps:4d} | 损失 {loss.data:.4f}\")\n\n# 第五步：让电脑自己编名字（推理）\n\ntemperature = 0.5  # 温度参数，控制随机性\nprint(\"\\n--- 推理生成 ---\")\nfor sample_idx in range(20):\n    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]\n    token_id = BOS\n    sample = []\n\n    for pos_id in range(block_size):\n        logits = gpt(token_id, pos_id, keys, values)\n        # 温度调整\n        probs = softmax([l \u002F temperature for l in logits])\n        # 按概率随机采样下一个 token\n        token_id = random.choices(range(vocab_size), weights=[p.data for p in probs])[0]\n        if token_id == BOS:\n            break\n        sample.append(uchars[token_id])\n\n    print(f\"样本 {sample_idx + 1:2d}: {''.join(sample)}\")\n```","https:\u002F\u002Foxqtewbrpuiouqqjrvdv.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Fpublic-media\u002F2026-07-16\u002Ffe8eb5f4-804c-4338-982f-60137ea8fbba.jpg",[],[],"龙家轩","https:\u002F\u002Fweatheraintbad.com",{"id":18,"name":19,"slug":20,"description":21},[66,67,69,73,74,75],{"id":36,"name":37,"slug":38},{"id":68,"name":19,"slug":20},"68cedb55-2cac-412f-8f81-fda8c7d686dd",{"id":70,"name":71,"slug":72},"88d2bc27-0e0f-468a-b907-2991cb97b87b","人工智能","ai",{"id":24,"name":25,"slug":26},{"id":40,"name":41,"slug":42},{"id":32,"name":33,"slug":34},3,"2026-03-31T00:00:00.000Z","2026-07-17T03:36:08.463Z","2026-07-16T11:15:46.645Z",{"id":81,"type":6,"title":82,"slug":83,"summary":84,"body":85,"coverUrl":86,"productScreenshots":87,"productLinks":88,"authorName":62,"authorUrl":63,"authorSubject":16,"category":89,"tags":94,"sourceLabel":44,"sourceName":44,"sourceUrl":44,"status":45,"seoTitle":44,"seoDescription":44,"canonicalUrl":44,"isFeatured":99,"sno":100,"sortOrder":48,"publishedAt":101,"updatedAt":102,"createdAt":103},"35a3e5ea-b651-45b6-9b82-d0c4aac1006a","如何让内容更容易被国内大模型引用","geo-in-china","通过可抓取的页面、结构化的答案、可信的证据和多平台权威分发，让大模型更容易发现、理解、信任并引用内容。","生成式引擎优化（GEO）的核心目标是让内容更容易被AI发现、理解、采信并写入回答。\n\n大模型通常会经历“理解问题—联网检索—筛选信源—提取信息—生成回答”的过程，具体涉及：\n- 内容能否被抓取\n- 信息能否被提取\n- 观点是否可信\n- 页面是否值得引用等问题。\n\nPranjal Aggarwal等人的研究（[arXiv](https:\u002F\u002Farxiv.org\u002Fabs\u002F2311.09735)）指出，优化内容表达可提高其在生成式回答中的可见度，但效果受行业、平台和查询方式影响，不存在适用于所有模型的固定技巧。\n\n## 一、先解决页面能否被读取\n\n重要内容必须直接出现在页面初始HTML中，不应依赖点击、登录或复杂JavaScript接口加载。每篇内容都应具有唯一稳定URL，并正确设置标题、描述、Canonical、站点地图和内部链接。\n\n文章应明确展示发布时间、更新时间、作者、来源、所属机构和联系方式。新闻、产品、机构及问答页面可补充JSON-LD结构化数据，帮助搜索系统识别页面实体和字段关系。\n\n传统SEO仍然是GEO的基础。一个没有正常收录、页面混乱或正文无法抓取的网站，很难成为AI信源。\n\n## 二、把文章写成可直接引用的“答案模块”\n\n大模型更容易使用结构清楚、语义完整的内容。标题应对应真实问题，正文开头直接给出结论，再补充解释、数据和依据。\n\n推荐采用“问题—结论—原因—证据—操作方法”的结构，并通过小标题、短段落、步骤、对比和FAQ拆分信息。每个段落尽量独立表达一个完整观点，避免大量宣传口号、空泛背景和需要结合上下文才能理解的句子。\n\n研究发现，具有清晰定义、数字事实、比较关系和操作步骤的长篇结构化页面，更容易被生成式引擎吸收到最终答案中。([arXiv](https:\u002F\u002Farxiv.org\u002Fabs\u002F2604.25707))\n\n## 三、建立可验证的事实与证据链\n\nAI需要的不只是观点，而是能够核验的事实。文章应尽量提供数据来源、政策文件、实验方法、案例时间、统计口径和原始链接。\n\n涉及品牌、产品和机构时，应统一名称、简介、核心业务、成立时间、地域和关键数据，避免官网、公众号、百科和媒体报道之间口径冲突。重要数据需要定期更新，并明确标注更新时间。\n\n引用权威资料、加入专业术语和提供准确数据，通常比单纯增加关键词更有效。([arXiv](https:\u002F\u002Farxiv.org\u002Fpdf\u002F2311.09735))\n\n## 四、通过第三方信源建立外部共识\n\nAI往往会综合多个来源，而不是只相信企业官网。除建设官网外，还应争取政府网站、主流媒体、行业协会、学术机构、专业社区和垂直平台的独立报道或引用。\n\n第三方内容不应只是重复新闻稿，而应从不同角度提供事实、评价、案例和数据，使品牌信息形成跨网站一致的“外部共识”。相关研究发现，生成式搜索对权威第三方信源的偏好通常高于品牌自有内容。([arXiv](https:\u002F\u002Farxiv.org\u002Fabs\u002F2509.08919))\n\n## 五、针对国内平台进行差异化分发\n\n豆包、千问、文心、元宝、DeepSeek和Kimi的搜索入口、生态内容及引用结果并不完全相同。行业实践普遍观察到，平台可能更容易调用与自身搜索或内容生态连接紧密的信源，但这种偏好会随版本、问题和搜索模式变化，不能视为固定规则。([智推时代 GenOptima](https:\u002F\u002Fzhituishidai.com\u002Fblog\u002Fzh-domestic-ai-platforms-explained.html))\n\n实际执行中，可将同一核心事实适配为官网深度文章、新闻报道、公众号内容、问答页面和行业报告，而不是把完全相同的稿件机械复制到所有平台。\n\n## 六、建立持续监测机制\n\nGEO不能通过一次提问判断效果。应建立覆盖品牌词、行业词、地域词、对比词和购买决策词的问题库，定期在六个模型中重复测试。\n\n核心指标包括品牌提及率、信源引用率、引用位置、事实准确率、核心问题覆盖率和竞品共现率。由于大模型回答具有随机性，同一问题需要采用多种表述并重复测试。监测结果应继续反哺选题、页面结构、内容更新和分发渠道。([阿里云开发者社区](https:\u002F\u002Fdeveloper.aliyun.com\u002Farticle\u002F1747099))\n\nGEO最有效的路径可以概括为：先让页面可抓取，再让内容可提取；用事实建立可信度，用第三方信源建立共识，最后通过多模型监测持续修正。与其寻找短期技巧，不如把网站建设成长期稳定、结构清晰、证据充分的高质量信息源。","https:\u002F\u002Foxqtewbrpuiouqqjrvdv.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Fpublic-media\u002F2026-07-17\u002F7d9c4c0e-eb28-4011-9b18-f7e7212eaa9f.jpg",[],[],{"id":90,"name":91,"slug":92,"description":93},"c523f1c9-338c-4618-add9-9ce67a39b2a0","研究","research","研究成果与启发",[95,96,97,98],{"id":70,"name":71,"slug":72},{"id":24,"name":25,"slug":26},{"id":40,"name":41,"slug":42},{"id":36,"name":37,"slug":38},false,49,"2026-07-17T00:00:00.000Z","2026-07-17T04:46:24.281Z","2026-07-17T04:40:14.581Z",{"id":105,"type":6,"title":106,"slug":107,"summary":108,"body":109,"coverUrl":110,"productScreenshots":111,"productLinks":112,"authorName":62,"authorUrl":63,"authorSubject":16,"category":113,"tags":114,"sourceLabel":44,"sourceName":44,"sourceUrl":44,"status":45,"seoTitle":44,"seoDescription":44,"canonicalUrl":44,"isFeatured":46,"sno":125,"sortOrder":48,"publishedAt":126,"updatedAt":127,"createdAt":128},"bc921879-1742-4bf4-98b1-6298a860e475","对编程语言发展历程的思考：从比特到思想","programminglanguages","编程语言的进化史，是人类不断把复杂抽象成简单的过程","> 1946年，ENIAC的工程师们需要用插头和开关来“编程”，每改变一次计算任务，就要花费几天时间重新接线。程序员的工作，是在电路板上理解机器的语言——二进制。\n> \n> 今天，我们对着AI说一句“帮我写个贪吃蛇游戏”，代码就生成了。\n> \n> 这就是编程语言的进化史，也是人类不断把复杂抽象成简单的过程。\n\n# 机器语言\n\n最早的编程就是机器语言，一串串的0和1。每条指令都是CPU直接理解的命令，比如`10110000 01100001`，我们可能完全不知道它是什么意思——这串二进制代表“把数字97存入寄存器”。\n\n在那个时代，程序员必须像机器一样思考。我们要记住每个操作码的含义，要手动计算内存地址，要小心翼翼地安排每一条指令。写一个简单的加法程序，可能需要几十个0和1的组合。\n\n> 计算机本质上只是一个听话但死板的机器。它不理解“方便”或“人性化”，只懂电信号的通断。程序员的工作，就是把自己变成机器的一部分。\n\n# 汇编语言\n\n很快，人们受不了了。汇编语言诞生了——用`MOV`代替`10110000`，用`ADD`代替加法操作。虽然本质上还是一一对应机器指令，但至少可读性有了质的飞跃。\n\n```\nMOV AL, 61h    ; 把十六进制61放入AL寄存器\nADD AL, 01h    ; 加1\n```\n\n> 汇编语言是人类第一次尝试“封装”复杂性。但本质上它仍然是机器的语言，只是给冰冷的二进制披上了一件可读的外衣。写汇编的人依然需要了解寄存器、堆栈、中断——我们仍然在思考“机器怎么做”，而不是“我想做什么”。\n\n# C语言\n\n1972年，Dennis Ritchie创造了C语言。这是真正的革命——它让程序员可以既写人类理解的代码，又能控制底层细节。\n\nC语言提供了变量、函数、循环、数组等抽象，同时又保留了指针这样直接操作内存的能力。Unix操作系统就是用C写的，它的成功证明了系统级语言的可能性。\n\n```c\nint sum = 0;\nfor(int i = 1; i \u003C= 100; i++) {\n    sum += i;\n}\n```\n\n> C语言的伟大之处在于它找到了平衡点——足够抽象来保护程序员，又足够底层来信任程序员。从这一刻起，编程开始从“让机器做事”转向“表达计算逻辑”。我们可以把注意力放在算法上，而不是寄存器的分配上。\n\n# C++与Java\n\n随着软件规模爆炸式增长，C语言的结构化编程开始显得力不从心。1990年代，面向对象编程成为主流。C++在C的基础上添加了类、继承、多态；Java进一步简化了内存管理，引入垃圾回收。\n\n我们开始用“对象”来建模世界——一个订单是一个对象，一个用户是一个对象，一个购物车也是一个对象。代码的组织方式从“函数集合”变成了“对象之间的消息传递”。\n\n```java\nclass Animal {\n    void speak() {\n        System.out.println(\"Some sound\");\n    }\n}\nclass Dog extends Animal {\n    void speak() {\n        System.out.println(\"Woof!\");\n    }\n}\n```\n\n> 面向对象的核心不是语法，而是思维方式的转变。我们不必再思考“机器怎么执行这段代码”，而是思考“这些概念之间的关系是什么”。编程越来越像在解决现实问题，而不是与机器博弈。\n\n# Python与JavaScript\n\n21世纪初，脚本语言崛起。Python强调可读性和简洁，JavaScript让浏览器变得可编程。它们的共同点是：**不需要编译**、**动态类型**、**上手门槛极低**。\n\n```python\n# 读取文件并统计单词数\nwith open('story.txt') as f:\n    words = f.read().split()\n    print(f\"单词数: {len(words)}\")\n```\n\n四行代码完成了一个实用程序。这在C语言中可能需要几十行，还要处理内存分配、缓冲区溢出等问题。\n\n> 脚本语言的出现让编程不再是计算机科学家的专利。数据分析师、设计师、学生都能通过Python快速解决问题。编程从“专业工种”变成了“通用技能”。JavaScript更是让每个人浏览器里的网页都变得可交互——我们不需要安装任何环境，打开F12就可以开始编程。\n\n# 自然语言与Vibe Coding\n\n2025年左右，一个叫“Vibe Coding”的概念开始流行。它的核心很简单：**用自然语言描述我们想要什么，AI生成代码**。\n\n我们对着IDE说：“创建一个网页，左侧是聊天列表，右侧是聊天窗口，数据先写死在JavaScript里。”几秒钟后，一个完整的前端应用就生成了。\n\n我们不需要知道React组件怎么写，不需要担心状态管理，不需要调试CSS布局。我们说出需求，AI理解并实现。\n\n> 这是编程进化的终点吗？也许是的——**当我们能直接用自然语言表达意图时，“编程”本身就不再需要了**。\n\n但更准确地说，编程的抽象层次达到了最高峰：\n\n- 机器语言：告诉机器每个比特\n- 汇编语言：告诉机器每个指令\n- C语言：告诉机器每个函数\n- Python：告诉计算机每个操作\n- 自然语言：告诉AI我们的意图\n\n每一层抽象都在隐藏底层细节，每一层进化都在让表达更接近人类的自然思维。\n\n# 进化的本质\n\n回顾这几十年的编程语言发展，我们能看到一条清晰的路径：\n\n**抽象层次不断升高，表达效率指数级提升。**\n\n用二进制写一个排序算法可能需要几千行0和1，用C语言可能几十行，用Python可能几行，用自然语言可能只需要一句话：“给这个数组排序。”\n\n但这条路径的另一面是：**我们离机器越来越远**。\n\n早期的程序员清楚地知道CPU如何执行每条指令，内存如何布局，缓存如何工作。今天的程序员可能完全不关心这些，他们只关心业务逻辑。这没什么不好——大部分问题确实不需要关心底层。\n\n> 编程语言的进化，本质上是人类不断把复杂性封装起来的过程。我们发明函数来封装重复逻辑，发明类来封装数据和操作，发明库来封装通用功能，发明框架来封装架构模式，发明AI来封装整个编码过程。\n\n每一次封装都释放了新的生产力，但代价是我们需要信任底层的抽象是可靠的。就像我们不会关心电梯的钢缆如何工作——**我们只是按按钮。**\n\n# 编程的消亡与重生\n\n当自然语言成为编程的最终抽象，“编程”这个词还会存在吗？\n\n编程不会消亡，但它会**变形**。\n\n未来的“程序员”可能更像“需求分析师”或“AI训练师”——能不能用自然语言清晰地描述我们想要什么；能不能识别AI生成的代码是否符合需求；能不能调试和优化AI的输出。\n\n换句话说，**编程的核心将从“怎么写代码”变成“怎么定义问题”**。\n\n这对于非技术人员来说是天大的好消息——他们终于可以直接用计算机解决问题，而不需要学习语法。对于专业程序员来说，这意味着要重新定义自己的价值：不是写代码的能力，而是理解问题、拆解需求、验证结果的能力。\n\n# 结语\n\n从机器语言的比特，到自然语言的思想，编程语言进化的每一步都在回答同一个问题：\n\n**如何让计算机更好地理解人类？**\n\n二进制是最糟糕的答案——需要人类去理解计算机。自然语言是最好的答案——让计算机去理解人类。\n\nVibe Coding不是一个终点，而是一个开始。当编程的门槛降到零，每个人都可以用自然语言指挥计算机创造东西时，人类创造力的释放将进入一个全新的时代。\n\n我们花了七十年的时间，从插头、开关、二进制、汇编、C语言、面向对象、脚本语言，一路走到自然语言编程。这不仅是技术的进步，更是人类思维方式的演进——从机器如何思考，到我们如何思考。\n\n也许有一天，编程语言这个概念本身会消失。我们会像和朋友聊天一样，和计算机合作创造。到那时，再回头看今天的编程语言，就像回头看石器时代的工具一样——既觉得原始，又充满敬意。\n","https:\u002F\u002Foxqtewbrpuiouqqjrvdv.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Fpublic-media\u002F2026-07-16\u002F395fe295-8b25-4ff5-bf50-0d42340b8e27.jpg",[],[],{"id":18,"name":19,"slug":20,"description":21},[115,116,117,118,122,123,124],{"id":36,"name":37,"slug":38},{"id":68,"name":19,"slug":20},{"id":70,"name":71,"slug":72},{"id":119,"name":120,"slug":121},"0848beb4-db26-4fb8-b391-f852a11be192","AI编程","ai-coding",{"id":24,"name":25,"slug":26},{"id":40,"name":41,"slug":42},{"id":32,"name":33,"slug":34},50,"2026-04-03T00:00:00.000Z","2026-07-17T03:36:00.020Z","2026-07-16T04:13:19.163Z"]