在实际的大模型部署和推理场景中，模型参数量巨大，对计算资源和内存带宽构成了严峻挑战。量化技术，特别是将模型权重和激活值从高精度（如FP32）转换为低精度（如INT8），是降低模型存储和计算开销、提升推理速度的关键手段。然而，简单的训练后量化（Post-Training Quantization, PTQ）往往会导致精度显著下降，尤其是在处理大模型复杂的激活分布时。量化感知训练（Quantization-Aware Training, QAT）通过在训练过程中模拟量化效应，让模型“提前适应”低精度计算，成为在保持高精度前提下实现高效推理的主流方案。本文将深入解析大模型QAT的原理，并提供一个从环境搭建到训练验证的完整实战流程，目标是让你不仅能理解QAT如何工作，更能亲手为一个中等规模的模型（如BERT或小型LLaMA）实施QAT，并获得可验证的量化模型。

1. 理解量化感知训练的核心原理与价值

量化感知训练并非在训练时真的使用低精度运算，而是通过插入“假量化”（Fake Quantization）节点来模拟量化过程中的舍入和截断效应。其核心思想是让模型在训练的前向传播中“感受”量化带来的噪声，并在反向传播中根据这些噪声调整权重，从而使最终模型对量化操作更加鲁棒。

1.1 从训练后量化到量化感知训练的演进

训练后量化（PTQ）流程简单：先训练一个全精度模型，然后直接对其权重和激活进行校准和量化。这种方法速度快，但精度损失可能较大，尤其是当模型激活值分布不均匀或存在异常值时。量化感知训练（QAT）则将量化模拟过程嵌入到训练循环中。在训练的前向传播时，权重和激活会先经过一个模拟的量化-反量化（Quantize-Dequantize, QDQ）过程，再参与计算。反向传播时，梯度会通过这个模拟的量化节点（通常使用直通估计器STE）传回，从而更新全精度权重。这样训练出的模型，其权重在本质上已经为后续的真实量化做好了准备。

1.2 QAT中的关键操作：量化、反量化与直通估计器

一个典型的假量化操作包含以下步骤：

  1. 量化（Quantize） ：将浮点数 x 映射到整数域。公式通常为： q = round(x / scale) + zero_point 。其中， scale （缩放因子）和 zero_point （零点）是量化参数，决定了浮点数到整数的映射关系。
  2. 反量化（Dequantize） ：将量化后的整数映射回浮点数，以模拟量化误差： x_q = (q - zero_point) * scale 。这个 x_q 就是带有量化噪声的近似值，用于后续计算。
  3. 直通估计器（Straight-Through Estimator, STE） ：在反向传播时，量化操作的梯度在理论上是不连续的（ round 函数梯度几乎处处为0）。STE 是一种技巧，它假设量化操作的梯度为1，即 dL/dx = dL/dx_q 。这使得梯度可以绕过不可微的 round 操作，直接传播到上游。

通过这种方式，模型在训练中不断“体验”并适应由 scale 和 zero_point 引入的噪声，最终学到的权重在真实量化后表现更好。

1.3 大模型QAT的特殊挑战与应对策略

大模型（如Transformer架构的LLM）的QAT面临独特挑战：

  • 激活值动态范围大 ：不同层、不同token的激活值分布差异显著，固定的量化参数可能不适用。
  • 计算图复杂 ：包含注意力机制、层归一化等复杂操作，需要精心设计量化节点的插入位置。
  • 训练成本高 ：对超大模型进行完整的QAT微调，计算资源消耗巨大。

因此，大模型QAT实践中常采用以下策略：

  • 部分量化 ：仅对线性层（如QKV投影、FFN）的权重和激活进行量化，而对层归一化、Softmax等对数值精度敏感的操作保持高精度。
  • 分层校准 ：为不同层甚至不同通道独立学习 scale 和 zero_point （即每通道量化），以更好地适应激活分布。
  • 两阶段训练 ：先在全精度下微调模型，再插入假量化节点进行QAT微调，最后导出量化模型。这比从头开始QAT更高效。

2. 环境准备与依赖配置

为了进行QAT实战，我们需要搭建一个包含深度学习框架、量化工具库和示例模型的开发环境。以下步骤以PyTorch为例，因为它提供了相对完善的QAT工具支持。

2.1 基础环境与PyTorch安装

首先确保你的环境有Python（建议3.8-3.10）和pip。然后安装PyTorch。请根据你的CUDA版本（如果有GPU）前往 PyTorch官网 获取准确的安装命令。例如，对于CUDA 11.8：

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

对于仅使用CPU的环境：

pip install torch torchvision torchaudio

2.2 安装量化与模型相关库

我们需要安装一些用于量化和模型处理的额外库：

  • torch.ao.quantization ：PyTorch内置的量化库（旧版本为 torch.quantization ）。
  • transformers ：Hugging Face库，用于加载和预处理预训练模型。
  • datasets ：用于加载训练和评估数据。
  • evaluate ：用于模型评估。
pip install transformers datasets evaluate

2.3 验证环境与硬件

创建一个简单的Python脚本来验证环境是否就绪：

import torch
import transformers
print(f"PyTorch version: {torch.__version__}")
print(f"Transformers version: {transformers.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")

运行后应能看到版本信息和GPU状态（如果可用）。

3. 项目实战：为BERT模型实施量化感知训练

我们将以一个经典的BERT-base模型在GLUE的MRPC（微软研究释义语料库）任务上的微调为例，演示完整的QAT流程。MRPC是一个句子对二分类任务，判断两个句子是否语义等价。

3.1 准备模型与数据

首先，加载预训练的BERT模型和分词器，并准备MRPC数据集。

from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
from datasets import load_dataset
import torch
from torch.ao.quantization import QuantStub, DeQuantStub, prepare_qat, convert

# 1. 加载模型和分词器
model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
# 注意：我们需要加载用于序列分类的模型
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# 2. 加载并预处理MRPC数据集
dataset = load_dataset("glue", "mrpc")

def tokenize_function(examples):
    return tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, padding="max_length", max_length=128)

tokenized_datasets = dataset.map(tokenize_function, batched=True)
tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
tokenized_datasets.set_format("torch", columns=["input_ids", "attention_mask", "labels"])

# 分割训练集和评估集
train_dataset = tokenized_datasets["train"]
eval_dataset = tokenized_datasets["validation"]

3.2 修改模型以支持QAT

PyTorch的QAT需要我们在模型定义中显式地插入 QuantStub 和 DeQuantStub 来标记量化开始和结束的位置。对于Transformer模型，通常我们在模型输入处插入 QuantStub ，在输出处插入 DeQuantStub 。更精细的做法是对每个需要量化的子模块（如 nn.Linear ）进行包装。这里我们采用一个简化的全局方法。

我们需要创建一个继承自原模型的新类，并插入量化存根。由于 transformers 库的模型结构复杂，更实用的方法是在训练前使用 torch.ao.quantization.quantize_dynamic 进行动态量化（一种PTQ）作为对比基线，或者使用 torch.ao.quantization.prepare_qat 对模型进行准备。 prepare_qat 会自动为模型中的可量化模块（如 nn.Conv2d , nn.Linear ）添加观察者（Observer）和假量化节点。

关键步骤：准备QAT模型 

# 定义量化配置（使用默认的QAT配置）
model.qconfig = torch.ao.quantization.get_default_qat_qconfig('fbgemm') # 用于服务器端推理的配置
# 如果是移动端，可以使用 'qnnpack'

# 确保模型处于训练模式（QAT必须在训练模式下准备）
model.train()

# 融合模型中可以融合的模块（例如Conv+Bn，对于BERT主要是Linear+激活函数，但transformers模型结构特殊，此步可能不适用，可跳过）
# model_fused = torch.ao.quantization.fuse_modules(model, [['layer1.0', 'layer1.0.relu']]) # 示例，对BERT不直接适用

# 准备模型进行QAT。这会插入假量化节点。
model_prepared = torch.ao.quantization.prepare_qat(model)

注意 ： prepare_qat 会就地修改模型。对于复杂的 transformers 模型，自动插入量化节点可能会遇到问题。在实际生产环境中，可能需要更手动地定义哪些层需要量化，或者使用专门为Transformer优化过的量化工具库（如Intel的 Neural Compressor、NVIDIA的 TensorRT 或 Qualcomm的 AIMET）。

3.3 定义QAT训练循环

我们将使用Hugging Face的 Trainer API，但需要对其进行定制以兼容QAT模型。 Trainer 本身不直接处理QAT特有的逻辑，但我们可以通过自定义训练步骤或在训练前后添加钩子来实现。

一个更直接的方法是使用标准的PyTorch训练循环，以便更精细地控制量化节点的行为。

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

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model_prepared.to(device)

# 定义优化器
optimizer = AdamW(model_prepared.parameters(), lr=2e-5)

# 简单的训练循环（示例，仅展示思路）
num_epochs = 3
for epoch in range(num_epochs):
    model_prepared.train()
    total_loss = 0
    # 这里使用一个小的数据子集进行演示
    train_dataloader = torch.utils.data.DataLoader(train_dataset.select(range(100)), batch_size=8, shuffle=True)
    
    for batch in tqdm(train_dataloader, desc=f"Epoch {epoch+1}"):
        batch = {k: v.to(device) for k, v in batch.items()}
        optimizer.zero_grad()
        
        # 前向传播：在QAT模型中，假量化节点会自动生效
        outputs = model_prepared(**batch)
        loss = outputs.loss
        total_loss += loss.item()
        
        # 反向传播
        loss.backward()
        optimizer.step()
    
    avg_loss = total_loss / len(train_dataloader)
    print(f"Epoch {epoch+1}, Average Loss: {avg_loss:.4f}")

    # 每个epoch后可以评估一下（注意评估时要将模型切换到eval模式，并禁用假量化？）
    # 在PyTorch QAT中，评估时通常使用 `model.eval()` 并调用 `torch.ao.quantization.convert` 进行转换。
    # 但为了观察训练过程中的验证集表现，我们可以暂时不转换，而是使用 `model_prepared.eval()` 并启用观察者收集统计信息。
    # 更常见的做法是：先完成所有QAT训练，再统一转换和评估。

3.4 转换量化模型并评估

QAT训练完成后，我们需要将模型转换为真正的量化模型（INT8）。转换过程会移除假量化节点，并将浮点权重替换为量化后的整数权重，同时生成必要的量化参数。

# 训练完成后，将模型设置为评估模式
model_prepared.eval()

# 转换为量化模型
model_quantized = torch.ao.quantization.convert(model_prepared)

# 保存量化模型
torch.save(model_quantized.state_dict(), "quantized_bert_mrpc.pth")
# 注意：转换后的模型结构可能发生变化，直接加载可能需要对应的量化模型定义。
# 更稳妥的方式是保存和加载整个模型（包括结构）。
torch.jit.save(torch.jit.script(model_quantized), "quantized_bert_mrpc_scripted.pt") # 尝试脚本化保存（可能因模型复杂度失败）

print("量化模型已保存。")

评估量化模型性能 ： 我们需要在评估集上比较全精度模型和量化模型的精度。由于转换后的模型是静态量化图，我们需要用与训练时相同的方式准备输入数据。

from evaluate import load as load_metric
import numpy as np

metric = load_metric("glue", "mrpc")

def evaluate_model(model_to_eval, eval_ds):
    model_to_eval.eval()
    eval_dataloader = torch.utils.data.DataLoader(eval_ds, batch_size=8)
    all_preds = []
    all_labels = []
    for batch in eval_dataloader:
        batch = {k: v.to(device) for k, v in batch.items()}
        with torch.no_grad():
            outputs = model_to_eval(**batch)
        logits = outputs.logits
        predictions = torch.argmax(logits, dim=-1)
        all_preds.extend(predictions.cpu().numpy())
        all_labels.extend(batch["labels"].cpu().numpy())
    return metric.compute(predictions=all_preds, references=all_labels)

# 评估原始全精度模型（需要重新加载或使用之前保存的）
# fp32_model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2).to(device)
# fp32_metrics = evaluate_model(fp32_model, eval_dataset)
# print(f"全精度模型评估结果: {fp32_metrics}")

# 评估量化模型 (注意：model_quantized 已经在 device 上)
quantized_metrics = evaluate_model(model_quantized, eval_dataset)
print(f"量化模型评估结果: {quantized_metrics}")

3.5 模型大小与推理速度对比

量化最主要的收益在于模型压缩和加速。我们可以对比一下模型文件大小和单次推理的耗时。

import os
import time

# 1. 模型大小对比
# 假设我们保存了全精度模型的状态字典
# torch.save(fp32_model.state_dict(), "fp32_bert_mrpc.pth")
fp32_size = os.path.getsize("fp32_bert_mrpc.pth") / (1024**2) # MB
quantized_size = os.path.getsize("quantized_bert_mrpc.pth") / (1024**2) # MB
print(f"全精度模型大小: {fp32_size:.2f} MB")
print(f"量化模型大小: {quantized_size:.2f} MB")
print(f"压缩比: {fp32_size/quantized_size:.2f}x")

# 2. 推理速度对比（示例，需在GPU上并多次测量取平均）
def inference_time_test(model, sample_input):
    model.eval()
    times = []
    with torch.no_grad():
        for _ in range(100): # 预热
            _ = model(**sample_input)
        for _ in range(200):
            start = time.time()
            _ = model(**sample_input)
            if torch.cuda.is_available():
                torch.cuda.synchronize()
            end = time.time()
            times.append(end - start)
    return np.mean(times) * 1000 # 转换为毫秒

# 准备一个样本输入
sample_batch = next(iter(torch.utils.data.DataLoader(eval_dataset, batch_size=1)))
sample_batch = {k: v.to(device) for k, v in sample_batch.items()}

# fp32_time = inference_time_test(fp32_model, sample_batch)
quantized_time = inference_time_test(model_quantized, sample_batch)
# print(f"全精度模型平均推理耗时: {fp32_time:.2f} ms")
print(f"量化模型平均推理耗时: {quantized_time:.2f} ms")
# print(f"加速比: {fp32_time/quantized_time:.2f}x")

4. 关键参数、配置与常见问题排查

成功实施QAT依赖于对一系列参数和配置的正确理解。以下是核心要素和常见陷阱。

4.1 量化配置详解

qconfig 决定了如何量化。 torch.ao.quantization.get_default_qat_qconfig 提供了预设配置。

  • 后端（backend） ： ‘fbgemm’ 适用于服务器端CPU（支持AVX2）， ‘qnnpack’ 适用于ARM CPU（如移动端）。GPU推理通常使用TensorRT或CUDA相关的后端，PyTorch原生支持有限。
  • 激活量化方案 ：默认使用 MovingAverageMinMaxObserver 观察激活值范围，并使用 FakeQuantize 进行假量化。
  • 权重量化方案 ：默认使用 MovingAverageMinMaxObserver 观察权重，并进行假量化。

你可以自定义 qconfig ：

from torch.ao.quantization import MinMaxObserver, PerChannelMinMaxObserver, FakeQuantize, default_qat_qconfig
# 例如，使用每通道量化权重（通常精度更高）
custom_qconfig = torch.ao.quantization.QConfig(
    activation=FakeQuantize.with_args(observer=MinMaxObserver, dtype=torch.quint8),
    weight=FakeQuantize.with_args(observer=PerChannelMinMaxObserver, dtype=torch.qint8)
)
model.qconfig = custom_qconfig

4.2 QAT流程检查清单

为确保QAT流程正确，请按以下清单检查：

步骤 检查项 目的与说明
准备阶段 模型处于 .train() 模式 prepare_qat 必须在训练模式下调用。
为模型设置了正确的 qconfig 指定量化的位宽、观察者类型等。
成功调用了 prepare_qat(model) 插入假量化节点和观察者。
训练阶段 训练数据正常加载和预处理 确保输入数据格式与模型匹配。
损失函数正常下降（初期） 表明模型在学习适应量化噪声。
使用了合适的优化器和学习率 QAT微调通常使用较小的学习率（如原学习率的1/10到1/100）。
转换阶段 训练完成后调用 model.eval() 将模型切换到评估模式。
成功调用 convert(model) 移除假量化节点，生成真正的量化模型。
评估阶段 量化模型加载正确 确保模型结构和参数匹配。
评估数据集处理方式与训练一致 避免因数据处理不一致导致性能偏差。
对比了全精度模型的精度 量化精度损失应在可接受范围内（例如<1%）。

4.3 常见问题与排查路径

在QAT实践中，你可能会遇到以下典型问题：

问题现象 可能原因 排查步骤与解决方案
精度损失巨大 1. 量化配置过于激进（如位宽太低）。
2. 对敏感层（如注意力输出、层归一化）进行了量化。
3. QAT训练轮次不足或学习率不当。
4. 激活值分布存在极端异常值。		 1. 检查 qconfig ，尝试使用INT8而不是更低精度。
2. 检查 prepare_qat 插入了哪些层，考虑跳过敏感层（手动修改模型或使用 quantization.ignore ）。
3. 增加QAT微调轮次，降低学习率，使用学习率热身。
4. 使用 HistogramObserver 观察激活分布，考虑使用 reduce_range 选项或对称量化。
模型无法转换（convert报错） 1. 模型中存在不支持量化的操作。
2. 模型在 convert 前未处于 .eval() 模式。
3. 自定义模块未正确注册。		 1. 检查模型结构，确保所有操作都在PyTorch量化支持列表中。复杂操作可能需要手动实现量化版本。
2. 确保在 convert 前调用 model.eval() 。
3. 对于自定义 nn.Module ，需要使用 torch.ao.quantization.QuantStub / DeQuantStub 或 torch.ao.quantization.quantize_dynamic 。
QAT训练后模型大小未减小 1. 仅保存了状态字典（ .pth ），其中仍包含浮点权重。
2. 未成功调用 convert ，保存的仍是包含假量化节点的训练模型。		 1. convert 操作会将浮点参数替换为量化参数（ scale 和 zero_point ）和低比特整数权重。确保保存的是转换后的模型。
2. 检查转换流程，确认 model_quantized 的参数类型（如 torch.qint8 ）。
推理速度没有提升甚至下降 1. 在不支持硬件加速的CPU上运行INT8推理。
2. 模型太小，量化开销抵消了计算收益。
3. 数据预处理或IO成为瓶颈。		 1. 确保在支持INT8指令集（如AVX-512 VNNI, ARM NEON dot product）的硬件上运行，或使用专用推理引擎（如TensorRT, OpenVINO）。
2. 对于小模型，量化收益有限。关注内存带宽节省。
3. 对推理流程进行 profiling，找到瓶颈。
动态形状支持问题 转换后的静态量化图可能对输入形状有固定要求。 1. 在QAT和转换时使用固定的输入形状。
2. 考虑使用支持动态形状的量化方法或推理引擎（如TorchScript的某些模式、ONNX Runtime、TensorRT）。
3. 对于可变长度输入，使用填充到最大长度并配合注意力掩码。

5. 大模型QAT的最佳实践与扩展方向

将QAT应用于百亿甚至千亿参数的大模型时，需要更精细的策略和工程优化。

5.1 针对大模型的优化策略

  1. 分层与选择性量化 ：
    • 权重量化 ：几乎所有线性层的权重都可以安全地量化到INT8，通常精度损失很小。
    • 激活量化 ：这是精度损失的主要来源。建议对注意力机制的 Q/K/V 投影和输出投影层、FFN的上层进行激活量化尝试，而对LayerNorm、Softmax、残差连接等保持FP16/BF16。可以使用逐层敏感度分析工具来确定哪些层的激活量化对精度影响最大。
  2. 混合精度训练 ：
    • 在进行QAT微调时，可以使用混合精度训练（AMP）。让模型权重、优化器状态以FP16/BF16存储和更新，仅在模拟量化的前向传播环节进行FP32->INT8->FP32的假量化操作。这能显著减少显存占用并加速训练。
  3. 使用更先进的量化方案 ：
    • SmoothQuant ：通过数学变换将激活量化的难度部分转移到权重上，从而在保持权重量化的同时，使激活值更易于量化，特别适合处理激活值异常值问题。
    • AWQ (Activation-aware Weight Quantization) 和 GPTQ ：属于训练后量化范畴，但通过利用少量校准数据调整权重，也能达到接近QAT的效果，且无需训练。可作为QAT的替代或补充方案。
  4. 借助专用工具链 ：
    • TensorRT ：NVIDIA的推理优化器，支持QAT模型的导入和部署，并能进行进一步的图层融合、内核优化，在GPU上获得极致性能。
    • Intel Neural Compressor ：提供丰富的量化算法（包括QAT）和对PyTorch、TensorFlow等框架的支持，特别针对CPU优化。
    • Qualcomm AIMET ：提供模型量化、稀疏化等工具，对移动端芯片有良好支持。

5.2 生产环境部署考量

在实验室跑通QAT只是第一步，生产部署需要考虑更多：

  1. 版本与兼容性 ：确保训练框架（PyTorch）、量化工具、推理引擎（如LibTorch, ONNX Runtime, TensorRT）的版本严格兼容。量化模型的序列化格式可能因版本而异。
  2. 性能基准测试 ：在目标硬件（特定型号的CPU、GPU或边缘设备）上，使用真实的生产输入数据分布，对量化模型进行全面的性能测试，包括吞吐量、延迟、功耗和精度。
  3. 监控与回滚 ：部署后，持续监控量化模型的线上指标（如预测分布、响应时间）。建立快速回滚机制，一旦发现精度漂移或性能异常，能立即切换回全精度模型。
  4. 流水线集成 ：将QAT作为模型开发流水线的一环。例如：全精度训练 -> QAT微调 -> 转换验证 -> 性能测试 -> 打包部署。自动化此流程以提高效率。

5.3 下一步学习路径

要深入掌握大模型量化，建议按以下路径探索：

  1. 理论基础 ：深入阅读关于量化、STE、量化参数校准（MinMax, KL散度）的论文。
  2. 框架深入 ：研究PyTorch Quantization API的源代码，理解 FakeQuantize , Observer , QConfig 等类的实现。
  3. 工具链实践 ：
    • 尝试使用 TensorRT 部署一个QAT后的模型，并比较与PyTorch原生推理的性能差异。
    • 学习使用 ONNX 格式导出量化模型，并在 ONNX Runtime 上运行。
  4. 前沿方案 ：学习 SmoothQuant 、 AWQ 、 GPTQ 等先进量化算法的原理和实现，理解它们如何解决大模型量化的特定难题。
  5. 全栈优化 ：将量化与模型压缩的其他技术（如剪枝、蒸馏）结合，探索复合优化策略。同时，了解硬件指令集（如Intel AVX-512 INT8, NVIDIA Tensor Core）如何加速量化计算。

量化感知训练是实现大模型高效部署不可或缺的技术。它平衡了模型精度与推理效率，但其成功实施依赖于对模型结构、量化原理和工具链的深刻理解。从一个小型模型（如BERT）开始实战，逐步理解每个步骤背后的“为什么”，是构建处理百亿参数大模型量化能力最扎实的起点。在实际项目中，务必进行充分的验证测试，并将量化模型与基线模型在业务指标上进行严谨对比，确保优化真正带来了价值。

Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区