8月15日TensorFlow学习笔记——RNN、LSTM、GRU、Auto-Encoders

于 2022-08-15 20:28:48 发布
阅读量383 收藏 1
点赞数
文章标签： tensorflow rnn 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ashen_0nee/article/details/126339588
版权
本文介绍了使用TensorFlow进行深度学习的实践，涵盖序列表示、RNN层（SimpleRNN、多层RNN）、情感分类、LSTM和GRU的实战应用。通过实例展示了如何构建和训练模型，包括从基本的嵌入层到复杂的LSTM和GRU单元，用于文本理解和情感分析任务。实验结果显示，不同类型的RNN在时间和性能上有所差异。
摘要由CSDN通过智能技术生成

文章目录

前言

本文为8月15日TensorFlow学习笔记，分为六个章节：

  • 序列表示方法；
  • RNN Layer；
  • 情感分类实战；
  • LSTM 实战；
  • GRU 实战；
  • Auto-Encoders。

一、序列表示方法

[ b , s e q _ l e n , f e a t u r e _ l e n ]   [ w o r d   n u m , b , w o r d   v e c ] [b, seq\_len, feature\_len]\\\ [word\ num, b, word\ vec] [b,seq_len,feature_len] [word num,b,word vec]

  • Random initialized embedding:
import tensorflow as tf
from tensorflow.keras import layers

x = tf.range(5)
x = tf.random.shuffle(x)
print('x: ', x)

net = layers.Embedding(10, 4)
print('net(x): ', net(x))
print('Variables: ', net.trainable_variables)

>>> x:  tf.Tensor([3 1 2 4 0], shape=(5,), dtype=int32)
>>> net(x):  tf.Tensor(
	[[ 0.00657358  0.012666    0.01578368  0.04547732]
	 [ 0.03115724 -0.0150555   0.00257788  0.0059495 ]
	 [-0.00751901 -0.02282023 -0.02350371 -0.00176684]
	 [ 0.00191356  0.04653488  0.04107442 -0.03144759]
	 [-0.02379932 -0.02618247 -0.01534456 -0.00577461]], shape=(5, 4), dtype=float32)

>>> Variables:  [<tf.Variable 'embedding/embeddings:0' shape=(10, 4) dtype=float32, numpy=
	array([[-0.0133497 , -0.02664096, -0.02426125, -0.03032522],
	       [-0.01147861,  0.00350826,  0.01625546, -0.00250021],
	       [ 0.03258711,  0.02548888,  0.01436329, -0.01171582],
	       [-0.03033434, -0.01988299,  0.03989463, -0.02743146],
	       [ 0.04732693, -0.01455421, -0.00769072,  0.01441428],
	       [ 0.04504165, -0.01252029, -0.04699463,  0.03120432],
	       [ 0.01991358, -0.00563236,  0.0146648 ,  0.03104378],
	       [ 0.00062705,  0.04419595,  0.00331502, -0.00502656],
	       [-0.03338401, -0.02013427, -0.00471456,  0.04988861],
	       [-0.04404187, -0.03447127,  0.00097726,  0.0235931 ]],
	      dtype=float32)>]

二、RNN Layer

1、Simplelayer

x t : [ b , 100 ]   o u t , h 1 = c a l l ( x , h 0 ) x_t: [b, 100]\\\ out, h1 = call(x, h_0) xt​:[b,100] out,h1=call(x,h0​)

cell = layers.SimpleRNNCell(3)
cell.build(input_shape=(None, 4))

print('Variables: ', cell.trainable_variable)

>>> Variables:  [<tf.Variable 'kernel:0' shape=(4, 3) dtype=float32, numpy=
	array([[ 0.9063113 , -0.15272564, -0.37417394],
	       [-0.62598073,  0.11762738,  0.33107877],
	       [ 0.82874715, -0.24461818,  0.1809479 ],
	       [ 0.06814569,  0.47765958,  0.49054313]], dtype=float32)>, <tf.Variable 'recurrent_kernel:0' shape=(3, 3) dtype=float32, numpy=
	array([[ 0.853045  ,  0.5034819 , -0.13718656],
	       [-0.5190743 ,  0.7916652 , -0.3222238 ],
	       [ 0.05362803, -0.34608147, -0.93667054]], dtype=float32)>, <tf.Variable 'bias:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>]

2、Multi-Layers

x = tf.random.normal([4, 80, 100])
xt0 = x[:, 0, :]

cell = tf.keras.layers.SimpleRNNCell(64)
cell2 = tf.keras.layers.SimpleRNNCell(64)

state0 = [tf.zeros([4, 64])]
state1 = [tf.zeros([4, 64])]

out0, state0 = cell(xt0, state0)
out2, state2 = cell2(out0, state0)

print('out2_shape', out2.shape)
print('state2[0]_shape', state2[0].shape)

>>> out2_shape (4, 64)
>>> state2[0]_shape (4, 64)

3、RNN Layer

self.rnn = keras.Sequential([
    layers.SimpleRNN(units, dropout=0.5, return_sequences=True, unroll=True),
    layers.SimpleRNN(units, dropout=0.5, unroll=True)
])

三、情感分类实战

import  os
import  tensorflow as tf
import  numpy as np
from    tensorflow import keras
from    tensorflow.keras import layers


tf.random.set_seed(22)
np.random.seed(22)
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
assert tf.__version__.startswith('2.')

batchsz = 128

# the most frequest words
total_words = 10000
max_review_len = 80
embedding_len = 100
(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=total_words)
# x_train:[b, 80]
# x_test: [b, 80]
x_train = keras.preprocessing.sequence.pad_sequences(x_train, maxlen=max_review_len)
x_test = keras.preprocessing.sequence.pad_sequences(x_test, maxlen=max_review_len)

db_train = tf.data.Dataset.from_tensor_slices((x_train, y_train))
db_train = db_train.shuffle(1000).batch(batchsz, drop_remainder=True)
db_test = tf.data.Dataset.from_tensor_slices((x_test, y_test))
db_test = db_test.batch(batchsz, drop_remainder=True)
print('x_train shape:', x_train.shape, tf.reduce_max(y_train), tf.reduce_min(y_train))
print('x_test shape:', x_test.shape)



class MyRNN(keras.Model):

    def __init__(self, units):
        super(MyRNN, self).__init__()

        # [b, 64]
        self.state0 = [tf.zeros([batchsz, units])]
        self.state1 = [tf.zeros([batchsz, units])]

        # transform text to embedding representation
        # [b, 80] => [b, 80, 100]
        self.embedding = layers.Embedding(total_words, embedding_len,
                                          input_length=max_review_len)

        # [b, 80, 100] , h_dim: 64
        # RNN: cell1 ,cell2, cell3
        # SimpleRNN
        self.rnn_cell0 = layers.SimpleRNNCell(units, dropout=0.5)
        self.rnn_cell1 = layers.SimpleRNNCell(units, dropout=0.5)


        # fc, [b, 80, 100] => [b, 64] => [b, 1]
        self.outlayer = layers.Dense(1)

    def call(self, inputs, training=None):
        """
        net(x) net(x, training=True) :train mode
        net(x, training=False): test
        :param inputs: [b, 80]
        :param training:
        :return:
        """
        # [b, 80]
        x = inputs
        # embedding: [b, 80] => [b, 80, 100]
        x = self.embedding(x)
        # rnn cell compute
        # [b, 80, 100] => [b, 64]
        state0 = self.state0
        state1 = self.state1
        for word in tf.unstack(x, axis=1): # word: [b, 100]
            # h1 = x*wxh+h0*whh
            # out0: [b, 64]
            out0, state0 = self.rnn_cell0(word, state0, training)
            # out1: [b, 64]
            out1, state1 = self.rnn_cell1(out0, state1, training)

        # out: [b, 64] => [b, 1]
        x = self.outlayer(out1)
        # p(y is pos|x)
        prob = tf.sigmoid(x)

        return prob

def main():
    units = 64
    epochs = 4

    model = MyRNN(units)
    model.compile(optimizer = keras.optimizers.Adam(0.001),
                  loss = tf.losses.BinaryCrossentropy(),
                  metrics=['accuracy'])
    model.fit(db_train, epochs=epochs, validation_data=db_test)

    model.evaluate(db_test)


if __name__ == '__main__':
    main()

>>> ……
	Epoch 4/4
	195/195 [==============================] - 8s 41ms/step - loss: 0.2468 - accuracy: 0.9028 - val_loss: 0.4614 - val_accuracy: 0.8266
	195/195 [==============================] - 2s 12ms/step - loss: 0.4614 - accuracy: 0.8266

四、LSTM 实战

import  os
import  tensorflow as tf
import  numpy as np
from    tensorflow import keras
from    tensorflow.keras import layers


tf.random.set_seed(22)
np.random.seed(22)
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
assert tf.__version__.startswith('2.')

batchsz = 128

# the most frequest words
total_words = 10000
max_review_len = 80
embedding_len = 100
(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=total_words)
# x_train:[b, 80]
# x_test: [b, 80]
x_train = keras.preprocessing.sequence.pad_sequences(x_train, maxlen=max_review_len)
x_test = keras.preprocessing.sequence.pad_sequences(x_test, maxlen=max_review_len)

db_train = tf.data.Dataset.from_tensor_slices((x_train, y_train))
db_train = db_train.shuffle(1000).batch(batchsz, drop_remainder=True)
db_test = tf.data.Dataset.from_tensor_slices((x_test, y_test))
db_test = db_test.batch(batchsz, drop_remainder=True)
print('x_train shape:', x_train.shape, tf.reduce_max(y_train), tf.reduce_min(y_train))
print('x_test shape:', x_test.shape)



class MyRNN(keras.Model):

    def __init__(self, units):
        super(MyRNN, self).__init__()

        # [b, 64]
        self.state0 = [tf.zeros([batchsz, units]),tf.zeros([batchsz, units])]
        self.state1 = [tf.zeros([batchsz, units]),tf.zeros([batchsz, units])]

        # transform text to embedding representation
        # [b, 80] => [b, 80, 100]
        self.embedding = layers.Embedding(total_words, embedding_len,
                                          input_length=max_review_len)

        # [b, 80, 100] , h_dim: 64
        # RNN: cell1 ,cell2, cell3
        # SimpleRNN
        # self.rnn_cell0 = layers.SimpleRNNCell(units, dropout=0.5)
        # self.rnn_cell1 = layers.SimpleRNNCell(units, dropout=0.5)
        self.rnn_cell0 = layers.LSTMCell(units, dropout=0.5)
        self.rnn_cell1 = layers.LSTMCell(units, dropout=0.5)


        # fc, [b, 80, 100] => [b, 64] => [b, 1]
        self.outlayer = layers.Dense(1)

    def call(self, inputs, training=None):
        """
        net(x) net(x, training=True) :train mode
        net(x, training=False): test
        :param inputs: [b, 80]
        :param training:
        :return:
        """
        # [b, 80]
        x = inputs
        # embedding: [b, 80] => [b, 80, 100]
        x = self.embedding(x)
        # rnn cell compute
        # [b, 80, 100] => [b, 64]
        state0 = self.state0
        state1 = self.state1
        for word in tf.unstack(x, axis=1): # word: [b, 100]
            # h1 = x*wxh+h0*whh
            # out0: [b, 64]
            out0, state0 = self.rnn_cell0(word, state0, training)
            # out1: [b, 64]
            out1, state1 = self.rnn_cell1(out0, state1, training)

        # out: [b, 64] => [b, 1]
        x = self.outlayer(out1)
        # p(y is pos|x)
        prob = tf.sigmoid(x)

        return prob

def main():
    units = 64
    epochs = 4

    import time

    t0 = time.time()

    model = MyRNN(units)
    model.compile(optimizer = keras.optimizers.Adam(0.001),
                  loss = tf.losses.BinaryCrossentropy(),
                  metrics=['accuracy'])
    model.fit(db_train, epochs=epochs, validation_data=db_test)

    model.evaluate(db_test)

    t1 = time.time()
    # 64.3 seconds, 83.4%
    print('total time cost:', t1-t0)


if __name__ == '__main__':
    main()

>>> Epoch 4/4
	195/195 [==============================] - 16s 84ms/step - loss: 0.2190 - accuracy: 0.9168 - val_loss: 0.4562 - val_accuracy: 0.8308
	195/195 [==============================] - 4s 21ms/step - loss: 0.4562 - accuracy: 0.8308
	total time cost: 81.24266004562378

五、GRU 实战

import  os
import  tensorflow as tf
import  numpy as np
from    tensorflow import keras
from    tensorflow.keras import layers


tf.random.set_seed(22)
np.random.seed(22)
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
assert tf.__version__.startswith('2.')

batchsz = 128

# the most frequest words
total_words = 10000
max_review_len = 80
embedding_len = 100
(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=total_words)
# x_train:[b, 80]
# x_test: [b, 80]
x_train = keras.preprocessing.sequence.pad_sequences(x_train, maxlen=max_review_len)
x_test = keras.preprocessing.sequence.pad_sequences(x_test, maxlen=max_review_len)

db_train = tf.data.Dataset.from_tensor_slices((x_train, y_train))
db_train = db_train.shuffle(1000).batch(batchsz, drop_remainder=True)
db_test = tf.data.Dataset.from_tensor_slices((x_test, y_test))
db_test = db_test.batch(batchsz, drop_remainder=True)
print('x_train shape:', x_train.shape, tf.reduce_max(y_train), tf.reduce_min(y_train))
print('x_test shape:', x_test.shape)



class MyRNN(keras.Model):

    def __init__(self, units):
        super(MyRNN, self).__init__()

        # [b, 64]
        self.state0 = [tf.zeros([batchsz, units])]
        self.state1 = [tf.zeros([batchsz, units])]

        # transform text to embedding representation
        # [b, 80] => [b, 80, 100]
        self.embedding = layers.Embedding(total_words, embedding_len,
                                          input_length=max_review_len)

        # [b, 80, 100] , h_dim: 64
        # RNN: cell1 ,cell2, cell3
        # SimpleRNN
        # self.rnn_cell0 = layers.SimpleRNNCell(units, dropout=0.5)
        # self.rnn_cell1 = layers.SimpleRNNCell(units, dropout=0.5)
        self.rnn_cell0 = layers.GRUCell(units, dropout=0.5)
        self.rnn_cell1 = layers.GRUCell(units, dropout=0.5)


        # fc, [b, 80, 100] => [b, 64] => [b, 1]
        self.outlayer = layers.Dense(1)

    def call(self, inputs, training=None):
        """
        net(x) net(x, training=True) :train mode
        net(x, training=False): test
        :param inputs: [b, 80]
        :param training:
        :return:
        """
        # [b, 80]
        x = inputs
        # embedding: [b, 80] => [b, 80, 100]
        x = self.embedding(x)
        # rnn cell compute
        # [b, 80, 100] => [b, 64]
        state0 = self.state0
        state1 = self.state1
        for word in tf.unstack(x, axis=1): # word: [b, 100]
            # h1 = x*wxh+h0*whh
            # out0: [b, 64]
            out0, state0 = self.rnn_cell0(word, state0, training)
            # out1: [b, 64]
            out1, state1 = self.rnn_cell1(out0, state1, training)

        # out: [b, 64] => [b, 1]
        x = self.outlayer(out1)
        # p(y is pos|x)
        prob = tf.sigmoid(x)

        return prob

def main():
    units = 64
    epochs = 4

    import time

    t0 = time.time()

    model = MyRNN(units)
    model.compile(optimizer = keras.optimizers.Adam(0.001),
                  loss = tf.losses.BinaryCrossentropy(),
                  metrics=['accuracy'])
    model.fit(db_train, epochs=epochs, validation_data=db_test)

    model.evaluate(db_test)

    t1 = time.time()
    # LSTM: 64.3 seconds, 83.4%
    # GRU:  96.7s, 83.4%
    print('total time cost:', t1-t0)


if __name__ == '__main__':
    main()

>>> Epoch 4/4
	195/195 [==============================] - 18s 91ms/step - loss: 0.2386 - accuracy: 0.9074 - val_loss: 0.4181 - val_accuracy: 0.8304
	195/195 [==============================] - 5s 26ms/step - loss: 0.4181 - accuracy: 0.8304
	total time cost: 89.22233891487122

六、Auto-Encoders

import  os
import  tensorflow as tf
import  numpy as np
from    tensorflow import keras
from    tensorflow.keras import Sequential, layers
from    PIL import Image
from    matplotlib import pyplot as plt



tf.random.set_seed(22)
np.random.seed(22)
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
assert tf.__version__.startswith('2.')


def save_images(imgs, name):
    new_im = Image.new('L', (280, 280))

    index = 0
    for i in range(0, 280, 28):
        for j in range(0, 280, 28):
            im = imgs[index]
            im = Image.fromarray(im, mode='L')
            new_im.paste(im, (i, j))
            index += 1

    new_im.save(name)


h_dim = 20
batchsz = 512
lr = 1e-3


(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()
x_train, x_test = x_train.astype(np.float32) / 255., x_test.astype(np.float32) / 255.
# we do not need label
train_db = tf.data.Dataset.from_tensor_slices(x_train)
train_db = train_db.shuffle(batchsz * 5).batch(batchsz)
test_db = tf.data.Dataset.from_tensor_slices(x_test)
test_db = test_db.batch(batchsz)

print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)



class AE(keras.Model):

    def __init__(self):
        super(AE, self).__init__()

        # Encoders
        self.encoder = Sequential([
            layers.Dense(256, activation=tf.nn.relu),
            layers.Dense(128, activation=tf.nn.relu),
            layers.Dense(h_dim)
        ])

        # Decoders
        self.decoder = Sequential([
            layers.Dense(128, activation=tf.nn.relu),
            layers.Dense(256, activation=tf.nn.relu),
            layers.Dense(784)
        ])


    def call(self, inputs, training=None):
        # [b, 784] => [b, 10]
        h = self.encoder(inputs)
        # [b, 10] => [b, 784]
        x_hat = self.decoder(h)

        return x_hat



model = AE()
model.build(input_shape=(None, 784))
model.summary()

optimizer = tf.optimizers.Adam(lr=lr)

for epoch in range(100):

    for step, x in enumerate(train_db):

        #[b, 28, 28] => [b, 784]
        x = tf.reshape(x, [-1, 784])

        with tf.GradientTape() as tape:
            x_rec_logits = model(x)

            rec_loss = tf.losses.binary_crossentropy(x, x_rec_logits, from_logits=True)
            rec_loss = tf.reduce_mean(rec_loss)

        grads = tape.gradient(rec_loss, model.trainable_variables)
        optimizer.apply_gradients(zip(grads, model.trainable_variables))


        if step % 100 ==0:
            print(epoch, step, float(rec_loss))


        # evaluation
        x = next(iter(test_db))
        logits = model(tf.reshape(x, [-1, 784]))
        x_hat = tf.sigmoid(logits)
        # [b, 784] => [b, 28, 28]
        x_hat = tf.reshape(x_hat, [-1, 28, 28])

        # [b, 28, 28] => [2b, 28, 28]
        x_concat = tf.concat([x, x_hat], axis=0)
        x_concat = x_hat
        x_concat = x_concat.numpy() * 255.
        x_concat = x_concat.astype(np.uint8)
        save_images(x_concat, 'ae_images/rec_epoch_%d.png'%epoch)

>>> ……
	99 0 0.2688389718532562
	99 100 0.272990345954895
Ashen_0nee
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RNN LSTM GRU介绍
舟
01-12 1086
RNN 在实际应用中，我们会遇到很多序列形的数据 为了建模序列问题，RNN引入了隐状态h（hidden state）的概念，h可以对序列形的数据提取特征，接着再转换为输出。 每一步使用的参数U、W、b都是一样的，也就是说每个步骤的参数都是共享的，这是RNN的重要特点 LSTM 长短期记忆（Long short-term memory, LSTM）是一种特殊的RNN，主要是为了解决长序列训练过程...
Tensorflow(7):RNN,LSTM,GRU,Auto-Encoder,VAE
JJJJJJames的博客
01-30 783
1、时间序列表示方法 sequence embedding [b,seq_len,feature_len] b:句子数量 seq_len:单词数量 feature_len 单词特征 [b,28,28] 从sequence角度理解，把每一个图片当作28个时间序列的输入，每个输入有28个特征。共有b个图片。 每个单词对应的三个波形，每个波形在每个时刻对应一个word vector，每个时刻代表当前输入的word。 how to represent a word one-hot encoding 问
rnn_autoenc:带歌曲数据的RNN自动编码器解码器
05-02
RNN自动编码器 我研究tensorflow和RNN＆RNN autoenc和代码。 我使用的是midi文件中的音乐旋律数据。 内容 基本RNN RNN自动编码器（LSTM自动编码器）（参考： ） 描述 1.基本的RNN 我在张量流代码中实现了基本的RNN结构。 2. RNN自动编码器 我在张量流代码中实现了RNN自动编码器结构。 它由RNN编码器和RNN解码器组成。 编码器的最终状态用作通用自动编码器的压缩空间。 解码器的输入是学习时的学习数据序列，但是当用于输出时，输出返回到输入。 代码 模型（仍在编辑中） RNN_AE_model_decoder_dynamic：在张量流中使用动态rnn的模型 RNN_AE_model_decoder_feedback：使用带有for循环的单元格进行建模 火车：火车模型 测试：使用经过训练的模型生成新序列 util：实用程序代码
keras实战-入门之RNN(GRU)自编码器
王伟王胖胖的博客
07-08 4815
@TOC RNN(GRU)自编码器 这次用RNN的自编码器来做音频的恢复。 RNN原理就不说了，可以看这篇文章 这次是用了RNN里的GRU，跟LSTM很像，但是比他训练要快点。需要librosa音频处理库，例子的音频数据集，提取码：c3oq。 import keras import numpy as np import librosa import librosa.display import o...
LSTM-Autoencoder:Tensorflow中的LSTM自动编码器和LSTM预测器
05-16
Tensorflow中的LSTM自动编码器和LSTM未来预测器。 这是基于本文的简单实现： : 要求 Tensorflow 1.4.0 的Python 3.5.4 Python软件包：numpy，matplotlib，os，argparse，scipy 用法 数据生成后实施重建或未来预测 使用旋转和移位生成数据：Image_generation.ipynb 使用LSTM自动编码器重建数据：Autoencoder.ipynb 输入重构和未来预测：AE_with_Predictor 结果 从复合模型 数据序列（从左到右）：0,1，...，t-1，t 轮换数据 在LSTM模型中输入序列数据后，重建数据并预测旋转多少 输入顺序 输入重构 未来预测 移位数据 在LSTM模型中输入序列数据后，重建数据并预测多少位移 输入顺序 输入重构 未来预测 参考实现 https://githu
用TensorFlow实现自编码器Autoencoders
CurryCoder的个人博客
05-28 2540
1.简介 自编码器是一种特殊的神经网络模型，它可以从无标签的训练集中训练得到，是一种无监督学习算法。它不仅可以用来降维，也可以作为一种生成模型，这表示此模型可以从输入数据中生成新的数据。本文中主要介绍不同类型的自编码器，并用TensorFlow进行实现。 2.原理 自编码器将原始的数据作为输入，然后将输入转化成有效的内部表现形式，输出数据看上去和输入是相似的。换句话说，为了生成新的数据来近似...
BP算法和RNN_模型CNN-RNN-LSTM和GRU简介
weixin_39942992的博客
11-20 1047
深度学习自从2006年以后已经“火”了十多年了，目前大家看到的，最普遍的应用成果是在计算机视觉、语音识别和自然语言处理（NLP）。最近工业界也在努力地扩展它的应用场景，比如游戏、内容推荐和广告匹配等等。深度模型架构分三种：前向反馈网络：MLP，CNN；后向反馈网络：stacked sparse coding, deconvolutional nets；双向反馈网络：deep Boltzmann m...
BP算法和RNN_深度学习 CNN 和 RNN 等模型简介
weixin_39540744的博客
11-20 903
导读： 深度学习自从2006年以后已经 "火" 了十多年了，目前大家看到的，最普遍的应用成果是在计算机视觉、语音识别和自然语言处理 ( NLP )。 最近工业界也在努力地扩展它的应用场景，比如游戏、内容推荐和广告匹配等等。深度模型架构分三种：❶ 前向反馈网络： MLP，CNN❷ 后向反馈网络： stacked sparse coding, deconvolutional nets❸ 双向反馈网络：...
轰炸理解深度学习里面的encoder-decoder模型
热门推荐
Microstrong
12-08 5万+
微信公众号 Encoder-Decoder（编码-解码）是深度学习中非常常见的一个模型框架，比如无监督算法的auto-encoding就是用编码-解码的结构设计并训练的；比如这两年比较热的image caption的应用，就是CNN-RNN的编码-解码框架；再比如神经网络机器翻译NMT模型，往往就是LSTM-LSTM的编码-解码框架。因此，准确的说，Encoder-Decoder并不是一个具体...
《基于深度学习的推荐系统研究综述》_黄立威——阅读笔记
qq_38285573的博客
08-11 5155
一、常用的深度学习模型和方法介绍 1.自编码器 自编码器通过一个编码和一个解码过程来重构输入数据，学习数据的隐表示。基本的自编码器可视为一个三层的神经网络结构.下图是自编码器结构示意图： 自编码器的目的是使得输入 x 与输出 y 尽可能接近，这种接近程度通过重构误差表示，根据数据的不同形式，通常重构误差有均方误差和交叉熵两种定义方式。 如果仅仅通过最小化输入输出之间的误差来实现对模型的...
TensorFlow实现AutoEncoder自编码器
09-20
主要为大家详细介绍了TensorFlow实现AutoEncoder自编码器，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Autoencoder 基于tensorflow2.0的代码
chwei20002005的博客
03-23 655
具体原理不讲了，网上资料相当多，但是感觉直接可以用的代码不多，所以基于各种资料实现了代码。 第一，利用autoencoder降噪， 第一部分：数据准备 from tensorflow.keras.datasets import mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.reshape((-1, 28 * 28)) / 255.0 # 除255的目的就是归一化 reshape的.
循环神经网络（RNN） LSTM与GRU
James_bobo的博客
09-24 1179
RNN简介 RNN是两种神经网络模型的缩写，一种是递归神经网络（Recursive Neural Network），一种是循环神经网络（Recurrent Neural Network）。虽然这两种神经网络有着千丝万缕的联系，但是本文主要讨论的是第二种神经网络模型——循环神经网络（Recurrent Neural Network）。 循环神经网络是指一个随着时间的推移，重复发生的结构。在自然语言处...
RNN、LSTM和GRU
Wisimer
02-26 1134
一、循环神经网络 传统的神经网络并不能做到保持信息的持久性，RNN(Recurrent Neural Retwork) 解决了这个问题。RNN 是包含循环的网络，允许信息的持久化。 在上面的示例图中，神经网络的模块，，正在读取某个输入 ，并输出一个值 。循环可以使得信息可以从当前步传递到下一步。 RNN 可以被看做是同一神经网络的多次复制，每个神经网络模块会把消息传递给下一个。所以，如果我们将这...
RNN-LSTM-GRU
Shingle_的博客
09-06 1495
循环神经网络（Recurrent Neural Network, RNN） 假设 Xt∈Rn×dXt∈Rn×d{X}_t \in \mathbb{R}^{n \times d} 是序列中时间步 t 的小批量输入 Ht∈Rn×hHt∈Rn×h{H}_t \in \mathbb{R}^{n \times h} 该时间步的隐藏层变量。跟多层感知机不同在于这里我们保存上一时间步的隐藏变量 Ht−1H...
RNN，LSTM，GRU
choose_c的博客
03-07 192
RNN LSTM 三个门(遗忘门，输入门，输出门)，隐层h，记忆细胞cell。 GRU 两个门(重置门，更新门)，隐层h。
RNN、GRU、LSTM
Hayden的博客
12-25 762
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/weixin_42432468 学习心得： 1、每周的视频课程看一到两遍 2、做笔记 3、做每周的作业练习，这个里面的含金量非常高。掌握后一定要自己敲一遍，这样以后用起来才能得心应手。 对RNN 、Simplified GRU、Full GRU、LSTM单元的理解： 1、RNN Unit 2、S...
第二十一节，使用TensorFlow实现LSTM和GRU网络
weixin_30648963的博客
05-12 918
本节主要介绍在TensorFlow中实现LSTM以及GRU网络。 一 LSTM网络 Long Short Term 网络—— 一般就叫做 LSTM ——是一种 RNN 特殊的类型，可以学习长期依赖信息。LSTM 由Hochreiter & Schmidhuber (1997)提出，并在近期被Alex Graves进行了改良和推广。在很多问题，LSTM 都取得相当巨大的成功，并得...
RNN/LSTM/GRU/seq2seq公式推导
dili8870的博客
03-17 1646
　　概括：RNN 适用于处理序列数据用于预测，但却受到短时记忆的制约。LSTM 和 GRU 采用门结构来克服短时记忆的影响。门结构可以调节流经序列链的信息流。LSTM 和 GRU 被广泛地应用到语音识别、语音合成和自然语言处理等。 1. RNN 　　RNN 会受到短时记忆的影响。如果一条序列足够长，那它们将很难将信息从较早的时间步传送到后面的时间步。 因此，如果你正在尝试处理一段文本...
ARIMA SARIMA VAR Auto-ARIMA Auto-SARIMA LSTM GRU RNN CNN MLP DNN MLP-LSTM MLP-GRU MLP-RNN MLP-CNN LSTM-ARIMA LSTM-MLP LSTM-CNN GRU-ARIMA GRU-MLP GRU-CNN RNN-ARIMA RNN-MLP RNN-CNN CNN-ARIMA CNN-MLP CNN-LSTM CNN-GRU ARIMA-SVM SARIMA-SVM VAR-SVM Auto-ARIMA-SVM Auto-SARIMA-SVM LSTM-SVM GRU-SVM RNN-SVM CNN-SVM MLP-SVM LSTM-ARIMA-SVM LSTM-MLP-SVM LSTM-CNN-SVM GRU-ARIMA-SVM GRU-MLP-SVM GRU-CNN-SVM RNN-ARIMA-SVM RNN-MLP-SVM RNN-CNN-SVM CNN-ARIMA-SVM CNN-MLP-SVM CNN-LSTM-SVM CNN-GRU-SVM ARIMA-RF SARIMA-RF VAR-RF Auto-ARIMA-RF Auto-SARIMA-RF LSTM-RF GRU-RF RNN-RF CNN-RF MLP-RF LSTM-ARIMA-RF LSTM-MLP-RF LSTM-CNN-RF GRU-ARIMA-RF GRU-MLP-RF GRU-CNN-RF RNN-ARIMA-RF RNN-MLP-RF RNN-CNN-RF CNN-ARIMA-RF CNN-MLP-RF CNN-LSTM-RF CNN-GRU-RF ARIMA-XGBoost SARIMA-XGBoost VAR-XGBoost Auto-ARIMA-XGBoost Auto-SARIMA-XGBoost LSTM-XGBoost GRU-XGBoost RNN-XGBoost CNN-XGBoost MLP-XGBoost LSTM-ARIMA-XGBoost LSTM-MLP-XGBoost LSTM-CNN-XGBoost GRU-ARIMA-XGBoost GRU-MLP-XGBoost GRU-CNN-XGBoost RNN-ARIMA-XGBoost RNN-MLP-XGBoost RNN-CNN-XGBoost CNN-ARIMA-XGBoost CNN-MLP-XGBoost CNN-LSTM-XGBoost CNN-GRU-XGBoost ARIMA-ANN SARIMA-ANN VAR-ANN 上面这100个缩写模型的全称及相关用途功能详细解释
最新发布
07-15
以下是对上述100个缩写模型的全称及相关用途功能的详细解释： 1. ARIMA (AutoRegressive Integrated Moving Average): 适用于平稳时间序列数据的预测，结合了自回归 (AR) 和移动平均 (MA) 的模型。 2. SARIMA (Seasonal ARIMA): 在ARIMA模型基础上添加了对季节性因素的建模，适用于带有季节性的时间序列数据的预测。 3. VAR (Vector Autoregression): 用于多变量时间序列数据的预测，基于自回归模型，能够捕捉变量之间的相互依赖关系。 4. Auto-ARIMA: 自动选择ARIMA模型的参数，通过对多个模型进行评估和选择来实现自动化。 5. Auto-SARIMA: 自动选择SARIMA模型的参数，通过对多个模型进行评估和选择来实现自动化。 6. LSTM (Long Short-Term Memory): 长短期记忆网络，一种适用于处理长期依赖关系的循环神经网络，用于时间序列数据的建模和预测。 7. GRU (Gated Recurrent Unit): 一种类似于LSTM的循环神经网络，具有更简化的结构，适用于时间序列数据的建模和预测。 8. RNN (Recurrent Neural Network): 适用于处理序列数据的神经网络模型，能够捕捉时间序列的动态特性。 9. CNN (Convolutional Neural Network): 卷积神经网络，主要用于图像处理，但也可以用于时间序列数据的预测，特别擅长局部模式的识别
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值