tensorflow
- 介绍
- 基本语法
- 工作原理
- Fetch取出内容
- Feed占位操作
- 模型的保存与读取
- 经典案例
- 线性回归
- 逻辑回归
- 简单神经网络
- CNN
- RNN
- 查看准确度
介绍
- 通过graph表示计算任务
- 在Session中执行图
- 使用tensor表示书籍
- 通过变量Variablew维护数据，feed和fetch可以为任意的操作(arbitrary operation) 赋值或者从其中获取数据.
参考：http://www.tensorfly.cn/tfdoc/get_started/basic_usage.html
基本语法
- 引入tensorflow包：import tensorflow as tf
- 创建变量的方式：tf.Variable(【矩阵】)
例如
w = tf.Variable([[0.5,1.0]])#w赋值为[0.5，1.0]
x = tf.Variable([[2.0],[1.0]])创建特殊的矩阵
# 零矩阵
a=tf.zeros([3, 4], int32)
#1矩阵
b=tf.ones([2, 3], int32)
#常数矩阵
c= tf.constant([[1, 2, 3], [4, 5, 6]])
#随机生成一个标准差为4，平均值为-1的x行x列矩阵，
norm = tf.random_normal([2, 3], mean=-1, stddev=4)
#python的数据类型转换成TensorFlow可用的tensor数据类型
import numpy as np
a = np.ones((3,3))
ta = tf.convert_to_tensor(a)变量
# 创建一个变量, 初始化为标量 0.
state = tf.Variable(0, name="counter")创建一个图：sess = tf.Session()
关闭一个图，任务完成关闭会话：sess.close()
- 初始化所有变量：init_op = tf.initialize_all_variables()
- 然后再调用sess.run(init_op),完成初始化
工作原理
再真实的使用过程中，我们会通过tf.Variable(参数)，来定义需要使用的参数变量。然后通过
init_op = tf.initialize_all_variables()，初始化变量。接下来，首先会使用一个会话Session来启动图，并调用Session.run方法执行操作
import tensorflow as tf
from tensorflow import int32
#创建变量
w = tf.Variable([[0.5,1.0]])
x = tf.Variable([[2.0],[1.0]])
#矩阵的乘法运算
y = tf.matmul(w, x)
#启动图后, 变量必须先经过`初始化` (init) op 初始化
# 首先必须增加一个`初始化` op 到图中
init_op = tf.global_variables_initializer()
#创建一个Session会话
with tf.Session() as sess:
# 运行 'init' op
sess.run(init_op)
#打印出y的值
print (y.eval（))Fetch取出内容
input1 = tf.constant(3.0)
input2 = tf.constant(2.0)
input3 = tf.constant(5.0)
intermed = tf.add(input2, input3)
mul = tf.mul(input1, intermed)
with tf.Session():
result = sess.run([mul, intermed])#依次取出多个内容
print(result)#将取出的结果打印出来
# 输出:
# [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]Feed占位操作
1.首先使用tf.placeholder进行占位操作
2.定义占位符的运算符法则
3.在Session会话中指定的Feed数据：
sess.run([运算规则名]),feed_dict={占位名1：数据，占位名2：数据…}
模型的保存与读取
tf.train.Saver来保存模型：例如： saver_path = saver.save(sess, “save/model.ckpt”)#将saver类中的计算域，保存模型到磁盘中去
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(init_op)
# Do some work with the model.对模型做一些工作
# Save the variables to disk. 保存模型到磁盘中
save_path = saver.save(sess, "C://Users//Administrator//Desktop//新建文件夹//a.txt")#模型的保存地址
print ("Model saved in file: ", save_path)模型的读取使用的是：saver.restore(sess, 地址)
if do_train == 0:
epoch = training_epochs-1
saver.restore(sess, "save/nets/cnn_mnist_basic.ckpt-" + str(epoch))#读取模型
test_acc = sess.run(accr, feed_dict={x: testimg, y: testlabel, keepratio:1.})#用读取到的模型进行测试
print (" TEST ACCURACY: %.3f" % (test_acc))经典案例
线性回归
生成y=0.1x+0.3的点信息
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
# 随机生成1000个点，围绕在y=0.1x+0.3的直线周围
num_points = 1000
vectors_set = []
for i in range(num_points):
x1 = np.random.normal(0.0, 0.50)#满足正态分布的中的为0.0，方差为0.5的随机点
y1 = x1 * 0.1 + 0.3 + np.random.normal(0.0, 0.03)#定义一个函数
vectors_set.append([x1, y1])#将生成的点放入到向量集合中去
# 生成一些样本
x_data = [v[0] for v in vectors_set]#将vectors_set中的第一列取出来放到x_data中
y_data = [v[1] for v in vectors_set]#将vectors_set中的第er列取出来放到y_data中线性回归训练数据
- 首先定义模型的参数
# 生成1维的W矩阵，取值是[-1,1]之间的随机数
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0), name='W')#tf.random_uniform的第一参数类型，
#参数二三分别为上下限值，包括下限，不包括上限
# 生成1维的b矩阵，初始值是0
b = tf.Variable(tf.zeros([1]), name='b')
# 经过计算得出预估值y
y = W * x_data + b #目标的模型值- 其次定义损失函数：通过最小化loss误差，来优化参数：
# 以预估值y和实际值y_data之间的均方误差作为损失
loss = tf.reduce_mean(tf.square(y - y_data), name='loss')#定义损失函数，采用均方误差作为损失值
# 采用梯度下降法来优化参数
#tf.train.GradientDescentOptimizer(learning_rate, use_locking=False,name=’GradientDescent’)
# 参数：
#learning_rate: A Tensor or a floating point value. 要使用的学习率
#use_locking: 要是True的话，就对于更新操作（update operations.）使用锁
#name: 名字，可选，默认是”GradientDescent”
optimizer = tf.train.GradientDescentOptimizer(0.5)#采用梯度下降的算法来优化，学习率为0.5
# 训练的过程就是最小化这个误差值
train = optimizer.minimize(loss, name='train')#最小化误差
#上述的最小化误差的代码也可以写成一行
#train = tf.train.GradientDescentOptimizer(0.5).minimize(loss, name='train')- 接下来，创建会话，并训练：
train = optimizer.minimize(loss, name=‘train’)#最小化误差
sess.run(train) ，要使得训练的loss最小
sess = tf.Session()#创建一个会话
init = tf.global_variables_initializer()#初始化variables变量
sess.run(init)#调用init对应的方法
# 初始化的W和b是多少
print ("W =", sess.run(W), "b =", sess.run(b), "loss =", sess.run(loss))
# 执行20次训练
for step in range(20):
sess.run(train)
# 输出训练好的W和b
print ("W =", sess.run(W), "b =", sess.run(b), "loss =", sess.run(loss))
writer = tf.summary.FileWriter("./tmp", sess.graph)最后打印结果
plt.scatter(x_data,y_data,c='r')
plt.plot(x_data,sess.run(W)*x_data+sess.run(b))#绘制图形，横坐标x_data,纵坐标为训练好的模型wx+b
plt.show()#显示逻辑回归
- 以MINST数据集合为例
- 首先读取数据
- 并将标签分类好
mnist = input_data.read_data_sets('data/', one_hot=True)
trainimg = mnist.train.images
trainlabel = mnist.train.labels
testimg = mnist.test.images
testlabel = mnist.test.labels- 其次，通过placeolder占位操作，定义需要训练的函数模型
x = tf.placeholder("float", [None, 784]) #占位操作
y = tf.placeholder("float", [None, 10]) # None is for infinite （无限）
W = tf.Variable(tf.zeros([784, 10]))#初始值为0
b = tf.Variable(tf.zeros([10]))
# LOGISTIC REGRESSION MODEL：y=wx+b
actv = tf.nn.softmax(tf.matmul(x, W) + b) #回归函数通过softmax分类器，投票得出最终的结果- 定义损失函数，并优化求解
# COST FUNCTION ：损失函数
#损失函数Cost Fuction -logP P是属于真实样本的概率值（预测值）
##以估计值y和实际值y_data之间的均方误差作为损失
cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(actv), reduction_indices=1)) #前两者为y*向正确的方向递减
#下降的步长为1
# OPTIMIZER：学习率
learning_rate = 0.01
#梯度下降优化器求解，训练的过程就是最下化损失函数cost
optm = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)#逻辑回归的常规套路，最小化误差梯度- 定义预测值与精度值
# PREDICTION：预测
#Predition argmax()函数 求最大值的索引
#其中tf.argmax(actv,1) 代表预测值第一行最大数对应的索引值 ，tf.argmax(y,1)真实值对应的索引
#其中tf.argmax(actv,0) 代表预测值第一列最大数对应的索引值 ，tf.argmax(y,0)真实值对应的索引
#预测值actv的索引和label值（真实值）的索引是否一样，pred返回值是True 或者 False
pred = tf.equal(tf.argmax(actv, 1), tf.argmax(y, 1))#判断预测值和真实值是否相等。
# ACCURACY：精度
accr = tf.reduce_mean(tf.cast(pred, "float"))#转换为平均的精度- 初始化变量并训练数据
# INITIALIZER
init = tf.global_variables_initializer()
training_epochs = 50#所有训练样本迭代次数
batch_size = 100#每次迭代的样本数
display_step = 10#没10次迭代，显示一次预测值分数和精度
# SESSION
sess = tf.Session()
sess.run(init)
# MINI-BATCH LEARNING
for epoch in range(training_epochs):#所有的样本循环training_epochs次数50
avg_cost = 0.#初始损失值为0
num_batch = int(mnist.train.num_examples/batch_size)#总的训练集的数目和每次取得样本数目:55000/100=550
for i in range(num_batch): #一共迭代550次
#每次取出100个数据进行操作
batch= mnist.train.next_batch(batch_size)#分别取batch_xs和batch_ys的数量的多少
batch_xs=batch[0]#取出训练集x的数据
batch_ys=batch[1]#取出训练集y的数据
feeds = {x: batch_xs, y: batch_ys}
sess.run(optm, feed_dict=feeds)#调用optm优化梯度的参数，喂数据
avg_cost =avg_cost+sess.run(cost, feed_dict=feeds)/num_batch#计算平均损失梯度
# DISPLAY
if epoch % display_step == 0:#每5次迭代过程打印一次数据
feeds_train = {x: batch_xs, y: batch_ys}
feeds_test = {x: mnist.test.images, y: mnist.test.labels}#取出测试集的数据
train_acc = sess.run(accr, feed_dict=feeds_train)#显示训练集的精度
test_acc = sess.run(accr, feed_dict=feeds_test) #显示测试集的精度
print ("Epoch: %03d/%03d cost: %.9f train_acc: %.3f test_acc: %.3f"
% (epoch, training_epochs, avg_cost, train_acc, test_acc))
print ("DONE")- 显示验证的结果
#取出图片并显示出来
randidx2=[550]
for i in randidx2:#可在此处使用方法1或者方法2
curr_img = np.reshape(trainimg[i, :], (28, 28)) # 28 by 28 matrix 。
#np.reshape函数功能：给予数组一个新的形状，而不改变它的数据
# print(trainlabel[i, :])
curr_label = np.argmax(trainlabel[i, :] ) # Label,返回的是对应的整形数字编号。
#存放格式如[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]，下标位置代表数字。
#plt.matshow([[0,0,0],[0,0,0],[0,0,0.95]], cmap=plt.get_cmap('gray'))#0代表黑色，其他值代表白色的亮度
plt.matshow(curr_img, cmap=plt.get_cmap('gray'))#根据（28*28）的矩阵的值来显示手写字体的值
plt.title("" + str(i) + "th Training Data " + "Label is " + str(curr_label))#显示title
print ("" + str(i) + "th Training Data " + "Label is " + str(curr_label))#打印信息
plt.show()
#验证模型的值和图片显示的值是否一致
a = np.reshape(trainimg[i, :], (1, 784))
print("a的类型为",a.shape)
y1=tf.matmul(a,W)+b#计算的出来的模型
print(sess.run(tf.argmax(y1,1)))#根据位置得出来数据的模型简单神经网络
1.定义网络结构
# NETWORK TOPOLOGIES：网络拓扑
n_hidden_1 = 256 #第一层网络的神经元个数
n_hidden_2 = 128 #第二层网络的神经元个数
n_input = 784 #每次输入点的个数
n_classes = 10 #十分类任务
# INPUTS AND OUTPUTS：输入和输出
x = tf.placeholder("float", [None, n_input])#输入
y = tf.placeholder("float", [None, n_classes])#输出
# NETWORK Parameters：网络参数
#（下面的都用来参数初始化）
stddev = 0.1#方差项
#（下面的操作都是对权重参数和偏置参数经常初始化操作，一般不适用零值初始化操作，本次选用高斯初始化）
weights = {
'w1': tf.Variable(tf.random_normal([n_input, n_hidden_1], stddev=stddev)),#定义网络结构
'w2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2], stddev=stddev)),
'out': tf.Variable(tf.random_normal([n_hidden_2, n_classes], stddev=stddev))
}
biases = {
'b1': tf.Variable(tf.random_normal([n_hidden_1])),
'b2': tf.Variable(tf.random_normal([n_hidden_2])),
'out': tf.Variable(tf.random_normal([n_classes]))
}
print ("NETWORK READY")2.定义函数的模型
#多层感知机：前向传播函数
def multilayer_perceptron(_X, _weights, _biases):
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(_X, _weights['w1']), _biases['b1']))
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, _weights['w2']), _biases['b2']))
return (tf.matmul(layer_2, _weights['out']) + _biases['out'])
# PREDICTION：预测值，输出值
pred = multilayer_perceptron(x, weights, biases)3.定义损失函数和定义优化器
# LOSS AND OPTIMIZER：损失值和优化器
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y)) #交叉熵函数做分类任务，平均的loss
optm = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(cost) #梯度下降的优化器4.定义模型精度的计算公式
corr = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))#模型的准确率
accr = tf.reduce_mean(tf.cast(corr, "float"))#转换float类型的平均精度5.初始化变量，然后创建会话，接着训练
# INITIALIZER：初始化全局的variables变量
init = tf.global_variables_initializer()
training_epochs = 101#迭代次数
batch_size = 100#每次取得数据
display_step =20 #显示步长
# LAUNCH THE GRAPH
sess = tf.Session()
sess.run(init)
# OPTIMIZE
for epoch in range(training_epochs):
avg_cost = 0.#初始损失值为0
total_batch = int(mnist.train.num_examples/batch_size)#总的训练集的数目和每次取得样本数目
# ITERATION
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size)#每次取得数据
feeds = {x: batch_xs, y: batch_ys}
sess.run(optm, feed_dict=feeds)#运行优化器
avg_cost += sess.run(cost, feed_dict=feeds)#计算损失值
avg_cost = avg_cost / total_batch#计算平均的损失值
# DISPLAY
if (epoch+1) % display_step == 0:
print ("Epoch: %03d/%03d cost: %.9f" % (epoch, training_epochs, avg_cost))
feeds = {x: batch_xs, y: batch_ys}
train_acc = sess.run(accr, feed_dict=feeds)
print ("TRAIN ACCURACY: %.3f" % (train_acc))
feeds = {x: mnist.test.images, y: mnist.test.labels}#取出测试集的数据
test_acc = sess.run(accr, feed_dict=feeds)
print ("TEST ACCURACY: %.3f" % (test_acc))验证结果
将输入的值带入到函数的模型中，将结果与标签值作比较
#验证模型的值和图片显示的值是否一致
a = np.reshape(mnist.train.images[i, :], (1, 784))
print("a的类型为",a.shape)
y1=multilayer_perceptron(a, weights, biases)#计算的出来的模型
print(sess.run(tf.argmax(y1,1)))#根据位置得出来数据的模型CNN
1.定义神经网络参数
'''
卷积神经网络模型
minist 数据集 n*784 卷积层->filter(3*3*1) 64个filter结果，
pooling 2*2
卷积2->filter（3*3*64） 特征128输出
pooling 2*2
全链接层 1 特征图 总结 1024
全链接2 分类10
'''
n_input = 784
n_output = 10
weights = {
#卷积层 3,3 filter的大小，1是深度 64是output特征图 stddev=0.1方差项
'wc1': tf.Variable(tf.random_normal([3, 3, 1, 64], stddev=0.1)),
'wc2': tf.Variable(tf.random_normal([3, 3, 64, 128], stddev=0.1)),
#全链接参数 7*7*128 输入时 转换成1024可以自己定义。前面不能自己定义
'wd1': tf.Variable(tf.random_normal([7*7*128, 1024], stddev=0.1)),
'wd2': tf.Variable(tf.random_normal([1024, n_output], stddev=0.1))
}
biases = {
'bc1': tf.Variable(tf.random_normal([64], stddev=0.1)),
'bc2': tf.Variable(tf.random_normal([128], stddev=0.1)),
'bd1': tf.Variable(tf.random_normal([1024], stddev=0.1)),
'bd2': tf.Variable(tf.random_normal([n_output], stddev=0.1))
}2.定义前向传播函数，即系统的模型函数
#卷积神经网络前向传播的函数
def conv_basic(_input, _w, _b, _keepratio):
# INPUT
#数据预处理 -1 自己推算 ，把 input进行reshape -
_input_r = tf.reshape(_input, shape=[-1, 28, 28, 1])#输入的预处理，【n,h,w,c】[自己处理，高，宽，通道数]
# CONV LAYER 1
#卷积 1 strides=[1,1,1,1]在不同的地方的 大小，w，h和其他 SAME将进行0值填充。
_conv1 = tf.nn.conv2d(_input_r, _w['wc1'], strides=[1, 1, 1, 1], padding='SAME')
#卷积中激活函数一般选取ReLu
_conv1 = tf.nn.relu(tf.nn.bias_add(_conv1, _b['bc1']))
#池化层1（其中strides中间两个数表示：2*2的操作）
_pool1 = tf.nn.max_pool(_conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
_pool_dr1 = tf.nn.dropout(_pool1, _keepratio)#不让每个神经元都参与进来，随机的杀死一些结点，防止过拟合
# CONV LAYER 2
_conv2 = tf.nn.conv2d(_pool_dr1, _w['wc2'], strides=[1, 1, 1, 1], padding='SAME')
_conv2 = tf.nn.relu(tf.nn.bias_add(_conv2, _b['bc2']))
#池化层2
_pool2 = tf.nn.max_pool(_conv2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
_pool_dr2 = tf.nn.dropout(_pool2, _keepratio)
# VECTORIZE
_dense1 = tf.reshape(_pool_dr2, [-1, _w['wd1'].get_shape().as_list()[0]])
# FULLY CONNECTED LAYER 1：wx+b的操作，全连接1操作
_fc1 = tf.nn.relu(tf.add(tf.matmul(_dense1, _w['wd1']), _b['bd1']))
_fc_dr1 = tf.nn.dropout(_fc1, _keepratio)#防止过拟合
# FULLY CONNECTED LAYER 2：wx+b的操作，全连接2操作
_out = tf.add(tf.matmul(_fc_dr1, _w['wd2']), _b['bd2'])
# RETURN
out = { 'input_r': _input_r, 'conv1': _conv1, 'pool1': _pool1, 'pool1_dr1': _pool_dr1,
'conv2': _conv2, 'pool2': _pool2, 'pool_dr2': _pool_dr2, 'dense1': _dense1,
'fc1': _fc1, 'fc_dr1': _fc_dr1, 'out': _out
}
return out
#模型的输出
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_output])
keepratio = tf.placeholder(tf.float32)
# FUNCTIONS
_pred = conv_basic(x, weights, biases, keepratio)['out']3.定义损失函数和优化器
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=_pred, labels=y))
optm = tf.train.AdamOptimizer(learning_rate=0.001).minimize(cost)#优化器4.定义精度的计算函数
_corr = tf.equal(tf.argmax(_pred,1), tf.argmax(y,1))
accr = tf.reduce_mean(tf.cast(_corr, tf.float32))5.初始化变量，然后创建会话，训练
#初始化变量
init = tf.global_variables_initializer()
#创建会话
sess = tf.Session()
sess.run(init)
training_epochs = 15
batch_size = 16
display_step = 1
for epoch in range(training_epochs):
avg_cost = 0.#初始损失值为0
total_batch = 10
# Loop over all batches
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size)#每次取出batch_size个数值
# Fit training using batch data
sess.run(optm, feed_dict={x: batch_xs, y: batch_ys, keepratio:0.7})
# Compute average loss
avg_cost += sess.run(cost, feed_dict={x: batch_xs, y: batch_ys, keepratio:1.})/total_batch
# Display logs per epoch step
if epoch % display_step == 0:
print ("Epoch: %03d/%03d cost: %.9f" % (epoch, training_epochs, avg_cost))
train_acc = sess.run(accr, feed_dict={x: batch_xs, y: batch_ys, keepratio:1.})
print (" Training accuracy: %.3f" % (train_acc))
#test_acc = sess.run(accr, feed_dict={x: testimg, y: testlabel, keepratio:1.})
#print (" Test accuracy: %.3f" % (test_acc))
print ("OPTIMIZATION FINISHED")RNN
1.定义模型的参数
diminput = 28#输入（将28*28的图片：一行一行的输入,输入的结果为[1,28]）
dimhidden = 128#输入的隐层,隐层有128个神经元
dimoutput = nclasses#最终分成的类别数
nsteps = 28#将输入分成多少小份
#权重参数和偏置参数的初始化
weights = {
'hidden': tf.Variable(tf.random_normal([diminput, dimhidden])),
'out': tf.Variable(tf.random_normal([dimhidden, dimoutput]))
}
biases = {
'hidden': tf.Variable(tf.random_normal([dimhidden])),
'out': tf.Variable(tf.random_normal([dimoutput]))
}2.定义RNN的模型
def _RNN(_X, _W, _b, _nsteps, _name):
#1.进行维度的转换
#[batchsize, nsteps, diminput] 转换为[nsteps, batchsize, diminput]
_X = tf.transpose(_X, [1, 0, 2])#将_X的第一和第二维度进行调换
# 2. Reshape input to [nsteps*batchsize, diminput]
_X = tf.reshape(_X, [-1, diminput])
# 3. Input layer => Hidden layer（隐藏层）
#这里是共享权重,nsteps个weights全部一样的.
_H = tf.matmul(_X, _W['hidden']) + _b['hidden']#计算隐层的输出wx+b操作
# 4. Splite data to 'nsteps' chunks. An i-th chunck indicates i-th batch data
_Hsplit = tf.split(_H,num_or_size_splits=nsteps,axis=0)#切片操作：将_H切分成_nsteps份
# 5. Get LSTM's final output (_LSTM_O) and state (_LSTM_S)
# Both _LSTM_O and _LSTM_S consist of 'batchsize' elements
# Only _LSTM_O will be used to predict the output.
with tf.variable_scope(_name,reuse=tf.AUTO_REUSE):#重复使用参数节约空间,防止报错
#设计一个计算单元
lstm_cell = rnn.BasicLSTMCell(128,forget_bias=1.0)#刚开始不忽略节点数
#利用RNN单元搭建网络,这里用的最简单的,其它以后在说
_LSTM_O,_LSTM_S = rnn.static_rnn(lstm_cell,_Hsplit,dtype=tf.float32)
#6.输出结果
_O = tf.matmul(_LSTM_O[-1], _W['out']) + _b['out'] #取出最后一列的输出值，作为系统的最后输出。
# Return!
return {
'X': _X, 'H': _H, 'Hsplit': _Hsplit,
'LSTM_O': _LSTM_O, 'LSTM_S': _LSTM_S, 'O': _O
}
x = tf.placeholder("float", [None, nsteps, diminput])
y = tf.placeholder("float", [None, dimoutput])
myrnn = _RNN(x, weights, biases, nsteps, 'basic')3.相同的套路：定义损失函数与准确度
learning_rate = 0.001
pred = myrnn['O']#打印出输出的值
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
optm = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) # Adam Optimizer
accr = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(pred,1), tf.argmax(y,1)), tf.float32))
init = tf.global_variables_initializer()4.最后训练数据
training_epochs = 5
batch_size = 16
display_step = 1
sess = tf.Session()
sess.run(init)
print ("Start optimization")
for epoch in range(training_epochs):
avg_cost = 0.
#total_batch = int(mnist.train.num_examples/batch_size)
total_batch = 100
# Loop over all batches
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
batch_xs = batch_xs.reshape((batch_size, nsteps, diminput))
# Fit training using batch data
feeds = {x: batch_xs, y: batch_ys}
sess.run(optm, feed_dict=feeds)
# Compute average loss
avg_cost += sess.run(cost, feed_dict=feeds)/total_batch
# Display logs per epoch step
if epoch % display_step == 0:
print ("Epoch: %03d/%03d cost: %.9f" % (epoch, training_epochs, avg_cost))
feeds = {x: batch_xs, y: batch_ys}
train_acc = sess.run(accr, feed_dict=feeds)
print (" Training accuracy: %.3f" % (train_acc))
testimgs = testimgs.reshape((ntest, nsteps, diminput))
feeds = {x: testimgs, y: testlabels}
test_acc = sess.run(accr, feed_dict=feeds)
print (" Test accuracy: %.3f" % (test_acc))
print ("Optimization Finished.")查看准确度
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
