1 focal loss的公式推导过程理解可以参考：寻找解决样本不均衡方法之Focal Loss与GHM - 知乎 (zhihu.com)
2 交叉熵损失函数的推导过程可以参考：交叉熵损失函数 - 知乎 (zhihu.com)
3 CE与BCE的区别：CE Loss 与 BCE Loss 区别 - 知乎 (zhihu.com)
l o g s o f t m a x = ln σ ( z ) j logsoftmax = \ln{\sigma(z)_{j}} logsoftmax=lnσ(z)j
n l l l o s s = − 1 N ∑ k = 1 N y k ( l o g s o f t m a x ) nllloss = - \frac{1}{N}\sum_{k=1}^Ny_{k}(logsoftmax) nllloss=−N1k=1∑Nyk(logsoftmax)
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
import torchvision
import torchvision.transforms as F
from IPython.display import display
class FocalLoss(nn.Module):
def __init__(self, weight=None, reduction='mean', gamma=0, eps=1e-7):
super(FocalLoss, self).__init__()
self.gamma = gamma
self.eps = eps
self.ce = torch.nn.CrossEntropyLoss(weight=weight, reduction=reduction)
def forward(self, input, target):
logp = self.ce(input, target)
p = torch.exp(-logp)
loss = (1 - p) ** self.gamma * logp
return loss.mean()
代码来源：Focal Loss代码分析(公式修改版-知乎公式坑) - 知乎 (zhihu.com)
代码实现的原理如下：
pytorch中交叉熵损失函数所有表达式，类比(3)
l
o
s
s
(
x
,
c
l
a
s
s
)
=
−
log
e
x
c
l
a
s
s
∑
j
e
x
j
=
−
x
c
l
a
s
s
+
log
∑
j
e
x
j
(3)
loss(x,class) = -\log{\frac{e^{x_{class}}}{\sum_{j}e^{x_j}}}= -x_{class} + \log{\sum_{j}e^{x_j}}\tag{3}
loss(x,class)=−log∑jexjexclass=−xclass+logj∑exj(3)
α-balanced交叉熵结合表达式
l
o
s
s
(
x
,
c
l
a
s
s
)
=
α
c
l
a
s
s
∗
(
−
x
c
l
a
s
s
+
log
∑
j
e
x
j
)
(4)
loss(x,class)= \alpha_{class}*(-x_{class} + \log{\sum_{j}e^{x_j}})\tag{4}
loss(x,class)=αclass∗(−xclass+logj∑exj)(4)
focal loss表达式：
l
o
s
s
(
x
,
c
l
a
s
s
)
=
(
1
−
e
x
c
l
a
s
s
∑
j
e
x
j
)
γ
−
log
e
x
c
l
a
s
s
∑
j
e
x
j
=
(
1
−
e
x
c
l
a
s
s
∑
j
e
x
j
)
γ
(
−
x
c
l
a
s
s
+
log
∑
j
e
x
j
)
=
−
(
1
−
p
t
)
γ
log
(
p
t
)
(5)
loss(x,class) =(1 - \frac{e^{x_{class}}}{\sum_{j}e^{x_j}})^{\gamma} -\log{\frac{e^{x_{class}}}{\sum_{j}e^{x_j}}} =(1 - \frac{e^{x_{class}}}{\sum_{j}e^{x_j}})^{\gamma}(-x_{class} + \log{\sum_{j}e^{x_j}}) = -(1-p_{t})^{\gamma} \log{(p_{t})}\tag{5}
loss(x,class)=(1−∑jexjexclass)γ−log∑jexjexclass=(1−∑jexjexclass)γ(−xclass+logj∑exj)=−(1−pt)γlog(pt)(5)
带有alpha平衡参数的focal loss表达式：
l
o
s
s
(
x
,
c
l
a
s
s
)
=
−
α
t
(
1
−
p
t
)
γ
log
(
p
t
)
(6)
loss(x,class) = -\alpha_{t}(1-p_{t})^{\gamma} \log{(p_{t})}\tag{6}
loss(x,class)=−αt(1−pt)γlog(pt)(6)
将CrossEntropyLoss改成Focal Loss
−
log
p
t
=
n
n
.
C
r
o
s
s
E
n
t
r
o
p
y
L
o
s
s
(
i
n
p
u
t
,
t
a
r
g
e
t
)
(7)
-\log{p_{t}} = nn.CrossEntropyLoss(input, target)\tag{7}
−logpt=nn.CrossEntropyLoss(input,target)(7)
那么：
p
t
=
t
o
r
c
h
.
e
x
p
(
−
n
n
.
C
r
o
s
s
E
n
t
r
o
p
y
L
o
s
s
(
i
n
p
u
t
,
t
a
r
g
e
t
)
)
(8)
p_{t} = torch.exp(-nn.CrossEntropyLoss(input, target))\tag{8}
pt=torch.exp(−nn.CrossEntropyLoss(input,target))(8)
所有Focal loss的最终为
f
o
c
a
l
l
o
s
s
=
−
α
t
(
1
−
p
t
)
γ
log
(
p
t
)
(9)
focalloss = -\alpha_{t}(1-p_{t})^{\gamma} \log{(p_{t})}\tag{9}
focalloss=−αt(1−pt)γlog(pt)(9)
当然考虑到是mini-batch算法，因此最后一步取均值运算。
关于使用CE与BCE的实现方法可以参考以下代码：（关于γ与α的调参也有部分解答）
一、Focal Loss理论及代码实现_MY头发乱了的博客-CSDN博客_focal loss代码实现
基于二分类交叉熵实现
# 1.基于二分类交叉熵实现
class FocalLoss(nn.Module):
def __init__(self, alpha=1, gamma=2, logits=False, reduce=True):
super(FocalLoss, self).__init__()
self.alpha = alpha
self.gamma = gamma
self.logits = logits
self.reduce = reduce
def forward(self, inputs, targets):
if self.logits:
BCE_loss = F.binary_cross_entropy_with_logits(inputs, targets, reduce=False)
else:
BCE_loss = F.binary_cross_entropy(inputs, targets, reduce=False)
pt = torch.exp(-BCE_loss)
F_loss = self.alpha * (1-pt)**self.gamma * BCE_loss
if self.reduce:
return torch.mean(F_loss)
else:
return F_loss
其他的参考资料
关于binary_cross_entropy_with_logits与binary_cross_entropy的区别可以看：
关于focal loss二分类公式的一些变形可以参考：
【论文解读】Focal Loss公式、导数、作用详解 - 知乎 (zhihu.com)
使用纯pytorch代码实现focal loss
Focal Loss 的Pytorch 实现以及实验 - 知乎 (zhihu.com)
辅助理解代码实现：
深度学习之目标检测（五）-- RetinaNet网络结构详解_木卯_THU的博客-CSDN博客_retinanet
focal loss原理及简单代码实现_pomelo33的博客-CSDN博客_focal loss代码实现
吃透torch.nn.CrossEntropyLoss() - 知乎 (zhihu.com)
如何在buildr项目中使用Ruby？我在很多不同的项目中使用过Ruby、JRuby、Java和Clojure。我目前正在使用我的标准Ruby开发一个模拟应用程序，我想尝试使用Clojure后端(我确实喜欢功能代码)以及JRubygui和测试套件。我还可以看到在未来的不同项目中使用Scala作为后端。我想我要为我的项目尝试一下buildr(http://buildr.apache.org/)，但我注意到buildr似乎没有设置为在项目中使用JRuby代码本身!这看起来有点傻，因为该工具旨在统一通用的JVM语言并且是在ruby中构建的。除了将输出的jar包含在一个独特的、仅限ruby
在rails源中:https://github.com/rails/rails/blob/master/activesupport/lib/active_support/lazy_load_hooks.rb可以看到以下内容@load_hooks=Hash.new{|h,k|h[k]=[]}在IRB中，它只是初始化一个空哈希。和做有什么区别@load_hooks=Hash.new 最佳答案 查看rubydocumentationforHashnew→new_hashclicktotogglesourcenew(obj)→new_has
我想在一个没有Sass引擎的类中使用Sass颜色函数。我已经在项目中使用了sassgem，所以我认为搭载会像以下一样简单:classRectangleincludeSass::Script::FunctionsdefcolorSass::Script::Color.new([0x82,0x39,0x06])enddefrender#hamlengineexecutedwithcontextofself#sothatwithintemlateicouldcall#%stop{offset:'0%',stop:{color:lighten(color)}}endend更新:参见上面的#re
我正在尝试用ruby中的gsub函数替换字符串中的某些单词，但有时效果很好，在某些情况下会出现此错误？这种格式有什么问题吗NoMethodError(undefinedmethod`gsub!'fornil:NilClass):模型.rbclassTest"replacethisID1",WAY=>"replacethisID2andID3",DELTA=>"replacethisID4"}end另一个模型.rbclassCheck 最佳答案 啊，我找到了!gsub!是一个非常奇怪的方法。首先，它替换了字符串，所以它实际上修改了
我有一个用户工厂。我希望默认情况下确认用户。但是鉴于unconfirmed特征，我不希望它们被确认。虽然我有一个基于实现细节而不是抽象的工作实现，但我想知道如何正确地做到这一点。factory:userdoafter(:create)do|user,evaluator|#unwantedimplementationdetailshereunlessFactoryGirl.factories[:user].defined_traits.map(&:name).include?(:unconfirmed)user.confirm!endendtrait:unconfirmeddoenden
我有一些代码在几个不同的位置之一运行:作为具有调试输出的命令行工具，作为不接受任何输出的更大程序的一部分，以及在Rails环境中。有时我需要根据代码的位置对代码进行细微的更改，我意识到以下样式似乎可行:print"Testingnestedfunctionsdefined\n"CLI=trueifCLIdeftest_printprint"CommandLineVersion\n"endelsedeftest_printprint"ReleaseVersion\n"endendtest_print()这导致:TestingnestedfunctionsdefinedCommandLin
我的主要目标是能够完全理解我正在使用的库/gem。我尝试在Github上从头到尾阅读源代码，但这真的很难。我认为更有趣、更温和的踏脚石就是在使用时阅读每个库/gem方法的源代码。例如，我想知道RubyonRails中的redirect_to方法是如何工作的:如何查找redirect_to方法的源代码？我知道在pry中我可以执行类似show-methodmethod的操作，但我如何才能对Rails框架中的方法执行此操作？您对我如何更好地理解Gem及其API有什么建议吗？仅仅阅读源代码似乎真的很难，尤其是对于框架。谢谢! 最佳答案 Ru
我的假设是moduleAmoduleBendend和moduleA::Bend是一样的。我能够从thisblog找到解决方案,thisSOthread和andthisSOthread.为什么以及什么时候应该更喜欢紧凑语法A::B而不是另一个，因为它显然有一个缺点？我有一种直觉，它可能与性能有关，因为在更多命名空间中查找常量需要更多计算。但是我无法通过对普通类进行基准测试来验证这一点。 最佳答案 这两种写作方法经常被混淆。首先要说的是，据我所知，没有可衡量的性能差异。(在下面的书面示例中不断查找)最明显的区别，可能也是最著名的，是你的
几个月前，我读了一篇关于rubygem的博客文章，它可以通过阅读代码本身来确定编程语言。对于我的生活，我不记得博客或gem的名称。谷歌搜索“ruby编程语言猜测”及其变体也无济于事。有人碰巧知道相关gem的名称吗？ 最佳答案 是这个吗:http://github.com/chrislo/sourceclassifier/tree/master 关于ruby-寻找通过阅读代码确定编程语言的rubygem？，我们在StackOverflow上找到一个类似的问题：
我目前正在使用以下方法获取页面的源代码:Net::HTTP.get(URI.parse(page.url))我还想获取HTTP状态，而无需发出第二个请求。有没有办法用另一种方法做到这一点？我一直在查看文档，但似乎找不到我要找的东西。 最佳答案 在我看来，除非您需要一些真正的低级访问或控制，否则最好使用Ruby的内置Open::URI模块:require'open-uri'io=open('http://www.example.org/')#=>#body=io.read[0,50]#=>"["200","OK"]io.base_ur