09-01 Tensorflow1基本使用

目录

• Tensorflow基本使用
• 一、确认安装Tensorflow
• 二、获取MNIST数据集
• 三、使用Tensorflow训练——Softmax回归
• 四、使用Tensorflow训练——卷积神经网络
  • 4.1 构建网络组件
  • 4.2 定义网络结构
  • 4.3 训练模型
• 五、使用Tensorflow进行可视化

更新、更全的《机器学习》的更新网站，更有python、go、数据结构与算法、爬虫、人工智能教学等着你：https://www.cnblogs.com/nickchen121/p/11686958.html

Tensorflow基本使用

一、确认安装Tensorflow

import tensorflow as tf

a = tf.constant(10)
b = tf.constant(32)
sess = tf.Session()
print(sess.run(a+b))

42

二、获取MNIST数据集

# 获取MNIST数据集
# 获取地址：https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/examples/tutorials/mnist/input_data.py
# Copyright 2015 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Functions for downloading and reading MNIST data."""
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/'

def maybe_download(filename, work_directory):
    """Download the data from Yann's website, unless it's already here."""
    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]

def extract_images(filename):
    """Extract the images into a 4D uint8 numpy array [index, y, x, depth]."""
    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

def dense_to_one_hot(labels_dense, num_classes=10):
    """Convert class labels from scalars to one-hot vectors."""
    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

def extract_labels(filename, one_hot=False):
    """Extract the labels into a 1D uint8 numpy array [index]."""
    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

class DataSet(object):
    def __init__(self, images, labels, fake_data=False, one_hot=False,
                 dtype=tf.float32):
        """Construct a DataSet.
        one_hot arg is used only if fake_data is true.  `dtype` can be either
        `uint8` to leave the input as `[0, 255]`, or `float32` to rescale into
        `[0, 1]`.
        """
        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]
            # Convert shape from [num examples, rows, columns, depth]
            # to [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:
                # Convert from [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

    def next_batch(self, batch_size, fake_data=False):
        """Return the next `batch_size` examples from this data set."""
        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
        if self._index_in_epoch > self._num_examples:
            # Finished epoch
            self._epochs_completed += 1
            # Shuffle the data
            perm = numpy.arange(self._num_examples)
            numpy.random.shuffle(perm)
            self._images = self._images[perm]
            self._labels = self._labels[perm]
            # Start next 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()
    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)
    validation_images = train_images[:VALIDATION_SIZE]
    validation_labels = train_labels[:VALIDATION_SIZE]
    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

三、使用Tensorflow训练——Softmax回归

# 使用Tensorflow 训练——Softmax回归
import time
import tensorflow as tf

# 读取 MNIST 数据集，分成训练数据和测试数据
mnist = read_data_sets('MNIST_data/', one_hot=True)

# 设置训练数据 x，连接权重 W 和偏置 b
x = tf.placeholder('float', [None, 784])
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

# 对 x 和 W 进行内积运算后把结果传递给 softmax 函数，计算输出 y
y = tf.nn.softmax(tf.matmul(x, W)+b)

# 设置期望输出 y_
y_ = tf.placeholder('float', [None, 10])

# 计算交叉熵代价函数
cross_entropy = -tf.reduce_sum(y_*tf.log(y))

# 使用梯度下降法最小化交叉熵代价函数
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

# 初始化所有参数
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

st = time.time()

# 迭代训练
for i in range(1000):
    # 选择训练数据(mini-batch)
    batch_xs, batch_ys = mnist.train.next_batch(100)
    # 训练处理
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

# 进行测试，确认实际输出和期望输出是否一致
correct_prediction = tf.equal(tf.argmax(y, -1), tf.argmax(y_, 1))
softmax_time = time.time()-st

# 计算准确率
accuary = tf.reduce_mean(tf.cast(correct_prediction, 'float'))
print('准确率：%s' % sess.run(accuary, feed_dict={
      x: mnist.test.images, y_: mnist.test.labels}))
softmax_acc = sess.run(accuary, feed_dict={
                       x: mnist.test.images, y_: mnist.test.labels})

Extracting MINIST_data/train-images-idx3-ubyte.gz
Extracting MINIST_data/train-labels-idx1-ubyte.gz
Extracting MINIST_data/t10k-images-idx3-ubyte.gz
Extracting MINIST_data/t10k-labels-idx1-ubyte.gz
准确率：0.9191

四、使用Tensorflow训练——卷积神经网络

4.1 构建网络组件

# 构建网络组件
import time
import tensorflow as tf

def weight_variable(shape):
    """
    初始化连接权重
    """
    # truncated_normal()根据指定的标准差创建随机数
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

def bias_variable(shape):
    """
    初始化偏置
    """
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

def conv2d(x, W):
    """
    构建卷积层
    x: 输入数据，四维参数——批大小、高度、宽度和通道数
    W: 卷积核参数，四维参数——卷积核高度、卷积核宽度、输入通道数和输出通道数
    """
    # strides设置卷积核移动的步长，strides=[1,2,2,1]步长为2
    # padding设置是否补零填充，padding='SAME'为填充；padding='VALID'为不填充
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
    """
    构建池化层
    x: 输入数据，四维参数——批大小、高度、宽度和通道数
    """
    # ksize设置池化窗口的大小，四维参数——批大小、高度、宽度和通道数
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

# 读取MNIST数据集
mnist = read_data_sets('MNIST_data', one_hot=True)
# 输入数据，二维数据shape=[批大小, 数据维度]
x = tf.placeholder('float', shape=[None, 784])
# 期望输出
y_ = tf.placeholder('float', shape=[None, 10])

# 修改数据集格式（批大小*28*28*通道数），即把二维数据修改成四维张量[-1,28,28,1]
x_image = tf.reshape(x, [-1, 28, 28, 1])

4.2 定义网络结构

# 定义网络结构
# 第1个卷积层，weight_variable([卷积核高度，卷积核宽度，通道数，卷积核个数])
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])

# 激活函数及池化
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1)+b_conv1)
h_pool = max_pool_2x2(h_conv1)

# 第2个卷积层
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])

# 激活函数及池化
h_conv2 = tf.nn.relu(conv2d(h_pool, W_conv2)+b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

# 设置全连接层的参数
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])

# 全连接层
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1)+b_fc1)

# Dropout
keep_prob = tf.placeholder('float')
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

# 设置全连接层的参数
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])

# softmax 函数
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2)+b_fc2)

# 误差函数，交叉熵代价函数
cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))

4.3 训练模型

# 训练模型
# 训练方法
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

# 测试方法
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))

# 创建训练用的会话
sess = tf.Session()

# 初始化参数
sess.run(tf.global_variables_initializer())

st = time.time()

# 迭代处理
for i in range(1000):
    # 选择训练数据(mini-batch)
    batch = mnist.train.next_batch(50)
    # 训练处理
    _, loss_value = sess.run([train_step, cross_entropy], feed_dict={
                             x: batch[0], y_: batch[1], keep_prob: 0.5})

    # 测试
    if i % 100 == 0:
        acc = sess.run(accuracy, feed_dict={
            x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.})
        print(f'卷积神经网络迭代 {i} 次的准确率：{acc}')

print(f'Softmax回归训练时间：{softmax_time}')
print(f'卷积神经网络训练时间：{time.time()-st}')

# 测试
acc = sess.run(accuracy, feed_dict={
               x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.})

print(f'Softmax回归准确率：{softmax_acc}')
print(f'卷积神经网络准确率：{acc}')

卷积神经网络迭代 0 次的准确率：0.08910000324249268
卷积神经网络迭代 100 次的准确率：0.8474000096321106
卷积神经网络迭代 200 次的准确率：0.9085000157356262
卷积神经网络迭代 300 次的准确率：0.9266999959945679
卷积神经网络迭代 400 次的准确率：0.9399999976158142
卷积神经网络迭代 500 次的准确率：0.9430999755859375
卷积神经网络迭代 600 次的准确率：0.953499972820282
卷积神经网络迭代 700 次的准确率：0.9571999907493591
卷积神经网络迭代 800 次的准确率：0.9599999785423279
卷积神经网络迭代 900 次的准确率：0.9613000154495239
Softmax回归训练时间：2.030284881591797
卷积神经网络训练时间：394.48987913131714
Softmax回归准确率：0.9190999865531921
卷积神经网络准确率：0.9670000076293945

五、使用Tensorflow进行可视化

# 使用Tensorflow进行可视化
# Copyright 2015 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Functions for downloading and reading MNIST data."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import gzip
import os
import time
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/'

def maybe_download(filename, work_directory):
    """Download the data from Yann's website, unless it's already here."""
    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]

def extract_images(filename):
    """Extract the images into a 4D uint8 numpy array [index, y, x, depth]."""
    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

def dense_to_one_hot(labels_dense, num_classes=10):
    """Convert class labels from scalars to one-hot vectors."""
    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

def extract_labels(filename, one_hot=False):
    """Extract the labels into a 1D uint8 numpy array [index]."""
    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

class DataSet(object):
    def __init__(self, images, labels, fake_data=False, one_hot=False,
                 dtype=tf.float32):
        """Construct a DataSet.
        one_hot arg is used only if fake_data is true.  `dtype` can be either
        `uint8` to leave the input as `[0, 255]`, or `float32` to rescale into
        `[0, 1]`.
        """
        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]
            # Convert shape from [num examples, rows, columns, depth]
            # to [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:
                # Convert from [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

    def next_batch(self, batch_size, fake_data=False):
        """Return the next `batch_size` examples from this data set."""
        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
        if self._index_in_epoch > self._num_examples:
            # Finished epoch
            self._epochs_completed += 1
            # Shuffle the data
            perm = numpy.arange(self._num_examples)
            numpy.random.shuffle(perm)
            self._images = self._images[perm]
            self._labels = self._labels[perm]
            # Start next 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()
    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)
    validation_images = train_images[:VALIDATION_SIZE]
    validation_labels = train_labels[:VALIDATION_SIZE]
    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

def weight_variable(shape):
    """
    初始化连接权重
    """
    # truncated_normal()根据指定的标准差创建随机数
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

def bias_variable(shape):
    """
    初始化偏置
    """
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

def conv2d(x, W):
    """
    构建卷积层
    x: 输入数据，四维参数——批大小、高度、宽度和通道数
    W: 卷积核参数，四维参数——卷积核高度、卷积核宽度、输入通道数和输出通道数
    """
    # strides设置卷积核移动的步长，strides=[1,2,2,1]步长为2
    # padding设置是否补零填充，padding='SAME'为填充；padding='VALID'为不填充
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
    """
    构建池化层
    x: 输入数据，四维参数——批大小、高度、宽度和通道数
    """
    # ksize设置池化窗口的大小，四维参数——批大小、高度、宽度和通道数
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

# 读取MNIST数据集
mnist = read_data_sets('MNIST_data', one_hot=True)

# # 输入数据，二维数据shape=[批大小, 数据维度]
# x = tf.placeholder('float', shape=[None, 784])
# # 期望输出
# y_ = tf.placeholder('float', shape=[None, 10])

# 通过as_default()生成一个计算图
with tf.Graph().as_default():
    # 设置数据集和期望输出
    x = tf.placeholder('float', shape=[None, 784], name='Input')
    y_ = tf.placeholder('float', shape=[None, 10], name='GroundTruth')
    # 修改数据集格式（批大小*28*28*通道数），即把二维数据修改成四维张量[-1,28,28,1]
    x_image = tf.reshape(x, [-1, 28, 28, 1])

    # 第1个卷积层，weight_variable([卷积核高度，卷积核宽度，通道数，卷积核个数])
    W_conv1 = weight_variable([5, 5, 1, 32])
    b_conv1 = bias_variable([32])

    # 激活函数及池化
    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1)+b_conv1)
    h_pool = max_pool_2x2(h_conv1)

    # 第2个卷积层
    W_conv2 = weight_variable([5, 5, 32, 64])
    b_conv2 = bias_variable([64])

    # 激活函数及池化
    h_conv2 = tf.nn.relu(conv2d(h_pool, W_conv2)+b_conv2)
    h_pool2 = max_pool_2x2(h_conv2)

    # 设置全连接层的参数
    W_fc1 = weight_variable([7*7*64, 1024])
    b_fc1 = bias_variable([1024])

    # 全连接层
    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1)+b_fc1)

    # Dropout
    keep_prob = tf.placeholder('float')
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

    # 设置全连接层的参数
    W_fc2 = weight_variable([1024, 10])
    b_fc2 = bias_variable([10])

    # softmax 函数
    # y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2)+b_fc2)
    with tf.name_scope('Output') as scope:
        y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2)+b_fc2)

    # 误差函数，交叉熵代价函数
    # cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
    with tf.name_scope('xentropy') as scope:
        cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
        # tf.summary.scalar()输出训练情况
        ce_summ = tf.summary.scalar('cross_entropy', cross_entropy)

    # 训练方法
    # train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
    with tf.name_scope('train') as scope:
        train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

    # 测试方法
    # correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
    # accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))
    with tf.name_scope('test') as scope:
        correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))
        accuracy_summary = tf.summary.scalar('accuracy', accuracy)

    # 创建训练用的会话
    sess = tf.Session()

    # 初始化参数
    sess.run(tf.global_variables_initializer())

    # 训练情况的输出设置（新增）
    # 把设置的所有输出操作合并为一个操作
    summary_op = tf.summary.merge_all()
    # tf.summary.FileWriter()保存训练数据，graph_def为图（网络结构）
    summary_writer = tf.summary.FileWriter('MNIST_data', graph_def=sess.graph_def)

    st = time.time()

    # 迭代处理
    for i in range(1000):
        # 选择训练数据(mini-batch)
        batch = mnist.train.next_batch(50)
        # 训练处理
        _, loss_value = sess.run([train_step, cross_entropy], feed_dict={
                                 x: batch[0], y_: batch[1], keep_prob: 0.5})

        # 测试
        if i % 100 == 0:
            #         acc = sess.run(accuracy, feed_dict={
            #             x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.})
            # summary_op输出训练数据，accuracy进行测试
            result = sess.run([summary_op, accuracy], feed_dict={
                x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.})
            # 传递summary_op
            summary_str = result[0]
            # 传递acc
            acc = result[1]
            # add_summary()输出summary_str的内容
            summary_writer.add_summary(summary_str, i)
            print(f'卷积神经网络迭代 {i} 次的准确率：{acc}')

    print(f'卷积神经网络训练时间：{time.time()-st}')

    # 测试
    acc = sess.run(accuracy, feed_dict={
                   x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.})

    print(f'卷积神经网络准确率：{acc}')

Extracting MNIST_data/train-images-idx3-ubyte.gz
Extracting MNIST_data/train-labels-idx1-ubyte.gz
Extracting MNIST_data/t10k-images-idx3-ubyte.gz
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
WARNING:tensorflow:Passing a `GraphDef` to the SummaryWriter is deprecated. Pass a `Graph` object instead, such as `sess.graph`.
卷积神经网络迭代 0 次的准确率：0.11810000240802765
卷积神经网络迭代 100 次的准确率：0.8456000089645386
卷积神经网络迭代 200 次的准确率：0.9088000059127808
卷积神经网络迭代 300 次的准确率：0.9273999929428101
卷积神经网络迭代 400 次的准确率：0.935699999332428
卷积神经网络迭代 500 次的准确率：0.9404000043869019
卷积神经网络迭代 600 次的准确率：0.9490000009536743
卷积神经网络迭代 700 次的准确率：0.951200008392334
卷积神经网络迭代 800 次的准确率：0.95660001039505
卷积神经网络迭代 900 次的准确率：0.9592999815940857
卷积神经网络训练时间：374.29131293296814
卷积神经网络准确率：0.963699996471405

终端运行：tensorboard --logdir ~/Desktop/jupyter/deepLearning/图解深度学习-tensorflow/MNIST_data Starting Tensor- Board on port 6006

• 其中--logdir指定的是完整路径目录