Python 在LSTM（NLP多标签分类）中处理超长时间步长序列

这是我第一次问有关stackoverflow的问题，如果我问的格式不正确，那么很抱歉。假设我正在处理一些非常长的时间步序列数据（10000000），有2701个样本，只有一个特性，我的输入数组是

[270110000000,1]

，我的数据集看起来像

 [ 2.81143e-01  4.98219e-01 -8.08500e-03 ...  1.00000e+02  1.00000e+02
   1.00000e+02]
 [ 1.95077e-01  2.20920e-02 -1.68663e-01 ...  1.00000e+02  1.00000e+02
   1.00000e+02]
 ...
 [ 1.06033e-01  8.96650e-02 -3.20860e-01 ...  1.00000e+02  1.00000e+02
   1.00000e+02]
 [ 6.85510e-02 -3.83653e-01 -2.19265e-01 ...  1.00000e+02  1.00000e+02
   1.00000e+02]
 [ 2.51404e-01  8.02280e-02  2.84610e-01 ...  1.00000e+02  1.00000e+02
   1.00000e+02]]

然而，根据我所读到的，通常LSTM网络在（200~400）个时间步长范围内表现更好，即使忽略性能，我也无法使用单个样本成功地进行训练

[110000000,1]

。我相信网络是正常的，因为我试图将每个样本的长度限制在（1500）以内，现在是

[27011500,1]

，它最终在第一个纪元停止了阻塞。如果需要，下面是我的代码：

from keras.utils import Sequence
import numpy as np
from numpy.lib.format import open_memmap
import gc
import platform
import pandas as pd
import numpy
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers import Dropout
from keras.layers import Masking
from sklearn.model_selection import train_test_split
import tensorflow as tf
from keras.backend.tensorflow_backend import set_session

config = tf.ConfigProto()
config.gpu_options.allocator_type = 'BFC' #A "Best-fit with coalescing" algorithm, simplified from a version of dlmalloc.
config.gpu_options.per_process_gpu_memory_fraction = 0.9
config.gpu_options.allow_growth = True
set_session(tf.Session(config=config)) 

stock_price=pd.read_csv("C:/Users/user/Desktop/Final-Year-Project-master/stock_classification_7Days_test.csv",sep=',', dtype={"ID":"string","Class":int})
print(stock_price)


print (platform.architecture()) 

y_data=[]
x_data=[]

y_data=pd.get_dummies(stock_price['Class'])


def embedded_reader(file_path):
    with open(file_path) as embedded_raw:
        for line in embedded_raw:
            for word in line.split(','):
                try:
                    val=float(word)
                    yield val
                except:
                    pass
    
    embedded_raw.close()
    gc.collect()   
        

for y in range(len(stock_price)):
    if int(stock_price.at[y,'Class']) is not None:
        i = stock_price.at[y,'ID']
        print("Company code current: ",i)
        embedded_current=[]

        try:
            gen=embedded_reader("C:/Users/user/Desktop/Final-Year-Project-master/json_test/{}.jsonl".format(i))

            
            while True:
                val=next(gen)
                embedded_current.append(val)

        except:
            pass

                    
        fp=np.memmap('embedded_array.mymemmap', dtype=np.uint8,mode='w+',shape=(1,)) 
        fp=np.delete(fp,0)
        fp=np.concatenate((fp,embedded_current),axis=0)
        fp=np.pad(fp, (0,(10000000-len(embedded_current))), 'constant', constant_values=(100, 100))
        print(fp)
        x_data.append(fp)
        print(np.shape(x_data))
        del fp

        print("embedded_data current: ",len(embedded_current))

        print("this is number {}".format(y))
        print("-----------------------------")
        gc.collect()
        

    gc.collect()        


                  
print(len(x_data))
print(np.shape(x_data))
print("-"*20)
print(np.shape(y_data))
print(np.size(y_data))

X_train, X_test, y_train, y_test = train_test_split(x_data,y_data,test_size=0.2,random_state=0)
print(np.shape(X_train))
print(np.shape(X_test))
X_train=np.array(X_train)
X_test=np.array(X_test)
print(np.shape(X_train))
print(np.shape(X_test))
print(X_train)
X_train = np.reshape(X_train, (X_train.shape[0],  X_train.shape[1], 1))
X_test = np.reshape(X_test, (X_test.shape[0],  X_train.shape[1], 1))
print(np.shape(X_train))
print(np.shape(X_test))
y_train=np.array(y_train)
y_test=np.array(y_test)

print(len(X_test[0]))
print(np.shape(y_train))


model=Sequential()

model.add(Masking(mask_value=100, input_shape=(10000000,1)))
model.add(LSTM(units=1, return_sequences = True, input_shape=(10000000,1)))
model.add(LSTM(units=1,return_sequences=False))
model.add(Dense(5,activation='sigmoid'))
model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])


model.summary()
model.fit(X_train,y_train,epochs=50,batch_size=4,verbose=1)
print(model.predict(X_test))
print("class label:", reverse_label(model.predict_classes(X_test)))
scores = model.evaluate(X_test, y_test)
print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))



model.save('my_model')

从他们提到的重塑阵列的一些教程中，我尝试将我的阵列重塑为类似于

[2701*25000，10000000/25000，1]

，但后来我遇到了一个问题，x_数据样本和y_数据样本不一样。我还看到了提到的

model.fit_generator

，但它似乎解决了样本量大的问题，在我的例子中，模型甚至不能处理单个样本（我是神经网络新手，所以不确定我是否正确理解它）。完全没有线索，非常感谢您的帮助，谢谢

---

编辑：请明确说明我的问题：“关于使用LSTM处理如此长的输入有什么建议吗？”

不确定您是否寻求关于如何使用LSTM处理长输入的建议，或者如何在重塑后修复x和y之间的长度不匹配。如果重塑输入，则创建400*2701个新的输入样本。所以x和y的长度不一样。为了缓解这种情况，你还应该“重塑”y，在这种情况下，每y复制400次，并使其全部适合2701*25000个向量。谢谢你的建议，我确实考虑过简单地复制y_数据以适应形状，只是不确定这是否可行。那么，假设我只是在寻求关于如何使用LSTM处理长输入的建议，那么我的最佳选择是什么？或者，重塑数据是否是解决此类问题的常用方法？再一次，非常感谢您的时间，当我在谷歌上搜索了几个星期，几乎什么都没有得到时，这意味着很多。我不知道如何处理时间步序列和很长的输入，我只使用了大约500个单词的序列。我认为整形不是一个好方法。使用双向编码器处理长依赖关系。也许你可以试试卷积神经网络？或者尝试使用其他工具？如果您使用序列标签，您可以尝试使用更简单的条件随机场（它们经常用于文本）。希望helpsI最终使用了整形和fit_生成器来处理任务，它的性能真的很差，正如预期的那样，但是由于某些原因，我无法更改为另一个工具，所以我想我现在只能接受它，尽管它非常…强制。无论如何，还是要谢谢你的时间，我会确保检查这些工具。