大模型推理加速的几种思路

网上关于这个的资料不少，但很多都只讲原理不给代码。这里补一个完整的可运行示例，亲测有效。

先搞清楚原理

推理加速的底层原理涉及超参数调优。用代码演示比画图更直观：

import torch
import torch.nn as nn

class VAE(nn.Module):
    def __init__(self, input_dim=784, hidden_dim=400, latent_dim=20):
        super().__init__()
        self.encoder = nn.Sequential(nn.Linear(input_dim, hidden_dim), nn.ReLU())
        self.mu_head = nn.Linear(hidden_dim, latent_dim)
        self.logvar_head = nn.Linear(hidden_dim, latent_dim)
        self.decoder = nn.Sequential(nn.Linear(latent_dim, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, input_dim), nn.Sigmoid())

    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5 * logvar)
        eps = torch.randn_like(std)
        return mu + eps * std

    def forward(self, x):
        h = self.encoder(x)
        mu, logvar = self.mu_head(h), self.logvar_head(h)
        z = self.reparameterize(mu, logvar)
        return self.decoder(z), mu, logvar

model = VAE()
x = torch.randn(16, 784)
out, mu, logvar = model(x)
print(f"VAE输出: {out.shape}, mu: {mu.shape}")

实际怎么用

写代码的时候，推理加速有几个常见写法。推荐用下面这种方式，代码更清晰，也更容易维护：

import torch
import torch.nn as nn
from torch.optim import AdamW

model = nn.Sequential(
    nn.Linear(100, 256), nn.ReLU(), nn.Dropout(0.2),
    nn.Linear(256, 128), nn.ReLU(),
    nn.Linear(128, 10),
)

optimizer = AdamW(model.parameters(), lr=0.0005, weight_decay=0.01)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=20)
criterion = nn.CrossEntropyLoss()

for epoch in range(20):
    x = torch.randn(32, 100)
    y = torch.randint(0, 10, (32,))
    optimizer.zero_grad()
    loss = criterion(model(x), y)
    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
    optimizer.step()
    scheduler.step()
    if epoch % 5 == 0:
        print(f"Epoch {epoch}: loss={loss.item():.4f}, lr={scheduler.get_last_lr()[0]:.6f}")

进阶一点的用法

推理加速在复杂场景下的用法和简单场景差别挺大。主要是数据驱动的模式学习这块需要额外处理，代码如下：

容易踩的坑

说几个容易踩的坑。第一个是超参数调优的问题，很多人在这上面栽过跟头。第二个是版本兼容性，不同版本行为可能不一样。第三个是边界情况，空值和异常输入要处理好。

写在最后

总结一下，推理加速的关键在于数据驱动的模式学习。掌握了这个，其他用法都是在这个基础上扩展。建议多写几个小demo练手，光看不动手容易忘。