学习

沿着问题,一步步读懂。

文章页用于查找;这里给出建议顺序。项目页看整体结构,实验页查协议与证据,实践页动手尝试。

0 / 59 · 你的阅读进度,仅保存在当前浏览器。

从下面选一条路线开始。

构建 / AI 应用开发

Java、HTTP 与 JSON 基础

已发布的阅读顺序 · 17
  1. 构建 · 入门

    Java 8 调用大语言模型:从第一次请求到多轮对话 →

    读后能做什么:发送请求、解析回答,并正确传递多轮历史。

    先修:Java、HTTP 与 JSON 基础

    项目 · Java LLM 实践集 →

    下一步:Java LLM 实践(二):HTTP 200 之后,怎样验收模型的 JSON? →

    15 分钟
  2. 构建 · 进阶

    Java LLM 实践(二):HTTP 200 之后,怎样验收模型的 JSON? →

    读后能做什么:把传输、JSON 结构和业务验收分开。

    先修:Java 8 调用大语言模型:从第一次请求到多轮对话

    项目 · Java LLM 实践集 →

    下一步:Java LLM 实践(三):超时之后,别让对话历史悄悄变了 →

    16 分钟
  3. 构建 · 进阶

    Java LLM 实践(三):超时之后,别让对话历史悄悄变了 →

    读后能做什么:让一次问答原子提交,失败不留下半轮。

    先修:Java LLM 实践(二):HTTP 200 之后,怎样验收模型的 JSON?

    实验 · A1 / 对话历史的提交边界 →项目 · Java LLM 实践集 →

    下一步:Java LLM 实践(四):两个请求同时返回,谁有资格写入历史? →

    10 分钟
  4. 构建 · 进阶

    Java LLM 实践(四):两个请求同时返回,谁有资格写入历史? →

    读后能做什么:用版本票据实现先提交者获胜,说明与串行的区别。

    先修:Java LLM 实践(三):超时之后,别让对话历史悄悄变了

    实验 · A2 / 并发历史提交 →项目 · Java LLM 实践集 →

    下一步:Java LLM 实践(五):工具超时了,为什么任务还在执行? →

    8 分钟
  5. 构建 · 进阶

    Java LLM 实践(五):工具超时了,为什么任务还在执行? →

    读后能做什么:限制工具白名单、参数与预算,区分超时和真正停止。

    先修:Java LLM 实践(二):HTTP 200 之后,怎样验收模型的 JSON?

    实验 · 工具调用失败恢复实验 →项目 · Java LLM 实践集 →

    下一步:Java LLM 实践(八):流式回答断了,半句答案该不该进入历史? →

    8 分钟
  6. 构建 · 进阶

    Java LLM 实践(八):流式回答断了,半句答案该不该进入历史? →

    读后能做什么:区分流式预览与可提交的完整回答。

    先修:Java LLM 实践(二):HTTP 200 之后,怎样验收模型的 JSON?

    实验 · Java LLM 实践(八):流式回答断了,半句答案该不该进入历史? →项目 · Java LLM 实践集 →

    下一步:Java LLM 实践(九):取消请求后,旧回答为什么还会覆盖新会话? →

    11 分钟
  7. 构建 · 进阶

    Java LLM 实践(九):取消请求后,旧回答为什么还会覆盖新会话? →

    读后能做什么:比较三种会话策略,阻止旧回调覆盖当前请求。

    先修:Java LLM 实践(八):流式回答断了,半句答案该不该进入历史?

    实验 · Java LLM 实践(九):取消请求后,旧回答为什么还会覆盖新会话? →项目 · Java LLM 实践集 →

    下一步:Java LLM 实践(十):点了取消,读取线程为什么还在运行? →

    10 分钟
  8. 构建 · 进阶

    Java LLM 实践(十):点了取消,读取线程为什么还在运行? →

    读后能做什么:区分本地取消、连接停止和远端任务终止。

    先修:Java LLM 实践(九):取消请求后,旧回答为什么还会覆盖新会话?

    实验 · Java LLM 实践(十):点了取消,读取线程为什么还在运行? →项目 · Java LLM 实践集 →

    下一步:TypeScript 能保证模型输出正确吗?32组输入与 Java 校验器的边界对照 →

    11 分钟
  9. 构建 · 进阶

    TypeScript 能保证模型输出正确吗?32组输入与 Java 校验器的边界对照 →

    读后能做什么:理解静态类型为何不能替代外部响应的运行时校验。

    先修:Java LLM 实践(二):HTTP 200 之后,怎样验收模型的 JSON?

    实验 · TypeScript / 输出边界对照 →项目 · Java LLM 实践集 →

    下一步:AI Radar 工程拆解:从 RSS 到网站,中间发生了什么? →

    11 分钟
  10. 构建 · 进阶

    AI Radar 工程拆解:从 RSS 到网站,中间发生了什么? →

    读后能做什么:追踪采集、去重和发布,区分历史实现与当前配置。

    先修:Java、HTTP 与 JSON 基础

    项目 · Hohoo’s AI Lab →

    下一步:Java 会话历史与请求窗口:裁掉的旧事实还能回来吗? →

    12 分钟
  11. 构建 · 进阶

    Java 会话历史与请求窗口:裁掉的旧事实还能回来吗? →

    读后能做什么:通过裁剪、提交、重启和扩窗的连续实验,分离可回看的完整历史与一次模型请求的上下文。

    先修:Java LLM 实践(三):超时之后,别让对话历史悄悄变了

    实验 · Java 会话历史与请求窗口:裁掉的旧事实还能回来吗? →项目 · Java LLM 实践集 →

    下一步:Java 请求重试:三次超时,不等于一个总期限 →

    9 分钟
  12. 构建 · 进阶

    Java 请求重试:三次超时,不等于一个总期限 →

    读后能做什么:七种真实本地 HTTP 情况,比较状态码、Retry-After、尝试上限和总等待预算。

    先修:Java LLM 实践(十):点了取消,读取线程为什么还在运行?

    实验 · Java 请求重试:三次超时,不等于一个总期限 →项目 · Java LLM 实践集 →

    下一步:Java 对话历史落盘:程序崩溃后,半轮记录怎么办? →

    9 分钟
  13. 构建 · 进阶

    Java 对话历史落盘:程序崩溃后,半轮记录怎么办? →

    读后能做什么:校验追加日志、142种截断前缀和三个真实异常退出子进程,明确本地提交与远端幂等的边界。

    先修:Java 会话历史与请求窗口:裁掉的旧事实还能回来吗?

    实验 · Java 对话历史落盘:程序崩溃后,半轮记录怎么办? →项目 · Java LLM 实践集 →

    下一步:Java 幂等重试:没收到回答,不等于没有执行 →

    9 分钟
  14. 构建 · 进阶

    Java 幂等重试:没收到回答,不等于没有执行 →

    读后能做什么:识别回复丢失与效果未知,复现并发去重和进程崩溃窗口。

    先修:Java 请求重试:三次超时,不等于一个总期限 · Java 对话历史落盘:程序崩溃后,半轮记录怎么办?

    实验 · Java 幂等重试:没收到回答,不等于没有执行 →项目 · Java LLM 实践集 →

    下一步:持久幂等:让操作身份与结果一起提交 →

    11 分钟
  15. 构建 · 进阶

    持久幂等:让操作身份与结果一起提交 →

    读后能做什么:用带CRC的追加日志、进程崩溃与99个截断前缀,解释持久幂等的提交边界。

    先修:Java 幂等重试:没收到回答,不等于没有执行

    实验 · 持久投递与历史恢复 →项目 · Java LLM 实践集 →

    下一步:Outbox投递:本地可靠,不等于远端只执行一次 →

    10 分钟
  16. 构建 · 进阶

    Outbox投递:本地可靠,不等于远端只执行一次 →

    读后能做什么:对照有键和无键接收端,解释回复丢失、回执缺失与远端重复副作用。

    先修:持久幂等:让操作身份与结果一起提交

    实验 · 持久投递与历史恢复 →项目 · Java LLM 实践集 →

    下一步:对话恢复:从意图、回执到完整问答 →

    10 分钟
  17. 构建 · 进阶

    对话恢复:从意图、回执到完整问答 →

    读后能做什么:在三个提交边界真实终止JVM,以持久事实恢复完整历史,保留远端重复执行反例。

    先修:Outbox投递:本地可靠,不等于远端只执行一次

    实验 · 持久投递与历史恢复 →项目 · Java LLM 实践集 →
    10 分钟
后续计划 · 尚未发表
  1. 构建 · 计划选题

    Tool Calling

  2. 构建 · 计划选题

    Spring AI 快速入门

  3. 构建 · 计划选题

    Agent 工作流

  4. 构建 · 计划选题

    评估效果,记录失败,复盘改进

  5. 构建 · 计划选题

    AI 应用可观测性

  6. 构建 · 计划选题

    Production

  7. 构建 · 计划选题

    AI Coding

  8. 构建 · 计划选题

    Codex

  9. 构建 · 计划选题

    MCP

  10. 构建 · 计划选题

    Skills

  11. 构建 · 计划选题

    Harness Engineering

  12. 构建 · 计划选题

    Testing

  13. 构建 · 计划选题

    Performance

理解 / LLM

Python、数组与矩阵运算基础;机制实验不使用训练好的大模型

已发布的阅读顺序 · 18
  1. 理解 · 进阶

    KV Cache 拆解:多轮对话的历史,为什么还要再传一遍? →

    读后能做什么:估算 K/V 数组容量,区分会话记忆和计算复用。

    先修:Python、数组与矩阵运算基础;机制实验不使用训练好的大模型

    下一步:LLM机制实验(一):改动未来Token,前面的输出应该变吗? →

    10 分钟
  2. 理解 · 进阶

    LLM机制实验(一):改动未来Token,前面的输出应该变吗? →

    读后能做什么:用未来信息泄漏反例检验因果掩码。

    先修:KV Cache 拆解:多轮对话的历史,为什么还要再传一遍?

    实验 · L2–L4 / 注意力与缓存机制 →项目 · Java LLM 实践集 →

    下一步:LLM机制实验(二):KV Cache省掉了什么,怎样证明没有算错? →

    8 分钟
  3. 理解 · 进阶

    LLM机制实验(二):KV Cache省掉了什么,怎样证明没有算错? →

    读后能做什么:逐步比较完整重算与增量计算的数值结果。

    先修:LLM机制实验(一):改动未来Token,前面的输出应该变吗?

    实验 · L2–L4 / 注意力与缓存机制 →项目 · Java LLM 实践集 →

    下一步:LLM机制实验(三):缓存只留四格,为什么不等于重算四个Token? →

    8 分钟
  4. 理解 · 进阶

    LLM机制实验(三):缓存只留四格,为什么不等于重算四个Token? →

    读后能做什么:滑动窗口裁剪后仍保留正确位置语义。

    先修:LLM机制实验(二):KV Cache省掉了什么,怎样证明没有算错?

    实验 · L2–L4 / 注意力与缓存机制 →项目 · Java LLM 实践集 →

    下一步:LLM 机制实验(四):前缀改了,旧 KV Cache 还能继续用吗? →

    8 分钟
  5. 理解 · 进阶

    LLM 机制实验(四):前缀改了,旧 KV Cache 还能继续用吗? →

    读后能做什么:识别模型、位置与输入变更后的失效条件。

    先修:LLM机制实验(三):缓存只留四格,为什么不等于重算四个Token?

    实验 · L5 / 前缀缓存失效 →项目 · Java LLM 实践集 →

    下一步:LLM 机制实验(五):改了历史,能否只重算变化的后缀? →

    9 分钟
  6. 理解 · 进阶

    LLM 机制实验(五):改了历史,能否只重算变化的后缀? →

    读后能做什么:匹配最长有效前缀并续算剩余 Token。

    先修:LLM 机制实验(四):前缀改了,旧 KV Cache 还能继续用吗?

    实验 · LLM 机制实验(五):改了历史,能否只重算变化的后缀? →项目 · Java LLM 实践集 →

    下一步:LLM 机制实验(六):缓存加大了,为什么还是一次都没命中? →

    10 分钟
  7. 理解 · 进阶

    LLM 机制实验(六):缓存加大了,为什么还是一次都没命中? →

    读后能做什么:按数组字节数限制 LRU,解释工作集放不下时的零命中。

    先修:LLM 机制实验(五):改了历史,能否只重算变化的后缀?

    实验 · LLM 机制实验(六):缓存加大了,为什么还是一次都没命中? →项目 · Java LLM 实践集 →

    下一步:LLM 机制实验(七):缓存省了计算,为什么实测反而更慢? →

    11 分钟
  8. 理解 · 进阶

    LLM 机制实验(七):缓存省了计算,为什么实测反而更慢? →

    读后能做什么:同时判断数值等价、计算节省与实测时间。

    先修:LLM 机制实验(六):缓存加大了,为什么还是一次都没命中?

    实验 · LLM 机制实验(七):缓存省了计算,为什么实测反而更慢? →项目 · Java LLM 实践集 →

    下一步:把答案放在上下文中间,模型就会漏掉吗?一次提前停止的对照试验 →

    12 分钟
  9. 理解 · 进阶

    把答案放在上下文中间,模型就会漏掉吗?一次提前停止的对照试验 →

    读后能做什么:区分计划、尝试、有效响应,保留限流后的不完整结果。

    先修:Python、数组与矩阵运算基础;机制实验不使用训练好的大模型

    项目 · Java LLM 实践集 →实验 · L1 / 上下文位置试验:提前停止的一轮 →

    下一步:LLM 实验(二):先让对照成立,再谈上下文位置 →

    12 分钟
  10. 理解 · 进阶

    LLM 实验(二):先让对照成立,再谈上下文位置 →

    读后能做什么:复核 24 次真实对照,说明全对结果的测量天花板。

    先修:把答案放在上下文中间,模型就会漏掉吗?一次提前停止的对照试验

    项目 · Java LLM 实践集 →实验 · L1 / 上下文位置试验:提前停止的一轮 →

    下一步:24次全对之后:怎样设计更有区分度的上下文实验? →

    16 分钟
  11. 理解 · 进阶

    24次全对之后:怎样设计更有区分度的上下文实验? →

    读后能做什么:检查 128 项离线实验设计,不把准备完成当模型结果。

    先修:LLM 实验(二):先让对照成立,再谈上下文位置

    项目 · Java LLM 实践集 →

    下一步:KV 缓存开销剖析:把省下的计算和新增的工作分开 →

    10 分钟
  12. 理解 · 进阶

    KV 缓存开销剖析:把省下的计算和新增的工作分开 →

    读后能做什么:对909次查询做分段计时,验证源码签名、查找、复制与续算分别花在哪里,同时保留缓存仍慢的结果。

    先修:LLM 机制实验(七):缓存省了计算,为什么实测反而更慢?

    实验 · KV 缓存开销剖析:把省下的计算和新增的工作分开 →项目 · Java LLM 实践集 →

    下一步:注意力分块:不保存完整分数矩阵,如何保持结果? →

    9 分钟
  13. 理解 · 进阶

    注意力分块:不保存完整分数矩阵,如何保持结果? →

    读后能做什么:从错误的分块平均出发,推导在线Softmax累加,并用9组数组和558次计时区分省内存与加速。

    先修:LLM机制实验(二):KV Cache省掉了什么,怎样证明没有算错?

    实验 · 注意力分块:不保存完整分数矩阵,如何保持结果? →项目 · Java LLM 实践集 →

    下一步:KV 量化入门:省下多少字节,又引入什么误差? →

    9 分钟
  14. 理解 · 进阶

    KV 量化入门:省下多少字节,又引入什么误差? →

    读后能做什么:比较整张量与逐行int8量化,显式计入scale,观察离群值对注意力输出的影响。

    先修:注意力分块:不保存完整分数矩阵,如何保持结果?

    实验 · KV 量化入门:省下多少字节,又引入什么误差? →项目 · Java LLM 实践集 →

    下一步:KV 量化轴:Key 与 Value 为什么不能一概而论? →

    9 分钟
  15. 理解 · 进阶

    KV 量化轴:Key 与 Value 为什么不能一概而论? →

    读后能做什么:根据离群值分布选择量化轴,独立复算输出误差和scale开销。

    先修:KV 量化入门:省下多少字节,又引入什么误差?

    实验 · KV 量化轴:Key 与 Value 为什么不能一概而论? →项目 · Java LLM 实践集 →

    下一步:KV分组打包:4-bit到底省了多少? →

    10 分钟
  16. 理解 · 进阶

    KV分组打包:4-bit到底省了多少? →

    读后能做什么:实际保存半字节整数码,复算分组scale开销、补齐字节与注意力输出误差。

    先修:KV 量化轴:Key 与 Value 为什么不能一概而论?

    实验 · KV打包、残差窗口与分块成本 →项目 · Java LLM 实践集 →

    下一步:KV残差窗口:最近Token一定值得高精度吗? →

    10 分钟
  17. 理解 · 进阶

    KV残差窗口:最近Token一定值得高精度吗? →

    读后能做什么:用早段与近段注意力对照,解释同样的float32窗口为何收益不同。

    先修:KV分组打包:4-bit到底省了多少?

    实验 · KV打包、残差窗口与分块成本 →项目 · Java LLM 实践集 →

    下一步:KV分块反量化:工作区小了,为什么更慢? →

    10 分钟
  18. 理解 · 进阶

    KV分块反量化:工作区小了,为什么更慢? →

    读后能做什么:区分缓存负载、工作数组和实测耗时,保留分块CPU实现更慢的810条计时记录。

    先修:KV残差窗口:最近Token一定值得高精度吗?

    实验 · KV打包、残差窗口与分块成本 →项目 · Java LLM 实践集 →
    10 分钟
后续计划 · 尚未发表
  1. 理解 · 计划选题

    Token 到底是什么

  2. 理解 · 计划选题

    Context Window

  3. 理解 · 计划选题

    Embedding

  4. 理解 · 计划选题

    Attention

  5. 理解 · 计划选题

    Transformer

  6. 理解 · 计划选题

    LLM Evaluation

  7. 理解 · 计划选题

    Sampling / Inference

探索 / 具身智能

Python 基础;教学仿真使用 MuJoCo 与直角坐标夹爪

已发布的阅读顺序 · 22
  1. 探索 · 入门

    具身智能实践(一):在 MuJoCo 中抓起方块,再故意抓偏 →

    读后能做什么:运行接触抓取并保留失败轨迹。

    先修:Python 基础;教学仿真使用 MuJoCo 与直角坐标夹爪

    项目 · Hohoo 具身实验 →

    下一步:具身实践(二):没抓住,就别继续搬运 →

    18 分钟
  2. 探索 · 进阶

    具身实践(二):没抓住,就别继续搬运 →

    读后能做什么:在搬运前验收抓取,失败时停止推进。

    先修:具身智能实践(一):在 MuJoCo 中抓起方块,再故意抓偏

    项目 · Hohoo 具身实验 →实验 · E2 / 抓取确认后再搬运 →

    下一步:具身实践(三):抓住之后,还要一直确认吗? →

    12 分钟
  3. 探索 · 进阶

    具身实践(三):抓住之后,还要一直确认吗? →

    读后能做什么:持续监测搬运中的滑落,而不只检查起点。

    先修:具身实践(二):没抓住,就别继续搬运

    项目 · Hohoo 具身实验 →实验 · E3 / 搬运中的持续接触监测 →

    下一步:具身实践(四):消息还在到,观测已经过期了 →

    14 分钟
  4. 探索 · 进阶

    具身实践(四):消息还在到,观测已经过期了 →

    读后能做什么:按采样时间判断缺测与旧包。

    先修:具身实践(三):抓住之后,还要一直确认吗?

    项目 · Hohoo 具身实验 →实验 · E4 / 观测新鲜度与采样间隔 →

    下一步:具身智能实践(五):通信恢复了,为什么还不能立刻继续搬运? →

    14 分钟
  5. 探索 · 进阶

    具身智能实践(五):通信恢复了,为什么还不能立刻继续搬运? →

    读后能做什么:恢复通信后重新验收,再决定继续。

    先修:具身实践(四):消息还在到,观测已经过期了

    实验 · E5 / 观测恢复后的重新验收 →项目 · Hohoo 具身实验 →

    下一步:具身智能实践(六):恢复门控与路径重规划,各自解决了什么? →

    12 分钟
  6. 探索 · 进阶

    具身智能实践(六):恢复门控与路径重规划,各自解决了什么? →

    读后能做什么:分离恢复门控和路径重规划的影响。

    先修:具身智能实践(五):通信恢复了,为什么还不能立刻继续搬运?

    实验 · E6 / 恢复门控与路径消融 →项目 · Hohoo 具身实验 →

    下一步:具身智能实践(七):搬运规则,为什么会误停正常下降? →

    14 分钟
  7. 探索 · 进阶

    具身智能实践(七):搬运规则,为什么会误停正常下降? →

    读后能做什么:按阶段选择验收条件,避免下降时误触高度规则。

    先修:具身智能实践(六):恢复门控与路径重规划,各自解决了什么?

    实验 · E7 / 下降阶段的抓取契约 →项目 · Hohoo 具身实验 →

    下一步:具身智能实践(八):检测到掉落以后,夹爪应该做什么? →

    13 分钟
  8. 探索 · 进阶

    具身智能实践(八):检测到掉落以后,夹爪应该做什么? →

    读后能做什么:解释报警后保持、停止与撤离的物理后果。

    先修:具身智能实践(七):搬运规则,为什么会误停正常下降?

    实验 · E8 / 报警后的退出动作 →项目 · Hohoo 具身实验 →

    下一步:具身智能实践(九):松爪命令成功,不等于放置完成 →

    9 分钟
  9. 探索 · 进阶

    具身智能实践(九):松爪命令成功,不等于放置完成 →

    读后能做什么:用接触与稳定窗口验收释放结果。

    先修:具身智能实践(八):检测到掉落以后,夹爪应该做什么?

    实验 · E9 / 释放后的完成验收 →项目 · Hohoo 具身实验 →

    下一步:具身智能实践(十):恢复次数受控了,为什么任务反而没完成? →

    9 分钟
  10. 探索 · 进阶

    具身智能实践(十):恢复次数受控了,为什么任务反而没完成? →

    读后能做什么:给重新验收加时限,并保留终止原因。

    先修:具身智能实践(九):松爪命令成功,不等于放置完成

    实验 · E10 / 有界恢复与冷却 →项目 · Hohoo 具身实验 →

    下一步:具身智能实践(十一):已经放好了,为什么还要撤销“完成”? →

    9 分钟
  11. 探索 · 进阶

    具身智能实践(十一):已经放好了,为什么还要撤销“完成”? →

    读后能做什么:分开记录历史完成和当前有效性。

    先修:具身智能实践(十):恢复次数受控了,为什么任务反而没完成?

    实验 · E11 / 完成事件与当前有效性 →项目 · Hohoo 具身实验 →

    下一步:具身智能实践(十二):恢复预算耗尽之后,夹爪应该做什么? →

    11 分钟
  12. 探索 · 进阶

    具身智能实践(十二):恢复预算耗尽之后,夹爪应该做什么? →

    读后能做什么:检验终止后的撤离动作,而不把状态改名当安全。

    先修:具身智能实践(十一):已经放好了,为什么还要撤销“完成”?

    实验 · 具身智能实践(十二):恢复预算耗尽之后,夹爪应该做什么? →项目 · Hohoo 具身实验 →

    下一步:具身智能实践(十三):下降中断之后,应该从哪一步恢复? →

    12 分钟
  13. 探索 · 进阶

    具身智能实践(十三):下降中断之后,应该从哪一步恢复? →

    读后能做什么:连接阶段、恢复预算和退出动作。

    先修:具身智能实践(十二):恢复预算耗尽之后,夹爪应该做什么?

    实验 · 具身智能实践(十三):下降中断之后,应该从哪一步恢复? →项目 · Hohoo 具身实验 →

    下一步:具身智能实践(十四):方块落进盒子,就能宣布任务完成吗? →

    13 分钟
  14. 探索 · 进阶

    具身智能实践(十四):方块落进盒子,就能宣布任务完成吗? →

    读后能做什么:区分物理放置、当前有效与合格完成。

    先修:具身智能实践(十三):下降中断之后,应该从哪一步恢复?

    实验 · 具身智能实践(十四):方块落进盒子,就能宣布任务完成吗? →项目 · Hohoo 具身实验 →

    下一步:OpenVLA 代码导读:图像和一句指令,怎样变成机器人动作? →

    13 分钟
  15. 探索 · 进阶

    OpenVLA 代码导读:图像和一句指令,怎样变成机器人动作? →

    读后能做什么:追踪 OpenVLA 动作接口,不把导读当已完成训练。

    先修:Python 基础;教学仿真使用 MuJoCo 与直角坐标夹爪

    实验 · 动作表示学习记录 →

    下一步:MuJoCo 第二场景:目标位置相同,为什么有的控制器停不住? →

    12 分钟
  16. 探索 · 进阶

    MuJoCo 第二场景:目标位置相同,为什么有的控制器停不住? →

    读后能做什么:用二维力控执行器比较质量与PD阻尼,记录饱和、超调和稳定完成,避免把经过目标当作任务成功。

    先修:具身智能实践(十四):方块落进盒子,就能宣布任务完成吗?

    实验 · MuJoCo 第二场景:目标位置相同,为什么有的控制器停不住? →项目 · Hohoo 具身实验 →

    下一步:MuJoCo 绕障:路径上的点能过去,执行器就能过去吗? →

    9 分钟
  17. 探索 · 进阶

    MuJoCo 绕障:路径上的点能过去,执行器就能过去吗? →

    读后能做什么:六条实际接触轨迹对照直达、贴边和留余量路径,解释几何尺寸、跟踪误差与碰撞之间的关系。

    先修:MuJoCo 第二场景:目标位置相同,为什么有的控制器停不住?

    实验 · MuJoCo 绕障:路径上的点能过去,执行器就能过去吗? →项目 · Hohoo 具身实验 →

    下一步:MuJoCo 延迟观测:知道旧位置,能预测现在吗? →

    9 分钟
  18. 探索 · 进阶

    MuJoCo 延迟观测:知道旧位置,能预测现在吗? →

    读后能做什么:24条配对轨迹比较即时/80ms延迟、位置噪声和常速度外推,保留超调下降但任务仍失败的结果。

    先修:MuJoCo 绕障:路径上的点能过去,执行器就能过去吗?

    实验 · MuJoCo 延迟观测:知道旧位置,能预测现在吗? →项目 · Hohoo 具身实验 →

    下一步:MuJoCo 速度估计:滤掉噪声,也可能让控制更差 →

    9 分钟
  19. 探索 · 进阶

    MuJoCo 速度估计:滤掉噪声,也可能让控制更差 →

    读后能做什么:从位置差分推导噪声放大,复算平滑滞后、控制限幅与稳定完成判定。

    先修:MuJoCo 延迟观测:知道旧位置,能预测现在吗? · MuJoCo 第二场景:目标位置相同,为什么有的控制器停不住?

    实验 · MuJoCo 速度估计:滤掉噪声,也可能让控制更差 →项目 · Hohoo 具身实验 →

    下一步:MuJoCo控制调参:最优候选不等于验证通过 →

    11 分钟
  20. 探索 · 进阶

    MuJoCo控制调参:最优候选不等于验证通过 →

    读后能做什么:54个开发回合选择参数,36个留出回合复核位置误差与稳定完成契约。

    先修:MuJoCo 速度估计:滤掉噪声,也可能让控制更差

    实验 · 二维控制的调参、失联与迁移 →项目 · Hohoo 具身实验 →

    下一步:MuJoCo失联策略:零力不等于停止 →

    10 分钟
  21. 探索 · 进阶

    MuJoCo失联策略:零力不等于停止 →

    读后能做什么:27回合比较旧观测控制、超时置零与衰减,展示观测超时和物理制动的差别。

    先修:MuJoCo控制调参:最优候选不等于验证通过

    实验 · 二维控制的调参、失联与迁移 →项目 · Hohoo 具身实验 →

    下一步:MuJoCo质量迁移:同一套增益还能用吗? →

    10 分钟
  22. 探索 · 进阶

    MuJoCo质量迁移:同一套增益还能用吗? →

    读后能做什么:36回合对照固定和质量缩放增益,解释更低平均误差为何仍不能通过速度验收。

    先修:MuJoCo失联策略:零力不等于停止

    实验 · 二维控制的调参、失联与迁移 →项目 · Hohoo 具身实验 →
    10 分钟
后续计划 · 尚未发表
  1. 探索 · 计划选题

    什么是具身智能

  2. 探索 · 计划选题

    理解感知、决策与行动

  3. 探索 · 计划选题

    带着问题读一篇论文

  4. 探索 · 计划选题

    VLM 与 VLA

  5. 探索 · 计划选题

    Action Space

  6. 探索 · 计划选题

    Embodied Benchmark

检索 / RAG · 检索增强生成

Java、HTTP 与 JSON 基础;先理解检索候选与回答证据的区别。

已发布两篇离线实践:BM25 检索基线、闭合字段的引用校验。它们尚不能证明真实模型的回答质量,也不是完整的博客问答系统。

已发布的阅读顺序 · 2
  1. 检索 · 进阶

    Java LLM 实践(六):先验收检索证据,再谈RAG回答 →

    读后能做什么:复算 BM25 检索和无答案误命中,识别玩具语料的局限。

    先修:Java 8 调用大语言模型:从第一次请求到多轮对话

    实验 · 检索质量对照实验 →项目 · Java LLM 实践集 →

    下一步:Java LLM 实践(七):引用是真的,为什么答案仍然不能通过? →

    8 分钟
  2. 检索 · 进阶

    Java LLM 实践(七):引用是真的,为什么答案仍然不能通过? →

    读后能做什么:校验证据与声明对应,而不把规则匹配当语义蕴含。

    先修:Java LLM 实践(六):先验收检索证据,再谈RAG回答

    实验 · 检索质量对照实验 →项目 · Java LLM 实践集 →

    下一步:查看后续研究计划 →

    9 分钟
后续计划 · 尚未发表
  1. 检索 · 计划选题

    先固定语料,再比较分块

    建立可追溯文档与人工标注问题集,分开开发集与保留测试集。

    先修知识
    完成 BM25 基线;能区分文档、片段和引用。
    研究问题
    固定长度与标题分段会在哪些问题上丢失答案上下文?
    计划产物
    语料快照、文档版本与来源、带无答案题的标注集、两种分块脚本及逐题检索记录。
    如何验证
    固定分词、检索器和 top-k;报告 Recall@k、答案跨块丢失与重复召回案例。测试集不用于选择分块参数。

    回到前一步 ↑ · 下一步 →

  2. 检索 · 计划选题

    BM25、向量与混合检索怎么选

    在同一问题集上比较关键词匹配、语义召回与融合排序。

    先修知识
    已有冻结语料与相关性标注;了解 Embedding 与相似度。
    研究问题
    别名、精确编号与中英文混用分别在哪种检索策略下失败?
    计划产物
    固定模型版本的本地向量索引、BM25/向量/融合三组结果、排名与耗时明细。
    如何验证
    相同分块和候选预算下比较 Recall@k、MRR、索引大小及查询时间;记录混合检索不如单一路径的题目。

    回到前一步 ↑ · 下一步 →

  3. 检索 · 计划选题

    重排之后,哪些证据进入上下文

    在固定上下文预算里选择覆盖问题且不过度重复的证据。

    先修知识
    完成检索对照;了解 Token 预算和引用标识。
    研究问题
    重排、去重和截断分别改善或损坏了哪些证据?
    计划产物
    候选与重排前后清单、上下文组装器、引用映射及预算裁剪日志。
    如何验证
    逐项消融,比较排序质量、证据覆盖、重复比例和耗时;不把排序提高直接写成回答准确率提高。

    回到前一步 ↑ · 下一步 →

  4. 检索 · 计划选题

    从命中证据到回答质量与拒答

    分开衡量检索命中、引用是否支持断言,以及资料缺失时能否拒答。

    先修知识
    完成证据组装与引用契约;先冻结评分规范。
    研究问题
    加入检索后,哪些回答改善,哪些只是带上了不支持结论的引用?
    计划产物
    沿用 retrieval-eval:无检索/有检索的成对输出、模型与提示版本、人工证据支持标注、无答案和冲突题的失败记录。
    如何验证
    协议先行;真实模型运行尚未完成。单列正确性、引用支持、错误拒答与无依据作答,保留逐题输出和用量;涉及付费调用须另行授权。

    回到前一步 ↑ · 下一步 →

  5. 检索 · 计划选题

    知识更新、访问权限与检索注入

    保证被撤回、过期或无权访问的资料不会作为当前回答证据。

    先修知识
    已有文档版本、来源标识和可追溯上下文。
    研究问题
    索引更新与权限变化后,旧片段和缓存会不会继续泄露或误导?
    计划产物
    版本更新/删除/权限撤销的回归用例、索引与缓存失效记录、检索内容含恶意指令的本地夹具。
    如何验证
    权限在证据进入模型前检查;旧版本不可误标当前。外部文本始终是数据,模型不可据此扩大工具权限;本地通过不代表通用注入防御已解决。

    回到前一步 ↑ · 下一步 →

  6. 检索 · 计划选题

    整合:可追溯的博客问答

    把检索、证据、回答和失败处理接成一个可复现的最小应用。

    先修知识
    完成前述评估与安全边界;确认部署成本和产品范围。
    研究问题
    读者能否核对来源、识别资料缺失,并在失败时继续阅读原文?
    计划产物
    保留在 hohoo-ai-lab 的最小工程、固定语料和版本、安装命令、评估报告及来源/无证据/错误界面。
    如何验证
    从干净环境跑通索引到回答;复现失败与拒答,检查密钥仅在服务端。尚未部署,不把本阶段计为已完成产品。

    回到前一步 ↑

工程基础

Java · Python · TypeScript · HTTP · JSON

AI 应用与工程专题 →

阅读清单 · 研究总览 · 动手实践