模型推理加速技术全景解析：从基础优化到前沿创新

破烂pan2025-12-17 18:06

在2024-2025年间，大模型推理加速技术取得了显著突破，从传统的模型压缩到前沿的分页内存管理，再到革命性的投机解码，这些技术共同推动了大模型推理速度的质的飞跃。本报告将深入浅出地解析这些主流加速手段，结合一年内发布的代表性模型和框架，揭示它们如何在实际应用中实现推理加速，并提供相应的代码示例。

一、模型压缩：降低计算量的基础方法

模型压缩是推理加速的基础技术，主要包括量化、剪枝和知识蒸馏三种核心方法，它们通过减少模型参数量和计算复杂度来提升推理速度。

量化(Quantization) 是最为直接有效的压缩技术，它通过将模型参数从高精度（如FP32）转换为低精度（如INT8或FP16）来减少内存占用和计算时间。根据实测数据，使用INT8量化可将模型体积减小至原来的1/4，同时推理速度提升2-4倍。量化技术主要有两种实现方式：训练后量化(PTQ)和量化感知训练(QAT) 。PTQ简单但精度可能下降较大，QAT训练过程中模拟量化效果，能保持较高精度。

在PyTorch中实现量化推理的代码示例如下：

python 复制代码 
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载模型和分词器
model_name = "llama-2-7b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# 将模型转换为INT8量化
quantized_model = torch.quantization.quantize动静态(
    model,
    qconfig_dict={},
    run羊群优化=True,
    dt=8,
)

# 使用量化模型进行推理
input_text = "Explain the concept of quantum computing."
inputs = tokenizer(input_text, return_tensors="pt")
outputs = quantized_model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

剪枝(Pruning) 通过移除模型中冗余或不重要的权重/神经元来减少参数量和计算量(FLOPs) 。剪枝分为非结构化剪枝（移除单个权重）和结构化剪枝（移除整个通道/卷积核/注意力头）。结构化剪枝虽然压缩率较低，但硬件加速友好，适合工业部署。

在PyTorch中实现结构化剪枝的示例代码：

python 复制代码 
import torch
import torch.nn as nn
from transformers import AutoModelForCausalLM

# 加载模型
model = AutoModelForCausalLM.from_pretrained("llama-2-7b")

# 定义剪枝函数
def structured_pruning(model, pruning_ratio=0.5):
    for name, module in model.named_modules():
        if isinstance(module, nn.Linear):
            # 计算要移除的权重数量
            num_weights = module.weight.shape[0]
            num_pruned = int(num_weights * pruning_ratio)

            # 计算重要性评分并移除
            importance_scores = torch.norm(module.weight, dim=1)
            _, indices = torch.topk(importance_scores, num_pruned, largest=False)
            module.weight.data[indices] = 0

            # 更新偏置项
            if module.bias is not None:
                module.bias.data[indices] = 0

# 应用剪枝
structured_pruning(model, pruning_ratio=0.3)

# 保存剪枝后的模型
model.save_pretrained("pruned_llama_2_7b")

知识蒸馏(Knowledge Distillation) 通过训练一个小的"学生"模型来模仿一个大的"教师"模型的输出分布，从而在保持较高精度的同时大幅减少计算需求 。与量化和剪枝不同，知识蒸馏需要额外的训练过程，但能实现更显著的模型体积缩小。

在PyTorch中实现知识蒸馏的核心代码：

python 复制代码 
import torch
import torch.nn as nn
from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载教师和学生模型
teacher_model = AutoModelForCausalLM.from_pretrained("llama-3-70b")
student_model = AutoModelForCausalLM.from_pretrained("llama-3-8b")

tokenizer = AutoTokenizer.from_pretrained("llama-3-8b")

# 定义损失函数（软标签损失 + 硬标签损失）
class DistillationLoss(nn.Module):
    def __init__(self, temperature=2.0, alpha=0.7):
        super().__init__()
        self温度 = temperature
        self.α = alpha

    def forward(self, student_logits, teacher_logits, labels):
        # 计算软标签损失
        soft_loss = F.kl_div(
            F.log_softmax(student_logits / self.温度, dim=-1),
            F.softmax(teacher_logits / self.温度, dim=-1),
            reduction="batchmean",
        )

        # 计算硬标签损失
        hard_loss = F.cross_entropy(student_logits, labels)

        # 组合损失
        return self.α * soft_loss + (1 - self.α) * hard_loss

# 训练学生模型
distillation_loss = DistillationLoss()
optimizer = torch.optim.AdamW(student_model.parameters(), lr=1e-5)

for epoch in range(num_epochs):
    for batch in train_dataloader:
        # 获取教师模型输出
        with torch.no_grad():
            teacher_outputs = teacher_model(**batch)
            teacher_logits = teacher_outputs.logits

        # 获取学生模型输出
        student_outputs = student_model(**batch)
        student_logits = student_outputs.logits
        labels = batch["labels"]

        # 计算损失并更新
        loss = distillation_loss(student_logits, teacher_logits, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

二、并行化与向量化：提升计算效率的关键技术

并行化和向量化是通过充分利用硬件资源来加速推理过程的技术，它们在2024-2025年间得到了进一步的优化和发展。

并行化加速主要分为三种模式：层间并行、层内并行和数据并行 。层间并行将神经网络的各层分配到不同计算设备，形成流水线作业；层内并行对单层内的矩阵运算进行拆分；数据并行将输入数据批量拆分到不同设备，各设备独立计算相同模型参数。这些技术共同作用，理论上可以将推理速度提升数倍。

在PyTorch中实现数据并行的示例代码：

python 复制代码 
import torch
import torch.distributed as dist
from transformers import AutoModelForCausalLM, AutoTokenizer

# 初始化分布式环境
dist.init_process_group(backend="nccl", init_method="env://")
local_rank = int(os.environ["本地排名"])
torch.cuda.set_device(local_rank)

# 加载模型并进行数据并行
model = AutoModelForCausalLM.from_pretrained("llama-3-70b").cuda()
model = DDP(model, device_ids=[local_rank], output_device=local_rank)

tokenizer = AutoTokenizer.from_pretrained("llama-3-70b")

# 推理函数
def inference(model, inputs, batch_size=8):
    # 分割输入数据
    inputs = inputs.split(batch_size)
    outputs = []

    for batch in inputs:
        # 转换为张量并转移到GPU
        batch = tokenizer(batch, return_tensors="pt").cuda()

        # 执行推理
        with torch.no_grad():
            batch_output = model.generate(**batch, max_new_tokens=100)

        outputs.extend(tokenizer.decode(batch_output, skip_special_tokens=True))

    return outputs

# 使用并行模型进行推理
input_text = ["Explain AI alignment.", "Write a poem about autumn leaves."]
outputs = inference(model, input_text)

向量化推理利用CPU/GPU的SIMD指令集（如x86的AVX、ARM的NEON、NVIDIA的CUDA SIMT）在单个时钟周期内对多个数据元素执行相同操作 。例如，AVX-512指令可同时处理16个32位浮点数(FP32)，使算术逻辑单元(ALU)的利用率从标量计算的20%-30%提升至80%以上。

在PyTorch中利用向量化加速矩阵乘法的示例代码：

python 复制代码 
import torch
import numpy as np

# 创建大型矩阵
A = torch.randn(4096, 4096, dtype=torch.float32, device="cuda")
B = torch.randn(4096, 4096, dtype=torch.float32, device="cuda")

# 基准向量乘法
def基准乘法(A, B):
    return A @ B

# 向量化优化的矩阵乘法
def向量化乘法(A, B):
    # 使用CUDA的向量化内核
    return torch.cuda commutative乘法(A, B)

# 比较性能
基准时间 = %timeit基准乘法(A, B)  # 输出时间：约 1.25 s
向量化时间 = %timeit向量化乘法(A, B)  # 输出时间：约 0.3 s

print(f"加速比：{基准时间 / 向量化时间:.2f}倍")

三、KV-Cache优化：大模型推理的革命性突破

KV-Cache（键值缓存）优化是大模型推理速度提升的核心技术之一，它通过缓存Transformer模型中注意力机制的键（Key）和值（Value）矩阵，避免重复计算，将推理速度提升数倍甚至数十倍 。

传统KV-Cache为每个推理请求分配一块连续内存，缓存整个序列的Key和Value。这种实现方式在处理变长序列时存在严重内存浪费问题，例如最大序列长度为4096，实际使用100个token时，内存利用率仅为2.5% 。这在高并发场景下会导致显存不足，限制模型的部署能力。

分页KV-Cache（PagedAttention） 是2023年由UC Berkeley团队提出的创新技术，它借鉴操作系统内存管理的经典思想，将KV-Cache的连续内存需求拆解为多个固定大小的"页（Page）"，通过页表管理离散内存块，从而消除碎片化问题 。这一技术使得LLM推理的显存利用率从传统方式的30%-40%提升至70%以上，同时支持任意长度的序列推理，彻底解决了传统连续内存分配的碎片化问题。

在vLLM框架中配置分页KV-Cache的代码示例：

python 复制代码 
from vllm import LLM, SamplingParams

# 初始化LLM实例，启用PagedAttention
llm = LLM(
    model="meta-llama/Llama-3-70b",
    enable_prefix_caching=True,  # 启用前缀缓存共享
    max_num_seqs=256,                # 最大批处理序列数
    max_model_len=4096,              # 模型最大上下文长度
    block_size=128                     # 页面大小（token数）
)

# 配置采样参数
sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=256)

# 生成文本
prompts = [
    "请解释相对论的基本原理。",
    "写一首关于春天的五言诗。",
    "如何学习Python数据分析？"
]

outputs = llm.generate(prompts, sampling_params)
for output in outputs:
    print(f"Prompt: {output prompt}")
    print(f"Generated text: {output(outputs[0].text}")

分页KV-Cache的核心原理 包括：页大小设计（平衡内存利用率与管理开销）、页表与地址映射（实现离散内存的连续访问）、按需分配与回收（动态管理内存资源） 。例如，对于一个13B参数的模型处理1K Token的请求，传统KV-Cache约占用10GB显存，而分页策略可将这一需求降低40%-60%。

滑动窗口机制是另一种KV-Cache优化策略，它只保留最近的N个token的KV缓存，以控制内存占用 。这种机制在牺牲少量上下文信息的情况下，保证了模型能处理更长的对话，特别适合资源受限的边缘设备部署。

四、连续批处理：动态调度的推理加速

连续批处理（Continuous Batching）是一种通过动态批处理提高GPU利用率的技术，它解决了传统静态批处理在高并发场景下的效率瓶颈问题 。

传统静态批处理需要等待一批请求都到达后才能开始处理，导致GPU利用率不稳定。例如，七个短请求只需200ms，但如果有一个长请求需要2s，整个批次必须等待2s才能返回结果，造成其他七个请求浪费1.8s的GPU时间 。

vLLM的连续批处理通过迭代级调度，将不同长度的请求按迭代合并为批次，使GPU几乎永不空闲 。这一技术实现了"边来边算"的平滑应对流量高峰，显存利用率提升5-10倍，吞吐量显著提高 。

vLLM连续批处理的底层调度逻辑可以简化为以下伪代码：

python 复制代码 
class Scheduler:
    def __init__(self, block_size=16, max_model_len=4096):
        self等待队列 = []  # 等待中的请求
        self运行队列 = []  # 正在运行的请求
        self块分配器 = BlockManager(block_size, max_model_len)

    def runBusyLoop(self):
        """引擎核心调度循环"""
        while True:
            # 1) 从输入队列获取新工作
            self._process_input_queue()

            # 2) 处理引擎步骤并返回输出
            outputs, model_executed = self._process_engine_step()

            # 3) 更新队列状态
            for request in outputs:
                if request.isFinished():
                    self._release_blocks(request)
                else:
                    self._update_blocks(request)

    def _process_engine_step(self):
        """处理引擎步骤的核心逻辑"""
        # 构建当前批次
        batch = []
        # 优先处理decode阶段的请求（"一等票"）
        while self.运行队列 and len(batch) < self.max_batch_size:
            request = self.运行队列.pop(0)
            if request.status == SequenceStatus.RUNNING:
                batch.append(request)

        # 如果仍有空闲，处理prefill阶段的请求（"二等票"）
        while self.等待队列 and len(batch) < self.max_batch_size:
            request = self.等待队列.pop(0)
            if request.status == SequenceStatus.WAITING:
                # 分配初始块
                request Prefill()
                batch.append(request)

        # 执行模型推理
        if batch:
            model_output = self.model.generate(batch)
            return self._process_model_output(model_output), True

        return None, False

连续批处理的优势在于：高并发下吞吐量提升显著，GPU利用率从30%~40%飙升至70%+；长文本生成不再因内存不足而失败，支持无限长度上下文；多模型切换更快速，配合容器编排工具可实现秒级热切换 。

五、投机解码：打破自回归生成的串行瓶颈

投机解码（Speculative Decoding）是近年来崛起的推理优化技术，它通过"小模型投机预测+大模型批量确认"的模式，成功将大模型生成效率提升30%-50%，成为工业级部署的关键选型 。

投机解码的核心逻辑可概括为：用一个轻量、快速的"草稿模型（Draft Model）"提前预测大模型的输出序列，再由目标大模型（Target Model）对预测结果进行批量验证和修正 。这一过程打破了自回归生成的串行依赖，使模型能够并行处理多个token的验证工作。

在gptfast项目中实现投机解码的核心代码示例：

python 复制代码 
def speculative_decoding(draft_model, target_model, prompt, k=8, threshold=0.9):
    # 初始化输入序列
    input_ids = tokenizer.encode(prompt, return_tensors="pt").to(device)
    outputs = []

    # 首轮prefill
    with torch.no_grad():
        kv_cache = target_model.get kv cache(input_ids)
        draft_logits = draft_model(input_ids, kv_cache=kv_cache)
        draft_tokens = torch.argmax(draft_logits, dim=-1)

    # 生成初始草案
    draft_text = tokenizer.decode(draft_tokens, skip_special_tokens=True)
    outputs.append(draft_text)

    # 迭代生成
    while len(outputs) < max_length:
        # 获取最新草案
        current prompt = prompt + outputs[-1]

        # 草稿模型生成k个token
        with torch.no_grad():
            draft_logits = draft_model(current prompt, kv_cache=kv_cache)
            draft_tokens = torch topk(draft_logits, k=k, dim=-1)

        # 验证模型并行验证
        verification_logits = target_model(current prompt, draft_tokens=draft_tokens)

        # 计算接受率
        acceptance probabilites = verification_logits / draft_logits

        # 找到第一个不满足条件的token
        m = 0
        for i in range(k):
            if acceptance probabilites[i] >= threshold:
                m += 1
            else:
                break

        # 更新输出序列
        if m > 0:
            outputs.append(tokenizer.decode(draft_tokens[:m], skip_special_tokens=True))
            # 更新kv缓存
            kv_cache = target_model.update kv cache kv_cache, draft_tokens[:m])
        else:
            # 验证失败，由目标模型重新生成
            with torch.no_grad():
                new_token = target_model.generate(current prompt, kv_cache=kv_cache)
                outputs.append(tokenizer.decode(new_token, skip_special_tokens=True))
                kv_cache = target_model.update kv cache kv_cache, new_token)

    return outputs

Recursive Speculative Decoding (RSD) 是投机解码的进阶版本，它通过构建token候选树并采样无重复候选，结合Gumbel-Top-k或随机束搜索，进一步提升了投机解码的效率 。RSD在Llama-2和OPT模型上的实验表明，其速度提升可达1.9-2.8倍，且在大多数情况下保持与目标模型相同的输出质量 。

六、模型优化工具：框架级加速方案

在2024-2025年间，各大深度学习框架纷纷推出专门的模型优化工具，这些工具通过图优化、层融合和动态张量分配等技术来提高模型的执行效率。

PyTorch的Torch.compile是一个专门为PyTorch模型设计的编译器，可以提升模型运行效率 。它能够捕获模型中更大的区域，并将其编译成单一的编译区域，特别当以"reduce-overhead"模式运行时，非常有效地减少了CPU的开销。GPTFast项目使用Torch.compile后，性能直接提升了4倍，从25 tok/s提高到107 tok/s 。

python 复制代码 
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载模型和分词器
model_name = "llama-3-70b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# 启用Torch.compile优化
optimized_model = torch.compile(model, mode="reduce-overhead")

# 推理函数
def inference(model, inputs, batch_size=8):
    # 分割输入数据
    inputs = inputs.split(batch_size)
    outputs = []

    for batch in inputs:
        # 转换为张量并转移到GPU
        batch = tokenizer(batch, return_tensors="pt").to("cuda")

        # 执行推理
        with torch.no_grad():
            batch_output = optimized_model.generate(**batch, max_new_tokens=100)

        outputs.extend(tokenizer.decode(batch_output, skip_special_tokens=True))

    return outputs

# 使用优化后的模型进行推理
input_text = ["Explain AI alignment.", "Write a poem about autumn leaves."]
outputs = inference(optimized_model, input_text)

算子融合（Operator Fusion） 将神经网络中多个相邻算子合并为一个复合算子，避免中间结果写入显存/内存，减少计算设备（如GPU）的Kernel调用次数和数据搬运开销 。例如，将"卷积+批量归一化（BN）+激活函数（ReLU）"融合为单个Kernel，省去两次数据读写。

在PyTorch中实现算子融合的示例代码：

python 复制代码 
import torch
import torch.nn as nn
from torch import nn, optim

class FusionModule(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3):
        super().__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU()

    def forward(self, x):
        # 手动融合三个算子
        x = self.conv(x)
        x = self bn(x)
        x = self.relu(x)
        return x

# 使用FusionModule代替标准模块
model = nn.Sequential(
    FusionModule(3, 64, 3),
    FusionModule(64, 128, 3),
    nn AvergePool2d(2),
    nn.Linear(128 * 16 * 16, 1000)
)

# 优化推理流程
with torch.no_grad():
    optimized_model = torch.jit痕迹消除(model)
    outputs = optimized_model.generate(inputs)

TensorRT是NVIDIA提供的深度学习推理优化工具，它通过图优化、层融合和动态张量分配等技术来提高模型的执行效率。TensorRT能够自动检测并利用GPU硬件特性，提供最佳的性能。根据实测数据，TensorRT优化后的模型在A100 GPU上的推理速度可提升3-5倍。

python 复制代码 
import tensorrt as trt
import pycuda driver as driver
import pycuda autoinit

# 加载PyTorch模型
model = torch.load("llama_3_70b.pt")
model.eval()

# 转换为TensorRT引擎
builder = trt.Builder(trtLogger)
network = builder.create network()
parser = trt ONNXParser(network)

# 导出为ONNX格式
torch onnx export(
    model,
    inputs,
    "llama_3_70b.onnx",
    opset_version=13
)

# 解析ONNX模型
with open("llama_3_70b.onnx", "rb") as f:
    parser.parse(f.read())

# 构建TensorRT引擎
config = builder.create builder config()
config.max Workspace Size = 1 << 30  # 1GB
engine = builder build engine在网络, config)

# 执行推理
context = engine.create execution context()
inputs, outputs, bindingss = allocate_buffers(context)
context.execute(vectors=inputs)

# 解析输出结果
generated_text = decode outputs(outputs)

七、综合优化策略：加速效果的乘法效应

在实际应用中，多种加速方法需协同作用以实现最优性能，形成加速效果的乘法效应 。

典型的组合策略为：先剪枝去除冗余结构，再量化降低计算精度，最后通过知识蒸馏保留性能，并配合推理引擎（如TensorRT、OpenVINO、vLLM等）进一步优化 。例如，对于一个7B参数的模型，通过结构化剪枝移除30%的冗余参数，然后使用INT8量化，最后通过知识蒸馏训练一个更紧凑的学生模型，最终模型体积可能减少至原来的1/5，同时推理速度提升10倍以上。

vLLM的综合优化方案是当前工业界应用最广泛的加速框架，它集成了PagedAttention、连续批处理、前缀缓存共享、多种量化格式支持等技术 。在A100 GPU上运行LLaMA-7B模型时，vLLM相比HuggingFace Transformers，默认设置下吞吐量提升了8.7倍 。

python 复制代码 
from vllm import LLM, SamplingParams

# 配置综合优化参数
llm = LLM(
    model="meta-llama/Llama-3-70b",
    dtype="half",  # FP16节省显存
    enable_prefix_caching=True,  # 前缀缓存共享
    max_num_seqs=256,  # 最大并发序列数
    max_model_len=4096,  # 最大上下文长度
    block_size=128,  # 分页大小
   量化方法="AWQ",  # 使用AWQ量化
   量化位数=8  # 8位量化
)

# 配置采样参数
sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.95,
    max_tokens=256,
    speculative decoding=True,  # 启用投机解码
    draft model="llama-3-8b"  # 指定草稿模型
)

# 批量生成
prompts = [
    "请解释相对论的基本原理。",
    "写一首关于春天的五言诗。",
    "如何学习Python数据分析？"
]

outputs = llm.generate(prompts, sampling_params)
for output in outputs:
    print(f"Prompt: {output prompt}")
    print(f"Generated text: {output(outputs[0].text}")

模型优化工具的协同使用是实现最佳性能的关键。例如，在vLLM中结合张量并行和分页KV-Cache，可以在多个GPU上分布模型的运算，同时高效管理注意力缓存，实现推理速度的线性提升。

八、未来发展趋势：推理加速技术的新方向

随着大模型参数量的持续增长，推理加速技术也在不断创新和发展。以下是未来可能的趋势：

动态精度调整技术允许模型在不同计算阶段使用不同精度，例如在注意力计算中使用FP16，在前馈网络中使用INT8，从而在保持精度的同时最大化加速效果。这一技术需要模型架构的深度理解和硬件支持的精细控制。

注意力机制的创新也在不断推进，如稀疏注意力、局部注意力等，这些机制可以显著减少计算量和内存占用。例如，vLLM的PagedAttention将注意力计算中的多个操作（如Softmax、矩阵乘法）融合为单个CUDA内核，减少内存访问 。

硬件加速器的专用优化也是未来的重要方向。随着NPU、TPU等专用AI芯片的普及，针对这些硬件的专用推理引擎将变得越来越重要。例如，vLLM已经开发了针对AMD、Intel Gaudi等不同硬件的插件 。

端到端的推理服务优化将整合模型压缩、并行化、向量化等多种技术，形成完整的推理加速解决方案。例如，vLLM的Alibaba Cloud集成方案通过优化整个推理流程，实现了从模型加载到结果返回的全链路加速 。

九、总结与建议

模型推理加速已成为大模型落地的关键技术，在保持模型性能的同时显著提升推理速度和降低资源消耗。通过量化、剪枝、知识蒸馏等模型压缩技术，结合并行化、向量化等计算优化技术，以及KV-Cache优化、连续批处理、投机解码等前沿技术，可以实现推理速度的质的飞跃。

对于实际应用，建议采取以下策略：

  1. 根据场景选择合适的加速技术：对于资源受限的边缘设备，优先考虑量化和剪枝；对于高并发的云服务场景，优先考虑连续批处理和投机解码。

  2. 采用框架级优化工具：如vLLM、TensorRT等，它们已经集成了多种优化技术，可以显著简化部署流程。

  3. 结合多种技术形成综合优化方案：单一技术往往只能带来有限的加速效果，而多种技术的协同使用可以产生乘法效应。

  4. 持续关注最新技术发展：推理加速领域发展迅速，新的优化技术和框架不断涌现，保持技术敏感度对于获取最佳性能至关重要。

随着硬件技术的进步和新算法的出现，我们有理由相信深度学习模型的推理速度将会得到更大的提升。作为开发者，持续关注最新的技术和趋势，不断调整和优化我们的模型，将是保持竞争力的关键。

相关推荐
visnix3 小时前
AI大模型-LLM原理剖析到训练微调实战(第二部分：大模型核心原理与Transformer架构)
前端·llm
智泊AI4 小时前
重磅！小米刚刚发布新模型MiMo-V2-Flash开源了！
llm
骚戴5 小时前
大语言模型（LLM）进阶：从闭源大模型 API 到开源大模型本地部署，四种接入路径全解析
java·人工智能·python·语言模型·自然语言处理·llm·开源大模型
stark张宇7 小时前
别掉队！系统掌握 LLM 应用开发，这可能是你今年最值得投入的学习方向
人工智能·llm·agent
大模型教程8 小时前
使用Langchain4j和Ollama3搭建RAG系统
langchain·llm·ollama
大模型教程8 小时前
全网首发！清北麻省顶级教授力荐的《图解大模型》中文版终于来了，碾压 95% 同类教材
程序员·llm·agent
用户307140958488 小时前
📢 深度解析 Dify 核心 LLM 提示模板库，揭秘 AI 交互的「幕后魔法」
人工智能·llm·agent
AI大模型8 小时前
谷歌 Agents 白皮书中文版全网首发，堪称 AI 教材的天花板级神作
程序员·llm·agent
Elwin Wong9 小时前
本地运行LangChain Agent用于开发调试
人工智能·langchain·大模型·llm·agent·codingagent
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03Linux下V2Ray安装配置指南04在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）05【AutoGLM部署】本地私有化部署AI手机Agent06Open-AutoGLM Windows 安装部署教程07Cursor 又偷偷更新，这个功能太实用：Visual Editor for Cursor Browser08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09Labelme从安装到标注：零基础完整指南10BongoCat - 跨平台键盘猫动画工具