一般性神经网络分类MNIST数据集——借助tensorflow

1 数据介绍：MNIST数据集是机器学习领域中非常经典的一个数据集，由55000个训练样本和10000个测试样本组成，每个样本都是一张28 * 28像素的灰度手写数字图片,如图1所示。
2 运行环境:Python 3.7、PyCharm
3 算法介绍：本次实验采用的是一般神经网络算法，将权重W和偏置b定义为变量，并初始化为0向量，用交叉验证法计算损失函数，采用梯度下降最快的方法进行模型训练，采用步长为0.001，每次加载100个训练样本，然后执行一次sess，用tf.equal来检测预测是与否真实标签匹配，然后取平均值作为正确率。
4 最终结果:模型训练的最终结果如图所示，训练集精度达到91%，测试集精度达到92.3%。

5 源代码
5.1算法实现代码
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

# python的input_data这个API维护得不好 可能会报错 解决办法：自己下载或创建input_data.py文件 放在当前工程目录下 直接导入input_data

# from tensorflow.examples.tutorials.mnist import input_data import input_data

mnist = input_data.read_data_sets(‘data/’, one_hot=True)
n_input = 784
n_classes = 10

x = tf.placeholder(“float”, [None, n_input])
y = tf.placeholder(“float”, [None, n_classes])
stddev = 0.1
weight = tf.Variable(tf.zeros([784, 10]))
biases = tf.Variable(tf.zeros([10]))
print(“network ready”)

pred = tf.nn.softmax(tf.matmul(x, weight) + biases)
cost = -tf.reduce_sum(y * tf.log(pred)) # 损失函数
optm = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(cost)
corr = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
accr = tf.reduce_mean(tf.cast(corr, “float”))

init = tf.global_variables_initializer()
print(“functions ready”)

training_epochs = 20
batch_size = 100
display_step = 4
sess = tf.Session()
sess.run(init)
for epoch in range(training_epochs):
avg_cost = 0
total_batch = int(mnist.train.num_examples / batch_size)
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
feeds = {x: batch_xs, y: batch_ys}
sess.run(optm, feed_dict=feeds)
avg_cost = avg_cost / total_batch
# 结果输出
if (epoch + 1) % display_step == 0:
print(“Epoch: %03d/%03d cost: %.9f” % (epoch, training_epochs, avg_cost))
feeds = {x: batch_xs, y: batch_ys}
train_acc = sess.run(accr, feed_dict=feeds)
print(“train accuracy: %.3f” % train_acc)
feeds = {x: mnist.test.images, y: mnist.test.labels}
test_acc = sess.run(accr, feed_dict=feeds)
print(“test accuracy: %.3f” % test_acc)
print(“optimization finished”)
5.2 input_data代码
#!/usr/bin/env python

# -*- coding:utf-8 -*-

# 用于下载和读取MNIST数据的函数 from __future__ import absolute_import from __future__ import division from __future__ import print_function import gzip import os import tensorflow.python.platform import numpy from six.moves import urllib from six.moves import xrange # pylint: disable=redefined-builtin import tensorflow as tf SOURCE_URL = 'http://yann.lecun.com/exdb/mnist/'

# 若数据不存在，则从Yann的网站下载数据 def maybe_download(filename, work_directory): if not os.path.exists(work_directory): os.mkdir(work_directory) filepath = os.path.join(work_directory, filename) # 若指定路径不存在,则开始从原网站上下载 if not os.path.exists(filepath): filepath, _ = urllib.request.urlretrieve(SOURCE_URL + filename, filepath) statinfo = os.stat(filepath) print('Successfully downloaded', filename, statinfo.st_size, 'bytes.') return filepath def _read32(bytestream): dt = numpy.dtype(numpy.uint32).newbyteorder('>') return numpy.frombuffer(bytestream.read(4), dtype=dt)[0]

# 将图像提取到一个4维uint8类型的numpy数组[index, y, x, depth] def extract_images(filename): print('Extracting', filename) with gzip.open(filename) as bytestream: magic = _read32(bytestream) if magic != 2051: raise ValueError('Invalid magic number %d in MNIST image file: %s' % (magic, filename)) num_images = _read32(bytestream) rows = _read32(bytestream) cols = _read32(bytestream) buf = bytestream.read(rows * cols * num_images) data = numpy.frombuffer(buf, dtype=numpy.uint8) data = data.reshape(num_images, rows, cols, 1) return data

# 将类标签从标量转换为一个one-hot向量 def dense_to_one_hot(labels_dense, num_classes=10): num_labels = labels_dense.shape[0] index_offset = numpy.arange(num_labels) * num_classes labels_one_hot = numpy.zeros((num_labels, num_classes)) labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1 return labels_one_hot

# 将标签提取到一维uint8类型的numpy数组[index]中 def extract_labels(filename, one_hot=False): print('Extracting', filename) with gzip.open(filename) as bytestream: magic = _read32(bytestream) if magic != 2049: raise ValueError('Invalid magic number %d in MNIST label file: %s' % (magic, filename)) num_items = _read32(bytestream) buf = bytestream.read(num_items) labels = numpy.frombuffer(buf, dtype=numpy.uint8) if one_hot: return dense_to_one_hot(labels) return labels

# 构造DataSet类

# one_hot arg仅在fake_data为true时使用

# `dtype`可以是`uint8`，将输入保留为`[0,255]`，或`float32`以重新调整为[0,1]。 class DataSet(object): def __init__(self, images, labels, fake_data=False, one_hot=False, dtype=tf.float32): dtype = tf.as_dtype(dtype).base_dtype if dtype not in (tf.uint8, tf.float32): raise TypeError('Invalid image dtype %r, expected uint8 or float32' % dtype) if fake_data: self._num_examples = 10000 self.one_hot = one_hot else: assert images.shape[0] == labels.shape[0], ('images.shape: %s labels.shape: %s' % (images.shape, labels.shape)) self._num_examples = images.shape[0] # 将[num examples, rows, columns, depth]转换形状成[num examples, rows*columns] (assuming depth == 1) assert images.shape[3] == 1 images = images.reshape(images.shape[0], images.shape[1] * images.shape[2]) if dtype == tf.float32: # 将[0, 255]转换为[0.0, 1.0]. images = images.astype(numpy.float32) images = numpy.multiply(images, 1.0 / 255.0) self._images = images self._labels = labels self._epochs_completed = 0 self._index_in_epoch = 0 @property def images(self): return self._images @property def labels(self): return self._labels @property def num_examples(self): return self._num_examples @property def epochs_completed(self): return self._epochs_completed

# 从数据集返回下一个`batch_size`示例 def next_batch(self, batch_size, fake_data=False): if fake_data: fake_image = [1] * 784 if self.one_hot: fake_label = [1] + [0] * 9 else: fake_label = 0 return [fake_image for _ in xrange(batch_size)], [fake_label for _ in xrange(batch_size)] start = self._index_in_epoch self._index_in_epoch += batch_size # 完成一个epoch if self._index_in_epoch > self._num_examples: # 随机抽取数据 self._epochs_completed += 1 perm = numpy.arange(self._num_examples) numpy.random.shuffle(perm) self._images = self._images[perm] self._labels = self._labels[perm] # 开始下一个epoch start = 0 self._index_in_epoch = batch_size assert batch_size <= self._num_examples end = self._index_in_epoch return self._images[start:end], self._labels[start:end]

# 读取训练数据 def read_data_sets(train_dir, fake_data=False, one_hot=False, dtype=tf.float32): class DataSets(object): pass data_sets = DataSets() # 若fake_data为true则返回空数据 if fake_data: def fake(): return DataSet([], [], fake_data=True, one_hot=one_hot, dtype=dtype) data_sets.train = fake() data_sets.validation = fake() data_sets.test = fake() return data_sets # 训练和测试数据文件名 TRAIN_IMAGES = 'train-images-idx3-ubyte.gz' TRAIN_LABELS = 'train-labels-idx1-ubyte.gz' TEST_IMAGES = 't10k-images-idx3-ubyte.gz' TEST_LABELS = 't10k-labels-idx1-ubyte.gz' VALIDATION_SIZE = 5000 # 读取训练和测试数据 local_file = maybe_download(TRAIN_IMAGES, train_dir) train_images = extract_images(local_file) local_file = maybe_download(TRAIN_LABELS, train_dir) train_labels = extract_labels(local_file, one_hot=one_hot) local_file = maybe_download(TEST_IMAGES, train_dir) test_images = extract_images(local_file) local_file = maybe_download(TEST_LABELS, train_dir) test_labels = extract_labels(local_file, one_hot=one_hot) # 取前5000个作为验证数据 validation_images = train_images[:VALIDATION_SIZE] validation_labels = train_labels[:VALIDATION_SIZE] # 取前5000个以后的作为训练数据 train_images = train_images[VALIDATION_SIZE:] train_labels = train_labels[VALIDATION_SIZE:] # 定义训练,验证和测试 data_sets.train = DataSet(train_images, train_labels, dtype=dtype) data_sets.validation = DataSet(validation_images, validation_labels, dtype=dtype) data_sets.test = DataSet(test_images, test_labels, dtype=dtype) return data_sets