如何解决由派对 keras 培训

我需要你的帮助。我的项目一般是关于开发用于定量巩膜中铁蛋白的图像分析算法。我的代码允许将分段和回归与顺序模型混合使用，并且输出是唯一的（即训练是同时完成的）。我希望它是每个部分。即，它进行分段训练，记录结果并开始回归。

分割的输入是图像加上它们的掩码；
回归的输入是图像加上铁蛋白的值。

分割和回归层被重命名

因为当使用主干时，其中一些共享相同的名称

def load_model(segmentation_model,regression_model,width,height,num_classes = 1):

# Rename segmentation model layers and weights
for layer in segmentation_model.layers:
    rename(segmentation_model,layer,layer.name + '_seg')
#for i,w in enumerate(segmentation_model.weights):
#    split_name = w.name.split('/')
#    new_name = split_name[0] + '_seg' + '/' + split_name[1]
#    segmentation_model.weights[i]._handle_name = new_name

# Rename regression model layers
for layer in regression_model.layers:
    rename(regression_model,layer.name + '_reg')
#for i,w in enumerate(regression_model.weights):
#    split_name = w.name.split('/')
#    new_name = split_name[0] + '_reg' + '/' + split_name[1]
#    regression_model.weights[i]._handle_name = new_name

image = layers.Input(shape=(width,3),name="img")

mask_image = segmentation_model(image)

if num_classes==1:
    mask_image_categorical = K.cast(K.squeeze(mask_image,axis=3) + 0.5,dtype='int32') # Threshold at 0.5
else:
    mask_image_categorical = K.argmax(mask_image,axis=3)

masked_layer = mylayers.CustomMasking(mask_value=0)
masked_image = masked_layer.call([image,mask_image_categorical])

value = regression_model(masked_image)

m = models.Model(inputs=image,outputs=[mask_image,value])
#m = models.Model(inputs=image,value,mask_image_categorical,masked_image])

#for i,w in enumerate(m.weights): print(i,w.name)

m.summary()

return m

def make_train（模型、regression_loss_weight、regression_loss_weight_max、train_generator、epochs、val_dataset、validation_steps、weights_path、logger_path、num_classes、focal、enable_plot、init_mode = False）：

optimizer = optimizers.Adam(lr=0.001,beta_1=0.9,beta_2=0.999,epsilon=1e-08)

regression_loss_weight_variable = K.variable(regression_loss_weight,name='regression_loss_weight')
mse = losses.MeanSquaredError()
weighted_mse = weighted_loss(mse,regression_loss_weight_variable)
weighted_mse.trainable = False

if focal:
    if num_classes == 1:
        bce = mylosses.binary_focal_loss
        weighted_bce = weighted_loss(bce,1 - regression_loss_weight_variable)
        loss = { 'model_segmentation' : weighted_bce,'model_regression' : weighted_mse} 
    else:
        fce = mylosses.categorical_focal_loss
        weighted_fce = weighted_loss(fce,1 - regression_loss_weight_variable)
        loss = { 'model_segmentation' : weighted_fce,'model_regression' : weighted_mse}
else:
    if num_classes == 1:
        bce = losses.BinaryCrossentropy(from_logits=True)
        weighted_bce = weighted_loss(bce,'model_regression' : weighted_mse}
    else:
        cce = losses.CategoricalCrossentropy()
        weighted_cce = weighted_loss(cce,1 - regression_loss_weight_variable)
        loss = { 'model_segmentation' : weighted_cce,'model_regression' : weighted_mse} 

metric = metrics.BinaryAccuracy() if num_classes == 1 else metrics.CategoricalAccuracy()
metric_array_segmentation = [metric,mymetrics.IoU_score_threshold,mymetrics.f1_score_threshold]
metric_array_regression = [metrics.RootMeanSquaredError(),metrics.MeanAbsoluteError(),metrics.MeanAbsolutePercentageError()]
metric_dict = { 'model_segmentation' : metric_array_segmentation,'model_regression' : metric_array_regression}

loss_weights = [1.0,1.0] # Weight for regression is taken into account in weighted_mse loss function

model.compile(optimizer,loss,metric_dict,loss_weights)

loss_weight_callback = LossWeightsCallback(regression_loss_weight_variable,regression_loss_weight,regression_loss_weight_max,epochs,'val_model_segmentation_f1-score')
freezing_callback = SegmentationModelFreezingCallback(model,'val_model_segmentation_f1-score',0.95)

checkpoint = ModelCheckpoint(weights_path,monitor='val_model_regression_root_mean_squared_error',mode='min',verbose=1,save_best_only=True)
csv_logger = CSVLogger(logger_path,append=True,separator=';')
lr_reducer = ReduceLROnPlateau(monitor='val_model_regression_root_mean_squared_error',factor=0.2,patience=10,min_lr=10e-7,min_delta=0.01,verbose=1)
earlystopping = EarlyStopping(monitor='val_model_regression_root_mean_squared_error',patience=20,restore_best_weights=True)
callbacks_list = [loss_weight_callback,freezing_callback,checkpoint,csv_logger,lr_reducer,earlystopping]

# Test custom masking layer or global model
#instance = train_generator[0]
#imgs = np.squeeze(instance[0],axis=3) if instance[0].shape[3] == 1 else instance[0]
#imsave("unmasked_img.png",imgs[0])
#masks = np.squeeze(instance[1]['model_segmentation'],axis=3) if instance[1]['model_segmentation'].shape[3] == 1 else instance[1]['model_segmentation']
#imsave("mask.png",masks[0] * 255)
#masked_layer = mylayers.CustomMasking(mask_value=0)
#masked_imgs = masked_layer.call([imgs,masks])
#img = K.eval(masked_imgs[0,:,:])
#imsave("masked_img.png",img)
#y = model(imgs)
#mask_image = y[0][0,:]
#value = K.eval(y[1][0])

if init_mode:
    instance = train_generator[0]
    model.train_on_batch(instance[0][:1],[instance[1]['model_segmentation'][:1],instance[1]['model_regression'][:1]] )
else:
    results = model.fit(train_generator,epochs=epochs,validation_data=val_dataset,validation_steps=validation_steps,callbacks=callbacks_list)
    model.save_weights(weights_path)

# display of metrics and loss vs epochs: metric names must match the metric functions
if enable_plot:
    if num_classes == 1:
        plot_history(results,metrics = ['model_segmentation_binary_accuracy','val_model_segmentation_binary_accuracy','model_regression_root_mean_squared_error','val_model_regression_root_mean_squared_error','model_regression_mean_absolute_error','val_model_regression_mean_absolute_error','model_regression_mean_absolute_percentage_error','val_model_regression_mean_absolute_percentage_error'],losses = ['model_segmentation_loss','model_regression_loss','val_model_segmentation_loss','val_model_regression_loss'])
    else:
        plot_history(results,metrics = ['model_segmentation_categorical_accuracy','val_model_segmentation_categorical_accuracy','model_segmentation_mean_io_u','val_model_segmentation_mean_io_u','model_segmentation_f1-score','val_model_regression_loss'])

在使用自定义模型和/或层时，定义模型和加载权重是不够的

模型还必须在最小集合上编译和训练才能初始化

def init_model(model,loss_weight,loss_weight_max,train_generator,weights_path,logger_path,num_classes,focus):

make_train(model,None,'',focal,False,True)
model.load_weights(weights_path)