LLM推理加速：量化、蒸馏、KV缓存的实战应用

老张2026/9/9大约 22 分钟推理加速量化模型蒸馏KV缓存Java工程师

LLM推理加速：量化、蒸馏、KV缓存的实战应用

从3秒到0.8秒：一次痛苦的本地部署之旅

2025年7月，北京某金融科技公司的Java工程师王浩接到了一个任务：在内网服务器上部署一套本地LLM，处理敏感的金融文本分析，数据不能出网。

他选了Llama3 70B，配了两张A100 80G显卡，满心期待地跑了第一个请求——等了18秒，才看到回复。

产品经理拍着桌子说："用户哪能等这么久，3秒都嫌慢！"

王浩开始了漫长的调优之旅。他先换了更小的Llama3 8B——速度快了，但回答质量下降太明显，业务验收不通过。然后他开始研究量化……

最终结果：

模型：Llama3 8B Q4_K_M量化版
显存占用：从16GB降到5.5GB
首Token延迟：从1.8秒降到0.6秒
吞吐量（tokens/s）：从42升到158
单服务器月成本：从12000元降到4800元

速度提升了近4倍，成本降低了60%。这不是魔法，是工程优化。

LLM推理慢的根本原因：内存带宽瓶颈

很多人以为LLM推理慢是因为"计算量太大"，但这个判断只对了一半。

真正的瓶颈是内存带宽，不是算力。

让我用一个类比来解释：

想象你是一家餐厅的厨师（GPU计算单元），你的刀工非常快（算力充足）。但问题是：食材库（显存/内存）在另一栋楼，每次做菜都需要服务员（内存带宽）来回搬运食材。服务员的速度成了瓶颈，而不是你的刀工。

在LLM推理中：

GPU算力：A100有312 TFLOPS的FP16算力，非常充足
显存带宽：A100显存带宽2TB/s，听起来很快，但模型参数太多
每次生成1个token：需要将模型全部参数从显存加载到计算单元

以Llama3 70B为例：

FP16精度：70B × 2字节 = 140GB参数
每生成1个token：需要读取140GB数据
A100带宽2TB/s：理论最快也要 140GB / 2000GB/s = 70ms/token

这就是为什么量化能显著提速——不是因为减少了计算量，而是因为减少了内存读取量。

量化技术：用类比理解INT8和INT4

什么是量化？

量化就是用更低精度的数字来表示模型参数，从而减少内存占用和带宽消耗。

类比：照片压缩

FP32精度：原始RAW格式，每个像素32位，文件100MB
FP16精度：高质量JPEG，每个像素16位，文件50MB，几乎看不出区别
INT8量化：中等压缩JPEG，每个像素8位，文件25MB，仔细看有轻微模糊
INT4量化：高压缩JPEG，每个像素4位，文件12.5MB，能明显感受到质量下降

关键点： 人眼看照片可以接受一定的质量损失；LLM对参数精度同样有一定容忍度——毕竟语言生成本身就有随机性，轻微的数值误差不会改变答案的方向。

量化的数学直觉（无公式版）

想象你要记录温度数据，范围是-50°C到+50°C：

FP32：精确到小数点后7位，比如23.4567891°C
INT8：只能表示256个不同值，精确到约0.4°C，比如23.5°C
INT4：只能表示16个不同值，精确到约6.25°C，比如25°C

模型参数也是类似的——绝大多数参数的值集中在很小的范围内，用低精度表示会有误差，但误差在可接受范围内。

关键技术区别

量化类型	精度损失	内存节省	适用场景
FP16	极小	50%	生产优先保质量
INT8（W8A8）	小	75%	生产环境平衡点
INT4（Q4）	中等	87.5%	本地部署优先速度
INT4混合	较小	85%左右	本地部署最佳选择

Ollama量化模型选择：Q4_K_M vs Q8_0

命名规范解读

Ollama使用GGUF格式，命名规则：模型名:参数量-量化类型

Q4_K_M：4位量化，K-quants方式，Medium规格
Q8_0：8位量化，标准方式
Q5_K_M：5位量化，K-quants方式，Medium规格

K-quants是什么？

K-quants（K-量化）是GGUF的一种改进量化方案。它不是对所有参数统一量化，而是对重要的参数用更高精度，对不重要的参数用低精度。这样在相同的文件大小下，质量比标准量化更好。

实测性能数据

测试环境：Apple M2 Ultra（192GB统一内存），Ollama v0.3.x，Llama3.1 8B

量化版本	文件大小	内存占用	速度(tok/s)	主观质量
FP16	16.1GB	18.2GB	38 tok/s	100%
Q8_0	8.5GB	9.8GB	68 tok/s	99%
Q6_K	6.1GB	7.4GB	89 tok/s	98.5%
Q5_K_M	5.3GB	6.6GB	102 tok/s	97%
Q4_K_M	4.7GB	5.9GB	124 tok/s	96%
Q4_0	4.5GB	5.7GB	128 tok/s	93%
Q3_K_M	3.5GB	4.8GB	152 tok/s	88%
Q2_K	2.8GB	4.1GB	178 tok/s	78%

结论：Q4_K_M是本地部署的最佳平衡点

Q8_0：质量最好，但速度只有Q4_K_M的55%，适合质量优先场景
Q4_K_M：96%质量保留，速度提升3倍+，绝大多数场景的最优选择
Q2_K：质量损失超过20%，只在极度内存受限时考虑

Spring AI集成Ollama

// OllamaConfig.java
package com.laozhang.ai.config;

import org.springframework.ai.ollama.OllamaChatClient;
import org.springframework.ai.ollama.api.OllamaApi;
import org.springframework.ai.ollama.api.OllamaOptions;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class OllamaConfig {

    /**
     * 配置Ollama客户端
     * 
     * 生产建议：
     * - 本地高质量场景：llama3.1:8b-instruct-q8_0
     * - 本地速度优先：llama3.1:8b-instruct-q4_K_M
     * - 服务器A100场景：直接用FP16，走vLLM
     */
    @Bean
    public OllamaChatClient ollamaChatClient() {
        OllamaApi ollamaApi = new OllamaApi("http://localhost:11434");
        
        OllamaOptions options = OllamaOptions.create()
            .withModel("llama3.1:8b-instruct-q4_K_M")
            .withTemperature(0.7f)
            .withNumCtx(4096)       // 上下文窗口大小（影响显存）
            .withNumGpu(35)         // GPU层数，-1表示全部offload到GPU
            .withNumThread(8)       // CPU线程数（混合推理时）
            .withRepeatPenalty(1.1f)
            .withTopP(0.9f);
        
        return new OllamaChatClient(ollamaApi, options);
    }
}

// OllamaInferenceService.java
package com.laozhang.ai.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.StreamingChatClient;
import org.springframework.ai.chat.messages.*;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

import java.util.List;

@Slf4j
@Service
@RequiredArgsConstructor
public class OllamaInferenceService {

    private final ChatClient ollamaChatClient;
    private final StreamingChatClient streamingOllamaClient;

    /**
     * 同步推理（适合批处理）
     */
    public String inference(String systemPrompt, String userMessage) {
        long start = System.currentTimeMillis();
        
        ChatResponse response = ollamaChatClient.call(
            new Prompt(List.of(
                new SystemMessage(systemPrompt),
                new UserMessage(userMessage)
            ))
        );
        
        long latency = System.currentTimeMillis() - start;
        String content = response.getResult().getOutput().getContent();
        
        log.info("Ollama inference: latency={}ms, tokens={}", 
            latency, 
            response.getMetadata().getUsage() != null 
                ? response.getMetadata().getUsage().getTotalTokens() 
                : "unknown");
        
        return content;
    }

    /**
     * 流式推理（适合实时交互）
     */
    public Flux<String> streamInference(String systemPrompt, String userMessage) {
        return streamingOllamaClient.stream(
            new Prompt(List.of(
                new SystemMessage(systemPrompt),
                new UserMessage(userMessage)
            ))
        ).map(response -> 
            response.getResult().getOutput().getContent()
        ).filter(content -> content != null && !content.isEmpty());
    }
}

KV缓存：最容易被忽视的性能金矿

什么是KV缓存？

在Transformer架构中，每次生成token时，模型需要"回看"之前所有的token。这个"回看"操作产生的中间结果（Key和Value矩阵），如果每次都重新计算，就是极大的浪费。

KV缓存就是把这些中间结果存下来，下次直接复用。

类比：你在查字典，每查一个词都要从第一页翻起——太慢了。KV缓存相当于你在书签上记下常用词的页码，下次直接跳过去。

System Prompt缓存的巨大价值

在AI应用中，System Prompt通常是固定的（定义AI的角色、能力、约束）。如果每次对话都重新计算System Prompt的KV缓存，是极大的浪费。

实测数据（GPT-4o，System Prompt 2000 tokens）：

场景	首Token延迟	成本
无缓存	2.1秒	$0.0030/请求
System Prompt缓存命中	0.6秒	$0.00075/请求
提升	71.4%↓	75%↓

前缀缓存（Prefix Caching）实现

// PrefixCacheService.java
package com.laozhang.ai.service;

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.messages.*;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.stereotype.Service;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.time.Duration;
import java.util.*;

@Slf4j
@Service
public class PrefixCacheService {

    private final ChatClient chatClient;
    
    /**
     * System Prompt的KV缓存映射
     * Key: System Prompt的Hash
     * Value: 对应的cached_prompt_tokens（供API传递）
     * 
     * 注意：这里的"缓存"不是存储结果，而是标记哪些System Prompt
     * 已经在AI服务侧缓存，以便传递cache_control标志
     */
    private final Cache<String, CachedPromptInfo> systemPromptCache = 
        Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterAccess(Duration.ofHours(1))
            .build();
    
    /**
     * 对话前缀缓存
     * Key: 对话历史的Hash（前N轮）
     * Value: 上一次的响应（避免重复生成）
     */
    private final Cache<String, String> responseCache = 
        Caffeine.newBuilder()
            .maximumSize(5000)
            .expireAfterWrite(Duration.ofMinutes(30))
            .build();

    public PrefixCacheService(ChatClient chatClient) {
        this.chatClient = chatClient;
    }

    /**
     * 带前缀缓存的聊天调用
     * 
     * 策略：
     * 1. 计算System Prompt + 历史消息的Hash
     * 2. 如果有完全匹配的缓存，直接返回（精确缓存）
     * 3. 如果System Prompt匹配，发送时携带cache_control标志（OpenAI/Anthropic支持）
     * 4. 记录新的缓存条目
     */
    public String chatWithPrefixCache(
            String systemPrompt, 
            List<ChatMessage> history,
            String userMessage) {
        
        // 构建完整消息列表
        List<Message> messages = new ArrayList<>();
        messages.add(new SystemMessage(systemPrompt));
        history.forEach(h -> {
            if (h.getRole().equals("user")) {
                messages.add(new UserMessage(h.getContent()));
            } else {
                messages.add(new AssistantMessage(h.getContent()));
            }
        });
        messages.add(new UserMessage(userMessage));
        
        // 计算缓存Key（不含最后一条用户消息的Hash）
        String prefixHash = hashMessages(messages.subList(0, messages.size() - 1));
        
        // 检查响应缓存（完全相同的对话）
        String fullHash = prefixHash + hashString(userMessage);
        String cachedResponse = responseCache.getIfPresent(fullHash);
        if (cachedResponse != null) {
            log.debug("Prefix cache hit (full match): {}", fullHash.substring(0, 8));
            return cachedResponse;
        }
        
        // 调用AI（System Prompt会在AI服务侧被缓存）
        long start = System.currentTimeMillis();
        String response = chatClient.call(new Prompt(messages))
            .getResult().getOutput().getContent();
        long latency = System.currentTimeMillis() - start;
        
        log.info("AI call: latency={}ms, systemPromptCached={}", 
            latency, systemPromptCache.getIfPresent(hashString(systemPrompt)) != null);
        
        // 标记System Prompt已缓存
        systemPromptCache.put(hashString(systemPrompt), 
            new CachedPromptInfo(systemPrompt, System.currentTimeMillis()));
        
        // 存储响应到前缀缓存
        responseCache.put(fullHash, response);
        
        return response;
    }

    /**
     * 计算消息列表的Hash（用于缓存Key）
     */
    private String hashMessages(List<Message> messages) {
        StringBuilder sb = new StringBuilder();
        messages.forEach(m -> sb.append(m.getClass().getSimpleName())
            .append(":").append(m.getContent()).append("|"));
        return hashString(sb.toString());
    }

    private String hashString(String input) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(input.getBytes(StandardCharsets.UTF_8));
            return HexFormat.of().formatHex(hash).substring(0, 16);
        } catch (Exception e) {
            return String.valueOf(input.hashCode());
        }
    }

    record CachedPromptInfo(String prompt, long cachedAt) {}
}

OpenAI Prompt Caching（官方支持）

// OpenAiPromptCachingService.java
package com.laozhang.ai.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.openai.OpenAiChatClient;
import org.springframework.ai.openai.OpenAiChatOptions;
import org.springframework.ai.chat.messages.*;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.stereotype.Service;

import java.util.List;

@Slf4j
@Service
@RequiredArgsConstructor
public class OpenAiPromptCachingService {

    private final OpenAiChatClient openAiChatClient;

    /**
     * OpenAI Prompt Caching最佳实践
     * 
     * 关键规则（OpenAI官方说明）：
     * 1. 缓存是自动的，无需特殊API调用
     * 2. 前缀至少1024个tokens才会触发缓存
     * 3. System Prompt放在消息列表最前面（稳定的前缀）
     * 4. 用户特定内容放在后面（变化的部分）
     * 
     * 成本：
     * - 缓存命中的prompt tokens：正常价格的50%
     * - 实测：固定2000 token的system prompt，命中率95%后成本降低约40%
     */
    public String callWithOptimizedCaching(
            String systemPrompt,       // 稳定，会被缓存
            String ragContext,         // 相对稳定，可能被缓存
            String userMessage) {     // 变化，不缓存
        
        // 正确的消息顺序：稳定内容在前，变化内容在后
        // OpenAI会自动缓存最长的稳定前缀
        String combinedSystem = systemPrompt + "\n\n## 参考资料\n" + ragContext;
        
        List<Message> messages = List.of(
            new SystemMessage(combinedSystem),  // 放前面，会被缓存
            new UserMessage(userMessage)         // 放后面，每次变化
        );
        
        OpenAiChatOptions options = OpenAiChatOptions.builder()
            .withModel("gpt-4o")
            .withTemperature(0.7f)
            // 可以通过metadata查看缓存命中情况
            .build();
        
        var response = openAiChatClient.call(
            new Prompt(messages, options)
        );
        
        // 检查缓存命中（通过usage信息）
        var usage = response.getMetadata().getUsage();
        if (usage != null) {
            log.info("Token usage - prompt: {}, completion: {}, cached: {}",
                usage.getPromptTokens(),
                usage.getCompletionTokens(),
                // OpenAI返回cached_tokens字段
                usage.getMetadata().getOrDefault("cached_tokens", "unknown")
            );
        }
        
        return response.getResult().getOutput().getContent();
    }
}

批处理推理：OpenAI Batch API的成本优化

对于不需要实时响应的任务（文章分类、批量摘要、离线分析），OpenAI Batch API提供50%折扣，24小时内完成处理。

// BatchInferenceService.java
package com.laozhang.ai.service;

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.io.*;
import java.nio.file.*;
import java.util.*;

@Slf4j
@Service
@RequiredArgsConstructor
public class BatchInferenceService {

    private final RestTemplate restTemplate;
    private final ObjectMapper objectMapper;
    
    @Value("${spring.ai.openai.api-key}")
    private String apiKey;

    /**
     * 提交批量推理任务
     * 
     * 适用场景：
     * - 每天夜间批量分析文章质量（10000篇/天）
     * - 离线生成所有文章的摘要
     * - 批量提取文章关键词
     * 
     * 成本对比（以10000次GPT-4o调用为例）：
     * - 实时API：$30/万次
     * - Batch API：$15/万次（50%折扣）
     * - 每月节省：约$450（按5万次/月算）
     */
    public String submitBatchJob(List<BatchRequest> requests) throws IOException {
        // 1. 构建JSONL文件（每行一个请求）
        Path tempFile = Files.createTempFile("batch_", ".jsonl");
        
        try (BufferedWriter writer = Files.newBufferedWriter(tempFile)) {
            for (BatchRequest request : requests) {
                BatchJobLine line = BatchJobLine.builder()
                    .customId(request.getId())
                    .method("POST")
                    .url("/v1/chat/completions")
                    .body(BatchJobBody.builder()
                        .model("gpt-4o")
                        .messages(List.of(
                            Map.of("role", "system", "content", request.getSystemPrompt()),
                            Map.of("role", "user", "content", request.getUserMessage())
                        ))
                        .maxTokens(1000)
                        .build())
                    .build();
                
                writer.write(objectMapper.writeValueAsString(line));
                writer.newLine();
            }
        }
        
        // 2. 上传文件到OpenAI Files API
        String fileId = uploadFile(tempFile);
        log.info("Uploaded batch file: {}", fileId);
        
        // 3. 创建Batch Job
        String batchId = createBatch(fileId);
        log.info("Created batch job: {}", batchId);
        
        // 清理临时文件
        Files.deleteIfExists(tempFile);
        
        return batchId;
    }

    /**
     * 查询批量任务状态
     * 建议：定时任务每30分钟查询一次
     */
    public BatchStatus getBatchStatus(String batchId) {
        String url = "https://api.openai.com/v1/batches/" + batchId;
        
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(apiKey);
        
        ResponseEntity<Map> response = restTemplate.exchange(
            url, HttpMethod.GET, new HttpEntity<>(headers), Map.class
        );
        
        Map<String, Object> body = response.getBody();
        return BatchStatus.builder()
            .id(batchId)
            .status((String) body.get("status"))
            .requestCounts((Map<String, Integer>) body.get("request_counts"))
            .outputFileId((String) body.get("output_file_id"))
            .build();
    }

    /**
     * 获取批量任务结果
     */
    public List<BatchResult> getBatchResults(String outputFileId) throws IOException {
        String url = "https://api.openai.com/v1/files/" + outputFileId + "/content";
        
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(apiKey);
        
        ResponseEntity<String> response = restTemplate.exchange(
            url, HttpMethod.GET, new HttpEntity<>(headers), String.class
        );
        
        List<BatchResult> results = new ArrayList<>();
        for (String line : response.getBody().split("\n")) {
            if (!line.isBlank()) {
                Map<String, Object> parsed = objectMapper.readValue(line, Map.class);
                String customId = (String) parsed.get("custom_id");
                
                Map<String, Object> responseBody = 
                    (Map<String, Object>) parsed.get("response");
                Map<String, Object> responseBodyInner = 
                    (Map<String, Object>) responseBody.get("body");
                List<Map<String, Object>> choices = 
                    (List<Map<String, Object>>) responseBodyInner.get("choices");
                
                String content = (String) 
                    ((Map<String, Object>) choices.get(0).get("message")).get("content");
                
                results.add(BatchResult.builder()
                    .customId(customId)
                    .content(content)
                    .build());
            }
        }
        
        return results;
    }

    private String uploadFile(Path filePath) {
        // 文件上传逻辑（省略具体HTTP实现）
        // 实际使用时可以用OkHttp的MultipartBody
        return "file-xxxx";
    }

    private String createBatch(String inputFileId) {
        String url = "https://api.openai.com/v1/batches";
        
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(apiKey);
        headers.setContentType(MediaType.APPLICATION_JSON);
        
        Map<String, Object> body = Map.of(
            "input_file_id", inputFileId,
            "endpoint", "/v1/chat/completions",
            "completion_window", "24h",
            "metadata", Map.of("description", "Daily article analysis batch")
        );
        
        ResponseEntity<Map> response = restTemplate.exchange(
            url, HttpMethod.POST, 
            new HttpEntity<>(body, headers), 
            Map.class
        );
        
        return (String) response.getBody().get("id");
    }

    // DTO类
    @lombok.Builder
    @lombok.Data
    public static class BatchRequest {
        String id;
        String systemPrompt;
        String userMessage;
    }

    @lombok.Builder
    @lombok.Data
    public static class BatchResult {
        String customId;
        String content;
    }

    @lombok.Builder
    @lombok.Data
    public static class BatchStatus {
        String id;
        String status;
        Map<String, Integer> requestCounts;
        String outputFileId;
    }
    
    @lombok.Builder
    @lombok.Data
    static class BatchJobLine {
        @com.fasterxml.jackson.annotation.JsonProperty("custom_id")
        String customId;
        String method;
        String url;
        BatchJobBody body;
    }
    
    @lombok.Builder
    @lombok.Data
    static class BatchJobBody {
        String model;
        List<Map<String, String>> messages;
        @com.fasterxml.jackson.annotation.JsonProperty("max_tokens")
        Integer maxTokens;
    }
}

模型蒸馏：大模型蒸馏到小模型

模型蒸馏是指用大模型（Teacher）的输出来训练小模型（Student），让小模型学习大模型的"思维方式"。

蒸馏工程实践

// DistillationDataCollector.java
package com.laozhang.ai.distillation;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.openai.OpenAiChatClient;
import org.springframework.ai.chat.messages.*;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.stereotype.Service;

import java.util.*;
import java.io.*;
import java.nio.file.*;

/**
 * 从大模型收集训练数据，用于微调小模型
 * 
 * 典型蒸馏流程：
 * 1. 设计高质量的任务样本（输入）
 * 2. 用GPT-4o生成对应的高质量输出
 * 3. 过滤低质量样本（自动评分）
 * 4. 用收集的数据集微调Llama3/Qwen等小模型
 * 5. 在业务任务上评估小模型是否达标
 * 6. 达标则切换到小模型（成本降低10-100倍）
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class DistillationDataCollector {

    private final OpenAiChatClient teacherModel;  // GPT-4o作为Teacher

    /**
     * 收集蒸馏训练数据
     * 用于代码审查场景：用GPT-4o生成高质量代码审查数据
     * 然后微调Llama3 8B，让小模型学会代码审查
     */
    public void collectDistillationData(
            List<String> codeSnippets, 
            Path outputPath) throws IOException {
        
        String systemPrompt = """
            你是一位资深Java工程师，专注于代码质量审查。
            对给定的代码片段，请给出：
            1. 代码质量评分（1-10）
            2. 主要问题（如果有）
            3. 具体改进建议
            4. 改进后的代码示例
            
            回答格式：
            评分：X/10
            问题：...
            建议：...
            改进代码：
            ```java
            ...
            ```
            """;
        
        List<Map<String, String>> dataset = new ArrayList<>();
        
        for (String code : codeSnippets) {
            try {
                // 用Teacher模型生成高质量输出
                String review = teacherModel.call(
                    new Prompt(List.of(
                        new SystemMessage(systemPrompt),
                        new UserMessage("请审查以下代码：\n\n```java\n" + code + "\n```")
                    ))
                ).getResult().getOutput().getContent();
                
                // 质量过滤：检查输出是否包含必要字段
                if (isHighQualityResponse(review)) {
                    dataset.add(Map.of(
                        "instruction", systemPrompt,
                        "input", code,
                        "output", review
                    ));
                    log.debug("Collected sample: {} chars", review.length());
                }
                
                // 防止速率限制
                Thread.sleep(100);
                
            } catch (Exception e) {
                log.error("Failed to collect sample", e);
            }
        }
        
        // 输出为JSONL格式（微调框架通用格式）
        saveAsJsonl(dataset, outputPath);
        log.info("Collected {} training samples, saved to {}", dataset.size(), outputPath);
    }

    /**
     * 质量过滤：确保训练数据达到标准
     */
    private boolean isHighQualityResponse(String response) {
        return response.contains("评分：") 
            && response.contains("建议：") 
            && response.length() > 200
            && response.contains("```java");
    }

    private void saveAsJsonl(List<Map<String, String>> data, Path path) throws IOException {
        try (BufferedWriter writer = Files.newBufferedWriter(path)) {
            for (Map<String, String> item : data) {
                // 转为Alpaca格式（通用微调格式）
                Map<String, Object> alpacaFormat = Map.of(
                    "instruction", item.get("instruction"),
                    "input", item.get("input"),
                    "output", item.get("output")
                );
                writer.write(new com.fasterxml.jackson.databind.ObjectMapper()
                    .writeValueAsString(alpacaFormat));
                writer.newLine();
            }
        }
    }
}

Speculative Decoding：投机解码的加速原理

投机解码是一种让大模型"提速而不降质"的技巧，原理有点反直觉但非常有趣。

类比：老师检查作业

传统解码：老师（大模型）逐字写出每个字→极慢

投机解码：

助手（小模型）先快速写出一段答案（5个token）
老师（大模型）一次性检查这5个token对不对
如果都对：直接接受，老师继续往后预测
如果某个token错了：从错误处重新由老师生成
关键：大模型验证5个token比生成5个token快（因为可以并行）

在vLLM中启用Speculative Decoding

// VllmInferenceClient.java
package com.laozhang.ai.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.List;
import java.util.Map;

/**
 * vLLM推理客户端
 * vLLM支持Speculative Decoding，通过配置参数启用
 */
@Slf4j
@Service
public class VllmInferenceClient {

    private final RestTemplate restTemplate;
    private final String vllmBaseUrl;

    public VllmInferenceClient(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
        this.vllmBaseUrl = "http://localhost:8000";
    }

    /**
     * 调用vLLM（支持Speculative Decoding）
     * 
     * vLLM启动命令（开启Speculative Decoding）：
     * python -m vllm.entrypoints.openai.api_server \
     *   --model llama3.1-70b \
     *   --speculative-model llama3.1-1b \  # Draft模型用小模型
     *   --num-speculative-tokens 5 \        # 每次投机5个token
     *   --tensor-parallel-size 4
     * 
     * 实测加速效果：
     * - 无Speculative：45 tok/s
     * - 开启Speculative (1B draft)：92 tok/s（2x加速）
     * - 开启Speculative (7B draft)：78 tok/s（1.7x加速，质量更接近原模型）
     */
    public String inference(String systemPrompt, String userMessage) {
        String url = vllmBaseUrl + "/v1/chat/completions";
        
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        
        Map<String, Object> requestBody = Map.of(
            "model", "llama3.1-70b",
            "messages", List.of(
                Map.of("role", "system", "content", systemPrompt),
                Map.of("role", "user", "content", userMessage)
            ),
            "temperature", 0.7,
            "max_tokens", 2000
            // Speculative Decoding在服务端配置，客户端无需特殊参数
        );
        
        ResponseEntity<Map> response = restTemplate.exchange(
            url, HttpMethod.POST,
            new HttpEntity<>(requestBody, headers),
            Map.class
        );
        
        var choices = (List<Map<String, Object>>) response.getBody().get("choices");
        var message = (Map<String, Object>) choices.get(0).get("message");
        return (String) message.get("content");
    }
}

Java工程师视角：推理加速的工程决策框架

面对"我要加速LLM推理"这个问题，Java工程师需要一个系统性的决策思路：

各方案成本收益速查表

方案	实施成本	速度提升	质量影响	推荐场景
Q4_K_M量化	低（换模型文件）	3x	-4%	本地部署首选
Batch API	低（改调用方式）	N/A	0	离线任务
前缀缓存	低（代码调整）	预填充70%↓	0	System Prompt长
Speculative Decoding	中（需两个模型）	2x	<1%	vLLM部署
模型蒸馏	高（需标注+训练）	5-10x	10-20%	特定垂直领域

综合优化代码示例

// InferenceOptimizationService.java
package com.laozhang.ai.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.*;

@Slf4j
@Service
@RequiredArgsConstructor
public class InferenceOptimizationService {

    private final PrefixCacheService prefixCacheService;
    private final BatchInferenceService batchInferenceService;
    
    // 请求合并窗口（毫秒）
    private static final long BATCH_WINDOW_MS = 50;
    
    // 待处理请求队列
    private final BlockingQueue<PendingRequest> pendingQueue = 
        new LinkedBlockingQueue<>(1000);
    
    // 后台批处理线程
    private final ScheduledExecutorService batchScheduler = 
        Executors.newScheduledThreadPool(1, r -> {
            Thread t = new Thread(r, "batch-inference-scheduler");
            t.setDaemon(true);
            return t;
        });

    /**
     * 智能推理分发
     * 根据请求特征自动选择最优策略
     */
    public CompletableFuture<String> smartInference(InferenceRequest request) {
        // 策略1：完全重复的请求（相同prompt）→ 返回缓存
        String cacheKey = buildCacheKey(request);
        // ... 缓存检查逻辑
        
        // 策略2：非实时任务 → 加入批处理队列
        if (!request.isRealtime()) {
            return submitToBatchQueue(request);
        }
        
        // 策略3：实时任务 → 前缀缓存 + 直接调用
        return CompletableFuture.supplyAsync(() -> 
            prefixCacheService.chatWithPrefixCache(
                request.getSystemPrompt(),
                request.getHistory(),
                request.getUserMessage()
            )
        );
    }

    private CompletableFuture<String> submitToBatchQueue(InferenceRequest request) {
        CompletableFuture<String> future = new CompletableFuture<>();
        pendingQueue.offer(new PendingRequest(request, future));
        return future;
    }

    private String buildCacheKey(InferenceRequest request) {
        return request.getSystemPrompt().hashCode() + "_" 
            + request.getUserMessage().hashCode();
    }

    record PendingRequest(InferenceRequest request, CompletableFuture<String> future) {}
}

FAQ

Q：量化会影响代码生成质量吗？

A：会有轻微影响，但通常在可接受范围内。实测中，Q4_K_M在代码生成任务上的HumanEval评分比FP16低约5-8%。如果你的场景对代码质量极为敏感，建议用Q8_0（质量损失<1%，速度也提升近2倍）。

Q：KV缓存和前缀缓存是同一个东西吗？

A：不完全一样。KV缓存是模型推理的底层机制（Transformer的注意力计算缓存）；前缀缓存是应用层的优化（跨请求复用相同前缀的计算结果）。两者都很重要，但层次不同。

Q：Batch API的24小时等待时间在实际使用中是否可接受？

A：要分场景。对于文章标签生成、离线质量评估、历史数据分析等任务，24小时完全可接受。对于实时用户交互，当然不行。建议将任务明确分类，能Batch的坚决Batch，成本节省非常显著。

Q：vLLM和Ollama怎么选？

A：场景不同，选择不同。开发/测试/个人使用：Ollama（配置简单，一键启动）。生产部署/多并发：vLLM（支持连续批处理，吞吐量比Ollama高3-5倍）。有A100/H100：vLLM + Tensor Parallel；消费级GPU或无GPU：Ollama足够。

Q：模型蒸馏需要多少训练数据？

A：取决于任务复杂度。实践中，针对特定垂直领域的蒸馏，500-2000条高质量样本通常就能让8B小模型在该领域达到70B模型90%左右的效果。关键在于样本质量而非数量——用GPT-4o生成样本，再用GPT-4o评分过滤，确保训练数据质量。

总结

王浩最终把项目中LLM推理性能优化总结成了一张清单，贴在工位上：

先分析瓶颈：是内存带宽（换量化模型）还是网络延迟（换更快的API）还是并发（用vLLM）
能缓存必缓存：System Prompt缓存是成本最低、收益最高的优化
离线任务必Batch：Batch API 50%折扣，每月能省几千块
本地部署选Q4_K_M：96%质量，3倍速度，是最佳平衡点
有GPU上vLLM：比Ollama吞吐高3-5倍，支持Speculative Decoding

从18秒到0.8秒，不是一步完成的，是一项一项优化叠加的结果。工程优化从来如此。

附录：推理加速完整工具链

本地部署工具对比

工具	适用场景	安装复杂度	并发能力	推荐度
Ollama	开发/测试/个人	极简（一键）	低	⭐⭐⭐⭐⭐
LM Studio	桌面GUI	极简	低	⭐⭐⭐⭐
vLLM	生产服务器	中等	高	⭐⭐⭐⭐⭐
llama.cpp	嵌入式/ARM	需要编译	低	⭐⭐⭐
TensorRT-LLM	NVIDIA GPU生产	复杂	极高	⭐⭐⭐⭐

量化模型快速下载命令

# 安装Ollama（macOS/Linux）
curl -fsSL https://ollama.com/install.sh | sh

# 下载常用量化模型（根据硬件选择）
# 8GB内存以上推荐 - 质量和速度的最佳平衡
ollama pull llama3.1:8b-instruct-q4_K_M

# 16GB内存推荐 - 更高质量
ollama pull llama3.1:8b-instruct-q8_0

# 代码专用模型（Java工程师强烈推荐）
ollama pull codestral:22b-v0.1-q4_K_M   # 代码生成
ollama pull deepseek-coder-v2:16b-lite-instruct-q4_K_M

# 中文优化模型
ollama pull qwen2.5:7b-instruct-q4_K_M

# 验证安装
ollama run llama3.1:8b-instruct-q4_K_M "你好，用一句话自我介绍"

vLLM生产部署启动脚本

#!/bin/bash
# start-vllm.sh - 生产级vLLM启动脚本

MODEL_PATH="/models/llama3.1-70b"
MODEL_NAME="llama3.1-70b"

# 基础启动（单GPU）
python -m vllm.entrypoints.openai.api_server \
  --model ${MODEL_PATH} \
  --served-model-name ${MODEL_NAME} \
  --host 0.0.0.0 \
  --port 8000 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.90

# 多GPU + Speculative Decoding（推荐生产配置）
python -m vllm.entrypoints.openai.api_server \
  --model ${MODEL_PATH} \
  --served-model-name ${MODEL_NAME} \
  --tensor-parallel-size 4 \          # 4张GPU并行
  --speculative-model /models/llama3.1-1b \  # Draft模型
  --num-speculative-tokens 5 \
  --gpu-memory-utilization 0.85 \
  --max-model-len 16384 \
  --enable-prefix-caching \           # 开启前缀缓存
  --disable-log-requests \            # 生产环境关闭请求日志
  --host 0.0.0.0 \
  --port 8000

Spring AI连接本地vLLM

// VllmChatConfig.java
package com.laozhang.ai.config;

import org.springframework.ai.openai.OpenAiChatClient;
import org.springframework.ai.openai.OpenAiChatOptions;
import org.springframework.ai.openai.api.OpenAiApi;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration
@Profile("local-llm")  // 本地部署时激活
public class VllmChatConfig {

    /**
     * vLLM兼容OpenAI API，可以直接用OpenAI客户端连接
     * 只需要修改base-url即可
     */
    @Bean
    public OpenAiChatClient vllmChatClient() {
        // vLLM的OpenAI兼容端点
        OpenAiApi openAiApi = new OpenAiApi(
            "http://localhost:8000",  // vLLM地址
            "not-needed"              // vLLM本地不需要API Key
        );

        OpenAiChatOptions options = OpenAiChatOptions.builder()
            .withModel("llama3.1-70b")  // 与vLLM启动时的served-model-name一致
            .withTemperature(0.7f)
            .withMaxTokens(2048)
            .build();

        return new OpenAiChatClient(openAiApi, options);
    }
}

# application-local-llm.yml
spring:
  ai:
    openai:
      base-url: http://localhost:8000
      api-key: not-needed
      chat:
        options:
          model: llama3.1-70b
          temperature: 0.7

推理性能监控

// InferenceMetricsCollector.java
package com.laozhang.ai.monitoring;

import io.micrometer.core.instrument.*;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 推理性能监控
 *
 * 关键指标：
 * - TTFT (Time To First Token)：首Token延迟，用户感知最重要
 * - TPS (Tokens Per Second)：吞吐量
 * - 缓存命中率：前缀缓存的效果
 * - 成本/千token：实际花费追踪
 */
@Slf4j
@Aspect
@Component
@RequiredArgsConstructor
public class InferenceMetricsCollector {

    private final MeterRegistry meterRegistry;
    private final AtomicLong totalTokensGenerated = new AtomicLong(0);
    private final AtomicLong totalCacheHits = new AtomicLong(0);
    private final AtomicLong totalCacheMisses = new AtomicLong(0);

    /**
     * 拦截所有AI调用，自动记录延迟和token数
     */
    @Around("execution(* org.springframework.ai.chat.ChatClient.call(..))")
    public Object monitorInference(ProceedingJoinPoint pjp) throws Throwable {
        long startTime = System.currentTimeMillis();

        Object result = pjp.proceed();

        long latencyMs = System.currentTimeMillis() - startTime;

        // 记录延迟
        Timer.builder("llm.inference.latency")
            .tag("type", "sync")
            .register(meterRegistry)
            .record(Duration.ofMillis(latencyMs));

        // 延迟分级告警
        if (latencyMs > 10000) {
            log.error("CRITICAL: LLM inference extremely slow: {}ms", latencyMs);
        } else if (latencyMs > 3000) {
            log.warn("SLOW: LLM inference took {}ms", latencyMs);
        }

        return result;
    }

    /**
     * 记录Token统计（每日汇总，用于成本追踪）
     */
    public void recordTokenUsage(int promptTokens, int completionTokens, boolean cacheHit) {
        totalTokensGenerated.addAndGet(completionTokens);

        if (cacheHit) {
            totalCacheHits.incrementAndGet();
        } else {
            totalCacheMisses.incrementAndGet();
        }

        // Prometheus指标
        Counter.builder("llm.tokens.prompt")
            .register(meterRegistry)
            .increment(promptTokens);

        Counter.builder("llm.tokens.completion")
            .register(meterRegistry)
            .increment(completionTokens);

        // 缓存命中率
        double hitRate = totalCacheHits.get() * 1.0 /
            Math.max(1, totalCacheHits.get() + totalCacheMisses.get());

        Gauge.builder("llm.cache.hit.rate", this, c -> hitRate)
            .register(meterRegistry);
    }

    /**
     * 每小时打印推理性能摘要
     */
    public void printHourlySummary() {
        log.info("""
            === LLM推理性能小时摘要 ===
            总生成Token数：{}
            缓存命中次数：{}
            缓存命中率：{:.1f}%
            """,
            totalTokensGenerated.get(),
            totalCacheHits.get(),
            totalCacheHits.get() * 100.0 /
                Math.max(1, totalCacheHits.get() + totalCacheMisses.get())
        );
    }
}