深度学习原理与框架-递归神经网络-RNN_exmaple(代码) 1.rnn.BasicLSTMCell(构造基本网络) 2.tf.nn.dynamic_rnn(执行rnn网络) 3.tf.expand_dim(增加输入数据的维度) 4.tf.tile(在某个维度上按照倍数进行平铺迭代) 5.tf.squeeze(去除维度上为1的维度)

1. rnn.BasicLSTMCell(num_hidden) #  构造单层的lstm网络结构

参数说明:num_hidden表示隐藏层的个数

2.tf.nn.dynamic_rnn(cell, self.x, tf.float32) # 执行lstm网络,获得state和outputs

参数说明:cell表示实例化的rnn网络,self.x表示输入层,tf.float32表示类型

3. tf.expand_dim(self.w, axis=0) 对数据增加一个维度

参数说明:self.w表示需要增加的数据维度,axis表示哪个维度进行增加

4. tf.tile(tf_expand, [num_example, 1, 1]) # 延某个方向进行平铺操作

参数说明:tf_expand表示输入的数据, [num_example, 1, 1] 表示延第一个维度进行num_example倍的平铺迭代

sess = tf.Session()
x = tf.constant([[1,2,1],[1,2,1]])
y = tf.tile(x, [2,1])
print(sess.run(y))# 代码结果

[[1 2 1]
[1 2 1]
[1 2 1]
[1 2 1]]

5.tf.squeeze(out) # 将维度上为1的维度都进行去除, 代码中将[?, 4, 1] 变成了[?, 4]

参数说明:out为输入数据

代码说明:代码使用了类的构造方式,在初始化阶段,进行参数和输入数据的初始化,同时使用self.model() 构造输出结果y_pred即?, 4, 返回的结果,在初始化过程中,使用tf.reduce_mean(tf.square(y - self.model))计算损失值,使用梯度下降进行优化,使用self.train和self.test输入实际值, 进行模型的训练和预测

数据说明:自己构造[?, 4, 1] 的数据集,数据集的规律是前两个相加等于预测结果,预测样本的维度为[?, 4] 压缩了最后一个维度

模型说明:使用的是单层的cell = rnn.LTSMCell(hidden_num),使用tf.nn.dynamic_rnn(cell, self.x, shape=tf.float32) , 获得输出值维度为[?, 4, 10]

代码主要分为三个部分:

第一部分:主要是构造初始参数,以及self.model() 进行模型的结果输出即y_pred, 对返回值使用均分误差,并使用自适应梯度下降降低损失值,同时构造self.Saver()

第二部分:构造输入函数self.train(self, train_x, train_y) 进行模型的训练,使用self.Saver.save(sess, ‘./model‘) 进行模型的参数的保存

第三部分:构造输入函数self.test(self.test_x) 进行模型的预测, 使用self.Saver.restore(sess, ‘./model‘) 进行模型参数的加载

第一部分:

第一步:构造类SeriesPredictor, 使用self.input_size = input_size 将输入转换为内部使用的数

第二步:使用tf.placeholder构造x的维度为[None, seq_size, input_size], 构造y的维度为[None, seq_size], 使用tf.Variable()构造W的维度为[hidden_num, 1], 构造b的维度为[1]

第三步:构造self.model() 用于获得预测值y_pred

第一步:使用rnn.BasicLSTMCell(self.hidden_num) 构造单层的LSTM网络

第二步: 使用tf.nn.dynamic_rnn(cell, self.x, shape=tf.float32)获得outputs和states的输出值,outputs的维度为[?, 4, 10]

第三步:使用tf.shape(self.x)[0] 获得self.x的样品数目

第四步:使用tf.expand_dim增加self.w_out的维度, 再使用tf.tile(tf_expand, [num_examples, 1, 1]) 将第一个维度的大小变得和样本数目self.x的大小相等

第五步:使用tf.matmul(self.x, tf_tile) + self.b_out 获得输出值

第六步:使用tf.squeeze(out)  将out的维度从[?, 4, 1]压缩为[?, 4]

第四步:将self.model() 返回的输出值与self.y 做均分误差用于计算损失值

第五步:tf.train.Adaoptimzer().minimize(cost) # 用于进行损失值的梯度下降

第六步:使用tf.Saver() 构建每个类的存储函数

import tensorflow as tf
import numpy as np
from tensorflow.contrib import rnn

class SeriesPredictor:

    def __init__(self, input_size, seq_size, hidden_num):

        self.input_size = input_size
        self.seq_size = seq_size
        self.hidden_num = hidden_num

        # 使用tf.placeholder设置x和y, 并且设置W, b
        self.W_out = tf.Variable(tf.random_normal([hidden_num, 1]), name=‘W_out‘)
        self.b_out = tf.Variable(tf.constant(0.1, shape=[1]), name=‘b_out‘)
        self.x = tf.placeholder(tf.float32, [None, seq_size, input_size])
        self.y = tf.placeholder(tf.float32, [None, seq_size])

        self.cost = tf.reduce_mean(tf.square(self.model() - self.y))
        self.train_op = tf.train.AdamOptimizer().minimize(self.cost)

        self.saver = tf.train.Saver()

    def model(self):

        cell = rnn.BasicLSTMCell(self.hidden_num)
        outputs, states = tf.nn.dynamic_rnn(cell, self.x, dtype=tf.float32)
        num_example = tf.shape(self.x)[0]

        tf_expand = tf.expand_dims(self.W_out, axis=0)
        tf_tile = tf.tile(tf_expand, [num_example, 1, 1])
        out = tf.matmul(outputs, tf_tile) + self.b_out
        out = tf.squeeze(out)

        return out

第二部分:在类中构建train函数,输入train_x, train_y 进行模型的训练

第一步:构建sess, tf.get_variable_scope().reuse_variable() 进行模型的参数的复用, 模型的初始化

第二步:sess.run([train_op, cost], feed_dict=) 执行降低损失值和计算cost的操作

第三步:每循环200次,打印损失值和迭代次数i

第四步:self.saver.save(sess, ‘./model‘) # 将模型参数的sess进行保存

    def train(self, train_x, train_y):        # 第一步:构建sess,
        with tf.Session() as sess:            # 模型参数的复用
            tf.get_variable_scope().reuse_variables()            # 模型初始化
            sess.run(tf.global_variables_initializer())
            for i in range(1000):                  # 第二步:执行降低损失值和计算cost
                _, mse = sess.run([self.train_op, self.cost], feed_dict={self.x:train_x, self.y:train_y})                  # 第三步:每循环200次,打印结果
                if i % 200 == 0:
                    print(i, mse)
            # 第四步:保存sess的参数
            save_path = self.saver.save(sess, ‘./model‘)
            print(‘Model saved to {}‘.format(save_path))

第三部分:构建test函数,输入为test_x, 加载sess参数,进行模型的预测

第一步:构建sess函数,使用tf.get_variable_scope().reuse_variable() 进行参数的复用

第二步:使用self.saver.restore(sess, ‘./model‘) # 进行参数的加载

第三步:使用sess.run(self.model(), feed_dict={self.x:test_x})  获得实际的预测值y_pred,返回预测的结果

    def test(self, test_x):
        # 第一步:构建sess,并进行模型参数的复用
        with tf.Session() as sess:
            tf.get_variable_scope().reuse_variables()
            # 第二步:加载sess模型的参数
            self.saver.restore(sess, ‘./model‘)
            # 第三步:输出模型的预测结果self.model, 返回结果
            out = sess.run(self.model(), feed_dict={self.x:test_x})
            return out

代码的主要调用函数

if __name__ == ‘__main__‘:
    # 实例化模型,input_size表示每一次输入,seq_size表示一共有几个单元,hidden_num表示隐藏层的个数
    predictor = SeriesPredictor(input_size=1, seq_size=4, hidden_num=10)    # 训练集的X
    train_x = [[[1], [2], [5], [6]],
              [[5], [7], [7], [8]],
               [[3], [4], [5], [7]]]     # 训练集的y
    train_y = [[1, 3, 7, 11],
               [5, 12, 14, 15],
               [3, 7, 9, 12]]     # 调用实例化函数的train进行模型训练
    predictor.train(train_x, train_y)     # 测试集的x
    test_x = [[[1], [2], [3], [4]],  # 1, 3, 5, 7
              [[4], [5], [6], [7]]]     # 测试集的y
    actual_y = [[[1], [3], [5], [7]],
                [[4], [9], [11], [13]]]     # 调用实例化的y进行模型的预测
    pred_y = predictor.test(test_x)
     # 打印输出的结果
    for i, x in enumerate(test_x):
        print(‘the input is {}‘.format(x))
        print(‘the actual y is {}‘.format(actual_y[i]))
        print(‘the pred y is {}‘.format(pred_y[i]))

原文地址:https://www.cnblogs.com/my-love-is-python/p/10549841.html

时间: 2024-10-29 10:34:58

深度学习原理与框架-递归神经网络-RNN_exmaple(代码) 1.rnn.BasicLSTMCell(构造基本网络) 2.tf.nn.dynamic_rnn(执行rnn网络) 3.tf.expand_dim(增加输入数据的维度) 4.tf.tile(在某个维度上按照倍数进行平铺迭代) 5.tf.squeeze(去除维度上为1的维度)的相关文章

深度学习原理与框架-递归神经网络-RNN网络基本框架(代码?) 1.rnn.LSTMCell(生成单层LSTM) 2.rnn.DropoutWrapper(对rnn进行dropout操作) 3.tf.contrib.rnn.MultiRNNCell(堆叠多层LSTM) 4.mlstm_cell.zero_state(state初始化) 5.mlstm_cell(进行LSTM求解)

问题:LSTM的输出值output和state是否是一样的 1. rnn.LSTMCell(num_hidden, reuse=tf.get_variable_scope().reuse)  # 构建单层的LSTM网络 参数说明:num_hidden表示隐藏层的个数,reuse表示LSTM的参数进行复用 2.rnn.DropoutWrapper(cell, output_keep_prob=keep_prob) # 表示对rnn的输出层进行dropout 参数说明:cell表示单层的lstm,o

深度学习原理与框架-递归神经网络-时间序列预测

代码说明:使用的是单层的rnn网络,迭代的终止条件为,第n的100次循环的损失值未降低次数超过3次,即跳出循环 数据说明:使用的是乘客的人数,训练集和测试集的分配为0.8和0.2, train_x使用的是前5个数据,train_y使用的是从2个数据到第6个数据,以此往后类推 代码: 第一部分:数据的读入,并将数据拆分为训练集和测试集,同时构造train_x, train_y, test_x, test_y, 每一个train的大小为5, 1 第二部分:实例化模型,同时对模型进行训练操作 第三部分

深度学习原理与框架-Tensorflow卷积神经网络-神经网络mnist分类

使用tensorflow构造神经网络用来进行mnist数据集的分类 相比与上一节讲到的逻辑回归,神经网络比逻辑回归多了隐藏层,同时在每一个线性变化后添加了relu作为激活函数, 神经网络使用的损失值为softmax概率损失值,即为交叉熵损失值 代码:使用的是mnist数据集作为分类的测试数据,数据的维度为50000*784 第一步:载入mnist数据集 第二步:超参数的设置,输入图片的大小,分类的类别数,迭代的次数,每一个batch的大小 第三步:使用tf.placeholder() 进行输入数

深度学习原理与框架-神经网络-cifar10分类(代码)

cifar神经网络的代码说明: 数据主要分为三部分: 第一部分:数据的准备 第二部分:神经网络模型的构造,返回loss和梯度值 第三部分:将数据与模型输入到函数中,用于进行模型的训练,同时进行验证集的预测,来判断验证集的预测结果,保留最好的验证集结果的参数组合 第一部分:数据的准备 第一步:构造列表,使用with open() as f: pickle.load进行数据的载入, 使用.reshape(1000, 3, 32, 32).transpose(0, 3, 1, 2).astype('f

深度学习原理与框架- batch_normalize(归一化操作)

1. batch_normalize(归一化操作),公式:传统的归一化公式 (number - mean) / std, mean表示均值, std表示标准差 而此时的公式是 scale * (num - mean) / std + beta  #scale 和 beta在计算的过程中会进行不断的更新,以使得数据可以产生多样性的分步 即 经过一次卷积层后,进行一次归一化操作,同时进行一次激活操作 x = conv_layer(x, [5, 5, 3, 64], 1) x = batch_norm

深度学习原理与框架-CNN在文本分类的应用 1.tf.nn.embedding_lookup(根据索引数据从数据中取出数据) 2.saver.restore(加载sess参数)

1. tf.nn.embedding_lookup(W, X) W的维度为[len(vocabulary_list), 128], X的维度为[?, 8],组合后的维度为[?, 8, 128] 代码说明一下:即根据每一行X中的一个数,从W中取出对应行的128个数据,比如X[1, 3]个数据是3062,即从W中的第3062行取出128个数据 import numpy as np import tensorflow as tf data = np.array([[2, 1], [3, 4], [5,

深度学习原理与框架-卷积网络细节-经典网络架构 1.AlexNet 2.VGG

1.AlexNet是2012年最早的第一代神经网络,整个神经网络的构架是8层的网络结构.网络刚开始使用11*11获得较大的感受野,随后使用5*5和3*3做特征的提取,最后使用3个全连接层做得分值得运算,使用的是softmax分类器 2. VGG-net,网络的特点是全部使用3*3的卷积,通常有两个版本一个是16-VGG和19-VGG,每一进行完一次maxpool,都进行一次维度的提升,为了减少由于降维压缩而导致的信息损失.最后使用3个全连接层进行得分值得预测,使用的是softmax计算损失值 原

对比学习资料《深度学习入门:基于Python的理论与实现》+《深度学习原理与实践》+《深度学习理论与实战基础篇》电子资料

我认为<深度学习入门:基于Python的理论与实现>电子书代码基本原理,简洁清楚,所用数学基本就是大一水平,适合做第一本入门书. <深度学习入门:基于Python的理论与实现>书代码实现的神经网络全是用numpy,超级适合刚刚入门想了解神经网络,数学不好看公式看不懂的人,看完这本基本就懂深度学习是弄啥子了. 如果连这本都看不懂的话,可以去看<Python神经网络编程>.我个人认为这两本书是最简单直白的方式让人理解神经网络的了. <深度学习原理与实践>电子书代

深度学习原理详解及Python代码实现

深度学习框架如Tensorflow和Pytorch等为用户提供了可供调用的API,但也隐藏了深度学习底层的实现细节. 为方便大家更加深入地理解深度学习原理并了解其底层实现方法,特此推出了<课程深度学习原理详解及Python代码实现>.期望能"掀起你的盖头来,让我看看你的模样",为深度学习进一步的优化和创新打下根基. 课程链接:https://edu.51cto.com/course/21426.html 本课程详细讲解深度学习原理并进行Python代码实现.课程内容涵盖感知