# 1.导入依赖包
import torch
import torchvision
from torch import nn
from torchvision.datasets import ImageFolder
from torchvision.transforms import Resize, ToTensor, Compose
from torch.utils.data import DataLoader

batch_size = 2
num_epochs = 10

# 2.获取数据  227*227  Resize ToTensor
train_data = ImageFolder(root='dataset/flower_datas/train', transform=Compose([ToTensor(),
                                                                               Resize((227, 227))]))
test_data = ImageFolder(root='dataset/flower_datas/val', transform=Compose([ToTensor(),
                                                                            Resize((227, 227))]))
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=True)

# 查看数据集
import matplotlib.pyplot as plt

# 遍历每个迭代的数据，将其结果展示出来
for b, (imgs, targets) in enumerate(train_loader):
    # 获取第一个batch的图像
    if b == 1:
        # 将其进行展示
        fig, axes = plt.subplots(1, 2)
        # 遍历batch中的每个图像
        for i in range(batch_size):
            # 图像显示出来
            axes[i].imshow(imgs[i].permute(1, 2, 0))
            # 设置图像标题
            axes[i].set_title(targets[i].item())
        plt.show()
    elif b > 0:
        break


# 3.构建模型
class AlexNet_Model(nn.Module):
    # 2.2 定义构造方法__init__
    def __init__(self, num_classes):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(3, 96, 11, 4, 0),
            nn.ReLU(inplace=True),  # inplace=True 内存复用
            nn.MaxPool2d(3, 2),

            nn.Conv2d(96, 256, 5, 1, 2),
            nn.ReLU(inplace=True),  # inplace=True 内存复用
            nn.MaxPool2d(3, 2),

            nn.Conv2d(256, 384, 3, 1, 1),
            nn.ReLU(inplace=True),  # inplace=True 内存复用
            nn.Conv2d(384, 384, 3, 1, 1),
            nn.ReLU(inplace=True),  # inplace=True 内存复用
            nn.Conv2d(384, 256, 3, 1, 1),
            nn.ReLU(inplace=True),  # inplace=True 内存复用
            nn.MaxPool2d(3, 2),
        )
        self.fc = nn.Sequential(
            nn.Linear(9216, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),

            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),

            nn.Linear(4096, num_classes)
        )

    # 2.3 定义前向传播方法forward
    def forward(self, x):
        x = self.conv(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x


model = AlexNet_Model(num_classes=5)

# 4.模型训练(225原则)
def train():
    # 225----2(初始化参数) 损失+优化器
    loss_fn = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
    # 225----2（遍历-轮次-数据）
    for i in range(num_epochs):
        train_accuracy_total = 0
        train_correct = 0
        epoch_loss = 0
        iter = 0
        for b, (images, labels) in enumerate(train_loader):
            # 225----5（前，损失，梯度，反向，参数）
            # 1.前向传播
            output = model(images)
            # 2.损失计算
            loss = loss_fn(output, labels)
            # 3.梯度归零
            optimizer.zero_grad()
            # 4.反向传播  # w.grad b.grad
            loss.backward()
            # 5.参数更新
            optimizer.step()

            # 获取输出类别 pred==label
            _, pred = torch.max(output.data, dim=1)

            # 累积训练准确率
            train_accuracy_total += labels.size(0)
            train_correct += (pred == labels).cpu().sum().item()
            train_acc = train_correct / train_accuracy_total

            # 统计loss  每一个轮次平均loss
            epoch_loss += loss.item()
            iter += 1
            avg_loss = epoch_loss / iter

        print(f'epoch:{i+1},   loss:{avg_loss:.4f},   train accuracy:{train_acc:.3f}')


if __name__ == '__main__':
    train()

# 5.模型测试

# 6.模型部署