深入理解CNN参数共享：从卷积核到图像分类的核心原理

1. 从一张图到一组数字：卷积操作到底在做一件什么事

很多人学CNN，第一反应是去背卷积的公式、记卷积核尺寸、算输出feature map大小。但我个人觉得，如果只停留在“算数学题”的层面，那你很快就会忘记CNN为什么存在，也根本理解不了参数共享四个字的分量。

先回到最根本的问题：一张图片是怎么被计算机看到的？

假设一张RGB图像是224×224，那它在内存里就是一个224×224×3的数组。全连接神经网络处理这个输入时，会把整张图拉直成一维向量，长度是224×224×3=150528。第一层如果设置1024个神经元，那么这一层光权重就是150528×1024，约1.54亿个参数。你还没开始训练，模型已经把显存吃掉了大半，更别提收敛速度和过拟合风险。

CNN的思路完全不一样。卷积操作不把图像拉直，而是保留它的二维空间结构，用一个很小的窗口在图像上滑动，每次只对局部区域做加权求和。这个滑动窗口就是卷积核，也叫滤波器。它的尺寸一般只有3×3、5×5，深度和输入通道数保持一致。

卷积的意义往大了说有三个：局部感知、权值共享、平移等变性。局部感知是指每次只看一个小邻域，符合图像中相邻像素相关性强的直觉；权值共享是同一个卷积核在整个图上滑动时参数不变，这直接让参数量锐减；平移等变性是说，如果一个物体在图像里移动了位置，卷积仍然能捕获到它，因为滤波器是滑动的，不是固定在一个位置。

用一个生活化的类比来理解：卷积核就像一张“特征模板”，比如检测垂直边缘的模板。无论这条垂直边缘出现在图的左上角还是右下角，你用的模板是同一张，这就是共享。如果你为每个位置都单独设计一个模板，那参数就会爆炸，而且完全没有必要——因为边缘就是边缘，它不会因为出现在不同位置就变成另一种特征。

所以卷积操作的本质，是对图像做“局部特征提取”，而参数共享是让这种提取在空间上普适。整个CNN的底层逻辑，就是通过一层层的局部提取，从边缘、纹理、部件到语义，逐步抽象出图像的内容。

2. 为什么图像处理不直接用全连接神经网络：参数爆炸只是第一层原因

热搜里有一条“图像处理为啥用CNN不用前馈神经网络”，我猜问出这个问题的同学大概率已经被全连接网络的参数规模吓到了。参数爆炸确实是最直观的劣势，但它不是唯一原因，甚至不是最核心的原因。

除开参数，全连接神经网络处理图像还有几个致命问题。

第一是空间结构丢失。你把图像拉直成向量，像素之间的位置关系全部被抹掉了。对于全连接网络来说，输入向量的第100个位置和第1000个位置之间的“距离”没有任何意义，它只看数值。但图像里，相邻像素是高度相关的，远处像素相关性弱，这种先验知识全连接网络完全无法利用，只能靠数据硬学。

第二是难以捕捉局部不变性。一张猫的照片，猫往左偏移几个像素，全连接网络的输入向量就完全变了，网络需要重新学习这个模式。要实现平移不变性，全连接网络得靠数据增强硬撑——把每张图做各种随机裁剪、平移，让网络见过足够多“不同位置上的猫”。但卷积网络天生具备这个能力，因为同一个卷积核在滑动，猫在哪个位置并不影响特征提取。

第三是训练难度极高。150528维的输入、上亿的第一层参数，梯度在反向传播时很容易出问题，而且对小数据集来说基本就是过拟合预警。你可以想象一下，如果让一个模型同时记住图像每一个位置和每一个特征的组合关系，它需要多少数据才能学得动。

所以说，CNN不是“在全连接网络上加了个卷积层”，而是换了一套更适合图像数据的归纳偏置。卷积的局部连接和权值共享，本质上是在告诉模型：图像的特征是局部、可复用、平移不变的。这种先验让模型在样本量有限时也能很好地泛化，这是CNN在图像领域统治级地位的根本原因。

顺便说一句，全连接网络并不是完全没有用了。在CNN的最后分类部分，通常还是会用一两个全连接层（或者全局平均池化替代），把卷积提取到的高层特征映射到具体的类别得分上。卷积负责特征提取，全连接负责决策输出，一个管看，一个管判。

3. 参数共享到底共享了什么：同一卷积核在不同位置的复用机制

“参数共享”这四个字，对新手来说理解起来其实有个坎：到底哪些参数是共享的？共享到什么程度？共享是怎么让计算量降下来的？

我分三个层面来拆。

第一个层面，空间位置的共享。一个3×3×3的卷积核在224×224的图像上滑动，会输出一个222×222的feature map。这个feature map上的每一个值，都是同一个卷积核和不同局部区域做点积得到的。也就是说，这个卷积核的27个参数（3×3×3）被整个feature map上的49284个位置共享。如果没有共享，每个输出位置一套独立的27个参数，参数量就会变成27×49284，约133万个，而共享之后只有27个。

第二个层面，同一层内不同卷积核的独立性。实际卷积层当然不会只有一个卷积核，而是有多个，比如64个、128个。每个卷积核负责提取一种特征模式，它们各自的参数是独立学习的。这一层如果有64个3×3×3的卷积核，参数量就是64×27=1728。这1728个参数，支撑起了当前层对输入的64种不同特征响应。

第三个层面，跨层不共享。注意，参数共享只发生在同一卷积核内部，不同卷积层之间是不共享的。第一层学到的是边缘、纹理，第二层在边缘的基础上组合出角点、弧线，后面逐层抽象出更加复杂的语义特征。如果跨层强行共享参数，那每一层提取的特征就都一样了，堆叠层数就失去了意义。

从数学上看，卷积输出的计算可以写成：

[ y[i,j] = \sum_{m=0}^{K_h-1} \sum_{n=0}^{K_w-1} \sum_{c=1}^{C_{in}} w[m,n,c] \cdot x[i+m - \frac{K_h-1}{2}, j+n - \frac{K_w-1}{2}, c] + b ]

这里w和b是共享的卷积核参数，x是输入，y是输出feature map。整个滑动的过程，等价于在全连接视角下给权重矩阵施加了一个“Toeplitz结构”的约束——大部分位置的权重被强制置为0（局部连接），剩余的位置共享同一个权重集合（参数共享）。

用一个具体数字感受一下收益。拿ResNet-50来说，它的第一个conv层是7×7卷积，输入通道3，输出通道64，参数量是7×7×3×64=9408。如果这个卷积层换成同等容量的全连接层，假设输入是224×224×3，输出是224×224×64，那参数量就是224×224×3×224×224×64，大约是1.5×10^12——一万五千亿级别的参数。这个数字已经不是“能不能训练”的问题，而是“存不存在”的问题。从这个对比就能直观感受到参数共享的恐怖之处。

4. 卷积层的核心参数逐个拆解：尺寸、步长、填充、通道数

理解了卷积的思想和参数共享的原理，接下来就要落到工程实现上。这一节我把卷积层的核心参数逐个展开，不整虚的，直接说清它们的作用、相互作用和调参经验。

4.1 卷积核尺寸：为什么大家偏爱3×3

卷积核尺寸决定单次感受野的大小。7×7能看到更大的范围，3×3只能看到局部，但3×3叠两层就能获得5×5的感受野，叠三层就是7×7。为什么要用小卷积核堆叠，而不是直接用一个大卷积核？

核心原因是参数效率和非线性表达。一个7×7卷积的参数是7×7×C_in×C_out=49C_inC_out，而三个3×3卷积的参数是3×3×C_in×C_out×3=27C_inC_out，参数少了接近45%，但感受野一样，而且中间多了两层非线性激活，表达能力反而更强。这就是VGG之后主流网络普遍用3×3的原因。

1×1卷积也很值得说。它不捕捉空间信息，只做跨通道的信息融合，常用来调整通道数，实现“瓶颈结构”中的降维。在MobileNet、EfficientNet这类轻量级网络里，1×1卷积几乎是标配。

4.2 步长：不只是“走几步”那么简单

步长（stride）是卷积核每次滑动的像素数。步长为1时，输出尺寸几乎等于输入尺寸（加上padding后）；步长为2时，输出尺寸直接减半，等价于把下采样融入了卷积操作，替代池化层。

步长的选择直接影响feature map的分辨率和感受野的扩张速度。步长为2的卷积在降低分辨率的同时会丢失一部分空间细节，所以一般只在网络的前几层或者需要快速降维的位置使用。在分割、检测这类对位置敏感的任务里，步长需要谨慎设计，可以用空洞卷积（dilated convolution）替代普通卷积，在不降低分辨率的情况下扩大感受野。

4.3 填充：决定输出尺寸和边缘信息的去留

填充（padding）说白了就是给输入图像四周补上像素。最常用的有两种：valid（不填充）和same（填充后输出尺寸和输入一致）。

valid卷积会让feature map越变越小，边缘像素只被卷积核覆盖一次，而中心像素会被覆盖多次，因此边缘信息天然被“边缘化”，权重更新对边缘像素的影响较小。same卷积通过补零解决这个问题，让每个位置被卷积核覆盖的次数均衡一些。

常见的same填充数值是padding=(kernel_size-1)//2，比如3×3卷积填充1，5×5卷积填充2。这样输出尺寸H=(W-K+2P)/S+1在S=1时等于W，实现尺寸不变。实际工程中，大多数场景用same就对了，除非你有意要缩小feature map。

4.4 输出通道：每个通道在“看”什么

输出通道其实就是卷积核的个数。每个卷积核独立地在输入上滑动，产出一个二维feature map，多个卷积核的输出堆叠在一起，形成深度为输出通道数的三维张量。

每个输出通道可以理解为模型学习到的一种特征响应。第一个卷积层的不同通道往往对应不同的边缘方向、不同的颜色组合；深层的通道则对应更复杂的语义模式，比如眼睛、轮子、文字区域等。通道数越多，模型的表达能力越强，但参数量和计算量也线性增长，而且过大的通道数在小数据集上会加速过拟合。

经验上，通道数一般按2的幂次设置，比如32、64、128、256，这样做是为了内存对齐和硬件加速。提升通道数时，通常配合池化或步长为2的卷积降低分辨率，控制计算量增长。

4.5 感受野：理解CNN层与层之间关系的钥匙

感受野（receptive field）是CNN里一个特别重要但容易被忽略的概念。它指的是输出feature map上一个点对应到输入图像上的区域大小。

举个例子，一个3×3卷积核输出feature map上的某个点，是由输入图像上3×3的区域计算而来的，所以它的感受野是3×3。再经过一个3×3卷积，这个点对应的输入区域就变成了5×5。公式是：RF_new = RF_old + (kernel_size - 1) × stride_prod，其中stride_prod是之前所有层的步长乘积。

感受野决定了每个输出位置能看到多大范围的原始图像信息，直接影响模型对大尺度模式的捕捉能力。在做语义分割、目标检测时，感受野不足意味着网络只能看到局部，无法理解全局上下文，这是很多模型效果不好的隐藏原因。

5. 手写一个最小可用的卷积层：别只会调框架，也得知道内部发生了什么

开始写代码之前，先说点实在的。绝大多数人平时用PyTorch、TensorFlow，一行nn.Conv2d就完事了，这没有错，但如果能把卷积的前向计算自己实现一遍，你对参数共享的理解会直接上一个台阶。尤其是面试时被问“卷积和全连接的区别”，你能从代码层面讲清楚，说服力是完全不一样的。

下面我用PyTorch实现一个纯Python版的二维卷积，不使用任何现成的卷积算子。

import numpy as np def conv2d_forward(inputs, weights, bias, stride=1, padding=0): """ 手写二维卷积前向传播 inputs: (C_in, H_in, W_in) weights: (C_out, C_in, K_h, K_w) bias: (C_out,) """ C_in, H_in, W_in = inputs.shape C_out, _, K_h, K_w = weights.shape # 先对输入做padding if padding > 0: inputs_pad = np.pad(inputs, ((0, 0), (padding, padding), (padding, padding)), mode='constant') else: inputs_pad = inputs # 计算输出尺寸 H_out = (H_in + 2 * padding - K_h) // stride + 1 W_out = (W_in + 2 * padding - K_w) // stride + 1 # 初始化输出 output = np.zeros((C_out, H_out, W_out)) # 核心循环：每个输出通道、每个输出位置，累加所有输入通道上的卷积结果 for oc in range(C_out): for i in range(H_out): for j in range(W_out): # 当前窗口在输入上的位置 h_start = i * stride w_start = j * stride # 取局部窗口并做加权求和 window = inputs_pad[:, h_start:h_start+K_h, w_start:w_start+K_w] # (C_in, K_h, K_w) prod = window * weights[oc] # (C_in, K_h, K_w) 广播乘法 output[oc, i, j] = prod.sum() + bias[oc] return output

这段代码对应了最原始的卷积定义——weights遍历C_in和K_h、K_w范围内的所有值，但滑块移动到任何位置，用的都是同一份weights[oc]。这就是参数共享在代码层面的体现。

写这个代码有几个点值得细想。首先是padding：np.pad里第一个维度是通道维，不参与空间填充，这一点容易写错。其次是循环顺序：外层是输出通道，里层是输出位置，这个顺序保证了weights[oc]在整个内层循环过程中不被修改——它就是共享的。最后是窗口切片：inputs_pad[:, h_start:h_start+K_h, w_start:w_start+K_w]这一步把当前窗口的所有通道都取出来，再和weights[oc]做广播乘法，这一步实际上就完成了所有输入通道的加权求和，不需要额外循环。

性能上，这段代码在大输入上会很慢，因为纯Python循环效率低。但作为教学实现，它的逻辑清晰度是最重要的。实际工程当然不会这么写，但你能看懂这段代码，就能完全理解卷积在做什么。

为了验证手写实现的正确性，可以和PyTorch的nn.Conv2d对比一下：

import torch import torch.nn as nn # 固定随机种子，保证两边初始化一致 torch.manual_seed(42) np.random.seed(42) # 构造输入 inputs_np = np.random.randn(3, 8, 8).astype(np.float32) inputs_torch = torch.from_numpy(inputs_np).unsqueeze(0) # (1, 3, 8, 8) # 定义PyTorch卷积层 conv = nn.Conv2d(in_channels=3, out_channels=4, kernel_size=3, stride=1, padding=1) weights_np = conv.weight.detach().numpy() # (4, 3, 3, 3) bias_np = conv.bias.detach().numpy() # (4,) # 手写卷积 out_manual = conv2d_forward(inputs_np, weights_np, bias_np, stride=1, padding=1) # PyTorch卷积 out_torch = conv(inputs_torch).squeeze(0).detach().numpy() # 对比差异 diff = np.abs(out_manual - out_torch).max() print(f"最大差异: {diff:.6e}")

运行结果应该是类似最大差异: 1.2e-06这样的数量级，说明手写实现和框架实现在这个配置下完全一致。这个差异主要来自浮点累加顺序不同，可以忽略。

如果你把padding改成0、stride改成2再跑一遍，也能得到相同的结果。这个小实验值得自己动手做一次，做完你对卷积计算过程、参数维度、输出尺寸公式的理解，比看十遍文档都有用。

6. 从卷积到CNN网络的前向传播：池化、激活和全连接的配合

单看一个卷积层只是零件，把零件组装成能跑的分类网络才叫整机。一个典型的CNN分类网络前向传播大概是这样的：卷积 → 激活 → 池化 → 卷积 → 激活 → 池化 → ... → 全连接 → Softmax。

6.1 激活函数：没有它，深度就没有意义

卷积本身是线性操作，多个卷积层叠加如果中间没有非线性激活，等价于一个大线性变换，那深度就毫无意义。激活函数的作用是在层与层之间引入非线性，让网络能够拟合复杂的函数映射。

ReLU是CNN里最常用的激活函数：

[ \text{ReLU}(x) = \max(0, x) ]

它的优点是计算极快、能缓解梯度消失、让部分神经元稀疏激活。但ReLU有个缺点：负区间梯度为0，如果某个神经元的输出在训练过程中一直落在负区间，它的梯度就是0，权重永远不会更新，这个神经元就“坏死”了。解决方式是用LeakyReLU：负区间保留一个很小的斜率，比如0.01，避免神经元完全死亡。

实际工程中我一般会先试ReLU，如果训练过程中发现大量神经元死亡或者特征图稀疏度过高，再换LeakyReLU或者ELU。没有绝对最优的激活函数，只有最适合当前模型的。

6.2 池化：保留关键信息，压缩计算量

卷积之后跟着池化是CNN的经典套路。池化最常见的是最大池化（max pooling）和平均池化（average pooling），窗口一般是2×2、步长为2，把feature map的宽高各减半。

最大池化取局部窗口的最大值，保留了局部最强烈的响应。它的平移不变性更强——物体稍微移动几个像素，最大值的位置可能变了变，但最大值本身变化不大。平均池化取均值，更平滑，适合需要保留整体特征的场景。

全局平均池化（global average pooling）值得单独说。它把整个feature map压缩成一个值，每个通道对应一个数。替换全连接层作为分类头，参数量几乎为零，而且天然的每个通道对应一种语义特征，可解释性更好。经典网络GoogLeNet就用这个思路。

要注意的是，近几年的SOTA网络倾向于用步长为2的卷积替代池化层做下采样。两者效果接近，但卷积能学习下采样的方式，理论上上限更高。不过池化也有它的价值，它没有可学习参数、天然具备一定的不变性、不易过拟合，在数据量有限的场景下仍然值得用。

6.3 一个完整的迷你CNN搭建实例

纸上谈兵这么多，还是得动手搭一个能训练的网络。我用PyTorch在CIFAR-10上搭一个极简CNN，展示卷积、池化、全连接如何配合。

import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms # 数据加载: CIFAR-10, 3x32x32的彩色图像, 10类 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True, num_workers=2) testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False, num_workers=2) # 定义迷你CNN class MiniCNN(nn.Module): def __init__(self): super().__init__() self.features = nn.Sequential( nn.Conv2d(3, 32, kernel_size=3, padding=1), # 32x32x32 nn.ReLU(), nn.MaxPool2d(2), # 32x16x16 nn.Conv2d(32, 64, kernel_size=3, padding=1), # 64x16x16 nn.ReLU(), nn.MaxPool2d(2), # 64x8x8 nn.Conv2d(64, 128, kernel_size=3, padding=1), # 128x8x8 nn.ReLU(), nn.MaxPool2d(2), # 128x4x4 ) self.classifier = nn.Sequential( nn.Flatten(), nn.Linear(128 * 4 * 4, 256), nn.ReLU(), nn.Linear(256, 10), ) def forward(self, x): x = self.features(x) x = self.classifier(x) return x model = MiniCNN() criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=1e-3) # 统计模型参数量 total_params = sum(p.numel() for p in model.parameters()) trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad) print(f"总参数量: {total_params:,}") print(f"可训练参数量: {trainable_params:,}") # 训练一个epoch看看 model.train() for epoch in range(1): running_loss = 0.0 for i, (inputs, labels) in enumerate(trainloader): optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() if i % 100 == 99: print(f"Batch {i+1}: loss={running_loss/100:.4f}") running_loss = 0.0

这个模型的参数总量大约只有12万左右。作为对比，同样输入尺寸（3×32×32）的一个单隐藏层全连接网络，隐藏层设512个神经元，参数量是3×32×32×512+512，约157万。于是就可以直观地看到：CNN用七分之一的参数量，拿到了更好的图像分类效果——因为它把大部分参数从“记住每个像素位置”转移到“学习通用特征模板”上，这个转移就是参数共享的功劳。

而且这个迷你网络在CIFAR-10上随便训一两个epoch，准确率就能到50%左右，充分训练后到75%以上没问题。同样的参数量给全连接网络，能到35%就是烧高香了。这就是结构先验带来的巨大优势。

7. 卷积网络训练中的常见坑和排查经验

训练CNN时间一长，谁都会遇到几个重复出现的问题。我把自己踩过的坑和排查思路整理出来，做成一个速查表，方便你照着定位。

除了这些比较常规的问题，我再分享三个不那么常见但实际遇到的细节。

第一个是图像尺寸与卷积核的匹配。训练图像是32×32时，第二层如果用5×5卷积加step 2，输出会直接变成14×14，配合池化后到7×7，再卷积一次就3×3了，feature map越来越小，深度却越来越厚，最后全连接层的输入维度可能变得很尴尬。设计网络时最好从输入尺寸倒推每一层feature map的尺寸，用笔算清楚再动手写代码。

第二个是Kaiming初始化的重要性。卷积层权重如果用默认的高斯小随机数初始化，在深层网络里前向传播的方差会逐层衰减，反向传播的梯度也会出问题。PyTorch的nn.Conv2d默认就用Kaiming均匀初始化，这是经过验证的合理默认值，但如果自定义模块而不注意初始化，很容易出现“网络推不动”的隐性故障。它不像loss爆炸那么显眼，但危害更大。

第三个是关于batch size对BatchNorm的影响。BatchNorm在训练时统计当前batch的均值方差，batch size太小（比如2、4），统计量噪声大，导致训练不稳定。图像分割这类显存消耗大的任务，经常被迫用小batch size，这时候可以考虑用GroupNorm或LayerNorm做替代方案，效果往往比BatchNorm稳定得多。

另外一个经常被问到的坑是：torchvision的预训练模型输入需要标准化。你在ImageNet上预训练好的ResNet，输入要经过mean=(0.485, 0.456, 0.406)、std=(0.229, 0.224, 0.225)的标准化，如果直接喂0~1数据，效果会明显变差。很多新手迁移学习上来就撞这个问题，特征提取没问题，但分类头训练完全不对。

8. 可视化卷积核和特征图：用眼睛验证模型学到了什么

写代码的人有个习惯：能用print解决的问题绝对不猜。训练CNN也是一样，与其对着loss曲线猜模型学会了什么，不如直接可视化卷积核和特征图，眼见为实。

第一层卷积核是最容易可视化的。因为输入是RGB三通道，卷积核尺寸是3×3×3，把权重归一化到0~255后直接按3×3的格子画出来就行。观察这些核的纹理、方向、颜色分布，你能直观看到模型学到了什么。一般来说，训练良好的第一层卷积核会呈现明显的边缘检测模式——不同方向的边缘、不同颜色的带状滤波器，就像一组Gabor滤波器。

特征图可视化是更实用的手段。取一张输入图片，把某个中间层的输出feature map画出来，观察不同通道在响应什么。这里的经验是：浅层通道响应的是边缘、纹理、颜色块；中层通道开始响应对应部件的东西，比如眼睛、轮子、窗户；深层通道响应的是语义区域，比如整张人脸、整个车身。

可视化工具上，我推荐用Jupyter Notebook配合matplotlib，简单直接。直接用plt.imshow(feature_map[0], cmap='gray')就能画出单个通道的特征响应。想把一层的所有通道拼接起来看，可以用torchvision.utils.make_grid，它会把N×C×H×W的tensor拼成一张大图，非常方便。

用可视化来排查问题也比想象中好用。有一次我训练一个分类模型，loss降得还行但准确率上不去，就去看第一层卷积核，结果发现全是噪声纹理，明显是学习率过大或者数据预处理有问题。改成合适的学习率重新训练后，卷积核恢复了清晰的边缘检测模式，准确率也随之上升。可视化不是锦上添花，它是定位CNN训练问题的一把重要工具。

如果你不想手动写可视化代码，也可以去看看第三方工具。有一些交互式可视化工具可以让你在浏览器里一层一层地查看CNN的中间输出，同时支持图片上传和层配置调整，对学习理解非常有帮助。

9. 轻量化与加速：参数共享后的进一步优化思路

参数共享已经把CNN的参数量压缩了几个数量级，但实际部署到手机、嵌入式设备时，显存和算力仍然紧张。轻量化模型和推理加速是工程落地绕不开的话题。

一个方向是深度可分离卷积，这是MobileNet的核心理念。它把标准卷积拆成两步：第一步是逐通道卷积（depthwise convolution），每个输入通道单独用一个3×3卷积核处理，不跨通道；第二步是逐点卷积（pointwise convolution），用1×1卷积在通道维度上做线性组合。这样的计算量约为标准卷积的1/8到1/9，而精度损失很小。

从参数共享的角度理解，深度可分离卷积进一步“共享”了空间卷积的部分。标准卷积是每个输出通道对应一组K×K×C_in的卷积核，而深度可分离卷积让K×K的空间卷积核在通道间共享，让1×1的通道组合卷积在空间各地共享，把一个耦合的卷积过程解耦成两个更轻量的过程。

另一个方向是量化。训练好的模型一般用FP32存储，但推理时可以用INT8。权重量化后模型体积减小到原来的1/4，而且INT8在专用硬件上的计算速度远高于FP32。我实际做过一个分类模型的INT8量化，精度下降不超过1%，但模型体积从100MB降到25MB，推理速度提升了3倍以上。

从理论上看，参数共享本身就在做“用结构先验换取参数效率”这件事，轻量化模型的本质思路仍然是这个方向上的延续——尽可能减少可学习参数，用结构化的方式组织计算。

10. 参数共享思想的其他应用：它不止属于CNN

掌握一个概念的最好方式，是看到它在多个场景下反复出现。参数共享并不是CNN独有的思想，它在深度学习很多地方都有体现。

RNN就是典型的参数共享。任意时间步t，模型都使用同一个权重矩阵处理隐状态和当前输入。你会发现，这和卷积核在空间位置上共享参数是同构的：RNN在时间维度共享，CNN在空间维度共享。两者都面临怎么让模型“在不同位置上做相同操作”的问题。

Transformer里的多头注意力也涉及参数共享的一些思路。Embedding层的权重在不同位置共享；因果注意力中的mask保证每个token只能看到前面的token，但注意力投影矩阵是所有位置共享的。你在Transformer里看不到“卷积”两个字，但局部连接和权重共享的痕迹无处不在。

在自监督学习、对比学习的场景中，不同的数据增强分支共享同一个编码器，这也是参数共享的变体——两个分支看到的图像不同，但特征是同一个编码器输出的，强制模型学会提取与增强方式无关的本质特征。

这些例子的共同点是：模型把一份参数用在多个不同的“位置”或“状态”上，逼着这份参数学习到可复用的通用模式。参数共享在CNN里很好理解的形态，一旦跳出图像，你会发现整个深度学习中处处都有它的影子。

所以我的建议是：别把“参数共享”当成CNN的一个考点，它本质上是一种建模哲学——用普遍性假设减少模型自由度，让参数花在刀刃上。理解到这一层，你再看ResNet、MobileNet、Transformer，都会有一种“原来如此”的通透感。