澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

学习笔记TF036

2019-10-12 作者:www.8455.com   |   浏览(164)

本节来介绍一下应用 KugaNN 的 LSTM 来做 MNIST 分类的不二秘技,RubiconNN 比较 CNN 来讲,速度恐怕会慢,但足以节约越来越多的内部存款和储蓄器空间。

双向循环神经网络(Bidirectional Recurrent Neural Networks,Bi-ENCORENN),Schuster、Paliwal,一九九八年第一回提议,和LSTM同年。Bi-奥德赛NN,扩展EnclaveNN可利用音信。普通MLP,数据长度有限量。PRADONN,能够管理不牢固长度时序数据,不只怕使用历史输入今后消息。Bi-MuranoNN,同一时间利用时序数据输入历史及前景多少,时序相反三个循环神经互连网连接同一输出,输出层能够相同的时候获取历史将来音信。

带头化 首先大家得以先开始化一些变量,如学习率、节点单元数、ENVISIONNN 层数等:

Language Modeling,不切合Bi-科雷傲NN,目的是由从前文预测下一单词,不可能将下文音讯传给模型。分类难题,手写文字识别、机器翻译、蛋白结构推断,Bi-QX56NN提高模型效果。百度语音识别,通过Bi-GL450NN综合上下文语境,进步模型准确率。

learning_rate = 1e-3
num_units = 256
num_layer = 3
input_size = 28
time_step = 28
total_steps = 2000
category_num = 10
steps_per_validate = 100
steps_per_test = 500
batch_size = tf.placeholder(tf.int32, [])
keep_prob = tf.placeholder(tf.float32, [])

Bi-RubiconNN网络布局基本,普通单向CR-VNN拆成八个方向,随即序正向,逆时序反赂。当前些天子节点输出,同一时候选用正向、反向三个趋势信息。多少个分化方向GL450NN不共用state,正向牧马人NN输出state只传给正向本田UR-VNN,反向ENVISIONNN输出state只传给反向奥迪Q3NN,正面与反面向QashqaiNN未有一贯连接。每种时间节点输入,分别传给正面与反面向TiggoNN,依照各自意况发生输出,两份输出一齐接二连三到Bi-ENVISIONNN输出节点,共同合成最后输出。对当下光阴节点输出进献(或loss),在磨炼中总结出来,参数依据梯度优化到合适值。

 

Bi-HavalNN练习,正面与反面向XC60NN未有交集,分别展开普通前馈网络。BPTT(back-propagation through time)算法磨练,无法同期立异意况、输出。正向state在t=1时一窍不通,反向state在t=T时未知,state在正面与反面向开端处未知,需人工设置。正向状态导数在t=T时未知,反向状态导数在t=1时一窍不通,state导数在正面与反面向结晶尾处未知,需设0代表参数更新不重大。

接下来还索要声美素佳儿(Friso)(Beingmate)下 MNIST 数据生成器:

千帆竞发锻炼,第一步,输入数据forward pass操作,inference操作,先沿1->T方向总括正向福睿斯NN state,再沿T->1方向总结反向奇骏NN state,获得输出output。第二步,backward pass操作,目的函数求导操作,先求导输出output,先沿T->1方向总结正向本田UR-VNN state导数,再沿1->T方向计算反向CRUISERNN state导数。第三步,依据求得梯度值更新模型参数,完结练习。

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)

Bi-奥迪Q5NN每种奥迪Q3NN单元,能够是观念瑞鹰NN,可以是LSTM或GRU单元。能够在一层Bi-CRUISERNN上再叠合一层Bi-翼虎NN,上层Bi-SportageNN输出作下层Bi-RAV4NN输入,能够更上一层楼抽象提炼特征。分类任务,Bi-TiguanNN输出类别连接全连接层,或三翻五次全局平均池化Global Average Pooling,再接Softmax层,和卷积网络同样。

 

TensorFlow完成Bidirectional LSTM Classifier,在MNIST数据集测量检验。载入TensorFlow、NumPy、TensorFlow自带MNIST数据读取器。input_data.read_data_sets下载读取MNIST数据集。

接下去常规声美素佳儿(Friso)下输入的数码,输入数据用 x 表示,标明数据用 y_label 表示:

设置练习参数。设置学习速率 0.01,优化器选择Adam,学习速率低。最大练习样本数 40万,batch_size 128,设置每隔十次磨练体现陶冶情形。

x = tf.placeholder(tf.float32, [None, 784])
y_label = tf.placeholder(tf.float32, [None, 10])

MNIST图像尺寸 28x28,输入n_input 28(图像宽),n_steps LSTM展开步数(unrolled steps of LSTM),设28(图像高),图像全体音信用上。三次读取一行像素(二十九个像素点),下个时间点再扩散下一行像素点。n_hidden(LSTM隐蔽节点数)设256,n_classes(MNIST数据集分类数目)设10。

 

成立输入x和学习指标y 的place_holder。输入x各个样本直接用二维结构。样本为八个光阴连串,第一维度 时间点n_steps,第二维度 每一种时刻点数据n_input。设置Softmax层weights和biases,tf.random_normal开首化参数。双向LSTM,forward、backward五个LSTM cell,weights参数数量翻倍,2*n_hidden。

此间输入的 x 维度是 [None, 784],代表 batch_size 不分明,输入维度 784,y_label 同理。

定义Bidirectional LSTM互连网生成函数。形状(batch_size,n_steps,n_input)输入变长度n_steps列表,成分造型(batch_size,n_input)。输入转置,tf.transpose(x,[1,0,2]),第一维度batch_size,第二维度n_steps,交换。tf.reshape,输入x变(n_steps*batch_size,n_input)形状。 tf.split,x拆成长度n_steps列表,列表逐个tensor尺寸(batch_size,n_input),切合LSTM单元输入格式。tf.contrib.rnn.BasicLSTMCell,创造forward、backward LSTM单元,掩饰节点数设n_hidden,forget_bias设1。正向lstm_fw_cell和反向lstm_bw_cell传入Bi-RNN接口tf.nn.bidirectional_rnn,生成双向LSTM,传入x输入。双向LSTM输出结果output做矩阵乘法加偏置,参数为日前定义weights、biases。

接下去我们须要对输入的 x 进行 reshape 操作,因为大家须求将一张图分为几个time_step 来输入,那样技术创设一个 TiguanNN 系列,所以这里直接将 time_step 设成 28,那样一来 input_size 就成为了 28,batch_size 不改变,所以reshape 的结果是二个三个维度的矩阵:

谈到底输出结果,tf.nn.softmax_cross_entropy_with_logits,Softmax处理总计损失。tf.reduce_mean计算平均cost。优化器Adam,学习速率learning_rate。tf.argmax获得模型预测体系,tf.equal剖断是还是不是预测准确。tf.reduce_mean求平均精确率。

x_shape = tf.reshape(x, [-1, time_step, input_size])

施行陶冶和测试操作。实践开头化参数,定义七个练习循环,保持总练习样本数(迭代数*batch_size)小于设定值。每轮磨炼迭代,mnist.train.next_batch获得三个batch数据,reshape改造形状。包涵输入x和演习指标y的feed_dict传入,试行教练操作,更新模型参数。迭代数display_step整好多倍,计算当前batch数据展望正确率、loss,体现。

 

学习笔记TF036。整个锻练迭代结果,陶冶好模型,mnist.test.images全部育项目检测试数据展望,体现正确率。

奥迪Q5NN 层 接下来我们必要创设三个 PAJERONN 模型了,这里大家使用的 LacrosseNN Cell 是 LSTMCell,何况要搭建一个三层的 LX570NN,所以这里还亟需用到 MultiENVISIONNNCell,它的输入参数是 LSTMCell 的列表。

学习笔记TF036。达成40万样本练习,练习集预测正确率基本是1,一千0样本测量检验集0.983正确率。

为此大家得以先声雅培(Abbott)个格局用于创立 LSTMCell,方法如下:

Bidirectional LSTM Classifier,MNIST数据集表现不及卷积神经互联网。Bi-HighlanderNN、双向LSTM互联网,时间体系分类任务表现越来越好,同一时间利用时间序列历史和前程音讯,结合上下文音信,结果综合判别。

def cell(num_units):
    cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=num_units)
    return DropoutWrapper(cell, output_keep_prob=keep_prob)
import tensorflow as tf
import numpy as np
# Import MINST data
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
# Parameters
learning_rate = 0.01
max_samples = 400000
batch_size = 128
display_step = 10
# Network Parameters
n_input = 28 # MNIST data input (img shape: 28*28)
n_steps = 28 # timesteps
n_hidden = 256 # hidden layer num of features
n_classes = 10 # MNIST total classes (0-9 digits)
# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_classes])
# Define weights
weights = {
    # Hidden layer weights => 2*n_hidden because of foward   backward cells
    'out': tf.Variable(tf.random_normal([2*n_hidden, n_classes]))
}
biases = {
    'out': tf.Variable(tf.random_normal([n_classes]))
}
def BiRNN(x, weights, biases):
    # Prepare data shape to match `bidirectional_rnn` function requirements
    # Current data input shape: (batch_size, n_steps, n_input)
    # Required shape: 'n_steps' tensors list of shape (batch_size, n_input)

    # Permuting batch_size and n_steps
    x = tf.transpose(x, [1, 0, 2])
    # Reshape to (n_steps*batch_size, n_input)
    x = tf.reshape(x, [-1, n_input])
    # Split to get a list of 'n_steps' tensors of shape (batch_size, n_input)
    x = tf.split(x, n_steps)
    # Define lstm cells with tensorflow
    # Forward direction cell
    lstm_fw_cell = tf.contrib.rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)
    # Backward direction cell
    lstm_bw_cell = tf.contrib.rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)
    # Get lstm cell output
#    try:
    outputs, _, _ = tf.contrib.rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, x,
                                       dtype=tf.float32)
#    except Exception: # Old TensorFlow version only returns outputs not states
#        outputs = rnn.bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, x,
#                                        dtype=tf.float32)
    # Linear activation, using rnn inner loop last output
    return tf.matmul(outputs[-1], weights['out'])   biases['out']

pred = BiRNN(x, weights, biases)
# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# Initializing the variables
init = tf.global_variables_initializer()
# Launch the graph
with tf.Session() as sess:
    sess.run(init)
    step = 1
    # Keep training until reach max iterations
    while step * batch_size < max_samples:
        batch_x, batch_y = mnist.train.next_batch(batch_size)
        # Reshape data to get 28 seq of 28 elements
        batch_x = batch_x.reshape((batch_size, n_steps, n_input))
        # Run optimization op (backprop)
        sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
        if step % display_step == 0:
            # Calculate batch accuracy
            acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y})
            # Calculate batch loss
            loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})
            print("Iter "   str(step*batch_size)   ", Minibatch Loss= "   
                  "{:.6f}".format(loss)   ", Training Accuracy= "   
                  "{:.5f}".format(acc))
        step  = 1
    print("Optimization Finished!")
    # Calculate accuracy for 128 mnist test images
    test_len = 10000
    test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
    test_label = mnist.test.labels[:test_len]
    print("Testing Accuracy:", 
        sess.run(accuracy, feed_dict={x: test_data, y: test_label}))

 

参谋资料:
《TensorFlow实战》

此地还加入了 Dropout,来减少操练进程中的过拟合。

应接付费咨询(150元每小时),作者的微信:qingxingfengzi

接下去咱们再利用它来构建多层的 科雷傲NN:

cells = tf.nn.rnn_cell.MultiRNNCell([cell(num_units) for _ in range(num_layer)])

 

只顾这里运用了 for 循环,每循环一遍新生成一个LSTMCell,实际不是向来利用乘法来扩充列表,因为这么会促成 LSTMCell 是同三个对象,导致营造完 Multi奇骏NNCell 之后出现维度不包容的主题材料。

接下去大家需求声可瑞康(Karicare)(Nutrilon)个早先状态:

h0 = cells.zero_state(batch_size, dtype=tf.float32)

 

下一场接下去调用 dynamic_rnn() 方法就可以达成模型的创设了:

output, hs = tf.nn.dynamic_rnn(cells, inputs=x_shape, initial_state=h0)

 

这里 inputs 的输入就是 x 做了 reshape 之后的结果,初阶状态通过 initial_state 传入,其回到结果有多少个,贰个 output 是富有 time_step 的输出结果,赋值为 output,它是三维的,第一维长度等于 batch_size,第二维长度等于 time_step,第三维长度等于 num_units。另多个 hs 是包蕴状态,是元组情势,长度即 哈弗NN 的层数 3,每一个因素都富含了 c 和 h,即 LSTM 的多个带有状态。

那样的话 output 的最后结出能够取最终叁个 time_step 的结果,所以能够使用:

output = output[:, -1, :]

 

依然直接取掩饰状态最终一层的 h 也是千篇一律的:

h = hs[-1].h

 

在这里模型中,二者是等价的。但注意假设用于文本管理,恐怕由于文本长度不一,而 padding,导致三头差别。

输出层 接下来我们再做一遍线性别变化换和 Softmax 输出结果就能够:

# Output Layer
w = tf.Variable(tf.truncated_normal([num_units, category_num], stddev=0.1), dtype=tf.float32)
b = tf.Variable(tf.constant(0.1, shape=[category_num]), dtype=tf.float32)
y = tf.matmul(output, w)   b
# Loss
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=y_label, logits=y)

 

那边的 Loss 直接调用了 softmax_cross_entropy_with_logits 先总计了 Softmax,然后总结了交叉熵。

练习和评估 最终再定义练习和评估的流程就可以,在教练进程中每间距一定的 step 就输出 Train Accuracy 和 Test Accuracy:

# Train
train = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cross_entropy)

# Prediction
correction_prediction = tf.equal(tf.argmax(y, axis=1), tf.argmax(y_label, axis=1))
accuracy = tf.reduce_mean(tf.cast(correction_prediction, tf.float32))

# Train
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for step in range(total_steps   1):
        batch_x, batch_y = mnist.train.next_batch(100)
        sess.run(train, feed_dict={x: batch_x, y_label: batch_y, keep_prob: 0.5, batch_size: batch_x.shape[0]})
        # Train Accuracy
        if step % steps_per_validate == 0:
            print('Train', step, sess.run(accuracy, feed_dict={x: batch_x, y_label: batch_y, keep_prob: 0.5,
                                                               batch_size: batch_x.shape[0]}))
        # Test Accuracy
        if step % steps_per_test == 0:
            test_x, test_y = mnist.test.images, mnist.test.labels
            print('Test', step,
                  sess.run(accuracy, feed_dict={x: test_x, y_label: test_y, keep_prob: 1, batch_size: test_x.shape[0]}))

 

运维 直接运营之后,只陶冶了几轮就可以高达 98% 的正确率:

Train 0 0.27
Test 0 0.2223
Train 100 0.87
Train 200 0.91
Train 300 0.94
Train 400 0.94
Train 500 0.99
Test 500 0.9595
Train 600 0.95
Train 700 0.97
Train 800 0.98

 

可以看出来 LSTM 在做 MNIST 字符分类的任务上只怕相比较灵通的。

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:学习笔记TF036

关键词: