1. 大模型文件加载：从“下载”到“跑起来”的第一步

如果你刚接触大模型，可能会觉得这事儿挺玄乎的：动辄几十GB的模型文件，怎么才能让它从硬盘里“活”过来，开始跟你对话、写代码、分析问题呢？其实，这个过程——文件加载——就是大模型应用中最基础、也最关键的一环。你可以把它想象成组装一台复杂的乐高模型，模型文件就是那一袋袋的零件和说明书，而加载过程，就是按照说明书，把成千上万个零件（参数）精准地放到正确的位置上，最终拼成一个能运转的智能机器。

我刚开始玩大模型的时候，就在加载这一步踩过不少坑。比如，好不容易从网上下载了一个几十G的模型，结果因为框架版本不匹配，死活加载不进去；或者加载成功了，但推理速度慢得像蜗牛，完全没法用。后来我才明白，文件加载远不止一个 load() 函数那么简单。它涉及到框架选择、格式兼容、硬件适配、性能调优等一系列问题。不同的文件格式，背后对应着不同的设计哲学和应用场景。PyTorch 的 .pt 文件灵活，适合研究和魔改；TensorFlow 的 SavedModel 打包完整，适合一键部署；ONNX 格式则像是个“中间翻译”，能让模型在不同的框架和硬件上跑起来。

这篇文章，我就以一个过来人的身份，跟你详细拆解大模型文件加载的实战全流程。我们不谈空洞的理论，就聊具体怎么操作、会遇到哪些问题、以及怎么解决。无论你是想快速体验一下大模型，还是打算深入做二次开发，相信这篇“避坑指南”都能帮你省下大量摸索的时间。我们的目标很简单：让你拿到任意一个主流大模型文件，都能稳稳当当地把它加载起来，并跑出最优的性能。

2. 核心文件拆解：模型“启动包”里都有什么？

在动手加载之前，我们得先搞清楚，从 Hugging Face 或模型官网下载下来的那个压缩包，解压后那一堆文件都是干嘛的。这就像拿到一个软件的安装包，里面肯定不止一个可执行文件。理解每个文件的作用，是成功加载的前提。

2.1 模型权重文件：模型的“记忆”与“技能”

这是最核心的文件，通常也是体积最大的。它存储了模型经过海量数据训练后学到的所有参数，也就是模型的“记忆”和“技能”。没有它，模型架构就是个空壳。常见的格式有：

  • .bin / .pth / .pt (PyTorch)：这是最常见的一种。.pth 或 .pt 通常是 PyTorch 的 torch.save() 保存的，可能只包含权重字典（state_dict），也可能包含整个模型对象和优化器状态。而 .bin 是 Hugging Face Transformers 库常用的一种更通用的二进制权重格式。
  • .safetensors (Hugging Face Safetensors)：这是 Hugging Face 大力推广的新格式。我实测下来，它的安全性和加载速度优势非常明显。它通过加密和校验机制，能有效防止模型文件被恶意篡改。更重要的是，它的加载方式避免了 Python 的 pickle 反序列化，速度更快，也更安全。现在很多新模型都首选这个格式。
  • .h5 (Keras/TensorFlow)：基于 HDF5 格式，在 TensorFlow 1.x 和 Keras 中很常见，可以同时保存模型结构和权重。
  • .ckpt (TensorFlow Checkpoint)：TensorFlow 的训练检查点文件，主要保存权重，也可能包含优化器状态等。
  • 分片文件：对于超大型模型（如百亿、千亿参数），一个文件可能太大，因此会被切分成多个分片，例如：
    model.safetensors.index.json
model-00001-of-00005.safetensors
model-00002-of-00005.safetensors
...
    这里的 index.json 文件就是“目录”，告诉加载器各个参数分布在哪个分片文件中。现代加载库（如 Transformers）都能自动识别并处理这种分片。

2.2 配置文件：模型的“骨架图纸”

光有参数（血肉）不行，还得知道这些参数怎么组织（骨架）。这就是配置文件的作用。

  • config.json：这是最重要的配置文件。它定义了模型的完整架构。比如，这个模型是 LLaMA 结构还是 GPT-2 结构？有多少层（num_hidden_layers）？每层有多少个神经元（hidden_size）？注意力头有多少个（num_attention_heads）？词汇表多大（vocab_size）？加载器会读取这个文件，来实例化一个空的模型结构，然后再把权重填进去。
  • generation_config.json：这个文件专为文本生成任务服务。它包含了推理时的超参数，比如生成的最大长度（max_length）、控制随机性的温度（temperature）、核采样参数（top_p, top_k）等。当你调用模型的 generate() 方法时，这些默认参数就会生效。当然，你也可以在代码里覆盖它们。

一个常见的误区：有人发现 config.json 里也有 bos_token_id 和 eos_token_id，generation_config.json 里也有，到底以哪个为准？简单来说，config.json 里的是模型结构层面的定义，是“它能理解什么”；而 generation_config.json 里的是生成任务的行为参数，是“它该如何输出”。在加载时，模型结构依赖 config.json；在生成文本时，优先级通常是：代码传入参数 > generation_config.json > config.json 中的默认值。

2.3 分词器文件：模型与人类的“翻译官”

大模型处理的是数字（Token ID），而我们输入输出的是文字。分词器（Tokenizer）就是负责在这两者之间转换的“翻译官”。它的文件确保了模型和我们对文字的理解是一致的。

  • tokenizer.json 或 tokenizer.model：这是分词器的主要模型文件，包含了构建分词器所需的全部数据，如词汇表、合并规则（对于 BPE 算法）、特殊标记等。tokenizer.json 是一种序列化格式，包含了分词管道的完整配置。
  • tokenizer_config.json：分词器的配置文件，指定了使用哪个分词器类（如 PreTrainedTokenizerFast）、特殊标记（bos_token, eos_token）是什么、模型最大长度（model_max_length）等元信息。
  • special_tokens_map.json：专门映射特殊标记（如 [CLS], [SEP], [PAD], [UNK]）到其 Token ID 的简单文件。

重要提示：现在很多新模型已经不再使用古老的 vocab.txt 了。tokenizer.json 等现代格式能支持更复杂、更高效的分词算法（如 BPE、WordPiece、SentencePiece）。确保你的分词器版本与模型匹配，否则可能会出现“词汇表对不上”的错误，导致生成乱码。

3. 主流框架加载实战：手把手代码演示

理论说再多，不如一行代码。下面我分别用 PyTorch + Transformers、TensorFlow 和 ONNX Runtime 这三种最常见的方式，带你走一遍完整的加载流程。我会把可能遇到的坑和优化技巧都写在注释里。

3.1 方案一：使用 Hugging Face Transformers (PyTorch) —— 最省心的方式

对于绝大多数开源模型，这几乎是首选方案。Hugging Face 的 transformers 库提供了统一的 API，屏蔽了底层差异，让加载变得异常简单。

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 指定模型路径，可以是 Hugging Face 模型ID，也可以是本地文件夹路径
model_name_or_path = "meta-llama/Llama-2-7b-chat-hf"  # 示例：从HF仓库加载
# 或者 model_name_or_path = "./local_models/llama-2-7b-chat"  # 示例：从本地加载

# 1. 加载分词器
# trust_remote_code: 如果模型有自定义代码，可能需要设置为True。但要注意安全，只信任可信来源。
tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, trust_remote_code=True)

# 2. 加载模型
model = AutoModelForCausalLM.from_pretrained(
    model_name_or_path,
    trust_remote_code=True,  # 同上
    torch_dtype=torch.float16,  # 关键优化！以半精度加载，显存减半，速度提升。GPU必备。
    device_map="auto",  # 关键优化！自动将模型层分布到可用的GPU和CPU上。对于多卡或显存不足的情况神器。
    # load_in_4bit=True,  # 更激进的优化！使用4比特量化加载，显存需求大幅降低，但可能轻微损失精度。
    # low_cpu_mem_usage=True,  # 优化CPU内存使用，在内存有限的机器上有用
)

# 将模型设置为评估模式（关闭Dropout等训练特有的层）
model.eval()

# 3. 使用模型进行推理
prompt = "请用Python写一个快速排序函数。"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)  # 将输入数据放到模型所在的设备上

with torch.no_grad():  # 禁用梯度计算，推理时节省显存和计算
    outputs = model.generate(
        **inputs,
        max_new_tokens=256,  # 生成的最大新token数
        temperature=0.7,     # 控制随机性：越低越确定，越高越有创意
        do_sample=True,      # 是否采样。False则为贪婪解码
        top_p=0.9,           # 核采样参数，累积概率超过p的token被过滤
    )

# 4. 解码输出
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)

这段代码的几个实战要点：

  1. torch_dtype=torch.float16：这是单卡加载大模型的关键。全精度（float32）的7B模型需要约28GB显存，半精度（float16）只需要14GB。如果你的GPU支持bfloat16（如A100、H100），用 torch.bfloat16 更好，数值范围更广。
  2. device_map="auto"：这是 Hugging Face accelerate 库提供的功能。如果你的模型太大，一张显卡放不下，它会自动将不同层分配到多个GPU上。甚至可以把一部分层放到CPU内存里（虽然会慢），让你在消费级显卡上也能运行超大模型。你还可以细粒度控制，如 device_map={"": 0} 表示所有层放在第0张卡上。
  3. load_in_4bit / load_in_8bit：来自 bitsandbytes 库的量化技术。8比特量化能让显存需求再减半，4比特则更夸张。这是让大模型在消费级显卡（如24G的3090/4090）上运行的关键技术。启用时需要先 pip install bitsandbytes。
  4. trust_remote_code：一些模型（如早期的 ChatGLM、Qwen）可能有自定义的模型架构代码。加载时需要从远程仓库（或本地）执行这些代码。务必只对可信来源的模型设置此参数，因为它会执行代码。

3.2 方案二：使用原生 PyTorch 加载 —— 更底层，更灵活

有时候，你可能需要更底层的控制，或者模型文件不是 Transformers 标准格式。这时就需要直接用 PyTorch 加载。

import torch
import json

# 假设我们有一个自定义结构的模型，权重保存为 .pth 文件
class MyCustomLM(torch.nn.Module):
    def __init__(self, config):
        super().__init__()
        # 根据 config 动态构建模型层
        self.embedding = torch.nn.Embedding(config['vocab_size'], config['hidden_size'])
        # ... 更多层定义
        self.lm_head = torch.nn.Linear(config['hidden_size'], config['vocab_size'])

    def forward(self, input_ids):
        # ... 前向传播逻辑
        return logits

# 1. 加载配置文件
with open('./custom_model/config.json', 'r') as f:
    model_config = json.load(f)

# 2. 实例化模型结构
model = MyCustomLM(model_config)

# 3. 加载权重文件
# 情况A: 权重文件是完整的模型状态字典（state_dict）
state_dict = torch.load('./custom_model/pytorch_model.bin', map_location='cpu')  # 先加载到CPU
model.load_state_dict(state_dict)
print("Model weights loaded successfully!")

# 情况B: 权重文件是包含模型、优化器等多种信息的字典（不推荐但可能遇到）
checkpoint = torch.load('./custom_model/checkpoint.pth', map_location='cpu')
model.load_state_dict(checkpoint['model_state_dict'])
# 如果想继续训练，还可以加载优化器状态
# optimizer.load_state_dict(checkpoint['optimizer_state_dict'])

# 4. 将模型转移到设备并设置为评估模式
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
model.eval()

# 注意：这种方式需要你自己实现分词和前处理逻辑，复杂度较高。

踩坑提醒：

  • map_location='cpu'：先加载到 CPU 再转移到 GPU 是一个好习惯。特别是当你的保存环境和使用环境 GPU 数量不一致时，直接 torch.load('file.pth') 可能会报错。
  • 键名不匹配：有时保存的 state_dict 键名和当前模型定义的键名可能因为前缀（如 module.，在多GPU训练后保存时产生）而不匹配。需要手动处理：
    # 去除 'module.' 前缀
new_state_dict = {k.replace('module.', ''): v for k, v in state_dict.items()}
model.load_state_dict(new_state_dict, strict=False)  # strict=False 允许部分加载

3.3 方案三：使用 ONNX Runtime 加载 —— 追求极致推理速度

当你需要生产环境部署，追求高吞吐、低延迟时，ONNX 格式和 ONNX Runtime 是利器。它可以将模型优化并运行在各种硬件后端（CPU/GPU）上。

# 首先，你需要将模型导出为 ONNX 格式（以 PyTorch 模型为例）
import torch.onnx
import onnx
from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载原始模型和分词器
model_name = "gpt2"
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16)
tokenizer = AutoTokenizer.from_pretrained(model_name)
model.eval()

# 准备一个示例输入（dummy input）
dummy_input = torch.randint(0, tokenizer.vocab_size, (1, 16)).to('cuda')  # batch_size=1, seq_len=16
# 注意：对于动态输入形状，需要更复杂的设置
input_names = ["input_ids"]
output_names = ["logits"]

# 导出 ONNX 模型
torch.onnx.export(
    model,
    (dummy_input,),  # 模型输入，是一个元组
    "gpt2.onnx",
    input_names=input_names,
    output_names=output_names,
    opset_version=14,  # ONNX 算子集版本，建议>=13
    dynamic_axes={
        'input_ids': {0: 'batch_size', 1: 'sequence_length'},  # 声明动态维度
        'logits': {0: 'batch_size', 1: 'sequence_length'}
    },
    do_constant_folding=True,
)

print("Model exported to ONNX.")

# 然后，使用 ONNX Runtime 加载和推理
import onnxruntime as ort
import numpy as np

# 创建 ONNX Runtime 会话，指定执行提供者（比如 CUDA）
providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']  # 优先使用CUDA
session = ort.InferenceSession("gpt2.onnx", providers=providers)

# 准备输入数据（需要是 numpy array）
input_ids = tokenizer("Hello, my dog is cute", return_tensors="np").input_ids.astype(np.int64)

# 运行推理
inputs = {session.get_inputs()[0].name: input_ids}
outputs = session.run(None, inputs)  # 第一个输出是 logits
logits = outputs[0]
print(f"Output logits shape: {logits.shape}")

# ONNX Runtime 也支持性能调优，比如启用优化
so = ort.SessionOptions()
so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
so.intra_op_num_threads = 4  # 设置线程数
session_optimized = ort.InferenceSession("gpt2.onnx", sess_options=so, providers=providers)

ONNX 实战心得：

  • 动态形状：大模型推理的序列长度经常变化，导出时务必设置 dynamic_axes，否则每次输入固定长度，很不灵活。
  • 性能调优：ONNX Runtime 提供了丰富的优化选项，如图优化（graph_optimization_level）、执行提供者选择（优先 GPU）、线程控制等，需要根据实际硬件调整。
  • 量化：ONNX Runtime 支持对 ONNX 模型进行静态量化（Post-training Quantization），能进一步压缩模型、提升 CPU 上的推理速度，是移动端部署的常用手段。

4. 常见加载问题与实战解决方案

加载过程中报错是家常便饭。下面我整理了几个最常碰到的问题和我的解决思路。

4.1 报错：CUDA out of memory (OOM)

这是最经典的错误，意思是显存不够。

解决方案（按尝试顺序）：

  1. 减小批次大小（Batch Size）：这是最直接的方法。如果你是在做批处理生成，尝试将 batch_size 设为 1。
  2. 启用梯度检查点（Gradient Checkpointing）：这是一种用计算时间换显存的技术。它会重新计算某些中间激活值，而不是一直保存在显存里。
    model.gradient_checkpointing_enable()
# 或者在加载时指定
model = AutoModelForCausalLM.from_pretrained(..., use_cache=False)  # 注意：use_cache=False 可能与梯度检查点冲突或配合使用，需看模型支持
  3. 使用半精度（fp16/bf16）：如前所述，加载时加上 torch_dtype=torch.float16。
  4. 使用 8-bit 或 4-bit 量化：
    from transformers import BitsAndBytesConfig
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)
model = AutoModelForCausalLM.from_pretrained(..., quantization_config=bnb_config)
  5. 使用 device_map="auto"：让 accelerate 库帮你把模型智能地分摊到多个 GPU 甚至 CPU 内存中。
  6. 使用 CPU 卸载（CPU Offload）：更极端的做法，将暂时不用的层换出到 CPU 内存，需要时再换入 GPU。速度会慢，但能跑起来。
    from accelerate import infer_auto_device_map
device_map = infer_auto_device_map(model, max_memory={0: "10GiB", "cpu": "30GiB"})
model = AutoModelForCausalLM.from_pretrained(..., device_map=device_map)

4.2 报错：KeyError: 'xxx' 或 Unexpected key(s) in state_dict

这通常是权重文件中的键名和模型定义对不上。

解决方案：

  1. 检查键名：打印出 state_dict 的键和模型 state_dict 的键，对比差异。
    print("Keys in checkpoint:", state_dict.keys())
print("Keys in model:", model.state_dict().keys())
  2. 去除前缀：如果是多GPU训练保存的模型，权重键名可能有 module. 前缀。
    state_dict = {k.replace('module.', ''): v for k, v in state_dict.items()}
  3. 非严格加载：使用 strict=False 参数，忽略不匹配的键。但这要小心，可能意味着有些权重没加载进去。
    model.load_state_dict(state_dict, strict=False)
  4. 手动映射：对于结构相似但命名不同的模型，可能需要写一个键名映射字典来手动加载。

4.3 报错：Tokenizer class not found 或 vocab size mismatch

分词器加载失败或与模型不匹配。

解决方案：

  1. 确保文件完整：检查 tokenizer.json、tokenizer_config.json、special_tokens_map.json 等文件是否存在。
  2. 指定分词器类：如果自动检测失败，可以手动指定。
    from transformers import LlamaTokenizerFast
tokenizer = LlamaTokenizerFast.from_pretrained('./model_path')
  3. 更新 transformers 库：老版本的库可能不支持新模型的分词器。pip install -U transformers。
  4. 检查词汇表大小：确认 config.json 里的 vocab_size 和分词器实际的词汇量一致。如果不一致，可能需要调整 config 或重新训练分词器（这种情况较少见，通常出现在自己组合模型和分词器时）。

4.4 报错：OSError: Unable to load weights from pytorch_model.bin

文件损坏或格式不对。

解决方案：

  1. 重新下载文件：网络传输可能导致文件损坏。检查文件的 MD5 或 SHA256 哈希值是否与官方提供的一致。
  2. 检查文件格式：用 file 命令（Linux/Mac）或文本编辑器打开文件头部看看。如果是 safetensors 格式却用 torch.load 去读，肯定会错。要用对应的库加载。
  3. 使用 safetensors 库：对于 .safetensors 文件，可以：
    from safetensors import safe_open
with safe_open("model.safetensors", framework="pt", device="cpu") as f:
    state_dict = {k: f.get_tensor(k) for k in f.keys()}

5. 性能优化技巧：让模型加载更快、跑得更稳

加载成功只是第一步，如何让它高效地跑起来更重要。下面是一些我实践中总结的优化点。

5.1 加速模型加载

  1. 使用 safetensors 格式：如果模型提供此格式，优先选用。它的加载速度比传统的 .bin 快，且更安全。
  2. 利用磁盘缓存：Hugging Face 的 transformers 库会默认将下载的模型缓存到 ~/.cache/huggingface/。第二次加载同模型时速度会快很多。你也可以通过 HF_HOME 环境变量指定缓存位置到更快的 SSD 硬盘上。
  3. 并行加载：对于超大型模型的分片文件，最新的库支持并行加载多个分片，充分利用 IO 和网络带宽。
  4. 预加载：在服务启动时，提前将模型加载到内存/显存中，而不是在第一个请求时再加载，可以避免首次请求的漫长等待。

5.2 优化推理速度与内存

  1. 使用 Flash Attention：如果模型和硬件支持（如 Ampere 架构及以后的 NVIDIA GPU），启用 Flash Attention 可以大幅加速注意力计算，并减少显存占用。很多新版的 Transformers 模型（如 Llama 2）已经原生集成，通过 attn_implementation="flash_attention_2" 参数启用。
    model = AutoModelForCausalLM.from_pretrained(
    ...,
    attn_implementation="flash_attention_2",  # 启用 Flash Attention-2
    torch_dtype=torch.bfloat16,
)
  2. 启用 KV Cache：在自回归生成（如文本续写）时，KV Cache 可以避免重复计算之前序列的 Key 和 Value 状态，极大提升生成速度。确保 model.generate() 时 use_cache=True（默认就是）。
  3. 调整生成参数：
    • max_new_tokens：不要设得过大，够用就行。
    • num_beams：束搜索（beam search）的束宽。num_beams=1 就是贪婪解码，最快；束宽越大，质量可能越高，但速度越慢，显存占用也成倍增加。
    • do_sample=False：使用贪婪解码而非采样，速度更快，结果更确定（但可能更枯燥）。
  4. 使用编译优化：PyTorch 2.0 及以上版本的 torch.compile 可以对模型进行图编译，在多次推理时获得显著的性能提升。
    model = torch.compile(model, mode="reduce-overhead")  # 在模型加载后、推理前调用
# 注意：第一次运行会较慢，因为需要编译图。

5.3 生产环境部署建议

  1. 模型格式选择：生产环境追求稳定和性能。通常会将训练框架（如 PyTorch）的模型导出为更适合部署的格式。
    • 服务端（GPU）：ONNX + TensorRT。NVIDIA 的 TensorRT 可以对 ONNX 模型进行极致优化，获得最佳的 GPU 推理性能。
    • 服务端（CPU）：ONNX + ONNX Runtime。ONNX Runtime 对 CPU 的优化非常出色。
    • 移动/边缘端：TFLite (TensorFlow) 或 Core ML (Apple)。需要进行量化（INT8/FP16）来压缩模型。
  2. 使用专用推理服务器：
    • Triton Inference Server (NVIDIA)：支持多种框架后端（PyTorch, TensorRT, ONNX Runtime等），功能强大，适合大规模部署。
    • TensorFlow Serving：专为 TensorFlow SavedModel 设计，成熟稳定。
    • vLLM / TGI (Text Generation Inference)：专门为大语言模型生成任务优化的推理服务器，实现了 PagedAttention 等高级特性，吞吐量比原生 PyTorch 高一个数量级，是当前部署 LLM 服务的热门选择。
  3. 监控与日志：在生产中，要监控模型的加载时间、推理延迟（P50, P99）、显存使用率、吞吐量（QPS）等关键指标，并设置合理的超时和熔断机制。

加载大模型文件，从“能跑”到“跑得好”，是一个不断调优的过程。它没有一成不变的银弹，需要你根据具体的模型、硬件、应用场景去灵活选择和组合这些技术。希望这篇实战解析，能成为你探索大模型世界的一块坚实垫脚石。遇到问题别慌，多查文档、多搜社区（Hugging Face论坛、Stack Overflow、相关项目的GitHub Issues），很多坑别人都已经踩过了。

# 深度学习
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 亚马逊云科技技术品牌专区