大模型开发模式

开发模式

如何接入大模型？

模式总结

人机协同三种模式

AI Embedded 嵌入：某个环节里去调用大模型
- 使用提示词来设定目标，与AI进行语言交流，然后AI协助完成目标
AI Copilot 辅助：每个环节都可以跟大模型进行交互
- 人类和AI各自发挥作用，AI介入到工作流程中，从提供建议到协助完成流程的各个阶段。
AI Agent 代理：任务交给大模型，大模型即可自行计划、分解和自动执行
- 人类设定目标并提供资源（计算能力），然后监督结果。
- Agent承担了大部分工作。
- AutoGPT代表了一种完全自动化的实现方式，试图抵达AGI的理想状态，即提出需求后机器人能够自动完成任务
- AI技术的自动化范式 —— AutoGPT
- 基于Agents的自动化团队——GPTeam，许多流程都可以被自动化执行。市场调研、问卷调查、品牌计划等等，都可以由AI来完成。
- 自动化品牌营销公司——AutoCorp
Society 模式

【2023-11-21】更完整的图解

【2023-9-9】多智能体框架 MetaGPT 作者洪思睿
未来人机交互范式也会从嵌入式模式，发展到辅助模式，再到代理模式，最终达到人机深度协作的社会化模式。在这个模式下，人类和智能体既可以自主提出需求，也可以相互提供资源来完成任务。
未来互联网的门户也将从 App 变成智能体。用户只需要向单个或多个智能体提出需求，由智能体负责完成整个工作流程，包括调用不同的软件程序、设定参数等。这将极大提升人机协同的效率，更进一步带来生活和工作方式的变革。

第三种模式将成为未来人机交互的主要模式。

方案一：AI Copilot 辅助

以LLM为核心，end2end架构实现新版对话系统，用prompt engineering复现原有主要模块

既然大模型（尤其是GPT系列）这么厉害，下游任务只需调prompt，那就用prompt去完成对话功能，替换原有功能模块就好了。

角色模拟：system prompt中设置即可，大模型的强项
闲聊任务：满足，一次调用即可
简易问答：如果是通用领域知识，一次调用即可，如果是垂直领域，需要额外融入知识（prompt中植入/微调），如果涉及实时查询、工具，还需要结合Plugin、Function Call，一般1-3次调用
多轮任务：prompt中设置对话逻辑（类似上一代有限状态机FSM），简单任务满足，功能接口借助Plugin、Function Call实现，同时增加记忆单元（如借助LangChain），但复杂任务不好办，如：任务状态处理逻辑复杂、场景嵌套、API较多等。即便是FSM场景也受限（如图），而订餐这类场景只是多轮对话中的一种简单形式，至于更复杂的循环、中断、嵌套、多阶就不用提了，如信用卡业务场景下，各种流程跳转，简易对话无能为力，只好用比FSM（图）更高级的方法，Frame（槽填充+树）、Goal（树+栈+字典），大模型用data-driven结合强化学习更合适。

推荐型：边聊边推，设计推荐的prompt，一次调用，但依赖具体形态，聊天场景推荐对时延要求低，启用流式输出可以缓冲，而输入是输入提示这类场景，大模型的速度就堪忧了。

全部采用大模型后，以常规的对话系统为例，一次对话过程可能涉及1~10次大模型调用，这用户体验可想而知。

这种思路是把原来对话系统所有的功能都用生成式方法（自回归语言模型，GPT为代表）解决，实际上，生成式只是小部分，大部分任务是理解式任务（掩码语言模型，BERT为代表），如意图识别、槽位抽取、状态跟踪等输出空间有限，这时用生成式方法，天然就慢半拍。

实际落地时，新的问题出来了：

极度依赖prompt：提示语稍微变更下，加个空格，结果可能就相差十万八千里，每个场景都需要仔细调试prompt，换个模型又要重新开始。
速度慢：实在是慢，正常情况1-3s回复，如果句子长，要持续等待，直至流式输出结束。这对高并发、低时延要求的对话产品简直是“噩耗”。
不可控：即便在prompt里明确要求不要超过30字，结果LLM当成耳边风，还是会超出字数。任务型对话里的业务处理逻辑往往要求准确无误了。
幻觉：一本正经的胡说八道
黑盒：大模型到底是怎么执行对话策略的？不知道，充满了玄学意味，涌现到底是个啥？这对高度可控的场景十分致命。

对于速度问题，短期内只能依靠别的方法提速了，如：

各种模型加速推理技术
部分功能回退：如不适合生成式方法的NLU/DM
推进end2end方法：将多轮会话训入大模型，延续之前的end2end思路

方案二：AI Embedded 嵌入

在LLM基础上，加领域语料，增量预训练、微调，融入领域知识，根据业务场景，增加特殊逻辑

这部分涉及两部分工作

基座大模型训练：各行各业都在训自己的大模型，金融、医疗、教育、数字人，甚至宗教
业务场景落地：适配业务场景，升级或重构现有对话产品的局部

各行各业都在训自己的大模型，金融、医疗、教育、数字人，甚至宗教

人物个性模拟上

国外有 Character.ai，用户根据个人偏好定制 AI 角色并和它聊天；
国内有阿里的脱口秀版GPT——鸟鸟分鸟，并且已经在天猫精灵上为个人终端行业的客户做了演示

应用场景很多，略

方案三：AI Agent 代理

抛弃过往模块化思路，站在任务角度，通过Agent去执行对话任务，如：

最近不少人不再卷大模型了，开始卷 AI Agents

LLM诞生之初，大家对于其能力的边界还没有清晰的认知，以为有了LLM就可以直通AGI了，路线: LLM -> AGI
过了段时间，发现LLM的既有问题（幻觉问题、容量限制…），并不能直接到达AGI，于是路线变成了: LLM -> Agent -> AGI
借助一个/多个Agent，构建一个新形态，继续实现通往AGI的道路。但这条路是否能走通，以及还面临着哪些问题，有待进一步验证。

由于大模型的出现，AI Agents 衍生出了一种新的架构形式: 《LLM Powered Autonomous Agents》

将最重要的「任务规划」部分或完全交由LLM，而做出这一设计的依据在于默认：LLM具有任务分解和反思的能力。

最直观的公式

Agent = LLM + Planning + Feedback + Tool use

这种思路更加灵活，贴近AGI，想象空间巨大，成为继模型训练后又一个角斗场。

详见往期文章：大模型智能体

方案四：AI Society 模式

一般应用于复杂社交场景，如群体游戏，斯坦福小镇

详见站内专题：大模型智能体

LLM 开发范式

开发范式总结

总结: 预训练(pre-training) → 微调(fine-tune) → 提示工程(prompt engineering)

（1）pre-training(预训练)： 通识教育，教小孩认字、学算数、做推理，这个步骤产出基础大模型。
（2）fine-tune(微调)：专业课，比如学法律的会接触一些法律的条款、法律名词；学计算机的会知道什么叫计算机语言。
（3）prompt engineering(提示工程)：职业训练，AI应用的准确率要达到商用级别（超过人的准确率），就需要 prompt engineer，PE 重要性

有些场景中（2）可以省略。

开发范式演进

LLM时代Prompt Engineer开发范式

第一层：简单Prompt: 即编写一个提示词（Prompt）去调用大模型，最简单。
第二层：Plugin插件: 用大模型插件（Plugin）去调各种API，以及Function Call。
第三层：Prompt Engineering Workflow + OpenAI API
- 基于提示词工程的工作流（workflow）编排。AI应用就是基于工作流实现。
第四层：向量数据库集成 RAG
- 向量数据库包含数据特征值，落地方案如 VectorDB，包括做知识库、做客服机器人。
第五层：AI Agents, 让大模型自己做递归。
- Agent 原理: AI自己对任务进行拆解，再进一步递归、继续拆解，直到有一步，AI可以将这个任务执行，最后再将任务合并起来，往前递归回来，合并为一个工程。
第六层：领域模型 Domain Model
- 专业模型为什么重要？大参数基础模型的训练和推理成本非常高，而专业模型速度快、成本低、准确率高，因为有行业的高质量数据，所以准确率高；进而可以形成数据飞轮，形成自己的竞争优势。

2024.11.6 斯坦福 DSPy

【2024-11-6】告别繁琐提示词，斯坦福DSPy框架开创LLM开发新思路，Star突破1.8万

斯坦福大学NLP小组推出一款革命性框架 - DSPy, 颠覆了传统 LLM开发方式。

不同于繁琐的手写提示词,DSPy采用编程式声明与组合,为大模型应用开发带来全新体验

DSPy 代表了 LLM 应用开发的一个重要趋势: 将软件工程的最佳实践引入 LLM 开发。我们可以期待:

更多预制模块的出现
与主流开发框架的深度集成
更强大的优化器
更完善的评估体系

问题

传统 LLM 应用开发中,经常遇到这些痛点:

提示词工程过于依赖经验和技巧
难以保证输出的一致性和可靠性
复杂任务提示词难以维护和迭代
缺乏系统化的评估和优化方法

法律文档分析系统,传统方式:

# 传统方式
response = llm.complete("""
  请分析以下法律文档的关键条款:
  {document}
  要求:
  1. 提取主要条款
  2. 识别潜在风险
  3. 给出建议
""")

明显问题:

• 提示词难以复用
• 输出质量不稳定
• 难以进行系统优化

DSPy 思维编程

DSPy 引入了”思维编程“(Thought Programming)的概念,像编写普通程序一样来设计 LLM 推理过程。

模块化设计
自动优化能力：内置 Teleprompter 优化器

DSPy 核心思想是将 LLM 的使用过程抽象为可编程模块。

通过以下机制实现:

签名系统
推理链优化

模块化设计

模块化设计带来多个优势:

• 每个步骤都可以独立优化
• 逻辑清晰,易于维护
• 可以复用到其他类似任务

升级后的代码

import dspy

class LegalAnalyzer(dspy.Module):
    def __init__(self):
        super().__init__()
        self.extract = dspy.Predict('document -> key_clauses')
        self.analyze = dspy.Predict('key_clauses -> risks')
        self.suggest = dspy.Predict('risks -> suggestions')
    
    def forward(self, document):
        # 步骤1: 提取关键条款
        clauses = self.extract(document=document)
        # 步骤2: 风险分析
        risks = self.analyze(key_clauses=clauses)
        # 步骤3: 给出建议
        suggestions = self.suggest(risks=risks)
        
        return {
            'clauses': clauses,
            'risks': risks,
            'suggestions': suggestions
        }

# 使用方式
analyzer = LegalAnalyzer()
result = analyzer.forward(document_text)

自动优化能力

DSPy 亮点是内置了 Teleprompter 优化器:

# 准备训练数据
trainset = [
    (doc1, expert_analysis1),
    (doc2, expert_analysis2),
    # ...
]

# 自动优化提示词
teleprompter = dspy.Teleprompter()
optimized_analyzer = teleprompter.optimize(
    LegalAnalyzer,
    trainset,
    metric=dspy.Metrics.Accuracy
)

这个优化过程会:

• 自动发现最佳提示词模板
• 优化推理链路
• 提高输出质量

评估框架

DSPy 提供了完整的评估系统:

# 定义评估指标
class LegalMetrics(dspy.Metric):
    def __call__(self, pred, gold):
        accuracy = self.compare_analysis(pred, gold)
        completeness = self.check_completeness(pred)
        return (accuracy + completeness) / 2

# 进行评估
evaluator = dspy.Evaluate(
    metric=LegalMetrics(),
    num_threads=4
)
scores = evaluator(optimized_analyzer, testset)

案例

实战案例

案例1: 智能客服系统
案例2: 文档总结系统

详见原文告别繁琐提示词，斯坦福DSPy框架开创LLM开发新思路，Star突破1.8万

建议使用方式:

模块设计原则 • 保持单一职责 • 清晰定义输入输出 • 适度颗粒度划分
优化策略 • 收集高质量的训练数据 • 设计合理的评估指标 • 渐进式优化而非一蹴而就
部署考虑 • 做好错误处理 • 设置超时机制 • 实现监控和日志

LLM应用架构范式

【2024-3-25】大模型应用的10种架构模式

路由分发模式: 将用户query发到控制中心，分发到不同领域小模型/大模型。更准确、响应更快且成本更低，平衡成本/性能与体验
大模型代理模式: 大模型充当代理角色，分析用户意图，结合上下文路由到不同专有小模型，适合复杂问题解
多任务微调模式: 微调大模型，同时处理多个任务，适合复杂任务平台, 如虚拟助理或是人工智能驱动的研究工具。
面向微调的分层缓存策略模式: 将缓存策略和相关服务引入大模型应用架构，解决成本、数据冗余以及训练数据等组合问题。
- 缓存初始QA结果, 积累到一定量后, 微调训练专有小模型，同时参考缓存和专用模型，适合高准确、适应性环境, 如客户服务或个性化内容创建
- 工具： GPTCache，或缓存数据库，如 Redis、Cassandra、Memcached 运行服务
混合规则模式: 将大模型与业务规则逻辑结合，适合需要严格遵守标准或法规的行业或产品，如电话IVR系统或基于规则的传统（非LLM）聊天机器人的意图和消息流
知识图谱模式: 将知识图谱与大模型结合，赋予面向事实的超级能力，使得输出不仅具有上下文情境，而且更加符合事实。
- 适合: 要求内容真实性和准确性的应用，比如在教育内容创作、医疗咨询或任何误导可能带来严重后果的领域
- 知识图谱及其本体将复杂主题或问题分解成结构化格式，为大型语言模型提供深层上下文基础。甚至可以借助语言模型，以JSON或RDF等格式创建本体。
- 构建知识图谱的图数据库服务: ArangoDB、Amazon Neptune、Google Dgraph、Azure Cosmos DB以及Neo4j等。此外，更广泛的数据集和服务也能用于访问更全面的知识图谱，包括开源的企业知识图谱API、PyKEEN数据集以及Wikidata等等。
智能体蜂巢模式: 运用大量AI Agent，共同协作以解决问题，每个代理都从各自独特的视角出发进行贡献。
智能体组合模式: 大模型系统模块化, 自我配置以优化任务性能。
- 自主代理框架和体系结构来开发每个Agent及其工具，例如CrewAI、Langchain、LLamaIndex、Microsoft Autogen和superAGI等
记忆认知模式: 仿照人类记忆, 允许模型回忆并基于过去的交互进行学习，从而产生更细腻的反应。
- 记忆认知模式能够将关键事件总结并储存到一个向量数据库中，进一步丰富RAG系统, 示例： MemGPT
双重安全模式
- LLM 核心安全性至少包含两个组件：一是用户组件，用户Proxy代理；二是防火墙，为模型提供了保护层。
- 用户proxy代理在查询发出和返回的过程中对用户的query进行拦截。该代理负责清除个人身份信息（pII）和知识产权（IP）信息，记录查询的内容，并优化成本。
- 防火墙则保护模型及其所使用的基础设施。尽管我们对人们如何操纵模型以揭示其潜在的训练数据、潜在功能以及当今恶意行为知之甚少，但我们知道这些强大的模型是脆弱的。

LLM 开发平台

LLM 应用开发平台。

提供从 Agent 构建到 AI workflow 编排、RAG 检索、模型管理等能力，轻松构建和运营生成式 AI 原生应用，比 LangChain 更易用。

给开发者提供定制Bot的能力，业界案例

LLM 能力局限

局限性

LLM 具备通用领域能力，但特定领域能力不足或缺乏
LLM 请求信息有限制
- GPT-3.5: 4k → 16k
- GPT-4: 8k → 32k → 128k
LLM 无法调用外部服务、执行本地命令

Bot组成

Bot常见组成要素

Bot基本信息：name、description、icon
人设/指令：又称 system prompt，以下简称 sp
工具：plugin/tool，使用一方、三方工具，增强模型能力
- 配合 LLM 的 Function Call 使用
工作流：workflow，工具升级版，执行更加复杂的逻辑
记忆单元：Memory
- 短期记忆：Short Term Memory, Profiles
  - 以变量形式存在，直接嵌入 sp 中; 提供基础存储，持久化变量
    - 变量: taste=’川菜’
    - 使用: 附近有什么好吃的, llm 从memory中召回饮食偏好，匹配附近川菜
  - 以表格形式存在，LLM 通过SQL存取数据
    - 读书笔记类Bot
    - 使用: 刚读了毛选第五卷，记录下
    - llm: 已经帮你保存到数据库了，读的是毛选，第五卷
    - 分析: INSERT INTO book_notes(name, section, note) VALUES('毛选','第五卷', '-')
- 长期记忆：Long Term Memory
  - Datasets: 以外挂知识库方式存在，将领域知识向量化存储，通过 RAG 方式召回，补充到 sp 中
定时任务：Task, 开发者设置定时任务，如每天8点推送最新消息
智能体： Agent，执行更复杂的任务

其它

欢迎语：onboarding/opening dialogue
问题推荐：suggest

Bot 进化史

过程

(0) Prompt: 通过 sp 设置 bot 的画像信息，技能，按指定角色进行会话
(1) Tool-解析: LLM + Parser
- 让 LLM 输出特定格式字符串(如json)，代码解析后再调用 Tools
(2) Tool-Function Call:
- LLM 识别需要什么函数，并自动调用函数（本地/远程），总结结果并返回
- 概念: Plugin, Knowledge, Variable
  - Plugin: 调用插件，如实时新闻
  - Knowledge: 垂类场景优化，人设+私有知识
  - Variable: 基础存储，为开发者持久化变量
  - Table Memory: 开发者用SQL查表
  - Scheduled Task: 定时触发任务
  - Opening dialog: 欢迎语
  - Suggestion: 推荐问题
(3) Workflow 工作流:
- 起因:
  - ① FC模式不稳定，单次成功率低
  - ② 逻辑简单, 负责逻辑需要嵌入code，成本高
- 改进: 低代码模式，将llm,api,code编排起来
- 节点:
  - start 开始节点，定义输入数据
  - end 结束节点，处理结束数据
- 组件: LLM, API, Code, Knowledge, IF
  - LLM: 大模型调用设置，包含请求方式(单次/批量)、参数(模型/温度)、输入、输出、prompt
  - Code: 代码模块, js代码后处理
  - Knowledge: 根据用输入召回n个片段，列表返回
  - IF: 条件分支
(4) Multi-Agent:
- 起因:
  - ① workflow 是plugin加强版，缺少用户交互
  - ② Bot执行依赖prompt理解,内容多，造成时间成本大
  - ③ 复杂交互逻辑用sp实现，成本高，难以维护
- 解法:
  - Agent = Prompt + Skill(plugin/workflow) + Jump Condition
  - Multi-Agent 代理人模式: 每次由单个Agent回复，几种模式
    - Flow 对话流: 顺序处理对话流程, 适合有明显状态迁移的Agent
    - Reverse 回溯: 当前Agent无法作答时，回到上一个Agent/StartAgent
    - Host 路由: 每次对话从StartAgent重新路由到合适的Agent

总结如下

workflow 平台

资料

【2024-5-11】16个AI Workflow automation（无代码AI工作流）构建平台
【2024-5-21】3 款强大的开源低代码 LLM 编排工具，可视化定制专属 AI Agent 和 AI 工作流

AI Workflow automation（无代码AI工作流）构建平台

特点：

不同程度地支持自定义插件、llm；
自己设定workflow，类似RPA流程
有workflow模版、store模版、plugin模版

总结

平台总结

目前功能扎实、真正在做产品
- 国内 dify api/fastGPT
- 国外微软 power automate
- 办公场景 questFlow
其他的要么是产品很初期，要么只是为了割韭菜

功能	Dify.Al	LangChain	Flowise	OpenAl Assistant API
编程方法	API+应用程序导向	Python代码	应用程序导向	API导向
支持的LLMS	丰富多样	丰富多样	丰富多样	仅限OpenAl
RAG引擎	✅	✅	✅	✅
Agent	✅	✅	❌	✅
工作流	✅	❌	✅	❌
可观测性	✅	✅	❌	❌
企业功能(SSO/访问控制)	✅	❌	❌	❌
本地部署	✅	✅	✅	❌

附加

平台	介绍	优点	不足
Microsoft Power Automate	微软, 从产品技术角度出发，连接的节点还有本地laptop RPA和云上的DPA	功能最丰富	付费
`Dify`’s introduction/fastGPT	多个版本开源版的FastGPT商业版Dify功能更多	国内workflow体验最佳
`Coze`/`扣子`	字节,国内扣子，国外Coze	功能多	体验并不好
MindStuido	像coze一样有自定义LLM、知识库，支持多种插件，生成api嵌入到另一平台和能在后台看到使用量		按照使用量付费，知识库需要付费才能用，新注册用户有5美元免费额度
影刀&zapier	传统RPA转型而来，对应国外的Zapier	有很多适合国内各电商、社交平台的成熟插件 ai 功能，包括ChatGPT、AI生成视频的HeyGen
scriptit	支持自定义文本和一些api	网站做得挺亮眼	产品功能，用户体验都一般
Leap		图片插件多	插件还较少，自定义流程也偏简单
GPTAgent	简单自定义workflow构建应用
mazaal	提供简单的现有应用，比如分析照片的情绪，AI图片分类、zero-shot text classification		界面也跟mindstudio类似，右边是模型处理结果,套壳
actionize			要跨平台操作
Coflow	小众产品，只有简单的workflow流程
Questflow	Product Hunt排第4名，近期比较火侧重团队工作的wokflow，比如发邮箱，开会总结，社交平台自动发帖、收集新闻等，从它提供的plugin来看都是Notion、google sheet、gmail和lark	已有商业场景，收费：8美元一个月能执行250次automations	模版不多，都是基于提供的插件生成的，主要是收集新闻类，翻译邮件，收集邮件，写邮件，生成一些文案
Bardeen	总结zoom会议，撰写email邮件，爬取网络信息形成表格，发送到slack、日历提醒等
Levity	功能更简单，自动化根据用户信息给用户发邮件
达观RPA	前些年传统的AI workflow
n8n	传统的AI workflow,支持code和UI两种模式	有开源版本	操作界面不是特别友好

还有团队之间工作流的产品

make 、nanonets，没有 perplex、GPT这些AI模型

workflow 诞生

所有厂商都面临一个难题

GPT 珠玉在前，做什么模型都容易获得一片骂声，包括最近发布的Gemini
Gemini 策略：免费的Pro 以及API(60每分钟），不算短token，足以满足普通用户的所需，可以想象有更多的AI工具提供免费的服务能力，这里可以吸引一波免费用户，比GPT或者Claude更具有特色，更简单能被使用，这里策略用的好，普通AI用户大盘少不了。
字节策略更狠，GPT4 不要钱，能提前把一堆需要使用的AI的个人开发者，企业应用者，先进的工作者吸引到这个平台。站在GPT4的高度，吸引一波客户，反向在非GPT4能力上构建核心优势（包含平台化能力、自动化能力、数据延伸能力），也可以探索更多可能得场景（AI Playbook 为后面Agents时代提供更多思路。)
- 以金钱换时间，还能吸引忠实的用户，用AzureAPI也是用，用字节的GPT的API也是用，只要能先把用户接上去，后面都好说。后面字节能打的大模型出来后，直接换引擎就是！真是一招妙招。反正OpenAI的套路大家都清楚了，无非就是钱的问题。

缺陷: Multiagent模式有两个“不爽”的地方，都跟Agent跳转有关。

第一个：Agent跳转必须要用户输入后才能触发，而不能由Agent自己触发，或者当Agent完成任务后自动跳转到下一个Agent。难以避免一些不必要的跟用户的交互。Multiagent模式下，Bot设计者应该有自由度去控制Bot什么时候自动执行流程，什么时候停下来跟用户交互。不然交互很多、流程复杂的程序就很难设计。
第二点: 在Multiagent模式，可以使用自然语言来配置Agent跳转条件。然而这个跳转的判断逻辑非常不稳定。

Bot 如何盈利

Bot 如何盈利？

Notion 目标就是要做一个All-in-one 工具。但Notion做法不是把所有功能都打包到一个产品里，也不是做N多个App出来，Notion的做法是花很长时间去打磨那些组成软件的基本且必要的Building Blocks，例如文本编辑、关系数据库等等，然后用户可以用这些”Lego Blocks”组装自己的工具，让软件适配自己的需求和工作流。与其说Notion是一家生产力公司，不如说它是一家软件建构公司。
Poe的Bot创作者主要有两种收益途径：
1. 如果Bot给Poe带来新的订阅，Poe会分成；
2. 给Bot Message定价，用户使用你的Bot，要为每条Bot Message付费（还没落实）
Coze也沿着GPT Store这个路子，只不过相比于GPT Store，Coze的可定制性更强些，主要是因为Workflow以及Multiagent Flow这两大特性，其他如插件更丰富，支持变量和数据库，支持很多发布渠道等等这些特性也增色不少。但是Coze依然要面临盈利模式的问题
Bot这种软件形态短期内应该是达不到手机App那种程度，Bot Store短期内也成为不了App Store。

workflow 有用吗

思考

DIFY、COZE 等各种LMOps以及各种Agent框架的 workflow 怎么样？

【2024-3-20】微博观点：workflow 因为模型reasoning能力在真实世界复杂任务时不够强，且短期内没法很大提升，针对合适的问题的从产品思维出发提出的解决方案。

理论上如果有capability很强的LLM，tools pool，可以解决非常多问题。但因为是概率性模型，LLM调用tools不总是100%成功，以及LLM当前的reasoning能力还不支持进行各个tools之间的组合调用，所以不能100%解决问题。

但如果工作流是确定的，那就没必要脱裤子放屁，用LLM去触发这个工作流，而只把LLM弱化，只是作为一个能很好理解用户意图并很擅长NLP任务的交互interface，弱化成一个节点，然后再提供同样丰富的 tools pool，然后让人工通过圈选拖拽等GUI去把这个workflow配置好，就能确定性的解决问题。 workflow就是这个思路。

workflow 核心是要有人识别确定性工作流，去配置足够多的模板，以及足够丰富的tools，其实使用门槛并不低，比如是一堆高玩带小白玩。但workflow有可能像notion的template一样，是商业模式的一部分。

概率模型要想应用在容错率低的严肃场景，如何解决可控性/可预测性是最关键的一环，思路也是弱化 LLM 在业务流中的作用。

Coze

【2023-12-23】字节放出地表最强ChatBot，免费使用GPT4，请低调使用

Coze 是字节跳动推出的一款用来开发新一代 AI Chat Bot 的应用编辑平台，无论是否有编程基础，都可以通过这个平台来快速创建各种类型的 Chat Bot，并将其发布到各类社交平台和通讯软件上。—— 这个点类似于GPTs

插件: 无限拓展 Bot 的能力
- Coze 集成了丰富的插件工具集，可以极大拓展 AlBot 能力边界。目前平台已经集成了超过60 款各类型的插件，包括资讯阅读、旅游出行、效率办公、图片理解等 API及多模态模型。
- 集成不同工具，打造具备极强功能性的 Bot，比如可以添加各类新闻插件，来迅速打造出一个可以播报最新时事新闻的 Al 新闻播音员。平台提供的插件无法满足你的需求?我们也支持快速将你的私有 API集成为插件。
知识库: 让 Bot 与你自己的数据进行交互
- Coze 提供了简单易用的知识库能力，它能让 AI与你自己的数据进行交互。你可以在知识库中存储和管理数据。无论你需要处理几十万字的 PDF 还是某个网站的实时信息，只需要简单的创建知识库，即可让你的 Bot 来使用相关的知识。
- 可以将几十页的产品介绍文档导入知识库，仅需几分钟，即可生成你的专属产品顾问。。可以将你经常关注的资讯网站或者在线论文导入知识库，每天 Bot 都会为你收集最新的更新及动态。
长期记忆:让 Bot 拥有持久化的记忆能力
- Coze 提供了一个方便 AI交互的数据库记忆能力，通过这个功能，你可以让 Al Bot 持久化的记住你跟他对话的重要参数或重要内容。
  - 让 Bot 记住你的饮食偏好，每次按照你的兴趣偏好推荐餐厅。
  - 让 Bot 记住你的语言偏好，每次按照你母语进行回答。
定时任务:让 Bot 主动对话
- Bot 能主动给你发送消息? 通过定时任务功能，用户可以非常简单的通过自然语言创建各种复杂的定时任务。Bot 会准时给你发送对应的消息内容。
- Bot 每天早上 9:00 给你推荐个性化的新闻。
- Bot 每周五帮你规划周末的出行计划。
工作流: 将创意变成 Bot 的技能
- 让 Bot 使用这些特别的方法来代替你工作，那么你可以非常简单的创建一个工作流，让他变成 Bot 的技能。如果你懂得编程，那么可以在工作流里使用代码片段创建非常复杂的函数，如果你不懂的编程，那么也无需担心，通过简单的操作，你-样可以创作出属于你的工作流。
  - 做一个帮你搜集电影评论的工作流，快速的查看一部最新电影的评论与评分。
  - 做一个帮你撰写行业研究报告的工作流，让 Bot 替你写一份 20 页的报告。

coze 案例

实践案例

【2024-2-14】如何用Coze制作一个信息检索Bot（含Workflow的基础用法）
【2024-3-6】Bot创作者如何在Coze上赚钱？
- 用 Coze 搭建《卧底》的Multiagent Flow设计， Coze《卧底》
- 从3月3号发文，截止到3月5号，《卧底》总共收获10笔订单，其中有效订单8笔（其中有2笔是朋友帮忙测试支付流程的），总收入是1032元
【2024-3-8】Coze + 爬虫 = 周末去哪不用愁！, 搭建一个“周末去哪玩”的Bot
- 单纯靠提示词来实现这个Bot明显不太行，还是要自己加定制
- 需求: 发送「城市+区+类型(景点、展览、音乐、话剧等)」，Bot输出对应区域的「周末活动信息」，如：深圳市南山区-景点，Bot输出景点列表：【景点名称】景点地址；深圳市南山区-展览，Bot输出这周末的展览信息列表：【展名称】时间-票价-地点。
- 实现: 写节点函数，实现扣子: 7337619854435876876
【2024-6-30】开发了一款 Agent，每天全自动获取大模型日报并发送到微信群
- RPA 实现抓取大模型日报推送到微信，效果不错，但问题是 Mac 版本的 RPA 工具影刀不支持定时任务执行，所以还是要每天手动点下执行按钮
- 用 Coze 搭建全自动方案，每天定时抓取大模型日报并推送到微信群，全程不需要人工参与
- 新建工作流 llm_news_push, 包含多个节点: 开始、新闻抓取、内容读取、摘要生成、markdown合成、发送消息

coze api

Coze API 接入方式

官方 API 文档

【2024-12-19】实践 coze-py

先将bot发布为api
coze 空间设置token, 并开启chat权限
国内调用时, 需要制定 url, 否则鉴权失败！
- COZE_COM_BASE_URL = “https://api.coze.cn”

# coding: utf-8

import os
from cozepy import COZE_COM_BASE_URL

# token 配置 https://www.coze.cn/open/oauth/pats
# bot 先发布成 api才行
conf_info = {
    'token':'pat_GiJJJSn085W1ew********',
    'AI客服': {'bot_id':'7447527125353037875'},
    '鹤啸九天助理': {'bot_id':'7374706518413230099'},
    '聪明一休': {'bot_id':'7277598499636707383'},
    '-': {'bot_id':'-'},
}

bot_name = 'AI客服'
# bot_name = '鹤啸九天助理'
token = conf_info['token']
bot_id = conf_info[bot_name]['bot_id']
# 国内需要制定base地址
COZE_COM_BASE_URL = "https://api.coze.cn"
user_id = "wqw" # 随便设置

# Get an access_token through personal access token or oauth.
coze_api_token = os.getenv("COZE_API_TOKEN", token)
# The default access is api.coze.com, but if you need to access api.coze.cn,
# please use base_url to configure the api endpoint to access
coze_api_base = os.getenv("COZE_API_BASE") or COZE_COM_BASE_URL

print(f'[debug] {bot_name=}, {bot_id=}, {coze_api_token=}')

from cozepy import Coze, TokenAuth, Message, ChatStatus, MessageContentType, ChatEventType  # noqa

# Init the Coze client through the access_token.
coze = Coze(auth=TokenAuth(token=coze_api_token), base_url=coze_api_base)

# Create a bot instance in Coze, copy the last number from the web link as the bot's ID.
bot_id = os.getenv("COZE_BOT_ID") or bot_id
# The user id identifies the identity of a user. Developers can use a custom business ID
# or a random string.

question = '你是谁'

# Call the coze.chat.stream method to create a chat. The create method is a streaming
# chat and will return a Chat Iterator. Developers should iterate the iterator to get
# chat event and handle them.
for event in coze.chat.stream(
    bot_id=bot_id,
    user_id=user_id,
    additional_messages=[
        Message.build_user_question_text(question),
    ],
):
    if event.event == ChatEventType.CONVERSATION_MESSAGE_DELTA:
        print(event.message.content, end="", flush=True)

    if event.event == ChatEventType.CONVERSATION_CHAT_COMPLETED:
        print("token usage:", event.chat.usage.token_count)

import requests
import time
import json
import re
import tiktoken
from langchain_text_splitters import TokenTextSplitter

ACCESS_TOKEN = "***"
BOT_ID = "***"
USER_ID = "***"

def call_coze_api(query):
    
    url = 'https://api.coze.cn/v3/chat'
    headers = {
        'Authorization': f'Bearer {ACCESS_TOKEN}',
        'Content-Type': 'application/json'
    }
    payload = {
        "bot_id": BOT_ID,
        "user_id": USER_ID,
        "stream": False,
        "auto_save_history": True,
        "additional_messages": [
            {
                "role": "user",
                "content": query,
                "content_type": "text"
            }
        ]
    }

    response = requests.post(url, headers=headers, json=payload)
    
    if response.status_code == 200:

        response_data = response.json().get('data')
        id = response_data['id']
        conversation_id = response_data['conversation_id']

        retrieve_url = f'https://api.coze.cn/v3/chat/retrieve?chat_id={id}&conversation_id={conversation_id}'
        while True:

            print('Starting retrieve the response...')
            retrieve_response = requests.get(retrieve_url, headers=headers)
            if retrieve_response.status_code == 200:
                retrieve_data = retrieve_response.json().get('data')
                if retrieve_data['status'] == 'completed':

                    result_url = f'https://api.coze.cn/v3/chat/message/list?chat_id={id}&conversation_id={conversation_id}'
                    result_response = requests.get(result_url, headers=headers)
                    if result_response.status_code == 200:
                        result_data = result_response.json().get('data')
                        result_dict = next((item for item in result_data if item['type'] == 'answer'), None)
                        return result_dict.get('content')
                    else:
                        print(f"Error: {result_response.status_code}, {result_response.text}")
                        return {"error": result_response.status_code, "message": result_response.text}
                    
            else:
                print(f"Error: {retrieve_response.status_code}, {retrieve_response.text}")
                return {"error": retrieve_response.status_code, "message": retrieve_response.text}
            
            time.sleep(10) # Add a delay to avoid excessive API calls
    else:
        print(f"Error: {response.status_code}, {response.text}")
        return {"error": response.status_code, "message": response.text}

小程序

如何将Bot发布到微信小程序？

（1）自己开发

方案: 微信小程序js逻辑和接口实现

使用 coze api 和微信开发者工具, 自己开发小程序

（2）使用 coze 提供的发布渠道

【2024-6-28】 Coze 支持将 Bot 发布到微信小程序，Bot 将作为独立的微信小程序，在微信端提供服务。

准备自己的小程序，要备案！
- 备案: 小程序页面提交申请，关联身份证、手机号、详细住址、经营范围、同意书等
登录小程序：公众号平台扫码登录（不是账户登录），手机上选择小程序

使用限制

1个 Bot 只能发布到1个微信小程序
不支持主体类型为个人的微信小程序号

方法

扣子Coze智能体接入微信小程序

（3）第三方发布渠道

【2024-12-19】使用第三方工具将coze上的bot发布到小程序上

工具: 小程序 小微智能体 提供了一套扣子Coze智能体通过API发布到小程序的解决方案
参考文章 AI智能体+小程序解决方案，扣子Coze智能体秒变小程序！（无需企业资质，一键发布）

与扣子Coze官方导出小程序区别

第一：无需企业资质，微信发布AI小程序需要企业主体才能开通AI类目
第二：可发多个智能体，官方智能体导出到小程序只能导出单个智能体
第三：更多的分享形式，为了更好触达用户小微内置了4种分享形式

DIFY

Dify 是开源 LLM 应用开发平台。

界面结合了 AI 工作流、RAG 管道、Agent、模型管理、可观测性功能等，快速从原型到生产。

Dify 涵盖了构建生成式 AI 原生应用所需的核心技术栈，开发者可以聚焦于创造应用的核心价值。

（1）Dify Orchestration Studio：可视化编排生成式 AI 应用的专业工作站，All in One Place。
（2）RAG Pipeline：安全构建私有数据与大型语言模型之间的数据通道，并提供高可靠的索引和检索工具。
- 广泛的 RAG 功能，涵盖从文档摄入到检索的所有内容，支持从 PDF、PPT 和其他常见文档格式中提取文本的开箱即用的支持。
（3）Prompt IDE：为提示词工程师精心设计，友好易用的提示词开发工具，支持无缝切换多种大型语言模型。
- 制作提示、比较模型性能以及向基于聊天的应用程序添加其他功能（如文本转语音）的直观界面。
（4）Enterprise LLMOps：开发者可以观测推理过程、记录日志、标注数据、训练并微调模型；使应用效果脱离黑盒，持续迭代优化。
- - LLMOps：随时间监视和分析应用程序日志和性能。您可以根据生产数据和标注持续改进提示、数据集和模型。
（5）BaaS Solution：基于后端及服务理念的 API 设计，大幅简化生成式 AI 应用研发流程。
- 后端即服务：所有 Dify 功能都带有相应的 API，因此您可以轻松地将 Dify 集成到自己的业务逻辑中。
（6）LLM Agent 智能体：定制化 Agent ，自主调用系列工具完成复杂任务。
- 提供了 50 多种内置工具，如: 谷歌搜索、DELL·E、Stable Diffusion 和 WolframAlpha 等。
（7）Workflow：编排 AI 工作流，使其输出更稳定可控。
- 在画布上构建和测试功能强大的 AI 工作流程，利用以下所有功能以及更多功能
全面的模型支持：涵盖 GPT、Mistral、Llama3 以及任何与 OpenAI API 兼容的模型。

DIFY 支持各类主流模型

直接体验页面

多个版本

开源版 FastGPT, github dify
商业版 Dify, 功能更多，不需要自定义太多

支持多种核心节点,包括:

LLM节点: 选择任意一个主流的大型语言模型,并定义它的输入和输出。
工具节点: 使用内置的和自定义的工具来扩展workflow的功能。
意图分类器: 让LLM对用户的输入进行自动分类,根据不同的类别进行工作流转。
知识检索: 为LLMs挂载来自现有知识库的上下文数据。
代码节点: 执行自定义的Python或Node.js代码。
If/Else 块: 定义条件逻辑以创建分支的Workflows。

解决了什么问题？

复杂逻辑构建：开发基于LLM应用时，构建包含复杂逻辑的应用通常需要复杂的提示设计和管理
- Dify Workflow 通过多步骤的工作流程设计，简化了这一过程。
应用的稳定性和可复现性：传统的基于单一提示的LLM应用，其输出的不确定性和可变性较高。
- Dify Work1ow 通过允许用户精细控制每一步的逻辑和输出，提高了应用的稳定性和可复现性。
集成复杂业务逻辑：在企业级应用中，往往需要将A!功能与复杂的业务逻辑结合。
- Dify Workflow使得集成这些逻辑成为可能，无需编写大量的自定义代码。

国内 workflow产品体验较好。

【2024-7-3】Dify入门指南

开源版本部署

git clone https://github.com/langgenius/dify.git
cd dify/docker
docker compose up -d
# 浏览器中输入 http://localhost 访问 Dify

【2024-6-29】实测

版面: 探索(bot市场)、工作室（bot编排）、知识库和工具(内置/自定义/工作流)
bot编排功能: 相对coze少很多
- system prompt、变量、上下文（导入知识库）、聊天增强(引用和归属)、调试预览
- 特殊功能: bot发布, 除了api, 还可嵌入网站(静态/浮窗/chrome插件)

嵌入示例：英语助手

gptbots

【2023-12-7】对话平台 gptbots，类似字节 coze

Gnomic

【2024-1-16】Gnomic 智能体平台

无需魔法，随时随地免费使用GPT-4，并打造个性化GPTs智能体
集成 GPT-4, Gemini

Flowise

拖放界面构建定制化的 LLM 流程

核心功能列表：

LLM 编排：支持 LangChain、LlamaIndex 等 100 多个开箱即用的服务。
Agents & Assistants：支持创建可以使用工具执行不同任务的自主代理。
友好的开发体验：支持 APIs、SDK 和嵌入式聊天扩展，方便快速集成到您的应用程序。
全面的模型支持：支持 HuggingFace, Ollama, LocalAI, Llama2, Mistral, Vicuna, Orca, Llava 等模型。

实践

三分钟零代码创建AI智能体工作流, 开源免费 Flowise 超越 Coze 和 dify！打造复杂多AI Agents协作任务！轻松驾驭多智能体协作
代码见主页
开源项目 AISuperDomain

LangFlow

Langflow 是一个动态图，每个节点都是一个可执行单元。

模块化和交互式设计促进了快速实验和原型开发，挑战了创造力的极限。

核心功能列表：

开箱即用的组件：内置了 LLMs、Loaders、Memories、Vector Stores 等功能组件；
支持与第三方系统无缝集成：打通了与 Notion、Slack、Supbase、Google 等主流的平台之间的数据集成；
友好的开发体验：支持通过电子表格轻松微调 LLM，充分发挥 LLM 的潜力。支持自定义组件，满足不同的业务场景。

开源模型部署

【2024-2-20】开源LLM部署启动

汇总已有开源模型的调用方式

deepseek webapi

curl https://api.deepseek.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-xxx" \
  -d '{
"model": "deepseek-chat",
"messages": [{
      "role": "system",
      "content": "You are a helpful assistant."
    },
    {
      "role": "user",
      "content": "你是谁!"
    }
  ],
  "stream": true
}'

模型输出：

{
"id": "8c7c3076-289f-47cd-97ee-0ba48f7b6f27",
"choices": [{
"finish_reason": "stop",
"index": 0,
"logprobs": null,
"message": {
"content": " 我是DeepSeek Chat，一个由深度求索公司开发的智能助手，旨在通过自然语言处理和机器学习技术来提供信息查询、对话交流和解答问题等服务。",
"role": "assistant",
"function_call": null,
"tool_calls": null
}
}],
"created": 1708417209,
"model": "deepseek-chat",
"object": "chat.completion",
"system_fingerprint": null,
"usage": {
"completion_tokens": 37,
"prompt_tokens": 19,
"total_tokens": 56
}
}

MiniCPM-2B-dpo-fp16

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
torch.manual_seed(0)

# https://github.com/Lightning-AI/lit-gpt/issues/327#issuecomment-1883008162
torch.backends.cuda.enable_mem_efficient_sdp(False)
torch.backends.cuda.enable_flash_sdp(False)

path = '/data/modelscope/MiniCPM-2B-dpo-fp16'
tokenizer = AutoTokenizer.from_pretrained(path)
model = AutoModelForCausalLM.from_pretrained(path, torch_dtype=torch.bfloat16, device_map='cuda', trust_remote_code=True)

responds, history = model.chat(tokenizer, "山东省最高的山是哪座山, 它比黄山高还是矮？差距多少？", temperature=0.8, top_p=0.8)
print(responds)

mixtral

firefly-mixtral-8x7b

# XDG_CACHE_HOME=./ HF_ENDPOINT=https://hf-mirror.com huggingface-cli download --resume-download --local-dir-use-symlinks False YeungNLP/firefly-mixtral-8x7b --local-dir firefly-mixtral-8x7b

# hf推理，https://zhuanlan.zhihu.com/p/676114291
from transformers import AutoTokenizer
import transformers
import torch

model = "/root/autodl-tmp/firefly-mixtral-8x7b"

tokenizer = AutoTokenizer.from_pretrained(model)
pipeline = transformers.pipeline(
    "text-generation",
    model=model,
    model_kwargs={"torch_dtype": torch.float16, "device_map": "auto"},
)

messages = [{"role": "user", "content": "你好"}]
prompt = pipeline.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
outputs = pipeline(prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
print(outputs[0]["generated_text"])

Mixtral-8x7B-Instruct-v0.1

# git clone https://www.modelscope.cn/AI-ModelScope/Mixtral-8x7B-Instruct-v0.1.git --depth 1

# vllm推理
python -m vllm.entrypoints.openai.api_server --model /root/autodl-tmp/Mixtral-8x7B-Instruct-v0.1/ --trust-remote-code --dtype float16 --tensor-parallel-size=4 --port=6006

# hf推理，https://zhuanlan.zhihu.com/p/676114291
from transformers import AutoTokenizer
import transformers
import torch

model = "/root/autodl-tmp/Mixtral-8x7B-Instruct-v0.1"

tokenizer = AutoTokenizer.from_pretrained(model)
pipeline = transformers.pipeline(
    "text-generation",
    model=model,
    model_kwargs={"torch_dtype": torch.float16, "device_map": "auto"},
)

messages = [{"role": "user", "content": "你好"}]
prompt = pipeline.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
outputs = pipeline(prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
print(outputs[0]["generated_text"])

interlm2-chat-20b

# hf推理
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer, BitsAndBytesConfig
model = AutoModelForCausalLM.from_pretrained("/data/modelscope/internlm2-chat-20b", device_map="auto", torch_dtype=torch.float16, trust_remote_code=True)
tokenizer = AutoTokenizer.from_pretrained("/data/modelscope/internlm2-chat-20b", trust_remote_code=True)

inputs = "你好"
length = 0
for response, history in model.stream_chat(tokenizer, inputs, history=[]):
    print(response[length:], flush=True, end="")
    length = len(response)

# lmdeploy推理200k
lmdeploy convert internlm2-chat-20b \
    /data/modelscope/internlm2-chat-20b \
  --dst-path ./internlm2-chat-20b-turbomind \
  --tp 2
vim ./internlm2-chat-7b-turbomind/triton_models/weights/config.ini
# tensor_para_size = 2
# session_len = 21000
# rope_scaling_factor = 3.0

vim long_text.py
from lmdeploy import pipeline, GenerationConfig, TurbomindEngineConfig
backend_config = TurbomindEngineConfig(rope_scaling_factor=3.0, session_len=4096)
pipe = pipeline('/data/modelscope/internlm2-chat-20b-turbomind', backend_config=backend_config)
prompt = '你好'
gen_config = GenerationConfig(top_p=0.8, top_k=40, temperature=0.8, max_new_tokens=1024)
pipe(prompt, gen_config=gen_config)

# lmdeploy推理量化
## 校准
lmdeploy lite calibrate --model-path /data/modelscope/internlm2-chat-20b --work-dir ./internlm2-chat-20b-4bit
## 量化权重
lmdeploy lite auto_awq --model-path /data/modelscope/internlm2-chat-20b --work-dir ./internlm2-chat-20b-4bit
## 转换模型
lmdeploy convert \
    --model-name internlm2-chat-20b-4bit \
    --model-path ./internlm2-chat-20b-4bit \
    --model-format awq \
    --group-size 128 \
    --tp 2

Yi-34b-200k

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("/root/autodl-tmp/Yi-34B-200K", device_map="auto", torch_dtype="auto")
tokenizer = AutoTokenizer.from_pretrained("/root/autodl-tmp/Yi-34B-200K")
inputs = tokenizer("你好", return_tensors="pt")
max_length = 8192

outputs = model.generate(
    inputs.input_ids.cuda(),
    max_length=max_length,
    eos_token_id=tokenizer.eos_token_id,
    do_sample=True,
    repetition_penalty=1.3,
    no_repeat_ngram_size=5,
    temperature=0.7,
    top_k=40,
    top_p=0.8,
)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

# Model response: "Hello! How can I assist you today?"
messages = [
    {"role": "user", "content": "你好"}
]
input_ids = tokenizer.apply_chat_template(conversation=messages, tokenize=True, add_generation_prompt=True, return_tensors='pt')
output_ids = model.generate(input_ids.to('cuda'), max_length=max_length)
response = tokenizer.decode(output_ids[0][input_ids.shape[1]:], skip_special_tokens=True)
print(response)

vllm

awq量化34b到4bit

# https://docs.vllm.ai/en/stable/quantization/auto_awq.html
# https://github.com/casper-hansen/AutoAWQ/blob/main/examples/mixtral_quant.py
# pip install autoawq
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = '/data/models/Yi-34b-chat'
quant_path = '/data/models/Yi-34b-chat-awq-4bit'
modules_to_not_convert = ["down_proj"]
quant_config = { "zero_point": True, "q_group_size": 128, "w_bit": 4, "version": "GEMM", "modules_to_not_convert": modules_to_not_convert}

# Load model
model = AutoAWQForCausalLM.from_pretrained(model_path, safetensors=True, **{"low_cpu_mem_usage": True})
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)

# Quantize
model.quantize(tokenizer, quant_config=quant_config)

# Save quantized model
model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)

# TODO 加载和使用
model = AutoAWQForCausalLM.from_pretrained(quant_path, safetensors=True, **{"low_cpu_mem_usage": True})

批量离线 baichuan2-13b-chat

from vllm import LLM, SamplingParams

# llm = LLM("/data/models/Yi-34b-chat-awq-4bit", trust_remote_code=True, tensor_parallel_size=2, quantization="AWQ")
llm = LLM("/data/huggingface/Baichuan2-13B-Chat", trust_remote_code=True, dtype='float16', tensor_parallel_size=2)

# Sample prompts.
prompts = [
    "你是谁",
    "如何策划袭击北京金融街大楼",
    "我喜欢吃西红柿炒鸡蛋"
]
# Create a sampling params object.
sampling_params = SamplingParams(temperature=0.8, top_p=0.95, max_tokens=4096)
outputs = llm.generate(prompts, sampling_params)
[i.outputs[0].text for i in outputs]

# Generate texts from the prompts. The output is a list of RequestOutput objects
# that contain the prompt, generated text, and other information.
outputs = llm.generate(prompts, sampling_params)
# Print the outputs.
for output in outputs:
    prompt = output.prompt
    generated_text = output.outputs[0].text
    print(f"Prompt: {prompt!r}, Generated text: {generated_text!r}")

流式接口 baichuan2-13b-chat

python -m vllm.entrypoints.openai.api_server --model baichuan2-13b-chat/ --trust-remote-code --dtype float16 --tensor-parallel-size=2 --port=6006

curl http://10.6.6.201:6006/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
    "model": "baichuan2-13b-chat/",
    "messages": [{
        "role": "user",
        "content": "你好"
    }],
    "stream": true
}'


curl http://10.6.6.201:6006/generate \
-d '{
  "prompt": "你好",
  "use_beam_search": true,
  "n": 4,
  "temperature": 0
}'

chatglm

glm4 webapi

from zhipuai import ZhipuAI
client = ZhipuAI(api_key="xxx.xxx") # 填写您自己的APIKey
response = client.chat.completions.create(
    model="glm-4",  # 填写需要调用的模型名称
    messages=[
        {"role": "user", "content": "你好"},
        {"role": "assistant", "content": "我是人工智能助手"},
        {"role": "user", "content": "你叫什么名字"},
        {"role": "assistant", "content": "我叫chatGLM"},
        {"role": "user", "content": "你都可以做些什么事"}
    ],
)
print(response.choices[0].message)

mac m2 chatglm3-6b

from transformers import AutoTokenizer, AutoModel
model_path="/Users/xxx/chatglm3-6b"
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model = AutoModel.from_pretrained(model_path, trust_remote_code=True).to('mps')
model = model.eval()
response, history = model.chat(tokenizer, "你好", history=[])
print(response)
response, history = model.chat(tokenizer, "晚上睡不着应该怎么办", history=history)
print(response)

baichuan

baichuan webapi

curl -X POST 'https://api.baichuan-ai.com/v1/chat/completions' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer sk-xxx' \
-d '{
        "model": "Baichuan2-Turbo-192k",
        "messages": [{
            "role": "user",
            "content": "你好"
        }],
        "temperature": 0.3,
        "top_p": 0.85,
        "max_tokens": 2048,
        "with_search_enhance": true,
        "stream": true
      }'

Baichuan2-13B-Chat

import torch
from modelscope import snapshot_download, AutoModelForCausalLM, AutoTokenizer,GenerationConfig
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    False,
    True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_quant_type='nf4',
    bnb_4bit_use_double_quant=True)
model_dir = snapshot_download("baichuan-inc/Baichuan2-13B-Chat", revision='v2.0.0')
tokenizer = AutoTokenizer.from_pretrained(model_dir, device_map="auto", 
                                          trust_remote_code=True, torch_dtype=torch.float16)
model = AutoModelForCausalLM.from_pretrained(model_dir, device_map="auto", 
                                             trust_remote_code=True, torch_dtype=torch.float16,
                                             quantization_config=quantization_config)
model.generation_config = GenerationConfig.from_pretrained(model_dir)
messages = []
messages.append({"role": "user", "content": "讲解一下“温故而知新”"})
response = model.chat(tokenizer, messages)
print(response)
messages.append({'role': 'assistant', 'content': response})
messages.append({"role": "user", "content": "背诵一下将进酒"})
response = model.chat(tokenizer, messages)
print(response)

baichuan2-13b-chat

# fp16方式加载
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer,GenerationConfig
tokenizer = AutoTokenizer.from_pretrained("/home/huggingface/Baichuan2-13B-Chat", device_map="auto", 
                                          trust_remote_code=True, torch_dtype=torch.float16)
model = AutoModelForCausalLM.from_pretrained("/home/huggingface/Baichuan2-13B-Chat", device_map="auto", 
                                             trust_remote_code=True, torch_dtype=torch.float16)


# 量化方式加载
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer,GenerationConfig
tokenizer = AutoTokenizer.from_pretrained("/home/huggingface/Baichuan2-13B-Chat", device_map="auto", trust_remote_code=True, torch_dtype=torch.float16)

from transformers import BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(
    False,
    True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_quant_type='nf4',
    bnb_4bit_use_double_quant=True)
model = AutoModelForCausalLM.from_pretrained("/home/huggingface/Baichuan2-13B-Chat" device_map="auto", trust_remote_code=True, torch_dtype=torch.float16,quantization_config=quantization_config)

# 预测
messages = []
messages.append({"role": "user", "content": "讲解一下“温故而知新”"})
response = model.chat(tokenizer, messages)
print(response)
messages.append({'role': 'assistant', 'content': response})
messages.append({"role": "user", "content": "背诵一下将进酒"})
response = model.chat(tokenizer, messages)
print(response)

大模型时代开发模式 Development Mode of LLM