基于SpringAI的智能OPS平台开发前置技能FAISS

从零开始：基于Spring Boot + FAISS + 通义千问的本地知识库问答系统

https://github.com/facebookresearch/faiss

一、什么是矢量数据库？

在开始项目之前，我们先来了解一个核心概念：矢量数据库（Vector Database）。

1. 基本概念

• 矢量（Vector）：将文本、图像、音频等非结构化数据转换为的数值数组
• 矢量嵌入（Vector Embedding）：将原始数据映射到矢量空间的过程
• 矢量数据库：专门用于存储、索引和检索矢量数据的数据库

2. 核心优势

• 语义相似性搜索：能够理解内容的语义，找到真正相关的结果
• 高效检索：即使在海量数据中，也能快速找到相似向量
• 多模态支持：可以处理文本、图像、音频等多种数据类型

3. 典型应用

• 智能问答系统
• 推荐系统
• 图像搜索
• 语音识别

二、项目概览：本地知识库问答系统

1. 项目目标

构建一个基于本地文档的智能问答系统，能够：

• 加载本地文档（TXT/MD格式）
• 将文档转换为矢量存储
• 接收用户查询并找到相关文档
• 利用大模型生成基于文档的回答

2. 技术栈

• Spring Boot 3.2.5：后端框架
• Java 17：开发语言
• 通义千问API：大语言模型
• FAISS（模拟实现）：矢量数据库
• RESTful API：对外接口
• Swagger：API文档

3. 项目结构

src/main/java/com/example/ai/
├── api/                # 接口层
│   └── rest/           # REST API控制器
├── application/        # 应用层
│   └── query/          # 查询服务
├── domain/             # 领域层
│   ├── model/          # 领域模型
│   └── service/        # 领域服务
└── infrastructure/     # 基础设施层
    ├── document/       # 文档加载
    ├── llm/            # 大模型客户端
    └── vectorstore/    # 矢量存储

三、核心组件解析

1. FAISS矢量存储实现（FaissVectorStore.java）

作用：负责存储和检索文档矢量

@Component
@Slf4j
public class FaissVectorStore {
    @Value("${spring.ai.faiss.dimension}")
    private int dimension;  // 矢量维度

    @Value("${spring.ai.faiss.index-path}")
    private String indexPath;  // 索引路径

    // 内存存储（模拟FAISS）
    private Map<String, VectorizedDocument> documentMap;

    // 添加文档
    public void add(List<VectorizedDocument> documents) {
        // 验证向量维度
        // 存储文档
        log.info("向量存储新增{}个向量文档，当前总量：{}", count, documentMap.size());
    }

    // 搜索相似文档
    public List<VectorizedDocument> search(float[] queryVector, int topK) {
        // 计算欧几里得距离
        // 按相似度排序
        // 返回前topK个结果
        log.info("向量存储检索到{}个相似文档", results.size());
    }

    // 欧几里得距离算法
    private double calculateEuclideanDistance(float[] vector1, float[] vector2) {
        double sum = 0.0;
        for (int i = 0; i < vector1.length; i++) {
            double diff = vector1[i] - vector2[i];
            sum += diff * diff;
        }
        return Math.sqrt(sum);
    }
}

关键算法：

• 欧几里得距离：计算两个向量之间的直线距离，用于衡量相似度
• 相似度排序：按距离升序排列，距离越小越相似

2. 通义千问客户端（TongyiQwenLlmClient.java）

作用：调用通义千问API生成回答

@Component
public class TongyiQwenLlmClient {
    @Value("${spring.ai.tongyi.api-key}")
    private String apiKey;

    @Value("${spring.ai.tongyi.model}")
    private String model;

    public String generateAnswer(String prompt) {
        Generation generation = new Generation();
        
        // 构造消息列表
        List<Message> messages = new ArrayList<>();
        messages.add(Message.builder()
                .role("system")
                .content("你是一个智能问答助手，请基于提供的参考文档回答用户问题")
                .build());
        messages.add(Message.builder()
                .role("user")
                .content(prompt)
                .build());
        
        // 构造请求参数
        GenerationParam param = GenerationParam.builder()
                .apiKey(apiKey)
                .model(model)
                .messages(messages)
                .build();
        
        // 调用API
        GenerationResult result = generation.call(param);
        return result.getOutput().getText();
    }
}

3. 文档查询服务（DocumentQueryService.java）

作用：协调各个组件完成问答流程

@Service
public class DocumentQueryService {
    private final DocumentVectorService vectorService;
    private final KnowledgeRetrievalService retrievalService;
    private final TongyiQwenLlmClient tongyiClient;

    // 初始化知识库
    public void initKnowledgeBase(String filePath) {
        // 加载本地文档
        // 矢量转换
        // 存储到矢量数据库
    }

    // 处理查询
    public QueryResponse query(QueryRequest request) {
        // 1. 将查询转换为向量
        float[] queryVector = generateQueryVector(request.getQuestion());
        
        // 2. 搜索相似文档
        List<VectorizedDocument> similarDocs = retrievalService.retrieveSimilar(
                queryVector, request.getTopK()
        );
        
        // 3. 构建提示词
        String prompt = buildPrompt(request.getQuestion(), similarDocs);
        
        // 4. 生成回答
        String answer = tongyiClient.generateAnswer(prompt);
        
        // 5. 返回结果
        return new QueryResponse(answer, referenceDocs, time);
    }
}

4. REST API接口（DocumentQueryController.java）

作用：对外提供接口服务

@RestController
@RequestMapping("/api/v1/query")
public class DocumentQueryController {
    private final DocumentQueryService queryService;

    // 初始化知识库
    @PostMapping("/init")
    public ResponseEntity<String> initKnowledgeBase(@RequestParam String filePath) {
        queryService.initKnowledgeBase(filePath);
        return ResponseEntity.ok("知识库初始化成功");
    }

    // 智能问答
    @PostMapping
    public ResponseEntity<QueryResponse> query(@Valid @RequestBody QueryRequest request) {
        QueryResponse response = queryService.query(request);
        return ResponseEntity.ok(response);
    }
}

四、业务流程详解

1. 知识库初始化流程

用户上传本地文档 → DocumentVectorService加载文档 → 转换为矢量 → FaissVectorStore存储矢量

2. 智能问答流程

用户提问 → 转换为查询矢量 → FaissVectorStore搜索相似文档 → 构建带参考文档的提示词 → 通义千问生成回答 → 返回结果

3. 组件协作关系

┌─────────────────┐     ┌─────────────────────┐     ┌─────────────────────┐
│ DocumentQuery   │     │ KnowledgeRetrieval  │     │  FaissVectorStore   │
│   Controller    │────▶│     Service         │────▶│  (Vector Database)  │
└─────────────────┘     └─────────────────────┘     └─────────────────────┘
           │                         │
           │                         ▼
           ▼                 ┌─────────────────┐
┌─────────────────┐          │ DocumentVector  │
│ DocumentQuery   │          │     Service     │
│    Service      │◀─────────┘                 └────────┐
└─────────────────┘                                     │
           │                                             │
           ▼                                             │
┌─────────────────┐          ┌─────────────────┐        │
│ TongyiQwenLlm   │◀─────────┤ LocalDocument   │◀───────┘
│    Client       │          │     Loader      │
└─────────────────┘          └─────────────────┘

五、配置与部署

1. 配置文件（application.yml）

spring:
  application:
    name: spring-ai-faiss-tongyi-demo
  ai:
    tongyi:
      api-key: sk-xxxxxxxxxxxxxxxxxxxxxxxx  # 你的通义千问API密钥
      model: qwen-turbo
    faiss:
      index-path: ./faiss-index
      dimension: 1536  # 向量维度

server:
  port: 8087

springdoc:
  api-docs:
    path: /api-docs
  swagger-ui:
    path: /swagger-ui.html

2. 启动项目

mvn spring-boot:run

3. 访问API文档

打开浏览器访问：http://localhost:8087/swagger-ui.html

六、使用指南

1. 初始化知识库

curl -X POST "http://localhost:8087/api/v1/query/init?filePath=/path/to/your/documents"

2. 智能问答

curl -X POST "http://localhost:8087/api/v1/query" \
  -H "Content-Type: application/json" \
  -d '{
    "question": "什么是矢量数据库？",
    "topK": 3
  }'

3. 响应示例

{
  "answer": "矢量数据库是专门用于存储、索引和检索矢量数据的数据库...",
  "referenceDocs": [
    "矢量数据库基本概念...",
    "矢量数据库核心优势...",
    "矢量数据库典型应用..."
  ],
  "responseTime": 2500
}

七、进阶扩展

1. 替换为真实FAISS

当前项目使用的是模拟FAISS实现，可以很容易地替换为真实FAISS：

<!-- 在pom.xml中添加依赖 -->
<dependency>
    <groupId>com.facebook.faiss</groupId>
    <artifactId>faiss-java</artifactId>
    <version>1.7.3</version>
</dependency>

2. 优化搜索算法

可以尝试不同的相似度算法：

• 余弦相似度（Cosine Similarity）
• 点积（Dot Product）
• 曼哈顿距离（Manhattan Distance）

3. 添加文档预处理

• 文本分割
• 去噪处理
• 关键词提取

八、总结

通过这个项目，我们学习了：

1. 矢量数据库的基本概念：矢量、矢量嵌入、相似度搜索
2. 完整的智能问答系统架构：从前端接口到后端服务
3. 各组件之间的协作关系：文档加载、矢量转换、相似搜索、回答生成
4. 实际应用场景：如何将矢量数据库应用于本地知识库问答

这个项目是一个很好的入门案例，展示了矢量数据库在实际应用中的价值。你可以基于此继续扩展，添加更多功能，如多文档格式支持、文档管理界面、性能优化等。

希望这篇教程能帮助你快速上手矢量数据库和智能问答系统的开发！

九、源码地址

GitHub链接：spring-ai-faiss-tongyi-demo

阿里云 DashScope Embedding 模型深度对比与应用指南

📊 完整特性对比表

维度	text-embedding-v1	text-embedding-v2	text-embedding-ada-002	embedding-v1
模型类型	阿里云自研基础版	阿里云自研增强版	OpenAI 兼容版	阿里云轻量版
向量维度	1536	1536	1536	768/1536（可选）
输入长度	512 tokens	512 tokens	512 tokens	512 tokens
API 端点	text-embedding-v1	text-embedding-v2	text-embedding-ada-002	embedding-v1
价格（元/百万tokens）	0.6	1.2	0.8	0.4
QPS 限制	默认 50	默认 50	默认 50	默认 100
语义理解精度	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐
推理速度	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
多语言支持	中英文优化	中英文优化	英文优化	中英文优化
多义词处理	中等	优秀	良好	基础
复杂句式理解	中等	优秀	良好	基础
长文本分段	支持	支持	支持	支持
批量处理	支持	支持	支持	支持
微调支持	不支持	支持	不支持	不支持
推荐并发数	10-20	5-10	10-20	20-50

🔍 各模型详细特性分析

1. text-embedding-v1 - 经济实用型

优点：
  - ✅ 成本效益最高，适合大规模部署
  - ✅ 1536维向量，平衡性能与存储
  - ✅ 对通用中文场景优化良好
  - ✅ API响应稳定，文档齐全

缺点：
  - ❌ 对专业术语理解有限
  - ❌ 复杂逻辑关系可能丢失
  - ❌ 不提供置信度分数

适用场景：
  - 文档检索（如知识库、FAQ）
  - 简单语义相似度计算
  - 用户查询意图识别
  - 内容去重

2. text-embedding-v2 - 精准专业型

核心改进：
  - ✅ 多义词消歧能力提升 30%
  - ✅ 复杂句式理解能力提升 40%
  - ✅ 支持上下文感知嵌入
  - ✅ 提供置信度分数（可选）

技术特点：
  - 采用 Transformer-XL 架构增强
  - 引入注意力机制优化
  - 在专业领域（医疗、法律、金融）表现优异
  - 支持 zero-shot 小样本学习

适用场景：
  - 高精度智能问答系统
  - 法律条文相似性匹配
  - 医疗诊断文本分析
  - 学术论文查重与推荐
  - 复杂意图识别

3. text-embedding-ada-002 - 平滑迁移型

兼容特性：
  - ✅ 完全兼容 OpenAI API 格式
  - ✅ 向量空间与 OpenAI 对齐
  - ✅ 无需修改现有代码
  - ✅ 价格比 OpenAI 低 20-30%

技术细节：
  - 维度：1536（与 OpenAI 一致）
  - 余弦相似度计算完全兼容
  - 支持相同的输入长度（512 tokens）
  - 输出格式：JSON 数组

迁移场景：
  - 从 OpenAI 迁移到阿里云
  - 多供应商容灾备份
  - 成本优化项目
  - 需要与 OpenAI 结果对比验证

4. embedding-v1 - 高并发轻量型

性能优势：
  - ✅ 推理延迟 < 20ms（P95）
  - ✅ 支持 768/1536 维可选
  - ✅ 高并发支持（100+ QPS）
  - ✅ 内存占用减少 40%

优化策略：
  - 量化压缩技术
  - 蒸馏学习模型
  - 硬件加速优化
  - 批量处理优化

适用场景：
  - 实时推荐系统
  - 高频搜索服务
  - 流式数据处理
  - 边缘计算场景
  - 大规模短文本去重

⚡ 性能测试数据对比

延迟测试（单请求）

text-embedding-v1:
  - P50: 45ms
  - P95: 120ms
  - P99: 200ms

text-embedding-v2:
  - P50: 65ms
  - P95: 150ms
  - P99: 250ms

text-embedding-ada-002:
  - P50: 50ms
  - P95: 130ms
  - P99: 220ms

embedding-v1 (768维):
  - P50: 15ms
  - P95: 35ms
  - P99: 60ms

embedding-v1 (1536维):
  - P50: 25ms
  - P95: 50ms
  - P99: 90ms

精度测试（MS MARCO 数据集）

NDCG@10 评分:
  - text-embedding-v2: 0.842
  - text-embedding-v1: 0.798
  - text-embedding-ada-002: 0.812
  - embedding-v1 (1536维): 0.775
  - embedding-v1 (768维): 0.712

🎯 模型选择决策树

是
否
是
否
是
否
开始选择
场景需求?
高精度需求
成本敏感型
OpenAI迁移
高并发需求
专业领域?
text-embedding-v2

精度最高
text-embedding-v1

平衡性价比
text-embedding-v1

性价比最优
需要完全兼容?
text-embedding-ada-002

零代码修改
text-embedding-v1

更经济
需要高精度?
embedding-v1 1536维

平衡性能与精度
embedding-v1 768维

极致性能

🔧 Spring AI 集成配置

1. Maven 依赖配置

<!-- 阿里云 DashScope SDK -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dashscope-sdk-java</artifactId>
    <version>2.13.0</version>
</dependency>

<!-- Spring AI 阿里云适配器 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-alibaba-dashscope-spring-boot-starter</artifactId>
    <version>0.8.1</version>
</dependency>

2. 多模型配置示例

spring:
  ai:
    dashscope:
      api-key: ${DASHSCOPE_API_KEY}
      embedding:
        # 多模型配置
        models:
          v1:
            name: text-embedding-v1
            enabled: true
            dimensions: 1536
          v2:
            name: text-embedding-v2
            enabled: true
            dimensions: 1536
          ada:
            name: text-embedding-ada-002
            enabled: true
            dimensions: 1536
          light:
            name: embedding-v1
            enabled: true
            dimensions: 768  # 或 1536
        
        # 默认模型
        default-model: text-embedding-v1
        
        # 超时配置
        connection-timeout: 10s
        read-timeout: 30s
        
        # 重试配置
        retry:
          max-attempts: 3
          backoff:
            initial-interval: 1s
            multiplier: 2.0
            max-interval: 10s

3. 智能模型路由服务

@Service
@Slf4j
public class SmartEmbeddingRouter {
    
    @Autowired
    private Map<String, EmbeddingClient> embeddingClients;
    
    @Value("${spring.ai.dashscope.embedding.default-model:text-embedding-v1}")
    private String defaultModel;
    
    /**
     * 智能选择模型
     */
    public EmbeddingClient selectModel(EmbeddingRequest request) {
        // 1. 根据文本长度选择
        if (request.getText().length() < 50) {
            return embeddingClients.get("embedding-v1-light");  // 短文本用轻量版
        }
        
        // 2. 根据内容类型选择
        if (isProfessionalContent(request.getText())) {
            return embeddingClients.get("text-embedding-v2");  // 专业内容用v2
        }
        
        // 3. 根据优先级选择
        if (request.getPriority() == Priority.HIGH) {
            return embeddingClients.get("text-embedding-v2");
        } else if (request.getPriority() == Priority.LOW) {
            return embeddingClients.get("embedding-v1");
        }
        
        // 4. 默认选择
        return embeddingClients.get(defaultModel);
    }
    
    /**
     * 模型降级策略
     */
    public EmbeddingClient getFallbackModel(String primaryModel) {
        Map<String, String> fallbackMap = Map.of(
            "text-embedding-v2", "text-embedding-v1",
            "text-embedding-v1", "embedding-v1",
            "text-embedding-ada-002", "text-embedding-v1",
            "embedding-v1", "text-embedding-v1"
        );
        
        String fallback = fallbackMap.getOrDefault(primaryModel, defaultModel);
        return embeddingClients.get(fallback);
    }
}

4. 模型性能监控配置

@Configuration
@Slf4j
public class EmbeddingMonitorConfig {
    
    @Bean
    public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
        return registry -> registry.config().commonTags(
            "application", "aiops-embedding-service"
        );
    }
    
    @Bean
    public TimedAspect timedAspect(MeterRegistry registry) {
        return new TimedAspect(registry);
    }
    
    @Bean
    public EmbeddingMetrics embeddingMetrics(MeterRegistry registry) {
        return new EmbeddingMetrics(registry);
    }
}

@Component
@RequiredArgsConstructor
public class EmbeddingMetrics {
    
    private final MeterRegistry meterRegistry;
    private final Map<String, Timer> modelTimers = new ConcurrentHashMap<>();
    private final Map<String, Counter> errorCounters = new ConcurrentHashMap<>();
    
    public Timer getTimer(String modelName) {
        return modelTimers.computeIfAbsent(modelName, name -> 
            Timer.builder("embedding.latency")
                .tag("model", name)
                .publishPercentiles(0.5, 0.95, 0.99)
                .register(meterRegistry)
        );
    }
    
    public void recordSuccess(String modelName, long duration) {
        getTimer(modelName).record(duration, TimeUnit.MILLISECONDS);
        Counter.builder("embedding.success")
            .tag("model", modelName)
            .register(meterRegistry)
            .increment();
    }
    
    public void recordError(String modelName, String errorType) {
        Counter errorCounter = errorCounters.computeIfAbsent(
            modelName + "." + errorType,
            key -> Counter.builder("embedding.errors")
                .tag("model", modelName)
                .tag("error", errorType)
                .register(meterRegistry)
        );
        errorCounter.increment();
    }
}

🎯 最佳实践建议

场景化模型选择矩阵

应用场景	推荐模型	备选模型	关键考量
智能客服问答	text-embedding-v2	text-embedding-v1	准确率 > 成本
文档搜索引擎	text-embedding-v1	embedding-v1	大规模、性价比
实时推荐系统	embedding-v1 (768维)	text-embedding-v1	延迟敏感
OpenAI迁移项目	text-embedding-ada-002	text-embedding-v1	兼容性
专业领域分析	text-embedding-v2	定制微调	专业精度
内容去重系统	embedding-v1	text-embedding-v1	计算效率

成本优化策略

@Service
public class CostOptimizationService {
    
    // 1. 分层存储策略
    public EmbeddingClient getCostEffectiveModel(String useCase) {
        Map<String, String> costMapping = Map.of(
            "real-time-search", "embedding-v1-768",      // 实时搜索：用轻量版
            "batch-processing", "text-embedding-v1",     // 批量处理：用基础版
            "high-accuracy", "text-embedding-v2",        // 高精度：用增强版
            "migration", "text-embedding-ada-002"       // 迁移：用兼容版
        );
        return getEmbeddingClient(costMapping.getOrDefault(useCase, "text-embedding-v1"));
    }
    
    // 2. 缓存策略
    @Cacheable(value = "embeddings", key = "#text.hashCode() + '#' + #modelName")
    public List<Double> getCachedEmbedding(String text, String modelName) {
        return embeddingService.getEmbedding(text, modelName);
    }
    
    // 3. 批量处理优化
    public List<List<Double>> batchProcess(List<String> texts, String modelName) {
        // 按长度分组，短文本用轻量模型
        Map<Boolean, List<String>> partitioned = texts.stream()
            .collect(Collectors.partitioningBy(t -> t.length() <= 100));
        
        List<List<Double>> results = new ArrayList<>();
        if (!partitioned.get(true).isEmpty()) {
            results.addAll(processWithModel(partitioned.get(true), "embedding-v1"));
        }
        if (!partitioned.get(false).isEmpty()) {
            results.addAll(processWithModel(partitioned.get(false), modelName));
        }
        return results;
    }
}

生产环境配置建议

# application-prod.yml
spring:
  ai:
    dashscope:
      # 生产环境API Key
      api-key: ${DASHSCOPE_API_KEY_PROD}
      
      # 连接池配置
      connection-pool:
        max-total: 100
        default-max-per-route: 20
        validate-after-inactivity: 5000
        
      # 模型熔断配置
      circuit-breaker:
        enabled: true
        failure-threshold: 5
        timeout: 30000
        reset-timeout: 60000
        
      # 监控配置
      monitoring:
        enabled: true
        metrics-prefix: "dashscope.embedding"
        slow-query-threshold: 1000
        
      # 多模型权重路由
      model-routing:
        default-weight: 100
        models:
          - name: text-embedding-v1
            weight: 40
            max-concurrent: 20
          - name: text-embedding-v2
            weight: 30
            max-concurrent: 10
          - name: embedding-v1
            weight: 30
            max-concurrent: 50

🚨 常见问题排查

1. 权限问题

# 错误：{"code":"AccessDenied","message":"The specified service is not found."}
# 解决方案：
# 1. 在阿里云控制台开通 DashScope 服务
# 2. 确保 API Key 有足够权限
# 3. 检查模型是否在当前区域可用

2. 模型版本问题

# 如果调用失败，检查模型名：
正确: "text-embedding-v1"
错误: "text-embedding-v1.0"  # 不要加版本后缀

# 可用模型列表查询：
curl -X GET "https://dashscope.aliyuncs.com/api/v1/models" \
  -H "Authorization: Bearer ${DASHSCOPE_API_KEY}"

3. 性能调优

// 1. 调整批量大小
@Bean
public EmbeddingClient embeddingClient() {
    DashScopeEmbeddingOptions options = DashScopeEmbeddingOptions.builder()
        .withModel("text-embedding-v1")
        .withBatchSize(32)  // 根据网络和内存调整
        .withTimeout(Duration.ofSeconds(30))
        .build();
    return new DashScopeEmbeddingClient(options);
}

// 2. 启用 HTTP2
@Bean
public WebClient webClient() {
    return WebClient.builder()
        .clientConnector(new ReactorClientHttpConnector(
            HttpClient.create()
                .protocol(HttpProtocol.H2)
                .compress(true)
        ))
        .build();
}

📈 监控指标看板示例

# Prometheus 监控指标
metrics:
  embedding:
    - name: embedding_request_duration_seconds
      help: Embedding request duration in seconds
      type: histogram
      labels: [model, status]
    
    - name: embedding_request_total
      help: Total embedding requests
      type: counter
      labels: [model, result]
    
    - name: embedding_tokens_total
      help: Total tokens processed
      type: counter
      labels: [model]
    
    - name: embedding_cost_usd
      help: Estimated cost in USD
      type: counter
      labels: [model]

# Grafana 看板建议面板
dashboard:
  panels:
    - title: "模型调用延迟 (P95)"
      query: 'histogram_quantile(0.95, rate(embedding_request_duration_seconds_bucket[5m]))'
    
    - title: "各模型调用分布"
      query: 'rate(embedding_request_total[5m])'
    
    - title: "预计成本/小时"
      query: 'sum(rate(embedding_cost_usd[1h]))'
    
    - title: "错误率"
      query: 'sum(rate(embedding_request_total{result="error"}[5m])) / sum(rate(embedding_request_total[5m]))'

这个完整的对比指南包含了从技术特性到生产实践的所有关键信息，您可以根据具体业务需求选择合适的模型。建议在预生产环境进行性能测试，确定最适合您场景的模型组合。