创业者必须掌握的AI降本四招

人工智能行业刚刚承认了独立创始人一直以来都知道的事实：一味地增加参数并不能解决问题。

在每一次淘金热中，总会有人环顾四周，意识到真正的财富不在于挖掘得更深，而在于出售更轻便的铲子。

我们正处于人工智能的这个阶段。

过去三年，整个行业都对规模顶礼膜拜。GPT-3升级到了GPT-4。Claude的上下文窗口数量从10万个增加到了20万个。所有人都以为前进的道路很简单：更多的参数、更多的计算资源，一切都要更多。

然而，仅仅一周之内，就发生了两件足以让所有把路线图押在“等待 GPT-5”上的 AI 公司感到恐惧的事情：

• Meta 发布了 AU-Net，一种全新的 LLM 架构，它彻底消除了分词。不是“改进”，而是彻底消除。
• 三星发布了一款紧凑型模型，在推理任务上超越了规模更大的 LLM，而计算资源却少得多。

如果你正在开发 AI 产品，并且你的全部策略是“等待 OpenAI 的下一次发布”，那么这篇文章就是一记警钟。

如果你每月向 OpenAI 支付五位数的费用，并且暗自怀疑是否有更好的方法，请继续阅读。

如果你是一位试图与那些投入巨资、风险投资支持的竞争对手抗衡的独立创始人，那么我即将为你提供一项不公平的优势。

1、我们都相信的谎言

我不断看到一个令人不安的模式：

我接触过的每一位人工智能创始人都有同样的反应。他们的上下文窗口不断扩大，令牌使用量呈爆炸式增长，OpenAI 的费用也成了令首席财务官 (CFO) 头疼的一项支出。

而大家给出的“解决方案”也如出一辙：“等等 GPT-5 吧。它会有更好的压缩率、更大的上下文范围和更快的推理速度。”

这是一个令人感到安慰的谎言。

真相却更加残酷：你大部分的令牌使用并非用于提升智能，而是浪费。

当你真正分析一个典型的 RAG 应用中令牌的去向时，你会发现一个令人震惊的模式：

• 重复的系统提示被复制到每一个请求中
• 永不改变的样板检索上下文
• 数百次 API 调用中重复的相同指令
• 由于分块策略过于简单，导致文档块冗余

你从 OpenAI 购买的不是智能，而是大规模的低效。

一旦你接受了这一点，一切都将改变。与其等待更大的模型，不如：

• 将系统上下文移入持久代理状态（LangGraph），
• 用混合搜索+预计算替换朴素的检索增强生（RAG），
• 缓存词嵌入和摘要而不是重新生成它们，
• 智能地路由查询而不是默认调用 GPT-4。

这些并非新想法，而是枯燥乏味的底层架构工作。但它们也是人工智能业务可持续发展与利润被 OpenAI 蚕食之间的关键所在。

这就是整个行业一直在自欺欺人的谎言。规模越大并非越好，规模越大成本越高。

2、Meta 的 AU-Net：分词路线的反抗军

如果你一直没注意到，分词是现代语言学习模型（LLM）的原罪。

每个模型——GPT-4、Claude、Gemini，等等——都从将文本分割成词元开始。这些词元是模型进行推理的基本单元。

问题在于？分词是一种有损的、语言偏向的、受历史因素影响的权宜之计，我们却一直假装它是一项功能。

以下是分词的成本：

多语言成本：

英语文本平均每个词约 0.7 个词元。中文呢？每个字符 2-3 个词元。如果您正在为非英语市场开发产品，那么每次 API 调用，您实际上要为相同的语义内容支付三倍的费用。

上下文浪费：

10 万个上下文窗口实际上并不是 10 万个“想法”。它是 10 万个词元槽位，其中许多都被浪费在：

• 子词片段（例如“Dont”→ [“Don”，“'t”]），
• 标点符号（每个引号、逗号、句号都是一个词元），
• 编码痕迹（毫无语义意义的 BPE 合并）。

推理瓶颈：

词元迫使模型以 2019 年 GPT-2 词汇表的方式“理解”文本。现代模型的智能程度比以往高出几个数量级，但它们仍然基于为更简单的架构设计的表示进行推理。

Meta 的全新架构 AU-Net（音频单元网络）应运而生。

AU-Net 不会对文本进行分词。相反，它处理语言的原始音频式连续表示。您可以将其理解为像 Whisper 处理语音那样处理文本：将其视为连续信号，而非离散的文本块。

为何这将改变一切？

# Traditional tokenizer (simplified)
from transformers import GPT2Tokenizer

tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
text = "Don't tokenize this unnecessarily."
tokens = tokenizer.encode(text)
# Output: [8061, 470, 11298, 1096, 428, 38347, 13]
# 7 tokens for 5 words - lots of overhead
# AU-Net approach (conceptual)
# No tokenization step. Text → continuous embedding directly.
# Result: denser, lossless, language-agnostic representation

其意义重大：

• 更低的延迟：无需分词预处理步骤。
• 更好的多语言支持：不存在特定语言的词汇偏差。
• 更密集的上下文：相同的“上下文窗口”包含更多语义信息。
• 潜在的成本更低：每个输入所需的处理单元更少。

Meta 尚未向公众发布 AU-Net。但如果这种方法能够大规模应用——早期基准测试表明确实如此——那么所有基于分词的架构都将变成技术债务。

3、三星的复仇：小模型，大思维

在 Meta 重新思考输入层的同时，三星也在重新思考其他一切。

上周，三星人工智能实验室发布了一款紧凑型推理模型，该模型在特定的推理基准测试中优于 GPT-4 类模型，而体积却只有其 10 到 50 倍。

仔细想想。

一个可以在设备端运行、无需任何 API 费用的模型，竟然能击败那些每百万代币就要花费 30 美元的模型。

这是怎么做到的？

这篇论文（目前仍在同行评审中）暗示了三项核心创新：

3.1 稀疏激活

并非每个神经元都需要对每个输入都激活。三星的模型采用动态稀疏路由——每次查询只激活网络中相关的 10-20% 的神经元。

这在理论上并不新鲜（混合专家模型就采用了这种方法），但三星的实现方式更加激进，并且与架构无关。

# Conceptual: Sparse activation in a reasoning model
import torch
import torch.nn as nn

class SparseReasoningLayer(nn.Module):
    def __init__(self, num_experts=64, active_experts=8):
        super().__init__()
        self.experts = nn.ModuleList([ExpertModule() for _ in range(num_experts)])
        self.router = RouterNetwork()
        self.active_experts = active_experts
    def forward(self, x):
        # Route input to only top-k experts
        expert_scores = self.router(x)
        top_k_indices = torch.topk(expert_scores, self.active_experts).indices
        # Only compute these experts
        outputs = [self.experts[i](x) for i in top_k_indices]
        return torch.sum(torch.stack(outputs), dim=0)

3.2 基于推理轨迹而非输出的蒸馏

大多数蒸馏方法训练一个小型模型来模拟大型模型的最终答案。

三星的方法基于推理轨迹进行训练：即大型模型在解决问题时逐步生成的内部“思考过程”。

这更接近于我们教人的方式。我们不仅向学生展示答案，还向他们展示如何思考问题。

# Conceptual: Distillation on reasoning traces
class ReasoningDistillation:
    def __init__(self, teacher_model, student_model):
        self.teacher = teacher_model
        self.student = student_model
def distill(self, problem):
        # Teacher generates reasoning trace
        teacher_trace = self.teacher.solve_with_trace(problem)
        # Example trace: ["Step 1: Identify variables", "Step 2: Apply constraint X", ...]
        # Student learns to replicate the trace, not just the answer
        loss = 0
        for step in teacher_trace:
            student_step = self.student.next_reasoning_step(problem, context=step)
            loss += nn.functional.mse_loss(student_step, step)
        return loss

3.3 计算最优训练

三星并没有仅仅训练一个更小的模型——他们训练得更智能。他们利用近期关于计算最优扩展规律（例如 Chinchilla）的研究成果，分配训练计算资源，以最大化每个参数的推理能力。

结果：得到的模型并非“更小的 GPT-4”。它是一种截然不同的架构，针对不同的成本/性能点进行了优化。

4、这对你的 AI 技术栈意味着什么

如果你正在构建一款 AI 产品，而你的架构是这样的：

用户输入 → GPT-4 API → 响应

……你就像在沙滩上建造。

以下是后规模时代的架构准则：

4.1 混合推理：按任务路由，而非默认路由

并非每个查询都需要 GPT-4。大多数查询都不需要。

# production/inference_router.py
from enum import Enum
from typing import Dict

class ModelTier(Enum):
    TINY = "on_device"          # <1B params, local
    SMALL = "compact_api"       # 7–13B params, cheap API
    LARGE = "frontier"          # GPT-4, Claude - expensive
def route_query(query: str, context: Dict) -> ModelTier:
    """
    Route queries to appropriate model tier based on complexity.
    """
    # Simple heuristics (replace with learned router in prod)
    if is_simple_lookup(query):
        return ModelTier.TINY
    if requires_reasoning(query) and not requires_external_knowledge(query):
        return ModelTier.SMALL
    # Only use expensive models when necessary
    return ModelTier.LARGE
def is_simple_lookup(query: str) -> bool:
    # FAQ matching, entity extraction, etc.
    return query.lower().startswith(("what is", "who is", "when did"))
def requires_reasoning(query: str) -> bool:
    # Multi-step logic, math, code generation
    reasoning_keywords = ["why", "how", "explain", "calculate", "debug"]
    return any(kw in query.lower() for kw in reasoning_keywords)

采用此架构：

• 70% 的查询会到达 TINY 层 → 成本接近于零，延迟 <100 毫秒。
• 25% 的查询会到达 SMALL 层 → 比 GPT-4 便宜 10 倍，延迟 200 毫秒。
• 5% 的查询会到达 LARGE 层 → 仅在真正必要时才会到达。

您的 OpenAI 账单将减少 80%。您的 p95 延迟将减少 60%。

4.2 尽可能预计算所有内容

大多数 AI 技术栈中最大的浪费是反复计算相同的嵌入、摘要和分析。

如果您正在运行 RAG，则应该：

• 缓存所有文档的嵌入（显而易见，但有一半的人没有这样做）。
• 预先生成的多级摘要（段落、章节、文档）。
• 实体间关系的索引图（如适用）。

# backend/preprocessing/document_pipeline.py
from celery import shared_task
from typing import List, Dict
@shared_task
def preprocess_document_pipeline(doc_id: int):
    """
    Everything that can be computed once, is computed once.
    """
    doc = Document.objects.get(id=doc_id)
    # 1. Generate embeddings (once)
    doc.embedding = generate_embedding(doc.content)
    # 2. Generate summaries at multiple levels (once)
    doc.summary_short = summarize(doc.content, max_words=50)
    doc.summary_long = summarize(doc.content, max_words=200)
    # 3. Extract entities and relationships (once)
    entities = extract_entities(doc.content)
    for entity in entities:
        node, _ = EntityNode.objects.get_or_create(name=entity["name"])
        EntityEdge.objects.create(document=doc, entity=node, relation=entity["role"])
    # 4. Index for hybrid search (once)
    index_for_keyword_search(doc)
    doc.save()

现在，在查询时，您无需调用 LLM 来“摘要此文档”，只需从数据库中获取预先计算好的摘要即可。

更快。更便宜。更好。

4.3 将提示重新视为“程序”，而非“请求”

提示工程的理念正在转变。

• 旧方法：编写一个庞大的系统提示符，将其放入每个请求中，然后祈祷一切顺利。
• 新方法：将提示符视为可重用、可组合的程序，并进行显式的状态管理。

# ai/prompt_manager.py
from typing import TypedDict, Optional, List, Dict
from langchain_core.messages import SystemMessage, HumanMessage

class AgentContext(TypedDict):
    persona: str
    retrieved_memories: List[str]
    user_preferences: Dict
    conversation_history: List[Dict]
class PromptProgram:
    """
    A reusable 'program' for constructing prompts.
    Only includes what's necessary for this specific task.
    """
    def __init__(self, base_instructions: str):
        self.base = base_instructions
    def build(self, context: AgentContext, query: str) -> List:
        # Only inject what's needed
        messages = [
            SystemMessage(content=self.base)
        ]
        # Conditionally add context (don't spam tokens)
        if context.get("retrieved_memories"):
            memory_context = "\n".join(context["retrieved_memories"][:3])  # Top 3 only
            messages.append(SystemMessage(content=f"Relevant context:\n{memory_context}"))
        messages.append(HumanMessage(content=query))
        return messages
# Usage
reflection_prompt = PromptProgram(
    base_instructions="You are a helpful AI assistant. Be concise and insightful."
)
context = AgentContext(
    persona="thoughtful",
    retrieved_memories=retrieve_top_k_memories(user_query, k=3),
    user_preferences={},
    conversation_history=[]
)
prompt = reflection_prompt.build(context, user_query)
response = llm.invoke(prompt)

此模式：

• 通过仅包含必要的上下文来减少令牌浪费。
• 通过使提示可测试、版本化和可组合，提高可维护性。
• 加快迭代速度——只需修改“程序”，而无需修改每一个 API 调用。

5、OpenAI 不想让你知道的真正原因

以下是一个令人不安的事实：OpenAI 的商业模式依赖于你的低效。

每一个浪费的代币都是收入。每一次冗余的 API 调用都是利润。每当你使用 GPT-4 来完成一个本可以由 70 亿参数模型处理的任务时，OpenAI 就赢了，而你输了。

这不是阴谋论，而是利益冲突。

同样的道理也曾在云计算领域上演。AWS 曾凭借过度配置的 EC2 实例赚得盆满钵满，直到竞争对手（以及诸如资源优化之类的内部工具）迫使其提高效率。

人工智能领域即将面临同样的考验。

未来 24 个月内获胜的公司并非拥有最庞大模型的公司。它们能够：

• 在模型层级之间进行智能路由，
• 积极进行预计算以避免冗余推理，
• 针对特定领域微调小型模型，而不是租用通用的大型模型，
• 运行混合架构（本地 + 云）以最大限度地降低延迟和成本。

如果您仍然默认对每个查询都使用 gpt-4-turbo，那么您就是在为 OpenAI 贡献利润。

6、如何摆脱对 GPT-4 的依赖

让我们采取一些实际行动。如果您背负着巨额 OpenAI 账单，并且想要退出，以下是分步指南：

6.1 审核你的令牌使用情况

# Run this against your OpenAI API logs
cat openai_logs.jsonl | jq -r '
  .choices[0].message.content | length
' | awk '{sum+=$1; count+=1} END {print "Avg response length:", sum/count}'

你需要了解：

• 每次请求的平均词元数（输入 + 输出）
• 查询类型分布（分类、生成、推理）
• 哪些查询是“高价值”（面向用户）的，哪些是“低价值”（内部、批量）的

6.2 找出唾手可得的成果

以下任务你永远不应该使用 GPT-4：

• 常见问题解答查找 → 替换为语义搜索 + 模板响应
• 实体提取 → 微调后的 10 亿参数模型或 spaCy
• 情感分析 → DistilBERT 或类似模型
• 简单分类 → 逻辑回归（认真地说）

# Example: Replace GPT-4 with a tiny classifier
from sklearn.linear_model import LogisticRegression
from sentence_transformers import SentenceTransformer

# One-time setup
embedder = SentenceTransformer('all-MiniLM-L6-v2')  # 22M params, runs locally
classifier = LogisticRegression()
# Train on your labeled data
X_train = embedder.encode(training_texts)
classifier.fit(X_train, training_labels)
# Inference (local, instant, free)
def classify_query(text: str) -> str:
    embedding = embedder.encode([text])
    return classifier.predict(embedding)[0]

节省：如果 40% 的查询是分类查询 → 立即降低 40% 的成本。

6.3 引入学习型路由

停止凭直觉路由。训练一个分类器来预测要使用哪个模型层级。

# ai/router.py
import joblib
from sentence_transformers import SentenceTransformer
from enum import Enum

class ModelTier(Enum):
    LOCAL = 0
    SMALL = 1
    LARGE = 2
class LearnedRouter:
    def __init__(self):
        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')
        self.classifier = joblib.load('router_model.pkl')  # Pre-trained
    def route(self, query: str) -> ModelTier:
        embedding = self.embedder.encode([query])
        tier = self.classifier.predict(embedding)[0]
        return ModelTier(tier)
# Usage
router = LearnedRouter()
tier = router.route("What is the capital of France?")  # → ModelTier.LOCAL
tier = router.route("Explain quantum entanglement and its implications")  # → ModelTier.LARGE

按如下步骤训练你的分类器：

• 记录所有查询以及您应该使用的模型层级（手动标注）。
• 训练一个简单的分类器（逻辑回归、XGBoost 等）。
• 部署并监控准确率。

6.4 针对你的领域微调小型模型

这是终极方案，但也是最有效的方案。

如果您拥有超过 1000 个高质量输入/输出示例，您可以微调一个 70 亿或 130 亿的模型，使其在您的特定用例中优于 GPT-4。

# Example: Fine-tuning Llama 3.1-8B on your data
# (Simplified — use Hugging Face, Axolotl, or similar in production)

# 1. Prepare dataset (JSONL format)
# {"messages": [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}
# 2. Fine-tune using LoRA (efficient, low-memory)
python finetune.py \
  --model meta-llama/Llama-3.1-8B \
  --data your_data.jsonl \
  --method lora \
  --epochs 3 \
  --output_dir ./finetuned_model
# 3. Deploy to your own infra (RunPod, Modal, etc.)
# Cost: ~$0.10/hour for inference → 100× cheaper than GPT-4

何时执行假设：

• 你的领域非常狭窄且定义明确（例如法律文件、医疗记录、SaaS 的客户支持）。
• 你在该领域每月处理超过 100 万个令牌。
• 你拥有已标注的数据，或者可以低成本地生成数据。

投资回报率：如果你每月花费 5000 美元使用 GPT-4 来训练一个狭窄领域的模型，那么通过微调可以将成本降低到每月 500 美元（降低 10 倍）。

7、关于“涌现能力”的肮脏秘密

人工智能领域有一种说法，认为更大的模型可以解锁“涌现能力”——即小型模型根本无法学习的能力。

这大多是胡扯。

实际情况是：

• 更大的模型使用更多样化的数据进行训练 → 它们具有更好的泛化能力。
• 更大的模型拥有更大的容量 → 它们可以记忆更多模式。

但是推理——我们真正关心的——并非规模带来的涌现属性。它是训练数据和架构带来的涌现属性。

三星的微型推理模型证明了这一点。你不需要 1750 亿个参数来进行链式推理。你需要的是：

• 训练数据中高质量的推理轨迹，
• 稀疏、高效的架构，避免资源浪费，
• 以及优先考虑推理而非记忆的计算优化训练。

“越大越好”的说法对那些销售计算资源的公司（OpenAI、Anthropic、Google）有利，但对你没有好处。

8、结束语

人工智能行业正处于一个转折点。

三年来，我们一直处于“越大越好”的时代。每一次新模型的发布都是一场追求更多参数、更多计算资源、更高成本的竞赛。

这个时代已经结束了。

未来三年将属于那些能够找到如何……的公司。以更少的资源实现更多：

• 混合架构，可在模型层级间智能路由。
• 稀疏高效的模型，仅激活所需部分。
• 预计算和缓存，将推理视为宝贵资源。
• 针对特定领域的微调，在特定任务上超越通用巨头。

如果你今天正在开发人工智能产品，您有两个选择：

• 继续搭上 OpenAI 的顺风车，支付每百万个代币 30 美元，并祈祷您的利润能够维持。
• 摒弃低效，构建混合架构，掌控您的成本结构。

如果你是一位独立创始人，与拥有无限资金的风险投资支持的竞争对手竞争，这将是你的不公平优势。他们之所以在 GPT-4 上烧钱，是因为他们有能力这样做。而您将通过 10 倍的效率击败他们。

原文链接：The End of 'Bigger-is-Better' in AI: Welcome to the Era of Tiny Models

汇智网翻译整理，转载请标明出处