Neural network Keras C3DNN预测结果相同

我正试图在Tensorflow支持的Keras中使用Conv3D神经网络进行变长多类序列分类

我创建了一个小示例，其中基于预期输出的标签生成输入分布。使用输入生成器对网络进行训练后，预测结果总是相同的值

复制：

将numpy导入为np
进口干酪
从keras.utils导入到_category
从keras.layers导入Conv3D、输入、展平、密集、Lambda、MaxPool3D、退出、激活
从keras.regularizers导入l2
从keras.optimizers导入Adam
从随机导入randint
从keras.models导入模型，顺序
将keras.backend作为K导入
#导入操作系统
#os.environ['CUDA_VISIBLE_DEVICES']='-1'
高度=40
宽度=40
NDIMS=1
NUM_类=10
def get_data（）：
nframes=randint（3,6）
label=randint（0，NUM_类-1）
x=np.数组（（（标签+1）*2）*np.随机.randn（n帧、高度、宽度、NDIMS））
#打印（np.标准（x），标签）
x=np。展开尺寸（x，轴=0）
y=keras.utils.to_category（[label]，num_classes=num_classes）
返回x，y
def输入_生成器（）：
尽管如此：
x、 y=获取_数据（）
产量（x，y）
def c3d（）：
重量衰减=0.005
输入=输入（（无、高度、宽度、NDIMS））
x=Conv3D（64，（3,3,3），跨步=（1,1,1），padding='same'，
激活='relu'，核正则化器=l2（权重衰减））（输入）
x=MaxPool3D（（2,2,1），跨步=（2,2,1），填充=（相同的'）（x）
x=Conv3D（128，（3,3,3），跨步=（1,1,1），padding='same'，
激活=relu'，核正则化子=l2（权重衰减））（x）
x=Lambda（Lambda-xa:K.sum（xa，轴=1））（x）
x=展平（）（x）
x=稠密（64，激活=relu'，核正则化子=l2（权重衰减））（x）
x=辍学率（0.5）（x）
x=稠密（32，活化=relu'，核正则化子=l2（重量衰减））（x）
x=辍学率（0.5）（x）
x=稠密（NUM\u类，核正则化器=l2（权重衰减））（x）
x=激活（'softmax'）（x）
lr=0.005
优化器=Adam（lr=lr）
模型=模型（输入，x）
compile（loss='classifical\u crossentropy'，optimizer=optimizer，metrics=['accurity']））
回归模型
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
型号=c3d（）
model.fit_生成器（input_generator（），每个_epoch的样本数=10，nb_epoch=50，verbose=1）
值=[]
argmaxes=[]
对于范围（100）内的i：
x、 获取数据（）
val=模型预测（x）
values.append（val）
argmaxes.append（np.argmax（val））
打印（argmaxes）

对于最后一条print语句，输出如下所示：

[4,4,4,4,4,4,4,4,4,4,4,4,4,4。。。

它在（0，NUM_CLASSES-1）中选择一个随机数，并在每次预测中使用它。在特征和它的标签之间应该有一个模式

更新：解决问题：

我已经将问题简化为更基本的元素，但还无法在原始问题（c3d）中获得这些结果.我已经用重复的标签替换了特征数据，并且我能够让网络多少了解到重复n次的值实际上就是分类。无论是可变长度还是非可变长度，在每5个时代500个样本的3次激活中，目测最近10次的最佳平均准确度得出：

输入、激活、学习率、层大小、激活、准确性、顺序
np.重复：tanh 0.001 48 adagrad 0.463199999995假
np.repeat:sigmoid 0.001 64 adam 0.47200000000000001假
np.重复：relu 0.001 64 adam 0.30519999999997错误

复制：

将numpy导入为np
进口干酪
从keras.utils导入到_category
从keras.layers导入输入，密集，λ
从keras.optimizers导入Adam、SGD、Adagrad、RMSprop
从随机导入randint
从keras.models导入模型
将keras.backend作为K导入
宽度=40
NUM_类=10
尺寸=1
无顺序=错误
def get_data（）：
nframes=randint（3,6）
label=randint（0，NUM_类-1）
x=np.repeat（标签，宽度*nframes）。重塑（nframes，宽度）。aType（np.float32）
#x=np.数组（（（标签+1）*2）*np.随机数.randn（n帧，宽度））
如果没有顺序：
x=x[0]
#打印（x，标签）
x=np。展开尺寸（x，轴=0）
y=keras.utils.to_category（[label]，num_classes=num_classes）
返回x，y
def输入_生成器（）：
尽管如此：
x、 y=获取_数据（）
产量（x，y）
def cd（activation='relu'，lr=0.0001，densite_size=16，optimizer=Adam（））：
如果没有顺序：
输入=输入（（宽度，））
x=密集（密集尺寸，激活=激活）（输入）
其他：
输入=输入（（无，宽度））
x=密集（密集尺寸，激活=激活）（输入）
x=Lambda（Lambda-xa:K.sum（xa，轴=1））（x）
x=密集（NUM_类，activation='softmax'）（x）
optimizer.lr=lr
模型=模型（输入，x）
compile（loss='classifical\u crossentropy'，optimizer=optimizer，metrics=['accurity']））
回归模型
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
激活=['sigmoid'，'tanh'，'relu']
学习率=[.01、.001、.0001、.00001]
图层大小=[16,32,48,64]
优化器=[（'adagrad'，adagrad（）），（'sgd'，sgd（）），（'rmsprop'，rmsprop（）），（'adam'，adam（））]
模型=cd（）
打印（model.summary（））
对于处于激活状态的用户：
对于学习中的lr费用：
对于层大小的ls：
优化器中的op名称：
型号=cd（a、lr、ls、op）
h=model.fit_生成器（输入_生成器（），每个_历元的采样数=500，nb_历元=5，详细度=0）
打印（a、lr、ls、名称、np.平均值（h.history.get（'acc'）[-10:]））#平均最后10个精度

问题：

为什么我的预测结果是这样的？我如何解决这个问题？ 似乎增加训练量会产生更好的结果，但即使给定标签数组的输入，仍然需要sig

import numpy as np
import keras
from keras.utils import to_categorical
from keras.layers import Conv3D, Input, Flatten, Dense, Lambda, MaxPool3D, Dropout, Activation
from keras.regularizers import l2
from keras.optimizers import Adam
from random import randint
from keras.models import Model, Sequential
import keras.backend as K

#import os
#os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
HEIGHT = 40
WIDTH = 40
NDIMS = 1
NUM_CLASSES = 10

def get_data():
    nframes = randint(3,6)
    label = randint(0,NUM_CLASSES-1)
    x = label++np.random.randn(nframes, HEIGHT, WIDTH, NDIMS)
    #print(np.std(x), label)
    x = np.expand_dims(x, axis=0)
    y = keras.utils.to_categorical([label], num_classes=NUM_CLASSES)
    return x,y

def input_generator():
    while True:
        x,y = get_data()
        yield (x, y)

def c3d():
    weight_decay = 0.000
    inputs = Input((None, HEIGHT, WIDTH, NDIMS))
    x = Conv3D(64,(3,3,3),strides=(1,1,1),padding='same',
            activation='relu',kernel_regularizer=l2(weight_decay))(inputs)
    x = MaxPool3D((2,2,1),strides=(2,2,1),padding='same')(x)
    x = Conv3D(128,(3,3,3),strides=(1,1,1),padding='same',
            activation='relu',kernel_regularizer=l2(weight_decay))(x)
    x = Lambda(lambda xa: K.sum(xa, axis=1))(x)
    x = Flatten()(x)
    x = Dense(64,activation='relu',kernel_regularizer=l2(weight_decay))(x)
    x = Dropout(0.0)(x)
    x = Dense(32,activation='relu',kernel_regularizer=l2(weight_decay))(x)
    x = Dropout(0.0)(x)
    x = Dense(NUM_CLASSES,kernel_regularizer=l2(weight_decay))(x)
    x = Activation('softmax')(x)

    lr = 0.0001
    optimizer = Adam(lr=lr)
    model = Model(inputs, x)
    model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
    return model

if __name__ == '__main__':
    model = c3d()
    print(model.summary())
    model.fit_generator(input_generator(), samples_per_epoch=1000, workers=5, use_multiprocessing=True, nb_epoch=5, verbose=1)
    values = []
    argmaxes = []
    for i in range(100):
        x,_ = get_data()
        val = model.predict(x)
        values.append(val)
        argmaxes.append(np.argmax(val))
    print(argmaxes)

1000/1000 [==============================] - 216s 216ms/step - loss: 1.6944 - acc: 0.3840
Epoch 2/5
1000/1000 [==============================] - 222s 222ms/step - loss: 0.9882 - acc: 0.5920
Epoch 3/5
1000/1000 [==============================] - 225s 225ms/step - loss: 0.7479 - acc: 0.7050
Epoch 4/5
1000/1000 [==============================] - 221s 221ms/step - loss: 0.4670 - acc: 0.7950
Epoch 5/5
1000/1000 [==============================] - 214s 214ms/step - loss: 0.6742 - acc: 0.8040
[9, 5, 4, 8, 0, 7, 9, 2, 9, 1, 7, 7, 2, 5, 7, 2, 5, 2, 8, 5, 9, 9, 0, 3, 8, 1, 9, 7, 3, 9, 1, 0, 1, 4, 2, 0, 3, 5, 4, 4, 9, 7, 2, 2, 4, 2, 4, 6, 4, 0, 1, 6, 8, 4, 5, 9, 1, 1, 0, 2, 0, 4, 7, 0, 0, 4, 7, 3, 2, 2, 5, 6, 3, 6, 2, 4, 7, 1, 2, 7, 3, 6, 1, 3, 3, 0, 2, 8, 3, 2, 1, 2, 3, 7, 8, 7, 9, 9, 6, 6]