PyTorch入门精简资料（四）用PyTorch实现多层网络

Datawhale_Task4  用PyTorch实现多层网络 
1.引入模块，读取数据 
2.构建计算图（构建网络模型）
3.损失函数与优化器
4.开始训练模型
5.对训练的模型预测结果进行评估

用pytorch实现AlexNet

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torch.utils.data import Dataset
from torch.autograd import Variable
from PIL import Image
import numpy as np
import os
from datetime import datetime
from tensorboardX import SummaryWriter


class MyDataset(Dataset):
    def __init__(self, txt_path, transform = None, target_transform = None):
        fh = open(txt_path, 'r')
        imgs = []
        count=0
        for line in fh:
            line = line.rstrip()
            words = line.split()
            if count == 60001:
                print(count,'words----------------',words[0],int(words[1]))
            count += 1
            imgs.append((words[0], int(words[1])))

        self.imgs = imgs    # 最主要就是要生成这个list， 然后DataLoader中给index，通过getitem读取图片数据
        self.transform = transform
        self.target_transform = target_transform

    def __getitem__(self, index):
        fn, label = self.imgs[index]
        img = Image.open(fn).convert('L')     # 像素值 0~255，在transfrom.totensor会除以255，使像素值变成 0~1
        img = img.resize((224,224), Image.ANTIALIAS)

        if self.transform is not None:
            img = self.transform(img)   # 在这里做transform，转为tensor等等

        return img, label

    def __len__(self):
        return len(self.imgs)

def validate(net, data_loader, set_name, classes_name):
    """
    对一批数据进行预测，返回混淆矩阵以及Accuracy
    :param net:
    :param data_loader:
    :param set_name:  eg: 'valid' 'train' 'tesst
    :param classes_name:
    :return:
    """
    net.eval()
    cls_num = len(classes_name)
    conf_mat = np.zeros([cls_num, cls_num])

    for data in data_loader:
        images, labels = data
        images = Variable(images)
        labels = Variable(labels)

        outputs = net(images)
        outputs.detach_()

        _, predicted = torch.max(outputs.data, 1)

        # 统计混淆矩阵
        for i in range(len(labels)):