在 LM Studio 中查看性能：

1. 聊天界面底部状态栏
   └── 显示 tok/s 和响应时间

2. Local Server 请求日志
   └── 显示每个请求的延迟

3. 使用代码测量：

"""测量 LM Studio 推理性能"""

import time
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:1234/v1",
    api_key="lm-studio"
)

def benchmark(prompt: str, max_tokens: int = 200) -> dict:
    """性能基准测试"""
    start = time.time()

    # 流式请求，测量 TTFT 和总时间
    first_token_time = None
    token_count = 0

    stream = client.chat.completions.create(
        model="qwen2.5-7b-instruct",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens,
        stream=True
    )

    for chunk in stream:
        content = chunk.choices[0].delta.content
        if content:
            if first_token_time is None:
                first_token_time = time.time()
            token_count += 1

    end = time.time()

    total_time = end - start
    ttft = first_token_time - start if first_token_time else None
    generation_time = end - first_token_time if first_token_time else total_time

    return {
        "total_time": round(total_time, 2),
        "ttft": round(ttft, 2) if ttft else None,
        "tokens": token_count,
        "tok_per_sec": round(token_count / generation_time, 1) if generation_time > 0 else 0
    }

# 运行测试
result = benchmark("用 200 字解释量子计算的基本原理")
print(f"总时间: {result['total_time']}s")
print(f"首 Token 时间: {result['ttft']}s")
print(f"生成 Tokens: {result['tokens']}")
print(f"生成速度: {result['tok_per_sec']} tok/s")

运行 LLM 时的内存组成：

┌─────────────────────────────────────────────┐
│                总内存需求                     │
├─────────────┬───────────────┬───────────────┤
│ 模型权重     │ KV Cache      │ 运行时开销    │
│ (主要部分)   │ (上下文相关)   │ (较小)       │
├─────────────┼───────────────┼───────────────┤
│ ~4.5 GB     │ ~0.5-4 GB     │ ~0.5 GB      │
│ (7B Q4_K_M) │ (取决于上下文) │              │
└─────────────┴───────────────┴───────────────┘

总需求 ≈ 模型大小 × 1.2 ~ 1.5

KV Cache 内存公式：

KV Cache (GB) = 2 × n_layers × n_heads × d_head × context_length × batch_size × 2 (bytes) / 1024³

简化估算：
├── 7B 模型, 32K 上下文: ~1-2 GB
├── 13B 模型, 32K 上下文: ~2-3 GB
├── 70B 模型, 32K 上下文: ~8-12 GB
└── 上下文翻倍 → KV Cache 翻倍

策略一：使用更小的量化
├── Q8_0 → Q4_K_M: 减少 ~40% 内存
├── Q4_K_M → Q3_K_M: 再减少 ~20%
└── 代价：质量略有下降

策略二：减少上下文长度
├── 32K → 8K: 减少 KV Cache
└── 适合短对话场景

策略三：使用更小参数量的模型
├── 14B → 7B: 减少 ~50% 内存
├── 7B → 3B: 再减少 ~50%
└── 代价：能力下降

策略四：CPU Offloading
├── 将部分层放在 CPU 上
├── 减少 GPU 内存占用
└── 代价：速度下降

# 检查 GPU 状态
nvidia-smi

# 监控 GPU 使用情况
watch -n 1 nvidia-smi

# 输出解读：
# GPU-Util: GPU 利用率（越高越好）
# Memory-Usage: 显存使用
# Temp: 温度（过高会降频）

NVIDIA GPU 优化建议：

1. 确保使用最新的 CUDA 驱动
   └── 建议 CUDA 12.x+

2. 选择合适的 GPU Offload 层数
   ├── VRAM 充足: n_gpu_layers = 99（全部）
   └── VRAM 不足: 根据可用显存设置

3. 避免显存碎片化
   └── 不要同时加载太多模型

4. 监控温度
   └── GPU 过热会自动降频，影响性能

Apple Silicon (M1/M2/M3/M4) 特点：

统一内存架构：
├── GPU 和 CPU 共享同一块物理内存
├── 无需手动管理数据拷贝
├── M1 Pro 16GB: 可用 ~14GB
└── M2 Max 32GB: 可用 ~28GB

优化建议：
1. 选择合适的模型大小
   ├── M1/M2 8GB: 最大 7B Q4
   ├── M1 Pro 16GB: 最大 13B Q4 或 7B Q8
   └── M2 Max 32GB+: 最大 34B Q4

2. 关闭其他内存占用大的应用
   └── 浏览器标签页是内存大户

3. macOS 会自动管理 Metal 加速
   └── 无需额外配置

4. 使用活动监视器监控内存压力
   └── 黄色/红色表示内存不足

Linux (ROCm):
# 确认 ROCm 安装
rocminfo

# 设置环境变量（根据 GPU 架构）
export HSA_OVERRIDE_GFX_VERSION=10.3.0  # RDNA2
export HSA_OVERRIDE_GFX_VERSION=11.0.0  # RDNA3

# 检查 GPU 是否被识别
rocm-smi

Windows (Vulkan):
├── LM Studio 使用 Vulkan 后端
├── 确保 Adrenalin 驱动最新
└── 性能通常低于 NVIDIA CUDA

选择量化级别：

你的 RAM/VRAM 有多少？
├── ≥ 模型 F16 大小
│   └── 使用 Q8_0 或 F16（最高质量）
│
├── ≥ 模型 Q8 大小
│   └── 使用 Q8_0（高质量，推荐）
│
├── ≥ 模型 Q5 大小
│   └── 使用 Q5_K_M（质量优先推荐）
│
├── ≥ 模型 Q4 大小
│   └── 使用 Q4_K_M（性价比推荐）
│
└── < 模型 Q4 大小
    └── 考虑更小参数量的模型

评估维度：

1. 语言能力
   ├── Q4_K_M: 中文流畅度 ~90%
   ├── Q5_K_M: 中文流畅度 ~95%
   └── Q8_0:   中文流畅度 ~98%

2. 代码能力
   ├── Q4_K_M: 代码正确性 ~85%
   ├── Q5_K_M: 代码正确性 ~92%
   └── Q8_0:   代码正确性 ~97%

3. 数学推理
   ├── Q4_K_M: 推理准确性 ~80%
   ├── Q5_K_M: 推理准确性 ~88%
   └── Q8_0:   推理准确性 ~95%

结论：
├── 一般对话/写作: Q4_K_M 足够
├── 代码生成: 推荐 Q5_K_M
└── 数学/逻辑推理: 推荐 Q8_0

单请求模式：
├── 一个请求独占所有 GPU 资源
├── 生成速度最快
└── 适合交互式对话

并发模式：
├── 多个请求共享 GPU 资源
├── 单个请求速度下降
├── 但总吞吐量提升
└── 适合 API 服务器

"""并发性能测试"""

import asyncio
import time
from openai import AsyncOpenAI

async def benchmark_concurrent(num_requests: int = 5):
    """测试并发性能"""
    client = AsyncOpenAI(
        base_url="http://localhost:1234/v1",
        api_key="lm-studio"
    )

    async def single_request(idx: int):
        start = time.time()
        response = await client.chat.completions.create(
            model="qwen2.5-7b-instruct",
            messages=[
                {"role": "user", "content": f"用一句话回答：{idx}+{idx}等于多少？"}
            ],
            max_tokens=50
        )
        elapsed = time.time() - start
        return {
            "idx": idx,
            "time": elapsed,
            "tokens": len(response.choices[0].message.content)
        }

    # 并发发送请求
    start = time.time()
    tasks = [single_request(i) for i in range(num_requests)]
    results = await asyncio.gather(*tasks)
    total_time = time.time() - start

    # 汇总结果
    print(f"并发请求数: {num_requests}")
    print(f"总时间: {total_time:.2f}s")
    print(f"平均延迟: {sum(r['time'] for r in results) / len(results):.2f}s")
    print(f"吞吐量: {sum(r['tokens'] for r in results) / total_time:.1f} tok/s")

asyncio.run(benchmark_concurrent(5))

Linux:
# 禁用透明大页面（可减少延迟抖动）
echo never | sudo tee /sys/kernel/mm/transparent_hugepage/enabled

# 调整 swappiness（减少 swap 使用）
sudo sysctl vm.swappiness=10

# 确保 GPU 性能模式
sudo nvidia-persistenced --persistence-mode

Windows:
├── 关闭不必要的后台程序
├── 设置电源计划为"高性能"
└── 确保 GPU 驱动为最新版

macOS:
├── 关闭不需要的应用
├── 检查活动监视器中的内存压力
└── 重启可清理内存碎片

Settings 优化建议：

1. Context Length
   ├── 按需设置，不要盲目设最大
   └── 8K 对多数场景足够

2. GPU Offload Layers
   ├── 设置为最大值（如果显存够）
   └── 或根据显存计算合适的值

3. Batch Size
   ├── 默认值通常足够
   └── 增大可提升吞吐量，但增加内存

4. Thread Count
   ├── 默认为 CPU 核心数
   └── 通常不需要调整

"""LM Studio 性能监控"""

import requests
import time
import json

def monitor_server(url: str = "http://localhost:1234"):
    """监控 LM Studio 服务器状态"""
    try:
        # 检查服务器是否在线
        response = requests.get(f"{url}/v1/models", timeout=5)
        if response.status_code == 200:
            models = response.json()["data"]
            print(f"服务器状态: 在线")
            print(f"可用模型: {len(models)}")
            for m in models:
                print(f"  - {m['id']}")
        else:
            print(f"服务器响应异常: {response.status_code}")
    except requests.ConnectionError:
        print("服务器未运行或无法连接")

if __name__ == "__main__":
    monitor_server()