深度学习（一）深层神经网络的搭建【附实例代码】 |
您所在的位置：网站首页 › 神经网络如何设计 › 深度学习（一）深层神经网络的搭建【附实例代码】 |
深度学习（一）深层神经网络的搭建【附实例代码】
|
深层神经网络
文章目录
深层神经网络1. MNIST 数据集2. 多分类问题2.1 softmax2.2 交叉熵
3. 数据加载4. 搭建网络并训练
前面一篇我们简要介绍了神经网络的一些基本知识，同时也是示范了如何用神经网络构建一个复杂的非线性二分类器，更多的情况神经网络适合使用在更加复杂的情况，比如图像分类的问题，下面我们用深度学习的入门级数据集 MNIST 手写体分类来说明一下更深层神经网络的优良表现。
1. MNIST 数据集
mnist 数据集是一个非常出名的数据集，基本上很多网络都将其作为一个测试的标准，其来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST)。 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员，一共有 60000 张图片。 测试集(test set) 也是同样比例的手写数字数据，一共有 10000 张图片。 每张图片大小是 28 x 28 的灰度图，如下： 所以我们的任务就是给出一张图片，我们希望区别出其到底属于 0 到 9 这 10 个数字中的哪一个。 2. 多分类问题前面我们讲过二分类问题，现在处理的问题更加复杂，是一个 10 分类问题，统称为多分类问题，对于多分类问题而言，我们的 loss 函数使用一个更加复杂的函数，叫交叉熵。 2.1 softmax提到交叉熵，我们先讲一下 softmax 函数，前面我们见过了 sigmoid 函数，如下 s ( x ) = 1 1 + e − x s(x)=\frac{1}{1+e^{-x}} s(x)=1+e−x1 可以将任何一个值转换到 0 ~ 1 之间，当然对于一个二分类问题，这样就足够了，因为对于二分类问题，如果不属于第一类，那么必定属于第二类，所以只需要用一个值来表示其属于其中一类概率，但是对于多分类问题，这样并不行，需要知道其属于每一类的概率，这个时候就需要 softmax 函数了。
对于网络的输出 z 1 , z 2 , ⋯ z k z_1, z_2, \cdots z_k z1,z2,⋯zk，我们首先对他们每个都取指数变成 e z 1 , e z 2 , ⋯ , e z k e^{z_1}, e^{z_2}, \cdots, e^{z_k} ez1,ez2,⋯,ezk，那么每一项都除以他们的求和，也就是 z i → e z i ∑ j = 1 k e z j zi \rightarrow \frac{e^{z_i}}{\sum_{j=1}^{k} e^{z_j}} zi→∑j=1kezjezi 如果对经过 softmax 函数的所有项求和就等于 1，所以他们每一项都分别表示属于其中某一类的概率。 2.2 交叉熵交叉熵衡量两个分布相似性的一种度量方式，前面讲的二分类问题的 loss 函数就是交叉熵的一种特殊情况，交叉熵的一般公式为 c r o s s − e n t r o p y ( p , q ) = E p [ − log q ] = − 1 m ∑ x p ( x ) log q ( x ) cross-entropy(p,q)=E_p[- \log{q}]= -\frac{1}{m} {\textstyle \sum_{x}} p(x) \log{q(x)} cross−entropy(p,q)=Ep[−logq]=−m1∑xp(x)logq(x) 对于二分类问题，我们可以写成： − 1 m ∑ i = 1 m ( y i log s i g m o i d ( x i ) + ( 1 − y i ) log ( 1 − s i g m o i d ( x i ) ) -\frac{1}{m} \sum_{i=1}^m (y^{i} \log sigmoid(x^{i}) + (1 - y^{i}) \log (1 - sigmoid(x^{i})) −m1i=1∑m(yilogsigmoid(xi)+(1−yi)log(1−sigmoid(xi)) 下面我们直接用 mnist 举例，讲一讲深度神经网络 3. 数据加载 import numpy as np import torch from torchvision.datasets import mnist # 导入 pytorch 内置的 mnist 数据 import torch.nn as nn # 使用内置函数下载 mnist 数据集 train_set = mnist.MNIST('./data', train=True, download=True) test_set = mnist.MNIST('./data', train=False, download=True) a_data, a_label = train_set[0] a_data
这里的读入的数据是 PIL 库中的格式，我们可以非常方便地将其转换为 numpy array a_data = np.array(a_data, dtype='float32') print(a_data.shape) (28, 28)这里我们可以看到这种图片的大小是 28 x 28 里面的 0 就表示黑色，255 表示白色 对于神经网络，我们第一层的输入就是 28 x 28 = 784，所以必须将得到的数据我们做一个变换，使用 reshape 将他们拉平成一个一维向量: def data_tf(x): x = np.array(x, dtype='float32') / 255 x = (x - 0.5) / 0.5 # 标准化，这个技巧之后会讲到 x = x.reshape((-1,)) # 拉平 x = torch.from_numpy(x) return x train_set = mnist.MNIST('./data', train=True, transform=data_tf, download=True) # 重新载入数据集，申明定义的数据变换 transform test_set = mnist.MNIST('./data', train=False, transform=data_tf, download=True) 再看一个例子： a, a_label = train_set[0] print(a.shape) print(a_label) torch.Size([784]) 5 from torch.utils.data import DataLoader # 使用 pytorch 自带的 DataLoader 定义一个数据迭代器 # 训练数据64个为一个batch train_data = DataLoader(train_set, batch_size=64, shuffle=True) # 测试数据128个为一个batch test_data = DataLoader(test_set, batch_size=128, shuffle=False)使用这样的数据迭代器是非常有必要的，如果数据量太大，就无法一次将他们全部读入内存，所以需要使用 python 迭代器，每次生成一个批次的数据 a, a_label = next(iter(train_data)) # 打印出一个批次的数据大小 print(a.shape) print(a_label.shape) torch.Size([64, 784]) torch.Size([64]) 4. 搭建网络并训练 定义四层神经网络： import torch.nn.functional as F class my_net(nn.Module): def __init__(self): super(my_net,self).__init__() self.fc1=nn.Linear(784,400) self.fc2=nn.Linear(400,200) self.fc3=nn.Linear(200,100) self.fc4=nn.Linear(100,10) def forward(self,x): x=F.relu(self.fc1(x)) x=F.relu(self.fc2(x)) x=F.relu(self.fc3(x)) return x net= my_net() print(net) my_net( (fc1): Linear(in_features=784, out_features=400, bias=True) (fc2): Linear(in_features=400, out_features=200, bias=True) (fc3): Linear(in_features=200, out_features=100, bias=True) (fc4): Linear(in_features=100, out_features=10, bias=True) ) 定义损失 criterion = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(net.parameters(), 1e-1) # 使用随机梯度下降，学习率 0.1 开始训练 losses = [] acces = [] eval_losses = [] eval_acces = [] for e in range(20): train_loss = 0 train_acc = 0 #net.train() for im, label in train_data: im = im label = label # 前向传播 out = net(im) loss = criterion(out, label) # 反向传播 optimizer.zero_grad() loss.backward() optimizer.step() # 记录误差 train_loss += loss.item() # 计算分类的准确率 _, pred = out.max(1) num_correct = (pred == label).sum().item() acc = num_correct / im.shape[0] train_acc += acc losses.append(train_loss / len(train_data)) acces.append(train_acc / len(train_data)) # 在测试集上检验效果 eval_loss = 0 eval_acc = 0 #net.eval() # 将模型改为预测模式 for im, label in test_data: im = im label = label out = net(im) loss = criterion(out, label) # 记录误差 eval_loss += loss.item() # 记录准确率 _, pred = out.max(1) num_correct = (pred == label).sum().item() acc = num_correct / im.shape[0] eval_acc += acc eval_losses.append(eval_loss / len(test_data)) eval_acces.append(eval_acc / len(test_data)) print('epoch: {}, Train Loss: {:.6f}, Train Acc: {:.6f}, Eval Loss: {:.6f}, Eval Acc: {:.6f}' .format(e, train_loss / len(train_data), train_acc / len(train_data), eval_loss / len(test_data), eval_acc / len(test_data))) epoch: 0, Train Loss: 0.525348, Train Acc: 0.847848, Eval Loss: 0.271614, Eval Acc: 0.910799 epoch: 1, Train Loss: 0.166704, Train Acc: 0.950043, Eval Loss: 0.141554, Eval Acc: 0.957081 epoch: 2, Train Loss: 0.115453, Train Acc: 0.964186, Eval Loss: 0.118387, Eval Acc: 0.962025 epoch: 3, Train Loss: 0.090116, Train Acc: 0.971948, Eval Loss: 0.091326, Eval Acc: 0.972409 epoch: 4, Train Loss: 0.072630, Train Acc: 0.977412, Eval Loss: 0.115369, Eval Acc: 0.962816 epoch: 5, Train Loss: 0.060656, Train Acc: 0.981177, Eval Loss: 0.075957, Eval Acc: 0.975178 epoch: 6, Train Loss: 0.051926, Train Acc: 0.983625, Eval Loss: 0.073108, Eval Acc: 0.976958 epoch: 7, Train Loss: 0.044283, Train Acc: 0.985441, Eval Loss: 0.065057, Eval Acc: 0.979430 epoch: 8, Train Loss: 0.037566, Train Acc: 0.987807, Eval Loss: 0.081599, Eval Acc: 0.974387 epoch: 9, Train Loss: 0.032722, Train Acc: 0.989322, Eval Loss: 0.067153, Eval Acc: 0.977650 epoch: 10, Train Loss: 0.027649, Train Acc: 0.991238, Eval Loss: 0.059325, Eval Acc: 0.982694 epoch: 11, Train Loss: 0.023471, Train Acc: 0.992437, Eval Loss: 0.071508, Eval Acc: 0.979529 epoch: 12, Train Loss: 0.019128, Train Acc: 0.994270, Eval Loss: 0.076266, Eval Acc: 0.977749 epoch: 13, Train Loss: 0.017213, Train Acc: 0.994453, Eval Loss: 0.083231, Eval Acc: 0.976365 epoch: 14, Train Loss: 0.015447, Train Acc: 0.995203, Eval Loss: 0.059105, Eval Acc: 0.983584 epoch: 15, Train Loss: 0.013146, Train Acc: 0.996252, Eval Loss: 0.067653, Eval Acc: 0.980320 epoch: 16, Train Loss: 0.012747, Train Acc: 0.996269, Eval Loss: 0.298849, Eval Acc: 0.915645 epoch: 17, Train Loss: 0.186615, Train Acc: 0.962054, Eval Loss: 0.082878, Eval Acc: 0.974288 epoch: 18, Train Loss: 0.043081, Train Acc: 0.985158, Eval Loss: 0.074628, Eval Acc: 0.977551 epoch: 19, Train Loss: 0.033418, Train Acc: 0.988956, Eval Loss: 0.072757, Eval Acc: 0.978441 画出 loss 曲线和 准确率曲线 import matplotlib.pyplot as plt %matplotlib inline plt.title('train loss') plt.plot(np.arange(len(losses)), losses);
可以看到我们的三层网络在训练集上能够达到 99.9% 的准确率，测试集上能够达到 98.20% 的准确率 参考：深度学习入门 |
【本文地址】
今日新闻 |
推荐新闻 |