Skip to main content
 首页 » 编程设计

python之值错误 : Unknown loss function:focal_loss_fixed when loading model with my custom loss function

2024年11月01日9jyk

我设计了自己的损失函数。但是,当尝试恢复到训练期间遇到的最佳模型时

model = load_model("lc_model.h5") 

我收到以下错误:

--------------------------------------------------------------------------- 
ValueError                                Traceback (most recent call last) 
<ipython-input-105-9d09ef163b0a> in <module> 
     23  
     24 # revert to the best model encountered during training 
---> 25 model = load_model("lc_model.h5") 
 
C:\ProgramData\Anaconda3\lib\site-packages\keras\engine\saving.py in load_model(filepath, custom_objects, compile) 
    417     f = h5dict(filepath, 'r') 
    418     try: 
--> 419         model = _deserialize_model(f, custom_objects, compile) 
    420     finally: 
    421         if opened_new_file: 
 
C:\ProgramData\Anaconda3\lib\site-packages\keras\engine\saving.py in _deserialize_model(f, custom_objects, compile) 
    310                       metrics=metrics, 
    311                       loss_weights=loss_weights, 
--> 312                       sample_weight_mode=sample_weight_mode) 
    313  
    314         # Set optimizer weights. 
 
C:\ProgramData\Anaconda3\lib\site-packages\keras\engine\training.py in compile(self, optimizer, loss, metrics, loss_weights, sample_weight_mode, weighted_metrics, target_tensors, **kwargs) 
    137             loss_functions = [losses.get(l) for l in loss] 
    138         else: 
--> 139             loss_function = losses.get(loss) 
    140             loss_functions = [loss_function for _ in range(len(self.outputs))] 
    141         self.loss_functions = loss_functions 
 
C:\ProgramData\Anaconda3\lib\site-packages\keras\losses.py in get(identifier) 
    131     if isinstance(identifier, six.string_types): 
    132         identifier = str(identifier) 
--> 133         return deserialize(identifier) 
    134     if isinstance(identifier, dict): 
    135         return deserialize(identifier) 
 
C:\ProgramData\Anaconda3\lib\site-packages\keras\losses.py in deserialize(name, custom_objects) 
    112                                     module_objects=globals(), 
    113                                     custom_objects=custom_objects, 
--> 114                                     printable_module_name='loss function') 
    115  
    116  
 
C:\ProgramData\Anaconda3\lib\site-packages\keras\utils\generic_utils.py in deserialize_keras_object(identifier, module_objects, custom_objects, printable_module_name) 
    163             if fn is None: 
    164                 raise ValueError('Unknown ' + printable_module_name + 
--> 165                                  ':' + function_name) 
    166         return fn 
    167     else: 
 
ValueError: Unknown loss function:focal_loss_fixed 

这是神经网络:

from keras.callbacks import ModelCheckpoint 
from keras.models import load_model 
 
model = create_model(x_train.shape[1], y_train.shape[1]) 
 
epochs =  35 
batch_sz = 64 
 
print("Beginning model training with batch size {} and {} epochs".format(batch_sz, epochs)) 
 
checkpoint = ModelCheckpoint("lc_model.h5", monitor='val_acc', verbose=0, save_best_only=True, mode='auto', period=1) 
 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.constraints import maxnorm 
 
def create_model(input_dim, output_dim): 
    print(output_dim) 
    # create model 
    model = Sequential() 
    # input layer 
    model.add(Dense(100, input_dim=input_dim, activation='relu', kernel_constraint=maxnorm(3))) 
    model.add(Dropout(0.2)) 
 
    # hidden layer 
    model.add(Dense(60, activation='relu', kernel_constraint=maxnorm(3))) 
    model.add(Dropout(0.2)) 
 
    # output layer 
    model.add(Dense(output_dim, activation='softmax')) 
 
    # Compile model 
    # model.compile(loss='categorical_crossentropy', loss_weights=None, optimizer='adam', metrics=['accuracy']) 
    model.compile(loss=focal_loss(alpha=1), loss_weights=None, optimizer='adam', metrics=['accuracy']) 
 
    return model 
 
# train the model 
history = model.fit(x_train.as_matrix(), 
                y_train.as_matrix(), 
                validation_split=0.2, 
                epochs=epochs,   
                batch_size=batch_sz, # Can I tweak the batch here to get evenly distributed data ? 
                verbose=2, 
                class_weight = weights, # class_weight tells the model to "pay more attention" to samples from an under-represented fraud class. 
                callbacks=[checkpoint]) 
 
# revert to the best model encountered during training 
model = load_model("lc_model.h5") 

这是我的损失函数:

import tensorflow as tf 
 
def focal_loss(gamma=2., alpha=4.): 
 
    gamma = float(gamma) 
    alpha = float(alpha) 
 
    def focal_loss_fixed(y_true, y_pred): 
        """Focal loss for multi-classification 
        FL(p_t)=-alpha(1-p_t)^{gamma}ln(p_t) 
        Notice: y_pred is probability after softmax 
        gradient is d(Fl)/d(p_t) not d(Fl)/d(x) as described in paper 
        d(Fl)/d(p_t) * [p_t(1-p_t)] = d(Fl)/d(x) 
        Focal Loss for Dense Object Detection 
        https://arxiv.org/abs/1708.02002 
 
        Arguments: 
            y_true {tensor} -- ground truth labels, shape of [batch_size, num_cls] 
            y_pred {tensor} -- model's output, shape of [batch_size, num_cls] 
 
        Keyword Arguments: 
            gamma {float} -- (default: {2.0}) 
            alpha {float} -- (default: {4.0}) 
 
        Returns: 
            [tensor] -- loss. 
        """ 
        epsilon = 1.e-9 
        y_true = tf.convert_to_tensor(y_true, tf.float32) 
        y_pred = tf.convert_to_tensor(y_pred, tf.float32) 
 
        model_out = tf.add(y_pred, epsilon) 
        ce = tf.multiply(y_true, -tf.log(model_out)) 
        weight = tf.multiply(y_true, tf.pow(tf.subtract(1., model_out), gamma)) 
        fl = tf.multiply(alpha, tf.multiply(weight, ce)) 
        reduced_fl = tf.reduce_max(fl, axis=1) 
        return tf.reduce_mean(reduced_fl) 
    return focal_loss_fixed 
 
# model.compile(loss=focal_loss(alpha=1), optimizer='nadam', metrics=['accuracy']) 
# model.fit(X_train, y_train, epochs=3, batch_size=1000) 

请您参考如下方法:

您必须加载 focal_loss_fixed 的 custom_objects,如下所示:

model = load_model("lc_model.h5", custom_objects={'focal_loss_fixed': focal_loss()}) 

但是,如果您只想对您的模型进行推理而不进一步优化或训练您的模型,您可以像这样忽略损失函数:

model = load_model("lc_model.h5", compile=False)