MNIST数据集简介
MNIST(Mixed National Institute of Standards and Technology database)是一个简单的机器视觉数据集，由几万张28x28像素的手写数字组成，这些图片仅有灰度值信息。
MNIST数据集的样例如图1所示：
该任务是对这些手写数字的图片进行识别分类，转成0-9一共10类。
Tensorflow相关代码说明
1. 首先需要将MNIST数据集导入，并查看MNIST数据的相关属性。
- 导入MNIST
# 从固定模块中导入
from tensorflow.examples.tutorials.mnist import input_data
# 下面所使用的方法中，第一个参数为MNIST在本地的位置，如果不存在便自动下载。
# one_hot的作用是为了得到一个仅有一个位置为1的一维数组，例如1对应[0,1,0,0,0,0,0,0,0,0]
mnist = input_data.read_data_sets("MNIST_data", one_hot = True)
- 查看MNIST相关属性
'''
MNIST数据集分为三个部分，训练数据集共55000张图片，验证集5000张图，测试集10000张图，像素值为28x28=784；
每个图片都有一个label与之对应，每个label包括10个由0和1组成的数组；
'''
# 查看训练集、验证集和测试集的样例数目
print ("Training data size: ", mnist.train.num_examples)
print ("Validating data size: ", mnist.validation.num_examples)
print ("Testing data size: ", mnist.test.num_examples)
# 查看三个数据集的维度信息
print ("Training images dimension: ", mnist.train.images.shape)
print ("Validating images dimension: ", mnist.validation.images.shape)
print ("Testing images dimension: ", mnist.test.images.shape)
print ("Training labels dimension: ", mnist.train.labels.shape)
print ("Validating labels dimension: ", mnist.validation.labels.shape)
print ("Testing labels dimension: ", mnist.test.labels.shape)
- 查看training数据集中某个成员的像素矩阵生成的一维数组和其属于的数字标签。
print ("Example training data: ", mnist.train.images[0] )
print ("Example training data label: ", mnist.train.labels[0])
2. 开始一个一层全连接网络训练
因为MNIST的像素大小不是很大，并且其空间相关性不是很大，所以可以使用全连接网络完成训练。
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data", one_hot = True)
# 使用下面这个函数可以将生成的会话自动注册成了交互性对话，更加的方便，对下面的参数初始化有作用
sess = tf.InteractiveSession()
# 定义输入训练数据的类型和维度大小，None代表无论大小为多少都可以
x = tf.placeholder(tf.float32, [None, 784])
# 将权重weights定义为全0
W1 = tf.Variable(tf.zeros([784, 10]))
# 将偏差bias定义为全0
b1 = tf.Variable(tf.zeros([10]))
# 对于多分类任务，softmax是较为常用的一个函数
y = tf.nn.softmax(tf.matmul(x, W1) + b1)
# 真实的label
y_ = tf.placeholder(tf.float32, [None, 10])
# 使用简单的交叉熵损失函数，reduce_mean函数将所有的数据进行了一个平均
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
# 定义训练的目标和方法，使用基础的随机梯度下降
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
# 初始化所有的函数
tf.global_variables_initializer().run()
for i in range(1000):
print("The %s-th steps" %(i + 1))
# 每个批次仅训练100个数据
x_batch, y_batch = mnist.train.next_batch(100)
# 将数据feed后训练
train_step.run({x: x_batch, y_: y_batch})
# argmax表示最大值的位置，equal用于表示两者是否相同，返回的结果为一个由True和False组成的数组
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
# 计算准确率，tf.cast将True和False变成浮点型
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# 将test数据feed进行测试
print(accuracy.eval({x: mnist.test.images, y_: mnist.test.labels}))
以上代码可以达到92%左右的准确率。
3. 增加一个隐藏层
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data", one_hot = True)
x = tf.placeholder(tf.float32, [None, 784])
# 增加一个dropout比例，训练的时候小于1，测试的时候等于1
keep_prob = tf.placeholder(tf.float32)
# 在这里的W1如果设置为全零的效果不够好，可能陷入了局部最优
W1 = tf.Variable(tf.truncated_normal([784, 300], stddev = 0.1))
b1 = tf.Variable(tf.zeros([300]))
hidden1 = tf.nn.relu(tf.matmul(x, W1) + b1)
# 隐藏层做一个dropout，避免过拟合，减少了参数的训练所以省时间
hidden1_drop = tf.nn.dropout(hidden1, keep_prob)
W2 = tf.Variable(tf.zeros([300, 10]))
b2 = tf.Variable(tf.zeros([10]))
y = tf.nn.softmax(tf.matmul(hidden1_drop, W2) + b2)
y_ = tf.placeholder(tf.float32, [None, 10])
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
# 这里使用了Ada
train_step = tf.train.AdagradOptimizer(0.3).minimize(cross_entropy)
tf.global_variables_initializer().run()
import time
time1 = time.time()
for i in range(3000):
print("The %s-th steps" %(i + 1))
x_batch, y_batch = mnist.train.next_batch(100)
# 设置dropout的比例为0.75，即只训练其1/4的参数
train_step.run({x: x_batch, y_: y_batch, keep_prob:0.75})
print("Done:%s" %(time.time() - time1))
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval({x: mnist.test.images, y_: mnist.test.labels, keep_prob:1.0}))
上述的代码可以达到98%的准确率。
4. 一个完整的代码（转自TensorFlow实战google深度学习框架）
mnist_inference.py
import tensorflow as tf
INPUT_NODE = 784
OUTPUT_NODE = 10
LAYER1_NODE = 500
def get_weight_variable(shape, regularizer):
weights = tf.get_variable("weights", shape, initializer=tf.truncated_normal_initializer(stddev=0.1))
if regularizer != None: tf.add_to_collection('losses', regularizer(weights))
return weights
def inference(input_tensor, regularizer):
with tf.variable_scope('layer1'):
weights = get_weight_variable([INPUT_NODE, LAYER1_NODE], regularizer)
biases = tf.get_variable("biases", [LAYER1_NODE], initializer=tf.constant_initializer(0.0))
layer1 = tf.nn.relu(tf.matmul(input_tensor, weights) + biases)
with tf.variable_scope('layer2'):
weights = get_weight_variable([LAYER1_NODE, OUTPUT_NODE], regularizer)
biases = tf.get_variable("biases", [OUTPUT_NODE], initializer=tf.constant_initializer(0.0))
layer2 = tf.matmul(layer1, weights) + biases
return layer2
mnist_train.py
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_inference
import os
BATCH_SIZE = 100
LEARNING_RATE_BASE = 0.8
LEARNING_RATE_DECAY = 0.99
REGULARIZATION_RATE = 0.0001
TRAINING_STEPS = 30000
MOVING_AVERAGE_DECAY = 0.99
MODEL_SAVE_PATH = "MNIST_model/"
MODEL_NAME = "mnist_model"
def train(mnist):
# 定义输入输出placeholder。
x = tf.placeholder(tf.float32, [None, mnist_inference.INPUT_NODE], name='x-input')
y_ = tf.placeholder(tf.float32, [None, mnist_inference.OUTPUT_NODE], name='y-input')
regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
y = mnist_inference.inference(x, regularizer)
global_step = tf.Variable(0, trainable=False)
# 定义损失函数、学习率、滑动平均操作以及训练过程。
variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
variables_averages_op = variable_averages.apply(tf.trainable_variables())
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
cross_entropy_mean = tf.reduce_mean(cross_entropy)
loss = cross_entropy_mean + tf.add_n(tf.get_collection('losses'))
learning_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE,
global_step,
mnist.train.num_examples / BATCH_SIZE, LEARNING_RATE_DECAY,
staircase=True)
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
with tf.control_dependencies([train_step, variables_averages_op]):
train_op = tf.no_op(name='train')
# 初始化TensorFlow持久化类。
saver = tf.train.Saver()
with tf.Session() as sess:
tf.global_variables_initializer().run()
for i in range(1, TRAINING_STEPS + 1):
xs, ys = mnist.train.next_batch(BATCH_SIZE)
_, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: xs, y_: ys})
if i % 1000 == 0:
print("After %d training step(s), loss on training batch is %g." % (step, loss_value))
saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step)
def main(argv=None):
mnist = input_data.read_data_sets("../../../datasets/MNIST_data", one_hot=True)
train(mnist)
if __name__ == '__main__':
main()
mnist_eval.py
import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_inference
import mnist_train
# 加载的时间间隔。
EVAL_INTERVAL_SECS = 10
def evaluate(mnist):
with tf.Graph().as_default() as g:
x = tf.placeholder(tf.float32, [None, mnist_inference.INPUT_NODE], name='x-input')
y_ = tf.placeholder(tf.float32, [None, mnist_inference.OUTPUT_NODE], name='y-input')
validate_feed = {x: mnist.validation.images, y_: mnist.validation.labels}
y = mnist_inference.inference(x, None)
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
variable_averages = tf.train.ExponentialMovingAverage(mnist_train.MOVING_AVERAGE_DECAY)
variables_to_restore = variable_averages.variables_to_restore()
saver = tf.train.Saver(variables_to_restore)
while True:
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state(mnist_train.MODEL_SAVE_PATH)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
accuracy_score = sess.run(accuracy, feed_dict=validate_feed)
print("After %s training step(s), validation accuracy = %g" % (global_step, accuracy_score))
else:
print('No checkpoint file found')
return
time.sleep(EVAL_INTERVAL_SECS)
def main(argv=None):
mnist = input_data.read_data_sets("../../../datasets/MNIST_data", one_hot=True)
evaluate(mnist)
if __name__ == '__main__':
main()
Pytorch相关代码说明
1、导入相关模块并加载数据
# 导入torch模块
import torch
import torch.nn as nn
# 加载Torchvision，用于图像处理的一个库，dataset中包含了相关数据
import torchvision.datasets as dset
# transforms可以将图像转换成张量形式
import torchvision.transforms as transforms
from torch.autograd import Variable
# 用于加载预先设计好的数据
import torch.utils.data as Data
import numpy as np
import matplotlib.pyplot as plt
# 这里定义一些所需要的参数
input_size = 784
hidden_size = 300
output_size = 10
batch_size = 100
learning_rate = 0.001
num_epochs = 5
'''
root: 数据集的位置；
train = True表示训练集, train = False表示测试集；
transform用于将PIL映像转换成特定的形式；
download=True会将数据集从Internet下载，并将其放在根目录中。如果数据集已经下载，则不会被下载。
'''
train_dataset = dset.MNIST(root = 'mnist_data', train = True, transform = transforms.ToTensor(), download = True)
test_dataset = dset.MNIST(root = 'mnist_data', train = False, transform = transforms.ToTensor())
2、传入所有数据
'''
dataset为加载数据的数据集；
batch_size为加载批训练的数据个数；
shuffle可以将每个epoch的数据重新打乱
'''
train_loader = torch.utils.data.DataLoader(dataset = train_dataset, batch_size = batch_size, shuffle = True)
test_loader = torch.utils.data.DataLoader(dataset = test_dataset, batch_size = batch_size, shuffle = False)
3、定义一个包含一个隐藏层的网络
class Net(nn.Module):
'''
激活函数使用ReLU
'''
def __init__(self, input_size, hidden_size, num_classes):
super(Net, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(hidden_size, num_classes)
def forward(self, x):
out = self.fc1(x)
out = self.relu(out)
out = self.fc2(out)
return out
# 使用上述类完成一个简单网络的定义
net = Net(input_size, hidden_size, output_size)
4、定义损失函数及其相关
# 使用经典的交叉熵函数
criterion = nn.CrossEntropyLoss()
# 使用torch.optim之前，需要用一个optimizer对象保存参数的状态，以便于计算参数的梯度信息，这里更新梯度的算法使用的是Adam
optimizer = torch.optim.Adam(net.parameters(), lr = learning_rate)
5、开始训练
for epoch in range(num_epochs):
for i, (images, labels) in enumerate(train_loader):
# print (Variable(images.view(100, 28 * 28)))
# 这里的-1和bacth_size有关，自适应参数，代码中结果就是100
images = Variable(images.view(-1, 28 * 28))
# batch_size个标签
labels = Variable(labels)
# 重置梯度信息
optimizer.zero_grad()
# feed整个图片数据集
outputs = net(images)
# 开始计算损失函数并进行后向传播
loss = criterion(outputs, labels)
loss.backward()
# 更新参数
optimizer.step()
# print(loss.data.item())
if(i + 1) % 100 == 0:
print('Epoch [%d/%d], Step [%d/%d], Loss: %.4f' % (epoch + 1, num_epochs, i + 1, len(train_dataset)//batch_size, loss.data.item()))
6、计算准确率
correct = 0
total = 0
# 按照批次进行计算测试集中正确的个数
for images, labels in test_loader:
images = Variable(images.view(-1, 28 * 28))
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum()
# 找到准确率
print('Accuracy: %d %%' % (100 * correct / total))
以上参数的设置并训练之后，识别率达到了97%。
扫一扫
494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
