好了，我已经发现了概念上的错误，我将input_image input的输入图像提供给损失函数。但实际上这些应该是y_true标签。一个可能的解决方案是向网络提供额外的输入“ip_labels”，这是感知损失@ tf. functions所需的y_true。下面是一个工作解决方案，它被编写为带有虚拟损失层的自定义损失函数：

def MyLoss2(input_image, reconstruct_image, weight_ip):
@tf.function
def perceptual_loss(input_image, reconstruct_image):
    
    input_image       = clip_0_1(input_image)
    reconstruct_image = clip_0_1(reconstruct_image)
    weights = clip_0_1(weight_ip)

    h1_list = LossModel(input_image)
    h2_list = LossModel(reconstruct_image)

    rc_loss = 0.0

    for h1, h2, weight in zip(h1_list, h2_list, selected_layer_weights):
           h1 = K.batch_flatten(h1)
           h2 = K.batch_flatten(h2)
  
           rc_loss = rc_loss + weight * K.sum(K.square(h1 - h2), axis=-1)
           
    pixel_loss = K.sum(K.square(K.batch_flatten(weights)*K.batch_flatten(input_image) - K.batch_flatten(weights)*K.batch_flatten(reconstruct_image)),axis=1)
    return rc_loss + pixel_loss
return perceptual_loss(input_image, reconstruct_image)

损耗层实现如下：

class DummyLayer(Layer):

def __init__(self, is_training):
super().__init__(is_training)
self.is_training=is_training

def get_config(self):
  config = super().get_config()
  config.update({
      "is_training": self.is_training,
  })
  return config

def call(self, inputs,is_training):

ip,classify,weight_ip = tf.unstack(inputs,axis=-1)

self.add_loss(MyLoss2(ip, classify, weight_ip))

return inputs

合成UNET具有附加输入ip_labels：

def synthesis_unet_weights(pretrained_weights=None, input_shape=(SIZE_s, SIZE_s, 3), num_classes=1, is_training=True):

ip        = Input(shape=input_shape)

ip_labels = Input(shape=input_shape)

weight_ip = Input(shape=input_shape[:2] + (num_classes,))

down1 = Conv2D(64, (3,3),padding='same', activation=LeakyReLU(alpha=0.3), kernel_initializer=initializer)(ip)

UNET encoder with skips

center = Conv2D(1024, (3,3),padding='same', activation='relu', kernel_initializer=initializer)(pool4)
center = Conv2D(1024, (3,3),padding='same', activation='relu', kernel_initializer=initializer)(center)

UNET decoder with the last layer up1

classify = Conv2D(num_classes, (1,1), activation='sigmoid')(up1)

if is_training:
            
    data=tf.stack([ip_labels,(tf.concat((classify,classify,classify),axis=3)),
                   (tf.concat((weight_ip,weight_ip,weight_ip),axis=3))],axis=-1)
    
    
    classify = DummyLayer(is_training=True)(data, is_training=True)
    
    inp, classify, weight_inp=tf.unstack(classify,axis=-1)
    
    model=Model(inputs=[ip, ip_labels, weight_ip], outputs=[classify])

    opt = tf.keras.optimizers.Adam(learning_rate=1e-3,clipnorm=1.0)
    
    model.compile(optimizer=opt, metrics=['mse','mae'])      
    
    return model
 
else:
    
    data=tf.stack([ip,(tf.concat((classify,classify,classify),axis=3)), ip],axis=-1)
    
    classify=DummyLayer(is_training=False)(data, is_training=False)
    inp, classify, weight_inp=tf.unstack(classify,axis=-1)

    model = Model(inputs=[ip], outputs=[classify])

    opt = tf.keras.optimizers.Adam(learning_rate=1e-3,clipnorm=1.0)
    model.compile(optimizer=opt)
    
    return model
    
return model

培训：

model=synthesis_unet_weights()
model.fit([input_images, labels, weight_maps], labels)

我知道堆叠和非堆叠Tensor的代码不是特别优雅，但它是工作的。