1

我正在尝试使 UNet CNN 适应与图像到图像转换非常相似的任务。网络的输入是大小为 (64,256) 的二进制矩阵，输出大小为 (64,32)。列表示通信信道的状态，其中列中的每个条目是子信道的状态。1表示子信道被占用，0表示子信道空闲。横轴代表时间的流动。因此，第一列是时隙 1 的通道状态，第二列是时隙的状态，依此类推。任务是在给定前 256 个时隙的情况下预测接下来 32 个时隙中的通道状态，我将其视为图像到图像的转换。训练数据的准确率约为 90%，而测试数据的准确率约为 50%。通过这里的准确性，我的意思是每张图片中正确条目的平均百分比。此外，在训练时，验证损失增加而损失减少，这是过度拟合的明显迹象。我已经尝试了大多数正则化技术，也尝试过降低模型的容量，但这只会减少训练误差，而不会改善泛化误差。有什么建议或想法吗？我在下一部分中包含了 1000 个样本的训练学习曲线、网络的实现以及来自训练和测试集的样本。我已经尝试了大多数正则化技术，也尝试过降低模型的容量，但这只会减少训练误差，而不会改善泛化误差。有什么建议或想法吗？我在下一部分中包含了 1000 个样本的训练学习曲线、网络的实现以及来自训练和测试集的样本。我已经尝试了大多数正则化技术，也尝试过降低模型的容量，但这只会减少训练误差，而不会改善泛化误差。有什么建议或想法吗？我在下一部分中包含了 1000 个样本的训练学习曲线、网络的实现以及来自训练和测试集的样本。

1000 个样本训练的学习曲线

3 来自训练集的样本

来自测试集的 3 个样本

下面是网络的实现：

def define_encoder_block(layer_in, n_filters, batchnorm=True):
    # weight initialization
    init = RandomNormal(stddev=0.02)
    # add downsampling layer
    g = Conv2D(n_filters, (4,4), strides=(2,2), padding='same',
               kernel_initializer=init)(layer_in)
    # conditionally add batch normalization
    if batchnorm:
        g = BatchNormalization()(g, training=True)
    # leaky relu activation
    g = LeakyReLU(alpha=0.2)(g)
    return g
 
# define a decoder block
def decoder_block(layer_in, skip_in, n_filters, filter_strides, dropout=True, skip=True):
  # weight initialization
  init = RandomNormal(stddev=0.02)
    # add upsampling layer
  g = Conv2DTranspose(n_filters, (4,4), strides=filter_strides, padding='same', 
                         kernel_initializer=init)(layer_in)
    # add batch normalization
  g = BatchNormalization()(g, training=True)
    # conditionally add dropout
  if dropout:
    g = Dropout(0.5)(g, training=True)
  if skip:
    g = Concatenate()([g, skip_in])
    # relu activation
  g = Activation('relu')(g)
  return g
 
# define the standalone generator model
def define_generator(image_shape=(64,256,1)):
    # weight initialization
    init = RandomNormal(stddev=0.02)
    # image input
    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)
    # bottleneck, no batch norm and relu
    b = Conv2D(512, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(e7)
    b = Activation('relu')(b)
    # decoder model
    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)
    # output
    g = Conv2DTranspose(1, (4,4), strides=(2,1), padding='same', kernel_initializer=init)(d7)
    out_image = Activation('sigmoid')(g)
    # define model
    model = Model(in_image, out_image)
    return model
4

0 回答 0