您的位置:新葡亰496net > 奥门新萄京娱乐场 > 学习笔记TF036

学习笔记TF036

发布时间:2019-09-22 11:06编辑:奥门新萄京娱乐场浏览(109)

    本节来介绍一下选择 EvoqueNN 的 LSTM 来做 MNIST 分类的点子,EvoqueNN 相比较 CNN 来讲,速度或许会慢,但能够省去更加多的内部存款和储蓄器空间。

    芝麻HTTP:TensorFlow LSTM MNIST分类,tensorflowlstm

    本节来介绍一下应用 RubiconNN 的 LSTM 来做 MNIST 分类的形式,途乐NN 比较 CNN 来讲,速度只怕会慢,但足以节省越来越多的内部存款和储蓄器空间。

    双向循环神经互连网(Bidirectional Recurrent Neural Networks,Bi-XC90NN),Schuster、Paliwal,一九九七年第贰回提议,和LSTM同年。Bi-中华VNN,扩大LX570NN可利用音信。普通MLP,数据长度有限制。SportageNN,能够管理不稳固长度时序数据,无法采纳历史输入以往新闻。Bi-RAV4NN,相同的时间使用时序数据输入历史及今后数码,时序相反四个循环神经网络连接同一输出,输出层能够况兼获得历史以往新闻。

    学学笔记TF036:完成Bidirectional LSTM Classifier,tf036bidirectional

    双向循环神经互联网(Bidirectional Recurrent Neural Networks,Bi-CR-VNN),Schuster、Paliwal,一九九八年第三次建议,和LSTM同年。Bi-CRUISERNN,扩展昂CoraNN可使用新闻。普通MLP,数据长度有限制。酷路泽NN,能够拍卖不稳固长度时序数据,非常的小概利用历史输入今后音讯。Bi-帕杰罗NN,同期接纳时序数据输入历史及未来数据,时序相反三个循环神经网络连接同一输出,输出层可以而且猎取历史今后音信。

    Language Modeling,不适合Bi-凯雷德NN,指标是通过前文预测下一单词,不能够将下文音信传给模型。分类难题,手写文字识别、机译、蛋白结构测度,Bi-PAJERONN升高模型效果。百度语音识别,通过Bi-LX570NN综合上下文语境,升高模型精确率。

    Bi-SportageNN互联网布局基本,普通单向奥迪Q3NN拆成多少个趋势,随时序正向,逆时序反赂。当前时刻节点输出,同不常候利用正向、反向四个样子信息。五个例外偏侧奥迪Q3NN不共用state,正向奥迪TT RSNN输出state只传给正向TiguanNN,反向CRUISERNN输出state只传给反向SportageNN,正面与反面向本田CR-VNN未有间接连接。每一个日子节点输入,分别传给正面与反面向福特ExplorerNN,根据各自情况发生输出,两份输出一起三番五次到Bi-EnclaveNN输出节点,共同合成最后输出。对领后天子节点输出进献(或loss),在教练中计算出来,参数根据梯度优化到合适值。

    Bi-LX570NN磨练,正面与反面向奥迪Q5NN未有交集,分别开展普通前馈网络。BPTT(back-propagation through time)算法练习,不可能同期更新意况、输出。正向state在t=1时不解,反向state在t=T时未知,state在正面与反面向起始处未知,需人工设置。正向状态导数在t=T时未知,反向状态导数在t=1时不解,state导数在正面与反面向结晶尾处未知,需设0代表参数更新不首要。

    早先磨练,第一步,输入数据forward pass操作,inference操作,先沿1->T方向计算正向汉兰达NN state,再沿T->1方向总括反向汉兰达NN state,获得输出output。第二步,backward pass操作,指标函数求导操作,先求导输出output,先沿T->1方向总结正向CRUISERNN state导数,再沿1->T方向总结反向君越NN state导数。第三步,依照求得梯度值更新模型参数,完毕陶冶。

    Bi-KugaNN每个SportageNN单元,能够是价值观RAV4NN,能够是LSTM或GRU单元。能够在一层Bi-昂CoraNN上再叠合一层Bi-宝马X5NN,上层Bi-本田CR-VNN输出作下层Bi-汉兰达NN输入,能够特别抽象提炼特征。分类义务,Bi-MuranoNN输出体系连接全连接层,或三番五次全局平均池化Global Average Pooling,再接Softmax层,和卷积网络同样。

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

    安装陶冶参数。设置学习速率 0.01,优化器选拔Adam,学习速率低。最大练习样本数 40万,batch_size 128,设置每间隔十回陶冶展现磨练景况。

    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。

    定义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。

    最后输出结果,tf.nn.softmax_cross_entropy_with_logits,Softmax管理总括损失。tf.reduce_mean计算平均cost。优化器Adam,学习速率learning_rate。tf.argmax获得模型预测连串,tf.equal推断是还是不是预测准确。tf.reduce_mean求平均准确率。

    实施教练和测量试验操作。施行初步化参数,定义贰个练习循环,保持总练习样本数(迭代数*batch_size)小于设定值。每轮流培陶冶迭代,mnist.train.next_batch得到多少个batch数据,reshape改动形象。包蕴输入x和教练目的y的feed_dict传入,推行教练操作,更新模型参数。迭代数display_step整好数倍,总计当前batch数据展望正确率、loss,体现。

    全方位练习迭代结果,操练好模型,mnist.test.images全体育项目检验试数据展望,体现正确率。

    完了40万样本磨炼,磨炼集预测正确率基本是1,10000样本测验集0.983正确率。

    Bidirectional LSTM Classifier,MNIST数据集表现不比卷积神经网络。Bi-CR-VNN、双向LSTM互联网,时间体系分类职责表现越来越好,同有时候接纳时间体系历史和前途新闻,结合上下文音讯,结果综合推断。

        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实战》

    应接付费咨询(150元每刻钟),小编的微信:qingxingfengzi

    LSTM Classifier,tf036bidirectional 双向循环神经网络(Bidirectional Recurrent Neural Networks,Bi-ENVISIONNN),舒斯特尔、Paliwal,1998年第贰遍...

    双向循环神经网络(Bidirectional Recurrent Neural Networks,Bi-EvoqueNN),舒斯特尔、Paliwal,1996年第二次提议,和LSTM同年。Bi-奥迪Q7NN,扩张安德拉NN可利用消息。普通MLP,数据长度有限制。本田CR-VNN,可以管理不固定长度时序数据,无法使用历史输入今后新闻。Bi-LX570NN,同期利用时序数据输入历史及前景多少,时序相反五个循环神经互连网连接同一输出,输出层能够同一时候获取历史今后新闻。

    初阶化 首先大家能够先起首化一些变量,如学习率、节点单元数、SportageNN 层数等:

    初始化

    首先大家能够先初步化一些变量,如学习率、节点单元数、大切诺基NN 层数等:

    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, [])
    

    接下来还索要声澳优下 MNIST 数据生成器:

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

    接下去常规声喜宝下输入的数据,输入数据用 x 表示,注解数据用 y_label 表示:

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

    那边输入的 x 维度是 [None, 784],代表 batch_size 不显明,输入维度 784,y_label 同理。

    接下去大家必要对输入的 x 进行 reshape 操作,因为大家需求将一张图分为多少个time_step 来输入,那样才能塑造四个 陆风X8NN 类别,所以那边一直将 time_step 设成 28,那样一来 input_size 就形成了 28,batch_size 不改变,所以reshape 的结果是四个三个维度的矩阵:

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

    Language Modeling,不适合Bi-科雷傲NN,指标是经过前文预测下一单词,无法将下文新闻传给模型。分类难点,手写文字识别、机译、蛋白结构推测,Bi-HavalNN进步模型效果。百度语音识别,通过Bi-QashqaiNN综合上下文语境,进步模型正确率。

    Language Modeling,不适合Bi-LacrosseNN,指标是通过前文预测下一单词,无法将下文音信传给模型。分类难题,手写文字识别、机译、蛋白结构揣摸,Bi-ENCORENN提高模型效果。百度语音识别,通过Bi-奥德赛NN综合上下文语境,提高模型精确率。

    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, [])
    

    RNN 层

    接下去大家供给创设四个 LX570NN 模型了,这里大家运用的 GL450NN Cell 是 LSTMCell,而且要搭建一个三层的 猎豹CS6NN,所以这里还须要用到 MultiTucsonNNCell,它的输入参数是 LSTMCell 的列表。

    就此大家能够先声澳优个情势用于创设 LSTMCell,方法如下:

    def cell(num_units):
        cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=num_units)
        return DropoutWrapper(cell, output_keep_prob=keep_prob)
    

    此处还加入了 Dropout,来裁减锻练进度中的过拟合。

    接下去大家再选用它来营造多层的 QX56NN:

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

    当心这里运用了 for 循环,每循环贰次新生成二个LSTMCell,并非平昔动用乘法来扩大列表,因为那样会促成 LSTMCell 是同叁个对象,导致构建完 MultiRubiconNNCell 之后出现维度不包容的难题。

    接下去我们供给声美素佳儿(Beingmate)个从头状态:

    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 是包罗状态,是元组方式,长度即 ENVISIONNN 的层数 3,每一个因素都包含了 c 和 h,即 LSTM 的八个带有状态。

    那样的话 output 的末段结果可以取最后三个 time_step 的结果,所以能够采纳:

    output = output[:, -1, :]
    

    抑或直接取遮掩状态最后一层的 h 也是完全一样的:

    h = hs[-1].h
    

    在此模型中,二者是等价的。但注意假诺用于文本管理,或然出于文本长度不一,而 padding,导致两方差异。

    Bi-LANDNN互联网布局为主,普通单向宝马7系NN拆成几个样子,随时序正向,逆时序反赂。当前时间节点输出,同时利用正向、反向多个方向音信。五个例外偏向ENVISIONNN不共用state,正向大切诺基NN输出state只传给正向CR-VNN,反向QX56NN输出state只传给反向翼虎NN,正面与反面向福特ExplorerNN未有直接连接。每一个时刻节点输入,分别传给正反向讴歌RDXNN,根据各自意况发生输出,两份输出一齐三番五次到Bi-SportageNN输出节点,共同合成最后输出。对近来时刻节点输出进献(或loss),在陶冶中计算出来,参数依据梯度优化到合适值。

    Bi-CRUISERNN互联网布局基本,普通单向宝马X3NN拆成四个方向,随时序正向,逆时序反赂。当前几日子节点输出,相同的时候使用正向、反向八个趋势消息。多个差别方向卡宴NN不共用state,正向EscortNN输出state只传给正向奥迪Q5NN,反向凯雷德NN输出state只传给反向ENCORENN,正面与反面向猎豹CS6NN未有一贯连接。各个时间节点输入,分别传给正面与反面向RAV4NN,依照各自景况产生输出,两份输出一同一连到Bi-凯雷德NN输出节点,共同合成最后输出。对当下光阴节点输出进献(或loss),在训练中总括出来,参数依照梯度优化到合适值。

     

    输出层

    接下去大家再做一次线性调换和 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,然后总括了交叉熵。

    Bi-EscortNN陶冶,正面与反面向冠道NN没有交集,分别张开普通前馈网络。BPTT(back-propagation through time)算法陶冶,不可能同期更新意况、输出。正向state在t=1时一窍不通,反向state在t=T时未知,state在正面与反面向开首处未知,需人工设置。正向状态导数在t=T时未知,反向状态导数在t=1时不解,state导数在正面与反面向结晶尾处未知,需设0代表参数更新不主要。

    Bi-CR-VNN磨练,正面与反面向昂CoraNN未有交集,分别实行普通前馈互联网。BPTT(back-propagation through time)算法练习,无法同临时间创新景况、输出。正向state在t=1时不敢问津,反向state在t=T时未知,state在正面与反面向开首处未知,需人工设置。正向状态导数在t=T时未知,反向状态导数在t=1时不敢问津,state导数在正面与反面向结晶尾处未知,需设0代表参数更新不重大。

    接下来还索要声多美滋下 MNIST 数据生成器:

    教练和评估

    末段再定义操练和评估的流水生产线就可以,在演练进程中每隔一定的 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]}))
    

    开班磨练,第一步,输入数据forward pass操作,inference操作,先沿1->T方向总括正向ENVISIONNN state,再沿T->1方向计算反向凯雷德NN state,获得输出output。第二步,backward pass操作,目的函数求导操作,先求导输出output,先沿T->1方向总结正向奥德赛NN state导数,再沿1->T方向计算反向奥迪Q3NN state导数。第三步,遵照求得梯度值更新模型参数,完毕磨练。

    开始磨练,第一步,输入数据forward pass操作,inference操作,先沿1->T方向总计正向LANDNN state,再沿T->1方向总结反向LANDNN state,获得输出output。第二步,backward pass操作,目的函数求导操作,先求导输出output,先沿T->1方向计算正向奔驰M级NN state导数,再沿1->T方向计算反向智跑NN state导数。第三步,依照求得梯度值更新模型参数,达成练习。

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

    运行

    直白运维之后,只演习了几轮就能够达到规定的标准 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 字符分类的天职上恐怕比较有效的。

    LSTM MNIST分类,tensorflowlstm 本节来介绍一下使用 LANDNN 的 LSTM 来做 MNIST 分类的不二秘诀,途锐NN 相比较 CNN 来讲,速度或然会慢,但足以...

    Bi-卡宴NN各个ENVISIONNN单元,能够是古板PAJERONN,能够是LSTM或GRU单元。能够在一层Bi-LANDNN上再叠合一层Bi-SportageNN,上层Bi-揽胜NN输出作下层Bi-MuranoNN输入,能够进一步抽象提炼特征。分类职分,Bi-福睿斯NN输出种类连接全连接层,或三番五次全局平均池化Global Average Pooling,再接Softmax层,和卷积网络相同。

    Bi-PAJERONN各样帕杰罗NN单元,能够是价值观PAJERONN,能够是LSTM或GRU单元。能够在一层Bi-QX56NN上再叠合一层Bi-瑞鹰NN,上层Bi-福特ExplorerNN输出作下层Bi-LX570NN输入,能够越发抽象提炼特征。分类任务,Bi-凯雷德NN输出类别连接全连接层,或延续全局平均池化Global Average Pooling,再接Softmax层,和卷积互连网一样。

     

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

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

    接下去常规声多美滋下输入的多寡,输入数据用 x 表示,申明数据用 y_label 表示:

    设置磨练参数。设置学习速率 0.01,优化器采取Adam,学习速率低。最大磨练样本数 40万,batch_size 128,设置每间隔十三回陶冶呈现陶冶情状。

    设置操练参数。设置学习速率 0.01,优化器选取Adam,学习速率低。最大练习样本数 40万,batch_size 128,设置每间隔11次磨炼显示磨练情状。

    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。

    MNIST图像尺寸 28x28,输入n_input 28(图像宽),n_steps LSTM张开步数(unrolled steps of LSTM),设28(图像高),图像全体音讯用上。贰回读取一行像素(贰16个像素点),下个小时点再盛传下一行像素点。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和读书目标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。

    定义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 来输入,那样才具营造一个 奥迪Q5NN 体系,所以这里直接将 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求平均正确率。

    末尾输出结果,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,体现。

    实行陶冶和测量试验操作。推行伊始化参数,定义二个教练循环,保持总磨练样本数(迭代数*batch_size)小于设定值。每轮流培磨练迭代,mnist.train.next_batch得到叁个batch数据,reshape改造造型。富含输入x和磨炼目的y的feed_dict传入,试行教练操作,更新模型参数。迭代数display_step整几倍,计算当前batch数据预测精确率、loss,体现。

     

    全套教练迭代结果,磨炼好模型,mnist.test.images全体育项目检查评定试数据预测,呈现精确率。

    全部教练迭代结果,演练好模型,mnist.test.images全体育项目检测试数据展望,显示正确率。

    奥迪Q5NN 层 接下来大家须要构建一个 瑞虎NN 模型了,这里我们使用的 奥迪Q5NN Cell 是 LSTMCell,而且要搭建三个三层的 ENVISIONNN,所以那边还索要用到 Multi凯雷德NNCell,它的输入参数是 LSTMCell 的列表。

    完了40万样本锻炼,磨炼集预测精确率基本是1,一千0样本测量试验集0.983正确率。

    做到40万样本练习,练习集预测正确率基本是1,一千0样本测验集0.983正确率。

    由此大家能够先声美素佳儿(Friso)个主意用于成立 LSTMCell,方法如下:

    Bidirectional LSTM Classifier,MNIST数据集表现比不上卷积神经互连网。Bi-TiguanNN、双向LSTM网络,时间种类分类职责表现更加好,同不时间利用时间体系历史和前景音讯,结合上下文新闻,结果综合判定。

    Bidirectional LSTM Classifier,MNIST数据集表现比不上卷积神经互连网。Bi-路虎极光NN、双向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}))
    
        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

    参谋资料:
    学习笔记TF036。《TensorFlow实战》

    接下去大家再利用它来营造多层的 LX570NN:

    迎接付费咨询(150元每小时),小编的微信:qingxingfengzi

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

     

    小心这里运用了 for 循环,每循环贰遍新生成一个LSTMCell,并不是一贯动用乘法来增添列表,因为这样会促成 LSTMCell 是同一个对象,导致创设完 MultiOdysseyNNCell 之后现身维度不包容的标题。

    接下去大家供给声爱他美(Dumex)个开始状态:

    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 是包罗状态,是元组方式,长度即 WranglerNN 的层数 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 字符分类的天职上或然比较灵通的。

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:学习笔记TF036

    关键词: