Модель Keras не может уменьшить потери

Question

Я предлагаю пример, в котором модель tf.keras не может учиться на очень простых данных. Я использую tensorflow-gpu==2.0.0, keras==2.3.0 и Python 3.7. В конце своего поста я даю код Python для воспроизведения проблемы, с которой я столкнулся.

---

1. Данные

ПримерыNumpy массивы формы (6, 16, 16, 16, 3). Чтобы упростить задачу, я рассматриваю только массивы, заполненные единицами и нулями. Массивам с 1 присваивается метка 1, а массивам с 0 - метка 0. Я могу сгенерировать несколько выборок (в следующем примере n_samples = 240) с помощью этого кода:

def generate_fake_data():
    for j in range(1, 240 + 1):
        if j < 120:
            yield np.ones((6, 16, 16, 16, 3)), np.array([0., 1.])
        else:
            yield np.zeros((6, 16, 16, 16, 3)), np.array([1., 0.])

Для ввода этогоДанные в модели tf.keras, я создаю экземпляр tf.data.Dataset, используя код ниже. По существу, это создаст перемешанные партии BATCH_SIZE = 12 образцов.

def make_tfdataset(for_training=True):
    dataset = tf.data.Dataset.from_generator(generator=lambda: generate_fake_data(),
                                             output_types=(tf.float32,
                                                           tf.float32),
                                             output_shapes=(tf.TensorShape([6, 16, 16, 16, 3]),
                                                            tf.TensorShape([2])))
    dataset = dataset.repeat()
    if for_training:
        dataset = dataset.shuffle(buffer_size=1000)
    dataset = dataset.batch(BATCH_SIZE)
    dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)
    return dataset

Модель

Я предлагаю следующую модель для классификации моих образцов:

def create_model(in_shape=(6, 16, 16, 16, 3)):

    input_layer = Input(shape=in_shape)

    reshaped_input = Lambda(lambda x: K.reshape(x, (-1, *in_shape[1:])))(input_layer)

    conv3d_layer = Conv3D(filters=64, kernel_size=8, strides=(2, 2, 2), padding='same')(reshaped_input)

    relu_layer_1 = ReLU()(conv3d_layer)

    pooling_layer = GlobalAveragePooling3D()(relu_layer_1)

    reshape_layer_1 = Lambda(lambda x: K.reshape(x, (-1, in_shape[0] * 64)))(pooling_layer)

    expand_dims_layer = Lambda(lambda x: K.expand_dims(x, 1))(reshape_layer_1)

    conv1d_layer = Conv1D(filters=1, kernel_size=1)(expand_dims_layer)

    relu_layer_2 = ReLU()(conv1d_layer)

    reshape_layer_2 = Lambda(lambda x: K.squeeze(x, 1))(relu_layer_2)

    out = Dense(units=2, activation='softmax')(reshape_layer_2)

    return Model(inputs=[input_layer], outputs=[out])

Модель оптимизирована с использованием Адама (с параметрами по умолчанию) ис потерей binary_crossentropy:

clf_model = create_model()
clf_model.compile(optimizer=Adam(),
                  loss='categorical_crossentropy',
                  metrics=['accuracy', 'categorical_crossentropy'])

Выход clf_model.summary():

Model: "model"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         [(None, 6, 16, 16, 16, 3) 0         
_________________________________________________________________
lambda (Lambda)              (None, 16, 16, 16, 3)     0         
_________________________________________________________________
conv3d (Conv3D)              (None, 8, 8, 8, 64)       98368     
_________________________________________________________________
re_lu (ReLU)                 (None, 8, 8, 8, 64)       0         
_________________________________________________________________
global_average_pooling3d (Gl (None, 64)                0         
_________________________________________________________________
lambda_1 (Lambda)            (None, 384)               0         
_________________________________________________________________
lambda_2 (Lambda)            (None, 1, 384)            0         
_________________________________________________________________
conv1d (Conv1D)              (None, 1, 1)              385       
_________________________________________________________________
re_lu_1 (ReLU)               (None, 1, 1)              0         
_________________________________________________________________
lambda_3 (Lambda)            (None, 1)                 0         
_________________________________________________________________
dense (Dense)                (None, 2)                 4         
=================================================================
Total params: 98,757
Trainable params: 98,757
Non-trainable params: 0

Обучение

Модель обучается для 500 эпох следующим образом:

train_ds = make_tfdataset(for_training=True)

history = clf_model.fit(train_ds,
                        epochs=500,
                        steps_per_epoch=ceil(240 / BATCH_SIZE),
                        verbose=1)

Проблема!

В течение 500 эпох потеря модели остается около 0,69 и никогда не опускается ниже 0,69. Это также верно, если я устанавливаю скорость обучения 1e-2 вместо 1e-3. Данные очень просты (только 0 и 1). Наивно, я бы ожидал, что модель будет иметь лучшую точность, чем 0,6. На самом деле, я ожидаю, что он быстро достигнет 100% точности. Что я делаю не так?

Полный код ...

import numpy as np
import tensorflow as tf
import tensorflow.keras.backend as K
from math import ceil
from tensorflow.keras.layers import Input, Dense, Lambda, Conv1D, GlobalAveragePooling3D, Conv3D, ReLU
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam

BATCH_SIZE = 12


def generate_fake_data():
    for j in range(1, 240 + 1):
        if j < 120:
            yield np.ones((6, 16, 16, 16, 3)), np.array([0., 1.])
        else:
            yield np.zeros((6, 16, 16, 16, 3)), np.array([1., 0.])


def make_tfdataset(for_training=True):
    dataset = tf.data.Dataset.from_generator(generator=lambda: generate_fake_data(),
                                             output_types=(tf.float32,
                                                           tf.float32),
                                             output_shapes=(tf.TensorShape([6, 16, 16, 16, 3]),
                                                            tf.TensorShape([2])))
    dataset = dataset.repeat()
    if for_training:
        dataset = dataset.shuffle(buffer_size=1000)
    dataset = dataset.batch(BATCH_SIZE)
    dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)
    return dataset


def create_model(in_shape=(6, 16, 16, 16, 3)):

    input_layer = Input(shape=in_shape)

    reshaped_input = Lambda(lambda x: K.reshape(x, (-1, *in_shape[1:])))(input_layer)

    conv3d_layer = Conv3D(filters=64, kernel_size=8, strides=(2, 2, 2), padding='same')(reshaped_input)

    relu_layer_1 = ReLU()(conv3d_layer)

    pooling_layer = GlobalAveragePooling3D()(relu_layer_1)

    reshape_layer_1 = Lambda(lambda x: K.reshape(x, (-1, in_shape[0] * 64)))(pooling_layer)

    expand_dims_layer = Lambda(lambda x: K.expand_dims(x, 1))(reshape_layer_1)

    conv1d_layer = Conv1D(filters=1, kernel_size=1)(expand_dims_layer)

    relu_layer_2 = ReLU()(conv1d_layer)

    reshape_layer_2 = Lambda(lambda x: K.squeeze(x, 1))(relu_layer_2)

    out = Dense(units=2, activation='softmax')(reshape_layer_2)

    return Model(inputs=[input_layer], outputs=[out])


train_ds = make_tfdataset(for_training=True)
clf_model = create_model(in_shape=(6, 16, 16, 16, 3))
clf_model.summary()
clf_model.compile(optimizer=Adam(lr=1e-3),
                  loss='categorical_crossentropy',
                  metrics=['accuracy', 'categorical_crossentropy'])

history = clf_model.fit(train_ds,
                        epochs=500,
                        steps_per_epoch=ceil(240 / BATCH_SIZE),
                        verbose=1)

Answer 1

В вашем коде есть одна критическая проблема: перемешивание размерности . Единственное измерение, которое вы должны никогда касаться, - это измерение партии - поскольку оно, по определению, содержит независимых выборок ваших данных. При первом изменении формы вы смешиваете размеры элементов с размером пакета:

Tensor("input_1:0", shape=(12, 6, 16, 16, 16, 3), dtype=float32)
Tensor("lambda/Reshape:0", shape=(72, 16, 16, 16, 3), dtype=float32)

Это похоже на подачу 72 независимых образцов формы (16,16,16,3). Другие слои сталкиваются с аналогичными проблемами.

---

РЕШЕНИЕ :

• Вместо того, чтобы изменять каждый шаг пути (для которого вы должны использовать Reshape)Придайте форму существующим слоям Conv и пула, чтобы все работало напрямую.
• Помимо входного и выходного слоев, каждый слой лучше называть чем-то коротким и простым - четкость не теряется, поскольку каждая строка четко определяется по имени слоя
• GlobalAveragePooling предназначенобыть окончательным слоем, так как он сворачивает элементы размеров - в вашем случае, вот так: (12,16,16,16,3) --> (12,3);Conv впоследствии служит небольшим целям
• Как указано выше, я заменил Conv1D на Conv3D
• Если вы не используете переменные размеры партий, всегда переходите на batch_shape= против shape=,как вы можете проверить размеры слоя в полном объеме (очень полезно)
• Ваше истинное batch_size здесь 6, исходя из вашего комментария ответ
• kernel_size=1 и (особенно) filters=1 являетсяочень слабая свертка, я заменил ее соответственно - вы можете вернуться, если хотите
• Если у вас есть только 2 класса в предполагаемом приложении, я советую использовать Dense(1, 'sigmoid') с binary_crossentropy потерей

В качестве последнего примечания: вы можете выбросить все вышеперечисленное , за исключением , за советы по перетасовке размерности, и при этом получить отличную производительность поезда;это был корень проблемы.

def create_model(batch_size, input_shape):

    ipt = Input(batch_shape=(batch_size, *input_shape))
    x   = Conv3D(filters=64, kernel_size=8, strides=(2, 2, 2),
                             activation='relu', padding='same')(ipt)
    x   = Conv3D(filters=8,  kernel_size=4, strides=(2, 2, 2),
                             activation='relu', padding='same')(x)
    x   = GlobalAveragePooling3D()(x)
    out = Dense(units=2, activation='softmax')(x)

    return Model(inputs=ipt, outputs=out)

BATCH_SIZE = 6
INPUT_SHAPE = (16, 16, 16, 3)
BATCH_SHAPE = (BATCH_SIZE, *INPUT_SHAPE)

def generate_fake_data():
    for j in range(1, 240 + 1):
        if j < 120:
            yield np.ones(INPUT_SHAPE), np.array([0., 1.])
        else:
            yield np.zeros(INPUT_SHAPE), np.array([1., 0.])


def make_tfdataset(for_training=True):
    dataset = tf.data.Dataset.from_generator(generator=lambda: generate_fake_data(),
                                 output_types=(tf.float32,
                                               tf.float32),
                                 output_shapes=(tf.TensorShape(INPUT_SHAPE),
                                                tf.TensorShape([2])))
    dataset = dataset.repeat()
    if for_training:
        dataset = dataset.shuffle(buffer_size=1000)
    dataset = dataset.batch(BATCH_SIZE)
    dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)
    return dataset

---

РЕЗУЛЬТАТЫ :

Epoch 28/500
40/40 [==============================] - 0s 3ms/step - loss: 0.0808 - acc: 1.0000

Answer 2

Поскольку ваши метки могут быть 0 или 1, я бы рекомендовал изменить функцию активации на softmax и количество выходных нейронов на 2. Теперь последний слой (выходной) будет выглядеть так:

out = Dense(units=2, activation='softmax')(reshaped_conv_features)

Я сталкивался с той же проблемой и раньше и понял, что, поскольку вероятности быть равными 1 или 0 связаны в том смысле, что это не проблема классификации с несколькими метками, Softmax является лучшим вариантом. Сигмоид назначает вероятности независимо от других возможных выходных меток.