六种主流Agent编排模式深度解析:从Workflow到Multi-Agent,助你打造稳定高效的智能系统!

本文系统解析Workflow、Routing、ReAct、Plan-and-Execute、Reflection和Multi-Agent六种主流Agent编排模式,明确其核心编排逻辑、适用场景与工程约束。强调选择本质是决策控制权分配:确定性环节交由代码,不确定性语义判断交由LLM。指出真实生产系统多采用组合模式,并给出选型路径建议——从Workflow起步,局部引入Agent,最后按需扩展Multi-Agent。

本文深入探讨了六种主流的Agent编排模式:Workflow、Routing、ReAct、Plan-and-Execute、Reflection和Multi-Agent。文章首先指出,这六种模式并非平级的“Agent架构”,而是解决不同层面问题的工具。接着,分别阐述了每种模式的编排核心、适用场景和实际应用案例,强调了它们之间的组合使用。文章最后指出,选择Agent架构的本质是决定“控制权应该放在哪里”,并推荐了一个从Workflow到局部引入Agent再到Multi-Agent的选型顺序,以最小化不确定性,解决原本无法通过确定性程序解决的问题。


做 Agent 开发时,经常会遇到这些词:

Workflow、Routing、ReAct、Plan-and-Execute、Reflection、Multi-Agent。

刚开始学很容易把它们理解成六种平级的“Agent 架构”,然后陷入一个问题:

我的项目到底应该选哪一种?

实际上,这种理解并不准确。

它们解决的是不同层面的问题:

  • Workflow:流程已经明确,怎么稳定执行?
  • Routing:有多条处理路径,应该走哪一条?
  • ReAct:路径未知,怎么边执行边决定下一步?
  • Plan-and-Execute:任务很复杂,怎么先规划再执行?
  • Reflection:第一次结果不好,怎么检查并改进?
  • Multi-Agent:一个 Agent 不够时,怎么让多个 Agent 分工协作?

而且这些模式不是互斥的。

一个真实的 Agent 系统,完全可能同时使用 Routing、Workflow、ReAct 和 Reflection。

所以这篇文章不准备堆太多概念,只围绕三个问题,把这 6 种模式讲清楚:

怎么编排?适合什么场景?实际项目里怎么用?


一、先看全局:6 种模式分别解决什么问题?

在深入每一种模式之前,可以先建立一张地图。

模式编排核心适用场景一句话理解
Workflow开发者预定义流程固定业务 SOP按设计好的流程执行
Routing动态选择处理分支多意图、多任务类型先判断走哪条路
ReAct根据执行结果动态决策路径无法提前确定边执行边决定
Plan-and-Execute先规划,再执行长链路复杂任务先想清楚怎么做
Reflection生成、评价、修改有明确质量标准做完以后再检查
Multi-Agent多个 Agent 分工协作专业能力边界明显不同专家各司其职

如果只记一件事:

选择 Agent 架构,本质上是在决定“控制权应该放在哪里”。

哪些步骤交给代码控制,哪些判断交给 LLM,哪些任务再拆给其他 Agent。


二、六种主流 Agent 编排模式

  1. Workflow:流程已知,就不要让模型自由发挥

Workflow 是最容易理解,也是在生产系统里最常见的一种模式。

编排模式

Workflow 的核心是:

开发者提前定义任务有哪些步骤,以及步骤之间如何流转。

例如一个航司退改规则解析服务:

原始文本先做清洗,然后提取关键片段,再调用 LLM 做结构化解析,接着执行 Schema 校验、风险判断,最后完成结果标准化。

这里虽然用了 LLM,但整个流程依然属于 Workflow。

原因很简单:

LLM 只负责完成某个节点,下一步执行什么依然是代码决定的。

Workflow 也不意味着只能线性执行。

它完全可以包含:

  • 条件分支;
  • 并行执行;
  • Retry;
  • 循环;
  • Human-in-the-loop;
  • LLM Judge。

所以判断一个系统是不是 Workflow,关键不是“有没有模型”,而是:

整体执行路径是不是主要由程序提前定义。

适用场景

Workflow 最适合:

  • 业务步骤明确;
  • 流程相对稳定;
  • 需要强可控性;
  • 对结果和风险要求高。

典型场景包括:

文档解析、合同信息提取、审批、订单退款、RAG 数据处理 Pipeline。

尤其是涉及资金、权限、数据库写操作的流程,能确定的部分尽量不要交给模型自由决策。

具体例子

例如合同信息提取。

业务要求非常明确:

先解析文件,再调用模型提取合同主体、金额、日期等字段,然后做字段校验,校验失败进入人工审核。

这种场景没有必要做成 ReAct Agent。

Workflow 已经足够,而且更加稳定。


  1. Routing:先判断问题属于哪一类

Routing 解决的问题不是“具体怎么完成任务”,而是:

这个任务应该交给谁处理?

编排模式

Routing 的典型流程是:

输入 → 分类 → 选择对应处理流程。

例如一个智能客服系统支持:

  • 退票;
  • 改签;
  • 行程单;
  • 联系人修改;
  • 会员添加。

用户说:

我的航班取消了,可以帮我退票吗?

Router 判断为:

refund

系统再进入退款处理流程。

如果用户问:

帮我修改一下订单联系人手机号。

则路由到:

contact_modify

Router 可以通过规则、传统分类模型,也可以通过 LLM Structured Output 实现。

适用场景

Routing 适合:

业务类型有限且明确,但不同类型的处理流程差异较大。

例如:

  • 智能客服;
  • 企业 AI 助手;
  • 多知识库 RAG;
  • Text-to-SQL;
  • 多工具业务系统。

它最大的价值是:

先缩小问题空间,再让后面的 Agent 工作。

具体例子

例如企业 AI 助手同时支持“问知识”和“查数据”。

用户问:

公司年假是多少天?

路由到 RAG 知识库。

用户问:

上个月国际机票订单量是多少?

路由到 Text-to-SQL。

这种场景如果把数据库、知识库、搜索、业务 API 全部丢给一个 ReAct Agent 自己判断,虽然也能做,但决策空间明显更大。

先 Routing,系统通常会更稳定。


  1. ReAct:路径不知道,就边执行边判断

ReAct 是 Agent 领域最经典的模式之一。

它最核心的特点是:

下一步做什么,不是提前写死,而是根据刚刚执行得到的结果动态决定。

编排模式

可以把 ReAct 理解成一个循环:

Decision → Action → Observation → New Decision

模型先判断当前应该执行什么 Action。

Action 通常是调用 Tool。

Tool 返回结果后,模型读取新的 Observation,再判断下一步该做什么。

一直循环,直到任务完成。

适用场景

ReAct 适合一个非常明确的条件:

不执行前一步,就无法确定下一步。

例如:

  • 故障诊断;
  • 搜索调研;
  • 动态工具调用;
  • 智能客服复杂问题;
  • 运维 Agent;
  • 数据分析 Agent。

这种任务的执行路径通常无法在开发阶段完整枚举。

具体例子

用户问:

为什么订单服务今天突然变慢了?

Agent 先查 Prometheus。

发现数据库查询耗时异常,于是继续查询数据库监控。

发现连接数很高,再检查慢 SQL。

最终定位到某个查询出现全表扫描。

在任务开始之前,你无法提前规定:

查询 Prometheus 后一定要查慢 SQL。

后续动作取决于实际 Observation。

这就是非常典型的 ReAct。

ReAct 最大的工程问题

灵活性的另一面是不确定性。

例如:

  • 连续重复调用同一个 Tool;
  • 在两个 Tool 之间循环;
  • 调用了错误工具;
  • Token 越来越多;
  • 任务一直不结束。

所以生产环境做 ReAct,通常还要增加:

Max Steps、Timeout、Loop Detection、Tool 幂等、Checkpoint、HITL。

否则做出来的只是一个 Demo Agent,而不是可靠的 Agent Runtime。


  1. Plan-and-Execute:复杂任务先做全局规划

ReAct 擅长动态决策,但对于特别长的任务,它容易出现一个问题:

一直关注眼前下一步,却缺少全局视角。

这就是 Plan-and-Execute 解决的问题。

编排模式

Plan-and-Execute 把任务拆成两个阶段:

Planning + Execution

先由 Planner 根据用户目标生成计划,再交给 Executor 执行。

例如用户要求:

调研 LangGraph、AutoGen、CrewAI,并给出 Agent 框架选型建议。

Planner 可以先拆成:

  1. 确定比较维度;
  2. 分析三个框架定位;
  3. 对比 Tool 能力;
  4. 对比状态管理;
  5. 对比 Multi-Agent;
  6. 分析优缺点;
  7. 输出选型结论。

然后 Executor 再逐项完成。

比较完整的架构还会加入 Replanner。

当实际执行结果与预期不一致时,动态调整剩余计划。

适用场景

Plan-and-Execute 更适合:

  • 复杂长任务;
  • 多个子目标;
  • Deep Research;
  • 长周期 Coding Task;
  • 数据分析报告;
  • 项目级自动化任务。

判断依据不是:

“需要调用很多 Tool。”

而是:

任务本身是否需要先做全局拆解。

具体例子

例如:

分析一个大型开源 Agent 项目,重点研究架构、Memory、Tool、Multi-Agent 和工程实现。

如果直接使用 ReAct,模型可能看到哪里分析到哪里,容易遗漏。

Plan-and-Execute 会先形成完整研究计划,再逐步执行。

而且有一点很重要:

Plan-and-Execute 和 ReAct 可以组合。

Planner 负责拆解整个任务。

而“分析 Memory 模块”这个具体 Step,又可以交给一个 ReAct Agent 去动态搜索代码、读取文件、继续追踪引用关系。

所以可以理解为:

Plan-and-Execute 负责任务级规划,ReAct 负责步骤级动态执行。


  1. Reflection:结果不好,就让系统自己发现问题

很多 AI 任务第一次生成的结果并不一定可靠。

例如:

  • SQL 漏了过滤条件;
  • 代码单元测试失败;
  • JSON 缺少字段;
  • 报告没有满足要求。

Reflection 就是针对这一类问题。

编排模式

Reflection 最典型的模式是:

Generate → Evaluate → Improve

先生成。

再检查。

如果发现问题,把反馈重新提供给 Generator,要求修正。

直到达到要求,或者超过最大迭代次数。

这里的 Evaluator 不一定必须是另一个 LLM。

它可以是:

  • 单元测试;
  • Schema Validator;
  • SQL 执行器;
  • Compiler;
  • 业务规则;
  • LLM Judge。

生产环境里有一个很重要的原则:

能用程序确定性检查的内容,优先用程序,不要全部依赖 LLM 自我反思。

适用场景

Reflection 适合:

存在相对清晰的评价标准,并且结果允许迭代改进。

例如:

  • Coding Agent;
  • Text-to-SQL;
  • 结构化抽取;
  • 报告生成;
  • Prompt 优化。

具体例子

Text-to-SQL Agent 第一次生成:

SELECT * FROM orders WHERE create_time >= ...

SQL Checker 发现:

用户问的是退款订单,但是 SQL 中没有 refund_status 条件。

于是将这个问题反馈给 Generator。

模型重新生成 SQL,再次执行校验。

这就是典型的 Reflection。

需要注意:

Reflection 的关键不是“让模型再想一遍”,而是提供新的评价信号。

如果只是把同样的问题重新问一次模型,严格来说不算一个好的 Reflection 设计。


  1. Multi-Agent:一个 Agent 不够,再进行专业化分工

Multi-Agent 很容易被过度设计。

很多项目本来一个 Agent 就能完成,却为了体现“Agent 架构”拆出五六个 Agent。

其实 Multi-Agent 真正适合的是:

不同任务之间存在明显的专业能力边界。

编排模式

Multi-Agent 的核心不是“数量多”,而是:

如何进行角色分工和控制权转移。

例如一个 AI 研发团队:

  • Product Agent;
  • Architect Agent;
  • Backend Agent;
  • Frontend Agent;
  • Test Agent。

再由 Leader / Supervisor 负责:

  • 拆解任务;
  • 分配任务;
  • 汇总结果;
  • 决定下一步。

也可以使用 Handoff。

例如客服入口 Agent 判断用户的问题属于退款,就直接把后续对话移交 Refund Agent。

适用场景

当不同子任务存在明显的:

  • Prompt 差异;
  • Tool 差异;
  • Context 差异;
  • 权限差异;
  • 专业能力差异;

才值得考虑 Multi-Agent。

如果只是任务步骤很多,通常:

Workflow + Single Agent

或者:

Plan-and-Execute + ReAct

已经足够。

具体例子

例如 AI 自动研发系统。

Product Agent 根据需求生成 PRD。

Architect Agent 根据 PRD 设计 API 和数据库。

Backend Agent 编写后端代码。

Frontend Agent 完成页面。

Test Agent 根据 PRD 和接口进行测试。

这种场景每个 Agent 的上下文、Skill、Tool 和职责都明显不同。

Multi-Agent 才真正发挥价值。


三、到底应该怎么选?

不要从“哪个架构更高级”出发,而要从业务不确定性出发。

可以用下面几个问题快速判断。

你的问题优先考虑
执行步骤是不是已经明确?Workflow
是不是先要判断任务属于哪一类?Routing
下一步必须根据上一步结果决定?ReAct
任务是不是很长,需要先拆解?Plan-and-Execute
结果能不能明确判断好坏并不断优化?Reflection
不同子任务是否存在明显专业边界?Multi-Agent

实际项目里,我更推荐这样一个顺序:

先考虑 Workflow,再考虑局部引入 Agent,最后才考虑 Multi-Agent。

原因很简单:

模型每多获得一部分控制权,就会增加一部分不确定性。

因此生产系统真正追求的不是:

Agent 自主程度最高。

而是:

用尽可能少的不确定性,解决原本无法通过确定性程序解决的问题。

可以把这个原则概括成一句话:

确定性逻辑交给代码,不确定性的语义判断交给模型。


四、真实生产系统往往是组合模式

六种模式并不是六选一。

例如一个企业智能客服系统完全可能这样设计。

首先使用 Routing 判断:

当前属于退票、改签还是其他业务。

进入退款场景后,身份校验、订单状态检查、退款审批使用固定 Workflow。

如果遇到复杂航变问题,则交给 ReAct Agent 动态查询订单、PNR、航班和航司规则。

如果任务是:

帮用户制定一个涉及多个航段的完整改签方案。

可以使用 Plan-and-Execute 先规划。

模型得到结果后,再通过 Reflection 检查方案是否满足业务规则。

如果未来退款、改签、航变分别由独立专家负责,还可以进一步拆成 Multi-Agent。

所以一个成熟的 Agent 系统,真正重要的不是给自己贴上:

“这是一个 ReAct Agent。”

而是:

在不同环节选择合适的控制模式。


五、面试中怎么回答 Agent 架构问题?

下面这些问题,基本覆盖了 Agent 架构相关的高频面试方向。

面试题 1:Workflow 和 ReAct 最大的区别是什么?

可以这样回答:

最核心的区别是下一步执行什么由谁决定。

Workflow 的执行路径主要由代码提前定义,所以稳定性、可测试性和可控性更高。

ReAct 则由 LLM 根据每一步 Tool 返回的 Observation 动态决定下一步 Action,更适合无法提前确定执行路径的任务。

在生产项目中我一般不会二选一,而是外层使用 Workflow 控制整体流程,在确实需要动态工具选择的节点内部使用 ReAct。

最后一句比较重要。

它说明你理解的是混合架构,而不只是概念。


面试题 2:什么时候会选择 ReAct?

回答重点不是“需要调用工具”。

可以这样回答:

我判断是否使用 ReAct 的关键是:下一步是否依赖运行时 Observation。

如果执行路径可以提前确定,就使用 Workflow。

如果必须先调用一个工具,根据结果才能决定后续动作,比如故障排查、搜索调研或者复杂客服场景,就比较适合 ReAct。

它的代价是路径、Token 和延迟都更难预测,所以生产环境还要配套 Loop Detection、Max Steps、Timeout 和 Tool 幂等。


面试题 3:ReAct 和 Plan-and-Execute 怎么选择?

可以回答:

ReAct 更偏局部动态决策,模型执行一步以后,根据 Observation 决定下一步,所以比较适合短链路、路径不确定的任务。

Plan-and-Execute 更强调全局规划,会先把复杂目标拆成多个 Step,再逐步执行,适合 Deep Research、长周期 Coding Task 等复杂任务。

两者也可以组合,外层用 Planner 做任务级拆解,具体 Step 再使用 ReAct Agent 执行。


面试题 4:Routing 和 ReAct 都能选工具,两者有什么区别?

这是一个很好的区分题。

可以回答:

Routing 更像一次或者少量几次的分类决策,它通常是在若干条已知路径中选择一条。

比如先判断用户是退票还是改签,然后进入对应 Workflow。

ReAct 则是一个持续的 Agent Loop,每执行一个 Action 得到新的 Observation 后,都可能重新决定下一步做什么。

所以 Routing 解决的是“走哪条已知路径”,ReAct 解决的是“路径本身无法提前确定”。


面试题 5:Reflection 是不是让模型自己检查自己?

可以回答:

可以这样理解,但工程实现里不应该只依赖模型自我评价。

Reflection 的核心是 Generate、Evaluate、Improve。Evaluator 可以是另一个 LLM,也可以是单元测试、Schema Validation、SQL 执行结果或者业务规则。

我更倾向于确定性问题使用程序评价,例如 JSON Schema、SQL 执行错误;只有语义质量这种无法规则化的问题,再使用 LLM Judge。

这样比单纯让模型“再想一遍”更加可靠。


面试题 6:什么时候才需要 Multi-Agent?

可以回答:

我不会因为任务复杂就直接使用 Multi-Agent。

只有不同子任务之间存在明显的 Prompt、Tool、Context、权限或者专业能力边界时,我才会考虑拆成多个 Agent。

比如研发场景中的产品、架构、开发和测试,它们的职责和上下文明显不同,就比较适合专业化 Agent。

如果只是执行步骤比较多,Plan-and-Execute 或单 Agent 通常更简单。


面试题 7:为什么生产环境不建议把所有流程都做成 Agent?

可以这样回答:

因为 Agent 的自由度本身就是一种不确定性。

像权限校验、金额计算、数据库事务、状态机迁移、幂等这些逻辑本身就是确定性的,没有必要让模型决策。

我一般会把确定性流程固化成代码或 Workflow,只把自然语言理解、复杂语义判断、动态工具选择和任务规划交给模型。

本质上就是用确定性的工程系统约束 LLM 的不确定性。


面试题 8:ReAct 出现工具循环调用怎么办?

可以分两层回答。

第一层是资源保护:

  • Max Steps;
  • Timeout;
  • Token Budget。

第二层是主动恢复:

  • 保存 Action History;
  • 检测相同 Tool + 参数的重复调用;
  • 判断执行状态是否长期没有变化;
  • 触发 Replan 或 Recovery;
  • 必要时进入 HITL。

所以一句话:

Max Steps 只是防止无限运行,Loop Detection + Replan 才是真正解决 Agent 恢复的问题。


最后

对于正在迷茫择业、想转行提升,或是刚入门的程序员、编程小白来说,有一个问题几乎人人都在问:未来10年,什么领域的职业发展潜力最大?

答案只有一个:人工智能(尤其是大模型方向)

当下,人工智能行业正处于爆发式增长期,其中大模型相关岗位更是供不应求,薪资待遇直接拉满——字节跳动作为AI领域的头部玩家,给硕士毕业的优质AI人才(含大模型相关方向)开出的月基础工资高达5万—6万元;即便是非“人才计划”的普通应聘者,月基础工资也能稳定在4万元左右。

再看阿里、腾讯两大互联网大厂,非“人才计划”的AI相关岗位应聘者,月基础工资也约有3万元,远超其他行业同资历岗位的薪资水平,对于程序员、小白来说,无疑是绝佳的转型和提升赛道。

如果你还不知道从何开始,我自己整理一套全网最全最细的大模型零基础教程,我也是一路自学走过来的,很清楚小白前期学习的痛楚,你要是没有方向还没有好的资源,根本学不到东西!

下面是我整理的大模型学习资源,希望能帮到你。

👇👇扫码免费领取全部内容👇👇

在这里插入图片描述

1、大模型学习路线

2、从0到进阶大模型学习视频教程

从入门到进阶这里都有,跟着老师学习事半功倍。

3、 入门必看大模型学习书籍&文档.pdf(书面上的技术书籍确实太多了,这些是我精选出来的,还有很多不在图里)

4、 AI大模型最新行业报告

2026最新行业报告,针对不同行业的现状、趋势、问题、机会等进行系统地调研和评估,以了解哪些行业更适合引入大模型的技术和应用,以及在哪些方面可以发挥大模型的优势。

5、面试试题/经验

【大厂 AI 岗位面经分享(107 道)】

【AI 大模型面试真题(102 道)】

【LLMs 面试真题(97 道)】

6、大模型项目实战&配套源码

适用人群

四阶段学习规划(共90天,可落地执行)
第一阶段(10天):初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识,对大模型 AI 的理解超过 95% 的人,可以在相关讨论时发表高级、不跟风、又接地气的见解,别人只会和 AI 聊天,而你能调教 AI,并能用代码将大模型和业务衔接。

  • 大模型 AI 能干什么?
  • 大模型是怎样获得「智能」的?
  • 用好 AI 的核心心法
  • 大模型应用业务架构
  • 大模型应用技术架构
  • 代码示例:向 GPT-3.5 灌入新知识
  • 提示工程的意义和核心思想
  • Prompt 典型构成
  • 指令调优方法论
  • 思维链和思维树
  • Prompt 攻击和防范
  • …
第二阶段(30天):高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习,学会构造私有知识库,扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架,抓住最新的技术进展,适合 Python 和 JavaScript 程序员。

  • 为什么要做 RAG
  • 搭建一个简单的 ChatPDF
  • 检索的基础概念
  • 什么是向量表示(Embeddings)
  • 向量数据库与向量检索
  • 基于向量检索的 RAG
  • 搭建 RAG 系统的扩展知识
  • 混合检索与 RAG-Fusion 简介
  • 向量模型本地部署
  • …
第三阶段(30天):模型训练

恭喜你,如果学到这里,你基本可以找到一份大模型 AI相关的工作,自己也能训练 GPT 了!通过微调,训练自己的垂直大模型,能独立训练开源多模态大模型,掌握更多技术方案。

到此为止,大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗?

  • 为什么要做 RAG
  • 什么是模型
  • 什么是模型训练
  • 求解器 & 损失函数简介
  • 小实验2:手写一个简单的神经网络并训练它
  • 什么是训练/预训练/微调/轻量化微调
  • Transformer结构简介
  • 轻量化微调
  • 实验数据集的构建
  • …
第四阶段(20天):商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知,可以在云端和本地等多种环境下部署大模型,找到适合自己的项目/创业方向,做一名被 AI 武装的产品经理。

  • 硬件选型

  • 带你了解全球大模型

  • 使用国产大模型服务

  • 搭建 OpenAI 代理

  • 热身:基于阿里云 PAI 部署 Stable Diffusion

  • 在本地计算机运行大模型

  • 大模型的私有化部署

  • 基于 vLLM 部署大模型

  • 案例:如何优雅地在阿里云私有部署开源大模型

  • 部署一套开源 LLM 项目

  • 内容安全

  • 互联网信息服务算法备案

  • …

    👇👇扫码免费领取全部内容👇👇

    在这里插入图片描述

3、这些资料真的有用吗?

这份资料由我和鲁为民博士(北京清华大学学士和美国加州理工学院博士)共同整理,现任上海殷泊信息科技CEO,其创立的MoPaaS云平台获Forrester全球’强劲表现者’认证,服务航天科工、国家电网等1000+企业,以第一作者在IEEE Transactions发表论文50+篇,获NASA JPL火星探测系统强化学习专利等35项中美专利。本套AI大模型课程由清华大学-加州理工双料博士、吴文俊人工智能奖得主鲁为民教授领衔研发。

资料内容涵盖了从入门到进阶的各类视频教程和实战项目,无论你是小白还是有些技术基础的技术人员,这份资料都绝对能帮助你提升薪资待遇,转行大模型岗位。

这份完整版的大模型 AI 学习资料已经上传CSDN,朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

在这里插入图片描述

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值