大模型量化部署实战:GGUF格式转换与llama.cpp本地推理配置

GGUF(GPT-Generated Unified Format)是llama.cpp团队推出的模型文件格式,替代早期的GGML格式,支持大语言模型在消费级硬件上运行。模型量化通过降低参数精度(从FP16到INT4/INT8),大幅减少显存占用和推理延迟,使7B-70B参数规模模型在单张显卡甚至CPU上完成推理。

GGUF格式原理与量化级别选择

GGUF将模型权重、词表、超参数打包为单一文件,支持mmap内存映射加载,避免完整加载到内存。量化级别从高到低:

  • Q8_0:8位量化,精度损失极小,体积约为FP16的50%
  • Q5_K_M:5位量化,体积约为FP16的35%,精度损失可接受
  • Q4_K_M:4位量化,体积约为FP16的28%,推理速度快,部署最常用
  • Q3_K_M:3位量化,体积约FP16的22%,精度损失明显,仅适合资源极端受限场景

选型建议:7B模型选Q4_K_M即可在8GB显存GPU运行;13B模型选Q4_K_M需要12GB显存;70B模型在Q4_K_M下需要约40GB显存,多卡部署或使用CPU+GPU混合推理。

模型转换:从HuggingFace到GGUF格式

使用llama.cpp提供的convert_hf_to_gguf.py脚本完成转换:

# 克隆llama.cpp
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

# 安装Python依赖
pip install -r requirements.txt

# 转换HuggingFace模型为GGUF格式(FP16)
python convert_hf_to_gguf.py /path/to/hf-model \
    --outtype f16 \
    --outfile model-f16.gguf

# 量化为Q4_K_M
./llama-quantize model-f16.gguf model-q4km.gguf Q4_K_M

转换过程读取HuggingFace格式的safetensors权重文件,重新排列为llama.cpp内部张量布局,再按指定量化算法压缩。Q4_K_M采用k-quants混合量化策略,对注意力层和前馈层使用不同量化精度,在压缩率和模型质量间取得平衡。

llama.cpp编译与推理配置

编译支持CUDA加速的llama.cpp:

mkdir build && cd build
cmake .. -DGGML_CUDA=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release -j

启动推理服务:

./llama-server \
    -m model-q4km.gguf \
    --port 8080 \
    --n-gpu-layers 35 \
    --ctx-size 4096 \
    --batch-size 512 \
    --temp 0.7 \
    --top-p 0.9

关键参数说明:

  • --n-gpu-layers:卸载到GPU的层数,设为模型总层数则全部在GPU计算
  • --ctx-size:上下文窗口长度,影响显存占用
  • --batch-size:prompt处理批大小,增大可加速预填充阶段
  • --temp:温度参数,控制输出随机性

性能对比与部署建议

以Llama-3-8B模型为例,在RTX 4060(8GB VRAM)上的测试数据:

量化级别 模型体积 显存占用 生成速度(tokens/s) 质量评分
F16 15.0 GB 超出显存 100%
Q8_0 8.1 GB 7.8 GB 28 99%
Q4_K_M 4.4 GB 5.2 GB 45 96%
Q3_K_M 3.5 GB 4.3 GB 52 90%

部署建议:生产环境优先选Q4_K_M或Q5_K_M,在推理速度和质量间取得平衡。如果显存充裕,Q8_0几乎无损。CPU推理场景使用Q4_K_M配合--threads参数设置物理核数,AVX2指令集可加速2-3倍。

原创文章,作者:小编,如若转载,请注明出处:https://www.yunthe.com/da-mo-xing-liang-hua-bu-shu-shi-zhan-gguf-ge-shi-zhuan-huan/

(0)
小编小编
上一篇 4天前
下一篇 4天前

相关推荐

大模型量化部署实战:GGUF格式转换与llama.cpp本地推理配置指南

大模型量化部署是AI模型部署链条中的关键环节。GGUF(GPT-Generated Unified Format)作为llama.cpp生态的标准模型格式,支持从2-bit到8-bit多种量化精度,能够在消费级显卡甚至纯CPU环境下运行百亿参数级大模型。本文围绕GGUF格式转换、llama.cpp编译配置、量化模型推理服务部署展开实战操作。

GGUF量化格式原理与量化精度选择

GGUF替代了早期的GGML格式,采用键值对存储元数据与张量信息,支持mmap内存映射加载,大幅减少启动时间。量化策略直接决定推理速度与显存占用的平衡点。

常用量化等级对比:

  • Q4_K_M:4-bit量化,体积约为原始模型的25%,精度损失可控,适合7B-13B模型在8GB显存GPU上运行
  • Q5_K_M:5-bit量化,精度优于Q4,体积约为原始模型30%,适合对输出质量要求较高的场景
  • Q8_0:8-bit量化,精度接近FP16,体积约为原始模型50%,适合显存充裕时追求最佳推理质量
  • Q2_K:2-bit极致量化,体积仅原始模型15%,适合纯CPU环境或内存受限设备

实际部署中,7B模型推荐Q4_K_M,13B模型在16GB显存下选Q4_K_M,32B及以上模型在24GB显存下选Q3_K_M或Q4_K_S。

llama.cpp编译安装与GPU加速配置

从源码编译llama.cpp以启用CUDA或Metal加速。Linux环境下CUDA编译流程:

# 克隆仓库
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# CUDA加速编译
make GGML_CUDA=1 -j$(nproc)

# 验证编译结果
./llama-cli --help

# CPU纯推理编译(无GPU环境)
make -j$(nproc)

macOS环境下启用Metal加速:

make GGML_METAL=1 -j$(nproc)

编译完成后,核心可执行文件包括llama-cli(命令行推理)、llama-server(HTTP API服务)、llama-quantize(模型量化工具)。

模型量化转换操作流程

使用llama.cpp自带的convert_hf_to_gguf.py脚本将HuggingFace格式模型转换为GGUF格式,再执行量化。以Qwen2.5-7B-Instruct为例:

# 安装依赖
pip install -r requirements/requirements-convert_hf_to_gguf.txt

# 转换为FP16 GGUF
python convert_hf_to_gguf.py /path/to/Qwen2.5-7B-Instruct \
    --outfile qwen2.5-7b-fp16.gguf \
    --outtype f16

# 执行Q4_K_M量化
./llama-quantize qwen2.5-7b-fp16.gguf qwen2.5-7b-q4_k_m.gguf Q4_K_M

# 验证量化模型
./llama-cli -m qwen2.5-7b-q4_k_m.gguf -p "你好,请自我介绍" -n 128

量化过程中终端会输出每层张量的量化误差统计,关注perplexity变化幅度,通常Q4_K_M的困惑度上升不超过原始模型的2%。

本地推理服务部署与API调用

llama-server提供兼容OpenAI API格式的HTTP接口,可直接对接下游应用:

# 启动推理服务
./llama-server \
    -m qwen2.5-7b-q4_k_m.gguf \
    --host 0.0.0.0 \
    --port 8080 \
    -ngl 28 \
    -c 4096 \
    --alias qwen2.5-7b

# 参数说明:
# -ngl 28:将28层offload到GPU(7B模型共32层)
# -c 4096:上下文窗口大小
# --alias:API调用时使用的模型名称

使用curl调用聊天接口:

curl http://localhost:8080/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "qwen2.5-7b",
        "messages": [
            {"role": "user", "content": "用Python实现快速排序算法"}
        ],
        "temperature": 0.7,
        "max_tokens": 512
    }'

推理性能调优与显存优化

实际部署中影响吞吐量的核心参数:

  • -ngl:GPU层数offload,显存足够时设为模型总层数可获得最佳速度,显存不足时逐步降低
  • -c:上下文长度,每增加1024 token约多占用显存,7B Q4模型每1024 token约占0.5GB
  • -b:批处理大小,增大可提升prompt评估速度,但增加显存占用
  • –flash-attn:启用Flash Attention,减少KV Cache显存占用约30%

使用llama-bench工具量化评估不同参数组合的性能表现:

./llama-bench -m qwen2.5-7b-q4_k_m.gguf -ngl 28 -p 512 -n 128

输出包含prompt评估速度(tokens/s)和生成速度(tokens/s),作为参数调优的基准数据。在RTX 4060 Ti 16GB环境下,Q4_K_M量化的7B模型通常可达30-45 tokens/s的生成速度,满足大多数交互式推理场景的需求。

原创文章,作者:小编,如若转载,请注明出处:https://www.yunthe.com/da-mo-xing-liang-hua-bu-shu-shi-zhan-gguf-ge-shi-zhuan-huan/

(0)
小编小编
上一篇 2026年8月25日
下一篇 2026年8月25日

相关推荐

大模型量化部署实战:GGUF格式转换与Ollama本地推理配置指南

为什么需要对大模型做量化处理

GPU显存不足是本地部署大模型遇到的首要障碍。一个7B参数的模型在FP16精度下需要约14GB显存,70B模型则需要140GB,远超消费级显卡的承载能力。量化(Quantization)通过降低权重精度来压缩模型体积,4-bit量化后7B模型仅需约4GB显存即可运行,代价是微小的精度损失,但推理速度反而因为显存带宽压力降低而提升。

当前主流的量化方案有GPTQ、AWQ和GGUF三种。GPTQ和AWQ适合GPU推理场景,GGUF则专为CPU+GPU混合推理设计,在Ollama、llama.cpp等框架中广泛支持,是本地部署的首选格式。

GGUF格式转换:从HuggingFace到量化模型

GGUF是llama.cpp项目定义的二进制模型格式,支持从2-bit到8-bit多种量化级别。转换流程分为两步:下载原始模型,执行格式转换与量化。

步骤一:安装转换工具链

# 克隆llama.cpp仓库
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# 安装Python依赖
pip install -r requirements.txt
pip install gguf

步骤二:下载HuggingFace模型

以Qwen2-7B-Instruct为例:

# 安装huggingface-cli
pip install huggingface-hub

# 下载模型到本地
huggingface-cli download Qwen/Qwen2-7B-Instruct \
    --local-dir ./Qwen2-7B-Instruct \
    --local-dir-use-symlinks False

步骤三:执行GGUF转换与量化

# 第一步:转换为GGUF F16格式(中间格式)
python convert_hf_to_gguf.py ./Qwen2-7B-Instruct \
    --outtype f16 \
    --outfile ./Qwen2-7B-Instruct-f16.gguf

# 第二步:量化为Q4_K_M(推荐的4-bit量化级别)
./llama-quantize ./Qwen2-7B-Instruct-f16.gguf \
    ./Qwen2-7B-Instruct-Q4_K_M.gguf Q4_K_M

常用量化级别对比:

| 量化级别 | 位宽 | 7B模型体积 | 精度损失 | 推理速度 |
|———|——|———–|———|———|
| Q8_0 | 8-bit | ~7.7GB | 极小 | 快 |
| Q5_K_M | 5-bit | ~5.3GB | 小 | 较快 |
| Q4_K_M | 4-bit | ~4.4GB | 中等 | 快 |
| Q3_K_M | 3-bit | ~3.5GB | 较大 | 最快 |

Q4_K_M在体积和精度之间取得了最佳平衡,适合大多数场景。如果显存充裕且对输出质量要求高,选Q5_K_M或Q8_0。

Ollama部署与本地推理配置

Ollama封装了llama.cpp的核心能力,提供一条命令完成模型加载和推理的完整体验。

安装Ollama

# Linux
curl -fsSL https://ollama.com/install.sh | sh

# macOS
brew install ollama

# 启动服务
ollama serve

导入自定义GGUF模型

Ollama支持从本地GGUF文件创建模型,需要编写Modelfile:

# 创建Modelfile
cat > Modelfile <<'EOF'
FROM ./Qwen2-7B-Instruct-Q4_K_M.gguf

PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096

TEMPLATE "{{{- if .System }}}{{ .System }}{{ end }}
{{ .Prompt }}}}"
EOF

# 创建模型
ollama create qwen2-7b-local -f Modelfile

验证模型运行

# 命令行推理
ollama run qwen2-7b-local "用Python实现一个快速排序算法"

# API调用
curl http://localhost:11434/api/generate -d '{
  "model": "qwen2-7b-local",
  "prompt": "解释什么是GGUF格式",
  "stream": false
}'

GPU加速与显存管理

Ollama默认将模型层分配到GPU显存中,超出显存容量的层自动回退到CPU内存。在多GPU环境下,Ollama按顺序分配层到不同GPU。

查看GPU使用情况:

# 查看Ollama运行状态
ollama ps

# NVIDIA显存监控
nvidia-smi --query-gpu=memory.used,memory.total --format=csv -l 5

当模型超过单张GPU显存时,有两个策略:

1. 降低量化级别:从Q4_K_M降到Q3_K_M,牺牲精度换取显存空间
2. 设置GPU层数限制:强制部分层走CPU推理

# 限制GPU加载层数(0表示全部CPU推理)
OLLAMA_NUM_GPU=1 ollama run qwen2-7b-local

多模型并发与资源隔离

生产环境通常需要同时运行多个模型。Ollama支持多模型并发,但需要合理规划显存:

# Ollama默认配置,模型5分钟无请求自动卸载
# 修改保持时间(单位:分钟)
OLLAMA_KEEP_ALIVE=30 ollama run qwen2-7b-local

# 设置环境变量持久化
export OLLAMA_KEEP_ALIVE=30
export OLLAMA_MAX_LOADED_MODELS=3  # 最大同时加载模型数

关键配置原则:所有并发模型的显存占用之和不超过GPU总显存的85%,预留空间给KV Cache和系统开销。

推理性能基准测试

部署完成后需要验证推理性能是否达标。使用ollama-benchmark或手动测速:

import time
import requests

def benchmark(model, prompt, n=5):
    times = []
    for _ in range(n):
        start = time.time()
        resp = requests.post("http://localhost:11434/api/generate",
            json={"model": model, "prompt": prompt, "stream": False},
            timeout=120)
        elapsed = time.time() - start
        data = resp.json()
        tokens = data.get("eval_count", 0)
        tps = tokens / (data.get("eval_duration", 1) / 1e9)
        times.append(tps)
        print(f"Round: {tps:.1f} tokens/s")

    avg = sum(times) / len(times)
    print(f"Average: {avg:.1f} tokens/s")

benchmark("qwen2-7b-local", "写一篇关于人工智能的500字文章")

在RTX 4090上,7B Q4_K_M模型单用户推理通常能达到80-120 tokens/s,满足交互式对话需求。70B Q4_K_M模型则需要两张4090,推理速度约15-25 tokens/s。

常见问题排查

模型加载失败”out of memory”

确认GPU显存是否足够。Q4_K_M量化下,7B模型需约4.4GB显存,13B需约8GB。检查是否有其他进程占用显存:

nvidia-smi
# 如果Xorg或Wayland占用显存,设置环境变量
export CUDA_VISIBLE_DEVICES=0

推理速度异常慢

大概率是GPU层没有正确加载,模型全部在CPU上运行。确认Ollama日志中是否有GPU相关的报错信息:

# 查看Ollama日志
journalctl -u ollama --no-pager -n 50

# 确认GPU层分配
# 正常情况ollama ps会显示GPU层数

中文输出乱码或重复

检查模型是否支持中文,以及template是否正确配置。中文模型建议设置temperature为0.7-0.9,避免温度过低导致重复输出。

GGUF量化与Ollama的组合为本地大模型部署提供了完整的解决方案。从格式转换到推理配置再到性能调优,整个流程已趋于标准化,开发者可以在消费级硬件上跑通7B-13B量级模型的本地推理服务。

原创文章,作者:小编,如若转载,请注明出处:https://www.yunthe.com/da-mo-xing-liang-hua-bu-shu-shi-zhan-gguf-ge-shi-zhuan-huan/

(0)
小编小编
上一篇 2026年7月30日
下一篇 2026年7月30日

相关推荐

大模型量化部署实战:GGUF格式转换与llama.cpp推理优化

为什么大模型需要量化部署

大模型开发落地过程中,推理成本是绕不开的瓶颈。一块A100 80GB的GPU售价超过10万元,而多数团队手头只有消费级显卡甚至纯CPU服务器。大模型量化部署方案通过降低参数精度,将原本需要多卡并行推理的模型压缩到单卡甚至纯CPU环境运行,推理速度与显存占用都能得到显著改善。GGUF格式作为llama.cpp生态的通用模型文件格式,支持从Q2_K到Q8_0多种量化级别,是目前开源社区中应用最广泛的量化方案。

GGUF格式与量化级别选择

GGUF(GPT-Generated Unified Format)是llama.cpp团队设计的二进制模型格式,替代了早期的GGML格式。GGUF的核心优势在于将模型权重、词表和元数据打包为单一文件,支持mmap加载,无需额外解析步骤。

量化级别的选择直接影响推理质量和资源消耗,以下是常用级别的对比:

| 量化级别 | 比特数/权重 | 7B模型体积 | 质量损失 | 适用场景 |
|----------|-------------|-------------|----------|----------|
| Q8_0     | 8-bit       | ~7.7GB      | 极小     | GPU推理,质量优先 |
| Q5_K_M   | 5-bit       | ~5.1GB      | 小       | 均衡推荐 |
| Q4_K_M   | 4-bit       | ~4.4GB      | 可接受   | CPU/低显存推理 |
| Q3_K_S   | 3-bit       | ~3.3GB      | 较明显   | 极限压缩场景 |

实际经验:通用对话场景推荐Q4_K_M或Q5_K_M,代码生成和逻辑推理场景至少使用Q5_K_M,Q3_K_S仅用于验证流程而非生产环境。

从HuggingFace原始权重转换GGUF格式

转换流程分两步:先将原始safetensors权重转为GGUF F16格式,再对F16文件执行量化。以下是完整操作步骤:

# 克隆llama.cpp仓库
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

# 安装Python依赖
pip install -r requirements.txt

# 第一步:转换为GGUF F16格式
python convert_hf_to_gguf.py \
  /path/to/model-dir \
  --outfile model-f16.gguf \
  --outtype f16

# 第二步:执行量化(以Q4_K_M为例)
./llama-quantize model-f16.gguf model-q4_km.gguf Q4_K_M

转换HuggingFace模型时需要注意模型目录结构,目录下必须包含config.json、tokenizer.json和safetensors权重文件。部分模型使用了自定义分词器(如LLaMA 3的BPE tokenizer),convert脚本会自动识别并处理。

如果模型是PyTorch格式(.bin文件),转换脚本同样支持,但safetensors格式加载速度更快且更安全。

llama.cpp推理配置与性能调优

GGUF模型转换完成后,使用llama.cpp进行推理。以下是关键参数配置:

# GPU推理(单卡)
./llama-cli \
  -m model-q4_km.gguf \
  -ngl 32 \
  -c 4096 \
  -b 512 \
  --temp 0.7 \
  --top-p 0.9 \
  -p "请解释Transformer中多头注意力的计算过程"

# CPU推理(指定线程数)
./llama-cli \
  -m model-q4_km.gguf \
  -ngl 0 \
  -t 8 \
  -c 4096 \
  -b 256 \
  --mlock \
  -p "请解释Transformer中多头注意力的计算过程"

关键参数说明:

-ngl(num-gpu-layers):卸载到GPU的层数。设为0则纯CPU推理,设为模型总层数则全部加载到GPU。对于7B模型,32层通常足够覆盖全部层。
-c(context-size):上下文窗口长度。增大此值会线性增加显存占用。
-b(batch-size):批处理大小。GPU推理建议512,CPU推理建议256或更小。
--mlock:锁定模型内存,防止被swap到磁盘,CPU推理场景建议开启。

NUMA架构CPU推理优化

在多路CPU服务器上运行llama.cpp推理时,NUMA拓扑对性能影响显著。默认情况下,llama.cpp所有线程共享同一个NUMA节点访问内存,跨节点内存访问延迟可能翻倍。

# 查看NUMA拓扑
numactl --hardware

# 输出示例:
# available: 2 nodes (0-1)
# node 0 size: 65536 MB
# node 1 size: 65536 MB

# 绑定NUMA节点0运行
numactl --cpunodebind=0 --membind=0 \
  ./llama-cli -m model-q4_km.gguf -ngl 0 -t 32 -c 4096 -p "test"

llama.cpp从b2050版本起支持-sm(split-mode)参数控制多NUMA节点的线程分布策略:

# 启用NUMA感知的线程分布
./llama-cli \
  -m model-q4_km.gguf \
  -ngl 0 \
  -t 64 \
  -c 4096 \
  -sm numa \
  -p "test prompt"

-sm numa模式下,llama.cpp自动将线程均匀分配到各NUMA节点,每个线程只访问本地节点的内存,避免跨节点延迟。实测在双路EPYC 7763服务器上,开启NUMA优化后推理吞吐量提升约35%。

显存不足时的分层卸载策略

当GPU显存无法容纳完整模型时,llama.cpp支持部分层卸载到GPU、其余层留在CPU的混合推理模式。通过调整-ngl参数逐步增大,找到显存上限对应的最佳层数:

# 逐步测试最佳GPU卸载层数
for ngl in 4 8 12 16 20 24 28 32; do
  echo "=== ngl=$ngl ==="
  ./llama-cli -m model-q4_km.gguf -ngl $ngl -c 2048 -p "test" 2>&1 | grep "tok/s"
done

监控显存占用的同时观察token/s指标,当显存接近上限时停止增加层数。一块12GB显存的RTX 3060运行Q4_K_M量化的7B模型,通常可以卸载约20-24层到GPU,剩余层由CPU计算,推理速度可达纯CPU的2-3倍。

批量推理与多用户并发部署

llama.cpp的llama-server模式提供OpenAI兼容的API服务,支持多用户并发请求:

# 启动API服务
./llama-server \
  -m model-q4_km.gguf \
  -ngl 32 \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080 \
  --parallel 4 \
  --cont-batching

# 客户端调用
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "local-model",
    "messages": [{"role": "user", "content": "解释注意力机制"}],
    "max_tokens": 512,
    "temperature": 0.7
  }'

--parallel设置并发槽位数,--cont-batching开启连续批处理,允许多个请求共享同一批次的前向计算,显著提升吞吐量。4并发槽位下,QPS通常可达单请求的2.5-3倍。

量化质量评估与回归测试

部署量化模型前,需要评估精度损失是否在可接受范围内。推荐使用以下方法:

# 使用perplexity工具计算困惑度
./llama-perplexity \
  -m model-q4_km.gguf \
  -f wikitext-2-raw/wiki.test.raw \
  --chunks 32

# 对比不同量化级别的困惑度
for model in model-f16.gguf model-q8_0.gguf model-q5_km.gguf model-q4_km.gguf; do
  echo "=== $model ==="
  ./llama-perplexity -m $model -f wikitext-2-raw/wiki.test.raw --chunks 32 2>&1 | grep "perplexity"
done

F16基准的7B模型WikiText-2困惑度约为5.8-6.0,Q5_K_M通常在6.0-6.2,Q4_K_M在6.3-6.8。如果量化后困惑度增幅超过15%,建议升一级量化。

除了自动指标,务必用业务场景的实际Prompt做人工评估。准备20-50条覆盖典型场景的测试用例,对比F16和量化版本的输出质量,关注格式正确性、事实准确性和逻辑一致性三个维度。

生产环境部署检查清单

将量化模型投入生产环境前,逐项确认以下配置:

1. 模型文件完整性:用sha256sum校验GGUF文件哈希,确保下载无损
2. 内存余量:预留模型体积1.2倍以上的可用内存,避免运行时OOM
3. 线程数配置:CPU推理线程数不超过物理核心数,超线程核心对推理性能提升有限
4. mlock设置:CPU推理场景务必开启--mlock,防止内存swap导致推理卡顿
5. 超时与重试:API服务配置请求超时和健康检查端点,接入负载均衡器
6. 日志与监控:启用--log-format text记录推理延迟和吞吐量指标,接入Prometheus监控

量化部署不是万能方案,它在推理成本和质量之间做取舍。正确的做法是根据业务场景的精度要求选择合适的量化级别,配合NUMA优化和分层卸载策略,在有限的硬件资源下获得最优的推理体验。

原创文章,作者:小编,如若转载,请注明出处:https://www.yunthe.com/da-mo-xing-liang-hua-bu-shu-shi-zhan-gguf-ge-shi-zhuan-huan/

(0)
小编小编
上一篇 2026年7月28日
下一篇 2026年7月28日

相关推荐