Python CNNLSTM2D实现

列车组有2550幅图像，测试组有1530幅图像。为了将这些图像分为两类，使用了一个混合的深度学习模型，包括，但是在运行代码时出现了一个错误，如下所示。我想知道是否有人帮我知道错误的原因。多谢各位

错误：

检查输入时：预期conv_lst_m2d_39_输入有5个维度，但得到了具有形状（32、64、64、3）的数组

新错误：

将numpy导入为np
导入glob
从PIL导入图像
导入tensorflow作为tf
images\u png=glob.glob（“*.png”）
图像=[]
对于图片中的pic\u png：
image=tf.read_文件（pic）
image=tf.image.decode_png（图像，通道=3，数据类型=tf.uint16）
image=tf.cast（image，tf.float32）
image=image/256.0
images.append（图像）
img_seq_list=[]
对于范围内的i（0，透镜（图像）-5，5）：
j=i+5
img_seq=np.stack（图像[i:j]，轴=0）
img_seq_list.追加（img_seq）
labels=np.zero（（2，len（img序列列表）+1），dtype=int）
标签=np.转置（标签）
长度=长度（img序列列表）/2
长度=整数（长度）
对于范围（0255）内的i：
如果我是127：
标签[i][1]=1
导入tensorflow作为tf
从keras.models导入顺序
从keras.layers导入卷积2D
从keras.layers导入MaxPoolig2D
从keras.layers导入展平
从keras.layers导入稠密
来自keras.layers.voluminal_ConvLSTM2D
从keras.layers.normalization导入批处理normalization
分类器=顺序（）
add（ConvLSTM2D（filters=40，kernel_size=（3,3），input_shape=（5,64,64,3），padding='same'，return_sequences=True））
add（BatchNormalization（））
add（ConvLSTM2D（filters=40，kernel_size=（3,3），
padding='same'，返回（序列=True））
add（BatchNormalization（））
add（ConvLSTM2D（filters=40，kernel_size=（3,3），
（同上）
#全连接
add（稠密（输出尺寸=128，激活=relu'））
add（稠密（输出尺寸=1，激活度='sigmoid'））
#编辑CNN
compile（优化器='adam'，loss='binary\u crossentropy'，metrics=['accurity']）
train_data=tf.data.Dataset.from_tensor_切片（（img_seq_list[0:127]，labels[0:127]））
序列数据=序列数据。随机（100）。批处理（10）
test_data=tf.data.Dataset.from_tensor_切片（（img_seq_list[128:254]，labels[128:254]））
测试数据=训练数据。洗牌（100）。批量（10）
历史=分类器.fit（训练数据、验证数据=测试数据）
将matplotlib.pyplot作为plt导入
acc=历史。历史['acc']
val_acc=历史。历史['val_acc']
损失=历史。历史['loss']
val_loss=历史。历史['val_loss']
历元=范围（1，透镜（acc）+1）
plt.绘图（时代、科目、r、标签、培训科目）
plt.绘图（历代，val_acc，'b'，label='Validation acc'）
产品名称（“培训和验证准确性”）
plt.legend（）
plt.图（）
plt.plot（时代、损失、“r”、标签=“培训损失”）
plt.绘图（年代、价值损失、“b”、标签=”验证损失“）
产品名称（“培训和验证损失”）
plt.plot（）
plt.legend（）
plt.show（）
测试损失，测试acc=分类器。评估（测试数据）
打印（“测试依据：”，测试依据）

我认为问题在于卷积LSTM层需要一个图像的时间序列，因此它必须有5个维度，包括批处理维度，因此形状为

（B，T，H，W，C）

。您已将输入形状（忽略批次维度）定义为

（无，64，64，3）

，因此需要输入形状

（批次，时间步长，64，64，3）

的批次张量

另外，我认为不赞成将生成器传递给

fit（）

编辑：如果您拥有视频流中的一系列帧，则可以将它们堆叠到具有一个或多个维度的数组中。您必须以正确的顺序从目录中手动获取图像，然后制作一个数据迭代器：

图像=
img_seq=np.堆栈（图像，轴=0）
#对训练数据中的每个图像序列执行上述操作，以获得N个序列
序列=
标签=
train_data=tf.data.Dataset.from_tensor_切片（（序列，标签））
序列数据=序列数据。随机（1000）。批量（批量大小）
#对测试数据执行类似操作

然后，您可以使用

fit（）

中的

tf.data.Dataset

：

model.fit（训练数据、验证数据=测试数据）

谢谢Aaron，我没有注意到你关于时间步的意思。你能在我的代码中解释一下吗？该层需要一系列图像作为输入（例如视频帧）。我的意思是你需要一系列的图像作为输入。如果你的数据集中只有不同的图像，这些图像在时间上是不相关的，那么卷积LSTM可能不合适。谢谢。我总共有2550张图片，正如你说的，我必须把它们做成5D张量的视频。作为python数据结构，有什么建议吗？您需要按照图像来自视频流的顺序对图像进行分组。我已经更新了我的答案。你应该删除代码中不再使用的旧部分，否则会造成混乱。你永远不应该使用图像来显示文本，始终以正确的格式复制并粘贴到问题中。在任何情况下，这都不是错误，只是张量列表。那么实际的例外是什么呢？好的。当然通过运行代码，spyder只显示一个张量列表，然后完成处理，不保留它。我认为您应该编辑此帖子，删除旧代码和错误，并准确指定新问题是什么以及您希望它做什么。此问题的新帖子位于此链接中：

    # importing libraries
    from keras.models import Sequential
    from keras.layers import Convolution2D
    from keras.layers import MaxPooling2D
    from keras.layers import Flatten
    from keras.layers import Dense
    import tensorflow as tf
    from keras.layers.convolutional_recurrent import ConvLSTM2D
    from keras.layers.normalization import BatchNormalization
    
    #Data_Prprocessing
    from keras.preprocessing.image import ImageDataGenerator
    train_datagen = ImageDataGenerator(
                                        rescale=1./255,
                                        shear_range=0.2,
                                        zoom_range=0.2,
                                        horizontal_flip=True)
    test_datagen = ImageDataGenerator(rescale=1./255)
    training_set = train_datagen.flow_from_directory(
                                        'D:\\thesis\\Paper 3\\Feature Extraction\\two_dimension_Feature_extraction\\stft_feature\\Training_set',
                                        target_size=(64, 64),
                                        batch_size=32,
                                        class_mode='binary')
    test_set = test_datagen.flow_from_directory(
                                        'D:\\thesis\\Paper 3\\Feature Extraction\\two_dimension_Feature_extraction\\stft_feature\\Test_set',
                                        target_size=(64, 64),
                                        batch_size=32,
                                        class_mode='binary')
    
    #initializing the CNN
    classifier = Sequential()
    
    classifier.add(ConvLSTM2D(filters=40, kernel_size=(3, 3),input_shape=(None, 64, 64, 3),  padding='same', return_sequences=True))
    
    classifier.add(BatchNormalization())
    
    classifier.add(ConvLSTM2D(filters=40, kernel_size=(3, 3),
                       padding='same', return_sequences=True))
    classifier.add(BatchNormalization())
    
    classifier.add(ConvLSTM2D(filters=40, kernel_size=(3, 3),
                       padding='same'))
    
    #Full Connection
    classifier.add(Dense(output_dim = 128, activation = 'relu'))
    classifier.add(Dense(output_dim = 1, activation = 'sigmoid'))
    
    #compiling the CNN
    classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
    
    #Fitting the CNN to the images
    
    history = classifier.fit_generator(training_set,
                             steps_per_epoch=2550,
                             epochs=25,
                             validation_data= test_set,
                             validation_steps=510)
    
    
    import matplotlib.pyplot as plt
    acc = history.history['acc']
    val_acc = history.history['val_acc']
    loss = history.history['loss']
    val_loss = history.history['val_loss']
    epochs = range(1, len(acc) + 1)
    plt.plot(epochs, acc, 'r', label='Training acc')
    plt.plot(epochs, val_acc, 'b', label='Validation acc')
    plt.title('Training and validation accuracy')
    plt.legend()
    plt.figure()
    plt.plot(epochs, loss, 'r', label='Training loss')
    plt.plot(epochs, val_loss, 'b', label='Validation loss')
    plt.title('Training and validation loss')
    plt.plot()
    plt.legend()
    plt.show()
    test_loss, test_acc = classifier.evaluate(test_set)
    print('test_acc:', test_acc)

ERROR:
ValueError: Input 0 is incompatible with layer conv_lst_m2d_23: expected ndim=5, found ndim=6

import numpy as np
import glob
from PIL import Image
import tensorflow as tf

images_png = glob.glob("*.png")
images = []
for pic in images_png:
    image = tf.read_file(pic)
    image = tf.image.decode_png(image, channels=3, dtype=tf.uint16)
    image = tf.cast(image, tf.float32)
    image = image / 256.0
    images.append(image)

img_seq_list = []
for i in range(0, len(images) - 5, 5): 
    j = i+5       
    img_seq = np.stack(images[i:j], axis=0)
    img_seq_list.append(img_seq)
    
labels = np.zeros((2,len(img_seq_list) + 1), dtype=int)
labels = np.transpose(labels)
length = len(img_seq_list)/2
length = int(length)
for i in range(0, 255):
    if i <= 127:
        labels[i][0] = 1
    elif i > 127 :
        labels[i][1] = 1

        
  

import tensorflow as tf
from keras.models import Sequential
from keras.layers import Convolution2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers.convolutional_recurrent import ConvLSTM2D
from keras.layers.normalization import BatchNormalization

classifier = Sequential()

classifier.add(ConvLSTM2D(filters=40, kernel_size=(3, 3),input_shape=(5, 64, 64, 3),  padding='same', return_sequences=True))

classifier.add(BatchNormalization())

classifier.add(ConvLSTM2D(filters=40, kernel_size=(3, 3),
                   padding='same', return_sequences=True))
classifier.add(BatchNormalization())

classifier.add(ConvLSTM2D(filters=40, kernel_size=(3, 3),
                   padding='same'))

#Full Connection
classifier.add(Dense(output_dim = 128, activation = 'relu'))
classifier.add(Dense(output_dim = 1, activation = 'sigmoid'))

#compiling the CNN
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

train_data = tf.data.Dataset.from_tensor_slices((img_seq_list[0:127], labels[0:127]))
train_data = train_data.shuffle(100).batch(10) 

test_data = tf.data.Dataset.from_tensor_slices((img_seq_list[128:254], labels[128:254]))
test_data = train_data.shuffle(100).batch(10)


history = classifier.fit(train_data, validation_data=test_data)

import matplotlib.pyplot as plt
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs, acc, 'r', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'r', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.plot()
plt.legend()
plt.show()

test_loss, test_acc = classifier.evaluate(test_data)
print('test_acc:', test_acc)