卷积操作详解（实战）：卷积核、步长、填充

import numpy as np

def conv1d(signal: np.ndarray, kernel: np.ndarray) -> np.ndarray:
    """1D 卷积（实际为互相关）
    signal: 1D 输入信号
    kernel: 1D 卷积核
    """
    k_size = len(kernel)
    output_len = len(signal) - k_size + 1  # valid 模式
    output = np.zeros(output_len)

    for i in range(output_len):
        output[i] = np.sum(signal[i:i+k_size] * kernel)

    return output

# 示例
signal = np.array([1, 3, 5, 2, 4])
kernel = np.array([1, 0, -1])
result = conv1d(signal, kernel)
print(f"1D 卷积结果: {result}")  # [-4  1 -3 -2]

def conv2d_single_channel(image: np.ndarray, kernel: np.ndarray) -> np.ndarray:
    """2D 单通道卷积（valid 模式，无填充）
    image: (H, W) 二维矩阵
    kernel: (K, K) 卷积核
    """
    H, W = image.shape
    K = kernel.shape[0]
    out_H = H - K + 1
    out_W = W - K + 1
    output = np.zeros((out_H, out_W))

    for i in range(out_H):
        for j in range(out_W):
            region = image[i:i+K, j:j+K]
            output[i, j] = np.sum(region * kernel)

    return output

def conv2d_multi_channel(image: np.ndarray, kernels: np.ndarray) -> np.ndarray:
    """多通道 2D 卷积
    image: (C_in, H, W) 多通道输入
    kernels: (C_out, C_in, K, K) 多核权重
    """
    C_out, C_in, K, _ = kernels.shape
    H, W = image.shape[1], image.shape[2]
    out_H = H - K + 1
    out_W = W - K + 1
    output = np.zeros((C_out, out_H, out_W))

    for c_out in range(C_out):
        for c_in in range(C_in):
            for i in range(out_H):
                for j in range(out_W):
                    region = image[c_in, i:i+K, j:j+K]
                    output[c_out, i, j] += np.sum(region * kernels[c_out, c_in])

    return output

import numpy as np
import matplotlib.pyplot as plt

# 经典手工卷积核
sobel_x = np.array([[-1, 0, 1],
                    [-2, 0, 2],
                    [-1, 0, 1]])  # 垂直边缘检测

sobel_y = np.array([[-1, -2, -1],
                    [ 0,  0,  0],
                    [ 1,  2,  1]])  # 水平边缘检测

laplacian = np.array([[0,  1, 0],
                      [1, -4, 1],
                      [0,  1, 0]])  # 二阶导数/边缘

gaussian_3x3 = np.array([[1, 2, 1],
                          [2, 4, 2],
                          [1, 2, 1]]) / 16.0  # 高斯平滑

# 可视化卷积核
kernels = {
    "Sobel-X (垂直边缘)": sobel_x,
    "Sobel-Y (水平边缘)": sobel_y,
    "Laplacian (锐化)": laplacian,
    "Gaussian (平滑)": gaussian_3x3,
}

fig, axes = plt.subplots(2, 2, figsize=(8, 8))
for ax, (name, kernel) in zip(axes.ravel(), kernels.items()):
    ax.imshow(kernel, cmap='coolwarm')
    ax.set_title(name)
    ax.axis('off')
plt.tight_layout()
plt.savefig("classic_kernels.png", dpi=150)

# 参数量对比：3x3 堆叠 vs 大核
def compare_params(kernel_size: int, num_layers: int, channels: int) -> int:
    """计算堆叠卷积的总参数量（忽略 bias）"""
    return num_layers * (kernel_size  2) * (channels  2)

channels = 64

# 等效感受野的参数量对比
params_3x3 = compare_params(3, 2, channels)  # 两个 3x3 ≈ 5x5 感受野
params_5x5 = compare_params(5, 1, channels)  # 一个 5x5
params_7x7 = compare_params(7, 1, channels)  # 一个 7x7

print(f"2×3×3 参数量: {params_3x3:,}")  # 589,824
print(f"1×5×5 参数量: {params_5x5:,}")  # 409,600 (感受野等效但参数少？)
# 注意: 5x5 = 25, 2×3x3 = 18, 但 channels² 乘上去后:
# 2×3²×64² = 2×9×4096 = 73,728
# 1×5²×64² = 25×4096 = 102,400

print(f"2×3×3: {params_3x3:,}")  # 73,728
print(f"1×5×5: {params_5x5:,}")  # 102,400
print(f"节省比例: {(1 - params_3x3/params_5x5)*100:.1f}%")  # 28.0%

import math

def conv_output_size(input_size: int, kernel_size: int,
                     stride: int = 1, padding: int = 0) -> int:
    """计算卷积输出尺寸
    input_size: 输入高度或宽度
    kernel_size: 卷积核大小
    stride: 步长
    padding: 单边填充量
    """
    return math.floor((input_size + 2 * padding - kernel_size) / stride) + 1

# ========== 典型场景 ==========
print("=== 步长对输出尺寸的影响 ===")
input_size = 32

for stride in [1, 2, 3, 4]:
    out = conv_output_size(input_size, kernel_size=3, stride=stride)
    reduction = (1 - out / input_size) * 100
    print(f"stride={stride}: 输出 {out}×{out}, 缩小 {reduction:.1f}%")

print()
print("=== 等效 Pooling 对比 ===")
# stride=2 的 3x3 卷积 vs maxpool 2x2
h, w, k, s, p = 224, 224, 3, 2, 1
out_h = conv_output_size(h, k, s, p)
print(f"输入: {h}×{w}, Conv(k=3,s=2,p=1) → {out_h}×{out_h}")
# MaxPool 2x2: out = floor((224 - 2) / 2) + 1 = 112
pool_out = conv_output_size(h, kernel_size=2, stride=2)
print(f"输入: {h}×{w}, MaxPool(k=2,s=2)   → {pool_out}×{pool_out}")

import numpy as np

def conv2d_with_stride(image: np.ndarray, kernel: np.ndarray,
                       stride: int = 1, padding: int = 0) -> np.ndarray:
    """带步长和填充的 2D 卷积"""
    if padding > 0:
        image = np.pad(image, pad_width=padding, mode='constant', constant_values=0)

    H, W = image.shape
    K = kernel.shape[0]
    out_H = (H - K) // stride + 1
    out_W = (W - K) // stride + 1
    output = np.zeros((out_H, out_W))

    for i in range(out_H):
        for j in range(out_W):
            region = image[i * stride:i * stride + K,
                           j * stride:j * stride + K]
            output[i, j] = np.sum(region * kernel)

    return output

# ========== 对比 stride=1 vs stride=2 ==========
img = np.arange(36).reshape(6, 6).astype(float)
kernel = np.ones((3, 3))

out_s1 = conv2d_with_stride(img, kernel, stride=1)  # 输出 4×4
out_s2 = conv2d_with_stride(img, kernel, stride=2)  # 输出 2×2

print(f"输入: 6×6, 核: 3×3")
print(f"stride=1 → 输出 {out_s1.shape[0]}×{out_s1.shape[1]}")
print(f"stride=2 → 输出 {out_s2.shape[0]}×{out_s2.shape[1]}")

import math

def padding_for_same(input_size: int, kernel_size: int,
                     stride: int = 1) -> int:
    """计算 Same 填充所需的填充量
    使 output_size = ceil(input_size / stride)
    """
    # output = floor((input + 2P - K) / S) + 1
    # 令 output = ceil(input / S)，求解 P
    output = math.ceil(input_size / stride)
    P = (output - 1) * stride + kernel_size - input_size
    P = math.ceil(P / 2)
    return max(0, P)

# ========== Same 填充计算 ==========
print("=== Same 填充量 ===")
for k in [3, 5, 7]:
    p = padding_for_same(32, k)
    out = math.floor((32 + 2*p - k) / 1) + 1
    print(f"K={k}: P={p}, 输出 {out}×{out} (stride=1)")

print()
# ========== 偶数核的特殊情况 ==========
print("=== 偶数核的不对称填充 ===")
for k in [2, 4]:
    p = padding_for_same(32, k)
    out = math.floor((32 + 2*p - k) / 1) + 1
    print(f"K={k}: 总填充={2*p}, 输出 {out}×{out}")

import numpy as np

def apply_padding(image: np.ndarray, padding: int,
                  mode: str = "constant") -> np.ndarray:
    """应用不同填充策略
    mode: "constant" (零填充), "reflect", "replicate"
    """
    if mode == "constant":
        return np.pad(image, padding, mode='constant', constant_values=0)
    elif mode == "reflect":
        return np.pad(image, padding, mode='reflect')
    elif mode == "replicate":
        return np.pad(image, padding, mode='edge')
    else:
        raise ValueError(f"未知填充模式: {mode}")

# ========== 不同填充模式对比 ==========
img = np.array([[1, 2, 3],
                [4, 5, 6],
                [7, 8, 9]])

print("原始图像:")
print(img)

print("\n零填充 (P=1):")
print(apply_padding(img, 1, "constant"))

print("\n反射填充 (P=1):")
print(apply_padding(img, 1, "reflect"))

print("\n复制填充 (P=1):")
print(apply_padding(img, 1, "replicate"))

import numpy as np
import math

def dilated_conv_output_size(input_size: int, kernel_size: int,
                              dilation: int = 1, stride: int = 1,
                              padding: int = 0) -> int:
    """计算空洞卷积输出尺寸
    有效核大小 K' = K + (K-1) × (dilation-1) = (K-1) × dilation + 1
    """
    effective_K = (kernel_size - 1) * dilation + 1
    return math.floor((input_size + 2 * padding - effective_K) / stride) + 1

def effective_receptive_field(kernel_size: int, dilation: int) -> int:
    """计算空洞卷积的等效感受野"""
    return (kernel_size - 1) * dilation + 1

# ========== 空洞率对感受野的影响 ==========
print("=== 3×3 卷积不同空洞率的感受野 ===")
for r in [1, 2, 3, 4, 5]:
    eff = effective_receptive_field(3, r)
    print(f"dilation={r}: 有效核={eff}×{eff}, 参数量仍为 9")

print()
print("=== 级联空洞卷积的感受野增长 ===")
# 3 层 3×3 卷积，空洞率分别为 1, 2, 4
total_rf = 1
for i, r in enumerate([1, 2, 4]):
    K = 3
    total_rf += (K - 1) * r
    print(f"第 {i+1} 层 (K=3, d={r}): 累积感受野 = {total_rf}×{total_rf}")

import numpy as np

def dilated_conv2d(image: np.ndarray, kernel: np.ndarray,
                   dilation: int = 1) -> np.ndarray:
    """空洞卷积实现
    dilation: 空洞率 (1 = 标准卷积)
    """
    H, W = image.shape
    K = kernel.shape[0]
    effective_K = (K - 1) * dilation + 1
    out_H = H - effective_K + 1
    out_W = W - effective_K + 1
    output = np.zeros((out_H, out_W))

    for i in range(out_H):
        for j in range(out_W):
            # 按空洞率采样输入区域
            region = image[i:i+effective_K:dilation,
                           j:j+effective_K:dilation]
            output[i, j] = np.sum(region * kernel)

    return output

# ========== 可视化空洞采样 ==========
img = np.arange(49).reshape(7, 7).astype(float)
kernel = np.ones((3, 3))

out_normal = dilated_conv2d(img, kernel, dilation=1)   # 5×5 输出
out_dilated = dilated_conv2d(img, kernel, dilation=2)  # 3×3 输出

print(f"输入: 7×7, 核: 3×3")
print(f"dilation=1: 输出 {out_normal.shape[0]}×{out_normal.shape[1]}")
print(f"dilation=2: 输出 {out_dilated.shape[0]}×{out_dilated.shape[1]}")

import numpy as np

def grouped_conv2d(image: np.ndarray, kernels: np.ndarray,
                   groups: int) -> np.ndarray:
    """分组卷积
    image: (C_in, H, W)
    kernels: (C_out, C_in/groups, K, K)
    groups: 分组数
    """
    C_in, H, W = image.shape
    C_out, _, K, _ = kernels.shape
    channels_per_group = C_in // groups
    outputs_per_group = C_out // groups
    out_H = H - K + 1
    out_W = W - K + 1
    output = np.zeros((C_out, out_H, out_W))

    for g in range(groups):
        # 第 g 组的输入通道
        start_c = g * channels_per_group
        end_c = start_c + channels_per_group
        group_input = image[start_c:end_c]  # (C/g, H, W)

        # 第 g 组的输出通道
        start_o = g * outputs_per_group
        end_o = start_o + outputs_per_group

        for c_out in range(outputs_per_group):
            for c_in in range(channels_per_group):
                for i in range(out_H):
                    for j in range(out_W):
                        region = group_input[c_in, i:i+K, j:j+K]
                        output[start_o + c_out, i, j] += \
                            np.sum(region * kernels[start_o + c_out, c_in])

    return output

def compare_params(C_in: int, C_out: int, K: int) -> dict:
    """对比标准卷积与深度可分离卷积的参数量"""
    # 标准卷积
    std_params = C_in * C_out * K * K

    # 深度可分离卷积 = 深度卷积 + 逐点卷积
    dw_params = C_in * K * K  # 每个通道独立卷积
    pw_params = C_in * C_out  # 1x1 通道混合
    sep_params = dw_params + pw_params

    return {
        "标准卷积": std_params,
        "深度卷积 (DW)": dw_params,
        "逐点卷积 (PW)": pw_params,
        "深度可分离总计": sep_params,
        "节省比例": f"{(1 - sep_params/std_params)*100:.1f}%",
    }

# ========== 参数量对比 ==========
for C_in, C_out, K in [(32, 64, 3), (128, 128, 3), (256, 256, 3), (512, 512, 3)]:
    result = compare_params(C_in, C_out, K)
    print(f"C_in={C_in}, C_out={C_out}, K={K}:")
    for k, v in result.items():
        print(f"  {k}: {v:,}")
    print()

import torch
import torch.nn as nn

# ========== Conv2d 参数全演示 ==========

# 1. 基础用法：标准卷积
conv_basic = nn.Conv2d(
    in_channels=3,      # RGB 输入
    out_channels=64,    # 64 个卷积核
    kernel_size=3,      # 3x3 卷积核
    stride=1,           # 步长 1
    padding=1,          # 填充 1（same padding）
    bias=True           # 使用偏置
)
print(f"标准卷积参数量: {conv_basic.weight.numel() + conv_basic.bias.numel():,}")
# 3 × 64 × 9 + 64 = 1,792

# 2. Same 填充（保持尺寸）
x = torch.randn(2, 3, 32, 32)  # batch=2, channels=3, 32x32
out = conv_basic(x)
print(f"输入: {x.shape} → 输出: {out.shape}")  # [2, 64, 32, 32]

# 3. 下采样（stride=2）
conv_downsample = nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1)
out2 = conv_downsample(out)
print(f"下采样: {out.shape} → {out2.shape}")  # [2, 128, 16, 16]

# 4. 空洞卷积
conv_dilated = nn.Conv2d(128, 128, kernel_size=3, padding=2, dilation=2)
out3 = conv_dilated(out2)
print(f"空洞卷积: {out2.shape} → {out3.shape}")  # [2, 128, 16, 16]

# 5. 深度可分离卷积
depthwise = nn.Conv2d(128, 128, kernel_size=3, padding=1, groups=128)
pointwise = nn.Conv2d(128, 256, kernel_size=1)
out4 = pointwise(depthwise(out3))
print(f"深度可分离: {out3.shape} → {out4.shape}")  # [2, 256, 16, 16]

import torch
import torch.nn as nn

# ========== 完整 CNN 示例（类似 VGG 风格）==========
class SimpleCNN(nn.Module):
    """小型 CNN 分类器"""
    def __init__(self, num_classes: int = 10):
        super().__init__()
        self.features = nn.Sequential(
            # Block 1: 32x32 → 32x32
            nn.Conv2d(3, 32, kernel_size=3, padding=1),   # 参数量: 896
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.Conv2d(32, 32, kernel_size=3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2, 2),  # 32x32 → 16x16

            # Block 2: 16x16 → 16x16
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2, 2),  # 16x16 → 8x8

            # Block 3: 8x8 → 8x8
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2, 2),  # 8x8 → 4x4
        )

        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(128 * 4 * 4, 256),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(256, num_classes),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.features(x)
        x = self.classifier(x)
        return x

# 验证网络
model = SimpleCNN(num_classes=10)
x = torch.randn(4, 3, 32, 32)
out = model(x)
print(f"输入: {x.shape} → 输出: {out.shape}")  # [4, 10]
print(f"总参数量: {sum(p.numel() for p in model.parameters()):,}")