预处理
- tensorflow库内包含mnist，直接加载mnist数据并转为一维数组形式。直接加载的是.gz格式。
import tensorflow.examples.tutorials.mnist.input_data as input_data # 加载mnist数据
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # one_hot为是否将标签转为一维数组形式逻辑回归
- 加载数据
- 图片转为一维数组
- 建立模型：softmax回归模型
- w为可变n*784二维矩阵，b为10数组
- w、b变量初始化为0
- y=w*x+b
- 损失函数：交叉熵
- 训练模型
- 模型评估
# -*- coding: utf-8 -*-
# 读取数据图片，预处理
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data # 加载mnist数据
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # one_hot为是否将标签转为一维数组形式
# 构建softmax回归模型
sess = tf.InteractiveSession() # 交互作用类（不需用在计算前构建整个图）
# 占位符（x和y_）
x = tf.placeholder("float", shape=[None, 784]) # 浮点数，二维数组（第一维大小不定，第二维是784）
y_ = tf.placeholder("float", shape=[None, 10]) # 用于代表对应某一MNIST图片的类别
# 变量（w权重和b偏置）
w = tf.Variable(tf.zeros([784, 10])) # 784*10的可变参数值二维矩阵
b = tf.Variable(tf.zeros([10])) # 10维的向量
sess.run(tf.initialize_all_variables()) # 初始化所有变量为0
# 类别预测与损失函数
y = tf.nn.softmax(tf.matmul(x, w) + b) # 计算每个分类的softmax概率值
cross_entropy = -tf.reduce_sum(y_ * tf.log(y)) # 损失函数（目标类别和预测类别之间的交叉熵）
# 训练模型
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy) # 最速下降法，步长为0.01
for i in range(1000):
batch = mnist.train.next_batch(50) # 每步加载50个样本
train_step.run(feed_dict={x: batch[0], y_: batch[1]}) # feed_dict被每次训练的数据替代
# 模型评估
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) # 检测预测值与实际值是否匹配
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) # 将布尔数组转化为正确率
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels})) # 输出最终正确率
神经网络
- 加载数据集
- 定义函数：
- 初始化函数
- 神经元模型：mlp、逻辑回归、s函数
- 照片转一维数组、确定测试、训练的照片、标签
- 占位符：定义张量
- 调用神经元模型函数
- 计算代价函数、构造优化器、求行最值
- 初始化变量、迭代100次
- 打印正确率
# -*- coding: utf-8 -*-
# 神经网络
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data # 加载数据
def init_weight(shape): # 初始化
return tf.Variable(tf.random_normal(shape, stddev=0.01)) # (stddev是标准差，random_normal是正态分布的随机输出值)张量的可变随机值
def model(X, w_h, w_o): # 神经元模型
h = tf.nn.sigmoid(tf.matmul(X, w_h)) # 这是一个基本的mlp，两个堆栈逻辑回归 # X和w_h矩阵相乘，s函数
return tf.matmul(h, w_o) # 在最后不使用softmax，因为代价函数 # 返回h和w_o的两矩阵之积
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # 把数据转换为一位数组的格式
trX = mnist.train.images # 训练的图片
trY = mnist.train.labels # 训练的标签
teX = mnist.test.images # 测试的图片
teY = mnist.test.labels # 测试的标签
# 占位符
X = tf.placeholder("float", [None, 784]) # 第一维长度不定，第二维长度为784的二维矩阵 浮点数 784=28*28
Y = tf.placeholder("float", [None, 10]) # 输出的10种情况
w_h = init_weight([784, 625]) # 创建特征变量 # 调用上边自定义的函数，对矩阵进行初始化
w_o = init_weight([625, 10]) # 初始化
py_x = model(X, w_h, w_o) # 调用上边的自定义函数，
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y)) # 计算代价
train_op = tf.train.GradientDescentOptimizer(0.05).minimize(cost) # 构造优化器 # 0.05的学习率使代价函数最小
predict_op = tf.argmax(py_x, 1) # 求行中最大值
# 在会话中启动图表
with tf.Session() as sess:
# 初始化所有变量
tf.global_variables_initializer().run() # 添加用于初始化变量的节点，
for i in range(100): # 迭代100次
for start, end in zip(range(0, len(trX)), range(128, len(trX)+1, 128)): # zip函数是将两个列表打包为元组的列表，元素个数与最短列表一致
sess.run(train_op, feed_dict={X: trX[start: end], Y: trY[start:end]}) # 跑
print(i, np.mean(np.argmax(teY, axis=1) ==
sess.run(predict_op, feed_dict={X: teX}))) # mean函数是求平均值，打印预测和实际相同时的概率
# for i in range(100):
# for start, end in zip(range(0, 1000), range(128, 1000+1, 128)):
# sess.run(train_op, feed_dict={X: trX[start: end], Y: trY[start:end]})
# print(i, np.mean(np.argmax(teY, axis=1) ==
# sess.run(predict_op, feed_dict={X: teX})))
卷积神经网络
- CNN
- 输入层
- 卷积层
- 激活函数
- 池化层
- 全连接层
卷积就是为了降维
池化就是数据压缩，特征压缩（提取主要特征）
- 加载数据
- 定义初始化函数、定义模型函数（relu、max_pool、dropout）
- 图片转一维数组
- 张量、初始化
- 调用模型函数
- 训练的下降率
- argmax
- 迭代10次
- 测试集是打乱的（np.random.shuffle）
- 打印准确率
# -*- coding: utf-8 -*-
#
#
# # # 读取数据图片，预处理
# # import tensorflow as tf
# # import tensorflow.examples.tutorials.mnist.input_data as input_data # 加载mnist数据
# # mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # one_hot为是否将标签转为一维数组形式
#
#
# # 构建一个多层卷积神经网络
# import tensorflow as tf
#
#
# # 权重初始化
# def weight_variable(shape): # 权重
# initial = tf.truncated_normal(shape, stddev=0.01)
# return tf.Variable(initial)
#
#
# def bias_variable(shape): # 偏置
# initial = tf.constant(0.1, shape=shape)
# return tf.Variable(initial)
#
#
# # 卷积和池化
# def conv2d(x, W):
# return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME') # 1步长的卷积，0边距的模板（用0填充边界）
#
#
# def max_pool_2x2(x): # 池化使用2*2的模板
# return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
# strides=[1, 2, 2, 1], padding='SAME')
#
#
# # 第一层卷积
# W_conv1 = weight_variable([5, 5, 1, 32]) # 卷积在每个5*5的patch中算出32个特征
# b_conv1 = bias_variable([32]) # 每个输出的通道都有一个的对应的偏置量
#
# x_image = tf.reshape(x, [-1, 28, 28, 1]) # x变为一个4d向量，第2、3维是图片的宽、高，第4维是图片的颜色通道数
#
# h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) # 把x_image和权值向量进行卷积，加上偏置项，然后使用RELU函数
# h_pool1 = max_pool_2x2(h_conv1) # 最后进行max_pooling（四个像素点中选取最大的）
#
#
# # 第二层卷积
# W_conv2 = weight_variable([5, 5, 32, 64]) # 每个5*5的patch中算出64个特征
# b_conv2 = bias_variable([64])
#
# h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
# h_pool2 = max_pool_2x2(h_conv2)
#
#
# # 密集层网络
# W_fc1 = weight_variable([7*7*64, 1024]) # 图片尺寸减少到了7*7，加入一个有1024个神经元的全连接层
# b_fc1 = bias_variable([1024])
#
# h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64]) # 把池化层输出的张量reshape为一些向量
# h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1) # 乘上权重矩阵，加上偏置，然后使用RELU
#
#
# # Droput(减少过拟合)
# keep_prob = tf.placeholder("float") # 训练中启用dropout，测试中关闭的dropout
# h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#
#
# # 输出层（添加一个softmax层）
# W_fc2 = weight_variable([1024, 10])
# b_fc2 = bias_variable([10])
#
# y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2) # softmax函数
#
#
# # 训练和模型评估（ADAM优化器做梯度下降，每100次迭代输出一次日志）
# cross_entropy = -tf.reduce_sum(y_ * tf.log(y_conv))
# 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.run(tf.initialize_all_variables())
# for i in range(20000):
# batch = mnist.train.next_batch(50)
# if i % 100 == 0:
# train_accuracy = accuracy.eval(feed_dict={
# x: batch[0], y_: batch[1], keep_prob: 1.0
# })
# print('step %d, training accuracy %g' % i, train_accuracy)
# train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
#
# print('test accuracy %g' % accuracy.eval(feed_dict={
# x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0
# }))
#
#
# ----------------------------------------------------------------------------------------------------------------------
#
# # # -*- coding: utf-8 -*-
#
#
# import tensorflow as tf
# import numpy as np
# from tensorflow.examples.tutorials.mnist import input_data
#
#
# batch_size = 128
# test_size = 256
#
#
# def init_weights(shape):
# return tf.Variable(tf.random_normal(shape, stddev=0.01))
#
#
# def model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden):
# l1a = tf.nn.relu(tf.nn.conv2d(X, w,
# strides=[1, 1, 1, 1], padding='SAME'))
# l1 = tf.nn.max_pool(l1a, ksize=[1, 2, 2, 1],
# strides=[1, 2, 2, 1], padding='SAME')
# l1 = tf.nn.dropout(l1, p_keep_conv)
#
# l2a = tf.nn.relu(tf.nn.conv2d(l1, w2,
# strides=[1, 1, 1, 1], padding='SAME'))
# l2 = tf.nn.max_pool(l2a, ksize=[1, 2, 2, 1],
# strides=[1, 2, 2, 1], padding='SAME')
# l2 = tf.nn.dropout(l2, p_keep_conv)
#
# l3a = tf.nn.relu(tf.nn.conv2d(l2, w3,
# strides=[1, 1, 1, 1], padding='SAME'))
# l3 = tf.nn.max_pool(l3a, ksize=[1, 2, 2, 1],
# strides=[1, 2, 2, 1], padding='SAME')
# l3 = tf.reshape(l3, [-1, w4.get_shape().as_list()[0]])
# l3 = tf.nn.dropout(l3, p_keep_conv)
#
# l4 = tf.nn.relu(tf.matmul(l3, w4))
# l4 = tf.nn.dropout(l4, p_keep_conv)
#
# pyx = tf.matmul(l4, w_o)
# return pyx
#
#
# mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
# trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels
# trX = trX.reshape(-1, 28, 28, 1)
# teX = teX.reshape(-1, 28, 28, 1)
#
#
# X = tf.placeholder("float", [None, 28, 28, 1])
# Y = tf.placeholder("float", [None, 10])
#
#
# w = init_weights([3, 3, 1, 32])
# w2 = init_weights([3, 3, 32, 64])
# w3 = init_weights([3, 3, 64, 128])
# w4 = init_weights([128 * 4 * 4, 625])
# w_o = init_weights([625, 10])
#
#
# p_keep_conv = tf.placeholder("float")
# p_keep_hidden = tf.placeholder("float")
# py_x = model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden)
#
#
# cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y))
# train_op = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost)
# predict_op = tf.argmax(py_x, 1)
#
#
# #
# with tf.Session() as sess:
# #
# tf.global_variables_initializer().run()
#
# for i in range(10):
# train_batch = zip(range(0, len(trX), batch_size),
# range(batch_size, len(trX) + 1, batch_size))
# for start, end in train_batch:
# sess.run(train_op, feed_dict={X: trX[start: end], Y: trY[start: end],
# p_keep_conv: 0.8, p_keep_hidden: 0.5})
#
# test_indices = np.arange(len(teX))
# np.random.shuffle(test_indices)
# test_indices = test_indices[0:test_size]
#
# print(i, np.mean(np.argmax(teY[test_indices], axis=1) ==
# sess.run(predict_op, feed_dict={X: teY[test_indices],
# Y: teY[test_indices],
# p_keep_conv: 1.0,
# p_keep_hidden: 1.0})))
# ----------------------------------------------------------------------------------------------------------------------
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data # 加载数据
batch_size = 128
test_size = 256
def init_weights(shape): # 初始化
return tf.Variable(tf.random_normal(shape, stddev=0.01))
def model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden): # 定义的模型函数
l1a = tf.nn.relu(tf.nn.conv2d(X, w,
strides=[1, 1, 1, 1], padding='SAME')) # l1a shape=(?, 28, 28, 32)
l1 = tf.nn.max_pool(l1a, ksize=[1, 2, 2, 1], # l1 shape=(?, 14, 14, 32)
strides=[1, 2, 2, 1], padding='SAME')
l1 = tf.nn.dropout(l1, p_keep_conv)
l2a = tf.nn.relu(tf.nn.conv2d(l1, w2,
strides=[1, 1, 1, 1], padding='SAME')) # l2a shape=(?, 14, 14, 64)
l2 = tf.nn.max_pool(l2a, ksize=[1, 2, 2, 1], # l2 shape=(?, 7, 7, 64)
strides=[1, 2, 2, 1], padding='SAME')
l2 = tf.nn.dropout(l2, p_keep_conv)
l3a = tf.nn.relu(tf.nn.conv2d(l2, w3,
strides=[1, 1, 1, 1], padding='SAME')) # l3a shape=(?, 7, 7, 128)
l3 = tf.nn.max_pool(l3a, ksize=[1, 2, 2, 1], # l3 shape=(?, 4, 4, 128)
strides=[1, 2, 2, 1], padding='SAME')
l3 = tf.reshape(l3, [-1, w4.get_shape().as_list()[0]]) # reshape to (?, 2048)
l3 = tf.nn.dropout(l3, p_keep_conv)
l4 = tf.nn.relu(tf.matmul(l3, w4))
l4 = tf.nn.dropout(l4, p_keep_hidden)
pyx = tf.matmul(l4, w_o)
return pyx
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # 将照片转一维数组
trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels # 定义训练、测试的图片、属性
trX = trX.reshape(-1, 28, 28, 1) # 28x28x1 input img
teX = teX.reshape(-1, 28, 28, 1) # 28x28x1 input img
X = tf.placeholder("float", [None, 28, 28, 1]) # 张量 浮点数 4维矩阵
Y = tf.placeholder("float", [None, 10])
w = init_weights([3, 3, 1, 32]) # 3x3x1 conv, 32 outputs
w2 = init_weights([3, 3, 32, 64]) # 3x3x32 conv, 64 outputs
w3 = init_weights([3, 3, 64, 128]) # 3x3x32 conv, 128 outputs
w4 = init_weights([128 * 4 * 4, 625]) # FC 128 * 4 * 4 inputs, 625 outputs
w_o = init_weights([625, 10]) # FC 625 inputs, 10 outputs (labels)
p_keep_conv = tf.placeholder("float") # 卷积核多项式乘法
p_keep_hidden = tf.placeholder("float") # 隐藏的
py_x = model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden) # 调用模型函数
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y)) # 准确率
train_op = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost) # 训练的下降率
predict_op = tf.argmax(py_x, 1) # 求行中最大
#
with tf.Session() as sess:
# 初始化所有可变值
tf.global_variables_initializer().run() # 跑
for i in range(10): # 迭代10次
training_batch = zip(range(0, len(trX), batch_size),
range(batch_size, len(trX)+1, batch_size)) # 训练批次
for start, end in training_batch: # 训练
sess.run(train_op, feed_dict={X: trX[start:end], Y: trY[start:end],
p_keep_conv: 0.8, p_keep_hidden: 0.5})
test_indices = np.arange(len(teX)) # 得到一个测试批
np.random.shuffle(test_indices) # 打乱测试集
test_indices = test_indices[0:test_size]
print(i, np.mean(np.argmax(teY[test_indices], axis=1) ==
sess.run(predict_op, feed_dict={X: teX[test_indices],
Y: teY[test_indices],
p_keep_conv: 1.0,
p_keep_hidden: 1.0}))) # 打印预准率