【AI 成长笔记】DNN 为什么不适合做图像识别？

import torch
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 定义图像预处理：调整大小、转换为 Tensor、归一化
transform = transforms.Compose([
    transforms.Resize((150, 150)),    # 调整图像为 150x150
    transforms.ToTensor(),            # 转换为 Tensor
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])

# 加载数据集
train_data = datasets.ImageFolder(root='data/train', transform=transform)
test_data = datasets.ImageFolder(root='data/test', transform=transform)

train_loader = DataLoader(train_data, batch_size=32, shuffle=True)
test_loader = DataLoader(test_data, batch_size=32, shuffle=False)

import torch.nn as nn
import torch.optim as optim

class DNN(nn.Module):
    def __init__(self):
        super(DNN, self).__init__()
        self.fc1 = nn.Linear(150*150*3, 512)  # 第一层，全连接层
        self.fc2 = nn.Linear(512, 512)          # 第二层，全连接层
        self.fc3 = nn.Linear(512, 1)            # 输出层

    def forward(self, x):
        # 将输入图像展平成一维向量
        x = x.view(-1, 150*150*3)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = torch.sigmoid(self.fc3(x))
        return x

model_dnn = DNN()

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 第一卷积层：输入通道 3，输出通道 32，使用 3x3 卷积核，边缘填充1
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        # 第二卷积层：输入 32，输出 64
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        # 池化层：2x2 最大池化
        self.pool = nn.MaxPool2d(2, 2)
        # 全连接层：假设经过两次池化后，图像尺寸变为 37x37（150/2/2 ≈ 37）
        self.fc1 = nn.Linear(64 * 37 * 37, 512)
        self.fc2 = nn.Linear(512, 1)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))  # 卷积 + 激活 + 池化
        x = self.pool(torch.relu(self.conv2(x)))  # 卷积 + 激活 + 池化
        x = x.view(-1, 64 * 37 * 37)  # 展平
        x = torch.relu(self.fc1(x))
        x = torch.sigmoid(self.fc2(x))
        return x

model_cnn = CNN()

def train_model(model, train_loader, criterion, optimizer, epochs=5):
    model.train()
    for epoch in range(epochs):
        running_loss = 0.0
        correct = 0
        total = 0
        for inputs, labels in train_loader:
            optimizer.zero_grad()
            outputs = model(inputs)
            labels = labels.unsqueeze(1).float()  # 转换标签格式为浮点型
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            running_loss += loss.item()
            predicted = (outputs > 0.5).float()
            correct += (predicted == labels).sum().item()
            total += labels.size(0)
        print(f"Epoch [{epoch+1}/{epochs}], Loss: {running_loss/len(train_loader):.4f}, Accuracy: {correct/total:.4f}")

# 定义损失函数和优化器（分别对两个模型）
criterion = nn.BCELoss()

optimizer_dnn = optim.Adam(model_dnn.parameters(), lr=0.001)
optimizer_cnn = optim.Adam(model_cnn.parameters(), lr=0.001)

print("Training DNN Model:")
train_model(model_dnn, train_loader, criterion, optimizer_dnn, epochs=5)

print("Training CNN Model:")
train_model(model_cnn, train_loader, criterion, optimizer_cnn, epochs=5)