FashionMNIST数据集及神经网络搭建

上一篇文章犯了个错误，图像不归一化的训练效果比归一化要好，也就是说无需除255.0

模型预测率达到80%以上。

from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
import seaborn as sns
import torch
import torch.nn as nn
from torch.optim import SGD
import torch.utils.data as Data
from torchvision import transforms
from torchvision.datasets import FashionMNIST
from icecream import ic
# ic.disable()

train_data=FashionMNIST(
    root='data/FashionMNIST',
    train=True,
    transform=transforms.ToTensor(),
    download=False
)
test_data=FashionMNIST(
    root='data/FashionMNIST',
    train=False,
    transform=transforms.ToTensor(),
    download=False
)
# train_data.data=train_data.data.type(torch.FloatTensor)/255.0
train_loader=Data.DataLoader(
    dataset=train_data,
    batch_size=64,
    shuffle=True,
)
test_loader=Data.DataLoader(
    dataset=test_data,
    batch_size=64,
    shuffle=True,
)

# # 可视化
# for step,(b_x,b_y) in enumerate(train_loader):
#     if step>0:
#         break
#     batch_x=b_x.squeeze().numpy()
#     batch_y=b_y.numpy()
#     class_label=train_data.classes
#     class_label[0]='T-shirt'
#     plt.figure(figsize=(12,5))
#     for i in np.arange(len(batch_y)):
#         plt.subplot(4,16,i+1)
#         plt.imshow(batch_x[i,:,:],cmap='gray')
#         plt.title(class_label[batch_y[i]],size=9)
#         plt.axis('off')
#         plt.subplots_adjust(wspace=0.5)
# plt.show()

# 搭建网络

class mNet(nn.Module):
    def __init__(self):
        super(mNet,self).__init__()
        self.conv1=nn.Sequential(
            nn.Conv2d(
                in_channels=1,
                out_channels=16,
                kernel_size=3,
                stride=1,
                padding=1
            ),
            nn.ReLU(),
            nn.AvgPool2d(kernel_size=2,stride=2)
        )
        self.conv2=nn.Sequential(
            nn.Conv2d(16,32,3,1,0),
            nn.ReLU(),
            nn.MaxPool2d(2,2)
        )
        self.fc=nn.Sequential(
            nn.Linear(32*6*6,256),
            nn.ReLU(),
            nn.Linear(256,128),
            nn.ReLU(),
            nn.Linear(128,10)
        )
    def forward(self,x):
        x=self.conv1(x)
        x=self.conv2(x)
        x=x.view(x.size(0),-1)
        output=self.fc(x)
        return output

mynet=mNet()
# ic(mynet)

epochs=10
criterion = nn.CrossEntropyLoss()
optimizer = SGD(mynet.parameters(), lr=0.01,momentum=0.5)
num_epochs = 10

for epoch in range(epochs):
    running_loss = 0.0
    cishu=f"{epoch+1}/{num_epochs}"
    for image,label in train_loader:
        optimizer.zero_grad()
        outputs=mynet(image)
        loss=criterion(outputs,label)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    loss_=running_loss/len(train_loader)

    mynet.eval()
    with torch.no_grad():
        acc=0
        for imaget,labelt in test_loader:
            outputs_test=mynet(imaget)
            _, predicted = torch.max(outputs_test, 1)
            acc+=accuracy_score(predicted,labelt)
    acc_=acc/len(test_loader)
    ic(cishu,loss_,acc_)