AI-helloworld AI开发社区

十款主流LLM应用框架对比

pangguoming — Thu, 29 May 2025 03:41:10 GMT

随着大型语言模型（LLM）的普及，开发者们需要强大的框架来快速构建智能应用。从聊天机器人到知识库搜索，市场上有许多工具可以简化开发流程。本文将比较十款主流开源框架：LangChain、Dify、LlamaIndex、Haystack、Flowise、Langflow、CrewAI、AutoGPT、n8n 和 MaxKB，帮助你选择最适合项目的工具。

框架简介

以下是这十款框架的简要概览，展示它们的定位和核心功能：

框架	类型	核心功能	许可证	主要语言
LangChain	开发者工具包	模块化LLM编排、RAG、代理	MIT	Python, JS/TS
Dify	低代码平台	快速应用开发、RAG、代理	Apache 2.0	Python, JS
LlamaIndex	数据框架	数据索引、检索、RAG	MIT	Python
Haystack	NLP管道框架	语义搜索、问答、RAG	Apache 2.0	Python
Flowise	低代码平台	基于LangChain的视觉化应用构建	Apache 2.0	JS/TS
Langflow	低代码平台	视觉化工作流、RAG、代理	MIT	Python
CrewAI	代理框架	多代理协作	MIT	Python
AutoGPT	自主代理	目标导向的任务自动化	MIT	Python
n8n	工作流自动化	通用自动化，支持LLM集成	Fair-code	JS/TS
MaxKB	知识库平台	知识管理、RAG	AGPL-3.0	Python

详细对比

我们从七个关键维度对比这些框架：易用性、定制化、开发速度、可扩展性、社区支持、集成能力和适用场景。

易用性 LangChain：需要Python或JS编程经验，学习曲线较陡，适合有技术的开发者。 Dify：低代码拖拽界面，适合非技术用户，快速上手。 LlamaIndex：中等难度，专注于数据任务，需Python基础。 Haystack：开发者友好，管道设计直观，适合NLP任务。 Flowise：低代码，基于LangChain，拖拽式设计对新手友好。 Langflow：视觉化界面支持代码导出，兼顾新手和开发者。 CrewAI：中等难度，需Python，代理设置简单但需理解角色分工。 AutoGPT：命令行操作复杂，不适合初学者。 n8n：低代码自动化，界面直观，适合工作流设计。 MaxKB：知识库创建简单，但文档不足增加学习成本。推荐：新手选 Dify，兼顾易用和灵活选 Langflow。
定制化 LangChain：高度模块化，支持链、代理、记忆，600+集成。 Dify：通过视觉组件定制，中等灵活，复杂逻辑受限。 LlamaIndex：数据索引和检索定制强，支持多种向量库。 Haystack：管道灵活，适合搜索和问答定制。 Flowise：受LangChain限制，非标准流程定制弱。 Langflow：支持代码级调整，灵活性高。 CrewAI：专注多代理，角色和任务可深度定制。 AutoGPT：任务自动化灵活，但缺乏结构化工具。 n8n：自动化定制强，LLM任务稍弱。 MaxKB：知识库定制适中，其他场景局限。推荐：复杂项目选 LangChain，数据任务选 LlamaIndex。
开发速度 LangChain：需编码，初期慢，但组件复用加速迭代。 Dify：模板和视觉流让原型开发最快。 LlamaIndex：RAG和搜索应用开发高效。 Haystack：管道设置快，复杂任务需调优。 Flowise：拖拽式开发，简单应用快速上线。 Langflow：视觉流加速原型，代码导出支持生产。 CrewAI：代理应用开发适中，需定义任务。 AutoGPT：配置和调试慢，实验性强。 n8n：自动化流程快，LLM应用稍慢。 MaxKB：知识库快速，通用应用较慢。推荐：快速原型选 Dify，视觉开发选 Flowise 或 Langflow。
可扩展性 LangChain：通过LangServe和LCEL支持企业级扩展。 Dify：适合中小规模，高流量场景稍弱。 LlamaIndex：数据密集应用扩展强，适合大数据集。 Haystack：企业级搜索任务表现优秀。 Flowise：受LangChain限制，扩展性有限。 Langflow：一键微服务部署，适合复杂工作流。 CrewAI：代理系统扩展适中，大规模未充分验证。 AutoGPT：非生产就绪，大规模不稳定。 n8n：自动化扩展强，LLM应用稍弱。 MaxKB：知识库扩展可行，通用场景未验证。推荐：企业级选 LangChain 和 Haystack，数据任务选 LlamaIndex。
社区与支持 LangChain：最大社区（3000+贡献者），文档详尽，Slack活跃。 Dify：快速增长（34.8k+ GitHub星），文档简单，更新频繁。 LlamaIndex：社区强大，文档清晰，GitHub/Discord活跃。 Haystack：社区稳定，Deepset支持，文档优质。 Flowise：社区中等，依赖LangChain生态。 Langflow：增长中，文档良好，开发活跃。 CrewAI：社区较小，专注代理场景。 AutoGPT：早期火爆，社区活跃度下降。 n8n：自动化社区强大，AI支持较少。 MaxKB：社区较小，文档有限。推荐：社区支持选 LangChain，文档质量选 LlamaIndex 或 Haystack。
集成能力 LangChain：600+集成（OpenAI、Hugging Face、向量库）。 Dify：预建集成（OpenAI、Zapier），数量较少。 LlamaIndex：向量库（FAISS、Pinecone）和数据连接强。 Haystack：支持transformer、向量库、API。 Flowise：继承LangChain集成，范围有限。 Langflow：无缝对接LangChain和Hugging Face。 CrewAI：基于LangChain，集成专注代理。 AutoGPT：集成少，需手动配置。 n8n：400+自动化集成，非LLM中心。 MaxKB：知识库工具集成，LLM支持基础。推荐：集成广度选 LangChain，数据集成选 LlamaIndex。
适用场景 LangChain：聊天机器人、复杂工作流、RAG、代理。 Dify：客服机器人、最小可行产品、简单RAG。 LlamaIndex：知识库、语义搜索、RAG。 Haystack：企业搜索、问答、文档分析。 Flowise：简单聊天机器人、数据分析。 Langflow：原型设计、复杂管道、教育工具。 CrewAI：多代理系统、研究自动化。 AutoGPT：实验性自动化、任务驱动代理。 n8n：业务自动化、LLM增强工作流。 MaxKB：知识管理、内部问答。推荐：多功能选 LangChain，专业任务选 Haystack 或 LlamaIndex。

如何选择？

新手或非技术用户：选 Dify 或 Flowise，低代码快速上手。需要高度定制的开发者：选 LangChain（复杂应用）或 Langflow（视觉+代码）。数据密集型任务：选 LlamaIndex（索引/检索）或 Haystack（搜索管道）。多代理协作：选 CrewAI（代理系统）或 Langflow（视觉代理流）。自动化需求：选 n8n（业务流程）或 AutoGPT（实验性自主任务）。知识库管理：选 MaxKB（专用知识库）或 LlamaIndex（通用RAG）。

总结

每个框架都在LLM应用生态中有独特定位：

LangChain 以多功能和集成见长，适合复杂项目。 Dify 让非技术用户也能快速开发。 LlamaIndex 和 Haystack 在数据和搜索任务中表现卓越。 Flowise 和 Langflow 简化开发流程，兼顾易用性。 CrewAI 和 AutoGPT 专注代理和自动化。 n8n 连接自动化与AI，MaxKB 专注知识管理。很多时候，不同的框架可以结合在一起使用，选择框架时，需权衡项目复杂度、团队技术水平和扩展需求。

conda: command not found conda的初始化方法

pangguoming — Thu, 29 May 2025 01:27:35 GMT

安装conda后，如果bashrc文件中没有conda的配置信息，则可以手动执行下列语句

eval "$(/home/wxy/miniconda3/bin/conda shell.YOUR_SHELL_NAME hook)" 其中YOUR_SHELL_NAME，可以修改为bash

也就是运行 eval "$(/home/wxy/miniconda3/bin/conda shell.bash hook)" 这样就初始化完毕了，再运行 conda 命令就没问题了

然后运行 conda init ，持久化配置，这样下次打开系统conda命令依然生效

Langchain + deepseek +neo4j 构建电影知识图谱智能问答

pangguoming — Mon, 26 May 2025 01:46:19 GMT

安装LangChain 依赖

pip install --upgrade --quiet  langchain langchain-community langchain-openai neo4j

安装Neo4j

https://neo4j.com/deployment-center/ 下载安装 neo4j-community-5.26.4 解压到任意目录

安装Neo4j Apoc 插件

https://github.com/neo4j/apoc/releases?page=1 下载安装apoc-5.26.6-core.jar 复制到neo4j安装目录 plugins目录下修改Neo4j配置文件，启用Neo4j Apoc 插件：到neo4j安装目录 plugins目录下修改\conf\neo4j.conf，添加如下两行

dbms.security.procedures.unrestricted=apoc.*
dbms.security.procedures.allowlist=apoc.*

启动Neo4j

命令行到neo4j安装目录\bin下运行：

neo4j console

langchain + deepseek +neo4j 构建电影知识图谱智能问答

import getpass
import os
from langchain.chains import GraphCypherQAChain
from langchain_openai import ChatOpenAI
from langchain_community.graphs import Neo4jGraph

os.environ["OPENAI_API_KEY"] = "您的DeepSeek API 秘钥"
os.environ["NEO4J_URI"] = "bolt://localhost:7687"
os.environ["NEO4J_USERNAME"] = "neo4j"
os.environ["NEO4J_PASSWORD"] = "您的Neo4j密码"

llm = ChatOpenAI(
    model='deepseek-chat',
    base_url="https://api.deepseek.com/v1"
)

graph = Neo4jGraph()

# Import movie information

movies_query = """
LOAD CSV WITH HEADERS FROM 
'https://raw.githubusercontent.com/tomasonjo/blog-datasets/main/movies/movies_small.csv' 
AS row
MERGE (m:Movie {id:row.movieId})
SET m.released = date(row.released),
    m.title = row.title,
    m.imdbRating = toFloat(row.imdbRating)
FOREACH (director in split(row.director, '|') | 
    MERGE (p:Person {name:trim(director)})
    MERGE (p)-[:DIRECTED]->(m))
FOREACH (actor in split(row.actors, '|') | 
    MERGE (p:Person {name:trim(actor)})
    MERGE (p)-[:ACTED_IN]->(m))
FOREACH (genre in split(row.genres, '|') | 
    MERGE (g:Genre {name:trim(genre)})
    MERGE (m)-[:IN_GENRE]->(g))
"""
#用Loadcsv 在线下载并构建电影知识图谱数据

graph.query(movies_query)
graph.refresh_schema() #刷新schema


chain = GraphCypherQAChain.from_llm(graph=graph,allow_dangerous_requests=True,llm=llm, verbose=True)
response = chain.invoke({"query": "What was the cast of the Casino?"}) #提问
print(response) #回答

回答如下：

 Entering new GraphCypherQAChain chain...[0m
Generated Cypher:
[32;1m[1;3mcypher
MATCH (p:Person)-[:ACTED_IN]->(m:Movie {title: 'Casino'})
RETURN p.name
[0m
Full Context:
[32;1m[1;3m[{'p.name': 'James Woods'}, {'p.name': 'Joe Pesci'}, {'p.name': 'Robert De Niro'}, {'p.name': 'Sharon Stone'}][0m

[1m> Finished chain.[0m
{'query': 'What was the cast of the Casino?', 'result': 'The cast of *Casino* includes James Woods, Joe Pesci, Robert De Niro, and Sharon Stone.'}

基于Langchain + DeepSeek 构建聊天机器人

pangguoming — Wed, 21 May 2025 00:53:09 GMT

基于Langchain + DeepSeek 构建聊天机器人

前言

本文主要介绍如何基于 DeepSeek 来创建一个聊天机器人。首先介绍 PromptTemplate 提示模版，它作为设计对话流的基础，能够极大提升用户体验。接着，深入 DeepSeek 环境准备及模型创建过程，包括获取 API、创建和配置 API Key、设置 base_url 以及选择合适的模型等步骤。基于 Langchain 框架，将介绍如何通过 MessagesPlaceholder 处理复杂的多轮对话，构建 Chain 保存对话历史，并了解 RunnableWithMessageHistory 对象的实现流式输出，并通过示例代码演示整个流程的实际运行效果。

备注：本系列文章基于 B 站课程：马士兵-AI 大模型全套教程（学习路线+LLM 大语言模型+RAG 实战+Langchain+ChatGLM-4+Transformer+DeepSeek）学习整理得到。

1. 使用 PromptTemplate 提示模板

Langchain 提供了一个提示词模板 ChatPromptTemplate，它用来帮助我们构建提示词。可以简单理解为 Python 的字符串拼接模板。

定义提示模版

from langchain_core.prompts import ChatPromptTemplate

prompt_template = ChatPromptTemplate.from_messages(
    [("system", '请将以下的内容翻译成{language}'), ("user", "{text}")]
)

完整使用代码及运行结果

import os
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

os.environ["OPENAI_API_KEY"] = "DEEPSEEK_API_KEY"

# 1. 创建模型
model = ChatOpenAI(
    model='deepseek-chat',
    base_url="https://api.deepseek.com/v1"
)

# 2. 定义提示模版
prompt_template = ChatPromptTemplate.from_messages(
    [("system", '请将以下的内容翻译成{language}'), ("user", "{text}")]
)

# 3. 创建返回的数据解析器
parser = StrOutputParser()

# 4. 创建链 chain
chain = prompt_template | model | parser

# 5. 直接使用 chain 进行调用
result = chain.invoke({"language": "English", "text": '我下午还有一节课，不能去打球了'})
print(result)

2. DeepSeek 环境准备及模型创建

2.1 获取 API

访问 DeepSeek 开放平台。

2.2 创建 API Key

在左侧点击 API Keys，然后创建 API Key。

2.3 配置 API KEY

os.environ["OPENAI_API_KEY"] = "your_key"

将上一步中创建的 Key 配置到环境变量中。

2.4 配置 base_url

model = ChatOpenAI(
    base_url="https://api.deepseek.com"
)

代理地址或中转地址填写 "https://api.deepseek.com"。
注意：出于与 OpenAI 兼容考虑，也可以将 base_url 设置为 "https://api.deepseek.com/v1"。

2.5 配置 model

model = ChatOpenAI(
    model='deepseek-reasoner',
    base_url="https://api.deepseek.com/v1"
)

deepseek-reasoner 是 DeepSeek 最新推出的推理模型 DeepSeek-R1。
通过指定 model='deepseek-reasoner'，即可调用 DeepSeek-R1。
注意：通过指定 model='deepseek-chat'，即可调用 DeepSeek-V3。

3. Langchain 构建聊天机器人

这个聊天机器人能够进行对话并记住之前的互动。

3.1 引入 MessagesPlaceholder 来处理多轮对话

MessagesPlaceholder 用于在 Prompt 中插入历史消息，支持多轮对话。动态的系统消息可以通过 {} 进行参数化。

# 定义提示模版
prompt_template = ChatPromptTemplate.from_messages([
    ('system', '你是一个乐于助人的助手。用{language}尽你所能回答所有问题。'),
    MessagesPlaceholder(variable_name='my_msg')
])

3.2 构建 Chain 和保存对话历史

LangChain 提供了 RunnableWithMessageHistory 和 ChatMessageHistory 来支持多轮对话，并保存对话的历史记录。

store = {}  # 所有用户的聊天记录都保存到 store。key: session_id, value: 历史聊天记录

# 此函数预期将接受一个 session_id，并返回与该 session_id 对应的聊天记录
def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

do_message = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key='my_msg'  # 每次聊天时发送 msg 的 key
)

3.3 调用 RunnableWithMessageHistory 对象的 invoke() 方法

每次调用 do_message.invoke() 时，都会根据当前会话的 sessionId 获取或创建对应的对话历史。

config = {'configurable': {'session_id': 'ls1234'}}  # 给当前会话定义一个 sessionId

# 第一轮对话
resp1 = do_message.invoke(
    {
        'my_msg': [HumanMessage(content='你好啊！ 我是孙悟空')],
        'language': '中文'
    },
    config=config
)
print(resp1.content)

# 第二轮对话
resp2 = do_message.invoke(
    {
        'my_msg': [HumanMessage(content='请问：我有其它的昵称吗')],
        'language': '中文'
    },
    config=config
)
print(resp2.content)

3.4 流式输出

LangChain 支持流式响应，这对于处理长文本或实时交互非常有用。

# 第三轮对话 返回的数据是流式的
config = {'configurable': {'session_id': 'lishi987'}}  # 给当前会话定义一个 sessionId
for resp in do_message.stream(
        {'my_msg': [HumanMessage(content='81难后，我该成仙还是成佛？ 或者入魔？')],
         'language': '中文'},
        config=config):
    # 每一次 resp 都是一个 token
    print(resp.content, end='-')

3.5 示例代码及运行效果

from langchain_core.messages import HumanMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
import os
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables import RunnableWithMessageHistory
from langchain_openai import ChatOpenAI

os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

# 1. 创建模型
model = ChatOpenAI(
    model='deepseek-chat',
    base_url="https://api.deepseek.com/v1"
)

# 2. 定义提示模版，引入 MessagesPlaceholder 来处理多轮对话
prompt_template = ChatPromptTemplate.from_messages([
    ('system', '你是一个乐于助人的助手。用{language}尽你所能回答所有问题。'),
    MessagesPlaceholder(variable_name='my_msg')
])

# 3. 创建链 chain
chain = prompt_template | model

# 4. 定义函数保存和管理对话历史
store = {}

def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

# 5. 将 Chain 和对话历史管理器对象结合
do_message = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key='my_msg'
)

config = {'configurable': {'session_id': 'ls1234'}}

# 6. 调用对话历史管理器对象的 invoke() 及 stream() 方法，进行对话
# 第一轮对话
resp1 = do_message.invoke(
    {
        'my_msg': [HumanMessage(content='你好啊！ 我是孙悟空')],
        'language': '中文'
    },
    config=config
)
print(resp1.content)

# 第二轮对话
resp2 = do_message.invoke(
    {
        'my_msg': [HumanMessage(content='请问：我有其它的昵称吗')],
        'language': '中文'
    },
    config=config
)
print(resp2.content)

# 第三轮对话 返回的数据是流式的
config = {'configurable': {'session_id': 'lishi987'}}
for resp in do_message.stream(
        {'my_msg': [HumanMessage(content='81难后，我该成仙还是成佛？ 或者入魔？')],
         'language': '中文'},
        config=config):
    print(resp.content, end='-')

ChatGPT模型常用参数设置(temperature, max_tokens, presence_penalty, frequency_penalty, top_p, n)

pangguoming — Tue, 22 Apr 2025 00:24:59 GMT

OpenAI ChatGPT参数配置指南

1. Temperature参数

1.1 作用

Temperature 是控制生成文本随机性和创造性的参数,取值范围在0到1之间：

低温度(接近0): 生成更确定和保守的文本
高温度(接近1或更高): 生成更随机和多样化的文本

1.2 参数设置建议

0.0: 完全确定性
0.2-0.5: 适合需要高一致性的任务
0.7-1.0: 适合需要创造性的任务
1.0: 生成非常多样化但可能不连贯的文本

2. Max_tokens参数

2.1 作用

控制生成回复的最大标记数量,影响文本长度和资源消耗。

2.2 参数设置建议

短回复: 10-50 tokens
中等长度: 50-200 tokens
长回复: 200-1000 tokens

注意事项

注意上下文长度限制
较长文本可能影响生成质量

3. Presence_penalty参数

3.1 作用

控制是否引入新话题,取值范围-2.0到2.0。

3.2 参数设置建议

正值: 鼓励引入新话题
负值: 减少新话题引入

4. Frequency_penalty参数

4.1 作用

控制重复词语频率,取值范围-2.0到2.0。

4.2 参数设置建议

正值: 减少重复词语
负值: 增加重复词语

5. Top_p参数

5.1 作用

使用核采样控制文本多样性,取值范围0到1。

5.2 参数设置建议

低值: 生成更确定的文本
高值: 生成更多样化的文本

与Temperature比较

Temperature控制随机性
Top_p控制考虑的标记概率

6. N参数

6.1 作用

控制生成回复数量。

6.2 参数设置建议

1: 生成单个回复(默认)
1: 生成多个独立回复

注意事项

值越大消耗资源越多

Langchain 的基本用法

pangguoming — Thu, 13 Mar 2025 02:00:48 GMT

langchain 的各种花式写法实在是太多，直接看复杂代码让人头晕。文本基于 0.3 版本记录一下基础语法，重点是 ChatModel、PromptTemplate 和 OutputParser，以及如何通过这三种对象搭基础 RunnableSequence，进行一次完整的 LLM 调用。这种小功能单元是 Agent 系统的基础结构。

关于 langchain 的更多细节，可以参考官方网站：Introduction | ️ LangChain LangChain Python API Reference 【我基于的是最新的 v0.3，从该版本起，很多传统写法已废弃，详见 Deprecations and Breaking Changes | ️ LangChain】

1. 开发环境

langchain 的核心是 langchain-core 和 langchain，如果用到一些社区功能，还要加上 langchain-community，搭建 Agent 用的是 langgraph。这些包可以先全部装上。

pip install langchain-core langchain langchain-community langgraph

2. 加载 LLM 模型

langchain 中的 LLM 是通过 API 来访问的，目前支持将近 80 种不同平台的 API，详见 Chat models | ️ LangChain

这些模型都是会话模型 ChatModel，因此命名都以前缀 Chat- 开始，比如 ChatOPenAI 和 ChatDeepSeek 等。这些模型分两种，一种由 langchain 官方提供，需要安装对应的依赖包（比如 langchain-openai），一种由社区提供，在 langchain-community 中实现。具体的安装和使用方式，可以从上面的链接中查看。

无论哪种模型，都需要配置密钥 api_key 和模型版本 model_name，以阿里云的百炼平台为例：

import os
# 通过环境变量配置密钥.
os.environ["DASHSCOPE_API_KEY"] = "自己的密钥"

from langchain_community.chat_models.tongyi import ChatTongyi
llm = ChatTongyi(model_name="qwen-max") # 也可以通过参数 api_key="..." 配置密钥.

# 调用模型.
llm.invoke("你好")
如果是由 langchain 提供的官方模型，还可以使用统一的初始化接口 init_chat_model：

from langchain.chat_models import init_chat_model

os.environ["OPENAI_API_KEY"] = "XXXXXXXXXXXXXXXXXX"
gpt_4o = init_chat_model("gpt-4o", model_provider="openai")

3. RunnableSequence

这里调用 llm 的方式是 Invoke()，这是 Runnable 对象的通用方法。在 langchain 里，几乎所有的核心功能类都是 Runnable 对象。Runnable 对象可以看作是一种“管道”或者“工作流”，它们拥有统一的调用接口，我们就不需要去记忆每种类型的入口函数到底叫什么名字，总之都是 invoke()。Runnable 对象的详细手册可以参看 Runnable interface | ️ LangChain，这里只介绍高频使用的：

invoke：把输入转换为输出，即调用函数； batch：并行计算； stream：流式处理；每一种 Runnable 对象，都已经预置了自身的输入类型和输出类型，即 invoke() 函数的输入和输出。可以通过成员函数 get_input_schema / get_input_jsonschema、get_output_schema / get_output_jsonschema、config_schema / get_config_jsonschema 查询。比如：

llm.get_input_jsonschema() invoke、batch、stream，都有对应的异步版本 ainvoke、abatch、astream，大大减轻了开发工作量。只要开发了一个 Runnable 对象，就能轻松变成并行版 batch() 和异步版 ainvoke()。

多个 Runnable 可以顺序拼接成“链式”的 RunnableSequence，比如：

chain = llm | xxx | yyy | zzz

拼接成的 chain 也是 Runnable 对象，能 invoke()，能 batch()，能 stream()。这种写法叫做 LCEL（LangChain Expression Language），看习惯就好了。

4. 基础消息类型 Message

Messages | ️ LangChain 继续说回 llm.invoke()。这个函数返回的是一个 AIMessage 对象。Message 是langchain 中 ChatModel 的核心输入输出类型，根据 role 可以分为 SystemMessage、HumanMessage、AIMessage 和 ToolMessage。每种 Message 的核心是内部属性 content。

当直接给 llm 输入字符串时，默认解析为 HumanMessage 类型。这里有很多种花式写法，以下的四种等价：

from langchain_core.messages import HumanMessage

llm.invoke("你好呀")
llm.invoke(HumanMessage(content="你好呀"))
# 以下两种写法只支持列表
llm.invoke([{"role": "user", "content": "你好呀"})
llm.invoke([("user", "你好呀")])

如果要传入会话历史，就使用 Message 列表的形式：

from langchain_core.messages import SystemMessage, HumanMessage

messages = [SystemMessage(content="你是我的私人助理"), HumanMessage(content="你好呀")]
llm.invoke(messages)

5. 输入模板 PromptTemplate

Prompt Templates | ️ LangChain 5.1. 带占位的基础模板实际调用 llm 时，每次请求需要在固定 prompt 中拼接用户定制项，这就需要 PromptTemplate 来实现。langchain 用的占位符是 {}，和 Python 的 f-string 一样。

from langchain_core.prompts import PromptTemplate

# 模板定义.
prompt_template = PromptTemplate.from_template("今天是星期{day}")
# 返回类型.
# PromptTemplate(input_variables=['day'], template='今天是星期{day}')
PromptTemplate 的两个核心属性是 input_variables 和 template，因此也可以通过直接赋值来初始化：

prompt_template = PromptTemplate(template='今天是星期{day}', input_variables=['day'])
PromptTemplate 也是 Runnable 对象，因此也使用 invoke() 作为入口。输入是参数字典，输出是 StringPromptValue 对象：

prompt_template.invoke({"day": "三"})
# 返回类型.
# StringPromptValue(text='今天是星期三')

还有一种模板是 ChatPromptTemplate，可以处理 Message 列表：

from langchain_core.prompts import ChatPromptTemplate

prompt_template = ChatPromptTemplate([
    ("system", "你是我的私人助理"),
    ("user", "今天是星期{day}")
])
# 返回类型.
# ChatPromptTemplate(input_variables=['day'], messages=[SystemMessagePromptTemplate(prompt=PromptTemplate(input_variables=[], template='你是我的私人助理')), HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['day'], template='今天是星期{day}'))])

从返回类型可以看到，ChatPromptTemplate 内部实际是一个 PromptTemplate 的列表。调用 invoke() 执行后，会转化为 ChatPromptValue，它的内部是 Message 列表：

prompt_template.invoke({"day": "三"})
# 返回类型.
# ChatPromptValue(messages=[SystemMessage(content='你是我的私人助理'), HumanMessage(content='今天是星期三')])

如果要在prompt中变动的一条完整 Message，可以使用消息占位符 MessagesPlaceholder，或者直接将 role 指定为 placeholder。两种写法等价：

from langchain_core.prompts import MessagesPlaceholder

# 第一种：使用 MessagesPlaceholder 占位.
prompt_template = ChatPromptTemplate([
    ("system", "你是我的私人助理"),
    MessagesPlaceholder("msgs")
])

# 第二种：直接使用 placeholder 作为消息的 role.
prompt_template = ChatPromptTemplate([
    ("system", "你是我的私人助理"),
    ("placeholder", "{msgs}")
])

# 返回类型.
# ChatPromptTemplate(input_variables=['msgs'], input_types={'msgs': typing.List[typing.Union[langchain_core.messages.ai.AIMessage, langchain_core.messages.human.HumanMessage, langchain_core.messages.chat.ChatMessage, langchain_core.messages.system.SystemMessage, langchain_core.messages.function.FunctionMessage, langchain_core.messages.tool.ToolMessage]]}, messages=[SystemMessagePromptTemplate(prompt=PromptTemplate(input_variables=[], template='你是我的私人助理')), MessagesPlaceholder(variable_name='msgs')])

ChatPromptTemplate 同样使用 invoke 接口来调用，注意占位符 msgs 对应的必须是列表：

# 第一种写法.
prompt_template.invoke({"msgs": [HumanMessage(content="你好！")]})
# 第二种写法.
prompt_template.invoke({"msgs": [("user", "你好！")]})
# 返回类型.
# ChatPromptValue(messages=[SystemMessage(content='你是我的私人助理'), HumanMessage(content='你好！')])

invoke 之后，ChatPromptTemplate 就转化成了 ChatPromptValue，也就是 Message 的列表。

5.2. Message拼接转模板当两个 Message 使用 + 进行拼接时，会自动转换为 ChatPromptValue。因此，定义模板也可以直接往 Message 上去拼字符串。

# Message 直接拼接.
SystemMessage(content="你是我的私人助理") + HumanMessage(content="今天的天气不太好")
# 返回类型.
# ChatPromptTemplate(input_variables=[], messages=[SystemMessage(content='你是我的私人助理'), HumanMessage(content='今天的天气不太好')])
# 字符串拼接.
SystemMessage(content="你是我的私人助理") + "今天是星期{day}"
# 返回类型.
# ChatPromptTemplate(input_variables=['day'], messages=[SystemMessage(content='你是我的私人助理'), HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['day'], template='今天是星期{day}'))])

5.3. 模板的部分格式化化 PromptTemplate 和 ChatPromptTemplate 的一个重要特点，是支持部分占位符的格式化。这一功能在复杂系统中尤其有用。比如，基类模板共有 a 和 b 两个占位符，派生模板 A 可以只使用 a，派生模板 B 可以只使用 b。部分格式化通过 partial() 来实现，先来看一个最简单的例子：

prompt_template = PromptTemplate.from_template("现在是 {year} 年 {month} 月")
# 输出.
# PromptTemplate(input_variables=['month', 'year'], template='现在是 {year} 年 {month} 月')
# 部分格式化.
partial_prompt = prompt_template.partial(year="2025")
# PromptTemplate(input_variables=['month'], partial_variables={'year': '2025'}, template='现在是 {year} 年 {month} 月')
在调用了 partial() 后，PromptTemplate 的 input_variables 由 ['month', 'year'] 减少到 ['month']，而 partial_variables 中增加了 {'year': '2025'}。

partial_prompt.invoke({"month": "3"})
# 输出.
# StringPromptValue(text='现在是 2025 年 3 月')

借着这个例子，介绍一些 langchain 中关于类型实例化的一种通用写法。比如上面的代码，当你看到输出内容是StringPromptValue(text=‘现在是 2025 年 3 月’)，这往往就是该类型的是初始化方法，可以通过原命令直接构造。比如：

from langchain_core.prompt_values import StringPromptValue

# 构造.
StringPromptValue(text='现在是 2025 年 3 月')
# 输出. 一模一样.
# StringPromptValue(text='现在是 2025 年 3 月')

了解这种写法之后，看各种类型会觉得清晰一些。继续说回模板的部分参数化。如果不直接调用 partial()，而是直接做 partial_variables 的赋值，那么也可以将占位符指定为函数：

from datetime import datetime

def _get_datetime():
    now = datetime.now()
    return now.strftime("%m/%d/%Y, %H:%M:%S")

# 直接定义模板.
prompt_template = PromptTemplate(
    template="今天的日期是 {date}，天气是 {wheather}",
    input_variables=["wheather"],
    partial_variables={"date": _get_datetime},
)
prompt_template.invoke({"wheather": "小雨"})
# 输出.
# StringPromptValue(text='今天的日期是 02/27/2025, 20:00:00，天气是 小雨')

6. 结构化输出 OutputParser

Output parsers | ️ LangChain 前面已经介绍了prompt 和 model，剩下的就是 model 的输出解析。通常来说，模型返回的输出是一个 AIMessage 对象，本质上还是字符串文本。在构造应用时，常常需要对大模型的输出做结构化，比如转换为 JSON 或者 Enum，以便于下游使用。这时就需要 OutputParser 来支持。

每种数据类型有自己对应的 OutputParser，比如 JSON 对应着 JsonOutputParser。无论哪种类型，都有一个公共方法 get_format_instructions()，可以返回对应格式的约束描述（schema）。实际上，结构化输出有两个步骤：

在 prompt 中注入 get_format_instructions()，告诉 llm 要生成什么类型的结果；在生成之后，进行对应格式的转化； 6.1. 生成格式约束以图书信息为例子，首先要基于 pydantic 构造 schema：

from pydantic import BaseModel, Field

class Book(BaseModel):
    name: str = Field(description="书籍名称")
    year: int = Field(description="出版年份")

然后基于 schema，构造 OutputParser：

from langchain_core.output_parsers import JsonOutputParser

parser = JsonOutputParser(pydantic_object=Book)
parser.get_format_instructions()
# 输出
# 'The output should be formatted as a JSON instance that conforms to the JSON schema below.\n\nAs an example, for the schema {"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}\nthe object {"foo": ["bar", "baz"]} is a well-formatted instance of the schema. The object {"properties": {"foo": ["bar", "baz"]}} is not well-formatted.\n\nHere is the output schema:\n```\n{"properties": {"name": {"description": "书籍名称", "title": "Name", "type": "string"}, "year": {"description": "出版年份", "title": "Year", "type": "integer"}}, "required": ["name", "year"]}\n```'

调用 get_format_instructions() 后，我们得到了一个很长的字符串。仔细看，这是一段关于格式约束的 prompt，它要求模型生成 JSON，然后告诉模型什么是 schema，然后对目标 schema 做了字段提示。当然，如果你不使用 OutputParser，也完全可以自己给 llm 写这么一段 prompt。

有了这段格式约束，就可以通过 PromptTemplate 的 partial_variables 注入进总体 prompt 中去。比如：

prompt = PromptTemplate(
    template="请帮我从出版列表中解析图书的信息。\n{format_instructions}\n出版列表：{query}\n",
    input_variables=["query"],
    partial_variables={"format_instructions": parser.get_format_instructions()},
)

6.2. 生成结构解析如果 llm 依从指令，生成了 JSON 格式的内容，就可以做下一步的结构化了：

response = "{\"name\": \"The World\", \"year\": 2025}"
parser.invoke(response)
# 输出.
# {'name': 'The World', 'year': 2025}

字符串的 response 就被转换成了 dict（也就是 JSON）。需要注意，这一步和前面定义的 schema 没有任何关系，只是单纯地做 JSON 转换。也就是说，只要是 JSON 字符串，无论是什么字段，都能转换成功。schema 只是用来生成格式约束来注入 prompt 中，并不参与生成后的格式解析。

6.3. 格式纠错如果 llm 生成的结果不是标准 JSON ，比如缺了引号或者加了别的字，可以用带纠错的 OutputFixingParser 来修复。OutputFixingParser 在解析输入时，如果直接成功会直接返回结构化对象，如果不成功则调用 llm 做默认1次的修复。

from langchain.output_parsers import OutputFixingParser

bad_response = "json {'name': 'The World', 'year': 2025}"
fix_parser = OutputFixingParser.from_llm(parser=parser, llm=llm)
fix_parser.parse(bad_response)
# 输出.
# {'name': 'The World', 'year': 2025}

和普通的 OutputParser 一样，OutputFixingParser 也是 schema 无关的，它只是做「格式」的修复。

7. 链 chain

一次基本的大模型调用，prompt、model 和 parser 都有了，而且都是 Runnable 对象，那么就能串联成 chain：

chain = prompt | llm | parser
chain.invoke({"query": "xxxxxxxxxxxxxx"})

由于 prompt 是 chain 的入口，那么 chain.invoke() 的输入参数就和 prompt 一致；parser 是 chain 的出口，那么 chain.invoke() 的输出格式就和 parser 一致。

有了这三部分，就能实现大部分的基础 llm 调用。langchain 还支持很多其他的范式，后续再讲。

RAG基本概念

pangguoming — Wed, 12 Mar 2025 00:07:26 GMT

1. 什么是 RAG？

RAG（Retrieval-Augmented Generation，检索增强生成）是一种结合信息检索和大模型生成的AI架构，主要用于提升大模型的知识准确性和上下文理解能力。

核心思想：

检索（Retrieval）：从外部知识库（如数据库、文档、网页）获取相关信息。生成（Generation）：将检索到的信息输入大模型（如GPT），让其基于这些信息生成更准确、可控的回答。为什么需要 RAG？

解决知识“遗忘”问题：基础大模型的知识可能过时，RAG可以引入最新信息。降低幻觉（Hallucination）：模型可能会编造信息，而RAG提供了可验证的外部数据，提高可信度。支持私有数据：可以让大模型使用企业内部文档，而不需要重新训练。

2. RAG 的核心组件

数据存储（知识库）

结构化数据：SQL数据库、NoSQL数据库（MongoDB）非结构化数据：PDF、网页、文本文件向量数据库（RAG的关键）：存储文本嵌入（embeddings）并支持高效检索。

嵌入模型（Embeddings）

把文本转换成向量表示，方便搜索。常见嵌入模型： OpenAI Embeddings（text-embedding-ada-002） BAAI BGE（中文推荐） Cohere、Hugging Face 的 embedding 模型

向量数据库（Vector Database）

存储和查询文本向量，检索相关信息。主流向量数据库： FAISS（轻量、本地） Weaviate、ChromaDB（开源） Pinecone、Milvus（云端）

检索（Retrieval）

基于相似度的检索（Top-K 近邻搜索）语义搜索（通过 embeddings 计算相似度）混合搜索（Hybrid Search）：结合关键字搜索 + 语义搜索

生成（LLM Response）

用大模型（如GPT-4、Claude、Llama）结合检索到的信息，生成回答。

3. RAG 的工作流程

（1）数据准备

收集和清理数据（PDF、数据库、网页）预处理数据（去重、拆分文本）用嵌入模型将数据转换成向量，并存入向量数据库（2）查询处理

用户输入问题对用户问题进行嵌入计算，转成向量在向量数据库中查找最相关的文档（Top-K）（3）信息融合

结合检索到的文档，构建 Prompt 让 LLM（大模型）基于上下文生成答案示例（简化版）：

用户问："如何优化库存管理？" RAG 先从数据库找出相关库存管理文档把这些文档的关键信息交给 GPT-4 进行总结 GPT-4 生成精准回答，并附带信息来源

4. RAG 进阶优化

✅ 1. Chunking（文本分块）

长文档拆成小段（比如每 500 个 Token 一块），避免检索不到核心内容。 ✅ 2. 多模态 RAG

除了文本，还可以检索图片、表格、代码等数据。 ✅ 3. RAG + 记忆

让模型记住用户的历史提问，提高连续对话能力（如Chatbot）。 ✅ 4. RAG + 评分机制

用 ReRanker 对检索的内容排序，提高相关性。 ✅ 5. RAG + 反馈优化

让用户反馈答案是否有用，并用 Reinforcement Learning 进一步优化 RAG。

5. RAG 实践（动手实验）

使用 LangChain 搭建一个 RAG 系统 LangChain 是一个专门用于 LLM 应用开发的 Python 框架，它支持 RAG 组件的集成。

安装依赖

pip install langchain openai faiss-cpu tiktoken

代码示例（RAG 小系统）

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.document_loaders import TextLoader
from langchain.llms import OpenAI

# 1. 加载文档并拆分
loader = TextLoader("data.txt")  
documents = loader.load()  

# 2. 转换为向量并存入FAISS数据库
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(documents, embeddings)

# 3. 用户查询 & 检索相关文档
query = "如何优化库存管理？"
retrieved_docs = vectorstore.similarity_search(query, k=3)

# 4. 结合检索结果，构造 Prompt 并调用 GPT
context = "\n\n".join([doc.page_content for doc in retrieved_docs])
prompt = f"根据以下内容回答问题:\n{context}\n\n问题: {query}"
llm = OpenAI()
response = llm(prompt)

print(response)

这个代码实现了：

加载文本数据计算文本向量，存入 FAISS 向量数据库根据用户问题检索相关文档调用 GPT 生成答案

向量数据库Faiss入门

pangguoming — Fri, 21 Feb 2025 03:15:40 GMT

向量数据库Faiss是Facebook AI研究院开发的一种高效的相似性搜索和聚类的库。它能够快速处理大规模数据，并且支持在高维空间中进行相似性搜索。本文将介绍如何搭建Faiss环境并提供一个简单的使用示例。

Faiss的安装

首先，我们需要在我们的系统上安装Faiss。Faiss支持Linux，macOS和Windows操作系统，可以通过Python的pip包管理器进行安装。在终端中输入以下命令：

pip install faiss-cpu

如果你的系统有NVIDIA的GPU并且已经安装了CUDA，你可以选择安装支持GPU的版本：

pip install faiss-gpu

Faiss的基本使用

安装完Faiss之后，我们可以开始创建我们的第一个向量数据库。首先，我们需要导入Faiss库和numpy库，因为Faiss的输入数据需要是numpy数组。

import numpy as np
import faiss

然后，我们可以生成一些随机数据作为我们的向量数据库。在这个例子中，我们生成了10000个128维的向量。

d = 128                            # dimension
nb = 10000                         # database size
np.random.seed(1234)             # make reproducible
xb = np.random.random((nb, d)).astype('float32')

接下来，我们需要创建一个索引。索引是Faiss进行高效搜索的关键。在这个例子中，我们使用最简单的L2距离索引。

index = faiss.IndexFlatL2(d)   # build the index
print(index.is_trained)

然后，我们可以将我们的数据添加到索引中。

index.add(xb)                  # add vectors to the index
print(index.ntotal)

现在，我们的向量数据库已经准备好了，我们可以进行搜索了。我们生成了5个查询向量，并且我们希望找到每个查询向量的最近的4个向量。

nq = 5                          # number of query vectors
k = 4                           # we want 4 similar vectors
Xq = np.random.random((nq, d)).astype('float32')
D, I = index.search(Xq, k)     # sanity check
print(I)
print(D)

在这个例子中，I是一个数组，它包含了每个查询向量的最近的4个向量的索引。D是一个数组，它包含了这些向量的距离。

Faiss的强大之处在于它可以处理任何可以表示为向量的数据，包括图片和文件。在这个部分，我们将介绍如何使用Faiss进行图片和文件的搜索。

图片搜索

在进行图片搜索时，我们首先需要将图片转换为向量。这通常通过深度学习模型，如CNN，来实现。这些模型可以将图片的视觉内容编码为一个向量，这个向量可以捕获图片的重要特征。

以下是一个简单的例子，我们使用预训练的ResNet模型将图片转换为向量：

from torchvision import models, transforms
from PIL import Image

# Load the pretrained model
model = models.resnet50(pretrained=True)
model = model.eval()

# Define the image transformations
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

# Load the image
image = Image.open('image.jpg')

# Apply the transformations and get the image vector
image = transform(image).unsqueeze(0)
image_vector = model(image).detach().numpy()

然后，我们可以将这个向量添加到Faiss的索引中，就像我们在前面的例子中做的那样。当我们需要搜索相似的图片时，我们可以将查询图片也转换为向量，然后使用Faiss进行搜索。

文件搜索

对于文件搜索，我们也需要将文件转换为向量。这通常通过自然语言处理模型，如BERT，来实现。这些模型可以将文本内容编码为一个向量，这个向量可以捕获文本的语义信息。

以下是一个简单的例子，我们使用预训练的BERT模型将文本文件转换为向量：

from transformers import BertModel, BertTokenizer

# Load the pretrained model and tokenizer
model = BertModel.from_pretrained('bert-base-uncased')
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Load the text file
with open('file.txt', 'r') as f:
    text = f.read()

# Tokenize the text and get the text vector
inputs = tokenizer(text, return_tensors='pt')
outputs = model(**inputs)
text_vector = outputs.last_hidden_state.mean(dim=1).detach().numpy()

然后，我们可以将这个向量添加到Faiss的索引中，就像我们在前面的例子中做的那样。当我们需要搜索相似的文件时，我们可以将查询文件也转换为向量，然后使用Faiss进行搜索。

结论

通过将图片和文件转换为向量，我们可以使用Faiss进行高效的搜索。这种方法不仅可以应用于图片和文件，还可以应用于任何可以表示为向量的数据，如音频，视频等。这使得Faiss成为处理大规模数据和进行相似性搜索的强大工具。

FastAPI 快速入门

pangguoming — Thu, 13 Feb 2025 03:22:31 GMT

参考： https://fastapi.tiangolo.com/zh/learn/ https://www.runoob.com/fastapi/fastapi-form.html https://blog.csdn.net/qq_39172059/article/details/136518206

一、什么是FastAPI？

FastAPI是一个现代、快速（高性能）的python web框架，基于标准的python类型提示，使用python3.6+构建的web框架。

FastAPI的架构为RESTful风格，RESTful是一种网络应用程序的设计风格和开发方式，其特点为每一个URI代表一种资源，客户端通过GET、POST、PUT、DELETE等动作，对服务器端资源进行操作。

（一）环境准备

1.安装FastAPI：pip install fastapi

（交互文档需要访问外部资源，行内在1.0.3版本中将外部资源转为行内资源，若行内网络使用请指定版本1.0.3）

2.安装ASGI服务：pip install uvicorn

（二）入门示例

新建一个main.py文件，编写如下:

from fastapi import FastAPI  
app = FastAPI()  
@app.get('/')  
def root():  
   return {'message': 'Hello World'}

启动服务

命令：uvicorn main:app --reload

² main:文件main.py（python模块）

² app：在模块中app=FastAPI()行中创建的对象

² --reload：代码更改后自动重启服务（上线时该参数值不能为true，降低性能）

启动服务后终端将会看到如下输出：

访问服务

启动服务后，使用浏览器访问127.0.0.1:8000，

可以得到{“Hello”:“World”} ,说明环境安装成功。

API交互文档

启动服务后，FastAPI会自动给生成两个交互文档：

SwaggerUI：http://127.0.0.1:8000/docs

ReDoc：http://127.0.0.1:8000/redoc

http://127.0.0.1:8000/openapi.json

查看openapi.json

http://127.0.0.1:8000/openapi.json

本地部署

命令：uvicorn main:app --host 0.0.0.0 --port 8000

² main:启动服务的py文件名

² app：服务对象名

² --host：IP地址

² --port：端口

本地部署后，可通过外部访问本地启动服务。

（三）入门示例了解FastAPI结构

from fastapi import FastAPI
 
app = FastAPI()  

@app.get('/')  
def root():  
    return {'message': 'Hello World'}

导入FastAPI

from fastapi import FastAPI

创建一个app实例

app = FastAPI()

编写路径操作装饰器

@app.get('/')

（1）使用get请求，也可使用其他请求方法的装饰器

@app.post()

@app.put()

@app.delete()

@app.options()

@app.head()

@app.patch()

@app.trace()

（2）路径(’/’) 自定义

定义路径操作函数

def root(): 
    return {'message': 'Hello World'}
	```
（1）python函数;

（2）当FastAPI接收一个使用GET方法访问路径为/的请求时这个函数会被调用;

（3）此处的返回值可以是：字典，列表，单独的值：比如str，int，Pydantic模型，自动转换为JSON的对象和模型。

5. 运行开发服务
```python
uvicorn main:app

此处可以执行要运行的服务器IP和端口号，默认IP :127.0.0.1，端口:8000

uvicorn main:app --host 127.0.0.1 --port 8080

二、uvicorn启动方式

（一）使用命令行运行

按入门示例的方式，在py文件所在目录下的命令行中运行。

（二）使用uvicorn.run()

三、接口文档注释

（一）注释类型

1.title标题

2.description描述

3.summary注释

4.tags标签

示例：

rom fastapi import FastAPI  
app = FastAPI(title='测试api应用程序', description='整体描述')  
@app.get(path='/', summary='接口注释', description='接口描述', tags= ['Root'])  
def read_root():      
    return {"Hello": "World"}

大模型落地路径：Prompt Engineering、RAG（检索增强生成、微调（Fine-tuning）、Pre-Training（预训练）

pangguoming — Sat, 08 Feb 2025 05:40:51 GMT

一、大模型技术发展现状

自2022年底ChatGPT掀起AI革命以来，大语言模型（LLM）技术快速迭代发展，从GPT-4到Claude 2，从文心一言到通义千问，大模型技术以惊人的速度发展。然而，在企业实际应用场景中，在企业探索大模型技术落地的过程中，RAG（检索增强生成）和微调（Fine-tuning）成为了两大主要技术方案。到底应该如何有成本和预算可控的情况下，又能基于当前的技术成熟度和应用边界来选择和确定一套可行的大模型技术验证方案，成为技术决策者面临的重要课题。

二、企业落地大模型主要挑战

在大模型技术蓬勃发展的今天，越来越多的企业开始探索大模型的落地应用。然而，从实践来看，企业在这一过程中面临着多重挑战。从这两年陆续跑过的客户以及行业对标企业的综合情况来看，由于整体经济形势的压力，很多细分领域的企业都面临着生存压力，但迫于业务竞争，不管是技术还是产品设计上，都必须无挑看拥抱大模型技术，将大模型融入业务流程中，设计创新型提效的业务应用，其中首要问题是面临成本压力，无论是模型训练还是持续运维，都需要投入大量的算力资源和人力成本，这对中小企业来说尤其沉重。其次是技术门槛高，企业需要组建具备专业AI背景的技术团队，而这类人才在市场上十分稀缺。数据质量和数据获取也是一大痛点。高质量的训练数据不仅获取困难，标注成本也十分高昂。同时，企业业务数据经常变动，如何确保模型能够及时更新知识库，保持对最新信息的响应能力，也是一个重要挑战。此外，业务场景往往要求快速验证和迭代，而传统的模型训练和微调周期较长，难以满足企业对时效性的要求。这些挑战使得许多企业在大模型落地过程中举步维艰，需要更加务实的技术方案和实施策略。

三、大模型建设模式分析

在大模型技术落地实践中，企业主要面临「能力建设」和「应用建设」两种路径选择。能力建设模式主要面向年度研发预算在2亿以上的大型企业，通过构建自主可控的大模型，实现数据安全与主权掌控。这种模式初期投入高达5,000万到1亿元，建设周期长达12-18个月，需要持续投入维护，适合对数据安全要求极高的行业头部企业，比如科大讯飞和阿里云等大模型头部企业以及一些像智谱、百川、Kimi、零一万物等独角兽企业。

相比之下，应用建设模式则是绝大多数企业的现实选择。这种模式通过调用开源大模型或API服务，快速实现智能化应用落地。其投入规模在50-500万元之间，建设周期仅需3-6个月，以软件开发为主，运维成本可控。在数据安全方面，通过脱敏处理和专网部署来保障。目前，除了科大讯飞、阿里云等少数企业在特定领域采用私有化部署千亿级参数模型外，大多数企业都倾向于选择投入小、见效快的应用建设路径，这也是在预算约束下的最优解决方案。

四、大模型落地路径分析

在大模型技术落地实践中，企业可以根据自身资源条件和业务需求，选择不同的技术路径。从投入规模和技术难度来看，主要分为四种实施方案：

Prompt Engineering：是大模型应用的入门级选择，适合资源有限且需要快速验证的场景。虽然其技术难度低、投入少，但在处理复杂任务时，性能提升有限，且对提示词的敏感性较高。这种方法更适合用于简单的任务或作为快速原型工具。
RAG（检索增强生成）的核心在于不改变现有的大模型结构，而是在其基础上增加外部知识库。当用户提出问题时，模型会检索相关的知识，增强回答的准确性。这种方式下，模型本身无需重新训练，降低了技术门槛和实施成本。
微调（Fine-tuning）则是基于已有的大模型，通过结合特定领域的知识对模型进行再训练，生成一个全新的微调模型。这个新模型能够更准确地针对特定业务场景进行回答，但需要投入大量的训练资源和时间。
Pre-Training（预训练）：是最为复杂和昂贵的路径，通常用于构建全新的大模型或进行全面的模型调整。其技术门槛极高，适合拥有强大技术团队和长期发展计划的企业。从以上的对比分析结果可以看到，最轻量级的是Prompt Engineering（提示词工程）路径，仅需2-5万投入，1-2人小团队即可开展。通过精心设计提示词优化模型输出，适合快速验证和简单场景，但难以处理复杂任务。其次是RAG（检索增强生成）方案，投入在20-300万之间，需要5-8人团队协作。通过结合企业知识库，可以有效提升模型输出质量，但面临知识更新维护成本高等挑战。

Fine-tuning（模型微调）路径则需要500-2000万投入，要求5-10人的专业团队。通过大量标注数据进行模型参数调优，可以实现特定任务的深度优化，但需要较多算力资源。最重的是Pre-Training（预训练）路径，投入超过2000万，需要10人以上的技术团队，通过海量数据从头构建或全面调整模型，技术门槛极高，适合具备强大技术实力和资金实力的头部企业。

从成本效益角度看，大多数企业适合采用Prompt Engineering或RAG方案切入，在验证效果后再考虑更深层次的技术路径。这种渐进式的落地策略既能控制风险，又能快速获得应用价值。

在实际应用中，企业需要根据自身的资源、业务需求和发展目标，选择合适的技术路径。从大模型当前的发展趋势及今年诸多企业在实践探索过程中的经验来看，RAG 技术因其较好的成本效益比和灵活性，成为越来越多企业的首选。这种选择不仅能快速实现业务价值，还能为后续的深度优化和扩展奠定基础。

五、RAG vs 微调，到底该如何选择

从前面我们的分析中可以看到，在大模型技术实际落地过程中，RAG（检索增强生成）和微调（Fine-tuning）是两种主流的技术路径，它们各具特色，适用于不同场景。让我们从多个维度深入分析这两种方案的选择依据。

5.1、技术方案本质对比

RAG方案通过外挂知识库扩展模型能力，无需改变基础模型架构，主要增强模型的知识储备；而微调则直接改造基础模型，通过训练使模型获得特定领域的专业能力。从实施角度看，RAG无需模型训练，部署相对轻量；微调则需要专业的训练过程，技术门槛较高。

5.2、场景技术选择建议

企业在技术路径选择时，建议优先考虑以下因素：首先评估业务数据更新频率，如果需要频繁更新知识库，建议选择RAG方案；其次考虑性能要求，对响应速度要求极高的场景更适合微调方案；最后要权衡投入产出比，RAG方案通常能以更低成本实现可观效果。总的来说，RAG凭借其灵活性、可控性和成本优势，适合大多数企业级应用场景；而微调则适合对特定任务性能要求极高的专业场景。企业可以基于自身需求，选择最适合的技术路径，也可以在不同场景下组合使用这两种方案。

5.3、RAG技术：大模型落地的优选之路

从实践角度来看，RAG的优势主要体现在四个方面：首先，实施周期短，企业可以快速构建应用原型；其次，投资成本低，避免了昂贵的训练资源和数据标注支出；再次，业务适应性强，知识库可以随业务需求实时更新；最后，风险可控性好，企业能够通过知识库管理精确把控输出内容。这种技术方案无需复杂的模型训练过程，通过将现有大模型与外部知识库相结合，不仅大幅降低了实施门槛，也为企业提供了更高的灵活性和可控性。

然而，RAG并非放之四海而皆准的解决方案。在某些特定场景下，如需要注入大量稳定的领域知识、追求极高任务准确率，或现有技术无法满足业务目标时，微调方案可能更为适合。因此，企业在技术选型时需要权衡具体场景需求，以及自身的资源条件。值得注意的是，RAG作为一种轻量级解决方案，不仅能够帮助企业快速验证AI应用的可行性，还为未来可能的深度定制铺平道路，是当前大模型落地过程中的理想起点。

5.4、RAG与微调技术优缺点对比分析

在大模型应用落地过程中，技术选型是一个关键的决策点。目前主流的实现路径主要包括RAG(检索增强生成)和微调(Fine-tuning)两种技术方案。这两种方案各具特色，适用于不同的应用场景和业务需求。

RAG技术通过将外部知识库与大模型能力相结合，实现了一种轻量级的知识注入方案。它无需对模型本身进行改造，而是通过检索相关知识并将其作为上下文输入到模型中，从而提升模型在特定领域的表现。这种方式的最大优势在于其灵活性和可控性，企业可以随时更新知识库内容，快速响应业务变化。

相比之下，微调技术则是通过额外的训练来优化模型在特定任务上的表现。这种方式直接作用于模型参数，能够让模型更深入地理解和掌握领域知识，在特定任务上表现出更好的性能。但这种深度定制也意味着更高的技术门槛和资源投入。

与大部分的IT技术一样，无论是微调还是RAG，都有其优点和局限性。选择合适的技术方案需要综合考虑多个因素，包括但不限于：应用场景的特点、性能要求、资源约束、团队能力等。随着技术的不断发展，这些方案的优劣势也在动态变化。下面我们将从多个维度详细对比这两种技术方案的特点，以供参考。

六、基于大模型的RAG应用开发与优化

在当前大模型应用如火如荼的背景下，RAG技术无疑是最受关注的应用方向之一。然而，真正能够系统性地介绍企业级RAG应用开发与优化的技术书籍却凤毛麟角。今天要向大家推荐的这本《基于大模型的RAG应用开发与优化 — 构建企业级LLM应用》，恰恰填补了这一领域的空白。

作为一名深耕大模型应用落地的技术人，我深知RAG技术从理论到实践的过程中存在诸多挑战。这本书最打动我的是它的实用性和系统性。全书用500多页的篇幅，不仅涵盖了RAG的基础架构和实现原理，更重要的是深入探讨了企业级应用中的各种优化策略和最佳实践。从最基础的向量检索到高级的混合检索策略，从简单的问答系统到复杂的多轮对话，书中都提供了详实的代码示例和实现思路。

特别值得一提的是，本书基于LlamaIndex框架来讲解RAG的实现，这个选择可以说恰到好处。相比其他框架，LlamaIndex更专注于RAG场景，API设计也更加简洁优雅。但作者并没有局限于框架本身，而是着重剖析了RAG的核心原理，这使得读者可以轻松地将这些知识迁移到其他框架中。

从内容编排上看，本书采用了循序渐进的方式：首先介绍最基础、最常见的RAG应用架构，然后逐步深入到不同的RAG实现方式和优化策略，最后还探讨了几种新型RAG范式的原理与实现。这样的结构设计让读者能够根据自身水平，找到最适合的切入点。

作为在一线实践大模型落地的应用开发人员，我觉得书中对于企业级RAG应用优化策略的观点还是比较贴切实际需求的。这些内容都来自实战经验的总结，包括如何处理长文本、如何优化检索效果、如何提升响应速度等关键问题，这些都是企业实际落地过程中必须面对的挑战。

RAG是什么

pangguoming — Fri, 07 Feb 2025 09:15:53 GMT

因为利用大模型的能力搭建知识库本身就是一个RAG技术的应用。

所以在进行本地知识库的搭建实操之前，我们需要先对RAG有一个大概的了解。

以下内容会有些干，我会尽量用通俗易懂的描述进行讲解。

我们都知道大模型的训练数据是有截止日期的，那当我们需要依靠不包含在大模型训练集中的数据时，我们该怎么做呢？实现这一点的主要方法就是通过检索增强生成RAG（Retrieval Augmented Generation）。

在这个过程中，首先检索外部数据，然后在生成步骤中将这些数据传递给LLM。

我们可以将一个RAG的应用抽象为下图的5个过程：

文档加载（Document Loading）：从多种不同来源加载文档。LangChain提供了100多种不同的文档加载器，包括PDF在内的非结构化的数据、SQL在内的结构化的数据，以及Python、Java之类的代码等
文本分割（Splitting）：文本分割器把Documents 切分为指定大小的块，我把它们称为“文档块”或者“文档片”
存储（Storage）：存储涉及到两个环节，分别是：将切分好的文档块进行嵌入（Embedding）转换成向量的形式将Embedding后的向量数据存储到向量数据库

检索（Retrieval）：一旦数据进入向量数据库，我们仍然需要将数据检索出来，我们会通过某种检索算法找到与输入问题相似的嵌入片
Output（输出）：把问题以及检索出来的嵌入片一起提交给LLM，LLM会通过问题和检索出来的提示一起来生成更加合理的答案

文本加载器（Document Loaders）文本加载器就是将用户提供的文本加载到内存中，便于进行后续的处理

文本切割器（Text Splitters）文本分割器把Documents 切分为指定大小的块，我把它们称为“文档块”或者“文档片”

文本切割通常有以下几个原因

为了更好的进行文本嵌入以及向量数据库的存储通常大语言模型都有上下文的限制，如果不进行切割，文本在传递给大模型的时候可能超出上下文限制导致大模型随机丢失信息文本切割器的概念是非常容易理解的，这里我们简单了解下文本切割器的工作流程

将文本切割成小的，语义上有意义的块（通常是句子）开始将这些小块组成一个较大的块，直到达到某个块的大小（这个会通过某种函数测量）一旦达到该大小，就将该块作为自己的文本片段，并开始创建一个新的文本块，同时保留一些重叠（以保持块之间的上下文）。文本嵌入模型（Text Embedding models）文本嵌入模型是用来将文本转换成数值向量的工具，这些向量能够捕捉文本的语义信息，使得相似的文本在向量空间中彼此接近。这对于各种自然语言处理任务，如文本相似性比较、聚类和检索等，都是非常有用的。下面是一段对嵌入的解释

词嵌入（Word Embedding）是自然语言处理和机器学习中的一个概念，它将文字或词语转换为一系列数字，通常是一个向量。简单地说，词嵌入就是一个为每个词分配的数字列表。这些数字不是随机的，而是捕获了这个词的含义和它在文本中的上下文。因此，语义上相似或相关的词在这个数字空间中会比较接近。

举个例子，通过某种词嵌入技术，我们可能会得到：

“国王” -> [1.2, 0.5, 3.1, …] “皇帝” -> [1.3, 0.6, 2.9, …] “苹果” -> [0.9, -1.2, 0.3, …]

从这些向量中，我们可以看到“国王”和“皇帝”这两个词的向量在某种程度上是相似的，而与“苹果”这个词相比，它们的向量则相差很大，因为这两个概念在语义上是不同的。

词嵌入的优点是，它提供了一种将文本数据转化为计算机可以理解和处理的形式，同时保留了词语之间的语义关系。这在许多自然语言处理任务中都是非常有用的，比如文本分类、机器翻译和情感分析等。

DeepSeek与chatbox 本地部署

pangguoming — Fri, 07 Feb 2025 06:22:40 GMT

1.下载Ollama并安装运行DeepSeek

从Ollama官方网站下载Ollama：

https://ollama.com/ 进入Ollama官方网站后，可以看到Ollama已经支持DeepSeek-R1的部署：

2、安装（以Windows平台为例）：在Windows系统下，获取对应的exe应用程序后，双击启动安装程序。安装过程中，全程选择默认设置，点击“Install”后一路确认到底。安装完成后，程序会自动启动，此时在电脑右下角的托盘区域，你将看到Ollama的应用图标。

验证安装：安装完成后，打开命令行窗口，输入以下命令：

ollama -v

3、加载模型

选择模型：Ollama软件安装完成后，便要获取DeepSeek R1模型。再次打开Ollama官网，点击“Models”，在众多模型中，“deepseek - r1”位列榜首，十分醒目。若命令执行后，显示类似“ollama version is 0.5.7”这样的版本信息，即表明Ollama已成功安装。若此前已安装过Ollama，此步骤可将其更新至最新版本，当前最新版本为0.5.7 。模型详情与下载：点击“deepseek - r1”进入详情页面，可知该模型是DeepSeek的第一代推理模型，性能与OpenAI - o1相当。复制并在命令行中运行以下命令：

ollama run deepseek - r1

Ollama随即开始载入模型。首次运行此命令时，模型会通过网络下载，若后续再次运行，将直接从本地载入。默认下载的是7B Q4的量化版模型，其大小约为4.7G。

4、安装ChatBox实现可视化交互

为了更便捷地与模型交互，摆脱命令窗口的限制，你可以安装ChatBox这一可视化界面工具。安装完成后，即可开启与DeepSeek R1的轻松对话之旅。（1）打开 https://chatboxai.app/zh 下载ChatBox （2）打开软件设置本地模型好了，我们就可以自己研究本地的大模型了

查看自己的cuda版本号

pangguoming — Sat, 10 Aug 2024 13:40:32 GMT

使用nvidia-smi nvidia-smi是NVIDIA提供的一个用于管理和监控GPU的命令行工具。它可以显示驱动程序版本和CUDA版本。

nvidia-smi

输出示例：

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 555.58.02    Driver Version: 555.58.02    CUDA Version: 12.5     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  Tesla K80           On   | 00000000:00:1E.0 Off |                    0 |
| N/A   39C    P8    29W / 149W |      0MiB / 11441MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+

自然语言处理（NLP）的开发框架

pangguoming — Wed, 24 Apr 2024 09:32:53 GMT

自然语言处理（NLP）领域有许多开源的框架和库，用于处理文本数据和构建NLP应用程序。以下是一些常见的NLP开源框架及其特点，希望对大家有所帮助。北京木奇移动技术有限公司，专业的软件外包开发公司，欢迎交流合作。

1.NLTK（Natural Language Toolkit）：

NLTK是Python的NLP库，提供了各种文本处理工具和数据集。它适用于教育和研究，并具有丰富的文档和社区支持。

2.spaCy：

spaCy是Python中高性能的NLP库，具有出色的实体识别、句法分析和词向量支持。它专注于速度和效率，并适用于生产环境。

3.Stanford NLP：

斯坦福大学的NLP工具包提供了一套强大的工具，包括分词、句法分析、命名实体识别等。它有多种语言支持，但需要Java运行环境。

4.Gensim：

Gensim是一个Python库，主要用于文本主题建模和词向量学习。它特别适用于处理大规模文本数据。

5.CoreNLP：

斯坦福大学的CoreNLP是Java库，提供了一套NLP工具，包括词性标注、句法分析、命名实体识别等。它具有高质量的分析功能。

6.OpenNLP：

Apache OpenNLP是一个开源的Java库，用于自然语言处理任务，如分词、句法分析、命名实体识别等。

7.TextBlob：

TextBlob是Python库，使文本分析变得简单。它提供了易于使用的API，用于情感分析、标记化、短语提取等任务。

8.AllenNLP：

AllenNLP是由Allen Institute for AI开发的深度学习NLP库。它提供了高度可配置的NLP模型和实验工具。

9.FastText：

FastText是Facebook开发的库，用于文本分类和词向量学习。它具有高速训练和分类的特点。

10.Spacy-Cli：

Spacy-Cli是spaCy的命令行接口，用于快速执行NLP任务，如实体识别、关键词提取和句法分析。

这些框架各有不同的优势和适用场景。选择框架应根据项目需求、编程语言偏好、性能要求和功能需求来决定。此外，AI领域不断发展，新的NLP框架和工具也可能不断涌现。因此，及时关注最新的NLP技术和库也是很重要的。

智能语音交互的三驾马车：ASR、NLP、TTS

pangguoming — Wed, 24 Apr 2024 07:48:49 GMT

语音交互是AI最重要的领域之一，也是目前落地产品比较成熟的领域，比如说智能客服、智能音箱、聊天机器人等，都已经有成熟的产品了。语音交互主要由哪些部分组成？各自主要处理什么任务？目前都遇到什么困难？本文将跟大家一起探讨下。

1 语音交互的组成

我们以一个智能音箱的例子来开始今天的讨论：

假设我们对智能音箱天猫精灵说“放一首周杰伦的《晴天》”。天猫精灵就会说“好的，马上为你播放周杰伦的《晴天》”，并且开始播放音乐。

这个过程猫精灵都做了些什么？

首先，天猫精灵把听到的声音转化成文字，然后理解内容，最后做出相应策略，并把响应策略转化成语音。

因此，语音交互就可以成以下这三个模块：语音识别（Automatic Speech Recognition）：简称ASR，是将声音转化成文字的过程，相当于耳朵。自然语言处理（Natural Language Processing）：简称NLP，是理解和处理文本的过程，相当于大脑。语音合成（Text-To-Speech）：简称TTS，是把文本转化成语音的过程，相当于嘴巴。下面我们就来详细的介绍每一个模块。

2 语音识别（ASR）

通常语音识别有两种方法：

“传统”的识别方法，一般采用隐马尔可夫模型（HMM）基于深度神经网络的“端到端”方法。两种方法都需要经过“输入—编码—解码—输出”的流程。

2.1 编码

编码就是把声音转化成机器能识别的样式，即用数字向量表示。输入的声音信号是计算机没办法直接识别的，首先需要将声音信号切割成一小段一小段，然后每一小段都按一定的规则用向量来表示。

2.2 解码

解码就是把数字向量拼接文字的形式。首先，将编译好的向量，放到声学模型中，就可以得到每一小段对应的字母是什么；

然后，把翻译出来的字母再经过语言模型，就可以组装成单词了。

当然声学模型和语言模型也是个神经网络，是通过大量的语音和语言数据来训练出来了，在这里就不展开讲了。

这里来个脑暴：

神经网络能不能做到，不需要编码和解码的过程，不需要声学和语言模型，直接把声音信号丢到神经网络里去训练，最后输出结果就是文字，具体中间过程是怎样的，让机器自己去学。如果这样能实现，我觉得很酷，看起来是不是真的很智能。

3 自然语言处理（NLP）

NLP是语音交互中最核心，也是最难的模块。

NLP主要涉及的技术有：文本预处理、词法分析、句法分析、语义理解、分词、文本分类、文本相似度处理、情感倾向分析、文本生成等等。但不局限于这些，涉及的技术比较多，且比较复杂。下面我们就挑几个主要的技术点简单聊下。

3.1 文本预处理

1）去噪声：

只要跟输出没有关系的我们就叫噪声，比如：空格、换行、斜杆等。

去噪声后，文本变得更加规范化，不会出现各种乱七八糟的符号，对于后续的处理非常重要。

2）词汇归一化

这个在处理英文文本时比较常用，如“play”，“player”，“played”,“plays” 和 ”playing”是“play”的多种表示形式。虽然他们的含义不一样，但是上下文中是相似的，可以把这些各种形式的单词归一化。

归一化是具有文本特征工程的关键步骤，因为它将高纬特征（N个不同特征）转化成低维空间。

3.2 词法分析

1）分词

分词就是把一个句子，切分成多个词汇。

比如：输入“明天深圳的天气怎样？”，这个句子就会被分成“明天/深圳/的/天气/怎样”。其中“明天”、“深圳”、“天气”就是这句话的关键词，通过关键词去匹配内容。

2）实体识别

实体提取：是指在一个文本中，提取出具体特定类别的实体，例如人名、地名、数值、专有名词等。

比如：输入“詹姆斯在NBA打了多少年”，其中“詹姆斯”就是实体词，计算机可能就可以通过当前的时间和詹姆斯加入NBA的时间给出他在NBA的球龄。

实体识别在信息检索、自动问答、知识图谱等领域运用的比较多，目的就是告诉计算机这个词是属于某类实体，有助于识别出用户意图。

3.3 文本分类

主要目的是为了将文档（文章）的主题进行分类，比如说是属于经济类、体育类、文学类等等。

解决文案分类问题，比较经典的算法是TF-IDF算法。

TF-IDF的主要思想是：如果某个词或短语在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。

别说“NBA”这个在一篇文章中出现的次数比较多，但又很少在其他文章中出现，那这篇出现多次“NBA”这个词的文章很可能就是体育类文章。

3.4 文本相似度处理

文本相似度通常也叫文本距离，指的是两个文本之间的距离。文本距离越小，相似度越高；距离越大，相似度越低。

比如：用户输入“这件衣服多少钱”或者说“这件衣服怎么卖”，这都是很口语化的句子，那要怎么给用户返回“衣服价格”呢？就是根据文本相似度处理的。

需要我们计算出“多少钱”、“怎么卖”跟“价格”的相似度，然后根据相似度去匹配最佳答案。

应用场景：推荐、排序、智能客服以及自动阅卷等。解决之前只能靠关键词精准匹配问题，识别语义，扩大了应用的范围。

3.5 情感倾向分析

情感倾向分析，主要分为两大类：情感倾向分类、观点抽取。

1）情感倾向分类

情感倾向分类是识别文本的情感倾向，如：消极、积极、中性。

比如：“这家餐馆不错，服务态度好、价格便宜”，整个句子是积极的评价。

情感倾向分类对给用户打标签，给用户推荐内容或服务，有比较好的效果。

2）观点抽取

观点抽取是把句子中的观点抽取出来。

还是“这家餐馆不错、服务态度好，价格便宜”这个句子，其中“服务态度好”、“价格便宜”就是观点词。

观点抽取对建立服务或内容的评价体系，有重要的意义。

3.6 目前遇到的困难

1）语言不规范

虽然目前我们可以总结出一些通用的规则，但是自然语言真的太灵活了。同一个词在不同的场景可能表达多个意思，不管是通过理解自然语言的规则，还是通过机器学习，都显得比较困难。

2）错别字

在处理文本时，会发现有大量的错别字，怎么样让机器知道这些错别字，并且改过来呢，也是NLP的一大难点。

3）新词

在互联网高速发展的时代，网上每天都会产生大量的新词，我们如何快速地发现这些新词，并让机器理解，也是非常重要的。

4 语音合成（TTS）

实现TTS，目前比较成熟的有两种方法：“拼接法”和“参数法”。

4.1 拼接法

首先，要准备好大量的语音，这些音都是又基本的单位拼接成的（基本单位如音节、音素等），然后从已准备好的声音中，抽取出来合成目标声音。

优点：语音合成的质量比较高。缺点：数据量要求很大，数据库里必须有足够全的“音”。

4.2 参数法

根据统计模型来产生每时每刻的语音参数（包括基频、共振峰频率等），然后把这些参数转化为波形。

优点：对数据的要求要小点。缺点：质量比拼接法差一些。

4.3 其他方法

谷歌DeepMind提出的WaveNet方法，基于深度学习的语音合成模型，不会对语音信号进行参数化，使用神经网络直接在时域预测合成语音波形的每一个采样点。 Deep Voice 3采用一种新颖的用于语义合成的全卷积架构，可以用于非常大规模的录音数据集。 VoiceLoop是Facebook提出的一种新的TTS神经网络，它能将文本转换为在室外采样的声音中的语音，且该网络架构比现有的网络架构简单。

张量的操作和运算

pangguoming — Wed, 17 Apr 2024 08:38:34 GMT

张量计算是一种在数学和计算机科学中广泛应用的概念。张量可以被理解为多维数组或矩阵的推广，它在许多领域，如线性代数、物理学、计算机视觉、机器学习和深度学习中都有重要的应用。在张量计算中，常常会涉及到一些基本的操作，例如张量的加法、减法、乘法和除法，以及与标量的乘法和除法。这些操作可以用来进行张量的组合、变换和运算。在线性代数中，张量可以表示为多维向量空间中的对象，其在坐标系中的表示方式是一个多维数组。根据张量的阶（即张量的维数），可以分为标量（零阶张量）、向量（一阶张量）、矩阵（二阶张量）和高阶张量等。在机器学习和深度学习中，张量的概念非常重要。神经网络模型中的输入数据和模型参数通常都以张量的形式表示。通过张量计算，可以对输入数据进行处理、特征提取和预测，同时也可以对模型参数进行优化和更新。在实际的编程实现中，有许多张量计算的库和框架可供使用，如NumPy、TensorFlow 和 PyTorch 等。这些工具提供了一系列的张量操作和函数，使得张量计算更加高效和方便。以下是一些常见的张量操作和运算：

一）张量操作

1、张量创建：通过指定元素的值或使用随机数生成器创建张量。 2、张量索引和切片：访问和提取张量中的特定元素、子集或切片。 3、张量重塑：改变张量的形状，可以增加、删除或调整维度。 4、张量转置：重新排列张量的轴顺序。 5、张量连接和分割：将多个张量合并为一个大张量，或将一个张量分割为多个小张量。 6、张量复制：创建一个与现有张量具有相同值的新张量。

二）张量运算

1、逐元素运算：对两个形状相同的张量进行逐元素的加法、减法、乘法和除法等运算。 2、矩阵运算：进行矩阵乘法、矩阵转置、矩阵求逆等操作。 3、张量归约：对张量的元素进行求和、求平均值、求最大/最小值等操作。可以指定沿着哪个轴进行归约。 4、广播操作：在形状不匹配的张量之间执行运算，根据广播规则自动扩展张量的形状。 5、点积和张量乘法：执行点积运算或张量乘法操作，根据维度规则进行计算。 6、梯度计算：在深度学习中，通过自动微分机制计算张量的梯度，用于反向传播算法和模型参数更新。

这些操作和运算在不同的张量计算库中都有相应的实现和函数。常见的张量计算库包括NumPy、TensorFlow、PyTorch 等，它们提供了丰富的函数和方法来执行张量计算任务。
需要注意的是，在进行张量计算时，要注意张量的形状和维度，确保操作和运算符合规则，并且，选择适当的库和函数来执行特定的张量操作和运算，以提高计算效率和准确性。
下面示例展示了一些常见的张量计算操作，包括张量的创建、加法、乘法、转置、归约、重塑、矩阵乘法以及索引和切片等，可以通过运行这段代码来查看输出结果，并根据需要进行修改和扩展。

import numpy as np
 
# 创建张量
# 二维张量（矩阵）
matrix = np.array([[1, 2, 3], [4, 5, 6]])
 
# 三维张量
tensor = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
 
# 张量加法
tensor_sum = tensor + tensor
 
# 张量乘法
tensor_product = tensor * tensor
 
# 张量转置
tensor_transpose = np.transpose(tensor)
 
# 张量归约（求和）
tensor_sum_axis0 = np.sum(tensor, axis=0)  # 在第一个轴上求和
tensor_sum_axis1 = np.sum(tensor, axis=1)  # 在第二个轴上求和
tensor_sum_axis2 = np.sum(tensor, axis=2)  # 在第三个轴上求和
 
# 张量重塑
reshaped_tensor = np.reshape(tensor, (2, 6))  # 将三维张量重塑为二维张量
 
# 矩阵乘法
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
matrix_product = np.dot(matrix1, matrix2)
 
# 张量索引和切片
tensor_slice = tensor[0, 1]  # 获取第一个轴为0，第二个轴为1的元素
tensor_subset = tensor[:, :, 1:3]  # 获取第三个轴上索引为1和2的切片
 
# 输出结果
print("Matrix:\n", matrix)
print("Tensor:\n", tensor)
print("Tensor Sum:\n", tensor_sum)
print("Tensor Product:\n", tensor_product)
print("Tensor Transpose:\n", tensor_transpose)
print("Tensor Sum Axis 0:\n", tensor_sum_axis0)
print("Tensor Sum Axis 1:\n", tensor_sum_axis1)
print("Tensor Sum Axis 2:\n", tensor_sum_axis2)
print("Reshaped Tensor:\n", reshaped_tensor)
print("Matrix Product:\n", matrix_product)
print("Tensor Slice:\n", tensor_slice)
print("Tensor Subset:\n", tensor_subset)

当上述代码被执行时，输出结果应该如下所示：

Matrix:
 [[1 2 3]
 [4 5 6]]
 
Tensor:
 [[[ 1  2  3]
  [ 4  5  6]]
 [[ 7  8  9]
  [10 11 12]]]
 
Tensor Sum:
 [[[ 2  4  6]
  [ 8 10 12]]
 [[14 16 18]
  [20 22 24]]]
 
Tensor Product:
 [[[ 1  4  9]
  [16 25 36]]
 [[49 64 81]
  [100 121 144]]]
 
Tensor Transpose:
 [[[ 1  4]
  [ 7 10]]
 [[ 2  5]
  [ 8 11]]
 [[ 3  6]
  [ 9 12]]]
 
Tensor Sum Axis 0:
 [[ 8 10 12]
  [14 16 18]]
 
Tensor Sum Axis 1:
 [[ 5  7  9]
  [17 19 21]]
 
Tensor Sum Axis 2:
 [[ 6 15]
  [24 33]]
 
Reshaped Tensor:
 [[ 1  2  3  4  5  6]
  [ 7  8  9 10 11 12]]
 
Matrix Product:
 [[19 22]
  [43 50]]
 
Tensor Slice:
 [4 5 6]

pytorch入门实例，MNIST数据集手写数字识别完整源码

pangguoming — Sun, 07 Apr 2024 09:19:41 GMT

import torch
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision.datasets import MNIST
import matplotlib.pyplot as plt


class Net(torch.nn.Module):

    def __init__(self):
        super().__init__()
        self.fc1 = torch.nn.Linear(28*28, 64)
        self.fc2 = torch.nn.Linear(64, 64)
        self.fc3 = torch.nn.Linear(64, 64)
        self.fc4 = torch.nn.Linear(64, 10)
    
    def forward(self, x):
        x = torch.nn.functional.relu(self.fc1(x))
        x = torch.nn.functional.relu(self.fc2(x))
        x = torch.nn.functional.relu(self.fc3(x))
        x = torch.nn.functional.log_softmax(self.fc4(x), dim=1)
        return x


def get_data_loader(is_train):
    to_tensor = transforms.Compose([transforms.ToTensor()])
    data_set = MNIST("", is_train, transform=to_tensor, download=True)
    return DataLoader(data_set, batch_size=15, shuffle=True)


def evaluate(test_data, net):
    n_correct = 0
    n_total = 0
    with torch.no_grad():
        for (x, y) in test_data:
            outputs = net.forward(x.view(-1, 28*28))
            for i, output in enumerate(outputs):
                if torch.argmax(output) == y[i]:
                    n_correct += 1
                n_total += 1
    return n_correct / n_total


def main():

    train_data = get_data_loader(is_train=True)
    test_data = get_data_loader(is_train=False)
    net = Net()
    
    print("initial accuracy:", evaluate(test_data, net))
    optimizer = torch.optim.Adam(net.parameters(), lr=0.001)
    for epoch in range(2):
        for (x, y) in train_data:
            net.zero_grad()
            output = net.forward(x.view(-1, 28*28))
            loss = torch.nn.functional.nll_loss(output, y)
            loss.backward()
            optimizer.step()
        print("epoch", epoch, "accuracy:", evaluate(test_data, net))

    for (n, (x, _)) in enumerate(test_data):
        if n > 3:
            break
        predict = torch.argmax(net.forward(x[0].view(-1, 28*28)))
        plt.figure(n)
        plt.imshow(x[0].view(28, 28))
        plt.title("prediction: " + str(int(predict)))
    plt.show()


if __name__ == "__main__":
    main()

机器学习中的过拟合现象及其解决方法

pangguoming — Sun, 07 Apr 2024 02:10:36 GMT

1. What❓

过拟合（Overfitting）是指在机器学习中，模型在训练集上表现较好，但在测试集或实际应用中表现较差的现象。过拟合发生时，模型过于复杂地学习了训练集中的噪声、异常值或特定模式，从而导致对新样本的泛化能力下降。

过拟合通常是由于模型在训练过程中过于强调训练集上的表现，将训练集中的噪声或特定模式也当作了普遍规律而过度拟合。过拟合可能导致模型过于复杂，过于依赖训练集中的特定样本，从而在面对新样本时无法进行准确的预测，从而降低了模型的泛化性能。

过拟合的表现通常包括训练集上的误差较低，但测试集上的误差较高，模型在训练集上的表现比在测试集上要好，模型对噪声或异常值敏感，对新样本的预测不准确等。

上图中，模型的训练误差以蓝色显示，验证误差以红色显示。随着模型的训练周期增大，验证误差增加（正斜率）而训练误差稳步下降（负斜率），则模型可能发生了过度拟合的情况。最好的预测和拟合模型将是验证误差具有其全局最小值的地方，也就是图中的虚线位置。

2. Solutions❗️

为了解决或者是缓解过拟合问题，以下是一些常用的方法：

2.1 数据增强

数据增强（Data Augmentation）是一种在机器学习和深度学习中用于增加训练数据量的技术。它通过对原始训练数据进行一系列变换操作，生成新的训练样本，从而扩增了训练数据的规模和多样性。数据增强可以帮助模型更好地学习到数据中的模式和特征，从而提高模型的泛化性能，减少过拟合的风险。数据增强技术可以应用于各种类型的数据，包括图像、文本、语音等。常用的图像数据增强操作包括随机翻转、随机旋转、随机缩放、随机裁剪、色彩变换等，如下图所示。对于文本数据，数据增强可以包括随机删除、随机替换、随机插入等操作。对于语音数据，数据增强可以包括加入噪声、变换语速、变换音调等操作。通过数据增强，可以生成具有多样性的训练样本，从而提高模型的鲁棒性，使其对于新的、未见过的数据更具泛化性能。数据增强也可以减少模型在训练过程中对于少量标注数据的依赖，从而在数据量较小的情况下仍能训练出效果较好的模型。

2.2 正则化

正则化（Regularization）：在损失函数中引入正则化项，如 L1 正则化（Lasso）、L2 正则化（Ridge）等，用于限制模型参数的大小，减小模型的复杂度，从而减少过拟合。 L1 正则化可以将一些模型参数稀疏化，即将一些参数设为零，从而实现特征选择的效果；而 L2 正则化会使得模型参数向零的方向收缩，从而减小参数的幅度，降低模型的复杂性。

L1 正则化（Lasso 正则化）：Original 是原始的损失函数（例如均方误差、交叉熵等），λ 是正则化参数（用于控制正则化项的权重），w 是模型的参数向量，||w||₁ 是参数向量 w 的 L1 范数（绝对值之和）。 L2 正则化（Ridge 正则化）：其中，损失函数、λ 和 w 的定义与 L1 正则化相同，但是这里的正则化项是参数向量 w 的 L2 范数的平方（参数的平方和）。需要注意的是，正则化参数 λ 的选择对于正则化技术的效果非常关键，λ 越大，正则化项对模型的惩罚越强，模型的复杂性越低；而 λ 越小，正则化项对模型的惩罚越弱，模型的复杂性越高。因此，在实际应用中，需要根据具体问题和数据集的情况，合理选择正则化参数的取值。

2.3 早停策略

早停策略（Early Stopping）：在训练过程中，根据验证集的性能表现，在验证集上性能不再提升时提前停止训练，从而防止模型在训练集上过拟合。

如上图所示，我们通常在验证集的误差曲线或者准确率曲线的拐点处停止训练，从而防止模型的过拟合。

2.4 随机丢弃

随机丢弃（Dropout）：在训练过程中，随机丢弃一些神经元的输出来减少神经元之间的依赖性，也就是输出置为零，如下图所示，这样可以强制网络在训练时学习多个独立的子网络，从而增加模型的泛化能力。 Dropout 的设置大小通常是一个超参数，需要在训练过程中进行调优。一般情况下，随机丢弃的大小在 0.1 到 0.5 之间比较常见，但最佳的设置大小取决于具体的问题和模型架构。在实践中，可以通过尝试不同的丢弃率进行模型训练，然后使用验证集上的性能指标来选择最佳的丢弃率。通常情况下，较大的丢弃率可以提供更强的正则化效果，但可能会降低模型的训练速度和预测性能，而较小的丢弃率则可能不足以减少过拟合。因此，建议从较小的丢弃率开始，例如 0.1 或 0.2，然后逐渐增加丢弃率，直到在验证集上达到最佳性能为止。

2.5 增加训练数据量

通过增加训练数据量，从而减少模型在训练集上的过拟合风险，提高模型的泛化能力。

给模型来一点大数据（Big Data）的调教。

2.6 其他

模型复杂度控制：通过减少模型的层数、节点数或卷积核的个数等方式降低模型的复杂度，从而减小过拟合的风险。批标准化（Batch Normalization）：在网络的每一层输入进行归一化，从而加速网络的收敛速度，降低模型在训练数据上的过拟合风险。模型集成（Model Ensemble）：通过组合多个不同的模型，如集成学习、模型融合等方式，从而提高模型的泛化能力。超参数调优（Hyperparameter Tuning）：调整模型的超参数，如学习率、批大小、正则化强度等，通过搜索最佳的超参数组合，从而改善模型的性能。异常检测（Anomaly Detection）：通过识别和过滤掉异常或噪声样本，从而减少对异常样本的拟合，提高模型的泛化能力。迁移学习（Transfer Learning）：将在一个领域或任务上训练好的模型迁移到另一个领域或任务上，并进行微调，从而利用已有的知识来提高模型的泛化能力。以上方法可以单独或者组合使用，具体的选择和调参需要根据具体的问题和数据集来定，以获得最佳的效果。

深度学习概念词汇解释

pangguoming — Sun, 07 Apr 2024 01:51:10 GMT

预测函数
线性回归

（Linear regression）统计学概念，是一种利用线性函数对自变量（特征）和因变量之间的关系进行建模的方法。线性回归是机器学习中一种广泛使用的基本回归算法。含有有多个特征的线性回归称为多元线性回归。

最小二乘法

（Least Squares Method）是一种数学优化技术，主要用于估计模型参数，它通过最小化误差的平方和来寻找数据的最佳函数匹配。这种方法在统计学、系统辨识、数据拟合等多个领域有着广泛的应用。

代价函数

预测函数经过最小二乘法就得到代价函数，求代价函数0值就是要解决的问题

损失函数

代价函数就是损失函数

梯度下降

梯度下降是求代价函数0值的解决方案，可得到一组概率分布数据

过拟合

过拟合（Overfitting）是指在机器学习中，模型在训练集上表现较好，但在测试集或实际应用中表现较差的现象。过拟合发生时，模型过于复杂地学习了训练集中的噪声、异常值或特定模式，从而导致对新样本的泛化能力下降。参考机器学习中的过拟合现象及其解决方法

Pytorch 载入模型 torch.load(file) 指定 device 为CPU 或者为GPU

pangguoming — Tue, 02 Apr 2024 01:20:26 GMT

torch.load(file) 默认是使用cuda GPU，要改为使用CPU需要添加参数map_location=torch.device(‘cpu’) 如下：

torch.load(file, map_location=torch.device('cpu'))

这样就是用CPU了

了解pytorch中的*.pth文件格式

pangguoming — Mon, 01 Apr 2024 06:51:54 GMT

一文了解pytorch中的*.pth文件格式

一、 .pth的作用
二、 .pth的两种主要保存方式
三、保存整个模型的状态会不会导致模型过拟合
四、保存整个模型的状态会不会导致模型欠拟合
拓：欠拟合和过拟合有什么区别

一、 .pth的作用

在深度学习中，.pth 文件通常用于保存 PyTorch 框架下的模型参数或整个模型的状态。

模型参数：模型在训练过程中学习到的权重和偏置等数值。这些参数是模型进行预测或推理的基础，它们捕捉了从输入数据到输出结果的映射关系。

整个模型：除了参数之外，整个模型的状态还会保存模型的结构信息，即模型的层、激活函数、损失函数等组件的定义和配置。这使得在加载模型时，不需要重新编写或定义模型的结构，可以直接从.pth文件中恢复模型的结构。

二、 .pth的两种主要保存方式

保存整个模型：使用torch.save(model, “my_model.pth”) 可以将整个模型的状态保存到 .pth 文件中。这种保存方式包括模型参数和整个模型的结构信息，因此在加载模型时不需要重新构建模型结构，直接使用在这里插入代码片model=torch.load(mymodel.pth)即可加载模型，并且可以通过 model.eval() 将模型设置为评估模式。仅保存模型参数：使用 torch.save(model.state_dict(), “my_model.pth”) 可以只保存模型的参数到一个字典中，并将这个字典保存到 .pth 文件中。在加载模型时，需要先重新构建模型的结构，然后使用 model.load_state_dict(torch.load(‘mymodel.pth’)) 来加载存储的模型参数，最后同样可以通过 model.eval() 将模型设置为评估模式。需要注意的是，保存整个模型的方式虽然方便，但序列化后的数据是属于特定的类和指定的字典结构，当在其他项目或进行代码重构后可能会出现错误。因此，在某些情况下，只保存模型的参数可能更为稳妥。然后根据需要手动构建模型的结构。这种方式可以更加灵活地控制模型的加载和使用过程。

三、保存整个模型的状态会不会导致模型过拟合

过拟合: 过拟合是指模型在训练数据上表现良好，但在未见过的测试数据上表现较差的现象。** 这通常是由于模型过于复杂或训练数据不足等原因导致的。保存整个模型的状态本身并不会导致模型过拟合。保存整个模型的状态只是将模型在某一时刻的参数和结构信息保存下来，以便后续使用或迁移。这个过程并不会改变模型的训练过程或数据分布，因此不会直接影响模型的过拟合情况。然而，如果在保存模型状态之后，使用相同的训练数据和相同的训练过程重新加载模型进行进一步训练，而没有采取任何防止过拟合的措施（如提前停止训练、使用正则化、增加数据多样性等），那么模型仍然有可能出现过拟合的情况。这是因为过拟合主要取决于训练数据和模型的复杂性，而不是保存和加载模型状态的过程。因此，为了防止模型过拟合，你应该在训练过程中采取适当的措施，并在保存模型状态之前确保模型已经得到了充分的验证和评估。当重新加载模型进行推理或迁移学习时，也要注意在新的数据上评估模型的性能，并根据需要调整模型的参数或结构。

四、保存整个模型的状态会不会导致模型欠拟合

欠拟合 :欠拟合通常指的是模型在训练数据上的性能就很差，无法捕捉到数据的内在规律和模式。这通常是由于模型过于简单、训练数据不足或数据质量不高等原因造成的。

保存整个模型的状态并不会导致模型欠拟合。保存整个模型状态仅仅是将模型在某一时刻的参数和结构保存下来，它并不改变模型的复杂度、训练数据的数量或质量。因此，保存模型状态并不会对模型的欠拟合情况产生直接影响。如果在加载模型后遇到欠拟合问题，应该从模型复杂度、训练数据、训练过程和数据预处理等方面进行检查和调整。

如果在加载并重新使用保存的模型时遇到了欠拟合问题，那么问题可能出在以下几个方面：

模型复杂度：原始的模型可能过于简单，无法捕捉数据的复杂特征。在这种情况下，你需要考虑使用更复杂的模型或增加模型的容量。训练数据：训练数据可能不足以让模型学习到足够的特征。你可以尝试增加训练数据的数量或多样性，或者通过数据增强技术来扩充数据集。训练过程：训练过程可能存在问题，比如学习率设置不当、训练轮数不够等。你可以尝试调整训练过程中的超参数，如学习率、批次大小、优化算法等，以改善模型的训练效果。数据预处理：数据的预处理方式可能不合适，导致模型无法有效地从数据中提取有用的信息。你需要确保数据经过适当的预处理，如归一化、标准化或特征选择等。综上所述，保存整个模型的状态并不会导致模型欠拟合。如果你在加载模型后遇到欠拟合问题，应该从模型复杂度、训练数据、训练过程和数据预处理等方面进行检查和调整。

拓：欠拟合和过拟合有什么区别

欠拟合（Underfitting）和过拟合（Overfitting）是机器学习模型训练中经常出现的两种对立问题，它们的主要区别体现在以下几个方面：

模型性能表现

欠拟合：模型在训练数据上的性能就很差，即使在训练集上也很难达到较高的准确率。这通常意味着模型没有学习到数据的内在规律和特征，导致模型过于简单，无法捕捉复杂的数据模式。
过拟合：模型在训练数据上表现良好，但在测试数据或未见过的数据上性能较差。这通常是因为模型过于复杂，对训练数据中的噪声或细节过于敏感，导致泛化能力下降。

模型复杂度与数据匹配度

欠拟合：通常是由于模型复杂度不够或者模型没有足够的能力去拟合数据的真实分布。这可能是因为模型参数太少，或者模型结构选择不当。
过拟合：通常是由于模型复杂度过高，以至于模型过度拟合了训练数据中的噪声和细节，而非数据的真实结构。

解决方法

欠拟合：增加模型复杂度（如增加神经网络的层数或节点数），使用更复杂的模型，或者提供更多的特征给模型学习。同时，确保数据预处理和特征工程充分，以便模型能够学习到更多有用的信息。
过拟合：简化模型复杂度（如减少神经网络的层数或节点数），使用正则化技术（如L1、L2正则化），增加训练数据量，进行数据增强，或者使用早停法（Early Stopping）等技术来防止模型在训练过程中过度拟合噪声。

直观理解

欠拟合：可以想象成一个简单的直线试图拟合一组复杂的数据点，结果是无法很好地捕捉数据的整体趋势。
过拟合：则可以想象成一个非常复杂的曲线（甚至可能穿过每一个数据点），虽然完美拟合了训练数据，但对于新的数据点却很难做出准确的预测。

总的来说，欠拟合和过拟合是模型训练过程中需要避免的两个极端情况。理想的情况是找到一个平衡点，使得模型既不过于简单而欠拟合，也不过于复杂而过拟合，从而能够在训练数据和未见过的数据上都表现出良好的性能。

神经网络介绍与8个分类

pangguoming — Wed, 27 Mar 2024 02:01:57 GMT

神经网络是一种机器学习方法，其灵感来自人脑中神经元间信号传递的方式。神经网络特别适用于非线性关系建模，通常用于执行模式识别，以及对语音、视觉和控制系统中的目标或信号进行分类。神经网络，特别是深度神经网络，以其在复杂识别应用中的出色表现而闻名，例如人脸识别、文本翻译和语音识别等应用。此类方法是推动高级驾驶辅助系统及其任务（包括车道分类和交通标志识别）创新的关键技术。

1.卷积神经网络（CNN）：

卷积神经网络是用于图像和空间数据处理的神经网络，通过卷积层和池化层来捕捉图像的局部特征，广泛应用于图像分类、物体检测等领域。

2.循环神经网络（RNN）：

循环神经网络适用于处理序列数据，如时间序列和文本。通过引入时间维度，RNN可以考虑数据的上下文信息。LSTM和GRU等变体解决了传统RNN的梯度问题，广泛应用于语言模型、文本生成等任务。

3.生成对抗网络（GAN）：

生成对抗网络由生成器和判别器组成，用于生成逼真的数据样本。生成器尝试生成与真实数据相似的样本，判别器努力区分真实和生成样本。GAN在图像生成、风格转换等领域创造了许多引人注目的成果。

4.图神经网络（GNN）：

图神经网络专门用于处理图数据，可以学习节点和边的表示。它在社交网络分析、分子预测等任务中有应用，对节点分类、链接预测等任务有出色表现。

5.长短时记忆网络（LSTM）：

长短时记忆网络是一种循环神经网络的变体，专门用于解决长序列任务。通过门控机制，LSTM能够更好地捕获序列中的长期依赖关系，适用于语音识别、自然语言生成等任务。

6.人工神经网络（ANN）：

人工神经网络是神经网络的基本形式，由神经元、权重和激活函数组成。多层感知器（MLP）是其常见形式，用于各种任务，如图像识别、数据分类等。

7.自编码器（Autoencoder）：

自编码器是一种用于学习数据表示的神经网络，通过编码和解码过程学习数据的压缩表示。它在数据降维、去噪、特征学习等方面有应用。

8.变换器（Transformer）：

变换器是一种基于自注意力机制的神经网络，用于处理序列数据，如自然语言文本。它在NLP领域引起了革命，广泛用于翻译、生成、情感分析等任务。每个神经网络都有其独特的设计和应用领域，通过了解它们，您可以更好地理解它们在不同领域中的价值和作用。

AI领域的几个概念：机器学习、深度学习和大模型

pangguoming — Wed, 27 Mar 2024 01:43:58 GMT

随着AI时代的到来，越来越多概念值得我们关注。这篇文章里，作者就介绍了人工智能、机器学习、深度学习和大模型的概念和关系，一起来看看，或许屏幕前的你会感兴趣。

上文简述了传统产品经理进化为AI产品经理的机遇和挑战，今天我们继续了解一下人工智能的概念和分类，并介绍AI领域非常重要的两个概念：机器学习和深度学习，最后还会聊一下最近爆火的大模型，看看这位明星选手处在AI这张大网的哪个位置。

一、什么是人工智能

人工智能（Artificial Intelligence，AI）是指用机器去实现所有目前必须借助人类智慧才能实现的任务。它本质上是基于学习能力和推理能力的不断进步，去模仿人类思考、认知、决策和行动的过程。

AI的核心目标是通过机器学习、深度学习等技术，让计算机能够从数据中学习，并自主地进行推理和决策。

从产品经理的视角来看，传统的功能实现，需要产品经理预设业务场景，规划功能逻辑细节，然后交给技术人员进行编码实现，最终功能和预想效果一致的话，就是很成功的一次迭代了。

似乎也没什么问题，但是当我们跳出来往下看，发现满屏都是形如“如果…那么…”的需求硬编码，虽然给了用户“所见即所得”的确定性，但是很多场景的表现都显得“木讷”，不够“聪明”，很多人类一眼就能得到答案的问题，想达到预期效果却难如登天。

而借助AI技术，我们可以将那些“木讷”的功能，交给一个个聪明的“人”来负责，它们不止可以完成本职工作，还能继续学习成长，独自进行逻辑推理，更好的做决策。

整个系统瞬间就活了起来，虽然有了更多的“不确定性”，但同时也冲破了天花板，拥有了无限可能。

根据AI的能力范围和智能化程度，可以将人工智能分为ANI、AGI和ASI三个等级。

ANI（弱人工智能）主要被编程以执行单一任务，它通常只能针对特定领域或任务展现出类似人类智能的能力。例如，手机地图导航、网购产品推荐等都是ANI的典型应用。
AGI（通用人工智能）则是在不特定编码知识与应用区域的情况下，应对多种甚至泛化问题的人工智能技术。它拥有推理、计划、解决问题、抽象思考、快速学习和从经验中学习的能力。AGI更像是无所不能的计算机，能够像人类一样应对多种任务和环境。
ASI（超人工智能）相较AGI，不仅要求具备人类某些能力，还要能够独立思考并解决问题。ASI不仅在智能化程度上超越了AGI，还在应用范围上有所扩展，能够应对更加复杂和多样化的任务。人工智能包括自然语言处理（NLP）、计算机视觉（CV）、机器学习、深度学习、数据挖掘、机器人技术等分支。这些分支在处理不同类型的数据和任务时各有优势。

例如，自然语言处理（NLP）主要关注于自然语言的理解和生成，计算机视觉（CV）则关注于图像和视频的识别和理解，机器学习和深度学习则通过训练数据来让计算机自主地进行决策和预测，数据挖掘则从大量数据中挖掘出有用的信息，机器人技术则利用AI技术来构建能够执行各种任务的自动化系统。

我们主要关注机器学习和深度学习。

二、什么是机器学习

机器学习（Machine learning）是一种人工智能的技术，通过让机器通过对过去已知大量数据的学习，逐渐有能力从数据中发现接近现实的规律，并通过这些规律对未来的某些状况进行预测，从而实现自主学习和预测的能力。

建模过程中，根据数据是否有明确标签，可以把机器学习分为监督学习、无监督学习和半监督学习三种类型。

监督学习：从有标签的数据中学习规律和模式，以便在未知数据上进行预测和分类。
无监督学习：从无标签的数据中学习规律和模式，以便在未知数据上进行聚类和降维等操作。
半监督学习：将监督学习和无监督学习相结合，利用少量有标签的数据和大量无标签的数据进行学习。根据机器学习的应用场景，目前可以分为分类问题、回归问题、聚类问题三大类。
分类问题：机器学习可以通过对已知类别的数据进行学习，从而对未知类别的数据进行分类。比如在垃圾邮件识别中，机器学习算法可以通过学习已知的垃圾邮件和非垃圾邮件，来判断一封新收到的邮件是否是垃圾邮件。分类问题的常见算法有K近邻算法、朴素贝叶斯、决策树、随机森林、支持向量机（SVM算法）等，后续文章会详细介绍。
回归问题：机器学习可以通过对已知的数据进行学习，从而对新的数据进行预测。比如在股票市场中，机器学习算法可以通过学习历史股票价格数据，来预测未来的股票价格。回归问题的常见算法有线性回归、逻辑回归等，后续文章会详细介绍。
聚类问题：机器学习可以将数据按照一定的特征进行聚类，从而将相似的数据归为一类。比如在客户分析中，机器学习算法可以通过学习客户的购买行为和喜好，将相似的客户归为一类，从而对不同的客户群体进行针对性的营销。聚类算法属于无监督学习，后续会介绍一下K均值算法（K-means）。

机器学习的优点（和深度学习相比）：

易于理解和实现，成本较低，好落地。
适用于小规模数据。
可解释性强，相对可控。
适用于各种类型的数据。机器学习的算法适用于各种类型的数据，包括结构化数据和非结构化数据。

机器学习的缺点（和深度学习相比）：

需要手动提取特征。这需要专业知识和经验，并且很难得到最佳特征，因此这也是体现产品经理价值的重要环节。
对数据质量要求高。机器学习的算法对数据质量要求较高，如果数据质量较差，会影响预测结果的准确性。
预测效果受限。机器学习的算法预测效果受限，无法处理较为复杂的数据集。

三、什么是深度学习

深度学习（Deep learning）是一种机器学习的分支，它是通过构建多层神经网络来实现自主学习和预测的能力。深度学习的核心是深度神经网络，它由多个层次的神经元组成，每一层都可以提取出不同的特征信息，从而实现对复杂数据的学习和预测。深度学习的应用范围非常广泛，包括图像识别、语音识别、自然语言处理等领域。

深度学习常见算法有反向传播（Backpropagation）、卷积神经网络（CNN）、循环神经网络（RNN）、生成对抗网络（GAN）等，后续会详细介绍。

深度学习的优点（和传统机器学习相比）：

自动提取特征。深度学习可以自动学习特征，从而避免了手动提取特征的麻烦。
适用于大规模数据。深度学习的算法适用于大规模的数据集。
预测效果较好。深度学习的算法预测效果较好，可以处理较为复杂的数据集。

深度学习的缺点（和传统机器学习相比）：

计算资源要求高。深度学习的算法需要大量的计算资源，包括计算机性能和存储空间。
训练时间长。深度学习的算法需要较长的训练时间，这会增加成本和时间成本。
模型可解释性差。深度学习的算法模型可解释性较差，很难理解模型的内部运作机制。

四、什么是大模型

大模型是指深度学习中的大型神经网络模型，它们通常包含数亿甚至数十亿个参数，可以处理海量的数据，并且具有强大的特征表达和推理能力。大模型的出现使得AI在语音识别、自然语言处理、图像识别等领域取得了突破性的进展，受到了广泛的关注。

大模型也属于深度学习，大模型的特点主要表现在以下几个方面：

巨大的规模：大模型包含的参数数量巨大，模型大小可以达到数百GB甚至更大。这种巨大的模型规模为模型提供了强大的表达能力和学习能力。
预训练方式：大模型通常在大规模数据集上进行预训练，这使得模型能够学习到广泛的知识和模式。预训练完成后，仅需使用少量数据的微调甚至无需微调，模型就能直接支撑各类应用。
多任务学习：大模型可以同时处理多个任务，这使得模型能够学习到更广泛的知识和技能。例如，语言模型可以同时学习词义、语法、语义等多个方面的知识。
模型架构和技术：大模型可以采用不同的模型架构和技术来优化模型的精度和效率。例如，Transformer模型可以用于处理自然语言处理任务，而卷积神经网络可以用于处理图像识别任务。
参数优化：大模型需要进行参数优化，以提高模型的精度和效率。例如，可以使用梯度下降等优化算法来训练模型，同时也可以使用正则化等技术来防止过拟合。
数据集要求：大模型需要处理大量的数据才能学到广泛的知识和模式，因此需要使用大规模的数据集。同时，数据集的多样性也能够帮助模型学习到更广泛的知识。大模型具有强大的表示能力和泛化能力，有着广泛的应用前景，而且已经有了一些AGI（通用人工智能）的感觉，但同时也存在巨大的计算和存储成本、难以调试和优化、难以解释和可视化以及难以部署和维护等问题。因此，在实际应用中需要根据具体任务和需求来选择合适规模的模型。

目前主流深度学习框架介绍与对比包括TensorFlow、PyTorch、Keras、Caffe

pangguoming — Wed, 27 Mar 2024 01:19:00 GMT

当下，有许多主流的开源深度学习框架供开发者使用。主要包括TensorFlow、PyTorch、Keras、Caffe等。

一、TensorFlow深度学习框架

TensorFlow（谷歌出品）：　　TensorFlow 是最受欢迎和广泛使用的深度学习框架之一。　　TensorFlow是一个由Google Brain团队开发的开源深度学习框架。它允许开发者创建多种机器学习模型，包括卷积神经网络、循环神经网络和深度神经网络等。　　TensorFlow使用数据流图来表示计算图，其中节点表示数学操作，边表示数据流动。使用TensorFlow可以利用GPU和分布式计算来加速训练过程。　　该框架有着广泛的应用场景，包括图像识别、自然语言处理、语音识别、推荐系统等。同时，TensorFlow也有着丰富的社区支持和文档资源，使其容易学习和使用。

适合各种应用，包括计算机视觉、自然语言处理和推荐系统等。
提供了丰富的工具和库，用于构建和训练神经网络模型。
支持静态计算图和动态计算图。可以在图构建阶段进行优化
具有强大的分布式计算能力。
支持多种语言接口，包括Python、C++、Java等
提供了许多高级操作，如自动微分、数据并行性等
易于在各种硬件平台上部署和运行
有强大的社区支持和丰富的文档

二、PyTorch深度学习框架

PyTorch（Facebook开源）： PyTorch 是另一个非常受欢迎的深度学习框架。　　PyTorch是一个由Facebook开源的深度学习框架，是目前市场上最流行的深度学习框架之一。它基于Python语言，提供了强大的GPU加速功能和动态计算图的支持。　　PyTorch的应用范围非常广泛，包括图像和语音识别、自然语言处理、计算机视觉、推荐系统等领域。　　PyTorch具有易于使用、灵活性高和代码可读性好等特点，使得它成为深度学习研究和应用的首选框架之一。

易于在GPU上加速训练，具有出色的 GPU 加速性能。
提供了广泛的预训练模型和工具包，
张量库，用于使用 GPU 和 CPU 进行深度学习。
强调动态计算图的构建，可以更灵活地进行模型调整和调试，使得模型构建和调试更加直观。
它在灵活性和易用性方面表现出色，特别适合研究和原型开发。
具有丰富的工具和库，如Torch方便使用。
提供简洁灵活的API，减少代码编写量
有活跃的社区和详细的文档支持

三、Keras深度学习框架

Keras（谷歌）： Keras（谷歌）（最初由François Chollet开发，现在为TensorFlow官方API）：　　Keras 是一个易用且功能强大的，用 Python 编写的高级神经网络 API，它能够以 TensorFlow, CNTK, 或者 Theano 作为后端运行。　　Keras 的开发重点是支持快速的实验。能够以最小的时延把你的想法转换为实验结果，是做好研究的关键。

Keras支持多个后端引擎，可以在 Tensorflow、Theano、CNTK 等框架上运行。
提供简洁易用的高级API，尤其适合初学者和快速原型设计
具有广泛的模型库、预训练模型和各种工具包，使得模型构建更加高效。
可以无缝切换到TensorFlow，以享受其强大的功能和生态系统
允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。
同时支持卷积神经网络和循环神经网络，以及两者的组合。
在 CPU 和 GPU 上无缝运行。

四、Caffe深度学习框架

Caffe（伯克利）　　Caffe的全称是Convolutional Architecture for Fast Feature Embedding，意为“用于特征提取的卷积架构”，它是一个清晰、高效的深度学习框架，核心语言是C++。　　Caffe是一种流行的深度学习框架，是由加州大学伯克利分校的研究人员开发的，用于卷积神经网络（CNN）和其他深度学习模型的训练和部署。　　Caffe的主要优点是速度快、易于使用和高度可移植性。　　它已被广泛应用于计算机视觉、自然语言处理和语音识别等领域。　　Caffe还具有一个强大的社区，提供了许多预训练的模型和可视化工具，使用户可以轻松地构建自己的深度学习模型。

Caffe 是一个基于 C++ 的深度学习框架，旨在高效地进行卷积运算。
它特别适合计算机视觉任务，并在图像分类和物体检测方面表现出色。
Caffe 提供了简单的配置文件来定义网络结构和超参数。
具有高效的 GPU 加速，适合在大规模数据集上训练模型。

五、几种框架的对比

目前最受欢迎的深度学习框架包括TensorFlow、PyTorch和Caffe。据市场研究公司O’Reilly发布的《2019年AI和深度学习市场调查报告》显示，TensorFlow是最受欢迎的深度学习框架，有57.2%的受访者使用它。PyTorch紧随其后，有37.1%的受访者使用它。Caffe和Keras也很受欢迎，分别占据了16.2%和13.7%的市场份额。

主要特点的简单对比表

	TensorFlow	PyTorch	Keras
计算图	静态图	动态图	静态图
语言接口	Python、C++、Java等	Python	Python
API	丰富	简洁	简洁
硬件支持	广泛	动态图	有限
社区支持	强大	活跃	活跃

AI HelloWorld 你好 AI 世界

pangguoming — Mon, 18 Mar 2024 07:48:58 GMT

我将在此分享ai开发知识

AI-helloworld AI开发社区

十款主流LLM应用框架对比

框架简介

详细对比

如何选择？

总结

conda: command not found conda的初始化方法

Langchain + deepseek +neo4j 构建电影知识图谱智能问答

安装LangChain 依赖

安装Neo4j

安装Neo4j Apoc 插件

启动Neo4j

langchain + deepseek +neo4j 构建电影知识图谱智能问答

基于Langchain + DeepSeek 构建聊天机器人

基于Langchain + DeepSeek 构建聊天机器人

前言

1. 使用 PromptTemplate 提示模板

定义提示模版

完整使用代码及运行结果

2. DeepSeek 环境准备及模型创建

2.1 获取 API

2.2 创建 API Key

2.3 配置 API KEY

2.4 配置 base_url

2.5 配置 model

3. Langchain 构建聊天机器人

3.1 引入 MessagesPlaceholder 来处理多轮对话

3.2 构建 Chain 和保存对话历史

3.3 调用 RunnableWithMessageHistory 对象的 invoke() 方法

3.4 流式输出

3.5 示例代码及运行效果

ChatGPT模型常用参数设置(temperature, max_tokens, presence_penalty, frequency_penalty, top_p, n)

OpenAI ChatGPT参数配置指南

1. Temperature参数

1.1 作用

1.2 参数设置建议

2. Max_tokens参数

2.1 作用

2.2 参数设置建议

注意事项

3. Presence_penalty参数

3.1 作用

3.2 参数设置建议

4. Frequency_penalty参数

4.1 作用

4.2 参数设置建议

5. Top_p参数

5.1 作用

5.2 参数设置建议

与Temperature比较

6. N参数

6.1 作用

6.2 参数设置建议

注意事项

Langchain 的基本用法

1. 开发环境

2. 加载 LLM 模型

3. RunnableSequence

4. 基础消息类型 Message

5. 输入模板 PromptTemplate

6. 结构化输出 OutputParser

7. 链 chain

RAG基本概念

1. 什么是 RAG？

2. RAG 的核心组件

3. RAG 的工作流程

4. RAG 进阶优化

5. RAG 实践（动手实验）

向量数据库Faiss入门

Faiss的安装

Faiss的基本使用

图片搜索

文件搜索

结论

FastAPI 快速入门

一、什么是FastAPI？

（ 一）环境准备

（二）入门示例

（三）入门示例了解FastAPI结构

二、uvicorn启动方式

（一）环境准备

pytorch入门实例，MNIST数据集手写数字识别完整源码

深度学习概念词汇解释