Pytorch nn.Module详解

fydw_7152025-02-20 9:27

torch.nn.Module 是 PyTorch 中所有神经网络模块的基类，提供了构建神经网络模型的基本框架。通过继承 nn.Module，可以方便地创建自定义的神经网络模块，实现复杂的神经网络结构。下面详细介绍 nn.Module 的核心概念、使用方法和注意事项。

一、nn.Module 的核心概念

  1. 模块化设计 ：nn.Module 将神经网络的各个部分封装成模块，方便组合、复用和管理。这些模块既可以是简单的层（如线性层、卷积层），也可以是由多个子模块组合而成的复杂模型。

  2. 参数管理 ：nn.Module 自动管理模型中的参数（nn.Parameter），并提供了方便的接口来访问和操作这些参数，如 .parameters()、.named_parameters()。

  3. 子模块管理 ：通过将子模块添加到父模块中，nn.Module 能够自动识别并管理模型中层次化的结构，这对于构建深层或递归的模型非常有用。

二、nn.Module 的基本使用方法

1. 创建自定义模块

创建自定义的神经网络模块需要继承 nn.Module，并实现 __init__ 和 forward 方法。

python 复制代码 
import torch
import torch.nn as nn

class CustomModel(nn.Module):
    def __init__(self):
        super(CustomModel, self).__init__()
        # 定义网络层
        self.layer1 = nn.Linear(in_features=784, out_features=256)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(in_features=256, out_features=10)

    def forward(self, x):
        # 定义前向传播
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x

2. 初始化方法 __init__

在 __init__ 方法中，定义网络所需的层和参数。这些层通常是其他 nn.Module 的实例，如 nn.Linear、nn.Conv2d 等。

  • 注册子模块 ：当在 __init__ 方法中将子模块赋值给 self 的成员变量时，nn.Module 会自动注册这些子模块。

3. 前向传播方法 forward

forward 方法定义了输入数据如何经过各个层的传递，最终得到输出。需要注意，forward 方法中不需要显式调用 backward，PyTorch 会根据计算图自动构建反向传播。

4. 模型实例化和使用

python 复制代码 
model = CustomModel()
input_data = torch.randn(64, 784)  # 批大小为64，输入特征为784
output = model(input_data)

三、nn.Module 的常用方法和属性

nn.Module 的常用方法和属性在神经网络的构建、训练和评估过程中起着关键作用。下面我将详细介绍这些方法和属性，并通过实际有意义的例子来说明它们的使用方式和应用场景。

1. parameters() 方法

作用
  • 返回模型中所有需要训练的参数的迭代器。
  • 参数通常以 nn.Parameter 的形式注册到模块中。
实际应用示例

场景： 在训练神经网络时，我们需要将模型的参数传递给优化器，以便更新这些参数。

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

# 定义一个简单的神经网络模型
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(10, 5)  # 输入特征维度为10，输出维度为5
        self.fc2 = nn.Linear(5, 1)   # 输入维度为5，输出为1

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 实例化模型
model = SimpleNet()

# 创建优化器，将模型参数传递给优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 打印模型的参数
for param in model.parameters():
    print(param.size())

解释：

  • model.parameters() 返回模型中所有可训练的参数，包括 fc1 和 fc2 的权重和偏置。
  • 优化器需要知道需要更新哪些参数，因此将这些参数传递给优化器。

2. children() 方法

作用
  • 返回模块的直接子模块的迭代器。
  • 仅包含模块的第一层子模块，不包括嵌套的子模块。
实际应用示例

场景： 我们想要冻结（不训练）预训练模型的前几层，以保留预训练的特征提取能力。

python 复制代码 
import torchvision.models as models
import torch.nn as nn

# 加载预训练的 VGG16 模型
vgg16 = models.vgg16(pretrained=True)

# 冻结前几个子模块的参数
for idx, child in enumerate(vgg16.children()):
    if idx < 2:  # 假设我们想冻结前两个子模块
        for param in child.parameters():
            param.requires_grad = False

# 添加新的全连接层进行微调
vgg16.classifier[-1] = nn.Linear(4096, 10)  # 假设我们有10个分类

# 检查哪些参数被训练
for name, param in vgg16.named_parameters():
    print(f"{name}: requires_grad = {param.requires_grad}")

解释：

  • vgg16.children() 返回 VGG16 模型的直接子模块，我们可以迭代它们并控制是否需要训练它们的参数。
  • 通过设置 param.requires_grad = False，我们可以冻结参数，使其在训练过程中不更新。

3. modules() 方法

作用
  • 返回模块自身及其所有子模块（包括嵌套子模块）的迭代器。
  • 可以遍历模型中的所有模块，方便进行批量操作。
实际应用示例

场景： 我们希望将模型中的所有激活函数 ReLU 替换为 LeakyReLU。

python 复制代码 
import torch.nn as nn

# 定义一个包含多个子模块的复杂模型
class ComplexNet(nn.Module):
    def __init__(self):
        super(ComplexNet, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(3, 16, 3),
            nn.ReLU()
        )
        self.layer2 = nn.Sequential(
            nn.Conv2d(16, 32, 3),
            nn.ReLU()
        )
        self.fc = nn.Linear(32 * 6 * 6, 10)

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = x.view(-1, 32 * 6 * 6)
        x = self.fc(x)
        return x

# 实例化模型
model = ComplexNet()

# 遍历模型的所有模块，将 ReLU 替换为 LeakyReLU
def replace_relu(module):
    for name, child in module.named_children():
        if isinstance(child, nn.ReLU):
            setattr(module, name, nn.LeakyReLU())
        else:
            replace_relu(child)

replace_relu(model)

# 验证替换结果
print(model)

解释：

  • 通过递归遍历 model.modules()，我们可以定位并替换所有的 ReLU 层。
  • 使用 setattr() 方法，我们可以在模型中动态地修改模块。

4. train() 和 eval() 方法

作用
  • train()：将模块设置为训练模式（如启用 Dropout 和 BatchNorm 训练行为）。
  • eval()：将模块设置为评估模式（如禁用 Dropout，并使用 BatchNorm 的运行时均值和方差）。
实际应用示例

场景： 在模型的训练和评估阶段，需要切换模型的模式，以确保层的行为正确。

python 复制代码 
import torch
import torch.nn as nn

# 定义一个包含 Dropout 和 BatchNorm 的模型
class NetWithDropout(nn.Module):
    def __init__(self):
        super(NetWithDropout, self).__init__()
        self.fc1 = nn.Linear(20, 50)
        self.bn1 = nn.BatchNorm1d(50)
        self.dropout = nn.Dropout(p=0.5)
        self.fc2 = nn.Linear(50, 2)

    def forward(self, x):
        x = torch.relu(self.bn1(self.fc1(x)))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

# 实例化模型
model = NetWithDropout()

# 在训练过程中
model.train()
# 模拟输入
train_input = torch.randn(10, 20)
train_output = model(train_input)

# 在评估过程中
model.eval()
# 模拟输入
eval_input = torch.randn(10, 20)
eval_output = model(eval_input)

解释：

  • 在训练模式下，Dropout 随机舍弃神经元，BatchNorm 计算和更新运行时统计量。
  • 在评估模式下，Dropout 不起作用，BatchNorm 使用训练过程中计算的统计量。
  • 通过切换模式，我们确保模型在不同阶段的行为符合预期。

5. state_dict() 和 load_state_dict() 方法

作用
  • state_dict()：返回包含模型所有可学习参数和缓冲区的字典对象。
  • load_state_dict()：将参数字典加载到模型中。
实际应用示例

场景： 我们希望保存训练好的模型参数，并在需要时加载它们。

python 复制代码 
import torch

# 假设模型已经训练好了
model = NetWithDropout()

# 保存模型参数
torch.save(model.state_dict(), 'model_weights.pth')
print("模型参数已保存到 'model_weights.pth'")

# 加载模型参数到新的模型实例
new_model = NetWithDropout()
new_model.load_state_dict(torch.load('model_weights.pth'))
print("模型参数已加载到新的模型实例")

# 确认模型在评估阶段
new_model.eval()

解释：

  • torch.save() 和 torch.load() 用于保存和加载模型的状态字典。
  • 通过 state_dict()，我们只保存模型的参数，而不保存整个模型结构。
  • 这样可以在代码更新或模型结构不变的情况下，加载之前的参数。

6. named_parameters() 方法

作用
  • 返回一个迭代器，生成模型参数的名称和参数本身的元组。
实际应用示例

场景： 我们想为模型的不同层设置不同的学习率，例如对预训练的层使用较小的学习率，对新添加的层使用较大的学习率。

python 复制代码 
import torch.optim as optim

# 假设我们使用预训练的模型并添加了一些新的层
class CustomNet(nn.Module):
    def __init__(self, pretrained_model):
        super(CustomNet, self).__init__()
        self.features = pretrained_model.features  # 预训练的特征提取部分
        self.new_layers = nn.Sequential(
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 10)
        )

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.new_layers(x)
        return x

# 加载预训练模型
pretrained_model = models.resnet18(pretrained=True)
model = CustomNet(pretrained_model)

# 为不同部分的参数设置不同的学习率
params = [
    {'params': model.features.parameters(), 'lr': 1e-4},
    {'params': model.new_layers.parameters(), 'lr': 1e-3}
]

optimizer = optim.SGD(params, momentum=0.9)

# 打印参数的名称和学习率
for param_group in optimizer.param_groups:
    for param in param_group['params']:
        print(f"Learning rate: {param_group['lr']}, Parameter shape: {param.shape}")

解释：

  • 使用 named_parameters()，我们可以获取参数的名称，并根据名称进行分组。
  • 在这个例子中，我们为预训练的特征部分设置了较小的学习率，为新添加的层设置了较大的学习率，以加快收敛速度。

7. zero_grad() 方法

作用
  • 将模型中所有可学习参数的梯度置零。
  • 通常在每次反向传播前调用，以避免累积梯度。
实际应用示例

场景： 在训练循环中，我们需要在每个批次开始时重置梯度。

python 复制代码 
# 假设我们在训练模型
for epoch in range(num_epochs):
    for data, target in train_loader:
        optimizer.zero_grad()  # 或者 model.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

解释：

  • 如果不调用 zero_grad()，梯度会在每次 backward 时累积，导致梯度值不正确。
  • optimizer.zero_grad() 和 model.zero_grad() 都可以重置梯度，二者等效。

8. to(device) 方法

作用
  • 将模型的所有参数和缓冲区移动到指定的设备（如 CPU 或 GPU）。
实际应用示例

场景： 如果我们想利用 GPU 加速模型的训练和推理，需要将模型和数据都移动到 GPU。

python 复制代码 
# 检查是否有可用的 GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f'Using device: {device}')

# 将模型移动到指定设备
model.to(device)

# 在训练循环中，确保输入数据也在同一设备上
for data, target in train_loader:
    data, target = data.to(device), target.to(device)
    optimizer.zero_grad()
    output = model(data)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()

解释：

  • model.to(device) 会递归地将模型的所有参数和缓冲区移动到指定设备。
  • 在训练和评估时，输入数据和模型必须在同一设备上。

9. register_buffer() 方法

作用
  • 向模块中注册一个持久的缓冲区，缓冲区不是可学习参数，但在模型保存和加载时会一同存储。
实际应用示例

场景： 在实现某些层时，需要保存一些在训练过程中更新但不需要梯度的变量，例如批归一化层的运行时均值和方差。

python 复制代码 
class MyBatchNorm1d(nn.Module):
    def __init__(self, num_features):
        super(MyBatchNorm1d, self).__init__()
        self.num_features = num_features
        self.weight = nn.Parameter(torch.ones(num_features))
        self.bias = nn.Parameter(torch.zeros(num_features))
        # 注册缓冲区
        self.register_buffer('running_mean', torch.zeros(num_features))
        self.register_buffer('running_var', torch.ones(num_features))

    def forward(self, x):
        if self.training:
            # 计算批次均值和方差
            batch_mean = x.mean(dim=0)
            batch_var = x.var(dim=0, unbiased=False)
            # 更新运行时均值和方差
            self.running_mean = 0.9 * self.running_mean + 0.1 * batch_mean
            self.running_var = 0.9 * self.running_var + 0.1 * batch_var
            # 归一化
            x_hat = (x - batch_mean) / torch.sqrt(batch_var + 1e-5)
        else:
            # 使用运行时均值和方差
            x_hat = (x - self.running_mean) / torch.sqrt(self.running_var + 1e-5)
        return self.weight * x_hat + self.bias

# 使用自定义的批归一化层
model = nn.Sequential(
    nn.Linear(20, 50),
    MyBatchNorm1d(50),
    nn.ReLU(),
    nn.Linear(50, 2)
)

解释：

  • register_buffer() 将变量注册为模型的缓冲区，这些变量不会更新梯度，但会在模型保存和加载时保留。
  • 缓冲区也会在调用 model.to(device) 时被移动到指定设备。

10. register_parameter() 方法

作用
  • 将一个新的参数（nn.Parameter 对象）注册到模块中。
  • 一般用于在模型的 __init__ 方法中动态添加参数。
实际应用示例

场景 1： 创建一个自定义的线性层，参数尺寸根据输入大小动态确定。

python 复制代码 
import torch
import torch.nn as nn

class DynamicLinear(nn.Module):
    def __init__(self, input_features, output_features):
        super(DynamicLinear, self).__init__()
        self.input_features = input_features
        self.output_features = output_features
        
        # 动态创建权重和偏置参数，但不使用内置的 nn.Linear
        weight = torch.randn(output_features, input_features)
        bias = torch.randn(output_features)
        
        # 注册参数
        self.register_parameter('weight', nn.Parameter(weight))
        self.register_parameter('bias', nn.Parameter(bias))
    
    def forward(self, x):
        return torch.nn.functional.linear(x, self.weight, self.bias)

# 使用自定义的 DynamicLinear
model = nn.Sequential(
    DynamicLinear(10, 5),
    nn.ReLU(),
    DynamicLinear(5, 1)
)

# 打印模型的参数
for name, param in model.named_parameters():
    print(f"Parameter name: {name}, Parameter size: {param.size()}")

解释：

  • 在 DynamicLinear 中，我们手动创建了权重 weight 和偏置 bias，并使用 register_parameter() 将它们注册为模型的参数。
  • 这样一来，参数就能被 model.parameters() 捕获，并在训练过程中优化。

场景 2： 在模型中可选择性地添加某个参数。

python 复制代码 
class OptionalBias(nn.Module):
    def __init__(self, input_features, output_features, use_bias=True):
        super(OptionalBias, self).__init__()
        self.weight = nn.Parameter(torch.randn(output_features, input_features))
        
        if use_bias:
            bias = torch.randn(output_features)
            self.register_parameter('bias', nn.Parameter(bias))
        else:
            # 如果不使用偏置，则将 bias 设置为 None
            self.register_parameter('bias', None)
    
    def forward(self, x):
        return torch.nn.functional.linear(x, self.weight, self.bias)

# 实例化不使用偏置的层
layer_no_bias = OptionalBias(10, 5, use_bias=False)

# 实例化使用偏置的层
layer_with_bias = OptionalBias(10, 5, use_bias=True)

# 检查参数
print("Without bias:")
for name, param in layer_no_bias.named_parameters():
    print(f"Parameter name: {name}, Parameter size: {param.size() if param is not None else 'None'}")

print("\nWith bias:")
for name, param in layer_with_bias.named_parameters():
    print(f"Parameter name: {name}, Parameter size: {param.size()}")

解释：

  • 通过条件判断，我们可以选择性地注册参数。
  • 如果不使用偏置，我们将 bias 参数设为 None，并使用 register_parameter('bias', None)，这样可确保模型结构的完整性，同时在 forward 方法中可以统一处理。

场景 3： 从外部加载参数并注册到模型中。

python 复制代码 
class ExternalParameterModule(nn.Module):
    def __init__(self, parameter_dict):
        super(ExternalParameterModule, self).__init__()
        for name, value in parameter_dict.items():
            param = nn.Parameter(value)
            self.register_parameter(name, param)
    
    def forward(self, x):
        # 假设我们使用这些参数进行一些计算
        for name, param in self.named_parameters():
            x = x * param
        return x

# 从外部加载参数值
external_params = {
    'scale_factor': torch.tensor(2.0),
    'shift_value': torch.tensor(1.0)
}

# 创建模型实例
model = ExternalParameterModule(external_params)

# 查看模型的参数
for name, param in model.named_parameters():
    print(f"Parameter name: {name}, Parameter value: {param.item()}")

# 使用模型进行计算
input_data = torch.tensor([3.0])
output = model(input_data)
print(f"Output: {output.item()}")

解释：

  • 在初始化时，我们从外部参数字典中创建 nn.Parameter，并使用 register_parameter() 将其注册。
  • 这使得我们可以灵活地从外部源（如预训练模型、配置文件等）加载参数。
注意事项

  1. 参数名称唯一性：

    • 在注册参数时，参数名称 name 必须是唯一的，不能与已有的参数或子模块重名。
    • 否则，会引发 KeyError 或覆盖已有的参数。

  2. 参数类型：

    • 注册的参数必须是 nn.Parameter 类型，或者为 None。
    • 如果需要注册非参数的变量，应该使用 register_buffer() 方法。

  3. 参数可见性：

    • 使用 register_parameter() 注册的参数，会被 model.parameters()、named_parameters() 等方法捕获。
    • 这确保了优化器能够正确地获取所有需要训练的参数。
与直接赋值的区别

  • 直接赋值注册参数：

    • 当我们在 __init__ 方法中，将 nn.Parameter 直接赋值给 self 的属性，例如 self.weight = nn.Parameter(...)，PyTorch 会自动将其注册为模型的参数。

  • 使用 register_parameter()：

    • 当需要动态地、循环地或条件性地注册参数，或者参数名称需要动态生成时，register_parameter() 非常有用。

示例：使用循环注册多个参数

python 复制代码 
class MultiParameterModule(nn.Module):
    def __init__(self, num_params):
        super(MultiParameterModule, self).__init__()
        for i in range(num_params):
            param = nn.Parameter(torch.randn(1))
            self.register_parameter(f'param_{i}', param)
    
    def forward(self, x):
        for name, param in self.named_parameters():
            x = x + param
        return x

# 注册5个参数的模块
model = MultiParameterModule(5)

# 查看模型的参数
for name, param in model.named_parameters():
    print(f"Parameter name: {name}, Parameter value: {param.item()}")

解释：

  • 在循环中，我们动态地创建和注册参数，参数名称根据循环索引生成。
  • 这种情况下，直接赋值无法实现这样的动态命名和注册，register_parameter() 则提供了灵活性。

11. named_modules() 方法

作用
  • 返回一个迭代器，生成模块的名称和模块本身的元组。
  • 包括模型自身及其所有子模块。
实际应用示例

场景： 我们希望知道模型中各个模块的名称和结构，或者根据模块名称进行特定操作。

python 复制代码 
# 打印模型的模块名称和结构
for name, module in model.named_modules():
    print(f"Module name: {name}, Module type: {module.__class__.__name__}")

# 示例：冻结特定命名的子模块的参数
for name, module in model.named_modules():
    if 'layer1' in name:
        for param in module.parameters():
            param.requires_grad = False

解释：

  • 通过 named_modules()，我们可以获取模块的名称和模块实例本身，便于对模型进行深入了解和操作。
  • 例如，我们可以根据名称模式对特定的层进行参数冻结、替换等操作。

nn.Module 的这些方法和属性为模型的构建、训练和管理提供了强大的工具。通过上述实际例子，我们可以看到如何在实际应用中利用这些方法：

  • 模型参数管理 ：使用 parameters()、named_parameters()、zero_grad()、register_parameter() 等方法，方便地管理模型的可学习参数。
  • 模型结构操作 ：利用 children()、modules()、named_modules() 可以遍历和修改模型的结构。
  • 模型模式切换 ：通过 train() 和 eval() 方法，控制模型在训练和评估阶段的行为。
  • 模型保存与加载 ：使用 state_dict() 和 load_state_dict()，可以高效地保存和加载模型参数。
  • 设备管理 ：调用 to(device) 方法，可以轻松地在 CPU 和 GPU 之间切换模型和数据的计算设备。
  • 缓冲区管理 ：使用 register_buffer()，可以在模型中添加非参数但需要持久化的变量。

五、小提示和最佳实践

  1. 始终调用父类的 __init__ 方法：

    在自定义模块的 __init__ 方法中，务必要调用 super().__init__()，以确保父类的初始化正确执行。

  2. 避免在模块中定义可训练参数的非 nn.Parameter 类型：

    如果在 __init__ 中定义了需要训练的参数，而没有使用 nn.Parameter 或将其赋值为子模块，参数将不会被 parameters() 方法检索到，从而无法参与训练。

  3. 正确使用模块模式：

    在训练和评估模型时，要记得切换模型的模式（train()、eval()），以确保诸如 Dropout 和 BatchNorm 等层以正确的方式工作。

  4. 使用 to(device) 方法：

    可以使用 model.to(device) 将模型和其参数移动到指定的设备（如 GPU）。

    python 复制代码 
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
input_data = input_data.to(device)
output = model(input_data)

  5. 模型保存和加载的一致性：

    在保存和加载模型时，建议只保存模型的参数（state_dict()），而不是整个模型对象。这可以避免因为代码变动导致的兼容性问题。

六、示例：构建卷积神经网络

下面是一个简单的卷积神经网络示例：

python 复制代码 
class ConvNet(nn.Module):
    def __init__(self):
        super(ConvNet, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.relu = nn.ReLU()
        self.fc = nn.Linear(in_features=16*14*14, out_features=10)

    def forward(self, x):
        x = self.relu(self.conv1(x))  # [batch_size, 16, 28, 28]
        x = self.pool(x)              # [batch_size, 16, 14, 14]
        x = x.view(-1, 16*14*14)      # 展平
        x = self.fc(x)
        return x

model = ConvNet()
print(model)

七、总结

nn.Module 是 PyTorch 构建神经网络的基石，它提供了灵活而强大的接口，支持各种复杂模型的构建。通过继承和扩展 nn.Module，可以实现自定义的网络结构，并利用 PyTorch 提供的自动微分机制、优化器和工具，加速模型的开发和训练。

希望以上内容能够帮助您深入理解 nn.Module，并在实际项目中灵活运用。

相关推荐
西西弗Sisyphus31 分钟前
全面掌握Python时间处理
python·time
java1234_小锋3 小时前
一周学会Flask3 Python Web开发-http响应状态码
python·flask·flask3
Elastic 中国社区官方博客3 小时前
Elasticsearch 混合搜索 - Hybrid Search
大数据·人工智能·elasticsearch·搜索引擎·ai·语言模型·全文检索
@心都3 小时前
机器学习数学基础：29.t检验
人工智能·机器学习
9命怪猫3 小时前
DeepSeek底层揭秘——微调
人工智能·深度学习·神经网络·ai·大模型
奔跑吧邓邓子4 小时前
【Python爬虫(12)】正则表达式：Python爬虫的进阶利刃
爬虫·python·正则表达式·进阶·高级
码界筑梦坊4 小时前
基于Flask的京东商品信息可视化分析系统的设计与实现
大数据·python·信息可视化·flask·毕业设计
pianmian14 小时前
python绘图之箱型图
python·信息可视化·数据分析
csbDD4 小时前
2025年网络安全（黑客技术）三个月自学手册
linux·网络·python·安全·web安全
kcarly5 小时前
KTransformers如何通过内核级优化、多GPU并行策略和稀疏注意力等技术显著加速大语言模型的推理速度？
人工智能·语言模型·自然语言处理
热门推荐
01本地部署DeepSeek教程（Mac版本）02如何在WPS和Word/Excel中直接使用DeepSeek功能03DeepSeek本地部署详细指南04太炸裂了！清华大学deepseek从入门到精通使用手册又出第三版了，《普通人如何抓住DeepSeek红利》（无套路，直接下载）05DeepSeek各版本说明与优缺点分析06DeepSeek r1本地安装全指南07本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程08DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具09在Windows下安装Ollama并体验DeepSeek r1大模型10Page Assist - 本地Deepseek模型 Web UI 的安装和使用