4.9-4.14后端组学习笔记

学习资料链接

pytorch学习网站：《PyTorch深度学习实践》完结合集

pytorch官方文档：PYTORCH DOCUMENTATION

pytorch框架博客系列：大纲与Pytorch框架学习

CCW

一、神经网络基本概念学习

1、epoch:将整个训练集进行一次训练

2、batch_size:每进行一次前向和后向传播所使用的样本数量

3、Iteration每进行一个batch的训练集是一次Iteration

4、optimizer:在后向传播时根据梯度对参数进行调整的函数

5、learning_rate:在optimizer中对参数改变速率进行调整的参数，net层中的参数数值变动率与lr成正比

二、数据集准备代码

def mnist_prepare():
    global train_loader,test_loader
    # Mnist digits dataset
    if not(os.path.exists('./mnist/')) or not os.listdir('./mnist/'):
    # not mnist dir or mnist is empyt dir
       DOWNLOAD_MNIST = True
       transform=transforms.Compose([
        transforms.toTensor(),
        transforms.Normalize((average[0],),(var[0],)),
        #transforms.Normalize((0.1307,), (0.3081,)),
])
       train_data = torchvision.datasets.MNIST(
         root='./mnist/',
         train=True, 
         transform=transform, 
         download=DOWNLOAD_MNIST,
         )
       test_data = torchvision.datasets.MNIST(root='./mnist/', train=False)
       train_loader = Data.DataLoader(dataset=train_data, batch_size=batch_size, shuffle=if_shuffle,num_workers=num_work)
       test_loader = Data.DataLoader(dataset=test_data, batch_size=batch_size, shuffle=False,num_workers=num_work)

pytorchvision.datasets中提供了丰富的经典数据集函数，同时为提供的数据划分好了test以及train部分。原项目使用的是mnist数据集。

pytorch为方便训练过程，定义了DataLoader类加载已有的数据集，shuffle表示数据集是否打乱，同时num_workers表示训练时由多少个线程进行处理。

二、训练部分代码

def train():
    running_loss=0
    for epo in range(epoch):
        for step, b_x, b_y in enumerate(train_loader,0): 
            b_x,b_y=b_x.to(device),b_y.to(device)
            optimzer.zero_grad()
            outputs=net(b_x)
            loss=loss_func(outputs,b_x)
            loss.backward()
            optimizer.step()
            running_loss+=loss.item()
            if step%300 == 0:
                print('[%d,%5d] loss:%.3f' % (epoch+1,step+1,running_loss/300))
                running_loss=0

每次将batch_size进行前向传播。计算损坏函数，对梯度清零，同时进行反向传播，更新模型参数。每训练300个数据输出一次当前损失值。

三、测试部分代码

def test():#for mnist and cifar10
    total=0
    correct=0
    with torch.no_grad():
        for data in test_loader:
            images,labels=data
            images,labels=images.to(device),labels.to(device)
            outputs=net(images)
            _,predicted=torch.max(outputs.data,dim=1)
            total+=labels.size(0)
            correct+=(predicted==labels).sum().item()
    print('accuracy on test_data= %d %%'%(100*correct/total))

根据给出的测试用例进行测试，并输出准确率

四、网络层的学习

1、全连接层

每个节点的输出为:y = xA^T + by=xAT+b，即线性增加函数

pytorch具体实现方法:torch.nn.Linear(in_features, out_features, bias=True)

in_features表示输入维度，out_features表示输出维度，bias表示是否对b进行学习

2、reshape层

变化输入数据矩阵的行和列，同时保证输入数据总数不变

实现方法,view()如x.view(-1,8),表示将输入矩阵变为8列，同时x根据调整

3、元素级相加层

类似矩阵的相加操作

实现方法:torch.add_().add_(),对不同的tensor进行数值上的相加

4、channel维度拼接层

实现方法:torch.concat(数据部分,dim)

将数据根据第dim维拼接在一起，应该要保证其他维度完全相同

五、打算新增的神经网络层

原先的卷积层实际上由3个层组成在一起，包括卷积层，激活层，池化层，将其进行拆分

1、卷积层(多种)

1维/2维/3维(设置在右边)

2、池化层(多种)

1维/2维/3维(设置在右边)

3、激活层(多种)

ReLU/Sigmoid/tanh/Leaky ReLU/ELU(设置在右边)

4、softmax层(多分类问题很有用)

5、RNN层(递归神经网络)

6、LSTM层(长周期神经网络)

六、新增的参数

根据对源代码阅读，认为可以新增以下static参数

1、测试集的选择

包括mnist,cifar10,stl10,svhn

2、是否打乱测试集,ifshuffle

3、CPU/GPU

4、Optimizer优化器删除其中的Optimizer,增加SGD,Momentum,RmsProp

七、新增经典模型（可做嵌套实现)

1、Lenet

class LenetNet(nn.Module):
    def __init__(self):
        super(LenetNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5) 
        self.conv2 = nn.Conv2d(6, 16, 5)  
        self.fc1   = nn.Linear(16*5*5, 120)  
        self.fc2   = nn.Linear(120, 84)
        self.fc3   = nn.Linear(84, 10)

def forward(self, x): 
    x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) 
    x = F.max_pool2d(F.relu(self.conv2(x)), 2) 
    x = x.view(x.size()[0], -1) 
    x = F.relu(self.fc1(x))
    x = F.relu(self.fc2(x))
    x = self.fc3(x)        
    return x

2、AlexNet

class AlexNet(nn.Module):
    def __init__(self, num_classes=1000):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(64, 192, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(192, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        self.classifier = nn.Sequential(
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, num_classes),
        )

def forward(self, x):
    x = self.features(x)
    x = x.view(x.size(0), 256 * 6 * 6)
    x = self.classifier(x)
    return x

KHJ

XTL