2025-08-13

WeChat Mini Program - Values Test and City Match

微信小程序项目：三观测试与城市匹配

本文介绍一个微信小程序项目的构想，包括三观测试功能、城市匹配系统以及论坛互动功能的实现方案。

功能概述

// 主要功能模块
const modules = {
  valuesTest: '三观测试系统',
  cityMatch: '城市匹配引擎',
  forum: '用户论坛'
}

三观测试系统

测试内容设计

// 测试题目结构
const questionSchema = {
  categories: [
    '人生价值观',
    '婚恋观念',
    '教育理念',
    '工作态度',
    '消费习惯'
  ],
  questionFormat: {
    type: '选择题/量表题',
    options: '多个选项',
    weight: '不同维度权重'
  }
}

评分算法

// 计算用户三观特征
function calculateValues(answers) {
  // 多维度评分系统
  const dimensions = {
    traditional: 0,  // 传统度
    openness: 0,     // 开放度
    materialistic: 0 // 物质导向
    // ... 其他维度
  }
  
  // 根据答案计算各维度分数
  answers.forEach(answer => {
    dimensions[answer.dimension] += answer.score * answer.weight
  })
  
  return dimensions
}

城市匹配系统

城市数据库

// 城市特征数据结构
const cityProfile = {
  basic: {
    name: '城市名称',
    population: '人口数量',
    gdp: 'GDP指标'
  },
  culture: {
    traditions: '传统文化指数',
    modernity: '现代化程度',
    lifestyle: '生活方式特征'
  },
  statistics: {
    avgIncome: '平均收入',
    costOfLiving: '生活成本',
    education: '教育资源'
  }
}

匹配算法

// 匹配用户与城市
function matchCityValues(userValues, cities) {
  return cities.map(city => {
    const similarity = calculateSimilarity(userValues, city.values)
    return {
      city: city.name,
      score: similarity,
      matches: findMatchingAspects(userValues, city.values)
    }
  }).sort((a, b) => b.score - a.score)
}

论坛互动系统

数据结构

// 论坛帖子结构
const postSchema = {
  author: {
    id: 'string',
    nickname: 'string',
    avatar: 'string',
    valuesProfile: 'object'  // 用户三观特征
  },
  content: {
    title: 'string',
    text: 'string',
    images: 'array',
    city: 'string'  // 关联城市
  },
  interaction: {
    likes: 'number',
    comments: 'array',
    shares: 'number'
  }
}

交互功能

// 论坛交互功能
class ForumInteraction {
  // 发布帖子
  async createPost(post) {
    // 添加三观标签
    post.tags = generateValuesTags(post.author.valuesProfile)
    return await db.posts.add(post)
  }
  
  // 寻找志同道合的帖子
  async findSimilarPosts(userValues) {
    const posts = await db.posts.find()
    return posts.filter(post => 
      calculateValuesSimilarity(userValues, post.author.valuesProfile) > 0.7
    )
  }
}

技术实现方案

前端架构

// 页面结构
pages: {
  test: {
    index: '测试首页',
    questions: '测试题目',
    result: '测试结果'
  },
  city: {
    match: '城市匹配',
    detail: '城市详情',
    comparison: '城市对比'
  },
  forum: {
    posts: '帖子列表',
    detail: '帖子详情',
    publish: '发布帖子'
  }
}

后端服务

// 服务端API
const apis = {
  values: {
    submit: '提交测试答案',
    analyze: '分析用户特征',
    compare: '特征对比'
  },
  city: {
    match: '城市匹配',
    statistics: '城市数据',
    recommend: '推荐城市'
  },
  forum: {
    post: '发帖相关',
    comment: '评论相关',
    search: '搜索相关'
  }
}

数据存储

数据库设计

// 数据库结构
const dbSchema = {
  users: {
    profile: '用户资料',
    values: '三观数据',
    preferences: '偏好设置'
  },
  cities: {
    basic: '基础数据',
    culture: '文化特征',
    statistics: '统计数据'
  },
  posts: {
    content: '帖子内容',
    metadata: '元数据',
    interactions: '互动数据'
  }
}

项目亮点

个性化推荐
- 基于三观特征的城市匹配
- 智能推荐同价值观的用户帖子
- 个性化的城市生活建议
社交互动
- 基于价值观的用户匹配
- 城市生活经验分享
- 群组讨论功能
数据分析
- 城市价值观分布图
- 用户群体特征分析
- 迁移趋势分析

发展规划

第一阶段
- 实现基础的测试功能
- 简单的城市匹配
- 基础论坛功能
第二阶段
- 完善匹配算法
- 添加更多城市数据
- 增强社交功能
第三阶段
- 引入机器学习推荐
- 开发地图可视化
- 增加城市群聊功能

变现方案

增值服务
- 深度三观分析报告
- 专业城市咨询服务
- VIP社交功能
广告收入
- 城市定向广告
- 房产中介合作
- 招聘信息推广
数据服务
- 城市人群画像报告
- 迁移趋势分析
- 企业定制数据服务

2025-08-13

WeChat Mini Program Getting Started

微信小程序入门

本文介绍微信小程序的基础知识，包括开发环境搭建、项目结构、基本组件使用以及生命周期等核心概念。

常见问题解答

1. 微信小程序可以用React吗？

微信小程序不能直接使用React，原因如下：

框架差异
- 小程序使用自己的WXML和WXSS，而不是HTML和CSS
- 小程序有自己的生命周期和数据绑定方式
- 小程序的运行环境不同于浏览器
替代方案
- 可以使用Taro等跨端框架，它支持使用React语法开发小程序
- Remax也是一个流行的选择，让你用React开发小程序
- 这些框架会将React代码转换为小程序代码

2. 为什么必须使用官方IDE而不是VSCode？

微信小程序必须使用官方IDE的原因：

功能特化
- 内置了小程序的调试和预览功能
- 提供了真机调试的能力
- 集成了性能监控和分析工具
安全考虑
- 官方IDE提供了加密和签名机制
- 确保上传的代码来源可信
- 防止代码被恶意篡改
开发效率
- 提供了小程序专用的API提示和自动补全
- 内置了模拟器，可即时预览效果
- 集成了项目上传和版本管理功能

开发环境准备

# 必要工具
1. 微信开发者工具 - 官方IDE
2. Node.js - 运行环境
3. npm/yarn - 包管理工具

项目结构说明

miniprogram/
├── pages/           # 页面文件夹
│   └── index/      # 首页
│       ├── index.js    # 逻辑
│       ├── index.wxml  # 结构
│       ├── index.wxss  # 样式
│       └── index.json  # 配置
├── utils/          # 工具函数
├── app.js         # 全局逻辑
├── app.json       # 全局配置
└── app.wxss       # 全局样式

基础组件使用

<!-- 视图容器 -->
<view class="container">
  <text>Hello World</text>
  <button type="primary">点击按钮</button>
  <image src="path/to/image.png"></image>
</view>

<!-- 页面逻辑 -->
Page({
  data: {
    message: 'Hello World'
  },
  onLoad() {
    // 页面加载时执行
  }
})

生命周期函数

应用生命周期

// app.js
App({
  onLaunch() {
    // 小程序初始化
  },
  onShow() {
    // 小程序显示
  },
  onHide() {
    // 小程序隐藏
  }
})

页面生命周期

// pages/index/index.js
Page({
  onLoad() {
    // 页面加载时
  },
  onShow() {
    // 页面显示时
  },
  onReady() {
    // 页面初次渲染完成时
  },
  onHide() {
    // 页面隐藏时
  },
  onUnload() {
    // 页面卸载时
  }
})

数据绑定与事件处理

// WXML
<view>{{message}}</view>
<button bindtap="handleClick">点击我</button>

// JS
Page({
  data: {
    message: 'Hello'
  },
  handleClick() {
    this.setData({
      message: 'World'
    })
  }
})

常用API

// 网络请求
wx.request({
  url: 'https://api.example.com/data',
  success(res) {
    console.log(res.data)
  }
})

// 本地存储
wx.setStorage({
  key: 'userInfo',
  data: {
    name: 'John'
  }
})

// 导航
wx.navigateTo({
  url: '/pages/detail/detail'
})

用户信息相关API

获取用户信息

// 获取用户信息
Page({
  getUserProfile() {
    wx.getUserProfile({
      desc: '用于完善会员资料', // 声明获取用户个人信息后的用途
      success: (res) => {
        const userInfo = res.userInfo
        console.log('用户信息:', userInfo)
        // userInfo包含：
        // - nickName: 用户昵称
        // - avatarUrl: 用户头像
        // - gender: 性别
        // - country: 国家
        // - province: 省份
        // - city: 城市
        // - language: 语言
      }
    })
  }
})

获取头像昵称

// wxml文件
<button class="avatar-wrapper" open-type="chooseAvatar" bind:chooseavatar="onChooseAvatar">
  <image class="avatar" src="{{avatarUrl}}"></image>
</button>
<input type="nickname" placeholder="请输入昵称" bindchange="onInputNickname"/>

// js文件
Page({
  data: {
    avatarUrl: '/images/default-avatar.png',
    nickname: ''
  },
  onChooseAvatar(e) {
    const { avatarUrl } = e.detail
    this.setData({
      avatarUrl,
    })
  },
  onInputNickname(e) {
    this.setData({
      nickname: e.detail.value
    })
  }
})

获取手机号

<button open-type="getPhoneNumber" bindgetphonenumber="getPhoneNumber">获取手机号</button>

Page({
  getPhoneNumber(e) {
    if (e.detail.code) {
      // 发送code到后端换取手机号
      wx.request({
        url: 'your_api_url',
        data: {
          code: e.detail.code
        },
        success: (res) => {
          console.log('获取手机号成功:', res.data)
        }
      })
    }
  }
})

获取位置信息

wx.getLocation({
  type: 'gcj02', // gcj02为火星坐标系
  success: (res) => {
    const {latitude, longitude} = res
    console.log('当前位置:', latitude, longitude)
    
    // 使用腾讯地图逆地址解析
    wx.request({
      url: `https://apis.map.qq.com/ws/geocoder/v1/?location=${latitude},${longitude}&key=YOUR_KEY`,
      success: (result) => {
        console.log('位置信息:', result.data)
      }
    })
  }
})

总结

微信小程序提供了一个完整的开发框架，包括：

基础组件 - 提供常用UI组件
生命周期 - 管理应用和页面状态
数据绑定 - 实现视图和逻辑的关联
丰富API - 支持各种系统功能调用

掌握这些基础知识后，就可以开始开发自己的小程序应用了。进阶内容包括：

组件化开发
分包加载
性能优化
云开发

部署发布流程

# 部署步骤

1. 代码上传
   - 在开发者工具中点击"上传"
   - 填写版本号和项目备注
   - 选择上传代码

2. 提交审核
   - 登录微信公众平台
   - 进入"版本管理"
   - 选择提交审核的版本
   - 填写审核信息
   - 等待审核结果（一般1-7天）

3. 发布上线
   - 审核通过后
   - 在版本管理页面
   - 点击"发布"按钮

常见审核问题

信息完整性
- 确保小程序基本信息完整
- 隐私政策和用户协议已提供
- 相关资质证明文件齐全
内容合规
- 符合微信小程序规范
- 无违规内容
- 功能正常可用
技术规范
- 页面加载性能达标
- 无明显错误或崩溃
- API使用符合规范

版本更新维护

// 检查更新
const updateManager = wx.getUpdateManager()

updateManager.onCheckForUpdate(function (res) {
  // 请求完新版本信息的回调
  console.log(res.hasUpdate)
})

updateManager.onUpdateReady(function () {
  wx.showModal({
    title: '更新提示',
    content: '新版本已经准备好，是否重启应用？',
    success(res) {
      if (res.confirm) {
        updateManager.applyUpdate()
      }
    }
  })
})

2025-08-13

数据集构建中的清洗方法分析

Bing搜索数据集清洗笔记

从Bing爬取query-doc对构建RAG数据集的清洗步骤：

1. 数据基础过滤

基础过滤的核心步骤：

长度过滤：丢弃过短的query和document
内容质量过滤：去除广告内容和纯导航页面
初步相关性过滤：检查document是否包含query关键词

2. 重复检测

重复检测的思路：

使用模糊匹配算法计算文档相似度
同时考虑query和document的相似度
设置相似度阈值进行去重判断
保留最先出现的样本

3. HTML清理

HTML清理流程：

移除HTML标签，保留有效文本
清理特殊字符和多余空白
规范化文本格式，去除空行
保持段落结构完整性

4. 相关性打分

5. 数据采样

采样策略考虑：

按query长度分桶，确保不同长度的样本都有覆盖
各桶等比例采样，保持数据分布平衡
随机采样，避免选择偏差

6. Test Dataset Construction

URL Sampling Strategy

Initial URL Collection
- Sample URLs from search results
- Ensure domain diversity
- Maintain a balanced ratio of HTML:PDF (~7:3)

URL Format Analysis

# HTML URLs pattern examples
www.example.com/article/12345
docs.example.org/guide/setup
blog.example.net/2023/08/post

# PDF URLs pattern examples
cdn.example.com/papers/research.pdf
archive.example.org/docs/whitepaper.pdf
files.example.net/reports/2023.pdf

URL Validation Steps
- Check URL accessibility
- Verify content type (text/html or application/pdf)
- Validate file size (PDF: 100KB-10MB)
- Confirm stable content (non-dynamic pages)
URL Categories to Include
- Technical documentation
- Academic papers
- Product documentation
- Official guidelines
- Research papers
- Industry reports

清洗流水线

完整处理流程：

基础清洗：长度、质量、初步相关性过滤
去重处理：相似度检测
相关性过滤：多维度打分筛选
分桶采样：平衡数据分布
URL采样：确保HTML和PDF分布平衡

2025-08-13

Chatgpt RAG Search Workflow Analysis

RAG Search Workflow Analysis

analysis from chatgpt

Web搜索流程

Web搜索采用简洁高效的方式：

搜索引擎查询返回snippet
直接使用snippet作为上下文
无需额外处理原始网页

优势：

效率高：避免了完整网页的处理
精确性：snippet通常包含查询相关的核心内容
资源占用低：无需额外的文本处理和存储

Document搜索流程

针对大型文档(>20k tokens)的处理策略：

Find API返回方式：
- 选项1：返回文档前20k tokens
- 选项2：每页返回500 tokens

使用建议：

对于一般查询：使用前20k tokens足够覆盖主要内容
对于需要精确定位的查询：采用500 tokens/页的方式能提供更精确的上下文

最佳实践

Web搜索：

def web_search_rag(query):
    # 获取搜索引擎snippet
    snippets = search_engine.get_snippets(query)
    
    # 直接使用snippet作为上下文
    context = snippets
    
    return context

文档搜索：

def doc_search_rag(query, doc_id, mode="chunk"):
    if mode == "head":
        # 返回前20k tokens
        context = find_api.get_head(doc_id, max_tokens=20000)
    else:
        # 按页返回
        context = find_api.get_chunks(doc_id, chunk_size=500)
        
    return context

总结

Web搜索流程优先使用snippet，简单高效
文档搜索根据具体需求选择合适的分块策略
关注token限制，确保上下文大小适中

2025-08-13

2025-08-12

置信度简记

置信度 (Confidence)

置信度是模型对其预测或输出的确信程度，通常用0-1之间的数值表示，数值越高表示模型越确信其结果的正确性。

2025-08-12

URL Hash对比精简总结

本文对URL Hash的各种实现方式进行精简总结，帮助快速选择合适的哈希方法。

主流哈希方法对比

MD5：128位哈希值，速度快但有碰撞风险
SHA-1：160位哈希值，安全性优于MD5
SHA-256：256位哈希值，安全性最高但计算较慢
MurmurHash：非加密哈希，速度快、分布均匀，适合URL去重
CRC32：32位校验和，速度最快但碰撞概率高

选择建议

根据场景需求权衡：

重视安全性：SHA-256
追求性能：MurmurHash
折中方案：SHA-1

2025-08-11

双塔模型

双塔模型 (Dual-Tower Model)

双塔模型在RAG (Retrieval-Augmented Generation) 系统中扮演着重要的检索角色。作为一名后端工程师，如果你正在构建搜索系统、RAG系统或推荐系统，了解双塔模型的原理和应用将会非常有帮助。本文从工程实践的角度介绍双塔模型的核心概念、优势以及实现方法。

RAG中的检索方法

RAG系统的核心步骤之一是从大量文档中检索与用户查询相关的内容。在RAG系统中，主要有以下几种检索方法：

稀疏检索 (Sparse Retrieval)
- 使用BM25等传统检索算法
- 基于关键词匹配
- 计算效率高，但可能会错过语义相关但用词不同的文档
密集检索 (Dense Retrieval)
- 使用神经网络将文本转换为稠密向量
- 基于语义相似度，能捕捉上下文关系
- 双塔模型是实现密集检索的一种架构方案，通过两个独立的编码器来生成向量
混合检索 (Hybrid Retrieval)
- 结合稀疏检索和密集检索的优点
- 可以同时考虑词汇匹配和语义相关性
- 例如：ColBERT模型，结合了词级别的交互和向量检索
重排序 (Re-ranking)
- 先用快速方法（如BM25）检索候选集
- 再用更复杂的模型（如Cross-Encoder）重排序
- 平衡效果和效率

注意：双塔模型本身不是一种检索方法，而是实现密集检索的一种具体架构。它通过两个独立的神经网络将查询和文档编码为向量，从而支持高效的相似度计算和检索。

稀疏检索算法示例

稀疏检索是传统信息检索中最常用的方法之一，其中BM25(Best Matching 25)是最经典的算法：

1. TF-IDF (Term Frequency-Inverse Document Frequency)

from sklearn.feature_extraction.text import TfidfVectorizer

# 初始化TF-IDF向量器
vectorizer = TfidfVectorizer()

# 文档集合
documents = [
    "BM25是一种检索算法",
    "检索算法用于搜索相关文档",
    "文档检索是信息检索的核心任务"
]

# 计算TF-IDF矩阵
tfidf_matrix = vectorizer.fit_transform(documents)

# 查询
query = "检索算法"
query_vec = vectorizer.transform([query])

# 计算相似度（使用矩阵乘法）
similarities = (query_vec * tfidf_matrix.T).toarray()[0]

2. BM25算法

from rank_bm25 import BM25Okapi
import jieba  # 中文分词

class ChineseBM25Retriever:
    def __init__(self, documents):
        # 对文档进行分词
        self.tokenized_docs = [list(jieba.cut(doc)) for doc in documents]
        self.bm25 = BM25Okapi(self.tokenized_docs)
        self.documents = documents
    
    def retrieve(self, query, top_k=3):
        # 对查询进行分词
        tokenized_query = list(jieba.cut(query))
        
        # 计算BM25分数
        scores = self.bm25.get_scores(tokenized_query)
        
        # 获取top-k文档
        top_indices = np.argsort(scores)[-top_k:][::-1]
        results = []
        
        for idx in top_indices:
            results.append({
                'document': self.documents[idx],
                'score': scores[idx]
            })
        
        return results

# 使用示例
documents = [
    "BM25是一种广泛使用的检索算法",
    "它在信息检索领域表现出色",
    "相比TF-IDF，BM25考虑了文档长度"
]

retriever = ChineseBM25Retriever(documents)
results = retriever.retrieve("检索算法的表现", top_k=2)

3. BM25的核心公式

BM25的得分计算公式如下：

def bm25_score(query_term, document, k1=1.5, b=0.75):
    """
    query_term: 查询词
    document: 文档
    k1: 词频饱和参数
    b: 文档长度归一化参数
    """
    # 文档中词项的频率
    tf = document.term_frequency(query_term)
    
    # 文档集合中包含该词的文档数量的倒数
    idf = log((N - n + 0.5) / (n + 0.5))
    
    # 文档长度归一化
    doc_len = len(document)
    avg_doc_len = average_document_length
    normalized_tf = ((k1 + 1) * tf) / (k1 * (1 - b + b * doc_len / avg_doc_len) + tf)
    
    return idf * normalized_tf

稀疏检索的特点：

基于词频统计，计算高效
不需要预训练，容易实现和部署
适合精确匹配场景
可以通过倒排索引优化检索速度

双塔模型在RAG中的应用

在众多检索方法中，双塔模型因其效率和可扩展性成为常用选择。它在RAG系统中的具体应用如下：

预处理阶段
- 使用Document Tower对知识库中的所有文档进行编码
- 将文档向量存储在向量数据库中（如Faiss）
- 这个过程只需执行一次，可离线完成
检索阶段
- 用户提出查询时，使用Query Tower将查询编码为向量
- 在向量数据库中快速找到最相似的文档向量
- 返回对应的原始文档作为上下文
与RAG的关系
- RAG = Retrieval (双塔模型) + Augmented Generation (LLM)
- 双塔模型负责高效的相似文档检索
- 检索到的文档会作为上下文提供给LLM
- LLM基于这些上下文生成最终回答

这种架构设计使得RAG系统能够：

快速从海量文档中检索相关内容
保持检索结果的语义相关性
支持大规模知识库的实时查询

什么是双塔模型？

双塔模型（Dual-Tower Model）也称为双编码器模型（Dual-Encoder Model），是一种神经网络架构，主要用于高效的相似度计算和匹配任务。它包含两个独立的神经网络”塔”：

Query Tower：处理查询/用户输入
Document Tower：处理文档/候选项

   Query          Document
     |               |
┌────┴────┐    ┌────┴────┐
│ Query   │    │Document │
│ Encoder │    │Encoder  │
└────┬────┘    └────┬────┘
     |               |
Query Vector    Doc Vector
     |               |
     └───── ∙ ───────┘
        Similarity

工程优势

对于后端工程师来说，双塔模型有以下几个重要优势：

高效的线上服务
- Document vectors可以预先计算并存储
- 线上只需计算query vector，大大减少推理延迟
- 支持使用ANN（近似最近邻）加速检索
可扩展性
- 支持大规模候选池
- 易于分布式部署
- 检索延迟与候选集大小的关系是对数级的
工程实用性
- 适合用Faiss等向量检索引擎部署
- 容易与现有系统集成
- 支持批量处理和缓存优化

实现示例

以下是使用PyTorch实现的简单双塔模型示例：

import torch
import torch.nn as nn

class TowerNet(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, output_dim),
            nn.LayerNorm(output_dim)
        )
    
    def forward(self, x):
        return self.encoder(x)

class DualTowerModel(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        # 查询塔和文档塔使用相同的结构但参数独立
        self.query_tower = TowerNet(input_dim, hidden_dim, output_dim)
        self.doc_tower = TowerNet(input_dim, hidden_dim, output_dim)
    
    def forward(self, query, document):
        # 计算query和document的向量表示
        query_vec = self.query_tower(query)
        doc_vec = self.doc_tower(document)
        
        # 计算余弦相似度
        similarity = torch.cosine_similarity(query_vec, doc_vec, dim=1)
        return similarity
    
    def encode_query(self, query):
        return self.query_tower(query)
    
    def encode_document(self, document):
        return self.doc_tower(document)

工程实践建议

向量存储选择

import faiss

# 初始化Faiss索引
dimension = 128  # 向量维度
index = faiss.IndexFlatIP(dimension)  # 内积用于余弦相似度

# 批量编码文档
doc_vectors = model.encode_document(documents)
index.add(doc_vectors.numpy())

# 线上检索
query_vector = model.encode_query(query)
D, I = index.search(query_vector.numpy(), k=10)  # 返回top-k

性能优化

# 1. 使用批处理加速编码
@torch.no_grad()
def batch_encode(self, texts, batch_size=32):
    vectors = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        vectors.append(self.encode_document(batch))
    return torch.cat(vectors)

# 2. 向量量化减少内存
quantizer = faiss.IndexFlatL2(dimension)
index = faiss.IndexIVFPQ(quantizer, dimension, nlist=100, 
                        m=8, nbits_per_idx=8)

缓存策略

from functools import lru_cache

@lru_cache(maxsize=10000)
def get_query_vector(query_text):
    return model.encode_query(query_text)

应用场景

搜索系统
- 文档检索
- 相似问题匹配
- 代码搜索
推荐系统
- 商品推荐
- 内容匹配
- 用户-物品相似度计算
信息检索
- 相似文本发现
- 跨语言检索
- 语义匹配

性能优化Tips

向量索引优化
- 使用IVF (Inverted File Index) 进行粗搜索
- 采用PQ (Product Quantization) 压缩向量
- 合理设置nprobe参数平衡速度和召回率
分布式部署
- 文档向量分片存储
- 查询塔负载均衡
- 结果合并策略
监控指标
- 向量计算延迟
- 检索QPS
- 内存使用
- 召回率/准确率

总结

双塔模型是一个非常实用的深度学习架构，特别适合需要大规模相似度计算的后端系统。通过合理的工程实现和优化，可以构建高性能、可扩展的搜索和推荐服务。作为后端工程师，掌握双塔模型不仅有助于理解现代信息检索系统，还能帮助你设计更好的服务架构。

2025-08-11

不同模型的token计数差异

在RAG系统中处理source data时，经常遇到以下问题：

同一个文本，在OpenAI和E5中的token数量不同
Large/Small model对token的处理可能有差异
中英文混合文本的token计数特殊情况

针对不同模型的token选择建议：

OpenAI GPT-3.5/4: 使用cl100k_base
E5 (Microsoft内部): 使用E5专用tokenizer
其他自定义模型: 使用对应的model checkpoint的tokenizer

以下是具体的实践示例：

Token数量差异演示

import tiktoken
from transformers import AutoTokenizer

# RAG系统中的查询和文档示例
query = "what's the history of Suzhou?"
document = """
Suzhou, located in Jiangsu Province, is one of the oldest cities in China.
The city's history dates back over 2,500 years, when it was founded in 514 BCE.
Suzhou is renowned for its classical gardens and ancient water towns.
"""

def analyze_tokens_for_rag(query, document):
    # 1. OpenAI cl100k_base (用于API调用和嵌入)
    cl100k_encoder = tiktoken.get_encoding("cl100k_base")
    
    query_tokens_oai = cl100k_encoder.encode(query)
    doc_tokens_oai = cl100k_encoder.encode(document)
    
    # 2. E5 tokenizer (用于嵌入生成)
    e5_tokenizer = AutoTokenizer.from_pretrained("intfloat/multilingual-e5-base")
    
    query_tokens_e5 = e5_tokenizer.encode(query)
    doc_tokens_e5 = e5_tokenizer.encode(document)
    
    print("Query分析:")
    print(f"- OpenAI tokens: {len(query_tokens_oai)} {query_tokens_oai}")
    print(f"- E5 tokens: {len(query_tokens_e5)} (含特殊tokens)\n")
    
    print("Document分析:")
    print(f"- OpenAI tokens: {len(doc_tokens_oai)}")
    print(f"- E5 tokens: {len(doc_tokens_e5)} (含特殊tokens)")
    
    # 显示实际分词结果
    print("\nQuery的分词结果:")
    print("OpenAI:", cl100k_encoder.decode(query_tokens_oai).split())
    print("E5:", e5_tokenizer.tokenize(query))

# 运行分析
analyze_tokens_for_rag(query, document)

"""
输出示例:
Query分析:
- OpenAI tokens: 7 [what, 's, the, history, of, Su, zhou]
- E5 tokens: 9 (含[CLS]和[SEP])

Document分析:
- OpenAI tokens: 64
- E5 tokens: 66 (含特殊tokens)

Query的分词结果:
OpenAI: ['what', "'s", 'the', 'history', 'of', 'Su', 'zhou']
E5: ['[CLS]', 'what', "'s", 'the', 'history', 'of', 'su', 'zhou', '[SEP]']
"""

RAG系统中的应用实践

在RAG系统中处理文本时，需要注意以下几点：

Query的token计数：
- OpenAI embedding和E5在同一个query上的token数会不同
- E5会额外添加特殊tokens（[CLS], [SEP]）
- 计算成本和长度限制需要分别考虑
Chunk的token计数：
- 文档分块时要考虑不同tokenizer的差异
- 相同字符数的文本可能产生不同token数
- 建议预留一定的token余量
Token数量差异原因：
不同的分词策略
- cl100k_base使用改进的BPE算法
- E5使用SentencePiece tokenizer
- 可能对同一个词有不同的分割方式
特殊tokens
- OpenAI模型通常不添加特殊标记
- E5等BERT系列模型会添加[CLS], [SEP]等特殊token
中文处理
- 不同tokenizer对”Suzhou”这样的混合文本有不同的处理策略
- 有的会将其作为一个整体，有的会分开处理

与其他编码器的比较

特性	cl100k_base	E5 Tokenizer	p50k_base
词汇表大小	100k	~30k	50k
特殊tokens	无	[CLS], [SEP] 等	无
中文处理	字符级	WordPiece	字符级
适用模型	GPT-3.5/4	E5系列	早期GPT-3
多语言支持	优秀	优秀	一般

使用场景

1. 文本长度估算

当需要评估文本长度是否适合模型时：

def check_text_length(text, max_tokens=4096):
    # 对于OpenAI API调用
    cl100k_tokens = len(tiktoken.get_encoding("cl100k_base").encode(text))
    # 对于E5 embedding
    e5_tokens = len(AutoTokenizer.from_pretrained("intfloat/multilingual-e5-base").encode(text))
    
    print(f"OpenAI tokens: {cl100k_tokens}")
    print(f"E5 tokens: {e5_tokens}")
    return cl100k_tokens <= max_tokens

2. RAG场景中的实际应用

def process_rag_document(text, chunk_size=500):
    """
    处理RAG系统中的文档，同时考虑不同模型的token数量
    """
    results = {}
    
    # OpenAI Large模型 (如GPT-4)
    oai_large = tiktoken.get_encoding("cl100k_base")
    large_tokens = oai_large.encode(text)
    
    # OpenAI Small模型 (如早期GPT-3)
    oai_small = tiktoken.get_encoding("p50k_base")
    small_tokens = oai_small.encode(text)
    
    # E5 Embedding模型
    e5_tokenizer = AutoTokenizer.from_pretrained("intfloat/multilingual-e5-base")
    e5_tokens = e5_tokenizer.encode(text)
    
    results["large_model"] = len(large_tokens)
    results["small_model"] = len(small_tokens)
    results["e5_model"] = len(e5_tokens)
    
    print(f"Large Model Tokens: {results['large_model']}")
    print(f"Small Model Tokens: {results['small_model']}")
    print(f"E5 Model Tokens: {results['e5_model']} (含特殊tokens)")
    
    return results

# 测试混合语言场景
text = """
RAG系统处理中英文混合文本：
The history of Suzhou (苏州) spans over 2,500 years.
它是中国最古老的城市之一，以园林闻名于世。
"""

token_counts = process_rag_document(text)

Key-Value计数实践

在RAG系统中，我们经常需要处理key和value的token数量：

def analyze_kv_tokens(key, value):
    """
    分析RAG系统中key和value的token数量
    """
    # OpenAI分析
    oai_tokenizer = tiktoken.get_encoding("cl100k_base")
    key_tokens_oai = oai_tokenizer.encode(key)
    value_tokens_oai = oai_tokenizer.encode(value)
    
    # E5分析
    e5_tokenizer = AutoTokenizer.from_pretrained("intfloat/multilingual-e5-base")
    key_tokens_e5 = e5_tokenizer.encode(key)
    value_tokens_e5 = e5_tokenizer.encode(value)
    
    print("OpenAI Token分析:")
    print(f"Key tokens: {len(key_tokens_oai)}")
    print(f"Value tokens: {len(value_tokens_oai)}")
    print(f"Total: {len(key_tokens_oai) + len(value_tokens_oai)}")
    
    print("\nE5 Token分析 (含特殊tokens):")
    print(f"Key tokens: {len(key_tokens_e5)}")
    print(f"Value tokens: {len(value_tokens_e5)}")
    print(f"Total: {len(key_tokens_e5) + len(value_tokens_e5)}")

# 测试示例
key = "What is the significance of Suzhou's gardens?"
value = """
The classical gardens of Suzhou were added to the UNESCO World Heritage List.
These gardens represent the development of Chinese landscape garden design
over more than 2,000 years.
"""

analyze_kv_tokens(key, value)

"""
典型输出差异：
1. E5会在key和value各自添加特殊tokens
2. OpenAI对相同文本的token数通常较少
3. 中英文混合时差异更明显
"""

最佳实践

token计数考虑因素
- 对于OpenAI API调用，使用cl100k_base计算token数
- 对于E5 embedding，需考虑特殊tokens的额外开销
- 中文文本通常每个字符占用一个token

混合场景处理

def get_token_counts(text):
    counts = {}
    # OpenAI
    counts["openai"] = len(tiktoken.get_encoding("cl100k_base").encode(text))
    # E5
    counts["e5"] = len(AutoTokenizer.from_pretrained("intfloat/multilingual-e5-base").encode(text))
    return counts

长度控制建议
- 预留特殊tokens的空间
- 考虑不同tokenizer的差异
- 在截断时注意保持语义完整性
多语言文本注意事项
- 确保使用支持目标语言的tokenizer
- 注意不同语言的token密度差异
- 混合语言文本可能需要特殊处理

2025-08-11

RAG pipeline的各项技术调研

本文将针对RAG(Retrieval-Augmented Generation) pipeline的各个关键技术组件进行深入调研，通过分析优质的技术文章和实践经验，为搭建高效的RAG系统提供理论基础和技术指导。

1.Why use RAG?
Traditionally, a base model is trained with point-in-time data to ensure its effectiveness in performing specific tasks and adapting to the desired domain. However, sometimes you need to work with newer or more current data. Two approaches can supplement the base model: fine-tuning or further training of the base model with new data, or RAG that uses prompt engineering to supplement or guide the model in real time.