利用pytorch搭建三层全连接神经网络，cifar10验证集上正确率55.3%

import torch
from torch.autograd import Variable
import numpy as np
import matplotlib.pyplot as plt
from torch.utils.data import sampler
%matplotlib inline
from torch import nn,optim
from torch.utils.data import DataLoader
from torchvision import datasets,transforms

NUM_TRAIN = 49000

#定义基本网络结构
# class Fc_Net(nn.Module):
#     def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
#         super(Fc_Net,self).__init__()
#         self.layer1=nn.Sequential(nn.Linear(in_dim,n_hidden_1),nn.BatchNorm1d(n_hidden_1),nn.ReLU(True))
#         self.layer2=nn.Sequential(nn.Linear(n_hidden_1,n_hidden_2),nn.BatchNorm1d(n_hidden_2),nn.ReLU(True))
#         self.layer3=nn.Sequential(nn.Linear(n_hidden_2,out_dim))
#     def forword(self,x):
#         x=self.layer1(x)
#         x=self.layer2(x)
#         x=self.layer3(x)
#         return x
    
class Fc_Net(nn.Module):
    def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
        super(Fc_Net,self).__init__()
        self.layer1=nn.Sequential(nn.Linear(in_dim,n_hidden_1),nn.BatchNorm1d(n_hidden_1),nn.ReLU(True))
        self.layer2=nn.Sequential(nn.Linear(n_hidden_1,n_hidden_2),nn.BatchNorm1d(n_hidden_2),nn.ReLU(True))
        self.layer3=nn.Sequential(nn.Linear(n_hidden_2,out_dim))
    def forword(self,x):
        x=self.layer1(x)
        x=self.layer2(x)
        x=self.layer3(x)
        return x
    
class CifarNet(nn.Module):
    
    def __init__(self, input_size, hidden1_size, hidden2_size, num_classes):
        
        super(CifarNet, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden1_size)
        self.relu1 = nn.ReLU()
        self.fc2 = nn.Linear(hidden1_size, hidden2_size)
        self.relu2 = nn.ReLU()
        self.fc3 = nn.Linear(hidden2_size, num_classes)  
    
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu1(out)
        out = self.fc2(out)
        out = self.relu2(out)
        out = self.fc3(out)
        return out

# Our model

#定义一些超参数
#import net
batch_size=128
learning_rate=1e-3
#预处理
transform=transforms.Compose(
[transforms.ToTensor(),transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])#将图像转化成tensor，然后继续标准化，就是减均值，除以方差

#读取数据集
# train_dataset=datasets.CIFAR10(root='./data',train=True,transform=data_tf,download=True)
# test_dataset=datasets.CIFAR10(root='./data',train=False,transform=data_tf)
train_dataset = datasets.CIFAR10(root='./vclab/datasets',
                                             train=True,
                                             transform=transform,
                                             download=True)
val_dataset = datasets.CIFAR10(root='./vclab/datasets',
                                           train = True,
                                           download = True,
                                           transform = transform)
test_dataset = datasets.CIFAR10(root='./vclab/datasets',
                                            train=False,
                                            transform=transforms.ToTensor())

#使用内置的函数导入数据集
# train_loader=DataLoader(train_dataset,batch_size=batch_size,shuffle=True)
# test_loader=DataLoader(test_dataset,batch_size=batch_size,shuffle=False)
train_loader = DataLoader(dataset=train_dataset,
                          batch_size=batch_size,
                          sampler=sampler.SubsetRandomSampler(range(NUM_TRAIN)))
loader_val = DataLoader(val_dataset,
                        batch_size=64,
                        sampler=sampler.SubsetRandomSampler(range(NUM_TRAIN, 50000)))
test_loader = DataLoader(dataset=test_dataset,
                         batch_size=batch_size,
                         shuffle=False)

#导入网络，定义损失函数和优化方法
model=CifarNet(3072,128,64,10)
if torch.cuda.is_available():#是否使用cuda加速
    model=model.cuda()
criterion=nn.CrossEntropyLoss()
optimizer=optim.Adam(model.parameters(),weight_decay=0.001)
# import net
n_epochs=50
train_loss = []
test_loss = [] 
train_accuracy = []
val_accuracy = []
test_accuracy = []
for epoch in range(n_epochs):
    running_loss=0.0
    running_correct=0
    print("epoch {}/{}".format(epoch,n_epochs))
    print("-"*10)
    n=0
    train_acc=0
    val_acc=0
    train_total=0
    val_total=0
    for data in train_loader:
        img,label=data
        img=img.view(img.size(0),-1)
#         img=img.T
#         print(type(img))
#         print(np.shape(img))
        if torch.cuda.is_available():
            img=img.cuda()
            label=label.cuda()
        else:
            img=Variable(img)
            label=Variable(label)
        model.train()
        out=model(img)#得到前向传播的结果
#         predict=torch.max(out,1)[1].data.squeeze()
        _, predicted = torch.max(out.data, 1)
        train_acc += (predicted == label).sum().item()
        train_total += label.size(0)
#         sum_acc+=(predict==label).sum().item()/label.size(0)
#         n+=1
        loss=criterion(out,label)#得到损失函数
        print_loss=loss.item()
        optimizer.zero_grad()#归0梯度
        loss.backward()#反向传播
        optimizer.step()#优化
        running_loss+=loss.item()
#         epoch+=1
#         if epoch%50==0:
#             print('epoch:{},loss:{:.4f}'.format(epoch,loss.data.item()))
    train_accuracy.append(train_acc/train_total)
    print(max(train_accuracy))
    for data in loader_val:
        img,label=data
        img=img.view(img.size(0),-1)
        if torch.cuda.is_available():
            img=Variable(img,volatile=True).cuda()
            label=Variable(label,volatile=True).cuda()
        else:
            img=Variable(img,volatile=True)
            label=Variable(label,volatile=True)
        model.eval()
        out=model(img)
        loss=criterion(out,label)
#         eval_loss+=loss.item()*label.size(0)
#         predict=torch.max(out,1)[1].data.squeeze()
        _, predicted = torch.max(out.data, 1)
        val_acc += (predicted == label).sum().item()
        val_total += label.size(0)

#         sum_acc+=(predict==label).sum().item()/label.size(0)
#         n+=1
#         val_acc+=num_correct.item()
    val_accuracy.append(val_acc/val_total)
    print(max(val_accuracy))