解锁PyTorch神经网络权重奥秘掌握模型参数提取与分析实战技巧

引言

在深度学习领域，神经网络权重（也称为参数）是模型的核心组成部分，它们存储了网络通过训练学习到的知识。PyTorch作为当前最受欢迎的深度学习框架之一，提供了灵活而强大的工具来处理神经网络权重。理解和掌握PyTorch中权重的提取与分析技术，对于模型调试、优化和解释至关重要。本文将深入探讨PyTorch神经网络权重的奥秘，从基础概念到高级技巧，帮助读者全面掌握模型参数的提取与分析实战技能。

PyTorch基础与神经网络参数

PyTorch简介

PyTorch是一个基于Python的科学计算库，主要针对两类用户：

替代NumPy以使用GPU的强大计算能力
提供最大灵活性和速度的深度学习研究平台

PyTorch的核心是张量（Tensor）计算和自动微分系统，这使得构建和训练神经网络变得直观而高效。

神经网络参数的基本概念

在PyTorch中，神经网络的参数通常指的是权重（weights）和偏置（biases）。这些参数是模型在训练过程中学习到的内容，它们决定了网络的输入如何转换为输出。

让我们通过一个简单的例子来理解神经网络参数：

import torch import torch.nn as nn # 定义一个简单的神经网络 class SimpleNet(nn.Module): def __init__(self): super(SimpleNet, self).__init__() self.fc1 = nn.Linear(10, 5) # 输入层到隐藏层 self.fc2 = nn.Linear(5, 1) # 隐藏层到输出层 def forward(self, x): x = torch.relu(self.fc1(x)) x = self.fc2(x) return x # 实例化模型 model = SimpleNet() print(model)

输出：

SimpleNet( (fc1): Linear(in_features=10, out_features=5, bias=True) (fc2): Linear(in_features=5, out_features=1, bias=True) )

在这个简单的网络中，我们有两个线性层（全连接层），每个层都有权重和偏置参数。fc1层的权重矩阵大小为5×10，偏置向量大小为5；fc2层的权重矩阵大小为1×5，偏置向量大小为1。

神经网络权重提取方法

基本参数提取

在PyTorch中，有几种方法可以提取神经网络的参数：

1. 使用`parameters()`方法

parameters()方法返回一个包含模型所有参数的迭代器：

# 提取所有参数 for param in model.parameters(): print(param.shape)

输出：

torch.Size([5, 10]) torch.Size([5]) torch.Size([1, 5]) torch.Size([1])

2. 使用`named_parameters()`方法

named_parameters()方法不仅返回参数，还返回它们的名称：

# 提取所有参数及其名称 for name, param in model.named_parameters(): print(f"名称: {name}, 形状: {param.shape}")

输出：

名称: fc1.weight, 形状: torch.Size([5, 10]) 名称: fc1.bias, 形状: torch.Size([5]) 名称: fc2.weight, 形状: torch.Size([1, 5]) 名称: fc2.bias, 形状: torch.Size([1])

3. 直接访问层的参数

我们也可以直接访问特定层的参数：

# 访问特定层的参数 fc1_weights = model.fc1.weight fc1_bias = model.fc1.bias print("fc1权重形状:", fc1_weights.shape) print("fc1偏置形状:", fc1_bias.shape)

输出：

fc1权重形状: torch.Size([5, 10]) fc1偏置形状: torch.Size([5])

提取特定层的参数

有时我们只对特定层的参数感兴趣，可以通过以下方式提取：

# 提取特定层的参数 def get_layer_parameters(model, layer_name): """获取指定层的参数""" for name, param in model.named_parameters(): if layer_name in name: print(f"找到匹配的参数: {name}, 形状: {param.shape}") return param return None # 获取fc1层的权重 fc1_weights = get_layer_parameters(model, "fc1.weight")

输出：

找到匹配的参数: fc1.weight, 形状: torch.Size([5, 10])

提取参数为NumPy数组

有时我们需要将PyTorch参数转换为NumPy数组以便进一步分析：

import numpy as np # 将PyTorch参数转换为NumPy数组 fc1_weights_np = model.fc1.weight.detach().numpy() fc1_bias_np = model.fc1.bias.detach().numpy() print("fc1权重NumPy数组形状:", fc1_weights_np.shape) print("fc1偏置NumPy数组形状:", fc1_bias_np.shape)

输出：

fc1权重NumPy数组形状: (5, 10) fc1偏置NumPy数组形状: (5,)

保存和加载参数

PyTorch提供了保存和加载模型参数的功能：

# 保存模型参数 torch.save(model.state_dict(), 'model_weights.pth') # 加载模型参数 loaded_state_dict = torch.load('model_weights.pth') model.load_state_dict(loaded_state_dict)

权重分析与可视化

权重统计分析

对权重进行统计分析可以帮助我们了解模型的特性：

def analyze_weights(weights): """分析权重的统计特性""" weights_np = weights.detach().numpy() print("权重统计信息:") print(f" 最小值: {np.min(weights_np):.6f}") print(f" 最大值: {np.max(weights_np):.6f}") print(f" 平均值: {np.mean(weights_np):.6f}") print(f" 标准差: {np.std(weights_np):.6f}") print(f" 中位数: {np.median(weights_np):.6f}") # 计算权重的分布 print("n权重分布:") print(f" 负权重比例: {np.sum(weights_np < 0) / weights_np.size:.2%}") print(f" 零权重比例: {np.sum(weights_np == 0) / weights_np.size:.2%}") print(f" 正权重比例: {np.sum(weights_np > 0) / weights_np.size:.2%}") # 分析fc1层的权重 analyze_weights(model.fc1.weight)

输出示例：

权重统计信息: 最小值: -0.284864 最大值: 0.295688 平均值: -0.003412 标准差: 0.168932 中位数: -0.005678 权重分布: 负权重比例: 48.00% 零权重比例: 0.00% 正权重比例: 52.00%

权重可视化

可视化权重可以帮助我们直观地理解模型的特性：

import matplotlib.pyplot as plt import seaborn as sns def visualize_weights(weights, title="权重分布"): """可视化权重分布""" weights_np = weights.detach().numpy().flatten() plt.figure(figsize=(12, 5)) # 直方图 plt.subplot(1, 2, 1) plt.hist(weights_np, bins=50, alpha=0.7) plt.title(f"{title} - 直方图") plt.xlabel("权重值") plt.ylabel("频数") # 箱线图 plt.subplot(1, 2, 2) plt.boxplot(weights_np) plt.title(f"{title} - 箱线图") plt.ylabel("权重值") plt.tight_layout() plt.show() # 可视化fc1层的权重 visualize_weights(model.fc1.weight, "FC1层权重")

权重热力图

对于二维权重矩阵（如全连接层的权重），我们可以使用热力图进行可视化：

def plot_weight_heatmap(weights, title="权重热力图"): """绘制权重热力图""" weights_np = weights.detach().numpy() plt.figure(figsize=(10, 8)) sns.heatmap(weights_np, cmap='coolwarm', center=0) plt.title(title) plt.xlabel("输入神经元") plt.ylabel("输出神经元") plt.show() # 绘制fc1层权重的热力图 plot_weight_heatmap(model.fc1.weight, "FC1层权重热力图")

卷积层权重可视化

对于卷积神经网络，我们可以可视化卷积核：

# 定义一个简单的CNN class SimpleCNN(nn.Module): def __init__(self): super(SimpleCNN, self).__init__() self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1) self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1) self.fc = nn.Linear(32 * 8 * 8, 10) # 假设输入图像经过池化后是8x8 def forward(self, x): x = torch.relu(self.conv1(x)) x = torch.max_pool2d(x, 2) x = torch.relu(self.conv2(x)) x = torch.max_pool2d(x, 2) x = x.view(x.size(0), -1) x = self.fc(x) return x # 实例化CNN模型 cnn_model = SimpleCNN() def visualize_conv_weights(conv_layer, n_filters=16, title="卷积核"): """可视化卷积层的卷积核""" weights = conv_layer.weight.data.cpu().numpy() plt.figure(figsize=(12, 8)) for i in range(min(n_filters, weights.shape[0])): plt.subplot(4, 4, i+1) # 对于多通道输入，取所有通道的平均值 if weights.shape[1] > 1: filter_img = np.mean(weights[i], axis=0) else: filter_img = weights[i, 0] plt.imshow(filter_img, cmap='viridis') plt.title(f'Filter {i+1}') plt.axis('off') plt.suptitle(title) plt.tight_layout() plt.show() # 可视化第一个卷积层的卷积核 visualize_conv_weights(cnn_model.conv1, title="第一层卷积核")

权重初始化策略

权重初始化对神经网络的训练至关重要，不好的初始化可能导致梯度消失或爆炸问题。PyTorch提供了多种初始化方法。

默认初始化

PyTorch中的层有默认的初始化方法：

# 查看线性层的默认初始化 linear_layer = nn.Linear(10, 5) print("默认初始化的权重:") print(linear_layer.weight) print("n默认初始化的偏置:") print(linear_layer.bias)

常见初始化方法

1. 均匀分布初始化

def init_uniform(model): """使用均匀分布初始化模型权重""" for name, param in model.named_parameters(): if 'weight' in name: nn.init.uniform_(param, a=-0.1, b=0.1) elif 'bias' in name: nn.init.uniform_(param, a=-0.1, b=0.1) # 应用均匀分布初始化 model = SimpleNet() init_uniform(model) print("均匀分布初始化后的fc1权重:") print(model.fc1.weight)

2. 正态分布初始化

def init_normal(model): """使用正态分布初始化模型权重""" for name, param in model.named_parameters(): if 'weight' in name: nn.init.normal_(param, mean=0, std=0.01) elif 'bias' in name: nn.init.normal_(param, mean=0, std=0.01) # 应用正态分布初始化 model = SimpleNet() init_normal(model) print("正态分布初始化后的fc1权重:") print(model.fc1.weight)

3. Xavier初始化

Xavier初始化（也称为Glorot初始化）适用于sigmoid和tanh激活函数：

def init_xavier(model): """使用Xavier初始化模型权重""" for name, param in model.named_parameters(): if 'weight' in name: nn.init.xavier_uniform_(param) elif 'bias' in name: nn.init.zeros_(param) # 应用Xavier初始化 model = SimpleNet() init_xavier(model) print("Xavier初始化后的fc1权重:") print(model.fc1.weight)

4. Kaiming初始化

Kaiming初始化（也称为He初始化）适用于ReLU及其变体激活函数：

def init_kaiming(model): """使用Kaiming初始化模型权重""" for name, param in model.named_parameters(): if 'weight' in name: nn.init.kaiming_uniform_(param, mode='fan_in', nonlinearity='relu') elif 'bias' in name: nn.init.zeros_(param) # 应用Kaiming初始化 model = SimpleNet() init_kaiming(model) print("Kaiming初始化后的fc1权重:") print(model.fc1.weight)

不同初始化方法的比较

让我们比较不同初始化方法对权重分布的影响：

def compare_initializations(): """比较不同初始化方法的权重分布""" # 创建多个模型实例 model_uniform = SimpleNet() model_normal = SimpleNet() model_xavier = SimpleNet() model_kaiming = SimpleNet() # 应用不同的初始化方法 init_uniform(model_uniform) init_normal(model_normal) init_xavier(model_xavier) init_kaiming(model_kaiming) # 获取各模型的fc1层权重 weights_uniform = model_uniform.fc1.weight weights_normal = model_normal.fc1.weight weights_xavier = model_xavier.fc1.weight weights_kaiming = model_kaiming.fc1.weight # 可视化比较 plt.figure(figsize=(15, 10)) # 均匀分布 plt.subplot(2, 2, 1) plt.hist(weights_uniform.detach().numpy().flatten(), bins=50, alpha=0.7) plt.title("均匀分布初始化") # 正态分布 plt.subplot(2, 2, 2) plt.hist(weights_normal.detach().numpy().flatten(), bins=50, alpha=0.7) plt.title("正态分布初始化") # Xavier初始化 plt.subplot(2, 2, 3) plt.hist(weights_xavier.detach().numpy().flatten(), bins=50, alpha=0.7) plt.title("Xavier初始化") # Kaiming初始化 plt.subplot(2, 2, 4) plt.hist(weights_kaiming.detach().numpy().flatten(), bins=50, alpha=0.7) plt.title("Kaiming初始化") plt.tight_layout() plt.show() # 比较不同初始化方法 compare_initializations()

权重微调与迁移学习

在迁移学习中，我们通常使用预训练模型的权重，并根据新任务进行微调。PyTorch提供了方便的工具来实现这一点。

加载预训练模型

PyTorch提供了许多预训练模型，我们可以直接加载它们：

import torchvision.models as models # 加载预训练的ResNet18模型 resnet18 = models.resnet18(pretrained=True) # 查看模型结构 print(resnet18)

冻结部分层

在迁移学习中，我们通常冻结预训练模型的前几层，只微调后面的层：

# 冻结所有层 for param in resnet18.parameters(): param.requires_grad = False # 解冻最后两层 for param in resnet18.layer4.parameters(): param.requires_grad = True for param in resnet18.fc.parameters(): param.requires_grad = True # 检查哪些层需要梯度 for name, param in resnet18.named_parameters(): print(f"{name}: requires_grad={param.requires_grad}")

修改最后一层

通常，我们需要根据新任务修改模型的最后一层：

# 获取最后一层的输入特征数 num_ftrs = resnet18.fc.in_features print("原始最后一层的输入特征数:", num_ftrs) # 修改最后一层以适应新的分类任务（假设有10个类别） resnet18.fc = nn.Linear(num_ftrs, 10) print("修改后的模型最后一层:", resnet18.fc)

部分层权重初始化

有时我们想对某些层使用预训练权重，而对其他层进行随机初始化：

def partial_init(model, pretrained_dict): """部分初始化模型权重""" model_dict = model.state_dict() # 1. 过滤出不需要更新的权重 pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict} # 2. 更新模型字典 model_dict.update(pretrained_dict) # 3. 加载更新的权重 model.load_state_dict(model_dict) return model # 创建一个没有预训练权重的ResNet18 new_resnet18 = models.resnet18(pretrained=False) # 获取预训练模型的权重 pretrained_dict = resnet18.state_dict() # 部分初始化新模型（只初始化除了最后一层之外的所有层） new_resnet18 = partial_init(new_resnet18, pretrained_dict) # 检查初始化结果 print("新模型最后一层的权重（应该是随机初始化的）:") print(new_resnet18.fc.weight[0, :5]) print("n预训练模型最后一层的权重:") print(resnet18.fc.weight[0, :5])

权重正则化与优化

权重正则化是防止模型过拟合的重要技术，PyTorch提供了多种正则化方法。

L1和L2正则化

在PyTorch中，L2正则化通常通过优化器的weight_decay参数实现：

import torch.optim as optim # 创建模型 model = SimpleNet() # 使用L2正则化（weight_decay） optimizer = optim.SGD(model.parameters(), lr=0.01, weight_decay=1e-4) # weight_decay就是L2正则化系数 # 训练循环示例 def train_with_l2(model, optimizer, data_loader, epochs=5): model.train() for epoch in range(epochs): total_loss = 0 for inputs, targets in data_loader: optimizer.zero_grad() outputs = model(inputs) loss = nn.MSELoss()(outputs, targets) # L2正则化已经包含在optimizer中，不需要额外添加 loss.backward() optimizer.step() total_loss += loss.item() print(f"Epoch {epoch+1}, Loss: {total_loss/len(data_loader):.4f}")

对于L1正则化，我们需要手动添加到损失函数中：

def train_with_l1(model, optimizer, data_loader, l1_lambda=0.01, epochs=5): model.train() for epoch in range(epochs): total_loss = 0 for inputs, targets in data_loader: optimizer.zero_grad() outputs = model(inputs) mse_loss = nn.MSELoss()(outputs, targets) # 添加L1正则化 l1_norm = sum(p.abs().sum() for p in model.parameters()) loss = mse_loss + l1_lambda * l1_norm loss.backward() optimizer.step() total_loss += loss.item() print(f"Epoch {epoch+1}, Loss: {total_loss/len(data_loader):.4f}")

权重约束

有时我们想对权重施加某些约束，例如权重归一化：

def apply_weight_constraints(model): """应用权重约束""" for param in model.parameters(): if 'weight' in param.__class__.__name__.lower(): # 权重归一化：将权重的范数限制为1 norm = param.norm(p=2, dim=1, keepdim=True) param.data = param.data / norm # 创建模型并应用权重约束 model = SimpleNet() print("应用权重约束前的fc1权重范数:") print(model.fc1.weight.norm(p=2, dim=1)) apply_weight_constraints(model) print("n应用权重约束后的fc1权重范数:") print(model.fc1.weight.norm(p=2, dim=1))

权重裁剪

权重裁剪可以防止梯度爆炸：

def train_with_gradient_clipping(model, optimizer, data_loader, clip_value=1.0, epochs=5): """使用梯度裁剪进行训练""" model.train() for epoch in range(epochs): total_loss = 0 for inputs, targets in data_loader: optimizer.zero_grad() outputs = model(inputs) loss = nn.MSELoss()(outputs, targets) loss.backward() # 应用梯度裁剪 torch.nn.utils.clip_grad_norm_(model.parameters(), clip_value) optimizer.step() total_loss += loss.item() print(f"Epoch {epoch+1}, Loss: {total_loss/len(data_loader):.4f}")

实战案例：权重提取与分析的应用

案例1：分析训练过程中的权重变化

让我们创建一个简单的示例，分析模型在训练过程中权重是如何变化的：

import torch.utils.data as data # 创建一些随机数据 X = torch.randn(100, 10) y = torch.randn(100, 1) # 创建数据加载器 dataset = data.TensorDataset(X, y) dataloader = data.DataLoader(dataset, batch_size=10, shuffle=True) # 创建模型 model = SimpleNet() optimizer = optim.SGD(model.parameters(), lr=0.01) # 存储训练过程中的权重 weight_history = [] # 训练模型并记录权重变化 def train_and_record_weights(model, optimizer, dataloader, epochs=10): model.train() for epoch in range(epochs): total_loss = 0 for inputs, targets in dataloader: optimizer.zero_grad() outputs = model(inputs) loss = nn.MSELoss()(outputs, targets) loss.backward() optimizer.step() total_loss += loss.item() # 记录当前权重 epoch_weights = {} for name, param in model.named_parameters(): epoch_weights[name] = param.clone().detach() weight_history.append(epoch_weights) print(f"Epoch {epoch+1}, Loss: {total_loss/len(dataloader):.4f}") # 训练模型并记录权重 train_and_record_weights(model, optimizer, dataloader) # 分析权重变化 def analyze_weight_changes(weight_history, param_name): """分析特定参数在训练过程中的变化""" initial_weight = weight_history[0][param_name] final_weight = weight_history[-1][param_name] # 计算权重变化 weight_change = (final_weight - initial_weight).norm().item() initial_norm = initial_weight.norm().item() final_norm = final_weight.norm().item() print(f"参数 {param_name} 的变化分析:") print(f" 初始权重范数: {initial_norm:.6f}") print(f" 最终权重范数: {final_norm:.6f}") print(f" 权重变化范数: {weight_change:.6f}") print(f" 相对变化: {weight_change/initial_norm:.2%}") # 可视化权重范数的变化 norms = [weight_history[i][param_name].norm().item() for i in range(len(weight_history))] plt.figure(figsize=(10, 5)) plt.plot(norms) plt.title(f"{param_name} 权重范数在训练过程中的变化") plt.xlabel("Epoch") plt.ylabel("权重范数") plt.grid(True) plt.show() # 分析fc1层权重的变化 analyze_weight_changes(weight_history, "fc1.weight")

案例2：模型相似性比较

我们可以通过比较模型权重来评估不同模型之间的相似性：

def compare_models(model1, model2): """比较两个模型的权重相似性""" # 确保两个模型结构相同 params1 = dict(model1.named_parameters()) params2 = dict(model2.named_parameters()) if set(params1.keys()) != set(params2.keys()): print("模型结构不同，无法比较") return similarities = {} for name in params1.keys(): param1 = params1[name] param2 = params2[name] # 计算余弦相似性 cos_sim = torch.nn.functional.cosine_similarity( param1.flatten(), param2.flatten(), dim=0 ).item() # 计算欧氏距离 euclidean_dist = torch.norm(param1 - param2).item() # 计算参数范数比 norm_ratio = (param2.norm() / param1.norm()).item() similarities[name] = { 'cosine_similarity': cos_sim, 'euclidean_distance': euclidean_dist, 'norm_ratio': norm_ratio } return similarities # 创建两个模型并使用不同的初始化方法 model1 = SimpleNet() init_xavier(model1) model2 = SimpleNet() init_kaiming(model2) # 比较两个模型 similarities = compare_models(model1, model2) # 打印比较结果 for param_name, metrics in similarities.items(): print(f"n参数 {param_name}:") print(f" 余弦相似性: {metrics['cosine_similarity']:.6f}") print(f" 欧氏距离: {metrics['euclidean_distance']:.6f}") print(f" 范数比: {metrics['norm_ratio']:.6f}")

案例3：权重剪枝

权重剪枝是一种模型压缩技术，通过移除不重要的权重来减小模型大小：

def prune_weights(model, pruning_percent=0.2): """对模型权重进行剪枝""" for name, param in model.named_parameters(): if 'weight' in name: # 获取权重的绝对值 weight_abs = param.data.abs() # 确定剪枝阈值 threshold = torch.quantile(weight_abs.flatten(), pruning_percent) # 应用剪枝：将小于阈值的权重设为0 mask = weight_abs > threshold param.data = param.data * mask.float() # 计算剪枝率 total_weights = param.data.numel() pruned_weights = (param.data == 0).sum().item() actual_pruning_rate = pruned_weights / total_weights print(f"参数 {name}:") print(f" 目标剪枝率: {pruning_percent:.2%}") print(f" 实际剪枝率: {actual_pruning_rate:.2%}") print(f" 剩余非零权重: {total_weights - pruned_weights}") # 创建并训练一个模型 model = SimpleNet() optimizer = optim.SGD(model.parameters(), lr=0.01) train_and_record_weights(model, optimizer, dataloader, epochs=5) # 应用权重剪枝 prune_weights(model, pruning_percent=0.3) # 评估剪枝后的模型性能 def evaluate_model(model, dataloader): """评估模型性能""" model.eval() total_loss = 0 with torch.no_grad(): for inputs, targets in dataloader: outputs = model(inputs) loss = nn.MSELoss()(outputs, targets) total_loss += loss.item() return total_loss / len(dataloader) # 评估剪枝前后的模型性能 original_loss = evaluate_model(model, dataloader) print(f"n剪枝后的模型损失: {original_loss:.6f}")

案例4：权重可视化解释模型

通过可视化权重，我们可以尝试理解模型是如何做出决策的：

# 创建一个更复杂的模型用于图像分类 class ImageClassifier(nn.Module): def __init__(self): super(ImageClassifier, self).__init__() self.conv1 = nn.Conv2d(3, 16, kernel_size=5, stride=1, padding=2) self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2) self.conv2 = nn.Conv2d(16, 32, kernel_size=5, stride=1, padding=2) self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2) self.fc1 = nn.Linear(32 * 8 * 8, 128) self.fc2 = nn.Linear(128, 10) def forward(self, x): x = torch.relu(self.conv1(x)) x = self.pool1(x) x = torch.relu(self.conv2(x)) x = self.pool2(x) x = x.view(x.size(0), -1) x = torch.relu(self.fc1(x)) x = self.fc2(x) return x # 实例化模型 image_model = ImageClassifier() # 可视化第一个卷积层的权重 visualize_conv_weights(image_model.conv1, n_filters=16, title="第一层卷积核") # 分析全连接层的权重 def analyze_fc_weights(fc_layer, title="全连接层权重分析"): """分析全连接层的权重""" weights = fc_layer.weight.data # 计算每个输出神经元的权重范数 neuron_norms = weights.norm(p=2, dim=1) plt.figure(figsize=(12, 5)) # 神经元权重范数分布 plt.subplot(1, 2, 1) plt.hist(neuron_norms.detach().numpy(), bins=20, alpha=0.7) plt.title(f"{title} - 神经元权重范数分布") plt.xlabel("权重范数") plt.ylabel("神经元数量") # 权重热力图（只显示部分神经元以避免图像过大） plt.subplot(1, 2, 2) num_neurons_to_show = min(20, weights.size(0)) sns.heatmap(weights[:num_neurons_to_show].detach().numpy(), cmap='coolwarm', center=0) plt.title(f"{title} - 权重热力图（前{num_neurons_to_show}个神经元）") plt.xlabel("输入神经元") plt.ylabel("输出神经元") plt.tight_layout() plt.show() # 分析第一个全连接层的权重 analyze_fc_weights(image_model.fc1, "FC1层权重分析")