Ожидается, что lambda_1_input будет иметь 4 измерения, но получит массив с формой (Нет, Нет, Нет, Нет, Нет)

Question

Я пытаюсь обучить модель оптического потока для определения скорости автомобиля с помощью Keras, но я получаю следующую ошибку при работе model.fit_generator:

ValueError: Error when checking input: expected lambda_1_input to have 4 dimensions, but got array with shape (None, None, None, None, None)

Я имею искали похожие посты, и большинство решений заключалось в том, что люди забыли преобразовать свои изображения с 3-мя измерениями в список с 4. Однако по какой-то причине я получаю массив с измерением 5, и форма все отсутствует. Я не совсем уверен, что происходит, как это казалось раньше.

Вот код для модели:

N_img_height = 66
N_img_width = 220
N_img_channels = 3

def model():
    inputShape = (N_img_height, N_img_width, N_img_channels)

    model = Sequential()
    # normalization    
    # perform custom normalization before lambda layer in network
    model.add(Lambda(lambda x: x/ 127.5 - 1, input_shape = inputShape))

    model.add(Convolution2D(24, (5, 5), 
                            strides=(2,2), 
                            padding = 'valid',
                            kernel_initializer = 'he_normal',
                            name = 'conv1'))


    model.add(ELU())    
    model.add(Convolution2D(36, (5, 5), 
                            strides=(2,2), 
                            padding = 'valid',
                            kernel_initializer = 'he_normal',
                            name = 'conv2'))

    model.add(ELU())    
    model.add(Convolution2D(48, (5, 5), 
                            strides=(2,2), 
                            padding = 'valid',
                            kernel_initializer = 'he_normal',
                            name = 'conv3'))
    model.add(ELU())
    model.add(Dropout(0.5))
    model.add(Convolution2D(64, (3, 3), 
                            strides = (1,1), 
                            padding = 'valid',
                            kernel_initializer = 'he_normal',
                            name = 'conv4'))

    model.add(ELU())              
    model.add(Convolution2D(64, (3, 3), 
                            strides= (1,1), 
                            padding = 'valid',
                            kernel_initializer = 'he_normal',
                            name = 'conv5'))


    model.add(Flatten(name = 'flatten'))
    model.add(ELU())
    model.add(Dense(100, kernel_initializer = 'he_normal', name = 'fc1'))
    model.add(ELU())
    model.add(Dense(50, kernel_initializer = 'he_normal', name = 'fc2'))
    model.add(ELU())
    model.add(Dense(10, kernel_initializer = 'he_normal', name = 'fc3'))
    model.add(ELU())

    # do not put activation at the end because we want to exact output, not a class identifier
    model.add(Dense(1, name = 'output', kernel_initializer = 'he_normal'))

    adam = Adam(lr=1e-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
    model.compile(optimizer = adam, loss = 'mse')

    return model

Этот код используется для создания собственного генератора данных обучения и проверки:

def generate_training_data(train_split, train_meta, batch_size = 30):
    image_batch = np.zeros((batch_size, 66, 220, 3))
    label_batch = np.zeros((batch_size))

    while True:
        for i in range(batch_size):

            idx = np.random.randint(0, len(train_split))

            index1 = train_split[idx]
            index2 = index1 + 1

            img1 = preprocess_image_from_path(f"clean_train_frames/F{index1}.jpeg")
            img2 = preprocess_image_from_path(f"clean_train_frames/F{index2}.jpeg")

            bright_factor = 0.2 * np.random.uniform()

            img1 = blur_image(adjust_brightness(img1, bright_factor))
            img2 = blur_image(adjust_brightness(img2, bright_factor))

            flow = opticalFlow(img1, img2)

            image_batch[i] = flow
            label_batch[i] = (train_meta.iloc[index1]["speed"] + train_meta.iloc[index2]["speed"]) / 2

        yield image_batch, label_batch

def generate_validation_data(valid_split, train_meta):
    while True:
        for idx in range(0, len(valid_split) - 1):
            index1 = train_split[idx]
            index2 = index1 + 1

            img1 = preprocess_image_from_path(f"clean_train_frames/F{index1}.jpeg")
            img2 = preprocess_image_from_path(f"clean_train_frames/F{index2}.jpeg")

            flow = opticalFlow(img1, img2)
            flow = flow.reshape(1, *np.shape(flow))

            speed = (train_meta.iloc[index1]["speed"] + train_meta.iloc[index2]["speed"]) / 2

            speed = np.array([[speed]])

            yield img1.reshape(1, *np.shape(flow)), speed

Наконец Вот как я передаю данные в модель для обучения:

val_size = len(valid_split)
valid_generator = generate_validation_data(valid_split, train_meta)
BATCH = 10
print('val_size: ', val_size)

filepath = 'asdf.h5'
earlyStopping = EarlyStopping(monitor='val_loss', 
                              patience=1, 
                              verbose=1, 
                              min_delta = 0.23,
                              mode='min',)
modelCheckpoint = ModelCheckpoint(filepath, 
                                  monitor = 'val_loss', 
                                  save_best_only = True, 
                                  mode = 'min', 
                                  verbose = 1,
                                 save_weights_only = True)
callbacks_list = [modelCheckpoint]

model = model()
train_size = len(train_split)
train_generator = generate_training_data(train_split, train_meta, BATCH)

history = model.fit_generator(
        generator = train_generator,
        steps_per_epoch = 400, 
        epochs = 85,
        callbacks = callbacks_list,
        verbose = 1,
        validation_data = valid_generator,
        validation_steps = val_size)

print(history)

Любая помощь будет высоко ценится. Спасибо!