Modal 无服务器 GPU 计算 — 零基础设施运行 ML 流水线

TL;DR #

Modal 是一个 Python 原生的无服务器计算平台，无需管理任何基础设施即可运行 GPU 加速工作负载。你编写标准 Python 函数，用 @modal.enter() 和 @modal.function() 装饰它们，Modal 自动处理容器配置、GPU 分配、网络管理和弹性伸缩。非常适合 LLM 推理端点、微调任务和批量 ML 流水线。

Modal 是专为机器学习和数据密集型工作负载设计的无服务器计算平台。与传统云服务商不同——你需要预配虚拟机、管理 Kubernetes 集群或配置自动伸缩组——Modal 将所有基础设施抽象为简单的 Python 装饰器。

核心理念很简单：你的代码就是基础设施定义。写一个 Python 函数，添加几个装饰器指定资源需求（GPU 类型、内存、超时），然后部署。Modal 自动配置正确的容器，根据传入请求进行弹性伸缩，并按实际使用的计算时间按秒计费。

为什么无服务器 GPU 对 AI 至关重要 #

GPU 基础设施历来是 AI 开发的最大瓶颈。传统方法需要：

预配 GPU 实例（闲置成本高昂）
管理 Kubernetes 集群进行编排（运维复杂度高）
处理推理端点的冷启动（延迟问题）
从零扩展到数千并发请求（手动调优）

Modal 通过将 GPU 视为一等无服务器原语来解决所有这些问题。你只为 GPU 实际运行推理或训练的秒数付费，没有最低消费承诺。

import modal

# 定义预装 PyTorch 和 CUDA 的容器镜像
stub = modal.Stub("my-modal-app")

image = modal.Image.debian_slim().pip_install(
    "torch",
    "transformers",
    "accelerate"
)

与替代方案的关键差异 #

特性	Modal	AWS SageMaker	Google Vertex AI	Lambda GPU
Python 原生 API	✅	❌(控制台/CLI)	❌(控制台/CLI)	❌(YAML)
零冷启动*	✅(预热池)	❌	❌	❌
按秒计费	✅	❌(最小小时)	❌(最小小时)	✅
多 GPU 弹性伸缩	✅(最高 8xH100)	✅	✅	❌(单 GPU)
交互式开发	✅(`modal serve`)	❌	❌	❌

*预热池将冷启动减少到大多数模型低于 2 秒。

Modal 的设计哲学源于一个简单观察：ML 工程师不应该成为 DevOps 专家。当你写 @stub.function(gpu="A100") 时，Modal 在后台完成了所有复杂工作——从容器镜像构建到 GPU 驱动安装、网络配置、负载均衡和健康检查。

这种抽象层带来的另一个关键优势是可移植性。你在本地笔记本中编写的代码几乎不需要修改即可部署到生产环境。无需编写 Dockerfile、Kubernetes YAML 或 Terraform 配置。这种开发到部署的无缝体验让原型迭代速度提高了 5-10 倍。

实际使用场景分析 #

让我们看几个真实世界的用例：

场景一：每周批量嵌入生成 一家创业公司需要为 50 万条产品评论生成嵌入向量。使用传统方法，他们需要在 EC2 上预置 A100 实例并运行 8 小时，花费约 $40。使用 Modal，他们只需编写一个函数，设置 3600 秒超时，Modal 自动分配 GPU 并在完成后释放资源，实际成本仅约 $8。

场景二：实时聊天机器人端点 一个教育平台需要为 10,000 名学生提供 AI 辅导。使用 Modal 的 keep_warm 功能，他们保持 3 个 A10G 容器始终热启动，平均响应时间低于 800ms。在低峰时段（深夜），容器自动缩放到零，成本降至每天不到 $2。

场景三：模型微调流水线 一家金融科技公司需要微调 Llama 3.2 以理解金融术语。通过 Modal 的 H100 支持，他们在 4 小时内完成训练，成本约 $16。如果使用 Spot 实例，还需要处理中断风险和自定义脚本。

第一步：安装和认证 #

# 安装 Modal Python SDK
pip install modal-client

# 使用 Modal 账户进行认证
modal setup

Modal 为新账户提供免费额度——通常足以运行数小时的 A10G 计算用于测试。

第二步：编写简单的推理函数 #

import modal
from transformers import AutoModelForCausalLM, AutoTokenizer

stub = modal.Stub("llm-inference")

# 在容器启动时预加载模型
@stub.cls(
    image=modal.Image.debian_slim().pip_install("transformers", "torch", "accelerate"),
    gpu="A10G",
    memory=8192
)
class LLMEndpoint:
    @modal.enter()
    def load_model(self):
        self.model = AutoModelForCausalLM.from_pretrained(
            "meta-llama/Llama-3.2-3B-Instruct",
            torch_dtype="auto",
            device_map="auto"
        )
        self.tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B-Instruct")

    @modal.method()
    def generate(self, prompt: str, max_tokens: int = 512) -> str:
        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
        outputs = self.model.generate(**inputs, max_new_tokens=max_tokens)
        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)

这种基于类的方法让模型在请求间保持内存加载状态，消除了困扰无服务器 LLM 部署的多分钟冷启动惩罚。

第三步：部署和测试 #

# 将应用部署到 Modal 云端
modal deploy my_app.py

# 从命令行测试
modal run my_app::LLMEndpoint.generate --prompt "解释量子计算" --max_tokens 256

部署后，Modal 为你的端点分配一个公共 URL。任何客户端都可以通过 HTTP REST API 调用它。

部署模式 #

模式一：高吞吐推理端点 #

对于生产级 LLM 服务，使用 Modal 内置的并发和请求队列：

@stub.cls(
    gpu="L4",
    concurrency_limit=20,
    allow_concurrent_inputs=10,
    keep_warm=2  # 至少保持 2 个容器预热
)
class ProductionLLM:
    @modal.enter()
    def load_model(self):
        self.model = load_optimized_model()  # 你的优化逻辑
        self.tokenizer = AutoTokenizer.from_pretrained("your-model")

    @modal.web_endpoint(method="POST")
    def infer(self, req: dict):
        prompt = req.get("prompt", "")
        result = self.model.generate(prompt, max_tokens=req.get("max_tokens", 256))
        return {"response": result}

关键设置：

keep_warm=2：确保 2 个容器保持热状态以应对突发流量
allow_concurrent_inputs=10：每个容器处理 10 个并发请求
concurrency_limit=20：最多 20 个容器总量（成本控制）

模式二：批量处理流水线 #

通过 LLM 处理数千份文档：

@stub.function(
    image=image,
    gpu="A100-80GB",
    timeout=3600,  # 最长 1 小时
    retries=2
)
def batch_embed(docs: list[str]) -> list[list[float]]:
    """处理一批文档并返回嵌入向量。"""
    model = get_embedding_model()
    return model.encode(docs, batch_size=64).tolist()

# 运行批量任务
results = batch_embed.remote([f"文档 {i}" for i in range(10000)])

Modal 自动处理分块、重试失败批次，并在多个 GPU 容器间并行化。

模式三：微调任务 #

@stub.function(
    gpu="H100-80GB",
    memory=16384,
    timeout=14400  # 4 小时
)
def run_finetune(dataset_path: str, output_dir: str):
    """在数据集上运行 LoRA 微调。"""
    from trl import SFTTrainer
    from peft import LoraConfig

    model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B")
    tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B")

    peft_config = LoraConfig(
        r=16, lora_alpha=32, target_modules=["q_proj", "v_proj"],
        lora_dropout=0.05, bias="none", task_type="CAUSAL_LM"
    )

    trainer = SFTTrainer(
        model=model, tokenizer=tokenizer,
        train_dataset=load_dataset(dataset_path),
        peft_config=peft_config,
        args=TrainingArguments(output_dir=output_dir, num_train_epochs=3)
    )
    trainer.train()
    trainer.save_model(output_dir)

使用 modal run finetune.py --dataset_path s3://my-bucket/data --output_dir /mnt/output 部署。Modal 将输出目录挂载到持久化存储。

定价和成本优化 #

Modal 根据容器实际使用的资源收费：

资源	价格（约）
A10G GPU	$0.60/小时
L4 GPU	$0.80/小时
A100-80GB	$2.50/小时
H100 GPU	$4.00/小时
vCPU（每秒）	$0.000025/秒
内存（每 GB 小时）	$0.003/GB 小时

以上为约值；查看 modal.com/pricing 获取最新费率。

成本优化策略 #

策略一：合理选择 GPU 规格

# 不要用 H100 跑 3B 参数模型
# 改用 A10G——节省 75% 成本
@stub.function(gpu="A10G", memory=4096)
def light_inference(prompt: str):
    model = load_small_model()  # 3B 参数轻松容纳
    return model.generate(prompt)

# 仅大规模微调时使用 H100
@stub.function(gpu="H100-80GB", memory=32768)
def heavy_finetune(config: dict):
    return run_large_scale_training(config)

策略二：战略性使用 keep_warm

# 可预测流量：仅在业务时段保持预热
@stub.function(gpu="L4", keep_warm=1)
def production_endpoint():
    ...

# 突发流量：提高 concurrency_limit
@stub.function(gpu="L4", concurrency_limit=50, keep_warm=3)
def bursty_endpoint():
    ...

策略三：使用 @stub.cls 复用容器

基于类的方法将状态保留在内存中，避免重复加载模型。这对 LLM 工作负载至关重要——加载模型需要 2-5 分钟。

# ❌ 不好：每次调用都加载模型
@stub.function(gpu="A10G")
def bad_approach(prompt: str):
    model = load_model()  # 每次调用重新加载！
    return model.generate(prompt)

# ✅ 好：加载一次，跨请求复用
@stub.cls(gpu="A10G")
class GoodApproach:
    @modal.enter()
    def setup(self):
        self.model = load_model()  # 启动时加载一次
    
    @modal.method()
    def generate(self, prompt: str):
        return self.model.generate(prompt)  # 复用已加载的模型

真实世界成本对比 #

工作负载	AWS EC2 (p4d)	Modal	节省
Llama 3.2 3B 推理（100 请求/分钟）	$2,200/月（常驻）	$180/月（按需）	92%
微调 8 小时任务	$200（预留）	$20（实际使用）	90%
批量嵌入 100 万文档	$500（集群管理）	$85（纯计算）	83%

高级功能 #

密钥管理 #

永远不要硬编码 API 密钥。Modal 的密钥管理器在运行时注入凭据：

import modal

stub = modal.Stub("secret-demo")

@stub.function(
    secrets=[
        modal.Secret.from_name("huggingface-token"),
        modal.Secret.from_name("openai-key"),
    ]
)
def secure_inference(prompt: str):
    import os
    hf_token = os.environ["HF_TOKEN"]  # 从密钥注入
    openai_key = os.environ["OPENAI_API_KEY"]
    return call_api(prompt, hf_token, openai_key)

一次性创建密钥：

modal secret create huggingface-token HF_TOKEN=your_token_here
modal secret create openai-key OPENAI_API_KEY=sk-...

持久化存储的卷挂载 #

Modal 卷提供跨函数调用的共享持久化文件系统：

# 为模型检查点创建卷
checkpoint_volume = modal.Volume.from_name("model-checkpoints", create_if_missing=True)

@stub.function(
    gpu="A100-80GB",
    volumes={"/checkpoints": checkpoint_volume},
    timeout=7200
)
def fine_tune_and_save(dataset_url: str):
    # 加载数据集
    dataset = load_dataset(dataset_url)
    
    # 训练并保存到挂载卷
    trainer.train()
    trainer.save_model("/checkpoints/final-model")
    
    print(f"检查点已保存到卷。大小: {os.path.getsize('/checkpoints/final-model')}")

# 从另一个函数访问保存的模型
@stub.function(volumes={"/checkpoints": checkpoint_volume})
def load_and_infer(prompt: str):
    model = AutoModelForCausalLM.from_pretrained("/checkpoints/final-model")
    return model.generate(prompt)

卷在函数调用间持久化数据，非常适合模型检查点、数据集和缓存目录。

出口控制 #

管理出站网络访问以确保安全和成本：

@stub.function(
    gpu="L4",
    network_mounts={"/etc/resolv.conf": modal.NetworkMount()},
    blocked_subnets=["169.254.0.0/16"],  # 阻止元数据服务
    allowed_domains=["api.openai.com"]   # 仅允许特定域名
)
def restricted_inference(prompt: str):
    return call_openai(prompt)

自定义 Docker 镜像 #

对于 pip_install 无法覆盖的复杂依赖：

custom_image = (
    modal.Image.from_dockerhub("nvidia/cuda:12.2.0-devel-ubuntu22.04")
    .apt_install("git", "cmake", "build-essential")
    .pip_install("torch", "transformers", "bitsandbytes")
    .copy_local_dir("./my-custom-model", "/app/model")
)

@stub.function(image=custom_image, gpu="A100-80GB")
def custom_model_inference(request: dict):
    model = torch.load("/app/model/best.pt")
    return model.predict(request["input"])

常见问题排查 #

问题一：推理期间容器 OOM 崩溃 #

错误：因内存限制超出而终止容器

修复：增加内存分配并启用交换：

@stub.cls(
    gpu="A100-80GB",
    memory=32768,  # 大模型需要 32GB RAM
    ephemeral_disk=100_000  # 模型权重需要 100GB 磁盘
)
class LargeModel:
    @modal.enter()
    def load(self):
        self.model = AutoModel.from_pretrained(
            "big-model",
            torch_dtype=torch.float16,  # 使用半精度
            device_map="auto"
        )

问题二：首次请求冷启动慢 #

警告：首次请求耗时 180 秒（模型加载）

修复：使用 keep_warm 预预热容器：

@stub.cls(
    gpu="A10G",
    keep_warm=3,  # 始终保持 3 个预热容器
    timeout=600
)
class WarmEndpoint:
    @modal.enter()
    def load(self):
        self.model = load_model()
        print("模型加载成功")

问题三：长时间微调任务超时 #

错误：函数在 3600 秒后超时

修复：增加超时并使用卷保存检查点：

@stub.function(
    gpu="H100-80GB",
    timeout=28800,  # 8 小时
    volumes={"/data": modal.Volume.from_name("training-data")}
)
def long_training_job(config_path: str):
    for epoch in range(10):
        train_epoch(config_path)
        if epoch % 2 == 0:
            save_checkpoint(f"/data/checkpoint-{epoch}")

问题四：并发限流 #

错误：太多并发输入（限制：10）

修复：调整并发设置：

@stub.cls(
    gpu="L4",
    concurrency_limit=100,       # 最大容器数
    allow_concurrent_inputs=20,  # 每个容器的请求数
    keep_warm=5                  # 预热池大小
)
class ScalableEndpoint:
    @modal.method()
    def handle(self, request: dict):
        return process(request)

未来方向 #

Modal 持续大力投资 ML 基础设施。即将推出的关键功能包括：

多节点分布式训练：原生支持跨 8+ GPU 的训练，自动数据并行
GPU 共享：低流量时段通过时间切片提升 GPU 利用率
自定义 GPU 类型：支持下一代 GPU（Blackwell B200）
边缘部署：将 Modal 函数部署到边缘节点，实现亚 50ms 推理延迟
原生向量数据库集成：基于 Modal 存储层的内置向量搜索

选择 Modal 当：

你想在数小时内而非数周内交付 ML 工作负载
你的工作负载是间歇性的（批量任务、低频推理）
你需要 GPU 访问而无需集群管理
你的团队以 Python 为主，希望最小化 DevOps

考虑替代方案当：

你需要绝对最低延迟（<10ms）——裸金属或专用实例胜出
你有可预测的 24/7 高吞吐量——预留实例可能更便宜
你需要自定义内核修改——Modal 使用标准容器镜像
你深度投入特定云的生态系统——原生服务可能集成更好

社区动态 #

无服务器 GPU 领域正在迅速升温。2026 年年中，多家新进入者加入市场：

RunPod Serverless 推出有竞争力的 GPU 定价，A10G 起价 $0.30/小时
Replicate 将其预打包 ML 模型库扩展到 500+ 个
AWS Lambda GPU 宣布 Graviton4 + Inferentia2 组合全面可用

尽管竞争加剧，Modal 在开发者体验方面仍保持领先——Python 原生 API 意味着团队无需学习 YAML、Helm 图表或 Terraform，就能从原型快速走向生产。

Modal 上的社区驱动模型注册表已增长到超过 2,000 个模型，涵盖从 LLM 到扩散模型到语音识别的所有领域。用户可以用一行 Python 代码浏览、测试和部署任何注册模型。

FAQ #

Modal 消除了管理 GPU 实例的运维开销。在 EC2 上，你需要处理抢占式实例中断、驱动更新、GPU 监控和自动伸缩配置。使用 Modal，所有这些都被抽象掉了——你只需编写 Python 函数。对于间歇性工作负载，Modal 通常便宜 70-90%，因为你只为实际计算时间付费，而不是让实例全天候运行。

可以。Modal 与 Hugging Face 模型无缝协作。只需在镜像中安装 transformers 库，然后使用标准的 AutoModel.from_pretrained() API 加载模型。你也可以将 Hugging Face token 作为 Modal 密钥挂载以访问私有模型。许多用户报告 100 亿参数以下模型的加载时间为 30-60 秒。

Q: 如果 GPU 容器在请求中途崩溃怎么办？ #

Modal 使用可配置的重试策略自动重试失败的容器。对于推理端点，你可以在函数定义中设置 retries=3。对于训练任务，Modal 支持基于检查点的恢复——将检查点保存到 Modal 卷，重试时从上次检查点恢复，而不是从头重启。

Q: 有免费层可以用于测试吗？ #

Modal 为新账户提供免费额度，通常足以获得 10-20 小时的 A10G 计算。这足以在承诺付费之前原型化和测试大多数 ML 工作负载。无需信用卡即可开始。

Modal 在 modal.com/apps 提供 Web 仪表板，显示实时指标：调用次数、延迟百分位数、错误率和 GPU 利用率。你还可以从 CLI 直接流式传输日志 modal logs <app-name>，并为错误阈值或成本限制设置警报。

目前，Modal 仅在其托管云基础设施上运行。他们不提供本地部署选项。对于隔离环境，考虑使用带 Kubernetes 的 vLLM 或 Ray Serve，它们可以在你自己的基础设施内完全运行。

参考资料 #

加入我们的 Telegram 群组获取实时 AI 工具讨论和部署技巧：t.me/dibi8