神经网络训练多任务学习(MTL)时，多个loss怎么分配权重(附代码)

这里我的代码里面使用的是“不确定性加权方法”

1. 基本思想：难学的任务给予更小的权重使得整体的多任务模型的训练更加顺畅和有效。 前提概念：认知不确定性和偶然不确定性。
2. 前提概念：认知不确定性和偶然不确定性

   1. 认知不确定性（epistemic）：指的是由于缺少数据导致的认知偏差。当数据很少的时候，训练数据提供的样本分布很难代表数据全局的分布，导致模型训练学偏。这种不确定性可以通过增加数据来改善。

   2. 偶然不确定性（aleatoric）：指的是由于数据本身，或者任务本身带来的认知偏差。偶然不确定性有个特点，其不会随着数据量增加而改善结果，数据即使增加，偏差仍然存在。

   3. 偶然不确定性可以分为两种情况：

        a. 数据依赖型或**异方差**。在进行数据标注的时候的误标记、错标记等，这些错误的数据也会造成模型预测偏差；
        b.任务依赖型或**同方差**。这个指的是，同一份数据，对于不同的任务可能会导致不同的偏差。
      

原论文：《Multi-task learning using uncertainty to weigh losses for scene geometry and semantics》
github上用pytorch的实现：https://github.com/Mikoto10032/AutomaticWeightedLoss

import torch
import torch.nn as nn

class AutomaticWeightedLoss(nn.Module):
    """automatically weighted multi-task loss
    Params：
        num: int，the number of loss
        x: multi-task loss
    Examples：
        loss1=1
        loss2=2
        awl = AutomaticWeightedLoss(2)
        loss_sum = awl(loss1, loss2)
    """
    def __init__(self, num=2):
        super(AutomaticWeightedLoss, self).__init__()
        params = torch.ones(num, requires_grad=True)
        self.params = torch.nn.Parameter(params)

    def forward(self, *x):
        loss_sum = 0
        for i, loss in enumerate(x):
            loss_sum += 0.5 / (self.params[i] ** 2) * loss + torch.log(1 + self.params[i] ** 2)
        return loss_sum

if __name__ == '__main__':
    awl = AutomaticWeightedLoss(2)
    print(awl.parameters())

具体的例子：

from torch import optim
from AutomaticWeightedLoss import AutomaticWeightedLoss

model = Model()

awl = AutomaticWeightedLoss(2)	# we have 2 losses
loss_1 = ...
loss_2 = ...

# learnable parameters
optimizer = optim.Adam([
                {'params': model.parameters()},
                {'params': awl.parameters(), 'weight_decay': 0}
            ])

for i in range(epoch):
    for data, label1, label2 in data_loader:
        # forward
        pred1, pred2 = Model(data)	
        # calculate losses
        loss1 = loss_1(pred1, label1)
        loss2 = loss_2(pred2, label2)
        # weigh losses
        loss_sum = awl(loss1, loss2)
        # backward
        optimizer.zero_grad()
        loss_sum.backward()
        optimizer.step()