TensorFLow 基础 矩阵相乘相加 线性回归 手写字体逻辑回归 神经网络 tensorboard 显示 网络结构 和 优化记录

一、矩阵相乘相加

#-*- coding:utf-8 -*-  #支持中文
#!/usr/bin/env python
# 两个数相乘 相加
import tensorflow as tf     # 导入tf包

a = tf.placeholder("float") # 创建一个 占位符 float类型变量  'a'
b = tf.placeholder("float") # 创建一个 占位符 float类型变量  'b'

y = tf.mul(a, b)            # 两个数相乘操作  tf.matmul 支持矩阵乘法
sum1= tf.add(a, b)          # 两个数相加操作

with tf.Session() as sess: # 创建回话 用于开始一个计算
print("%f 应该等于 2.0" % sess.run(y, feed_dict={a: 1, b: 2})) # 运行时 喂数据 赋值（字典）
print("%f 应该等于 9.0" % sess.run(y, feed_dict={a: 3, b: 3}))
print("%f 应该等于 6.0" % sess.run(sum1, feed_dict={a: 3, b: 3}))

二、线性回归 求参数 Linear Regression

#-*- coding:utf-8 -*-
#!/usr/bin/env python
# 两维变量 线性回归 linear regression
import tensorflow as tf #tf包
import numpy as np      #科学计算

trX = np.linspace(-1, 1, 201)   # -1 到 200的线性序列 步长为1
trY = 4 * trX + 2 + np.random.randn(*trX.shape) * 0.33
# 创建一个y = 4*x + 2 带有随机数

X = tf.placeholder("float") # float类占位符 X
Y = tf.placeholder("float") # float类占位符 Y

##模型函数
#简单的线性回归模型 linear regression model
def model(X, w, b):
return tf.mul(X, w) - b

##需要估计的变量
b = tf.Variable(0.0, name="bias")    # 变量 偏置
w = tf.Variable(0.0, name="weights") # 变量 权重
# 模型
y_model = model(X, w, b)
#代价函数CF
cost = tf.square(Y - y_model)        #误差平方为 代价函数 cost function

# 优化函数  梯度下降法 学习率为0.007
train_op = tf.train.GradientDescentOptimizer(0.007).minimize(cost)

# 开始回话 执行优化
with tf.Session() as sess:
# 初始化变量
#tf.initialize_all_variables().run() 旧版
tf.global_variables_initializer().run()

for i in range(200):
for (x, y) in zip(trX, trY):# zip绑定数据和标签 分批次取出数据对
sess.run(train_op, feed_dict={X: x, Y: y})# 运行时 喂数据 赋值（字典）

print(sess.run(w))   # 优化后的 权重值 接近 4
print(sess.run(b))   # 优化后的 偏置值 接近  -2  -b =2  b =-2

三维变量回归 

#-*- coding:utf-8 -*-
#!/usr/bin/env python
# 三维变量 线性回归 linear regression
import tensorflow as tf
import numpy as np

# 生成数据 generate date
x_data = np.float32(np.random.rand(2, 100))    # 2行 100列  维度 2*100
## 预测 两个权重 0.1 和 0.2 以及一个 偏置 0.3
# 无噪声
y_data = np.dot([0.100, 0.200], x_data) + 0.300 # y=a*x1 + b*x2 +c
# 有噪声
#y_data = np.dot([0.100, 0.200], x_data) + 0.300 + np.random.randn(*(1,x_data.shape[1]))*0.11

# 创建模型 参数初始化 creat model
b = tf.Variable(tf.zeros([1])) #偏置变量 b 初始化为0
W = tf.Variable(tf.random_uniform([1, 2], -1.0, 1.0))#1行2列 权重变量 初始化为随机 -1~1之间均匀分布
y_model = tf.matmul(W, x_data) + b#模型

# 代价函数 coss function
loss = tf.reduce_mean(tf.square(y_model - y_data))# 差值平方 再求 均值

# 优化函数  梯度下降法 学习率为0.55
train_op = tf.train.GradientDescentOptimizer(0.55).minimize(loss)
#train = optimizer.minimize(loss)

# 初始化变量 (in this case just variable W)
# init = tf.initialize_all_variables()#旧的
init =tf.global_variables_initializer()

# 在会话中启动 计算图
with tf.Session() as sess:
sess.run(init)#初始
4000
化变量
# 开始训练loop train
for step in xrange(0, 201): #训练200次
sess.run(train_op)      #执行优化函数
if step % 20 == 0:      #每20步 显示一下结果
print step, sess.run(W), sess.run(b)

# 结果大概为 W: [[0.100  0.200]], b: [0.300]

使用 tensorboard  显示 网络结构 和 优化记录

#-*- coding:utf-8 -*-
#!/usr/bin/env python
# 三维变量 线性回归  + tensorboard 显示优化记录
import tensorflow as tf
import numpy as np

# 生成数据 generate date
x_data = np.float32(np.random.rand(2, 100))     # 2行 100列 随机数
## 预测 两个权重 0.1 和 0.2 以及一个 偏置 0.3
# 无噪声
y_data = np.dot([0.100, 0.200], x_data) + 0.300 # y=a*x1 + b*x2 +c
# 有噪声
#y_data = np.dot([0.100, 0.200], x_data) + 0.300 + np.random.randn(*(1,x_data.shape[1]))*0.11

# 创建模型 creat model
b = tf.Variable(tf.zeros([1]), name="b")  #偏置变量 b 初始化为0
W = tf.Variable(tf.random_uniform([1, 2], -1.0, 1.0), name="W") #1行2列 权重变量 初始化为随机 -1~1之间均匀分布
# y_model = tf.matmul(W, x_data) + b  # 模型
y_model = tf.add(tf.matmul(W, x_data, name="MatMul") , b , name="Add")# 模型 为每一个操作 添加名字 可以在在图中显示

# 代价函数 coss function 最小化方差
#loss = tf.reduce_mean(tf.square(y_model - y_data)) #差值平方 均值  为每一步操作 添加名字
loss = tf.reduce_mean(tf.square(tf.sub(y_model , y_data, name = "Sub"),name="Square"), name="ReduceMean") # 差值 平方 均值

# 优化函数  梯度下降法 学习率为0.55
#train_op = tf.train.GradientDescentOptimizer(0.55).minimize(loss)
optimizer = tf.train.GradientDescentOptimizer(0.2, name="Optimizer") # 为 优化步骤 名字
train = optimizer.minimize(loss, name="minimizer") # 为最小化步骤添加名字

## 声明 summary  记录数据 用于可视化显示
# 分别记录 权重W 偏置b  以及 误差loss的变化  变量 tf.summary.histogram  常量 tf.summary.scalar
# summarizes = [tf.histogram_summary("W",W), tf.histogram_summary("b",b), tf.scalar_summary("loss",loss)]
summarizes = [tf.summary.histogram("W",W), tf.summary.histogram("b",b), tf.summary.scalar("loss",loss)]
# 记录操作 合并在一起
# summary_op = tf.merge_summary(summarizes)
summary_op = tf.summary.merge(summarizes)

# 初始化变量 (in this case just variable W)
# init = tf.initialize_all_variables() #旧的
#init =tf.global_variables_initializer()

# 在会话中启动计算图
with tf.Session() as sess:
#初始化变量
# tf.initialize_all_variables() no long valid from
# 2017-03-02 if using tensorflow >= 0.12
if int((tf.__version__).split('.')[1]) < 12 and int((tf.__version__).split('.')[0]) < 1:
init = tf.initialize_all_variables()    #旧版
else:
init = tf.global_variables_initializer()#新版
sess.run(init)
# 记录拟合日志
# summary_writer = tf.train.SummaryWriter("./log/linear_regression_log", graph_def=sess.graph)
summary_writer = tf.summary.FileWriter("./logs/linear_regression_log", graph = sess.graph)#外加记录网络图模型 sess.graph
# 使用 tensorboard --logdir="/目录" 会给出一段网址： 打开即可 显示可视化的 信息
# 开始训练loop train
for step in xrange(0, 1000):#训练1000次
sess.run(train)#执行优化函数
if step % 20 == 0:#每20步 显示一下结果
print step, sess.run(W), sess.run(b)
summary_str = sess.run(summary_op)
summary_writer.add_summary(summary_str, global_step=step)
# you will get the result W: [[0.100  0.200]], b: [0.300]

三、逻辑回归 输出0/1

#-*- coding:utf-8 -*-
#!/usr/bin/env python
# 手写字体 逻辑回归(仅有权重)
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data   # 读取mnist手写字体数据工具

## 初始化权重  带入矩阵权重的维度信息 #####
def init_weights(shape):
return tf.Variable(tf.random_normal(shape, stddev=0.01))# 均匀分布初始化 标准差为 0.01

## 模型函数 ####
def model(X, w):
return tf.matmul(X, w)
# notice we use the same model as linear regression,
#this is because there is a baked in cost function which performs softmax and cross entropy

## 数据处理 data preprocessing
mnist = input_data.read_data_sets("../minist/MNIST_data/", one_hot=True)# 读取数据
# 训练数据 训练数据标签 测试数据  测试数据标签
trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels

## 训练数据的 占位符
X = tf.placeholder("float", [None, 784]) # 28*28的图像 展开成一维度 1*784  同时输入多张图像
Y = tf.placeholder("float", [None, 10])  # 标签为1*10  分别表示是哪一个数字  仅有一个1 其余都是0
## 权重初始化
w = init_weights([784, 10]) # 784*10 输入n×784  .* 784*10 -> n*10 最后每张图像输出 1*10 标签 0/1
## 预测值
pred_y_x = model(X, w)# 每个图像 会得到10个值 分别对应是 0~9 的可能性

#(logits, labels, name=None)   cross_entropy = -tf.reduce_sum(y_real*tf.log(y_predict))
## 计算代价函数 softmax回归(归一化)后  利用实际标签Y求对数信息增益  再求均值 预测
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred_y_x, Y))
# compute mean cross entropy (softmax is applied internally)

## 优化函数        梯度下降法 学习率为0.05
train_op = tf.train.GradientDescentOptimizer(0.05).minimize(cost)

## 预测值
predict_op = tf.argmax(pred_y_x, 1) # 逻辑回归输出（1*10）中的最大值即为 预测数字

## 变量初始化
# init = tf.initialize_all_variables()#旧的
init =tf.global_variables_initializer()

## 在会话中 启动图
with tf.Session() as sess:
# 初始化变量
#tf.initialize_all_variables().run() 旧版
#tf.global_variables_initializer().run()
sess.run(init)

for i in range(50):#训练50次
for start, end in zip(range(0, len(trX), 128), range(128, len(trX)+1, 128)):# [0 128 256...] [128 256 ...]
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})))# 每次训练后使用测试集测试

模型加入偏置参数

#-*- coding:utf-8 -*-
#!/usr/bin/env python
# 手写字体 逻辑回归(权重+偏置)
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data   # 读取mnist手写字体数据工具

## 初始化权重 #####
def init_weights(shape):
return tf.Variable(tf.random_normal(shape, stddev=0.01))

## 模型函数 ####
def model(X, w, b):
return tf.matmul(X, w) + b

## 数据处理 data preprocessing
mnist = input_data.read_data_sets("../minist/MNIST_data/", one_hot=True)
# 训练数据 训练数据标签 测试数据  测试数据标签
trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels

## 训练数据的 占位符
X = tf.placeholder("float", [None, 784]) # a picture is a 784 dimension verb
Y = tf.placeholder("float", [None, 10])  # a label is a 10dimension verb which has only one 1 ,others is 0

## 权重初始化
w = init_weights([784, 10])      # 784*10 输入n×784  .* 784*10 -> n*10 最后每张图像输出 1*10
## 偏置
b = tf.Variable(tf.zeros([10]))  # 1*10
## 模型
pred_y_x = model(X, w, b)

#(logits, labels, name=None)   cross_entropy = -tf.reduce_sum(y_real*tf.log(y_predict))
## 计算代价函数 softmax回归 后 对数 信息增益 均值
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred_y_x, Y))
## 优化函数        梯度下降法 学习率为0.05
train_op = tf.train.GradientDescentOptimizer(0.05).minimize(cost) # construct optimizer
## 预测值
predict_op = tf.argmax(pred_y_x, 1) # 逻辑回归输出（1*10）中的最大值即为 预测数字

## 变量初始化
# init = tf.initialize_all_variables()#旧的
init = tf.global_variables_initializer()

## 启动 图 回话
with tf.Session() as sess:
# 初始化变量
#tf.initialize_all_variables().run() 旧版
#tf.global_variables_initializer().run()
sess.run(init)

for i in range(50):#训练50次
for start, end in zip(range(0, len(trX), 128), range(128, len(trX)+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})))#在每次训练后测试 测试集

四、简单神经网络 使用参数变量控制程序  + tensorboard显示优化记录

#-*- coding:utf-8 -*-
#!/usr/bin/env python
# 神经网 28*28 矩阵图输入

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf

## 导入 mnist数据集 读取工具
from tensorflow.examples.tutorials.mnist import input_data

## 参数设置  使用flag设置参数变量 来统一管理
flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_boolean('fake_data', False, 'If true, uses fake data for unit testing.')  ## 假数据            布尔数据类型
flags.DEFINE_integer('max_steps', 1000, 'Number of steps to run trainer.')             ## 最大学习步数      整数类型
flags.DEFINE_float('learning_rate', 0.001, 'Initial learning rate.')                   ## 初始学习率        浮点数类型
flags.DEFINE_float('dropout', 0.9, 'Keep probability for training dropout.')           ## 神经元部分激活概率 浮点数类型
flags.DEFINE_string('data_dir', '../minist/MNIST_data/', 'Directory for storing data') ## 数据集路径        字符串类型
flags.DEFINE_string('summaries_dir', './logs/mnist_LogReg_logs', 'Summaries directory')## 训练日志存储路径   字符串类型
## 训练步骤###################################################################
def train():
## 输入数据
mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True, fake_data=FLAGS.fake_data)# 读取
sess = tf.InteractiveSession()##交互式 会话
## 创建一个多层模型 Create a multilayer model.
## 输入数据占位符
with tf.name_scope('input'):## 为了可视化显示 定义每一步操作的名字
x  = tf.placeholder(tf.float32, [None, 784], name='x-input') # 特征输入 28*28=784 1*784
y_ = tf.placeholder(tf.float32, [None, 10], name='y-input')  # 标签输入 1*10维
## 改变数据 形状
with tf.name_scope('input_reshape'):
image_shaped_input = tf.reshape(x, [-1, 28, 28, 1])
# tf.image_summary('input', image_shaped_input, 10)# 对输入数据进行 变形 并记录
tf.summary.image('input', image_shaped_input, 10)  # 对输入数据进行 变形 并记录

# 随机初始化 权重
def weight_variable(shape):
"""Create a weight variable with appropriate initialization."""
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
# 初始化偏置
def bias_variable(shape):
"""Create a bias variable with appropriate initialization."""
initial = tf.constant(0.1, shape=shape) # 0.1常量
return tf.Variable(initial)
# 记录变量 的各项参数
# summary.scalar 记录常量 summary.histogram 记录变量
def variable_summaries(var, name):
with tf.name_scope('summaries'):##操作名字
mean = tf.reduce_mean(var)             # 计算均值操作
tf.summary.scalar('mean/' + name, mean)# 记录数据的均值
with tf.name_scope('stddev'):          # 计算标准差 操作
stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
tf.summary.scalar('sttdev/' + name, stddev)# 记录数据的标准差
tf.summary.scalar('max/' + name, tf.reduce_max(var))# 记录数据的最大值
tf.summary.scalar('min/' + name, tf.reduce_min(var))# 记录数据的最小值
tf.summary.histogram(name, var)# 记录变量数据本身

## 定义神经网络函数
def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu):
"""简单的神经网络层 矩阵相乘 加上偏置 使用非线性激活函数激活.
同时也记录了一些变量的 变化
"""
with tf.name_scope(layer_name):#操作名字 层 的名字
#创建权重
with tf.name_scope('weights'):
weights = weight_variable([input_dim, output_dim])#按相关尺寸 创建权重变量
variable_summaries(weights, layer_name + '/weights')#记录变量的各项参数
#创建偏置
with tf.name_scope('biases'):
biases = bias_variable([output_dim])
variable_summaries(biases, layer_name + '/biases')
#创建操作
with tf.name_scope('Wx_plus_b'):
preactivate = tf.matmul(input_tensor, weights) + biases # y = w * x + b             实现线性变换
tf.summary.histogram(layer_name + '/pre_activations', preactivate)#记录变量 preactivate 激活前
activations = act(preactivate, 'activation')                  # 使用非线性激活函数激活  实现非线性操作
tf.summary.histogram(layer_name + '/activations', activations)#记录激活后的输出
return activations
#####以上为 train 定义的 变白 函数部分 以下为其实际执行的部分################################
### 创建一个隐含层  输入 784 输出 500 名为 layer1###########################
hidden1 = nn_layer(x, 784, 500, 'layer1')
#### 部分神经元激活
with tf.name_scope('dropout'):
keep_prob = tf.placeholder(tf.float32)#占位符
tf.summary.scalar('dropout_keep_probability', keep_prob)#记录常量 dropout参数
dropped = tf.nn.dropout(hidden1, keep_prob)             ## 部分神经元输出
## 创建输出层 输入 500 输出 10 名为 layer2  最后softmax回归输出 0~9
y = nn_layer(dropped, 500, 10, 'layer2', act=tf.nn.softmax)# 最后 softmax非线性 归一化 exp(xi)/sum(exp(xi))

### 计算信息熵 系统混乱度
with tf.name_scope('cross_entropy'):
diff = y_ * tf.log(y) # y_ 为真实标签  y为预测概率(0~1 softmax的输出)
with tf.name_scope('total'):
cross_entropy = -tf.reduce_mean(diff)#均值
tf.summary.scalar('cross entropy', cross_entropy)#记录常量信息熵
#  loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y, labels=y_))
### 训练优化 Adam算法优化
with tf.name_scope('train'):
train_step = tf.train.AdamOptimizer(FLAGS.learning_rate).minimize(cross_entropy)
### 计算 准确度
with tf.name_scope('accuracy'):
with tf.name_scope('correct_prediction'):
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))#和标签相等即为正确1 否者错误为0
#看预测的10个标签里的最大值是否为真实标签
with tf.name_scope('accuracy'):
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))#均值
tf.summary.scalar('accuracy', accuracy)##记录准确度

# 合并所有的 日志记录 写入相应的文件中
merged = tf.merge_all_summaries()
train_writer = tf.summary.FileWriter(FLAGS.summaries_dir + '/train', graph = sess.graph) #训练 外加记录 网络模型图
test_writer  = tf.summary.FileWriter(FLAGS.summaries_dir + '/test')#测试

#初始化变量
#tf.initialize_all_variables().run()
if int((tf.__version__).split('.')[1]) < 12 and int((tf.__version__).split('.')[0]) < 1:
tf.initialize_all_variables().run()#旧版
else:
tf.global_variables_initializer().run()#新版

# 训练模型,记录训练日志.
# 每隔10步, 测试 测试集 准确度,记录测试日志

## 产生训练和测试数据  喂数据
def feed_dict(train):
if train or FLAGS.fake_data: # 训练集
xs, ys = mnist.train.next_batch(100, fake_data=FLAGS.fake_data)
k = FLAGS.dropout # 训练时部分神经元激活
else:# 测试集
xs, ys = mnist.test.images, mnist.test.labels
k = 1.0 # 测试时 全部神经元激活
return {x: xs, y_: ys, keep_prob: k}

for i in range(FLAGS.max_steps):
if i % 10 == 0:  # 每10步
9e08
记录日志 使用测试数据集
summary, acc = sess.run([merged, accuracy], feed_dict=feed_dict(False))
test_writer.add_summary(summary, i)
print('Accuracy at step %s: %s' % (i, acc))## 打印准确度
else:  # 每100步 记录状态 执行测试 99 199 ..
if i % 100 == 99:  # Record execution stats
run_options  = tf.RunOptions(trace_level = tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, _ = sess.run([merged, train_step],
feed_dict=feed_dict(True),
options=run_options,
run_metadata=run_metadata)
train_writer.add_run_metadata(run_metadata, 'step%03d' % i)
train_writer.add_summary(summary, i)
print('Adding run metadata for', i)
else:  # 其他步骤 记录日志
summary, _ = sess.run([merged, train_step], feed_dict=feed_dict(True))
train_writer.add_summary(summary, i)
train_writer.close()
test_writer.close()

def main(_):
if tf.gfile.Exists(FLAGS.summaries_dir):
tf.gfile.DeleteRecursively(FLAGS.summaries_dir)
tf.gfile.MakeDirs(FLAGS.summaries_dir)
train()

if __name__ == '__main__':
tf.app.run()