AI嵌入模型入门：文本向量化的工作原理和应用

你是否好奇过，当你在搜索引擎中输入一段文字，为什么它能找到语义相关的内容而不仅仅是匹配关键词？为什么 AI 助手能够理解你的问题并从海量文档中找到最相关的答案？这背后的核心技术之一就是嵌入模型（Embedding Model）。嵌入模型将文本转化为数学向量，让计算机能够理解语言的语义含义。本文将从零开始，用通俗易懂的语言讲解嵌入模型的工作原理、主流产品和实际应用。

一、什么是嵌入模型

1.1 从文字到数字

计算机无法直接理解文字，它只能处理数字。嵌入模型的作用就是将文本（单词、句子、段落甚至整篇文档）转换为一组数字（向量），这组数字能够捕捉文本的语义信息。

举一个简单的例子：

• “我今天很开心” → [0.12, -0.34, 0.56, …, 0.78]（1536维向量）
• “我今天很高兴” → [0.11, -0.33, 0.55, …, 0.77]（1536维向量）
• “股票今天大跌” → [-0.89, 0.45, -0.23, …, 0.12]（1536维向量）

语义相似的文本在向量空间中的距离很近，语义不同的文本距离较远。这就是嵌入模型的核心能力。

1.2 向量的维度

嵌入向量的维度（即向量的长度）通常在 384 到 3072 之间。维度越高，理论上能表达的语义信息越丰富，但计算和存储成本也越高。

常见维度：

• 384 维：MiniLM、All-MiniLM-L6-v2 等轻量模型
• 768 维：BERT-base、E5-small 等中等模型
• 1024 维：BGE-large、E5-large 等大模型
• 1536 维：OpenAI text-embedding-3-small
• 3072 维：OpenAI text-embedding-3-large

1.3 嵌入模型 vs 语言模型

很多人会把嵌入模型和大语言模型（LLM）混淆，它们的区别是：

嵌入模型和语言模型是互补的：嵌入模型负责”理解和检索”，语言模型负责”生成和推理”。它们经常配合使用，例如在 RAG（检索增强生成）系统中。

二、嵌入模型的工作原理

2.1 词嵌入的起源

嵌入模型的发展可以追溯到 2013 年的 Word2Vec。Word2Vec 首次展示了将单词映射到向量空间的可能性，并发现了有趣的向量算术关系：

向量("国王") - 向量("男人") + 向量("女人") ≈ 向量("女王")

这说明向量空间确实捕捉了语言的语义关系。但 Word2Vec 的局限是每个词只有一个固定向量，无法处理多义词。

2.2 上下文嵌入

2018 年，BERT 的出现带来了革命性的变化。BERT 的嵌入是上下文化的——同一个词在不同语境中有不同的向量表示。例如：

• “银行的利率很高” → “银行”的向量偏向金融机构
• “河的左岸是一片树林” → “岸”的向量偏向地理概念

2.3 句子和文档嵌入

现代嵌入模型不仅处理单个词，而是处理整句甚至整段文本。其工作流程大致如下：

1. 分词（Tokenization）：将文本拆分为 token（子词单元）
2. Token 嵌入：每个 token 转化为一个初始向量
3. Transformer 编码：通过多层注意力机制，让每个 token 的向量融入上下文信息
4. 池化（Pooling）：将所有 token 向量聚合为一个固定长度的句子/文档向量
5. 归一化：将向量归一化到单位长度，便于计算余弦相似度

2.4 相似度计算

得到文本向量后，常用的相似度计算方法有：

余弦相似度（Cosine Similarity）：最常用，衡量两个向量的方向是否一致

similarity = cos(θ) = (A · B) / (|A| × |B|)

值范围 [-1, 1]，1 表示完全相似，0 表示无关，-1 表示完全相反。

欧氏距离（Euclidean Distance）：衡量两个向量的直线距离

distance = √(Σ(ai - bi)²)

距离越小越相似。

点积（Dot Product）：当向量已归一化时，点积等价于余弦相似度

dot_product = Σ(ai × bi)

三、主流嵌入模型对比

3.1 OpenAI 嵌入模型

text-embedding-3-small

• 维度：1536
• 最大 token：8191
• 价格：$0.02 / 百万 token
• 特点：性价比高，支持维度裁剪

text-embedding-3-large

• 维度：3072
• 最大 token：8191
• 价格：$0.13 / 百万 token
• 特点：性能最强，支持维度裁剪

3.2 开源嵌入模型

BGE（BAAI General Embedding） 由北京智源人工智能研究院开发，在多个基准测试中表现优异。

• bge-large-zh-v1.5：中文最强开源嵌入模型之一，1024维
• bge-m3：支持多语言、多粒度检索，1024维
• bge-small-zh-v1.5：轻量版，512维，适合资源有限的场景

E5（Embedding from Exploring Embeddings） 由微软开发，通用性强。

• e5-large-v2：1024维，英文表现优秀
• e5-mistral-7b-instruct：基于 Mistral 7B 的大规模嵌入模型

GTE（General Text Embeddings） 由阿里达摩院开发。

• gte-large-zh：中文嵌入质量很高
• gte-Qwen2：基于 Qwen2 架构

Jina Embeddings 由 Jina AI 开发，支持超长文本。

• jina-embeddings-v3：支持 8192 token，多语言
• jina-embeddings-v2-base-zh：中文专用版

3.3 性能基准对比

根据 MTEB（Massive Text Embedding Benchmark）排行榜的最新数据：

3.4 如何选择嵌入模型

选择嵌入模型时需要考虑以下因素：

• 语言支持：如果主要处理中文，选择对中文优化较好的模型（如 BGE、GTE）
• 文本长度：如果需要处理长文档，选择支持更大上下文的模型（如 Jina v3 支持 8192 token）
• 性能要求：检索场景需要高检索分数，分类场景需要高分类分数
• 资源限制：本地部署考虑模型大小和推理速度
• 成本：API 调用考虑价格，本地部署考虑硬件成本
• 维度：高维度存储成本高但可能更准确，支持裁剪的模型更灵活

四、嵌入模型的实际应用

4.1 语义搜索

传统的关键词搜索只能匹配字面上的关键词，而语义搜索能理解查询的意图，找到语义相关的内容。

示例：

• 查询：“如何提高工作效率”
• 关键词搜索可能找到：“效率工具推荐”（匹配”效率”）
• 语义搜索还能找到：“时间管理的七个方法”、“番茄工作法详解”、“减少工作中的干扰”

from sentence_transformers import SentenceTransformer
import numpy as np

# 加载嵌入模型
model = SentenceTransformer('BAAI/bge-large-zh-v1.5')

# 文档库
documents = [
    "时间管理的七个方法：1. 设定明确目标 2. 优先级排序...",
    "番茄工作法是一种时间管理方法，每25分钟专注工作...",
    "Python 编程入门教程，从零开始学编程...",
    "如何减少工作中的干扰：关闭通知、设置专注时间...",
    "React 前端开发指南，组件化开发最佳实践...",
]

# 生成文档嵌入
doc_embeddings = model.encode(documents, normalize_embeddings=True)

# 用户查询
query = "怎样在上班时更专注"
query_embedding = model.encode([query], normalize_embeddings=True)

# 计算相似度
similarities = np.dot(doc_embeddings, query_embedding.T).flatten()

# 排序并显示结果
results = sorted(zip(documents, similarities), key=lambda x: x[1], reverse=True)
for doc, score in results[:3]:
    print(f"[{score:.4f}] {doc[:50]}...")

4.2 RAG（检索增强生成）

RAG 是目前最流行的 AI 应用架构之一，它将嵌入模型的检索能力和大语言模型的生成能力结合起来：

用户提问 → 嵌入模型编码 → 向量检索相关文档 → 将文档作为上下文 → LLM 生成回答

RAG 的优势：

• LLM 基于最新的文档内容回答，减少幻觉
• 可以引用具体的来源
• 知识可以随时更新，无需重新训练模型

import chromadb
from sentence_transformers import SentenceTransformer
import requests

# 初始化
embedding_model = SentenceTransformer('BAAI/bge-large-zh-v1.5')
client = chromadb.PersistentClient(path="./my_rag_db")
collection = client.get_or_create_collection("knowledge_base")

def add_documents(docs):
    """添加文档到向量数据库"""
    embeddings = embedding_model.encode(docs, normalize_embeddings=True)
    ids = [f"doc_{i}" for i in range(len(docs))]
    collection.add(
        ids=ids,
        embeddings=embeddings.tolist(),
        documents=docs
    )

def rag_query(question):
    """RAG 查询"""
    # 1. 检索相关文档
    q_embedding = embedding_model.encode([question], normalize_embeddings=True)
    results = collection.query(
        query_embeddings=q_embedding.tolist(),
        n_results=3
    )
    
    # 2. 构建上下文
    context = "\n\n".join(results['documents'][0])
    
    # 3. 调用 LLM 生成回答
    prompt = f"""基于以下参考资料回答问题：

参考资料：
{context}

问题：{question}

请用中文简洁回答："""
    
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": "qwen2:7b",
            "prompt": prompt,
            "stream": False
        }
    )
    
    return response.json()["response"]

# 使用示例
add_documents([
    "Python 3.12 引入了类型参数语法，允许使用 type 关键字定义类型别名...",
    "FastAPI 是一个基于 Python 的现代 Web 框架，支持自动文档生成...",
    "Docker 容器技术可以将应用及其依赖打包在一起，确保环境一致性...",
])

answer = rag_query("Python 有什么新的语法特性？")
print(answer)

4.3 文本分类

嵌入模型可以将文本分类问题转化为向量空间的聚类或分类问题：

from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# 准备训练数据
texts = [
    "这个产品太好用了，强烈推荐！",
    "质量很差，完全不值这个价格",
    "包装很好，物流也快，好评",
    "用了一次就坏了，太差了",
    # ... 更多数据
]
labels = ["正面", "负面", "正面", "负面"]

# 生成嵌入
embeddings = model.encode(texts, normalize_embeddings=True)

# 训练分类器
X_train, X_test, y_train, y_test = train_test_split(
    embeddings, labels, test_size=0.2
)
classifier = SVC(kernel='linear')
classifier.fit(X_train, y_train)

# 评估
predictions = classifier.predict(X_test)
print(classification_report(y_test, predictions))

# 预测新文本
new_text = "这个手机拍照效果非常好"
new_embedding = model.encode([new_text], normalize_embeddings=True)
prediction = classifier.predict(new_embedding)
print(f"分类结果: {prediction[0]}")

4.4 文档聚类

将大量文档自动聚类为不同的主题组：

from sklearn.cluster import KMeans
import numpy as np

# 假设有一批新闻文章
articles = [
    "苹果公司发布了新款 iPhone，搭载最新 A18 芯片...",
    "特斯拉第三季度财报超预期，股价大涨...",
    "中国队在世界杯预选赛中获得关键胜利...",
    "NBA 季后赛：湖人对阵掘金...",
    "央行宣布降准 0.5 个百分点...",
    "新型流感病毒变异株引起关注...",
]

# 生成嵌入
embeddings = model.encode(articles, normalize_embeddings=True)

# KMeans 聚类
kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(embeddings)

# 显示聚类结果
for cluster_id in range(3):
    print(f"\n--- 类别 {cluster_id + 1} ---")
    for i, c in enumerate(clusters):
        if c == cluster_id:
            print(f"  {articles[i][:50]}...")

4.5 推荐系统

嵌入模型可以构建基于内容的推荐系统：

class ContentRecommender:
    def __init__(self, model):
        self.model = model
        self.items = []
        self.embeddings = None
    
    def add_items(self, items):
        """添加推荐项"""
        self.items.extend(items)
        self.embeddings = self.model.encode(
            self.items, normalize_embeddings=True
        )
    
    def recommend(self, query, top_k=5):
        """基于查询推荐"""
        q_embedding = self.model.encode([query], normalize_embeddings=True)
        similarities = np.dot(self.embeddings, q_embedding.T).flatten()
        
        top_indices = np.argsort(similarities)[-top_k:][::-1]
        return [(self.items[i], similarities[i]) for i in top_indices]
    
    def similar_items(self, item_index, top_k=5):
        """查找相似项"""
        item_embedding = self.embeddings[item_index]
        similarities = np.dot(self.embeddings, item_embedding)
        
        top_indices = np.argsort(similarities)[-top_k-1:][::-1]
        # 排除自身
        return [(self.items[i], similarities[i]) 
                for i in top_indices if i != item_index]

五、向量数据库

5.1 什么是向量数据库

当文档数量达到百万级别时，逐一计算相似度变得不可行。向量数据库使用特殊的索引结构（如 HNSW、IVF）来实现高效的近似最近邻搜索（ANN），在毫秒级别完成百万级文档的检索。

5.2 主流向量数据库

ChromaDB

• 轻量级，嵌入式数据库
• 适合原型开发和中小规模应用
• Python 原生支持
• 内存+持久化存储

import chromadb
client = chromadb.Client()
collection = client.create_collection("my_docs")

Milvus

• 开源分布式向量数据库
• 支持百亿级向量
• 丰富的索引类型
• 适合大规模生产环境

Pinecone

• 全托管云服务
• 无需运维
• 按需付费
• 适合不想管理基础设施的团队

Qdrant

• Rust 编写，性能优异
• 支持过滤搜索
• 易于部署（Docker）

FAISS（Facebook AI Similarity Search）

• Meta 开发的高性能库
• 不是数据库，是搜索库
• 适合嵌入到自己的应用中
• GPU 加速支持

5.3 ChromaDB 完整使用示例

import chromadb
from chromadb.utils import embedding_functions

# 创建持久化客户端
client = chromadb.PersistentClient(path="./chroma_data")

# 使用自定义嵌入函数
ef = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="BAAI/bge-large-zh-v1.5"
)

# 创建集合
collection = client.get_or_create_collection(
    name="my_knowledge_base",
    embedding_function=ef,
    metadata={"hnsw:space": "cosine"}
)

# 添加文档
collection.add(
    documents=[
        "Python 是一种解释型、面向对象的编程语言",
        "JavaScript 是 Web 前端开发的核心语言",
        "Rust 以其内存安全和并发安全著称",
        "Go 语言由 Google 开发，适合构建高并发服务",
    ],
    metadatas=[
        {"category": "language", "level": "beginner"},
        {"category": "language", "level": "beginner"},
        {"category": "language", "level": "advanced"},
        {"category": "language", "level": "intermediate"},
    ],
    ids=["doc1", "doc2", "doc3", "doc4"]
)

# 搜索（支持过滤）
results = collection.query(
    query_texts=["适合写后端服务的编程语言"],
    n_results=2,
    where={"level": {"$in": ["intermediate", "advanced"]}}
)

print(results['documents'])
print(results['metadatas'])

六、本地部署嵌入模型

6.1 使用 Sentence Transformers

pip install sentence-transformers

from sentence_transformers import SentenceTransformer

# 加载模型（首次会自动下载）
model = SentenceTransformer('BAAI/bge-large-zh-v1.5')

# 编码文本
texts = ["人工智能正在改变世界", "深度学习是AI的核心技术"]
embeddings = model.encode(texts, normalize_embeddings=True)

print(f"向量维度: {embeddings.shape}")
print(f"向量示例: {embeddings[0][:5]}")

6.2 使用 Ollama 运行嵌入模型

# 下载嵌入模型
ollama pull bge-m3
# 或
ollama pull nomic-embed-text

# API 调用
curl http://localhost:11434/api/embeddings -d '{
    "model": "bge-m3",
    "prompt": "人工智能正在改变世界"
}'

Python 调用：

import requests

def get_embedding(text, model="bge-m3"):
    response = requests.post(
        "http://localhost:11434/api/embeddings",
        json={"model": model, "prompt": text}
    )
    return response.json()["embedding"]

embedding = get_embedding("人工智能正在改变世界")
print(f"维度: {len(embedding)}")

6.3 使用 TEI（Text Embeddings Inference）

Hugging Face 提供的高性能嵌入推理服务器：

# Docker 部署
docker run --gpus all -p 8080:80 \
    ghcr.io/huggingface/text-embeddings-inference:latest \
    --model-id BAAI/bge-large-zh-v1.5

# 调用
import requests

response = requests.post(
    "http://localhost:8080/embed",
    json={"inputs": ["人工智能正在改变世界", "深度学习是核心技术"]}
)
embeddings = response.json()

6.4 性能对比

在 NVIDIA RTX 4070 上，处理 1000 条文本的嵌入速度：

七、嵌入模型的最佳实践

7.1 文本预处理

在嵌入之前进行适当的文本预处理可以提高检索质量：

def preprocess_for_embedding(text):
    """嵌入前的文本预处理"""
    # 1. 清理特殊字符
    import re
    text = re.sub(r'\s+', ' ', text)  # 合并空白
    text = re.sub(r'[^\w\s\u4e00-\u9fff]', '', text)  # 保留中文和字母
    
    # 2. 截断到模型支持的最大长度
    # bge-large-zh-v1.5 最大 512 token
    
    # 3. 对于长文档，分块处理
    chunks = split_into_chunks(text, max_tokens=480, overlap=30)
    
    return chunks

7.2 分块策略

对于长文档，需要合理分块：

• 固定长度分块：简单但可能切断语义单元
• 句子边界分块：保持句子完整性
• 语义分块：使用嵌入相似度找到自然的分割点
• 递归分块：先按段落分，再按句子分，最后按字符分

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", "。", "！", "？", ".", "!", "?", " "]
)

chunks = splitter.split_text(long_document)

7.3 混合检索

结合关键词检索和语义检索可以获得最佳效果：

class HybridSearch:
    def __init__(self, embedding_model, documents):
        self.model = embedding_model
        self.documents = documents
        self.embeddings = model.encode(documents, normalize_embeddings=True)
        
        # 构建 BM25 索引（关键词检索）
        from rank_bm25 import BM25Okapi
        tokenized_docs = [doc.split() for doc in documents]
        self.bm25 = BM25Okapi(tokenized_docs)
    
    def search(self, query, top_k=5, alpha=0.5):
        """混合检索"""
        # 语义检索
        q_embedding = self.model.encode([query], normalize_embeddings=True)
        semantic_scores = np.dot(self.embeddings, q_embedding.T).flatten()
        
        # 关键词检索
        bm25_scores = self.bm25.get_scores(query.split())
        
        # 归一化分数
        semantic_norm = (semantic_scores - semantic_scores.min()) / \
                        (semantic_scores.max() - semantic_scores.min() + 1e-8)
        bm25_norm = (bm25_scores - bm25_scores.min()) / \
                    (bm25_scores.max() - bm25_scores.min() + 1e-8)
        
        # 加权合并
        combined = alpha * semantic_norm + (1 - alpha) * bm25_norm
        
        top_indices = np.argsort(combined)[-top_k:][::-1]
        return [(self.documents[i], combined[i]) for i in top_indices]

7.4 嵌入缓存

对于重复的文本，缓存嵌入结果可以显著提升性能：

import hashlib
import pickle

class EmbeddingCache:
    def __init__(self, cache_file="embedding_cache.pkl"):
        self.cache_file = cache_file
        try:
            with open(cache_file, 'rb') as f:
                self.cache = pickle.load(f)
        except:
            self.cache = {}
    
    def get_embedding(self, text, model):
        key = hashlib.md5(text.encode()).hexdigest()
        if key not in self.cache:
            self.cache[key] = model.encode([text])[0]
            self._save()
        return self.cache[key]
    
    def _save(self):
        with open(self.cache_file, 'wb') as f:
            pickle.dump(self.cache, f)

八、嵌入模型在 AI Agent 中的应用

8.1 工具检索

AI Agent 通常拥有大量可用工具，使用嵌入模型可以根据用户意图动态检索最相关的工具：

class ToolRetriever:
    def __init__(self, model):
        self.model = model
        self.tools = {}
        self.tool_descriptions = []
        self.embeddings = None
    
    def register_tool(self, name, description, function):
        self.tools[name] = {"desc": description, "func": function}
        self.tool_descriptions.append(f"{name}: {description}")
        self.embeddings = self.model.encode(
            self.tool_descriptions, normalize_embeddings=True
        )
    
    def find_tools(self, query, top_k=3):
        q_embedding = self.model.encode([query], normalize_embeddings=True)
        similarities = np.dot(self.embeddings, q_embedding.T).flatten()
        top_indices = np.argsort(similarities)[-top_k:][::-1]
        
        return [
            (list(self.tools.keys())[i], similarities[i])
            for i in top_indices
        ]

8.2 记忆管理

AI Agent 使用嵌入模型管理长期记忆，实现相关记忆的检索和更新：

class AgentMemory:
    def __init__(self, model, collection):
        self.model = model
        self.collection = collection
    
    def remember(self, content, metadata=None):
        """存储记忆"""
        embedding = self.model.encode([content], normalize_embeddings=True)
        self.collection.add(
            documents=[content],
            embeddings=embedding.tolist(),
            metadatas=[metadata or {}],
            ids=[f"mem_{hash(content)}"]
        )
    
    def recall(self, query, top_k=5):
        """回忆相关记忆"""
        q_embedding = self.model.encode([query], normalize_embeddings=True)
        results = self.collection.query(
            query_embeddings=q_embedding.tolist(),
            n_results=top_k
        )
        return results['documents'][0]

九、常见问题解答（FAQ）

Q：嵌入模型和分词器（Tokenizer）有什么区别？

A：分词器只是将文本拆分为 token，不涉及语义理解。嵌入模型则将整个文本编码为包含语义信息的向量。分词器是嵌入模型的一个前置步骤。

Q：不同模型生成的嵌入可以互相比较吗？

A：不可以。不同模型的向量空间是独立的，它们生成的嵌入不能直接比较。如果更换模型，需要重新生成所有文档的嵌入。

Q：嵌入模型能处理图片、音频等非文本数据吗？

A：传统的文本嵌入模型只处理文本。但现在有多模态嵌入模型（如 CLIP、Jina CLIP）可以同时处理图片和文本，将它们映射到同一个向量空间中。

Q：为什么嵌入向量的维度不能太低？

A：维度太低，向量空间无法充分表达复杂的语义关系。就像一个低分辨率的图片无法展示细节一样。但维度也不是越高越好，过高的维度会增加存储和计算成本，还可能导致维度灾难。

Q：本地运行嵌入模型需要什么硬件？

A：嵌入模型很小（通常 100MB-1GB），在 CPU 上就能快速运行。一台普通的笔记本电脑就可以本地运行嵌入模型。如果有 GPU，处理速度会更快，但不是必需的。

Q：如何评估嵌入模型的好坏？

A：主要看 MTEB（Massive Text Embedding Benchmark）基准测试的分数。它涵盖了检索、分类、聚类、语义相似度等多个维度的评测。但最重要的还是在你的具体应用场景上进行测试。

Q：嵌入模型会不会过时？

A：嵌入模型技术在持续进步，新模型性能更好。但老模型的嵌入结果在同一个向量空间中仍然有效。建议在启动新项目时使用最新的模型，老项目如果效果满意可以不升级。

十、总结

嵌入模型是现代 AI 应用的基石技术。它将文本转化为计算机可理解的向量表示，使语义搜索、文档检索、文本分类、推荐系统等应用成为可能。

关键要点回顾：

1. 嵌入模型将文本转化为固定长度的语义向量
2. 余弦相似度是最常用的向量相似度度量方法
3. BGE、GTE、Jina 是目前表现最好的开源嵌入模型
4. RAG 架构结合了嵌入检索和 LLM 生成的优势
5. 向量数据库解决了大规模向量检索的效率问题
6. 嵌入模型本地部署非常简单，CPU 即可运行

无论你是构建 AI 应用、优化搜索系统，还是开发 AI Agent，嵌入模型都是不可或缺的核心组件。希望本文帮助你建立了扎实的理论基础，并掌握了实际的使用技能。现在就选择一个嵌入模型，开始你的第一个语义搜索项目吧！