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
