- Focal -loss是交叉熵损失函数的变体，交叉熵损失函数公式如下：
C E ( p , y ) = − y l o g ( p ) − ( 1 − y ) l o g ( 1 − p ) = { − l o g ( p ) y = 1 − l o g ( 1 − p ) o t h e r w i s e CE(p , y) = -y log (p) - (1-y) log(1-p) = begin{cases}- log (p) &y = 1 \ - log(1 - p) &otherwise end{cases} CE(p,y)=−ylog(p)−(1−y)log(1−p)={−log(p)−log(1−p)y=1otherwise - 其中
p
p
p可以理解为模型的预测结果，
y
y
y可以理解为数据的真实标签。
为了便于理解还是以二分类的思想去理解，为什么是二分类呢，因为类别除了1就是-1两个类别。首先从交叉熵函数进行理解。
C E ( p , y ) = { − l o g ( p ) y = 1 − l o g ( 1 − p ) o t h e r w i s e CE(p , y) = begin{cases}- log (p) &y = 1 \ - log(1 - p) &otherwise end{cases} CE(p,y)={−log(p)−log(1−p)y=1otherwise - 当真实标签
y
=
1
y=1
y=1时，假如某个样本预测标签为1这个类的概率为0.6，也就是预测结果
p
=
0.6
p=0.6
p=0.6，那么损失就是
−
l
o
g
(
0.6
)
-log (0.6)
−log(0.6)；如果
p
=
0.8
p=0.8
p=0.8，则损失为
−
l
o
g
(
0.8
)
- log (0.8)
−log(0.8)，值得注意的是：
−
l
o
g
(
0.6
)
>
−
l
o
g
(
0.8
)
-log (0.6) > - log (0.8)
−log(0.6)>−log(0.8)。
为了方便用 p t p_t pt代替分段损失函数：
p t = { p y = 1 1 − p o t h e r w i s e p_t = begin{cases} p &y = 1 \ 1 - p &otherwise end{cases} pt={p1−py=1otherwise -
p
t
p_t
pt是类别概率，衡量样本的难易程度，如果
p
t
p_t
pt较大，则代表是简单的样本，较小则代表是困难（复杂）样本。
− a t C E ( p t ) = − a t l o g ( p t ) = { − a t l o g ( p ) − ( 1 − a t ) l o g ( 1 − p ) - a_tCE(p_t) = -a_t log(p_t) = begin{cases} -a_t log(p) \ -(1 - a_t) log(1-p) end{cases} −atCE(pt)=−atlog(pt)={−atlog(p)−(1−at)log(1−p) - 系数
a
t
a_t
at与
p
t
p_t
pt的定义类似，当真实标签
y
=
1
y = 1
y=1时，
a
t
=
a
a_t =a
at=a，当真实标签
y
=
−
1
y = -1
y=−1时，其参数为
1
−
a
t
=
1
−
a
1 - a_t = 1 - a
1−at=1−a（
a
a
a的范围是0~1）。可以设定
a
t
a_t
at的值来控制正负样本对总损失的共享权重。这里说到正负样本，一般而言，在检测任务中负样本数要比正样本数多很多，基本是3:1的比例。那么
a
t
a_t
at在retinaNet论文中取0.25，该系数在实现的代码中是以你的类别数来定义的，啥意思呢，就是他会给第一个正类一个0.25的系数因子，那么其余的类别就可以理解为负类，他们都是0.75的系数因子。这也就是说，正类的系数因子要小，而负类的系数因子要大，这也可以理解为，在计算损失的时候，一般的正负样本最后的比例都接近于1:3的系数比例，可想而知负样本（负类）对损失的影响有多大，所以负样本的系数因子更大一些，损失函数则更偏向于把负样本的损失一点点降低。这也正是解决了正负样本不均衡的问题。根据上面所说，
a
t
a_t
at解决了正负样本的问题，但是无法解决容易分类样本和难分类样本的问题，于是就有了接下来的公式：
F L ( p t ) = − ( 1 − p t ) γ l o g ( p t ) FL(p_t) = -(1 - p_t)^gamma log(p_t) FL(pt)=−(1−pt)γlog(pt)
其中： − ( 1 − p t ) γ − − − − − − > p t = { p y = 1 1 − p o t h e r w i s e -(1 - p_t)^gamma ------>p_t = begin{cases} p &y = 1 \ 1 - p &otherwise end{cases} −(1−pt)γ−−−−−−>pt={p1−py=1otherwise - 这里称
γ
gamma
γ为调制参数
(
γ
>
=
0
)
(gamma >=0)
(γ>=0)，
(
1
−
p
t
)
γ
(1 - p_t)^gamma
(1−pt)γ称为调制系数。从上式可以看出：同样讨论对于一个二分类的问题，也就是两个类别讨论。当一个样本被分错时，也就是当标签类y = 1时，p = 0.3，根据上式可以看到，y=1 , p= 0.3 , 则
p
t
=
0.3
p_t = 0.3
pt=0.3，那么
(
1
−
p
t
)
γ
(1 - p_t)^gamma
(1−pt)γ就很大（通常
γ
gamma
γ取2）。这也就说明，分错的这个类表示难分的类。假如标签类y = 1或 -1，其 p = 0.8，那么
p
t
=
0.8
p_t = 0.8
pt=0.8，则
(
1
−
p
t
)
γ
(1 - p_t)^gamma
(1−pt)γ就非常小，这也就是说，该类别容易分类。通过上面的例子，就是说，面对容易分的样本，
(
1
−
p
t
)
γ
(1 - p_t)^gamma
(1−pt)γ调制系数比较小，面对复杂的样本，
(
1
−
p
t
)
γ
(1 - p_t)^gamma
(1−pt)γ调制系数比较大。对于损失函数来说，调制系数小则对损失影响小，调制系数大则对损失影响大，这也就实现了损失函数关于容易分类和复杂分类样本的处理。
综上 a t ， ( 1 − p t ) γ a_t ，(1 - p_t)^gamma at，(1−pt)γ即实现了调节正负样本的问题，也解决了难易分类样本的问题。
最后的Focal Loss函数为：
F L ( p t ) = − a t ( 1 − p t ) γ × C E ( p t ) FL(p_t) = - a_t (1- p_t) ^gamma times CE(p_t) FL(pt)=−at(1−pt)γ×CE(pt)
下图是 γ gamma γ取不同数值时 F o c a l L o s s Focal Loss FocalLoss损失函数的图像，其中 γ = 0 gamma = 0 γ=0就是交叉熵损失函数。
对于Focal Loss的使用，有以下几个版本，但是还是具体看自己使用在哪个模型中，从RetinaNet的文章中以及众多的解释中，对于目标检测任务而言，应用于分类类别损失是做好的。如果小伙伴有了解的话，我用的YOLOv4模型，他的总损失包括边界框回归损失，置信度损失和分类类别损失，共三种损失组成，目前直接可以用的就是替换掉类别的分类损失，而对于v4中，分类的原损失函数用的BCELoss，里面涉及到标签平滑技术，但是也是可以直接根据Focal Loss的函数来改进，希望想把yolo的类别分类损失换成Focal Loss损失的小伙伴一起交流。下面是几个比较好的Focal Loss代码（下了好多版本，最后还是基于原v4的BCELoss损失函数基础上改的）：下面的代码在原基础上给出了详细的中文注释，希望帮助到你~~
class FocalLoss(nn.Module):
def __init__(self, apply_nonlin=None, alpha=None, gamma=2, balance_index=0, smooth=1e-5, size_average=True,cuda=False):
super(FocalLoss, self).__init__()
self.apply_nonlin = apply_nonlin
self.alpha = alpha
self.gamma = gamma
self.balance_index = balance_index
self.smooth = smooth
self.size_average = size_average
self.cuda = cuda
if self.smooth is not None:
if self.smooth < 0 or self.smooth > 1.0:
raise ValueError('smooth value should be in [0,1]')
def forward(self, pred, target):
if self.apply_nonlin is not None:
pred = self.apply_nonlin(pred)
num_class = pred.shape[1]
#判断pred的维度是否大于2
if pred.dim() > 2:
# N,C,d1,d2 -> N,C,m (m=d1*d2*...)
#将输入的维度修改为N,C,d1,d2 -> N,C,m
pred = pred.view(pred.size(0), pred.size(1), -1)
#-->在上面的pred函数中我们得到pred的维度是N,C,m，
#-->permute函数是百年换tensor的维度 -- N,C,m --> N,m,C
#--contiguous函数会拷贝一份变换前的输入
pred = pred.permute(0, 2, 1).contiguous()
#-->同样是将输入同一输入维度--N,m,C --> N*m行C列 限定在一个矩阵内
pred = pred.view(-1, pred.size(-1))
# torch.squeeze(input,dim,out)
#--> torch.squeeze 同样是压缩数据的维度
target = torch.squeeze(target, 1)
#--> 将输出的target维度限制1列
target = target.view(-1, 1)
#print(pred.shape, target.shape)
alpha = self.alpha
if alpha is None:
#-->alpha-全1（维度为：输入类别数行，1列）
alpha = torch.ones(num_class, 1)
# isinstance() 函数，是Python中的一个内置函数，用来判断一个函数是否是一个已知的类型。
#isinstance(a,(str,int,list)) a的类型是元组中的一个，结果返回 True
#如果对象的类型与参数二的类型相同则返回 True，否则返回 False。
elif isinstance(alpha, (list, np.ndarray)):
# assert 检查程序，不符合条件即终止程序
assert len(alpha) == num_class
# 将alpha的维度限制在num_class行1列，具体数值为alpha
alpha = torch.FloatTensor(alpha).view(num_class, 1)
#alpha.sum()是一个数，因为alpha为n行一列的数，所以alpha.sum是alpha的和
alpha = alpha / alpha.sum()
elif isinstance(alpha, float):
#alpha是Num_class行1列的全一的矩阵
alpha = torch.ones(num_class, 1)
# 一般alpha取0.25，故alpha等于n行1列全是0.75的数
alpha = alpha * (1 - self.alpha)
alpha[self.balance_index] = self.alpha
else:
raise TypeError('Not support alpha type')
'''
if cuda:
alpha = torch.from_numpy(alpha).type(torch.FloatTensor).cuda()
else:
alpha = torch.from_numpy(alpha).type(torch.FloatTensor)
'''
#if alpha.device != pred.device:
alpha = alpha.to(pred.device)
#转变成long类型
idx = target.cpu().long()
one_hot_key = torch.FloatTensor(target.size(0), num_class).zero_()
one_hot_key = one_hot_key.scatter_(1, idx, 1)
#if one_hot_key.device != pred.device:
one_hot_key = one_hot_key.to(pred.device)
if self.smooth:
one_hot_key = torch.clamp(
one_hot_key, self.smooth / (num_class - 1), 1.0 - self.smooth)
pt = (one_hot_key * pred).sum(1) + self.smooth
logpt = pt.log()
gamma = self.gamma
alpha = alpha[idx]
alpha = torch.squeeze(alpha)
loss = -1 * alpha * torch.pow((1 - pt), gamma) * logpt
if self.size_average:
loss = loss.mean()
else:
loss = loss.sum()
return loss
版本二
class focal_loss(nn.Module):
def __init__(self, alpha=0.25, gamma=2, num_classes=5, size_average=True):
"""
focal_loss损失函数, -α(1-yi)**γ *ce_loss(xi,yi)
步骤详细的实现了 focal_loss损失函数.
:param alpha: 阿尔法α,类别权重. 当α是列表时,为各类别权重,当α为常数时,类别权重为[α, 1-α, 1-α, ....],常用于 目标检测算法中抑制背景类 , retainnet中设置为0.255
:param gamma: 伽马γ,难易样本调节参数. retainnet中设置为2
:param num_classes: 类别数量
:param size_average: 损失计算方式,默认取均值
"""
super(focal_loss, self).__init__()
self.size_average = size_average
if isinstance(alpha, list):
assert len(alpha) == num_classes # α可以以list方式输入,size:[num_classes] 用于对不同类别精细地赋予权重
print(" --- Focal_loss alpha = {}, 将对每一类权重进行精细化赋值 --- ".format(alpha))
self.alpha = torch.Tensor(alpha)
else:
assert alpha < 1 # 如果α为一个常数,则降低第一类的影响,在目标检测中为第一类
print(" --- Focal_loss alpha = {} ,将对背景类进行衰减,请在目标检测任务中使用 --- ".format(alpha))
self.alpha = torch.zeros(num_classes)
self.alpha[0] += alpha
self.alpha[1:] += (1 - alpha) # α 最终为 [ α, 1-α, 1-α, 1-α, 1-α, ...] size:[num_classes]
self.gamma = gamma
def forward(self, preds, labels):
"""
focal_loss损失计算
:param preds: 预测类别. size:[B,N,C] or [B,C] 分别对应与检测与分类任务, B批次, N检测框数, C类别数
:param labels: 实际类别. size:[B,N] or [B] [B*N个标签(假设框中有目标)]，[B个标签]
:return:
"""
# 固定类别维度，其余合并(总检测框数或总批次数)，preds.size(-1)是最后一个维度
preds = preds.view(-1, preds.size(-1))
self.alpha = self.alpha.to(preds.device)
# 使用log_softmax解决溢出问题，方便交叉熵计算而不用考虑值域
preds_logsoft = F.log_softmax(preds, dim=1)
# log_softmax是softmax+log运算，那再exp就算回去了变成softmax
preds_softmax = torch.exp(preds_logsoft)
# 这部分实现nll_loss ( crossentropy = log_softmax + nll)
preds_softmax = preds_softmax.gather(1, labels.view(-1, 1))
preds_logsoft = preds_logsoft.gather(1, labels.view(-1, 1))
self.alpha = self.alpha.gather(0, labels.view(-1))
# torch.pow((1-preds_softmax), self.gamma) 为focal loss中 (1-pt)**γ
# torch.mul 矩阵对应位置相乘，大小一致
loss = -torch.mul(torch.pow((1 - preds_softmax), self.gamma), preds_logsoft)
# torch.t()求转置
loss = torch.mul(self.alpha, loss.t())
# print(loss.size()) [1,5]
if self.size_average:
loss = loss.mean()
else:
loss = loss.sum()
return loss
