pytorch02——FashionMNIST时装分类

前文概要：最近参加了DataWhale的组队学习任务，pytorch进阶组队，有一些深度学习基础，先来总结第一个项目实战任务，FashionMNIST时装分类任务，该数据集是一个比较成熟的数据集，可以直接在torch.utils.data的dataset包中直接下载即可。

整体超参数的设置：

## 配置其他超参数，如batch_size, num_workers, learning rate, 以及总的epochs
batch_size = 256
num_workers = 0   # 对于Windows用户，这里应设置为0，否则会出现多线程错误
lr = 1e-4
epochs = 20

1.以下操作完成数据集的下载和参数设置

from torch.utils.data import Dataset,DataLoader
train_data = datasets.FashionMNIST(root='./data', train=True, download=True, transform=data_transform)
test_data = datasets.FashionMNIST(root='./data', train=False, download=True, transform=data_transform)

2.初始的数据集中的数据是PIL格式的图像，需要先Resize 28*28尺寸的tensor

data_transform = transforms.Compose([
   # transforms.ToPILImage(),   # 这一步取决于后续的数据读取方式，如果使用内置数据集则不需要
 # 上一行代码中由于我们并没有使用自定义数据集，所以不需要这一步
    transforms.Resize(image_size),
    transforms.ToTensor(),
    transforms.Normalize(0.5,0.5)#这一行代码加不加都可，加了之后对
                           #数据进行归一化，更利于训练并且准确度有所提高
])

3.加载数据中的数据

#读取数据
train_loader = DataLoader(train_data,batch_size=batch_size,shuffle=True,num_workers=num_workers,drop_last=True)
test_loader = DataLoader(test_data,batch_size=batch_size,shuffle=False,num_workers=num_workers)

---

通过以上三步完成对数据的下载，加载，超参数的配置。数据部分完成了
4.设置网络模型

# 设置网络模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 32, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, stride=2),
            nn.Dropout(0.3),
            nn.Conv2d(32, 64, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, stride=2),
            nn.Dropout(0.3)
        )
        sequential = nn.Sequential(nn.Linear(64 * 4 * 4, 512), nn.ReLU(), nn.Linear(512, 10))
        self.fc = sequential
    def forward(self, x):
        x = self.conv(x)
        x = x.view(-1, 64 * 4 * 4)
        x = self.fc(x)
        # x = nn.functional.normalize(x)
        return x
model = Net()
model = model.cuda()

5.设置损失函数和优化器

# 设置损失函数
criterion = nn.CrossEntropyLoss()

# 优化器
optimizer = optim.Adam(model.parameters(),lr=0.001)

6.网络训练函数

def train(epoch):
    model.train()
    train_loss = 0
    for data, label in train_loader:
        data,label = data.cuda(),label.cuda()
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output,label)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()*data.size(0)
    train_loss = train_loss/len(train_loader.dataset) # 计算损失值
    print('Epoch: {} \tTraining Loss: {:.6f}'.format(epoch, train_loss)) 

7.验证网络性能函数

def val(epoch):
    model.eval()
    val_loss = 0
    gt_labels = []
    pred_labels = []
    with torch.no_grad(): #验证数据集的时候不需要计算图的生成
        for data,label in test_loader:
            data,label = data.cuda(),label.cuda()
            output = model(data)
            preds = torch.argmax(output,1)
            gt_labels.append(label.cpu().data.numpy())
            pred_labels.append(preds.cpu().data.numpy())
            loss = criterion(output,label)
            val_loss += loss.item()*data.size(0)
        val_loss = val_loss/len(test_loader.dataset)
        gt_labels,pred_labels = np.concatenate(gt_labels),np.concatenate(pred_labels)
        acc = np.sum(gt_labels==pred_labels)/len(pred_labels)
        print('Epoch: {} \tValidation Loss: {:.6f}, Accuracy: {:6f}'.format(epoch, val_loss, acc))

8.调用训练函数和验证函数

# 共计训练二十轮函数
for epoch in range(1,epochs+1):
    train(epoch)
    val(epoch)
    print(f"第{epoch}轮训练结束")

9.保存训练模型

save_path = "./FashionModel1.pkl"
torch.save(model,save_path)

项目概览：

训练二十轮下的网络识别准确度：