Keras 我使用的是一个自定义损失函数（yolo v2损失函数），但是我得到的损失是nan

以下代码的灵感来自回购Keras-Yolo-v2，我正面临代码方面的问题，我正试图了解损失的可能原因。 我已经使用了像clipnorm这样的技术，但那没有帮助。 这是yolo v2的自定义损失，我正在尝试在Tensorflow 2.0上实现它。 我对此有一些想法，在某个地方，值变为0，这将导致损失为Nan，但我可以准确地找出可能发生这种情况的地方。任何帮助都将不胜感激

提前谢谢

class YoloLossKeras:

    def __init__(self, priors):
        self.priors = priors

    def loss(self, y_true, y_pred):

        n_cells = y_pred.get_shape().as_list()[1]
        y_true = tf.reshape(y_true, tf.shape(y_pred), name='y_true')
        y_pred = tf.identity(y_pred, name='y_pred')

        #### PROCESS PREDICTIONS ####
        # get x-y coords (for now they are with respect to cell)
        predicted_xy = tf.nn.sigmoid(y_pred[..., :2])

        # convert xy coords to be with respect to image
        cell_inds = tf.range(n_cells, dtype=tf.float32)
        predicted_xy = tf.stack((
            predicted_xy[..., 0] + tf.reshape(cell_inds, [1, -1, 1]), 
            predicted_xy[..., 1] + tf.reshape(cell_inds, [-1, 1, 1])
        ), axis=-1)

        # compute bb width and height
        predicted_wh = self.priors * tf.exp(y_pred[..., 2:4])

        # compute predicted bb center and width
        predicted_min = predicted_xy - predicted_wh / 2
        predicted_max = predicted_xy + predicted_wh / 2

        predicted_objectedness = tf.nn.sigmoid(y_pred[..., 4])
        predicted_logits = tf.nn.softmax(y_pred[..., 5:])


        #### PROCESS TRUE ####
        true_xy = y_true[..., :2]
        true_wh = y_true[..., 2:4]
        true_logits = y_true[..., 5:]

        true_min = true_xy - true_wh / 2
        true_max = true_xy + true_wh / 2

        #### compute iou between ground truth and predicted (used for objectedness) ####
        intersect_mins  = tf.maximum(predicted_min, true_min)
        intersect_maxes = tf.minimum(predicted_max, true_max)
        intersect_wh    = tf.maximum(intersect_maxes - intersect_mins, 0.)
        intersect_areas = intersect_wh[..., 0] * intersect_wh[..., 1]

        true_areas = true_wh[..., 0] * true_wh[..., 1]
        pred_areas = predicted_wh[..., 0] * predicted_wh[..., 1]

        union_areas = pred_areas + true_areas - intersect_areas
        iou_scores  = intersect_areas / union_areas

        #### Compute loss terms ####
        responsibility_selector = y_true[..., 4]

        xy_diff = tf.square(true_xy - predicted_xy) * responsibility_selector[..., None]
        xy_loss = tf.reduce_sum(xy_diff, axis=[1, 2, 3, 4])

        wh_diff = tf.square(tf.sqrt(true_wh) - tf.sqrt(predicted_wh)) * responsibility_selector[..., None]
        wh_loss = tf.reduce_sum(wh_diff, axis=[1, 2, 3, 4])

        obj_diff = tf.square(iou_scores - predicted_objectedness) * responsibility_selector
        obj_loss = tf.reduce_sum(obj_diff, axis=[1, 2, 3])

        best_iou = tf.reduce_max(iou_scores, axis=-1)
        no_obj_diff = tf.square(0 - predicted_objectedness) * tf.cast(best_iou < 0.6,tf.float32)[..., None] * (1 - responsibility_selector)
        no_obj_loss = tf.reduce_sum(no_obj_diff, axis=[1, 2, 3])

        clf_diff = tf.square(true_logits - predicted_logits) * responsibility_selector[..., None]
        clf_loss = tf.reduce_sum(clf_diff, axis=[1, 2, 3, 4])

        object_coord_scale = 5
        object_conf_scale = 1
        noobject_conf_scale = 1
        object_class_scale = 1

        loss = object_coord_scale * (xy_loss + wh_loss) + \
                object_conf_scale * obj_loss + noobject_conf_scale * no_obj_loss + \
                object_class_scale * clf_loss
        return loss 

YoloLossKeras类：
定义初始值（自身，优先级）：
self.priors=优先级
def损失（自身、y_真实、y_pred）：
n_cells=y_pred.get_shape（）.as_list（）[1]
y_-true=tf.reformate（y_-true，tf.shape（y_-pred），name='y_-true'）
y_pred=tf.identity（y_pred，name='y_pred'）
####过程预测####
#获取x-y坐标（目前它们是关于单元格的）
预测的x=tf.nn.sigmoid（y_pred[…，：2]）
#将xy坐标转换为相对于图像的坐标
单元格inds=tf.range（n个单元格，数据类型=tf.float32）
预测的_xy=tf.stack((
预测的_xy[…，0]+tf.重塑（单元[1，-1,1]），
预测的xy[…，1]+tf.重塑（单元索引，[-1,1,1]）
)，轴=-1）
#计算bb宽度和高度
预测值=self.priors*tf.exp（y\u pred[…，2:4]）
#计算预测的bb中心和宽度
预测的最小值=预测的xy-预测的wh/2
预计最大值=预计xy+预计wh/2
预测的对象性=tf.nn.sigmoid（y_pred[…，4]）
预测值=tf.nn.softmax（y_pred[…，5:]）
####过程真实####
true_xy=y_true[…，：2]
真的，真的
true\u logits=y\u true[…，5:]
真最小=真xy-真wh/2
真最大值=真xy+真wh/2
####计算基础真实值和预测值之间的iou（用于对象性）####
相交最小值=tf.最大值（预测最小值、真实最小值）
相交最大值=tf.最小值（预测最大值，真实最大值）
intersect_wh=tf.最大值（intersect_maxes-intersect_mins，0.）
相交面积=相交面积[…，0]*相交面积[…，1]
真面积=真面积[…，0]*真面积[…，1]
预测面积=预测面积[…，0]*预测面积[…，1]
并集面积=前面积+真实面积-相交面积
iou分数=相交区域/联合区域
####计算损失项####
责任选择器=y_真[…，4]
xy_diff=tf.square（真_xy-预测_xy）*责任_选择器[…，无]
xy_损失=tf.减少_总和（xy_差异，轴=[1,2,3,4]）
wh_diff=tf.square（tf.sqrt（true_wh）-tf.sqrt（predicted_wh））*责任选择器[…，无]
wh_loss=tf.减少wh_sum（wh_diff，axis=[1,2,3,4]）
obj_diff=tf.square（iou分数-预测对象性）*责任选择器
obj_损失=tf。减少总和（obj_差异，轴=[1,2,3]）
最佳iou=tf。减少最大iou（iou分数，轴=-1）
无目标差异=tf.square（0-预测目标性）*tf.cast（最佳iou<0.6，tf.float32）[……，无]*（1-责任选择器）
无目标损失=tf。减少总和（无目标差异，轴=[1,2,3]）
clf_diff=tf.square（真逻辑-预测逻辑）*责任逻辑选择器[…，无]
clf_损失=tf。减少总和（clf_差异，轴=[1,2,3,4]）
对象坐标比例尺=5
对象配置比例=1
无对象配置比例=1
对象\类别\比例=1
损失=对象协调比例*（xy损失+wh损失）+\
对象配置比例*对象配置比例损失+无对象配置比例*无对象配置比例损失+\
对象\u类别\u比例*clf\u损失
回波损耗