Tensorflow 笔记-全连接神经网络搭建

MNIST 数据集输出手写数字识别准确率 

输入手写数字输出识别结果 

全连接：每个神经元与前后相邻层的每一个神经元都有连接关系，输入是
特征，输出为预测的结果

前先向传播

定义输入、参数和输出。

# mnist_forward.py
import tensorflow as tf

INPUT_NODE = 28 * 28
OUTPUT_NODE = 10
LAYER1_NODE = 500

def get_weight(shape, regularizer):
    w = tf.Variable(tf.truncated_normal(shape, stddev=0.1))
    if regularizer != None:
        tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w

def get_bias(shape):
    b = tf.Variable(tf.zeros(shape))
    return b

def forward(x, regularizer):
    w1 = get_weight([INPUT_NODE, LAYER1_NODE], regularizer)
    b1 = get_bias([LAYER1_NODE])
    y1 = tf.nn.relu(tf.matmul(x, w1) + b1)

    w2 = get_weight([LAYER1_NODE, OUTPUT_NODE], regularizer)
    b2 = get_bias([OUTPUT_NODE])
    y = tf.matmul(y1, w2) + b2
    return y

反向传播

反向传播过程完成网络参数的训练

# coding:utf-8
# mnist_backward.py
# 反向传播过程实现利用训练数据集对神经网络模型训练，通过降低损失函数值，
# 实现网络模型参数的优化，从而得到准确率高且泛化能力强的神经网络模型

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_forward
import os
import mnist_generateds

BATCH_SIZE = 200
LEARNING_RATE_BASE = 0.1
LEARNING_RATE_DECAY = 0.99
REGULARIZER = 0.0001
STEPS = 50000
MOVING_AVERAGE_DECAY = 0.99
MODEL_SAVE_PATH = './model/'
MODEL_NAME = 'mnist_model'
train_num_examples = 60000

#def backward(mnist):
def backward():
    x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
    y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])
    y = mnist_forward.forward(x, REGULARIZER)  #前向传播函数
    global_step = tf.Variable(0, trainable=False)

    ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    cem = tf.reduce_mean(ce)
    loss = cem + tf.add_n(tf.get_collection('losses'))

    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
        train_num_examples / BATCH_SIZE,
        LEARNING_RATE_DECAY,
        staircase=True)

    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)

    ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
    ema_op = ema.apply(tf.trainable_variables())
    with tf.control_dependencies([train_step, ema_op]):
        train_op = tf.no_op(name='train')

    saver = tf.train.Saver()
    img_batch, label_batch = mnist_generateds.get_tfrecord(BATCH_SIZE, isTrain=True)

    with tf.Session() as sess:
        init_op = tf.global_variables_initializer()
        sess.run(init_op)

        ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH)
        if ckpt and ckpt.model_checkpoint_path:
            saver.restore(sess, ckpt.model_checkpoint_path)

        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess, coord=coord)

        for i in range(STEPS):
            #xs, ys = mnist.train.next_batch(BATCH_SIZE)
            xs, ys = sess.run([img_batch, label_batch])
            _, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: xs, y_: ys})
            if i % 1000 == 0:
                print("After %s training steps, loss on training batch is %s." % (step, loss_value))
                saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step)
        coord.request_stop()
        coord.join(threads)

def main():
    #mnist = input_data.read_data_sets("./data/", one_hot=True)
    #backward(mnist)
    backward()

if __name__ == '__main__':
    main()

预测

# coding:utf-8
# mnist_test.py

import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_backward
import mnist_forward

TEST_INTERVAL_SECS = 5


def test(mnist):
    with tf.Graph().as_default() as g:
        x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
        y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])
        y = mnist_forward.forward(x, None)

        # 实例化带滑动平均的saver对象
        ema = tf.train.ExponentialMovingAverage(mnist_backward.MOVING_AVERAGE_DECAY)
        ema_restore = ema.variables_to_restore()
        saver = tf.train.Saver(ema_restore)

        correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

        while True:
            with tf.Session() as sess:
                ckpt = tf.train.get_checkpoint_state(mnist_backward.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={x: mnist.test.images, y_: mnist.test.labels})
                    print("After %s training steps, test accuracy = %s" % (global_step, accuracy_score))

                else:
                    print("No checkpoint file found\n")

            time.sleep(TEST_INTERVAL_SECS)


def main():
    mnist = input_data.read_data_sets("./data/test/", one_hot=True)
    test(mnist)


if __name__ == '__main__':
    main()

 

输入真实图片预测结果

网络输入：一维数组（784 个像素点）

像素点：0-1 之间的浮点数（接近 0 越黑，接近 1 越白） 

网络输出：一维数组（十个可能性概率），数组中最大的那个元素所对应的索引号就是预测的结果

def application():  
    testNum = input("input the number of test pictures:") 
    for i in range(testNum): 
        testPic = raw_input("the path of test picture:") 
        testPicArr = pre_pic(testPic) 
        preValue = restore_model(testPicArr) 
        print "The prediction number is:", preValue  
注解： 
任务分成两个函数完成 
1）testPicArr = pre_pic(testPic)对手写数字图片做预处理 
2）preValue = restore_model(testPicArr) 将符合神经网络输入要求的图片喂
给复现的神经网络模型，输出预测值

制作数据集，实现特定应用

数据集生成读取文件

tfrecords 文件 

1）tfrecords：是一种二进制文件，可先将图片和标签制作成该格式的文件。使用 tfrecords 进行数据读取，会提高内存利用率。 

2）tf.train.Example: 用来存储训练数据。训练数据的特征用键值对的形式表示。 

如:‘ img_raw ’ :值 ‘ label ’ :值  值是 Byteslist/FloatList/Int64List 

3）SerializeToString( )：把数据序列化成字符串存储。 

生成 tfrecords 文件 

#coding:utf-8

import tensorflow as tf
import numpy as np
from PIL import Image
import os

image_train_path = './mnist_data_jpg/mnist_train_jpg_60000/'
label_train_path = './mnist_data_jpg/mnist_train_jpg_60000.txt'
tfRecord_train = './data/mnist_train.tfrecords'
image_test_path = './mnist_data_jpg/mnist_test_jpg_10000/'
label_test_path = './mnist_data_jpg/mnist_test_jpg_10000.txt'
tfRecord_test = './data/mnist_test.tfrecords'
data_path = './data'
resize_height = 28
resize_width = 28

def read_tfRecord(tfRecord_path):
    filename_queue = tf.train.string_input_producer([tfRecord_path])
    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(filename_queue)
    features = tf.parse_single_example(serialized_example,
                                       features={
                                           'label': tf.FixedLenFeature([10], tf.int64),
                                           'img_raw': tf.FixedLenFeature([], tf.string)
                                       })
    img = tf.decode_raw(features['img_raw'], tf.uint8)
    img.set_shape([28 * 28])
    img = tf.cast(img, tf.float32) * (1. / 255)
    label = tf.cast(features['label'], tf.float32)
    return img, label

def write_tfRecord(tfRecordNmae, image_path, label_path):
    writer = tf.python_io.TFRecordWriter(tfRecordNmae)
    num_pic = 0
    f = open(label_path, 'r')
    contents = f.readlines()
    f.close()
    for content in contents:
        value = content.split()
        img_path = image_path + value[0]
        img = Image.open(img_path)
        img_raw = img.tobytes()
        labels = [0] * 10
        labels[int(value[1])] = 1

        example = tf.train.Example(features=tf.train.Features(feature={
            'img_raw': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw])),
            'label': tf.train.Feature(int64_list=tf.train.Int64List(value=labels))
        }))
        writer.write(example.SerializeToString())
        num_pic += 1
        print "The number of picture:", num_pic
    writer.close()
    print "write tfrecord successfull"

def generate_tfRecord():
    isExists = os.path.exists(data_path)
    if not isExists:
        os.mkdir(data_path)
        print 'The directory was created successfully'
    else:
        print 'directory already exists'
    write_tfRecord(tfRecord_train, image_train_path, label_train_path)
    write_tfRecord(tfRecord_test, image_test_path, label_test_path)

def get_tfrecord(num, isTrain=True):
    if isTrain:
        tfRecord_path = tfRecord_train
    else:
        tfRecord_path = tfRecord_test

    img, label = read_tfRecord(tfRecord_path)
    img_batch, label_batch = tf.train.shuffle_batch([img, label],
                                                    batch_size=num,
                                                    num_threads=2,
                                                    capacity=1000,
                                                    min_after_dequeue=700)

    return img_batch, label_batch

def main():
    generate_tfRecord()

if __name__ == '__main__':
    main()