深度学习2.0-38.RNN实战-情感分类实战

本文详细介绍了使用Tensorflow实现RNN情感分类的实践过程,包括单个SimpleRNNCell、两个SimpleRNNCell以及RNNCell的具体代码实现,旨在帮助读者深入理解RNN在深度学习中的应用。
摘要由CSDN通过智能技术生成

1.方案

在这里插入图片描述
在这里插入图片描述

2.代码实现-一个SimpleRNNCell

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, optimizers, Sequential, losses

tf.random.set_seed(22)
np.random.seed(22)
assert tf.__version__.startswith('2.')

# 数据集加载
# imdb是一个电影评论的数据集
# 将生僻单词归结为一个单词(未知单词),total_words表示常见单词的数量
total_words = 10000
max_review_len = 80  # 设置句子长度
batchsz = 64
embedding_len = 100
(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=total_words)

# pad,将句子长度padding成一个长度,方便用一个线性层来处理
# 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))
# drop_remainder=True表示当最后一个bath小于batchsz时,会将最后一个batch丢弃掉
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])]

        # transfrom test to embedding representation
        # [b,80] => [b,80,100]     每个单词用一个100维的向量来表示
        self.embedding = layers.Embedding(total_words, embedding_len, input_length=max_review_len)

        # 将句子单词的数量在时间轴上展开
        # [b,80,100] => [b,64]  ,h_dim : 64
        # RNN : cell1.cell2.cell3
        # SimpleRNN已经在内部完成了时间轴上的展开
        # 在这一层上training与test的逻辑是不一样的
        self.rnn_cell0 = layers.SimpleRNNCell(units, dropout=0.5)

        # outlayer , [b,64] => [b,1]
        self.outlayer = layers.Dense(1)  # 1个输出结点

    #  定义前向传播
    def call(self, inputs, training=None):
        """
        train mode : net(x),net(x,training=True)
        test mode : net(x,training=False)
        :param inputs: [b,80]
        :param training: 通过设置training参数来设置是否断掉短路连接(dropout是否起作用)
        :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
        # word : [b,100]
        for word in tf.unstack(x, axis=1):  # tf.unstack(x,axis=1)表示对x在1维上进行展开
            # h_t = x_t*w_xh + h_t-1 * w_hh , 输入状态word,历史化状态state
            #  out,state1是相同的,只是为了与rnn作match,这种情况两者返回是不同的
            # training为True时,使用dropout;training为False时,不使用dropout
            out, state1 = self.rnn_cell0(word, state0,training)
            # 重新赋值做循环
            state0 = state1

        # 累积的所有的单词的语义信息
        # out : [b,64] => [b,1]
        x = self.outlayer(out)
        prob = tf.sigmoid(x)

        return prob


def main():
    units = 64
    epochs = 4

    model = MyRNN(units)
    # 模型训练
    model.compile(optimizer = optimizers.Adam(lr = 1e-3),
                  loss = tf.losses.BinaryCrossentropy(),
                  metrics = ['accuracy'],
                  experimental_run_tf_function=False)       # 增加这一行即可解决


    model.fit(db_train, epochs=epochs, validation_data=db_test)
	# test
    model.evaluate(db_test)


if __name__ == '__main__':
    main()
x_train shape: (25000, 80) tf.Tensor(1, shape=(), dtype=int64) tf.Tensor(0, shape=(), dtype=int64)
x_test shape: (25000, 80)

Epoch 4/4
 1/97 [..............................] - ETA: 2s - loss: 0.1859 - accuracy: 0.9141
 3/97 [..............................] - ETA: 2s - loss: 0.2098 - accuracy: 0.9136
 5/97 [>.............................] - ETA: 2s - loss: 0.2274 - accuracy: 0.9094
 7/97 [=>............................] - ETA: 2s - loss: 0.2337 - accuracy: 0.9061
 9/97 [
  • 0
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1. ARIMA 2. SARIMA 3. VAR 4. Auto-ARIMA 5. Auto-SARIMA 6. LSTM 7. GRU 8. RNN 9. CNN 10. MLP 11. DNN 12. MLP-LSTM 13. MLP-GRU 14. MLP-RNN 15. MLP-CNN 16. LSTM-ARIMA 17. LSTM-MLP 18. LSTM-CNN 19. GRU-ARIMA 20. GRU-MLP 21. GRU-CNN 22. RNN-ARIMA 23. RNN-MLP 24. RNN-CNN 25. CNN-ARIMA 26. CNN-MLP 27. CNN-LSTM 28. CNN-GRU 29. ARIMA-SVM 30. SARIMA-SVM 31. VAR-SVM 32. Auto-ARIMA-SVM 33. Auto-SARIMA-SVM 34. LSTM-SVM 35. GRU-SVM 36. RNN-SVM 37. CNN-SVM 38. MLP-SVM 39. LSTM-ARIMA-SVM 40. LSTM-MLP-SVM 41. LSTM-CNN-SVM 42. GRU-ARIMA-SVM 43. GRU-MLP-SVM 44. GRU-CNN-SVM 45. RNN-ARIMA-SVM 46. RNN-MLP-SVM 47. RNN-CNN-SVM 48. CNN-ARIMA-SVM 49. CNN-MLP-SVM 50. CNN-LSTM-SVM 51. CNN-GRU-SVM 52. ARIMA-RF 53. SARIMA-RF 54. VAR-RF 55. Auto-ARIMA-RF 56. Auto-SARIMA-RF 57. LSTM-RF 58. GRU-RF 59. RNN-RF 60. CNN-RF 61. MLP-RF 62. LSTM-ARIMA-RF 63. LSTM-MLP-RF 64. LSTM-CNN-RF 65. GRU-ARIMA-RF 66. GRU-MLP-RF 67. GRU-CNN-RF 68. RNN-ARIMA-RF 69. RNN-MLP-RF 70. RNN-CNN-RF 71. CNN-ARIMA-RF 72. CNN-MLP-RF 73. CNN-LSTM-RF 74. CNN-GRU-RF 75. ARIMA-XGBoost 76. SARIMA-XGBoost 77. VAR-XGBoost 78. Auto-ARIMA-XGBoost 79. Auto-SARIMA-XGBoost 80. LSTM-XGBoost 81. GRU-XGBoost 82. RNN-XGBoost 83. CNN-XGBoost 84. MLP-XGBoost 85. LSTM-ARIMA-XGBoost 86. LSTM-MLP-XGBoost 87. LSTM-CNN-XGBoost 88. GRU-ARIMA-XGBoost 89. GRU-MLP-XGBoost 90. GRU-CNN-XGBoost 91. RNN-ARIMA-XGBoost 92. RNN-MLP-XGBoost 93. RNN-CNN-XGBoost 94. CNN-ARIMA-XGBoost 95. CNN-MLP-XGBoost 96. CNN-LSTM-XGBoost 97. CNN-GRU-XGBoost 98. ARIMA-ANN 99. SARIMA-ANN 100. VAR-ANN 上面这些缩写模型的全称及相关用途功能详细解释
07-15
以下是对缩写模型的全称及相关用途功能的详细解释: 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. MLP (Multi-Layer Perceptron): 多层感知机,一种前馈神经网络模型,适用于处理非线性关系的时间序列数据。 11. DNN (Deep Neural Network): 深度神经网络,具有多个隐藏层的神经网络模型,能够学习更复杂的特征表示。 12. MLP-LSTM: 结合了多层感知机和长短期记忆网络的模型,用于时间序列数据的建模和预测。 13. MLP-GRU: 结合了多层感知机和门控循环单元网络的模型,用于时间序列数据的建模和预测。 14. MLP-RNN: 结合了多层感知机和循环神经网络的模型,用于时间序列数据的建模和预测。 15. MLP-CNN: 结合了多层感知机和卷积神经网络的模型,用于时间序列数据的建模和预测。 这些模型可以根据具体问题和数据的特性来选择和使用,以获得最佳的时间序列预测性能。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值