import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
import matplotlib.pyplot as plt
import numpy as np

# 加載 MNIST 數據集
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
x_train = x_train.reshape((x_train.shape[0], 28, 28, 1))
x_test = x_test.reshape((x_test.shape[0], 28, 28, 1))
y_train = to_categorical(y_train, 10)  # 10 是類別數（0-9的數字）
y_test = to_categorical(y_test, 10)

# 構建卷積神經網絡模型
model = models.Sequential()
# 卷積層 1：32 個 3x3 的卷積核，使用 ReLU 激活函數
model.add(layers.Conv2D(32, (3, 3), activatinotallow='relu', input_shape=(28, 28, 1)))
# 池化層：2x2 最大池化
model.add(layers.MaxPooling2D((2, 2)))
# 卷積層 2：64 個 3x3 的卷積核，使用 ReLU 激活函數
model.add(layers.Conv2D(64, (3, 3), activatinotallow='relu'))
# 池化層：2x2 最大池化
model.add(layers.MaxPooling2D((2, 2)))
# 卷積層 3：128 個 3x3 的卷積核，使用 ReLU 激活函數
model.add(layers.Conv2D(128, (3, 3), activatinotallow='relu'))
# 展平層：將二維數據展平為一維數據
model.add(layers.Flatten())
# 全連接層：128 個神經元，ReLU 激活函數
model.add(layers.Dense(128, activatinotallow='relu'))
# 輸出層：10 個神經元，對應 10 個類別（數字 0-9），softmax 激活函數
model.add(layers.Dense(10, activatinotallow='softmax'))

model.compile(optimizer='adam',  # 使用 Adam 優化器
              loss='categorical_crossentropy',  # 多類交叉熵損失函數
              metrics=['accuracy'])  # 評估標準：準確率

# 訓練模型
model.fit(x_train, y_train, epochs=5, batch_size=64, validation_data=(x_test, y_test))

# 評估模型性能
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f'測試集準確率: {test_acc:.4f}')
predictions = model.predict(x_test[:5])

# 可視化預測結果和圖像
for i in range(5):
    plt.subplot(1, 5, i+1)  
    plt.imshow(x_test[i].reshape(28, 28), cmap='gray')  
    plt.title(f"預測: {predictions[i].argmax()}")  
plt.show()

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

# 數據加載與預處理
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

# 加載 MNIST 數據集
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)

trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

# 定義卷積神經網絡模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)  # 1通道輸入，32通道輸出，3x3卷積核
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)  # 32通道輸入，64通道輸出，3x3卷積核
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)  # 64通道輸入，128通道輸出，3x3卷積核
        self.fc1 = nn.Linear(128 * 3 * 3, 128)  # 全連接層，輸入維度為卷積輸出的展開維度
        self.fc2 = nn.Linear(128, 10)  # 輸出層，10個數字類別

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.max_pool2d(x, 2)  # 2x2最大池化
        x = torch.relu(self.conv2(x))
        x = torch.max_pool2d(x, 2)  # 2x2最大池化
        x = torch.relu(self.conv3(x))
        x = torch.max_pool2d(x, 2)  # 2x2最大池化
        x = x.view(-1, 128 * 3 * 3)  # 展平
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 初始化模型、損失函數和優化器
model = CNN()
criterion = nn.CrossEntropyLoss()  # 使用交叉熵損失
optimizer = optim.Adam(model.parameters(), lr=0.001)  # 使用Adam優化器

# 訓練模型
num_epochs = 5
for epoch in range(num_epochs):
    model.train()  # 設置模型為訓練模式
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(trainloader, 0):
        optimizer.zero_grad()  # 清零梯度
        outputs = model(inputs)  # 計算模型輸出
        loss = criterion(outputs, labels)  # 計算損失
        loss.backward()  # 反向傳播
        optimizer.step()  # 更新參數
        running_loss += loss.item()

    print(f"Epoch {epoch+1}, Loss: {running_loss/len(trainloader)}")

print("Finished Training")

# 測試模型
model.eval()  # 設置模型為評估模式
correct = 0
total = 0
with torch.no_grad():  # 在測試時不計算梯度，減少內存消耗
    for inputs, labels in testloader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"Test Accuracy: {100 * correct / total:.2f}%")

# 獲取前 5 張圖片及其預測結果
dataiter = iter(testloader)
images, labels = dataiter.next()

# 獲取模型預測結果
model.eval()  # 設置模型為評估模式
outputs = model(images)
_, predicted = torch.max(outputs, 1)

# 顯示圖像和預測結果
fig, axes = plt.subplots(1, 5, figsize=(12, 3))
for i in range(5):
    ax = axes[i]
    ax.imshow(images[i].numpy().squeeze(), cmap='gray')  # 顯示圖像
    ax.set_title(f"Pred: {predicted[i].item()}\nTrue: {labels[i].item()}")
    ax.axis('off')

plt.show()