Graph_convolution_深度学习基础_利用mnist数据集实现mlp/cnn和自编码器
深度学习基础，利用mnist数据实现前反馈神经网络、卷积神经网络和自编码神经网络
提示：笔记来源来自网课，记录相关内容仅为后续复习方便，不是抄袭，不是抄袭！本节课程的代码记录于google网页的colaboratory中，命名方式是：graph_convolution_lesson20。
文章目录
1.加载数据
我们以MNIST数据集为例展示PyTorch中如何加载数据。MNIST数据集包含了10种不同手写的数字，即0到9。每张图片的标签也就是0到9中的某个数字。在这个数据集上，我们的任务预测图片对应哪个数字，所以这是一个分类问题。
torchvision中收集了多种数据集，我们可以直接调用这个工具包来下载我们需要的数据。
import matplotlib.pyplot as plt
from torchvision import datasets, transforms
import torch.nn as nn
import torch
from torch.nn import functional as F
#下载mnist数据集中的训练集，并保存到data文件夹
data_train = datasets.MNIST('data', train=True, download=True, transform=transforms.ToTensor())
# 加载MNIST数据集中的测试集
data_test = datasets.MNIST('data', train=False, download=True, transform=transforms.ToTensor())
#取出mnist中的第一张图
imag, label = data_train[0]
print(imag.size())
#torch.Size([1, 28, 28])
#可视化10个数据
for i in range(10):
imag, label = data_train[i]
imag = imag.numpy().squeeze() #将数据形状[1, 28, 28]变为[28, 28]
plt.subplot(1, 10, i+1)
plt.imshow(imag)
2.前馈神经网络
2.1. 搭建神经网络
2.1.1 用矩阵运算搭建神经网络层
因为神经网络里的运算其实就是在对矩阵进行操作，所以我们可以直接把网络用矩阵运算来表示。例如，给定输入x，一个线性层里的操作可以表示为: x’ = W x + b，其中W和b是这个线性层的参数。遵循面向对象编程（Object Oriented Programming，OOP）的原则，我们定义一个前馈神经网络的类，把我们需要的功能封装在其中。我们可以按照如下的逻辑来设计一个两层前馈神经网络：
class Linear(nn.Module): # 继承torch.nn.Module
def __init__(self, in_features, out_features):
super(Linear, self).__init__() # super()是表示调用父类的函数，这行代码相当于nn.Module.__init__(self)
self.weight = nn.Parameter(torch.randn(in_features, out_features))
self.bias = nn.Parameter(torch.randn(out_features))
def forward(self, x): # x是模型输入
x = x.mm(self.weight)
return x + self.bias
一些注意事项：
1、定义的Linear层需要继承nn.Module(torch.nn.Module)这个类。继承这个类之后，Linear这个类就能使用nn.Module类里定义好的函数。比如eval()、to()。 同时继承之后需要调用父类的初始化函数，即super(Linear, self).init()；
2、这里我们定义了两种参数，即self.weight和self.bias；
3、我们在定义parameter的时候，使用了torch.randn()，相当于对参数进行了初始化；
4、forward函数表示网络里的前向过程，得到输出。由于该类继承了nn.Module，当我们实例化该类后，如layer = Linear(…)，layer()就等于layer.forward()；
5、注意这里我们没有使用Softmax层，因为后面我们使用损失函数是torch.nn.CrossEntropyLoss，它里面已经包含了Softmax操作。
class MLP(nn.Module):
def __init__(self, in_features, hidden_features, out_features):
super(MLP, self).__init__()
self.in_features = in_features
self.layer1 = Linear(in_features, hidden_features) # 此处的Linear()是我们前面自定义的Linear类
self.layer2 = Linear(hidden_features, out_features)
def forward(self,x):
x = x.view(-1, self.in_features) # 将每张图片转换成向量
x = self.layer1(x)
x = F.relu(x) # 非线性激活层，ReLU函数
return self.layer2(x)
一些注意事项：
1、同样的，MLP这个类也需要继承nn.Module；
2、层与层之间我们需要一个非线性激活层，这里我们使用ReLU;
3、不是所有的MLP都需要这一步x = x.view(-1, self.in_features)，这里只是因为我们的输入数据是二维图片，我们需要将其变为向量。
2.1.2 用PyTorch里预定义的神经网络层
class MLP(nn.Module):
def __init__(self, in_features, hidden_features, out_features):
super(MLP, self).__init__()
self.in_features = in_features
self.layer1 = nn.Linear(in_features, hidden_features) # 此处的nn.Linear是PyTorch里定义的线性层
self.layer2 = nn.Linear(hidden_features, out_features)
def forward(self, x):
x = x.view(-1, self.in_features) # 将每张图片转换成向量
x = self.layer1(x)
x = F.relu(x) # 非线性激活层，ReLU函数
return self.layer2(x)
这个MLP同前面我们的手动定义的MLP的不同之处就在于，self.layer1和self.layer2是直接调用的PyTorch中定义好的nn.Linear。torch.nn中还定义了许多网络层，如卷积层、池化层等等。详情可见该链接。
2.1.3 神经网络的前向过程 Foward propogation
# 这里我们继续以第一张图片为例来演示神经网络的前向过程
# 我们首先实例化一个MLP，
img, label = data_train[0]
img = img.view(-1) # view(-1)表示把矩阵变成一维向量: (1,28,28) --> (784,)
feat_dim = len(img) # 计算输入的特征的维度（图片的维度）
num_classes = 10
model = MLP(in_features=feat_dim, hidden_features=256, out_features=num_classes)
print(model)
# 我们定义一个device变量，用于决定我们是否要把数据和模型放在GPU上运行
# 如果没有安装cuda的话，则使用cpu
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(device)
#'cuda'
将模型和数据放在device上（放在cpu或者gpu上）
model = model.to(device)
img = img.to(device)
output = model(img)
print(output)
模型输出的是一个长度为10的向量，我们可以认为每个元素代表对应类别的概率（这里是未进行归一化的概率）
# 我们取出其中最大值对应的类别，并和真实类别就行比较
predicted = output.argmax()
print('预测标签:', predicted.item(), '; 实际标签:', label)
#
# 我们取出其中最大值对应的类别，并和真实类别就行比较
predicted = output.argmax()
print('预测标签:', predicted.item(), '; 实际标签:', label)
#预测标签: 1 ; 实际标签: 5
2.2 训练神经网络
# 我们定义一个train函数来封装我们的训练过程
def train(model, data, num_epochs=5, learning_rate=1e-3, batch_size=32):
# 定义一个优化器，Adam优化器是梯度下降法的一个变种
optimizer = torch.optim.Adam(model.parameters(),
lr=learning_rate,
weight_decay=1e-5) # weight_decay表示L2正则项
# 把训练数据封装到DataLoader，这样便于我们以及选取batch以及打乱数据顺序
train_loader = torch.utils.data.DataLoader(data,
batch_size=batch_size,
shuffle=True)
# 定义损失函数
criterion = nn.CrossEntropyLoss()
for epoch in range(num_epochs):
loss_total = 0 # 定义一个loss_total变量来记录我们的loss变化
for data in train_loader:
# 梯度清零
optimizer.zero_grad()
img, label = data
img = img.to(device)
label = label.to(device)
# 前向传播和反向传播
output = model(img)
loss = criterion(output, label)
loss.backward()
# 优化参数
optimizer.step()
loss_total += loss.item()
print('Epoch: {}, Training Loss: {:.4f}'.format(epoch+1, loss_total))
train(model, data_train)
之前经常有报错：我们发现两个数据的device不同，建议同时放在cpu和cuda上。今天找到了原因：model和数据都需要.to(device)
测试函数
torch.no_grad() # 由于测试的时候不需要求导，可以暂时关闭autograd，提高速度，节约内存
def test(model, data, batch_size=128):
num_correct = 0 # 预测正确的图片数
num_total = 0 # 总共的图片数
test_loader = torch.utils.data.DataLoader(data,
batch_size=batch_size,
shuffle=False)
for data in test_loader: # 按batch取出测试集中的数据
img, label = data
img = img.to(device)
label = label.to(device)
output = model(img)
predicted = output.argmax(1)
num_total += len(label)
num_correct += (predicted == label).sum()
print('共有{}张图片，准确率为: {:.2f}%'.format(num_correct, 100 * num_correct / num_total))
test(model, data_train)
test(model, data_test)
3. 卷积神经网络 (CNN)
CNN可以被拆分为两个块（block）：特征提取部分（feature extractor）和分类部分（classification）。特征提取部分由多个卷积层构成，而分类部分由全连接层，即前馈神经网络。因此我们在定义CNN的时候也可以按照这么两部分来定义。
class CNN(nn.Module):
def __init__(self):
super(CNN, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 16, 3, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(16, 32, 3, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(32, 64, 7)
)
self.classifier = nn.Sequential(
nn.Linear(64, 120),
nn.ReLU(),
nn.Linear(120, 10)
)
def forward(self, x):
x = self.features(x)
x = x.view(-1, 64) # 铺平成向量，flattening
x = self.classifier(x)
return x
cnn卷积神经网络使用过程中要注意shape的变化
注意：
1、这里我们不再手动定义卷积层了，直接调用nn.Conv2d。对于nn.Conv2d(1, 16, 3, stride=2, padding=1)，其中1表示输入有1个通道（channel），16表示该层的输出有16个通道，stride=2表示卷积的平移步长是2，padding=1表示填充的幅度。
2、我们在定self.features的时候用到了nn.Sequential()，它是一个将多个网络层（和激活函数）结合起来的容器。用户可以通过nn.Sequential()来组合自己想搭建的神经网络。
model = CNN().to(device)
train(model, data_train) # 调用之前定义好的train函数
test(model, data_train)
test(model, data_test)
4. 自编码器 AutoEncoder
自编码器可以看作是一个试图从输出中重建输入的神经网络。它包含两个部分：编码器和解码器。编码器负责对输入进行编码，而解码器负责对编码后的信息进行重建。因此，作为一个示例，我们构建如下的由卷积神经网络构成的自编码器。
class Autoencoder(nn.Module):
def __init__(self):
super(Autoencoder, self).__init__()
# 我们用前面CNN中使用的特征提取部分当作这里的编码器encoder
self.encoder = nn.Sequential(
nn.Conv2d(1, 16, 3, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(16, 32, 3, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(32, 32, 7)
)
# 对于解码器decoder，我们需要使用nn.ConvTranspose2d
self.decoder = nn.Sequential(
nn.ConvTranspose2d(32, 32, 7),
nn.ReLU(),
nn.ConvTranspose2d(32, 16, 3, stride=2, padding=1, output_padding=1),
nn.ReLU(),
nn.ConvTranspose2d(16, 1, 3, stride=2, padding=1, output_padding=1),
nn.Sigmoid()
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
其中编码器由卷积层构成，解码器都由反卷积层构成。
autoencoder = Autoencoder().to(device) # device is either 'cpu' or 'cuda'
# 大体上跟前面train()函数一致，只是损失函数和输入有所不同
def train_autoencoder(model, data, num_epochs=10, learning_rate=1e-3, batch_size=32):
# 定义一个优化器，Adam优化器是梯度下降法的一个变种
optimizer = torch.optim.Adam(model.parameters(),
lr=learning_rate,
weight_decay=1e-5) # weight_decay表示L2正则项
# 把训练数据封装到DataLoader，这样便于我们以及选取batch以及打乱数据顺序
train_loader = torch.utils.data.DataLoader(data,
batch_size=batch_size,
shuffle=True)
# 定义损失函数，这里我们使用MSE loss来衡量输出和输入的差别
criterion = nn.MSELoss()
for epoch in range(num_epochs):
loss_total = 0 # 定义一个loss_total变量来记录我们的loss变化
for data in train_loader:
# 梯度清零
optimizer.zero_grad()
img, _ = data
img = img.to(device)
# 前向传播和反向传播
output = model(img)
loss = criterion(output, img)
loss.backward()
# 优化参数
optimizer.step()
loss_total += loss.item()
print('Epoch: {}, Training Loss: {:.4f}'.format(epoch+1, loss_total))
train_autoencoder(autoencoder, data_train)
# 观察生成的图片的质量
test_loader = torch.utils.data.DataLoader(data_test,
batch_size=8,
shuffle=False)
for i, data in enumerate(test_loader):
img, _ = data
autoencoder = autoencoder.to('cpu')
img_new = autoencoder(img).detach().numpy()
img = img.numpy()
plt.figure(figsize=(8, 2))
for j in range(8):
plt.subplot(2, 8, j+1)
plt.imshow(img_new[j].squeeze())
plt.subplot(2, 8, 8+j+1)
plt.imshow(img[j].squeeze())
if i >= 2:
break
DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。
更多推荐
0
0- 0
已为社区贡献1条内容
所有评论(0)