Computer vision 计算中间层输出的梯度并使用优化器更新权重

我试图实现下面的体系结构，但不确定是否正确应用了渐变磁带

在上面的体系结构中，我们可以看到，蓝色框中有来自多个层的输出。每个蓝盒被称为损失分支，其中包含两个损失，即交叉熵和l2损失。我在tensorflow 2中编写了架构，并使用渐变磁带进行定制培训。我不确定的一件事是，我应该如何使用梯度磁带更新损耗

我有两个疑问

在这种情况下，我应该如何使用梯度带来处理多重损失。我对看代码感兴趣 例如，在上面的图像中考虑第三个蓝色框（第三个丢失分支），在这里我们将从<强> CONV 13 <强>层中获取输入，得到两个输出，一个用于分类，另一个用于回归。 因此，在计算了损失后，我应该如何更新权重，我应该更新上面的所有层（从conv 1到conv 13），还是只更新获取我的conv 13（conv 11、12和13）的层权重

我还附上了一个我昨天详细发帖的问题

下面是我尝试过的渐变下降的片段。如果我错了，请纠正我

        images = batch.data[0]
        images = (images - 127.5) / 127.5

        targets = batch.label

        with tensorflow.GradientTape() as tape:
            outputs = self.net(images)
            loss = self.loss_criterion(outputs, targets)
        
        self.scheduler(i, self.optimizer)
        grads = tape.gradient(loss, self.net.trainable_variables)
        self.optimizer.apply_gradients(zip(grads, self.net.trainable_variables))

以下是用作上述损耗标准的自定义损耗函数的代码

    losses = []
    for i in range(self.num_output_scales):
        pred_score = outputs[i * 2]
        pred_bbox = outputs[i * 2 + 1]
        gt_mask = targets[i * 2]
        gt_label = targets[i * 2 + 1]

        pred_score_softmax = tensorflow.nn.softmax(pred_score, axis=1)
        loss_mask = tensorflow.ones(pred_score_softmax.shape, tensorflow.float32)

        if self.hnm_ratio > 0:
            pos_flag = (gt_label[:, 0, :, :] > 0.5)
            pos_num = tensorflow.math.reduce_sum(tensorflow.cast(pos_flag, dtype=tensorflow.float32)) 
        if pos_num > 0:
            neg_flag = (gt_label[:, 1, :, :] > 0.5)
            neg_num = tensorflow.math.reduce_sum(tensorflow.cast(neg_flag, dtype=tensorflow.float32))
            neg_num_selected = min(int(self.hnm_ratio * pos_num), int(neg_num))
            neg_prob = tensorflow.where(neg_flag, pred_score_softmax[:, 1, :, :], \
            tensorflow.zeros_like(pred_score_softmax[:, 1, :, :]))
            neg_prob_sort = tensorflow.sort(tensorflow.reshape(neg_prob, shape=(1, -1)), direction='ASCENDING')
            prob_threshold = neg_prob_sort[0][int(neg_num_selected)]
            neg_grad_flag = (neg_prob <= prob_threshold)
            loss_mask = tensorflow.concat([tensorflow.expand_dims(pos_flag, axis=1), 
                tensorflow.expand_dims(neg_grad_flag, axis=1)], axis=1)
        else:
            neg_choice_ratio = 0.1
            neg_num_selected = int(tensorflow.cast(tensorflow.size(pred_score_softmax[:, 1, :, :]), dtype=tensorflow.float32) * 0.1)
            neg_prob = pred_score_softmax[:, 1, :, :]
            neg_prob_sort = tensorflow.sort(tensorflow.reshape(neg_prob, shape=(1, -1)), direction='ASCENDING')
            prob_threshold = neg_prob_sort[0][int(neg_num_selected)]
            neg_grad_flag = (neg_prob <= prob_threshold)                
            loss_mask = tensorflow.concat([tensorflow.expand_dims(pos_flag, axis=1), 
                tensorflow.expand_dims(neg_grad_flag, axis=1)], axis=1)

        pred_score_softmax_masked = tensorflow.where(loss_mask, pred_score_softmax, 
            tensorflow.zeros_like(pred_score_softmax, dtype=tensorflow.float32))
        pred_score_log = tensorflow.math.log(pred_score_softmax_masked)
        score_cross_entropy = - tensorflow.where(loss_mask, gt_label[:, :2, :, :], 
            tensorflow.zeros_like(gt_label[:, :2, :, :], dtype=tensorflow.float32)) * pred_score_log
        loss_score = tensorflow.math.reduce_sum(score_cross_entropy) / 
        tensorflow.cast(tensorflow.size(score_cross_entropy), tensorflow.float32)

        mask_bbox = gt_mask[:, 2:6, :, :]
        predict_bbox = pred_bbox * mask_bbox
        label_bbox = gt_label[:, 2:6, :, :] * mask_bbox
        # l2 loss of boxes
        # loss_bbox = tensorflow.math.reduce_sum(tensorflow.nn.l2_loss((label_bbox - predict_bbox)) ** 2) / 2
        loss_bbox = mse(label_bbox, predict_bbox) / tensorflow.math.reduce_sum(mask_bbox)

        # Adding only losses relevant to a branch and sending them for back prop
        losses.append(loss_score + loss_bbox)
        # losses.append(loss_bbox)
    
        # Adding all losses and sending to back prop Approach 1
        # loss_cls += loss_score
        # loss_reg += loss_bbox
        # loss_branch.append(loss_score)
        # loss_branch.append(loss_bbox)
        # loss = loss_cls + loss_reg

    return losses

loss=[]
对于范围内的i（self.num\u输出\u刻度）：
pred_分数=输出[i*2]
pred_bbox=输出[i*2+1]
gt_mask=目标[i*2]
gt_标签=目标[i*2+1]
pred_分数softmax=tensorflow.nn.softmax（pred_分数，轴=1）
损失掩码=tensorflow.ones（pred\u score\u softmax.shape，tensorflow.float32）
如果self.hnm_比率>0：
pos_标志=（gt_标签[：，0，：，：]>0.5）
pos_num=tensorflow.math.reduce_sum（tensorflow.cast（pos_标志，dtype=tensorflow.float32））
如果pos_num>0：
neg_标志=（gt_标签[：，1，：，：]>0.5）
neg_num=tensorflow.math.reduce_sum（tensorflow.cast（neg_标志，dtype=tensorflow.float32））
所选负数值=最小值（int（self.hnm_ratio*pos_num），int（负数值））
neg_prob=tensorflow。其中（neg_标志，pred_分数_softmax[：，1，：，：]\
tensorflow.zeros_like（pred_score_softmax[：，1，：，：]）
neg_prob_sort=tensorflow.sort（tensorflow.reformate（neg_prob，shape=（1，-1）），direction='升序〕）
概率阈值=负概率排序[0][int（已选择负数量）]
负梯度标志=（负概率）