Как справиться с сильным переобучением в сверточной нейронной сети UNet с кодировщиком/декодировщиком в задаче, очень похожей на перевод изображений?

Я пытаюсь подогнать CNN UNet под задачу, очень похожую на перевод изображений. Входные данные сети – это бинарная матрица размером (64,256), а выход – размером (64,32). Колонки представляют собой статус канала связи, где каждое значение в колонне – это статус подсистемы. 1 означает, что подсистема занята, а 0 – что подсистема свободна. Горизонтальная ось представляет поток времени. Таким образом, первая колонка – это статус канала в 1-й временной интервал, вторая колонка – статус во 2-й временной интервал и так далее. Задача состоит в том, чтобы предсказать статус канала в следующих 32 временных интервалах, исходя из предыдущих 256 временных интервалов, которые я рассматривал как перевод изображений.
Точность на обучающих данных составляет около 90%, в то время как точность на тестовых данных около 50%. Под точностью я здесь имею в виду средний процент правильных значений в каждом изображении. Также во время обучения значение потерь на валидации увеличивается, в то время как потери уменьшаются, что является явным признаком переобучения. Я пробовал большинство техник регуляризации и также пытался снизить мощность модели, но это лишь снижает ошибку обучения, не улучшая ошибку обобщения. Есть ли какие-либо советы или идеи? Я включил в следующую часть кривую обучения для обучения на 1000 образцах, реализацию сети и образцы из обучающего и тестового наборов.

Кривые обучения на 1000 образцах

3 образца из обучающего набора

3 образца из тестового набора

Вот реализация сети:

def define_encoder_block(layer_in, n_filters, batchnorm=True):
    # инициализация весов
    init = RandomNormal(stddev=0.02)
    # добавление слоя downsampling
    g = Conv2D(n_filters, (4,4), strides=(2,2), padding='same',
               kernel_initializer=init)(layer_in)
    # условное добавление batch normalization
    if batchnorm:
        g = BatchNormalization()(g, training=True)
    # активация leaky relu
    g = LeakyReLU(alpha=0.2)(g)
    return g
 
# определение блока декодера
def decoder_block(layer_in, skip_in, n_filters, filter_strides, dropout=True, skip=True):
  # инициализация весов
  init = RandomNormal(stddev=0.02)
    # добавление слоя upsampling
  g = Conv2DTranspose(n_filters, (4,4), strides=filter_strides, padding='same', 
                         kernel_initializer=init)(layer_in)
    # добавление batch normalization
  g = BatchNormalization()(g, training=True)
    # условное добавление dropout
  if dropout:
    g = Dropout(0.5)(g, training=True)
  if skip:
    g = Concatenate()([g, skip_in])
    # активация relu
  g = Activation('relu')(g)
  return g
 
# определение отдельно стоящей модели генератора
def define_generator(image_shape=(64,256,1)):
    # инициализация весов
    init = RandomNormal(stddev=0.02)
    # вход изображения
    in_image = Input(shape=image_shape)
    e1 = define_encoder_block(in_image, 64, batchnorm=False)
    e2 = define_encoder_block(e1, 128)
    e3 = define_encoder_block(e2, 256)
    e4 = define_encoder_block(e3, 512)
    e5 = define_encoder_block(e4, 512)
    e6 = define_encoder_block(e5, 512)
    e7 = define_encoder_block(e6, 512)
    # узкое место, без batch norm и relu
    b = Conv2D(512, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(e7)
    b = Activation('relu')(b)
    # модель декодера
    d1 = decoder_block(b, e7, 512, (1,2))
    d2 = decoder_block(d1, e6, 512, (1,2))
    d3 = decoder_block(d2, e5, 512, (2,2))
    d4 = decoder_block(d3, e4, 512, (2,2), dropout=False)
    d5 = decoder_block(d4, e3, 256, (2,2), dropout=False)
    d6 = decoder_block(d5, e2, 128, (2,1), dropout=False, skip=False)
    d7 = decoder_block(d6, e1, 64, (2,1), dropout=False, skip=False)
    # выход
    g = Conv2DTranspose(1, (4,4), strides=(2,1), padding='same', kernel_initializer=init)(d7)
    out_image = Activation('sigmoid')(g)
    # определение модели
    model = Model(in_image, out_image)
    return model

Я не уверен, что то, что вы видите выше, на самом деле является проблемой переобучения. То, что я вижу, это то, что кривая валидации на самом деле вообще не снижается, трудно сказать, что это переобучение. Обычно в случае переобучения мы видим, что значение потерь на валидации снижается, но в какой-то момент оно начинает снова расти.

Все это указывает на то, что либо валидационный набор не похож на обучающий набор, либо у модели нет мощности для того, чтобы действительно изучить паттерны, но она способна их запомнить (это на самом деле проблема тонкого смещения).

Одна проблема, которую я также вижу в вашей реализации, это то, что вы сначала применяете BatchNorm, а затем применяете dropout. Dropout применяется после активации, поэтому переместите это. Это может вызывать проблемы.

Для начала, что произойдет, если регуляризацию полностью снизить? Например, если вы уберете dropout и термины batchnorm?