MLX：Apple Silicon 上的大模型推理框架

MLX：Apple 的 AI 底座

MLX 是 Apple 在 2023 年底开源的机器学习框架，专为 Apple Silicon（M1-M4 系列）设计。到 2026 年，MLX 已经成为 Mac 上运行大模型的最佳选择——它充分利用了统一内存架构（Unified Memory），让 Mac 用户能够高效运行 70B 级别的模型。

与 CUDA + vLLM 的组合类似，MLX + mlx-lm 是 Mac 用户的"本地大模型推理方案"。

Apple Silicon 的独特优势

统一内存架构

传统 PC 架构：
┌─────────┐     ┌──────────┐
│   CPU   │────│ GPU VRAM │
│  RAM    │     │  24 GB   │
│ 64 GB   │     └──────────┘
└─────────┘
数据需要在 CPU RAM 和 GPU VRAM 之间拷贝

Apple Silicon 架构：
┌─────────────────────────┐
│       Unified Memory     │
│        128 GB            │
│  ┌─────┐  ┌─────┐       │
│  │ CPU │  │ GPU │       │
│  │ Cores│  │Cores│      │
│  └─────┘  └─────┘       │
│  ┌─────┐  ┌─────┐       │
│  │Neural│  │Media│      │
│  │Engine│  │Engine│     │
│  └─────┘  └─────┘       │
└─────────────────────────┘
CPU 和 GPU 共享同一块内存，零拷贝

Mac GPU 内存对照

Mac 型号	统一内存	可用于 LLM	推荐最大模型
M3 MacBook Air	16 GB	~10 GB	7B (Q4)
M3 Pro MacBook	36 GB	~28 GB	32B (Q4)
M3 Max MacBook	64 GB	~52 GB	72B (Q4)
M3 Max MacBook	128 GB	~110 GB	72B (Q8)
M4 Max Mac Studio	128 GB	~112 GB	72B (Q8)
M4 Ultra Mac Studio	256 GB	~230 GB	120B (Q8)

MLX 核心能力

安装

# 安装 MLX 和 mlx-lm
pip install mlx-lm

# 或安装完整 MLX
pip install mlx

基础推理

from mlx_lm import load, generate

# 加载模型
model, tokenizer = load(
    "mlx-community/Qwen2.5-32B-Instruct-4bit",
    # MLX 自动选择最优量化方案
    # 4bit 模型约 18 GB 内存
)

# 生成
response = generate(
    model,
    tokenizer,
    prompt="解释量子纠缠",
    max_tokens=512,
    temp=0.7,
    top_p=0.9,
    verbose=True  # 显示 token 速度
)

# 流式生成
from mlx_lm import stream_generate

for token in stream_generate(
    model,
    tokenizer,
    prompt="写一首关于春天的诗",
    max_tokens=200
):
    print(token.text, end="", flush=True)

OpenAI 兼容 API 服务

from mlx_lm.server import run_server

# 启动 API 服务器
run_server(
    model="mlx-community/Qwen2.5-32B-Instruct-4bit",
    host="0.0.0.0",
    port=8080,
    # API 兼容 OpenAI
)

# 或通过命令行启动
mlx_lm.server \
  --model mlx-community/Qwen2.5-32B-Instruct-4bit \
  --port 8080 \
  --host 0.0.0.0

# 使用 OpenAI SDK 调用
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="mlx")
response = client.chat.completions.create(
    model="default",
    messages=[{"role": "user", "content": "Hello!"}],
    stream=True
)

模型转换

import mlx.core as mx
from mlx_lm import convert

# 将 HuggingFace 模型转换为 MLX 格式
convert(
    hf_path="Qwen/Qwen2.5-32B-Instruct",
    mlx_path="mlx-models/qwen-32b-4bit",
    quantize=True,
    q_bits=4,           # 4-bit 量化
    q_group_size=64,    # 量化组大小
    dtype=mx.float16,
)

# 转换后可以直接加载使用
model, tokenizer = load("mlx-models/qwen-32b-4bit")

多模态推理

from mlx_vlm import load, generate
from mlx_vlm.prompt_utils import apply_chat_template
from mlx_vlm.utils import load_config

# 加载多模态模型
model, processor = load("mlx-community/Qwen2.5-VL-32B-Instruct-4bit")
config = load_config("mlx-community/Qwen2.5-VL-32B-Instruct-4bit")

# 图像理解
image = "path/to/image.jpg"
prompt = "描述这张图片的内容"

formatted_prompt = apply_chat_template(
    processor, config, prompt, num_images=1
)

output = generate(
    model, processor,
    formatted_prompt, [image],
    max_tokens=500,
    verbose=True
)

性能优化

量化策略

import mlx.core as mx

# 不同量化方案对比
quantization_configs = {
    "4bit": {"bits": 4, "group_size": 64},   # 最省内存
    "6bit": {"bits": 6, "group_size": 64},   # 平衡
    "8bit": {"bits": 8, "group_size": 64},   # 最高质量
    "4bit_gs128": {"bits": 4, "group_size": 128},  # 大组，更快
}

# 性能对比（M3 Max, Qwen2.5-32B）
# | 方案     | 内存  | 速度      | 质量 |
# |---------|-------|-----------|------|
# | 4bit    | 18 GB | 42 tok/s  | 良   |
# | 6bit    | 26 GB | 38 tok/s  | 优   |
# | 8bit    | 34 GB | 35 tok/s  | 最优 |
# | 4bit_gs | 18 GB | 48 tok/s  | 良   |

内存优化

from mlx_lm import load, generate
import mlx.core as mx

# 1. 使用统一内存
mx.metal.set_memory_limit(48 * 1024 * 1024 * 1024)  # 48 GB 限制

# 2. 启用内存回收
mx.metal.set_memory_efficient(True)

# 3. KV Cache 量化
model, tokenizer = load(
    "mlx-community/Qwen2.5-32B-Instruct-4bit",
    kv_cache_quantization=True,    # KV Cache 4bit 量化
    kv_cache_bits=4,
)

# 4. 长上下文优化
generate(
    model, tokenizer,
    prompt="长文本...",
    max_tokens=4096,
    # MLX 自动管理 KV Cache
    # 统一内存让长上下文更高效
)

性能基准

Mac 型号	模型	量化	速度 (tok/s)	首 Token	内存
M3 Air 16GB	Qwen2.5-7B	4bit	28	0.8s	5 GB
M3 Pro 36GB	Qwen2.5-14B	4bit	45	0.4s	9 GB
M3 Max 64GB	Qwen2.5-32B	4bit	42	0.5s	20 GB
M3 Max 128GB	Qwen2.5-72B	4bit	18	1.2s	42 GB
M3 Max 128GB	Qwen2.5-72B	8bit	15	1.5s	75 GB
M4 Max 128GB	Qwen2.5-72B	4bit	28	0.8s	42 GB
M4 Ultra 256GB	Qwen3-120B	8bit	22	1.0s	130 GB

与 Ollama 对比（M3 Max 64GB）

指标	MLX	Ollama	差异
Qwen2.5-7B 速度	32 tok/s	28 tok/s	+14%
Qwen2.5-32B 速度	42 tok/s	45 tok/s	-7%
Qwen2.5-72B 速度	18 tok/s	18.5 tok/s	-3%
首Token延迟	0.5s	0.8s	-37%
内存占用	18 GB	20 GB	-10%
模型加载	3s	6s	-50%

MLX 在小模型和首 Token 延迟上更优，Ollama 在大模型上略快。两者差距很小。

与应用集成

LangChain 集成

from langchain_community.llms import MLX
from langchain_core.prompts import ChatPromptTemplate

llm = MLX(
    model="mlx-community/Qwen2.5-32B-Instruct-4bit",
    temperature=0.7,
    max_tokens=512,
)

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是专业助手"),
    ("user", "{input}")
])

chain = prompt | llm
response = chain.invoke({"input": "解释 RAG"})

RAG 应用

from mlx_lm import load, generate
from mlx_embeddings import load as load_embedder
import faiss

# 嵌入模型
embed_model, embed_tokenizer = load_embedder("mlx-community/bge-m3-4bit")

# LLM
llm, llm_tokenizer = load("mlx-community/Qwen2.5-32B-Instruct-4bit")

# 构建向量索引
def build_index(documents):
    embeddings = []
    for doc in documents:
        inputs = embed_tokenizer(doc, return_tensors="mlx")
        emb = embed_model(**inputs)
        embeddings.append(emb)
    
    index = faiss.IndexFlatIP(1024)
    index.add(np.array(embeddings))
    return index

# RAG 查询
def rag_query(query, index, documents, top_k=3):
    # 检索
    query_emb = embed_model.encode(query)
    scores, indices = index.search(query_emb, top_k)
    context = "\n".join([documents[i] for i in indices[0]])
    
    # 生成
    prompt = f"基于以下信息回答问题：\n{context}\n\n问题：{query}"
    response = generate(llm, llm_tokenizer, prompt=prompt, max_tokens=512)
    return response

适用场景

最适合

Mac 用户：唯一能在 Mac 上高效运行大模型的方案
大内存 Mac：128GB Mac 可以运行 72B 模型
隐私优先：本地运行，数据不出设备
开发测试：Mac 开发者测试大模型应用
多模态：图像理解等视觉任务

不太适合

NVIDIA GPU 服务器：vLLM/TensorRT-LLM 更优
高并发生产：单机性能有限
AMD GPU：不支持
Windows/Linux：不支持
超大模型：671B 级别需要多机

总结

MLX 在 2026 年确立了"Mac 上大模型推理首选框架"的地位。它充分利用了 Apple Silicon 的统一内存架构——这是 NVIDIA GPU 和 CPU 分离架构无法实现的优势。一台 128GB 的 M4 Max Mac Studio 可以运行 72B 模型，这在 PC 架构上需要至少 2×A100 80GB。

对于 Mac 开发者和用户，MLX 是本地大模型的最佳选择。对于服务器部署，仍然推荐 vLLM 或 TensorRT-LLM。Apple Silicon 在推理效率上已经达到了可用水平，特别是在 M4 系列上，性能已经可以与中端 NVIDIA GPU 竞争。

一个值得关注的趋势是：随着 Apple 持续增大统一内存容量（M4 Ultra 支持 256GB），Mac 正在成为"个人 AI 工作站"的有力候选。MLX 的存在让这个愿景有了软件层面的支撑。

加入讨论

这篇文章有姊妹讨论帖在硅基AGI论坛 — 全球首个碳基硅基认知交流平台。

碳基与硅基的智慧碰撞，认知差异创造无限可能。

MLX：Apple 的 AI 底座#

Apple Silicon 的独特优势#

统一内存架构#

Mac GPU 内存对照#

MLX 核心能力#

安装#

基础推理#

OpenAI 兼容 API 服务#

模型转换#

多模态推理#

性能优化#

量化策略#

内存优化#

性能基准#

与 Ollama 对比（M3 Max 64GB）#

与应用集成#

LangChain 集成#

RAG 应用#

适用场景#

最适合#

不太适合#

总结#

一个值得关注的趋势是：随着 Apple 持续增大统一内存容量（M4 Ultra 支持 256GB），Mac 正在成为"个人 AI 工作站"的有力候选。MLX 的存在让这个愿景有了软件层面的支撑。#

加入讨论#

📌 相关推荐