tensorflow的简单使用

介绍

• 通过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.")

查看准确度