10 P3 실습: 합성곱 신경망과 컴퓨터 비전

# TensorFlow 를 사용할 때 기타 정보 표시 제한. Tensorflow를 불러오기 전에 실행해야 함
import os
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"

import tensorflow as tf
import torch

# TensorFlow
tf_gpus = tf.config.list_physical_devices("GPU")

print("=== TensorFlow ===")
print("Version:", tf.__version__)
print("GPU 사용 가능:", len(tf_gpus) > 0)
if tf_gpus:
    print("GPU:", tf_gpus[0].name)

print()

# PyTorch
print("=== PyTorch ===")
print("Version:", torch.__version__)
print("GPU 사용 가능:", torch.cuda.is_available())
if torch.cuda.is_available():
    print("GPU:", torch.cuda.get_device_name(0))
    print("CUDA version:", torch.version.cuda)

import numpy as np
import matplotlib.pyplot as plt
import keras
from keras import layers

from keras.datasets import mnist

(mnist_x_all, mnist_y_all), (mnist_x_test, mnist_y_test) = mnist.load_data()

mnist_x_all = mnist_x_all.astype("float32")[..., None] / 255.0
mnist_x_test = mnist_x_test.astype("float32")[..., None] / 255.0

rng = np.random.default_rng(42)
order = rng.permutation(len(mnist_x_all))
n_val = int(len(mnist_x_all) * 0.10)
train_ids, val_ids = order[:-n_val], order[-n_val:]

mnist_x_train, mnist_y_train = mnist_x_all[train_ids], mnist_y_all[train_ids]
mnist_x_val, mnist_y_val = mnist_x_all[val_ids], mnist_y_all[val_ids]

print("훈련:", mnist_x_train.shape, mnist_y_train.shape)
print("검증:", mnist_x_val.shape, mnist_y_val.shape)
print("테스트:", mnist_x_test.shape, mnist_y_test.shape)

fig, axes = plt.subplots(1, 5, figsize=(10, 2))
for i, ax in enumerate(axes):
    ax.imshow(mnist_x_train[i, :, :, 0], cmap="gray")
    ax.set_title(f"Label: {mnist_y_train[i]}")
    ax.axis("off")
plt.tight_layout()

inputs = keras.Input(shape=(28, 28, 1))
x = layers.Conv2D(32, 3, padding="same", activation="relu", name="first_conv")(inputs)
x = layers.MaxPooling2D(pool_size=2)(x)
x = layers.Conv2D(64, 3, padding="same", activation="relu")(x)
x = layers.MaxPooling2D(pool_size=2)(x)
x = layers.Conv2D(128, 3, padding="same", activation="relu")(x)
x = layers.GlobalAveragePooling2D()(x)
outputs = layers.Dense(10, activation="softmax")(x)

mnist_cnn = keras.Model(inputs, outputs, name="mnist_cnn")
mnist_cnn.summary()

mnist_cnn.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

mnist_history = mnist_cnn.fit(
    mnist_x_train, mnist_y_train,
    validation_data=(mnist_x_val, mnist_y_val),
    epochs=4, batch_size=128, verbose=1,
)

fig, axes = plt.subplots(1, 2, figsize=(10, 3.5))

for key, title, ax in [("loss", "Loss", axes[0]), ("accuracy", "Accuracy", axes[1])]:
    epochs = range(1, len(mnist_history.history[key]) + 1)
    ax.plot(epochs, mnist_history.history[key], label="Train")
    ax.plot(epochs, mnist_history.history["val_" + key], label="Validation")
    ax.set_xlabel("Epoch")
    ax.set_xticks(range(1, 5))
    ax.set_title(title)
    ax.legend()

plt.tight_layout()

conv_example = layers.Conv2D(32, 3, use_bias=False)
conv_example(keras.Input(shape=(28, 28, 1)))

dense_example = layers.Dense(32, use_bias=False)
dense_example(keras.Input(shape=(28*28,)))

print("Conv2D 파라미터:", conv_example.count_params())
print("Dense 파라미터:", dense_example.count_params())

from torch import nn
from torch.utils.data import TensorDataset, DataLoader

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("장치:", device)

torch_x_train = torch.from_numpy(mnist_x_train).permute(0, 3, 1, 2)
torch_x_val = torch.from_numpy(mnist_x_val).permute(0, 3, 1, 2)
torch_x_test = torch.from_numpy(mnist_x_test).permute(0, 3, 1, 2)

train_loader = DataLoader(TensorDataset(torch_x_train, torch.from_numpy(mnist_y_train).long()),
                          batch_size=128, shuffle=True)
val_loader = DataLoader(TensorDataset(torch_x_val, torch.from_numpy(mnist_y_val).long()),
                        batch_size=256)
test_loader = DataLoader(TensorDataset(torch_x_test, torch.from_numpy(mnist_y_test).long()),
                         batch_size=256)

print("Keras 첫 배치 차원:", mnist_x_train[:128].shape)
print("PyTorch 첫 배치 차원:", next(iter(train_loader))[0].shape)

class TorchMNISTCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, 3, padding=1)
        self.pool = nn.MaxPool2d(2)
        self.relu = nn.ReLU()
        self.gap = nn.AdaptiveAvgPool2d(1)
        self.output = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(self.relu(self.conv1(x)))
        x = self.pool(self.relu(self.conv2(x)))
        x = self.relu(self.conv3(x))
        x = self.gap(x)
        x = torch.flatten(x, start_dim=1)
        return self.output(x)  # logits

torch_cnn = TorchMNISTCNN().to(device)
print(torch_cnn)

def run_torch_epoch(model, loader, loss_fn, optimizer=None):
    training = optimizer is not None
    model.train() if training else model.eval()
    total_loss, correct, total = 0.0, 0, 0

    with torch.set_grad_enabled(training):
        for xb, yb in loader:
            xb, yb = xb.to(device), yb.to(device)
            if training:
                optimizer.zero_grad()
            logits = model(xb)
            loss = loss_fn(logits, yb)
            if training:
                loss.backward()
                optimizer.step()
            total_loss += loss.item() * len(xb)
            correct += (logits.argmax(dim=1) == yb).sum().item()
            total += len(xb)
    return total_loss / total, correct / total

loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(torch_cnn.parameters(), lr=1e-3)

torch_history = {"loss": [], "accuracy": [], "val_loss": [], "val_accuracy": []}
for epoch in range(3):
    tr_loss, tr_acc = run_torch_epoch(torch_cnn, train_loader, loss_fn, optimizer)
    va_loss, va_acc = run_torch_epoch(torch_cnn, val_loader, loss_fn)
    for key, value in [("loss", tr_loss), ("accuracy", tr_acc),
                       ("val_loss", va_loss), ("val_accuracy", va_acc)]:
        torch_history[key].append(value)
    print(f"epoch {epoch+1}: loss={tr_loss:.3f}, accuracy={tr_acc:.3f}, "
          f"val_loss={va_loss:.3f}, val_accuracy={va_acc:.3f}")

keras_test_loss, keras_test_acc = mnist_cnn.evaluate(mnist_x_test, mnist_y_test, verbose=0)
torch_test_loss, torch_test_acc = run_torch_epoch(torch_cnn, test_loader, loss_fn)
print(f"Keras    테스트 정확도: {keras_test_acc:.3f}")
print(f"PyTorch  테스트 정확도: {torch_test_acc:.3f}")

import numpy as np
from datasets import load_dataset

# --------------------------------------------------
# 1. CIFAR-10 데이터셋 불러오기
# --------------------------------------------------

# Hugging Face에서 CIFAR-10 다운로드
# train: 50,000장 / test: 10,000장
# 각 이미지는 32×32 크기의 RGB 이미지
cifar = load_dataset("uoft-cs/cifar10")

# 이미지의 클래스 번호(label)만 NumPy 배열로 변환
cifar_y_train_all = np.array(cifar["train"]["label"])
cifar_y_test_all = np.array(cifar["test"]["label"])


# --------------------------------------------------
# 2. 고양이(cat)와 개(dog) 이미지 선택
# --------------------------------------------------

# CIFAR-10 클래스 번호: cat=3, dog=5
# 이진 분류 타깃: cat=0, dog=1

# 난수 시드를 고정하여 동일한 데이터 선택을 재현
rng = np.random.default_rng(42)

# 훈련, 검증, 테스트 이미지의 인덱스를 저장할 리스트
train_ids, val_ids, test_ids = [], [], []

# 고양이(3)와 개(5)를 각각 같은 수만큼 선택
for original_class in (3, 5):

    # 해당 클래스에 속한 이미지의 인덱스를 찾아 무작위로 섞기
    tr = rng.permutation(
        np.flatnonzero(cifar_y_train_all == original_class)
    )
    te = rng.permutation(
        np.flatnonzero(cifar_y_test_all == original_class)
    )

    # 원래 훈련 데이터에서 클래스별 1,000장씩 선택
    train_ids.extend(tr[:1000])

    # 원래 훈련 데이터에서 클래스별 250장씩 검증용으로 선택
    val_ids.extend(tr[1000:1250])

    # 원래 테스트 데이터에서 클래스별 300장씩 선택
    test_ids.extend(te[:300])

# 고양이와 개 이미지가 섞이도록 전체 순서를 다시 무작위로 변경
train_ids = rng.permutation(train_ids)
val_ids = rng.permutation(val_ids)
test_ids = rng.permutation(test_ids)


# --------------------------------------------------
# 3. 선택한 이미지만 NumPy 배열로 변환
# --------------------------------------------------

def get_images(split, ids):
    """선택된 이미지들을 float32 NumPy 배열로 반환"""

    # split: "train" 또는 "test"
    # ids: 선택할 이미지의 인덱스
    # 각 이미지를 NumPy 배열로 바꾼 뒤 하나의 배열로 결합
    return np.stack([
        np.array(cifar[split][int(i)]["img"], dtype="float32")
        for i in ids
    ])


# --------------------------------------------------
# 4. 훈련·검증·테스트 데이터 생성
# --------------------------------------------------

# 훈련 데이터
catdog_x_train = get_images("train", train_ids)
catdog_y_train = (cifar_y_train_all[train_ids] == 5).astype("float32")

# 검증 데이터: 원래 훈련 데이터에서 분리
catdog_x_val = get_images("train", val_ids)
catdog_y_val = (cifar_y_train_all[val_ids] == 5).astype("float32")

# 테스트 데이터: 원래 테스트 데이터에서 선택
catdog_x_test = get_images("test", test_ids)
catdog_y_test = (cifar_y_test_all[test_ids] == 5).astype("float32")

# 레이블 변환 원리:
# cat(3) == 5 → False → 0.0
# dog(5) == 5 → True  → 1.0

# 주의: 이미지를 float32로 변환했지만 픽셀값은 여전히
# 0~255 범위이다. 정규화·모델별 전처리는 이후 단계에서 수행한다.


# --------------------------------------------------
# 5. 데이터 구성 결과 확인
# --------------------------------------------------

print("훈련 / 검증 / 테스트:",
      len(train_ids), len(val_ids), len(test_ids))

print("훈련 이미지:", catdog_x_train.shape)
print("검증 이미지:", catdog_x_val.shape)
print("테스트 이미지:", catdog_x_test.shape)
print("이미지 모양:", catdog_x_train.shape[1:])

fig, axes = plt.subplots(2, 5, figsize=(9, 4))
for ax, image, label in zip(axes.flat, catdog_x_train[:10], catdog_y_train[:10]):
    ax.imshow(image.astype("uint8"))
    ax.set_title("dog" if label == 1 else "cat")
    ax.axis("off")
plt.tight_layout()

augmentation = keras.Sequential([
    layers.RandomFlip("horizontal"),
    layers.RandomRotation(0.10),
    layers.RandomTranslation(0.10, 0.10),
    layers.RandomZoom(0.07),
    layers.RandomContrast(0.5),
], name="augmentation")

image = catdog_x_train[:1]

fig, axes = plt.subplots(2, 5, figsize=(9, 4))
axes = axes.flatten()

axes[0].imshow(image[0].astype("uint8"))
axes[0].set_title("Original")

for i, ax in enumerate(axes[1:], start=1):
    changed = augmentation(image, training=True).numpy()[0]
    ax.imshow(np.clip(changed, 0, 255).astype("uint8"))
    ax.set_title(f"Augmented {i}")

for ax in axes:
    ax.axis("off")

plt.tight_layout()

def build_catdog_model(use_augmentation=False):
    inputs = keras.Input(shape=(32, 32, 3))
    x = inputs
    if use_augmentation:
        x = layers.RandomFlip("horizontal")(x)
        x = layers.RandomRotation(0.05)(x)
    x = layers.Rescaling(1.0 / 255)(x)
    x = layers.Conv2D(32, 3, padding="same", activation="relu")(x)
    x = layers.MaxPooling2D(2)(x)
    x = layers.Conv2D(64, 3, padding="same", activation="relu")(x)
    x = layers.MaxPooling2D(2)(x)
    x = layers.Conv2D(128, 3, padding="same", activation="relu")(x)
    x = layers.GlobalAveragePooling2D()(x)
    outputs = layers.Dense(1, activation="sigmoid")(x)
    model = keras.Model(inputs, outputs)
    model.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])
    return model

baseline_catdog = build_catdog_model(use_augmentation=False)
augmented_catdog = build_catdog_model(use_augmentation=True)

history_baseline = baseline_catdog.fit(
    catdog_x_train, catdog_y_train,
    validation_data=(catdog_x_val, catdog_y_val),
    epochs=5, batch_size=64, verbose=1,
    callbacks=[keras.callbacks.EarlyStopping(monitor="val_loss", patience=2, restore_best_weights=True)],
)
history_augmented = augmented_catdog.fit(
    catdog_x_train, catdog_y_train,
    validation_data=(catdog_x_val, catdog_y_val),
    epochs=5, batch_size=64, verbose=1,
    callbacks=[keras.callbacks.EarlyStopping(monitor="val_loss", patience=2, restore_best_weights=True)],
)

plt.figure(figsize=(7, 4))
for label, h in [("Baseline CNN", history_baseline), ("Augmented CNN", history_augmented)]:
    epochs = range(1, len(h.history["val_loss"]) + 1)
    plt.plot(epochs, h.history["val_loss"], label=label)
plt.xlabel("epoch")
plt.xticks(range(1, 6))
plt.ylabel("Validation loss")
plt.legend()
plt.tight_layout()

transfer_base = keras.applications.Xception(
    input_shape=(96, 96, 3), include_top=False, weights="imagenet"
)
transfer_base.trainable = False

inputs = keras.Input(shape=(32, 32, 3))
x = layers.RandomFlip("horizontal")(inputs)
x = layers.Resizing(96, 96)(x)
x = layers.Rescaling(1 / 127.5, offset=-1)(x)  # Xception 입력 범위 [-1, 1]
x = transfer_base(x, training=False)  # 미세 조정 중에도 BatchNorm은 추론 모드
x = layers.GlobalAveragePooling2D()(x)
outputs = layers.Dense(1, activation="sigmoid")(x)
transfer_model = keras.Model(inputs, outputs, name="catdog_xception_transfer")
transfer_model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss="binary_crossentropy", metrics=["accuracy"],
)
transfer_history = transfer_model.fit(
    catdog_x_train, catdog_y_train,
    validation_data=(catdog_x_val, catdog_y_val),
    epochs=4, batch_size=16, verbose=1,
    callbacks=[keras.callbacks.EarlyStopping(monitor="val_loss", patience=2, restore_best_weights=True)],
)

transfer_base.trainable = True
for layer in transfer_base.layers[:-20]:
    layer.trainable = False
for layer in transfer_base.layers:
    if isinstance(layer, layers.BatchNormalization):
        layer.trainable = False

print("미세 조정 대상 가중치 수:", len(transfer_base.trainable_weights))
transfer_model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-5),
    loss="binary_crossentropy", metrics=["accuracy"],
)
transfer_history = transfer_model.fit(
    catdog_x_train, catdog_y_train,
    validation_data=(catdog_x_val, catdog_y_val),
    epochs=2, batch_size=16, verbose=1,
    callbacks=[keras.callbacks.EarlyStopping(monitor="val_loss", patience=1, restore_best_weights=True)],
)

candidates = {
    "기준 CNN": (baseline_catdog, history_baseline),
    "증식 CNN": (augmented_catdog, history_augmented),
}
if transfer_history is not None:
    candidates["전이 학습"] = (transfer_model, transfer_history)

for name, (_, h) in candidates.items():
    print(name, "최소 검증 손실:", round(min(h.history["val_loss"]), 4),
          "최종 검증 정확도:", round(h.history["val_accuracy"][-1], 4))

best_name = min(candidates, key=lambda key: min(candidates[key][1].history["val_loss"]))
best_model = candidates[best_name][0]
print("검증 손실로 선택한 모델:", best_name)

catdog_test_loss, catdog_test_acc = best_model.evaluate(
    catdog_x_test, catdog_y_test, verbose=0
)
print(f"선택 모델의 테스트 정확도: {catdog_test_acc:.3f}")

res_inputs = keras.Input(shape=(32, 32, 3))
x = layers.Conv2D(16, 3, padding="same", activation="relu")(res_inputs)
skip = x  # 블록 입력 저장
x = layers.Conv2D(16, 3, padding="same")(x)
x = layers.Add()([x, skip])
x = layers.Activation("relu")(x)
res_model = keras.Model(res_inputs, x)
print("입력:", res_model.input_shape, "출력:", res_model.output_shape)

bn_inputs = keras.Input(shape=(32, 32, 3))
x = layers.Conv2D(16, 3, padding="same", use_bias=False)(bn_inputs)
x = layers.BatchNormalization()(x)
x = layers.Activation("relu")(x)
bn_model = keras.Model(bn_inputs, x)
print("출력 모양:", bn_model.output_shape)

comparison_input = keras.Input(shape=(32, 32, 3))
normal_conv = layers.Conv2D(64, 3, use_bias=False)
separable_conv = layers.SeparableConv2D(64, 3, use_bias=False)
normal_conv(comparison_input)
separable_conv(comparison_input)

print("Conv2D 가중치 수:", normal_conv.count_params())
print("SeparableConv2D 가중치 수:", separable_conv.count_params())

# 전이 학습에서 불러온 실제 Xception 층의 구성을 살펴본다.
if transfer_base is not None:
    for cls in (layers.SeparableConv2D, layers.BatchNormalization, layers.Add):
        count = sum(isinstance(layer, cls) for layer in transfer_base.layers)
        print(f"{cls.__name__}: {count}")
    print("Xception feature shape:", transfer_base.output_shape)
else:
    print("Xception 모델이 로드되지 않아 구조 확인을 건너뜁니다.")

class DepthwiseSeparableConv(nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.depthwise = nn.Conv2d(
            in_channels, in_channels, kernel_size=3, padding=1,
            groups=in_channels, bias=False
        )
        self.pointwise = nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)

    def forward(self, x):
        x = self.depthwise(x)
        return self.pointwise(x)


class MiniXceptionBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()
        self.main = nn.Sequential(
            nn.ReLU(),
            DepthwiseSeparableConv(in_channels, out_channels),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(),
            DepthwiseSeparableConv(out_channels, out_channels),
            nn.BatchNorm2d(out_channels),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1) if stride == 2 else nn.Identity(),
        )
        self.skip = (
            nn.Identity() if stride == 1 and in_channels == out_channels else
            nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels),
            )
        )

    def forward(self, x):
        return self.main(x) + self.skip(x)


class MiniXception(nn.Module):
    def __init__(self):
        super().__init__()
        self.stem = nn.Sequential(
            nn.Conv2d(3, 24, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(24),
            nn.ReLU(),
        )
        self.entry = MiniXceptionBlock(24, 32, stride=2)
        self.middle = MiniXceptionBlock(32, 32)
        self.exit = MiniXceptionBlock(32, 64, stride=2)
        self.pool = nn.AdaptiveAvgPool2d(1)
        self.classifier = nn.Linear(64, 1)

    def forward(self, x):
        x = self.stem(x)
        x = self.entry(x)
        x = self.middle(x)
        x = self.exit(x)
        x = self.pool(x).flatten(1)
        return self.classifier(x).squeeze(1)  # logits: (batch,)


torch.manual_seed(42)
mini_xception = MiniXception().to(device)

with torch.no_grad():
    demo_logits = mini_xception.eval()(torch.zeros(2, 3, 32, 32, device=device))
print('Model output shape:', tuple(demo_logits.shape))
print('Trainable parameters:', sum(p.numel() for p in mini_xception.parameters() if p.requires_grad))

regular = nn.Conv2d(32, 64, kernel_size=3, padding=1, bias=False)
separable = DepthwiseSeparableConv(32, 64)
print('Regular Conv2d parameters:', sum(p.numel() for p in regular.parameters()))
print('Depthwise separable parameters:', sum(p.numel() for p in separable.parameters()))

mini_x_train = torch.from_numpy(catdog_x_train / 255.0).permute(0, 3, 1, 2).contiguous()
mini_y_train = torch.from_numpy(catdog_y_train)
mini_x_val = torch.from_numpy(catdog_x_val / 255.0).permute(0, 3, 1, 2).contiguous()
mini_y_val = torch.from_numpy(catdog_y_val)

mini_train_loader = DataLoader(
    TensorDataset(mini_x_train, mini_y_train), batch_size=32, shuffle=True
)
mini_val_loader = DataLoader(
    TensorDataset(mini_x_val, mini_y_val), batch_size=64, shuffle=False
)

mini_loss_fn = nn.BCEWithLogitsLoss()
mini_optimizer = torch.optim.Adam(mini_xception.parameters(), lr=1e-3)


def run_mini_epoch(model, loader, optimizer=None):
    training = optimizer is not None
    model.train(training)
    total_loss, correct, n = 0.0, 0, 0
    with torch.set_grad_enabled(training):
        for xb, yb in loader:
            xb, yb = xb.to(device), yb.to(device)
            if training:
                optimizer.zero_grad()
            logits = model(xb)
            loss = mini_loss_fn(logits, yb)
            if training:
                loss.backward()
                optimizer.step()
            total_loss += loss.item() * len(yb)
            correct += ((logits >= 0).float() == yb).sum().item()
            n += len(yb)
    return total_loss / n, correct / n


mini_history = {'loss': [], 'val_loss': [], 'accuracy': [], 'val_accuracy': []}
for epoch in range(20):
    train_loss, train_acc = run_mini_epoch(mini_xception, mini_train_loader, mini_optimizer)
    val_loss, val_acc = run_mini_epoch(mini_xception, mini_val_loader)
    mini_history['loss'].append(train_loss)
    mini_history['val_loss'].append(val_loss)
    mini_history['accuracy'].append(train_acc)
    mini_history['val_accuracy'].append(val_acc)
    print(f'Epoch {epoch + 1}: loss={train_loss:.3f}, accuracy={train_acc:.3f}, '
          f'val_loss={val_loss:.3f}, val_accuracy={val_acc:.3f}')

fig, axes = plt.subplots(1, 2, figsize=(10, 3.5))
epochs = range(1, len(mini_history['loss']) + 1)

axes[0].plot(epochs, mini_history['loss'], marker='o', label='Train')
axes[0].plot(epochs, mini_history['val_loss'], marker='o', label='Validation')
axes[0].set(xlabel='Epoch', ylabel='Loss', title='Mini Xception: Loss')
axes[0].set_xticks(range(1, 21, 2))
axes[0].legend()

axes[1].plot(epochs, mini_history['accuracy'], marker='o', label='Train')
axes[1].plot(epochs, mini_history['val_accuracy'], marker='o', label='Validation')
axes[1].set(xlabel='Epoch', ylabel='Accuracy', title='Mini Xception: Accuracy')
axes[1].set_xticks(range(1, 21, 2))
axes[1].legend()

plt.tight_layout()

mini_x_examples = mini_x_val[:8].to(device)
mini_xception.eval()
with torch.no_grad():
    mini_dog_scores = torch.sigmoid(mini_xception(mini_x_examples)).cpu().numpy()

fig, axes = plt.subplots(2, 4, figsize=(10, 5))
for i, ax in enumerate(axes.flat):
    ax.imshow(catdog_x_val[i].astype('uint8'))
    true_label = 'dog' if catdog_y_val[i] == 1 else 'cat'
    pred_label = 'dog' if mini_dog_scores[i] >= 0.5 else 'cat'
    ax.set_title(f'True: {true_label}, Pred: {pred_label}\nP(dog)={mini_dog_scores[i]:.2f}')
    ax.axis('off')
plt.tight_layout()

import matplotlib.cbook as cbook
from PIL import Image
from torchvision.models.detection import fasterrcnn_resnet50_fpn
from torchvision.models.detection import FasterRCNN_ResNet50_FPN_Weights

sample_path = cbook.get_sample_data('grace_hopper.jpg', asfileobj=False)
detection_image = Image.open(sample_path).convert('RGB')

detection_device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
weights = FasterRCNN_ResNet50_FPN_Weights.DEFAULT
detector = fasterrcnn_resnet50_fpn(weights=weights).to(detection_device)
detector.eval()

detection_transform = weights.transforms()
coco_categories = weights.meta['categories']

print('Detection device:', detection_device)
print('Sample image size:', detection_image.size)

def run_detection(image, score_threshold=0.70):
    x = detection_transform(image).unsqueeze(0).to(detection_device)
    with torch.no_grad():
        output = detector(x)[0]

    boxes = output['boxes'].detach().cpu().numpy()
    labels = output['labels'].detach().cpu().numpy()
    scores = output['scores'].detach().cpu().numpy()
    keep = scores >= score_threshold
    return boxes[keep], labels[keep], scores[keep]


def show_detection(ax, image, boxes, labels, scores, title):
    ax.imshow(image)
    ax.set_title(title)
    ax.axis('off')
    for box, label, score in zip(boxes, labels, scores):
        x1, y1, x2, y2 = box
        rect = plt.Rectangle((x1, y1), x2 - x1, y2 - y1,
                             fill=False, edgecolor='yellow', linewidth=2)
        ax.add_patch(rect)
        ax.text(x1, max(y1 - 5, 5),
                f"{coco_categories[label]} {score:.2f}",
                color='black', fontsize=9,
                bbox=dict(facecolor='yellow', alpha=0.8, edgecolor='none'))

boxes_07, labels_07, scores_07 = run_detection(detection_image, score_threshold=0.70)

fig, ax = plt.subplots(figsize=(6, 6))
show_detection(ax, detection_image, boxes_07, labels_07, scores_07,
               'Object detection (threshold = 0.70)')
plt.tight_layout()

for label, score in zip(labels_07, scores_07):
    print(f"{coco_categories[label]:>12s}: {score:.3f}")

boxes_03, labels_03, scores_03 = run_detection(detection_image, score_threshold=0.30)
boxes_08, labels_08, scores_08 = run_detection(detection_image, score_threshold=0.80)

fig, axes = plt.subplots(1, 2, figsize=(12, 6))
show_detection(axes[0], detection_image, boxes_03, labels_03, scores_03,
               'Threshold = 0.30')
show_detection(axes[1], detection_image, boxes_08, labels_08, scores_08,
               'Threshold = 0.80')
plt.tight_layout()

print('Number of detections at 0.30:', len(scores_03))
print('Number of detections at 0.80:', len(scores_08))