文章/答案/技术大牛

发布

社区首页 >问答首页 >基于LSTM Keras的序列数据的多类分类

问基于LSTM Keras的序列数据的多类分类
EN

Stack Overflow用户

提问于 2019-10-11 10:53:27

回答 1查看 1.5K关注 0票数 1

我试图对顺序数据进行多类分类，根据源的累积读取来了解某些事件的来源。

我使用的是一个简单的LSTM层，64个单元和一个密集层，以相同数量的单元作为目标。该模型似乎并没有学到任何东西，因为精度仍然保持在1%左右的所有想法。def create_model()：model = Sequential()

model.add(LSTM(64, return_sequences=False))

model.add(Dense(8))
model.add(Activation("softmax"))

model.compile(
    loss="categorical_crossentropy",
    optimizer=Adam(lr=0.00001),
    metrics=["accuracy"],
)

return model

我试着将学习率改变为非常小的值(0.001，0.0001，1e-5)，并为更大的时代进行训练，但观测的准确性没有变化。我是不是漏掉了什么？我的数据预处理不正确还是模型创建有问题？

提前谢谢你的帮助。

数据集

Accumulated- Source-1   Source-2    Source-3  
Reading   
217             0       0       0  
205             0       0       0  
206             0       0       0  
231             0       0       0  
308             0       0       1  
1548            0       0       1  
1547            0       0       1  
1530            0       0       1  
1545            0       0       1  
1544            0       0       1   
1527            0       0       1  
1533            0       0       1  
1527            0       0       1  
1527            0       0       1  
1534            0       0       1  
1520            0       0       1  
1524            0       0       1  
1523            0       0       1  
205             0       0       0  
209             0       0       0  
.  
.  
.

我创建了一个滚动窗口数据集，该数据集将SEQ_LEN=5提供给LSTM网络：

rolling_window                   labels
[205, 206, 217, 205, 206]       [0, 0, 0]
[206, 217, 205, 206, 231]       [0, 0, 0]
[217, 205, 206, 231, 308]       [0, 0, 1]
[205, 206, 231, 308, 1548]      [0, 0, 1]
[206, 231, 308, 1548, 1547]     [0, 0, 1]
[231, 308, 1548, 1547, 1530]    [0, 0, 1]
[308, 1548, 1547, 1530, 1545]   [0, 0, 1]
[1548, 1547, 1530, 1545, 1544]  [0, 0, 1]
[1547, 1530, 1545, 1544, 1527]  [0, 0, 1]
[1530, 1545, 1544, 1527, 1533]  [0, 0, 1]
[1545, 1544, 1527, 1533, 1527]  [0, 0, 1]
[1544, 1527, 1533, 1527, 1527]  [0, 0, 1]
[1527, 1533, 1527, 1527, 1534]  [0, 0, 1]
[1533, 1527, 1527, 1534, 1520]  [0, 0, 1]
[1527, 1527, 1534, 1520, 1524]  [0, 0, 1]
[1527, 1534, 1520, 1524, 1523]  [0, 0, 1]
[1534, 1520, 1524, 1523, 1520]  [0, 0, 1]
[1520, 1524, 1523, 1520, 205]   [0, 0, 0]
.  
.  
.

重塑数据集

X_train = train_df.rolling_window.values
X_train = X_train.reshape(X_train.shape[0], 1, SEQ_LEN)

Y_train = train_df.labels.values
Y_train = Y_train.reshape(Y_train.shape[0], 3)

模型

def create_model():
    model = Sequential()

    model.add(LSTM(64, input_shape=(1, SEQ_LEN), return_sequences=True))
    model.add(Activation("relu"))

    model.add(Flatten())
    model.add(Dense(3))
    model.add(Activation("softmax"))

    model.compile(
        loss="categorical_crossentropy", optimizer=Adam(lr=0.01), metrics=["accuracy"]
    )

    return model

训练

model = create_model()
model.fit(X_train, Y_train, batch_size=512, epochs=5)

训练输出

Epoch 1/5
878396/878396 [==============================] - 37s 42us/step - loss: 0.2586 - accuracy: 0.0173
Epoch 2/5
878396/878396 [==============================] - 36s 41us/step - loss: 0.2538 - accuracy: 0.0175
Epoch 3/5
878396/878396 [==============================] - 36s 41us/step - loss: 0.2538 - accuracy: 0.0176
Epoch 4/5
878396/878396 [==============================] - 37s 42us/step - loss: 0.2537 - accuracy: 0.0177
Epoch 5/5
878396/878396 [==============================] - 38s 43us/step - loss: 0.2995 - accuracy: 0.0174

编辑-1

在尝试了Max的建议后，以下是结果(损失和准确性仍未改变)

建议的模型

def create_model():
    model = Sequential()

    model.add(LSTM(64, return_sequences=False))

    model.add(Dense(8))
    model.add(Activation("softmax"))

    model.compile(
        loss="categorical_crossentropy",
        optimizer=Adam(lr=0.001),
        metrics=["accuracy"],
    )

    return model

X_train

array([[[205],
        [217],
        [209],
        [215],
        [206]],

       [[217],
        [209],
        [215],
        [206],
        [206]],

       [[209],
        [215],
        [206],
        [206],
        [211]],

       ...,

       [[175],
        [175],
        [173],
        [176],
        [174]],

       [[175],
        [173],
        [176],
        [174],
        [176]],

       [[173],
        [176],
        [174],
        [176],
        [173]]])

Y_train (P.S:实际上有8个目标类。上面的例子是对实际问题的简化)

array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       ...,
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]])

Training-output

Epoch 1/5
878396/878396 [==============================] - 15s 17us/step - loss: 0.1329 - accuracy: 0.0190
Epoch 2/5
878396/878396 [==============================] - 15s 17us/step - loss: 0.1313 - accuracy: 0.0190
Epoch 3/5
878396/878396 [==============================] - 16s 18us/step - loss: 0.1293 - accuracy: 0.0190
Epoch 4/5
878396/878396 [==============================] - 16s 18us/step - loss: 0.1355 - accuracy: 0.0195
Epoch 5/5
878396/878396 [==============================] - 15s 18us/step - loss: 0.1315 - accuracy: 0.0236

编辑-2

根据Max和Marcin的建议，准确度低于3%。虽然十分之一，它达到95%的准确性。这完全取决于第一个时代开始时的精确度。如果它没有在正确的位置开始梯度下降，它就不能达到很好的精度。我需要使用不同的初始化器吗？改变学习速度不会带来可重复的结果。

建议：

Scale/Normalize X_train ( to )
不重塑LSTM层中的Y_train Y_train小单位(从64减少到16)
有较小的batch_size (从512减少到64)

缩放X_train

array([[[ 0.01060734],
        [ 0.03920736],
        [ 0.02014085],
        [ 0.03444091],
        [ 0.01299107]],

       [[ 0.03920728],
        [ 0.02014073],
        [ 0.03444082],
        [ 0.01299095],
        [ 0.01299107]],

       [[ 0.02014065],
        [ 0.0344407 ],
        [ 0.01299086],
        [ 0.01299095],
        [ 0.02490771]],

       ...,

       [[-0.06089251],
        [-0.06089243],
        [-0.06565897],
        [-0.05850889],
        [-0.06327543]],

       [[-0.06089251],
        [-0.06565908],
        [-0.05850898],
        [-0.06327555],
        [-0.05850878]],

       [[-0.06565916],
        [-0.0585091 ],
        [-0.06327564],
        [-0.05850889],
        [-0.06565876]]])

非整形Y_train

array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       ...,
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]])

具有较小单元的模型

def create_model():
    model = Sequential()

    model.add(LSTM(16, return_sequences=False))

    model.add(Dense(8))
    model.add(Activation("softmax"))

    model.compile(
        loss="categorical_crossentropy", optimizer=Adam(lr=0.001), metrics=["accuracy"]
    )

    return model

训练输出

Epoch 1/5
878396/878396 [==============================] - 26s 30us/step - loss: 0.1325 - accuracy: 0.0190
Epoch 2/5
878396/878396 [==============================] - 26s 29us/step - loss: 0.1352 - accuracy: 0.0189
Epoch 3/5
878396/878396 [==============================] - 26s 30us/step - loss: 0.1353 - accuracy: 0.0192
Epoch 4/5
878396/878396 [==============================] - 26s 29us/step - loss: 0.1365 - accuracy: 0.0197
Epoch 5/5
878396/878396 [==============================] - 27s 31us/step - loss: 0.1378 - accuracy: 0.0201

lstm

machine-learning

keras

deep-learning

回答 1

Stack Overflow用户

发布于 2019-10-11 13:27:42

序列应该是LSTM的第一个维度(输入数组的第二个)，即：

重塑数据集

X_train = train_df.rolling_window.values
X_train = X_train.reshape(X_train.shape[0], SEQ_LEN, 1)

Y_train = train_df.labels.values
Y_train = Y_train.reshape(Y_train.shape[0], 3)

LSTM不需要输入形状。LSTM默认具有“tanh”激活，这通常是一个很好的选择。

模型

def create_model():
    model = Sequential()

    model.add(LSTM(64, return_sequences=True))

    model.add(Flatten())
    model.add(Dense(3))
    model.add(Activation("softmax"))

    model.compile(loss="categorical_crossentropy", optimizer=Adam(lr=0.01), metrics=["accuracy"])

    return model

也许不是使用平面()层，而是将return_sequences=False用于LSTM是一个更好的选择。试试看吧。

编辑

此外，试着在数据的特征缩放方面进行预处理。数据值似乎相当大。

票数 0

页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持

原文链接：

https://stackoverflow.com/questions/58339718

复制

相似问题

问基于LSTM Keras的序列数据的多类分类
EN

回答 1

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问基于LSTM Keras的序列数据的多类分类EN

回答 1

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问基于LSTM Keras的序列数据的多类分类
EN