09-01 Tensorflow1基本使用
目錄html
更新、更全的《機器學習》的更新網站，更有python、go、數據結構與算法、爬蟲、人工智能教學等着你：http://www.javashuo.com/article/p-vozphyqp-cm.htmlpython
Tensorflow基本使用
1、確認安裝Tensorflow
import tensorflow as tf a = tf.constant(10) b = tf.constant(32) sess = tf.Session() print(sess.run(a+b))
42
2、獲取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
3、使用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
4、使用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
5、使用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 6006web
- 其中--logdir指定的是完整路徑目錄
相關文章
- 1. 09-01 Tensorflow1基本使用
- 2. 0901
- 3. TensorFlow1
- 4. 0901做業
- 5. win10+anaconda+tensorflow1+pycharm
- 6. Tensorflow1.x與Tensorflow2.0
- 7. 基本使用
- 8. 【python編程】tensorflow1.x庫常用語法
- 9. Git使用-基本使用
- 10. Anaconda默認Tensorflow2.x版本，命令安裝Tensorflow1.x版本
- 更多相關文章...
- • Redis基本安裝和使用 - Redis教程
- • Lua 基本語法 - Lua 教程
- • Kotlin學習（二）基本類型
- • Kotlin學習（一）基本語法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
