小编tod*_*day的帖子

我有两个训练有素的模型（model_A和model_B），并且两个模型都有辍学层。我已经冻结model_A并model_B合并了它们，并获得了新的密集层model_AB（但我尚未删除model_A的和model_B的辍学层）。model_AB的权重将是不可训练的，除了增加的致密层。

现在的问题是：在辍学层model_A和model_B活动状态（即滴神经元）时，我的训练model_AB？

我正在尝试构建图像分类模型。这是一个 4 类图像分类。这是我用于构建图像生成器和运行训练的代码：

train_datagen = ImageDataGenerator(rescale=1./255.,
                               rotation_range=30,
                               horizontal_flip=True,
                               validation_split=0.1)


train_generator = image_gen.flow_from_directory(train_dir, target_size=(299, 299), 
                                                class_mode='categorical', batch_size=20,
                                                subset='training')

validation_generator = image_gen.flow_from_directory(train_dir, target_size=(299, 299), 
                                                class_mode='categorical', batch_size=20,
                                                subset='validation')

model.compile(Adam(learning_rate=0.001), loss='categorical_crossentropy',
                                         metrics=['accuracy'])

model.fit_generator(train_generator, steps_per_epoch=int(440/20), epochs=20, 
                              validation_data=validation_generator, 
                              validation_steps=int(42/20))

我能够完美地进行训练和验证工作，因为训练目录中的图像存储在每个班级的单独文件夹中。但是，正如您在下面看到的，测试目录有 100 个图像，其中没有文件夹。它也没有任何标签，只包含图像文件。

如何使用 Keras对test文件夹中的图像文件进行预测？

我有两种类型的输入序列，其中input1包含 50 个值和input2包含 25 个值。我尝试在函数式 API 中使用 LSTM 模型来组合这两种序列类型。然而，由于我的两个输入序列的长度不同，我想知道我当前所做的是否是正确的方法。我的代码如下：

input1 = Input(shape=(50,1))
x1 = LSTM(100)(input1)
input2 = Input(shape=(25,1))
x2 = LSTM(50)(input2)

x = concatenate([x1,x2])
x = Dense(200)(x)
output = Dense(1, activation='sigmoid')(x)

model = Model(inputs=[input1,input2], outputs=output)

更具体地说，我想知道如何组合两个具有不同输入长度的 LSTM 层（即在我的例子中为 50 和 25）。如果需要，我很乐意提供更多详细信息。

我制作了一个 TensorFlow CsvDataset，我正在尝试对数据进行标记：

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
from tensorflow import keras
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
import os
os.chdir('/home/nicolas/Documents/Datasets')

fname = 'rotten_tomatoes_reviews.csv'


def preprocess(target, inputs):
    tok = Tokenizer(num_words=5_000, lower=True)
    tok.fit_on_texts(inputs)
    vectors = tok.texts_to_sequences(inputs)
    return vectors, target


dataset = tf.data.experimental.CsvDataset(filenames=fname,
                                          record_defaults=[tf.int32, tf.string],
                                          header=True).map(preprocess)

运行这个，给出以下错误：

ValueError: len 需要一个非标量张量，得到一个形状 Tensor("Shape:0", shape=(0,), dtype=int32)

我尝试过的：几乎任何可能性领域。请注意，如果我删除预处理步骤，一切都会运行。

数据是什么样的：

(<tf.Tensor: shape=(), dtype=int32, numpy=1>,
 <tf.Tensor: shape=(), dtype=string, numpy=b" Some movie critic review...">)

如何计算CNN网络中的参数总数

这是代码：

input_shape = (32, 32, 1)
flat_input_size = input_shape[0]*input_shape[1]*input_shape[2]
num_classes = 4

cnn_model = Sequential()
cnn_model.add(Conv2D(32, (3, 3), padding='same',
                 input_shape=input_shape))
cnn_model.add(Activation('relu'))
cnn_model.add(MaxPooling2D(pool_size=(2, 2)))
cnn_model.add(Conv2D(64, (3, 3)))
cnn_model.add(Activation('relu'))
cnn_model.add(MaxPooling2D(pool_size=(2, 2)))
cnn_model.add(Dropout(0.25))
cnn_model.add(Conv2D(128, (3, 3), padding='same'))
cnn_model.add(Activation('relu'))
cnn_model.add(MaxPooling2D(pool_size=(2, 2)))
cnn_model.add(Dropout(0.25))
cnn_model.add(Flatten())
cnn_model.add(Dense(512))
cnn_model.add(Activation('relu'))
cnn_model.add(Dropout(0.5))
cnn_model.add(Dense(num_classes))
cnn_model.add(Activation('softmax'))

这是结果

如何获得 320, 18496, 73856, 590336, 2052，谁能解释一下？

我是 Keras 的新手，想知道如何使用不同长度的（中断）时间序列训练 LTSM。例如，考虑从第 1 天到第 10 天的连续系列和从第 15 天到第 20 天的另一个连续系列。简单地将它们连接到单个系列可能会产生错误的结果。我看到基本上有两种选择可以使它们成形(batch_size, timesteps, output_features)：

1. 通过一些默认值 (0) 扩展较短的系列，即对于上面的示例，我们将有以下批次：

   d1, ..., d10
   d15, ..., d20, 0, 0, 0, 0, 0
   

   Run Code Online (Sandbox Code Playgroud)

2. 计算长度的 GCD，将系列切成小块，并使用有状态的 LSTM，即：

   d1, ..., d5
   d6, ..., d10
   reset_state
   d15, ..., d20
   

   Run Code Online (Sandbox Code Playgroud)

还有其他/更好的解决方案吗？用完整序列训练无状态 LSTM 是否等同于用片段训练有状态 LSTM？

基于这篇文章。我需要一些基本的实施帮助。下面你会看到我使用 Dropout 层的模型。使用 noise_shape 参数时，碰巧最后一批不适合批量大小，从而产生错误（请参阅其他帖子）。

原型号：

def LSTM_model(X_train,Y_train,dropout,hidden_units,MaskWert,batchsize):
   model = Sequential()
   model.add(Masking(mask_value=MaskWert, input_shape=(X_train.shape[1],X_train.shape[2]) ))
   model.add(Dropout(dropout, noise_shape=(batchsize, 1, X_train.shape[2]) ))   
   model.add(Dense(hidden_units, activation='sigmoid', kernel_constraint=max_norm(max_value=4.) ))   
   model.add(LSTM(hidden_units, return_sequences=True, dropout=dropout, recurrent_dropout=dropout))  

现在 Alexandre Passos 建议使用tf.shape获取运行时批量大小。我试图以不同的方式将运行时批量大小的想法实现到 Keras 中，但从未奏效。

   import Keras.backend as K

   def backend_shape(x):
       return K.shape(x)

   def LSTM_model(X_train,Y_train,dropout,hidden_units,MaskWert,batchsize):    
       batchsize=backend_shape(X_train)
       model = Sequential()
       ...
       model.add(Dropout(dropout, noise_shape=(batchsize[0], 1, X_train.shape[2]) )) 
       ...  

但这只是给了我输入张量形状，而不是运行时输入张量形状。

我也尝试使用 Lambda 层

def output_of_lambda(input_shape):
   return (input_shape)

def LSTM_model_2(X_train,Y_train,dropout,hidden_units,MaskWert,batchsize):       
   model = Sequential()
   model.add(Lambda(output_of_lambda, outputshape=output_of_lambda))
   ...
   model.add(Dropout(dropout, noise_shape=(outputshape[0], 1, X_train.shape[2]) …

我有一个像这样的numpy数组：

[[0. 1. 1. ... 0. 0. 1.]
 [0. 0. 0. ... 0. 0. 1.]
 [0. 0. 1. ... 0. 0. 0.]
 ...
 [0. 0. 0. ... 0. 0. 1.]
 [0. 0. 0. ... 0. 0. 1.]
 [0. 0. 0. ... 1. 0. 1.]]

我这样转换它以减少内存需求：

x_val = x_val.astype(np.int)

结果是：

[[0 1 1 ... 0 0 1]
 [0 0 0 ... 0 0 1]
 [0 0 1 ... 0 0 0]
 ...
 [0 0 0 ... 0 0 1]
 [0 0 …

我正在用 Keras 编写一个序列到序列模型。由于某种原因，当我尝试在下面的函数中定义模型时：

def define_GRU_models(encoder_input_dim,
              output_dim,
              activation,
              n_units):
# define training encoder #
###########################
# layer 1
encoder_inputs = Input(shape=encoder_input_dim)
l1_encoder = GRU(n_units,
                      name='l1_encoder',
                      return_sequences=True,
                      return_state=True)
l1_encoder_outputs, l1_encoder_state = l1_encoder(encoder_inputs)

# layer 2
l2_encoder = GRU(n_units,
                      name='l2_encoder',
                      return_state=True)
l2_encoder_outputs, l2_encoder_state = l2_encoder(l1_encoder_outputs)

# define training decoder #
###########################

# layer 1
decoder_inputs = Input(shape=(None, output_dim))
l1_decoder_gru = GRU(int(n_units/2),
                          name='l1_decoder_gru',
                          return_sequences=True,
                          return_state=False)
l1_decoder_outputs, _ = l1_decoder_gru(decoder_inputs)

# layer 2
l2_decoder_gru = GRU(n_units,
                          name='l2_decoder_gru',
                          return_sequences=True,
                          return_state=False)
l2_decoder_outputs, _ = l2_decoder_gru(l1_decoder_outputs, initial_state=l1_encoder_state)

# …

我已经在 Keras 中为一些时间序列训练了以下模型：

    input_layer = Input(batch_shape=(56, 3864))
    first_layer = Dense(24, input_dim=28, activation='relu',
                        activity_regularizer=None,
                        kernel_regularizer=None)(input_layer)
    first_layer = Dropout(0.3)(first_layer)
    second_layer = Dense(12, activation='relu')(first_layer)
    second_layer = Dropout(0.3)(second_layer)
    out = Dense(56)(second_layer)
    model_1 = Model(input_layer, out)

然后我定义了一个新模型，其中包含经过训练的层，model_1并添加了具有不同速率 的 dropout 层drp：

    input_2 = Input(batch_shape=(56, 3864))
    first_dense_layer = model_1.layers[1](input_2)
    first_dropout_layer = model_1.layers[2](first_dense_layer)
    new_dropout = Dropout(drp)(first_dropout_layer)
    snd_dense_layer = model_1.layers[3](new_dropout)
    snd_dropout_layer = model_1.layers[4](snd_dense_layer)
    new_dropout_2 = Dropout(drp)(snd_dropout_layer)
    output = model_1.layers[5](new_dropout_2)
    model_2 = Model(input_2, output)

然后我得到这两个模型的预测结果如下：

result_1 = model_1.predict(test_data, batch_size=56)
result_2 = model_2.predict(test_data, batch_size=56)

我期望得到完全不同的结果，因为第二个模型有新的 dropout 层并且这两个模型不同（IMO），但事实并非如此。两者都产生相同的结果。为什么会这样？