CNNの基礎 — 畳み込み・プーリング・受容野の数理

import numpy as np
import matplotlib.pyplot as plt

# --- 畳み込み演算の可視化 ---

def conv2d(image, kernel, stride=1, padding=0):
    """2D畳み込み（スクラッチ実装）"""
    if padding > 0:
        image = np.pad(image, padding, mode='constant')

    H, W = image.shape
    kH, kW = kernel.shape
    out_H = (H - kH) // stride + 1
    out_W = (W - kW) // 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+kH, j*stride:j*stride+kW]
            output[i, j] = np.sum(region * kernel)

    return output

# テスト画像の生成（市松模様 + 対角線）
np.random.seed(42)
img_size = 16
image = np.zeros((img_size, img_size))
# 市松模様
for i in range(img_size):
    for j in range(img_size):
        if (i // 4 + j // 4) % 2 == 0:
            image[i, j] = 1.0
# 対角線
for i in range(img_size):
    if i < img_size:
        image[i, i] = 0.5

# 各種カーネル
kernels = {
    "Horizontal Edge": np.array([[-1, -1, -1],
                                  [ 0,  0,  0],
                                  [ 1,  1,  1]], dtype=float),
    "Vertical Edge":   np.array([[-1, 0, 1],
                                  [-1, 0, 1],
                                  [-1, 0, 1]], dtype=float),
    "Sharpen":         np.array([[ 0, -1,  0],
                                  [-1,  5, -1],
                                  [ 0, -1,  0]], dtype=float),
}

fig, axes = plt.subplots(2, 4, figsize=(18, 8))

# 元画像
ax = axes[0, 0]
ax.imshow(image, cmap="gray", vmin=-1, vmax=1)
ax.set_title("Input Image", fontsize=12)
ax.axis("off")
axes[1, 0].axis("off")

# 各カーネルと結果
for idx, (name, kernel) in enumerate(kernels.items()):
    # カーネルの表示
    ax = axes[0, idx + 1]
    ax.imshow(kernel, cmap="RdBu_r", vmin=-5, vmax=5)
    for i in range(3):
        for j in range(3):
            ax.text(j, i, f"{kernel[i,j]:.0f}", ha="center",
                    va="center", fontsize=10, fontweight="bold")
    ax.set_title(f"Kernel: {name}", fontsize=11)
    ax.axis("off")

    # 畳み込み結果
    ax = axes[1, idx + 1]
    output = conv2d(image, kernel, stride=1, padding=1)
    ax.imshow(output, cmap="gray")
    ax.set_title(f"After Convolution", fontsize=11)
    ax.axis("off")

plt.tight_layout()
plt.savefig("conv_kernels.png", dpi=150, bbox_inches="tight")
plt.show()

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(42)

class Conv2D:
    """2次元畳み込み層"""

    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0):
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.kernel_size = kernel_size
        self.stride = stride
        self.padding = padding

        # He初期化
        fan_in = in_channels * kernel_size * kernel_size
        self.W = np.random.randn(out_channels, in_channels,
                                  kernel_size, kernel_size) * np.sqrt(2.0 / fan_in)
        self.b = np.zeros(out_channels)

    def forward(self, X):
        """X: (batch, in_channels, H, W)"""
        self.X = X
        B, C, H, W = X.shape
        k = self.kernel_size
        s = self.stride
        p = self.padding

        if p > 0:
            X = np.pad(X, ((0,0), (0,0), (p,p), (p,p)), mode='constant')

        H_out = (H + 2*p - k) // s + 1
        W_out = (W + 2*p - k) // s + 1
        out = np.zeros((B, self.out_channels, H_out, W_out))

        for i in range(H_out):
            for j in range(W_out):
                region = X[:, :, i*s:i*s+k, j*s:j*s+k]
                # (B, C_in, k, k) と (C_out, C_in, k, k) の畳み込み
                for f in range(self.out_channels):
                    out[:, f, i, j] = np.sum(
                        region * self.W[f], axis=(1, 2, 3)) + self.b[f]

        return out


class MaxPool2D:
    """Max Pooling層"""

    def __init__(self, kernel_size=2, stride=2):
        self.kernel_size = kernel_size
        self.stride = stride

    def forward(self, X):
        B, C, H, W = X.shape
        k = self.kernel_size
        s = self.stride
        H_out = (H - k) // s + 1
        W_out = (W - k) // s + 1
        out = np.zeros((B, C, H_out, W_out))

        for i in range(H_out):
            for j in range(W_out):
                region = X[:, :, i*s:i*s+k, j*s:j*s+k]
                out[:, :, i, j] = np.max(region, axis=(2, 3))

        return out

# --- 畳み込みの動作確認 ---
# 入力画像（1枚, 1チャネル, 8x8）
image = np.random.randn(1, 1, 8, 8)

conv = Conv2D(in_channels=1, out_channels=4, kernel_size=3, padding=1)
pool = MaxPool2D(kernel_size=2, stride=2)

# 順伝播
conv_out = conv.forward(image)
relu_out = np.maximum(0, conv_out)
pool_out = pool.forward(relu_out)

print(f"入力:    {image.shape}")
print(f"Conv後:  {conv_out.shape}")
print(f"ReLU後:  {relu_out.shape}")
print(f"Pool後:  {pool_out.shape}")

# 特徴マップの可視化
fig, axes = plt.subplots(2, 5, figsize=(16, 6))

# 入力
axes[0, 0].imshow(image[0, 0], cmap="gray")
axes[0, 0].set_title("Input (8x8)", fontsize=11)
axes[0, 0].axis("off")
axes[1, 0].axis("off")

# Conv + ReLU の特徴マップ
for f in range(4):
    axes[0, f+1].imshow(relu_out[0, f], cmap="viridis")
    axes[0, f+1].set_title(f"Conv+ReLU ch{f} (8x8)", fontsize=10)
    axes[0, f+1].axis("off")

    axes[1, f+1].imshow(pool_out[0, f], cmap="viridis")
    axes[1, f+1].set_title(f"After Pool ch{f} (4x4)", fontsize=10)
    axes[1, f+1].axis("off")

plt.suptitle("Feature Maps through CNN Layers", fontsize=14, y=1.02)
plt.tight_layout()
plt.savefig("cnn_feature_maps.png", dpi=150, bbox_inches="tight")
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# --- 受容野の計算 ---

def compute_receptive_field(layers):
    """各層の受容野サイズを計算"""
    r = 1  # 入力の受容野は1
    j = 1  # 累積ストライド
    receptive_fields = [r]
    jumps = [j]

    for kernel_size, stride in layers:
        r = r + (kernel_size - 1) * j
        j = j * stride
        receptive_fields.append(r)
        jumps.append(j)

    return receptive_fields, jumps

# 異なるアーキテクチャの比較
architectures = {
    "3x3 Conv x5\n(stride=1)": [(3, 1)] * 5,
    "3x3 Conv x3\n+ MaxPool x2": [(3, 1), (2, 2), (3, 1), (2, 2), (3, 1)],
    "5x5 Conv x3\n(stride=1)": [(5, 1)] * 3,
    "VGG-style\n(3x3 + Pool)": [(3,1),(3,1),(2,2),(3,1),(3,1),(2,2)],
}

fig, axes = plt.subplots(1, 2, figsize=(14, 5.5))

# (a) 受容野サイズの推移
ax = axes[0]
colors = ["tab:blue", "tab:orange", "tab:green", "tab:red"]

for (name, layers), color in zip(architectures.items(), colors):
    rfs, _ = compute_receptive_field(layers)
    ax.plot(range(len(rfs)), rfs, "o-", linewidth=2, markersize=6,
            color=color, label=name)

ax.set_xlabel("Layer index", fontsize=12)
ax.set_ylabel("Receptive field size", fontsize=12)
ax.set_title("Receptive Field Growth by Architecture", fontsize=13)
ax.legend(fontsize=9)
ax.grid(True, alpha=0.3)

# (b) 受容野の可視化（3x3 Conv x3）
ax = axes[1]
img_size = 15
image = np.ones((img_size, img_size)) * 0.9

# 3層目のユニットの受容野（中央のユニット）
# 3x3 Conv x3: RF = 7
rf_size = 7
center = img_size // 2
start = center - rf_size // 2
end = start + rf_size

# 受容野の階層を色分け
# Layer 1: 3x3 (赤)
layer1_start = center - 1
layer1_end = center + 2
# Layer 2: 5x5 (オレンジ)
layer2_start = center - 2
layer2_end = center + 3
# Layer 3: 7x7 (黄)
layer3_start = center - 3
layer3_end = center + 4

rf_map = np.ones((img_size, img_size, 3)) * 0.9

# Layer 3 RF
rf_map[layer3_start:layer3_end, layer3_start:layer3_end] = [1.0, 1.0, 0.7]
# Layer 2 RF
rf_map[layer2_start:layer2_end, layer2_start:layer2_end] = [1.0, 0.8, 0.5]
# Layer 1 RF
rf_map[layer1_start:layer1_end, layer1_start:layer1_end] = [1.0, 0.5, 0.3]
# Center pixel
rf_map[center, center] = [1.0, 0.0, 0.0]

ax.imshow(rf_map, extent=[0, img_size, img_size, 0])
ax.set_title("Receptive Field Visualization\n(3x3 Conv x3, RF=7x7)",
             fontsize=12)
ax.set_xlabel("Width", fontsize=11)
ax.set_ylabel("Height", fontsize=11)

# 注釈
ax.annotate("Center unit", xy=(center+0.5, center+0.5),
            xytext=(center+3, center-3),
            fontsize=10, ha="center",
            arrowprops=dict(arrowstyle="->", color="black"))

ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig("receptive_field.png", dpi=150, bbox_inches="tight")
plt.show()