论文题目：Multi-Task Learning Using Uncertainty to Weigh Losses
for Scene Geometry and Semantics
中文翻译：使用不确定性来衡量权重损失的多任务学习——用于几何和语义场景

代码链接：https://github.com/yaringal/multi-task-learning-example
摘要
只专注于单个模型可能会忽略一些相关任务中可能提升目标任务的潜在信息，通过进行一定程度的共享不同任务之间的参数，可能会使原任务泛化更好，许多深度学习应用受益于多任务学习——多元回归和目标分类。在本篇论文中，我们观察到不同任务的损失之间的尺度差异非常大，我们不能直接将各个任务的损失相加作为整体的损失，这样会导致一个任务收敛的很快，其他的任务表现很差，一个简单的解决方案是，将损失简单相加替换为加权和，以使所有任务损失的尺度接近。但是，这引入了需要进行调节的超参数。而对这些加权值进行手工微调是一件很困难且昂贵的事情，会使得多任务学习在实践中让人望而却步。由此我们提出了一种新的确定每个任务加权值的方法——引入同方差的不确定性来确定 MTL 中损失的权重：在每个任务的损失函数中学习另一个噪声参数（noise parameter）。此方法可以接受多任务（可以是回归和分类），并统一所有损失的尺度。这样，我们就能像一开始那样，直接相加得到总损失了。
1. Introduction
多任务学习通过从共享的特征表达中学习多个目标来提高学习效率和预测精度，多任务学习现在已经应用在机器学习的方方面面——从计算机视觉到自然语言处理到语言识别。
我们在计算机视觉的环境理解中探索多任务学习，环境理解算法必须同时理解环境的几何和语义信息，这引入了一个有趣的多任务问题——环境理解涉及到不同单元和尺度的各种分类和回归任务的联合学习，视觉环境理解的多任务学习在系统中是非常重要的，因为在这样的系统中长时间的计算力投入是禁止的，比如机器人中。将所有的任务结合成一个模型可以减少计算力，并且允许这些系统实时运行。
之前同时学习多个任务的方法是简单使用损失的加权和，损失的加权值或是均匀的，或是需要手工微调，然而，我们证明了这样做的模型的表现强烈依赖于每个任务损失的加权值，而手工去微调这些加权值达到最优是很昂贵且困难的。我们观察到每个任务最佳权重依赖于一个衡量尺度——最后发现这个尺度就是任务噪声的幅度。
在这篇工作中，我们提出了一个原则性的方法——使用同方差不确定性来将多个任务损失结合来同时学习多个目标，我们将同方差不确定性看作和任务相关的加权值，同时展示了怎样得到一个原则性的多任务损失函数，它可以很好的平衡不同回归和分类损失，我们的方法可以学着去平衡这些加权值，与单独学习每个任务相比，产生了更加优越的性能。
具体来讲，我们展示了在学习环境几何和语义等三个任务中我们方法的表现。首先，我们学着去针对每个像素点对目标分类（称之为语义分割），其次，我们的模型执行实例分割，这是更难的任务——因为它不仅需要判断每个像素的类别，还需要判断这个像素点属于哪个目标。这比单独的目标检测也要难。最后，我们证明了使用语义标签和多任务深度学习可以提高几何和深度估计。
在现有文献中，经常使用单独的深度学习模型来学习深度回归、语义分割和实例分割来构建一个完整的系统。给一张单目的输入图片，我们的系统首先去做语义分割、实例分割和深度密集估计（如Figure 1所示）。而其他的视觉模型已经展示了多任务学习，我们展示了如何将几何和语义信息结合起来，将这些任务结合起来构成单个模型确保了在减少计算的同时完成单个任务的输出，最后，我们展示了多任务中的共享表达可以提高在不同指标上的性能，来使得模型更高效：



总的来说，本篇论文的主要贡献在于：

一个新颖且原则性的多任务损失使用同方差不确定性来同时学习不同数量和单元的各种分类和回归损失；
一个用来完成语义分割、实例分割和 depth regression；
展示了多任务学习中损失加权值得重要性，相比于单独训练每个模型，我们如何才能通过多任务学习获得更优越的表现；

2. Multi Task Learning with Homoscedastic Uncertainty
多任务学习涉及到优化到多个目标，是现在深度学习很流行的一个问题。原来将多个目标损失结合在一起的方法就是对单个任务的损失简单多一个加权和：


这是之前的工作中使用的主要方法，其中模型的表现力对于 $w_{i}$ 特别敏感（如上面的Figure 2所示），这些加权超参数手工调参代价很高，因此发现一种便利的方法来学习最佳加权值是很迫切的。
更具体的讲，我们考虑一个网络来学习从输入图片中预测像素深度和语义类别。在Figure 2中每张图的边界表示分别在单个任务上训练的模型，曲线刻画了对于不同权重$w_{i}$的表现，我们观察到在一些最佳加权值中，这种联合网络表现得比分别训练每个网络要好。Figure 2也展示了两个回归任务的相似结果：实例分割和深度回归。我们接下来展示了如何使用概率建模的想法来学习最佳任务权重。
3.1. 同方差不确定性（任务依赖型不确定性）
在贝叶斯建模中，有两种不同类型的不确定性可以建模。

认知不确定性是模型中常见的一种不确定性，通常由数据不足产生，可以通过增加训练数据来解释，认知不确定性测量的，是我们的input data是否存在于已经见过的数据的分布之中；
偶然不确定性捕捉到的是我们的数据不能解释的信息；

偶然不确定性可以再分为两个子类：

数据依赖型（不同方差）是一种依赖于输入数据的偶然不确定性，可以作为一个模型输出预测；
任务依赖性（相同方差）是不依赖于输入数据的偶然不确定性，它不是一个模型输入，对于所有输入数据来说都是常量，但是不同任务之间不同。因此被描述为任务依赖型不确定性；

在多任务设置中，我们展示了任务不确定性捕捉到了任务之间的相关置信度，反映了回归和分类任务的不确定性，它也依赖于任务的表征和衡量单元，我们提出了我们可以使用同方差不确定性作为多任务学习问题中加权损失的基础。
3.2. Multi-task likelihoods
在本节中，我们提出了基于最大化同方差高斯似然函数的多任务损失函数，我们令$f^{W}(x)$作为输入x权重W的神经网络输出，我们定义了下面的概率模型，对于回归任务，我们讲我们的似然函数定义为高斯分布（均值为模型输出，方差为噪声）：



加入了一个噪声因子$\sigma$，对于分类任务我们经常用softmax函数压缩模型输出，并从结果概率向量中采样：



在有多个模型输出的情况下，我们经常多任务似然函数定义为：



模型输出为$y_{1},y_{2}...y_{K}$，$f^{W}(x)$为我们充足的统计，其实就是将网络看作一个作用在输入上的函数f。
在最大化似然函数中，我们一般选择最大化对数似然函数，在回归问题中，举个例子，对数似然函数可以写为：



对于高斯似然，$\sigma$是模型观察到的噪声参数——捕捉到了输出中有多少噪声，接着我们最大化和模型参数W和观察噪声参数$\sigma$有关的对数似然函数。
让我们现在假设模型输出由两个向量$y_{1}和y_{2}$组成，每一个都遵循高斯分布：



最大化似然函数（6）相当于最小化对数似然函数的相反数，于是我们要最小化的多目标输出模型为$\pounds (W,\sigma _{1},\sigma _{2})$：



这里我们将$\pounds _{1}(W)=||y_{1}-f^{W}(x)||^{2}$记为第一个输出变量的损失，$\pounds _{2}(W)$类似。
我们通过最小化（7）式，来自适应地学习损失$\pounds _{1}(W)和\pounds _{2}(W)$的相对权重$\sigma _{1}和\sigma _{2}$。当$变量y_{1}$的噪声参数$\sigma _{1}$增加时意味着损失$\pounds _{1}(W)$的加权值降低了，另一方面，当噪声减少时，目标损失的相关权重增大了，同时通过（7）式中的最后一项来限制$\sigma _{1}和\sigma _{2}$，使得其不能太大，起了一个正则化的作用。这个地方我是这么想的，噪声参数大意味着输出变量的方差太大，结果不可靠，所以在目标损失中该损失的加权值应该减少。
这种结构可以简单扩展到多个回归输出中，然而，扩展到分类似然函数中更有趣，我们将噪声参数$\sigma$作为一个缩放因子加入到（3）式中：



$\sigma$是一个正因子，这个可以看成是一个玻尔兹曼分布（输入被放缩了$\sigma ^{2}倍$），这个因子可以是固定的，也可以学习得到，参数的幅度决定了离散分布的均匀性，这和不确定性有关，输出的对数似然可以被写为：


$f^{W}_{c}$可以看作是向量$f^{W}$的第c个元素。
接下来，我们假设模型的多个输出由一个连续的输出$y_{1}$（回归值）和离散的输出$y_{2}$（分类值）组成，分别由高斯似然和softmax似然建模，就像之前定义一个联合损失$\pounds(W,\sigma _{1},\sigma _{2})$，可以写成：



这里的$\pounds _{1}(W)=||y_{1}-f^{W}(x)||^{2}，\pounds _{2}(W)=-logSoftmax(y_{2},f^{W}(x))$，这里观察到当$\sigma _{2}$趋向于1时，最后一项可以通过$\frac{1}{\sigma _{2}}\sum _{c^{'}}exp(\frac{1}{\sigma ^{2}_{2}}f^{W}_{c^{'}}(x))\approx exp(f^{W}_{c^{'}}(x))^{\frac{1}{\sigma ^{2}_{2}}}$来近似，这极大地简化了优化目标。
这种结构可以到连续和离散损失函数的任意结合，允许我们以一种原则性的方法学习每个损失的相关权重，这种损失可以平滑地区分，相关权重不会收敛到0。相反，使用（1）中简单地加权和会导致相关权重可能收敛到0。
在实践中，我们训练网络来预测对数方差$s:=log\sigma ^{2}$，这是因为回归s比回归$\sigma ^{2}$更稳定，这样也可以避免分母项为0，同时指数映射也允许来回归没有约束的缩放值，这里的exp(-s)被解析到正值，给了方差一个有效值。

砝码称重 
设有 1g 、 2g 、 3g 、 5g 、 10g 、 20g 的砝码各若干枚（其总重 <=1000 ）， 
要求： 
    输入方式： a1  a2  a3  a4  a5  a6 
             （表示 1g 砝码有 a1 个， 2g 砝码有 a2 个，…， 20g 砝码有 a6 个） 
    输出方式： Total=N 
             （ N 表示用这些砝码能称出的不同重量的个数，但不包括一个砝码也不用的情况） 
如输入： 1_1_0_0_0_0   （注：下划线表示空格） 


  输出： TOTAL=3   表示可以称出 1g ， 2g ， 3g 三种不同的重量。 

还是一道DP的问题——其实有点暴搜的意思。这道题不是很难，如果你做过装箱问题，你会发现他们竟惊人的相似 
这次代码格式还不错 
/**********************************************************************************/
/*  Problem: f013 "砝码称重" from NOIP1996                                        */
/*  Language: C                                                                   */
/*  Result: AC (1ms, 408KB) on SzNOI.cn                                           */
/*  Author: creativewang at 2011-01-16 15:43:44                                   */
/**********************************************************************************/
/*
*Program name:Weigh
*Website to submit:sanoi.cn/oj
*Program ID:
*/
#include<stdio.h>
#define MAX_WEIGHT 1000
#define KINDS 6
int main(void)
{
    int max=0,                          /*max weight available*/
        amount[KINDS+1],                  /*amount of weights*/
        weight[KINDS+1]={0,1,2,3,5,10,20},  /*weight each weight weighs*/
        opt[MAX_WEIGHT+1]={0},
        ans=0;                          /*this is the answer*/
    opt[0]=1;
    int i,j,k;
    for(i=1;i<=KINDS;i++)                /*calculate max weight*/
    {
        scanf("%d",amount+i);
        max=amount[i]*weight[i]+max;
    }
    for(i=1;i<=6;i++)
        for(j=1;j<=amount[i];j++)
            for(k=max;k>=weight[i];k--)
                if(opt[k-weight[i]])
                    opt[k]=1;
    for(i=max;i>0;i--)                /*count!*/
        if(opt[i]==1)
            ans++;
    printf("Total=%d",ans);
    return 0;
}

Multi-Task Learning Using Uncertainty to Weigh Losses  for Scene Geometry and Semantics
https://arxiv.org/abs/1705.07115
CVPR 2018

Alex Kendall University of Cambridge
Yarin Gal  University of Oxford
Roberto Cipolla University of Cambridge

Question
在多任务模型中, 往往每一个任务都会使用一个单独的loss.
如文中使用CityScapes数据集同时做分语义割(Semantic Segmentation), 实例分割(Instance Segmentation), 单目深度估计(Monocular Disparity Estimation), 三个任务的loss截然不同,如果模型训练时侧重一个任务, 那么其他任务的性能就会很差.
而单任务模型中, 也会添加不同的loss去提高训练的速度, 或者增强模型的性能.
举例来说, 在reid 任务中, 会同时存在ID loss 和 metric loss, 两种loss的作用不同,前者用于分类, 快速收敛模型, 后者用于度量学习, 缩小类内间距和扩大类间距离. 而且随着训练迭代次数的增加, 两种loss对于模型泛化性的作用也随之不同.
多个 loss 之间的取舍会随着数据集的尺度差异, 以及任务的难易程度改变, 恒定的权重会制约模型的收敛方向, 进而影响模型的最终性能.
如何动态调整loss之间的权重, 就是文中所要研究的内容.
Methodology

概率机器学习和不确定性
机器学习训练模型模型从观察到的数据（训练数据）中学习一些模式和假设，并对未观察到的数据（测试数据）进行推断。然而，由于输入数据噪声、感官噪声、测量误差、非最优超参数设置等诸多原因，该模型对预测具有不确定性。
从概率论的角度来看，用单点估计作为权重来建立任何分类都是不合理的，而且神经网络无法正确评估训练数据中的不确定性。机器学习中的概率模型指出，所有形式的不确定性不可能是一个真实的值，而更像是一个概率值，并使用概率论来回答一切问题。概率分布用于建模学习、不确定性和未观测状态。在观察数据之前，先定义一个先验概率分布，然后进行学习，一旦观察到数据，该分布就转换为后验分布。
网络中的不确定性是衡量模型对其预测确定程度的指标。在贝叶斯模型中，存在两种主要的不确定性类型：偶然不确定性（Aleatoric uncertainty）和认知不确定性（Epistemic uncertainty）。
偶然不确定性测量观测中固有的噪声。这种不确定性存在于数据采集方法中，如传感器噪声或沿数据集均匀分布的运动噪声。即使收集了更多的数据，也不能减少这种不确定性, 只能通过提高数据精度避免.
偶然不确定性可以进一步分为同方差不确定性（Task-dependant or Homoscedastic uncertainty）和异方差不确定性（Data-dependant or Heteroscedastic uncertainty）


异方差不确定性，取决于输入数据，并预测为模型输出。其中一些输入可能具有比其他输入更多的噪声输出。异方差的不确定性尤为重要，可以防止模型输出非常自信的决策。


同方差不确定性，不取决于输入数据。它不是模型输出，而是一个对所有输入数据保持不变并且在不同任务之间变化的数量。因此，它可以被描述为任务相关的不确定性。


认知不确定性代表了模型本身造成的不确定性。给定更多数据可以减少这种不确定性，并且通常称为模型不确定性。


同方差不确定性与输入无关, 取决于任务固有的不确定性, 通过将同方差不确定性转变为loss的weight, 模型就可以具有动态调整loss的能力.
现在将同方差不确定性定义为 $\sigma$, 因为 $\sigma$ 对所有输入数据保持不变并且在不同任务之间变化的数量, 所以假设 $\sigma$ 是模型存在的参数, 并且维持不变. 当前我们已经有了输出和标签, 那么为了求出参数 $\sigma$ , 可以使用极大似然估计计算.

极大似然估计
利用给定的样本和概率分布, 反推分布参数.
假设概率分布或者概率密度函数为 $f(x ; \theta)$ 由于 $\theta$ 未知,
则定义对于 $\theta$ 的似然函数 $L(\theta)=\prod_{i=1}^{n} f\left(x_{i} ; \theta\right)$
为了最大化似然函数,
利用对数函数担当递增的性质,对似然函数取对数, 得到$lnL(\theta)=\sum_{i=1}^{n} lnf\left(x_{i} ; \theta\right)$
对 $\theta$ 求导, 并将导数置为 0 , $\frac{\partial \ln L(\theta)}{\partial \theta_{j}}=0$
如果存在驻点 $\hat\theta$ , 则可以认定 $\hat\theta$ 可以使得对数似然函数最大, 也使得似然函数最大.

在文中, 并没有完全按照极大似然估计的做法, 做法如下:
首先定义 $\mathbf{f}^{\mathbf{W}}(\mathbf{x})$ 为神经网络的输出特征张量.
回归问题
在回归问题中, 神经网络直接输出预测值$\mathbf{f}^{\mathbf{W}}(\mathbf{x})$ , 并且与真值 $\mathbf{y}$ 存在固有的同方差不确定性, 那么就可以假设对于 $\mathbf{y}$ 的后验概率符合以 $\sigma^2$ 作为方差的高斯分布:

$p\left(\mathbf{y} | \mathbf{f}^{\mathbf{W}}(\mathbf{x})\right)=\mathcal{N}\left(\mathbf{f}^{\mathbf{W}}(\mathbf{x}), \sigma^{2}\right) \tag{1}$

取对数:

$\log p\left(\mathbf{y} | \mathbf{f}^{\mathbf{W}}(\mathbf{x})\right) \propto-\frac{1}{2 \sigma^{2}}\left\|\mathbf{y}-\mathbf{f}^{\mathbf{W}}(\mathbf{x})\right\|^{2}-\log \sigma^2  \tag{2}$
可以发现 loss  $\left\|\mathbf{y}-\mathbf{f}^{\mathbf{W}}(\mathbf{x})\right\|^2$ 出现在等式右侧. 两边同时乘以-号, 将问题转化为使得负对数似然函数最小:
$-\log p\left(\mathbf{y} | \mathbf{f}^{\mathbf{W}}(\mathbf{x})\right) \propto\frac{1}{2 \sigma^{2}}\left\|\mathbf{y}-\mathbf{f}^{\mathbf{W}}(\mathbf{x})\right\|^{2}+\log \sigma^2  \tag{3}$
当前, 预测值$\mathbf{f}^{\mathbf{W}}(\mathbf{x})$ 与真值 $\mathbf{y}$ 已知, 可以通过梯度下降的算法去寻找最终的 $\sigma$.
分类问题
分类问题思路一致, 推导还是看论文吧, 不抄了. 结果与回归一致.
Code
在实践中, 我们训练网络来预测对数方差$s:=\log \sigma^{2}$, 这样可以使得训练更稳定, 同时避免分母项为0, 同时指数映射也允许来回归没有约束的缩放值, 这里的 $exp(-s)$ 可以被解析到正值, 给了方差一个有效值.
loss += torch.exp(-sem_uncertainty) * sem_loss + 0.5 * sem_uncertainty
loss += 0.5 * (torch.exp(-inst_uncertainty) * inst_loss + inst_uncertainty)
loss += 0.5 * (torch.exp(-depth_uncertainty) * depth_loss + depth_uncertainty)

https://github.com/oscarkey/multitask-learning
这个实现的太复杂, 而且不通用, 之后可能会改进成为一个model方便使用.
Reference
[1] 极大似然估计–百度百科
[2] 一文搞懂极大似然估计
[3] 贝叶斯深度学习-概述

The balance was the first mass measuring instrument invented. In its traditional form, it consists of a pivoted horizontal lever of equal length arms, called the beam, with a weighing pan, also called scale, suspended from each arm (which is the origin of the originally plural term “scales” for a weighing instrument). The unknown mass is placed in one pan, and standard masses are added to this or the other pan until the beam is as close to equilibrium as possible. The standard weights used with balances are usually labeled in mass units, which are positive integers.
With some standard weights, we can measure several special masses object exactly, whose weight are also positive integers in mass units. For example, with two standard weights 1 and 5, we can measure the object with mass 1, 4, 5 or 6 exactly.
In the beginning of this problem, there are 2 standard weights, which masses are x and y. You have to choose a standard weight to break it into 2 parts, whose weights are also positive integers in mass units. We assume that there is no mass lost. For example, the origin standard weights are 4 and 9, if you break the second one into 4 and 5, you could measure 7 special masses, which are 1, 3, 4, 5, 8, 9, 13. While if you break the first one into 1 and 3, you could measure 13 special masses, which are 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13! Your task is to find out the maximum number of possible special masses.
Input

There are multiple test cases. The first line of input is an integer T < 500 indicating the number of test cases. Each test case contains 2 integers x and y. 2 ≤ x, y ≤ 100
Output

For each test case, output the maximum number of possible special masses.
Sample Input

2

4 9

10 10

Sample Output

13

9
题目意思是说，给你两个砝码，将这两个砝码中的一个拆成任意两个砝码，然后用这三个砝码放在天平上，看最多可以表示多少种重量，输出可以表示重量种类最多的那一个。不要被固定思维给限制住了，砝码可以放在左右两边，左右两边都放的时候可以用右边的减去左边的来表示实际的重量。
比较像牛客网上的一道题，用-1,0,1来对应表示放左边、不放和放右边，用集合set来记录可以记录的情况，最后选取所有可能情况的最大值即可。由于数据量不是特别大，所以可以暴力。
AC代码
#include<iostream>
#include<set>
#include<cmath>
using namespace std;
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		int x,y,maxn=-1;
		cin>>x>>y;
		for(int i=1;i<=x/2;i++)//拆第一个砝码，只需要拆到一半就可以，结果是对称的
		{
			set<int> s;
			for(int j=-1;j<=1;j++)
				for(int k=-1;k<=1;k++)
					for(int l=-1;l<=1;l++)
						if(j*i+k*(x-i)+l*y>0)
							s.insert(j*i+k*(x-i)+l*y);
			int temp=s.size();
			if(maxn<temp)
				maxn=temp;
		}
		for(int i=1;i<=y/2;i++)//拆第二个砝码
		{
			set<int> s;
			for(int j=-1;j<=1;j++)
				for(int k=-1;k<=1;k++)
					for(int l=-1;l<=1;l++)
						if(j*i+k*(y-i)+l*x>0)
							s.insert(j*i+k*(y-i)+l*x);
			int temp=s.size();
			if(maxn<temp)
				maxn=temp;
		}
		cout<<maxn<<endl;
	}
	return 0;
}