当前位置 主页 > 网站技术 > 代码类 >

    Pytorch 实现focal

    栏目:代码类 时间:2020-01-14 15:09

    我就废话不多说了,直接上代码吧!

    import numpy as np
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
     
     
    # 支持多分类和二分类
    class FocalLoss(nn.Module):
      """
      This is a implementation of Focal Loss with smooth label cross entropy supported which is proposed in
      'Focal Loss for Dense Object Detection. (https://arxiv.org/abs/1708.02002)'
        Focal_Loss= -1*alpha*(1-pt)^gamma*log(pt)
      :param num_class:
      :param alpha: (tensor) 3D or 4D the scalar factor for this criterion
      :param gamma: (float,double) gamma > 0 reduces the relative loss for well-classified examples (p>0.5) putting more
              focus on hard misclassified example
      :param smooth: (float,double) smooth value when cross entropy
      :param balance_index: (int) balance class index, should be specific when alpha is float
      :param size_average: (bool, optional) By default, the losses are averaged over each loss element in the batch.
      """
     
      def __init__(self, num_class, alpha=None, gamma=2, balance_index=-1, smooth=None, size_average=True):
        super(FocalLoss, self).__init__()
        self.num_class = num_class
        self.alpha = alpha
        self.gamma = gamma
        self.smooth = smooth
        self.size_average = size_average
     
        if self.alpha is None:
          self.alpha = torch.ones(self.num_class, 1)
        elif isinstance(self.alpha, (list, np.ndarray)):
          assert len(self.alpha) == self.num_class
          self.alpha = torch.FloatTensor(alpha).view(self.num_class, 1)
          self.alpha = self.alpha / self.alpha.sum()
        elif isinstance(self.alpha, float):
          alpha = torch.ones(self.num_class, 1)
          alpha = alpha * (1 - self.alpha)
          alpha[balance_index] = self.alpha
          self.alpha = alpha
        else:
          raise TypeError('Not support alpha type')
     
        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, input, target):
        logit = F.softmax(input, dim=1)
     
        if logit.dim() > 2:
          # N,C,d1,d2 -> N,C,m (m=d1*d2*...)
          logit = logit.view(logit.size(0), logit.size(1), -1)
          logit = logit.permute(0, 2, 1).contiguous()
          logit = logit.view(-1, logit.size(-1))
        target = target.view(-1, 1)
     
        # N = input.size(0)
        # alpha = torch.ones(N, self.num_class)
        # alpha = alpha * (1 - self.alpha)
        # alpha = alpha.scatter_(1, target.long(), self.alpha)
        epsilon = 1e-10
        alpha = self.alpha
        if alpha.device != input.device:
          alpha = alpha.to(input.device)
     
        idx = target.cpu().long()
        one_hot_key = torch.FloatTensor(target.size(0), self.num_class).zero_()
        one_hot_key = one_hot_key.scatter_(1, idx, 1)
        if one_hot_key.device != logit.device:
          one_hot_key = one_hot_key.to(logit.device)
     
        if self.smooth:
          one_hot_key = torch.clamp(
            one_hot_key, self.smooth, 1.0 - self.smooth)
        pt = (one_hot_key * logit).sum(1) + epsilon
        logpt = pt.log()
     
        gamma = self.gamma
     
        alpha = alpha[idx]
        loss = -1 * alpha * torch.pow((1 - pt), gamma) * logpt
     
        if self.size_average:
          loss = loss.mean()
        else:
          loss = loss.sum()
        return loss
     
     
     
    class BCEFocalLoss(torch.nn.Module):
      """
      二分类的Focalloss alpha 固定
      """
      def __init__(self, gamma=2, alpha=0.25, reduction='elementwise_mean'):
        super().__init__()
        self.gamma = gamma
        self.alpha = alpha
        self.reduction = reduction
     
      def forward(self, _input, target):
        pt = torch.sigmoid(_input)
        alpha = self.alpha
        loss = - alpha * (1 - pt) ** self.gamma * target * torch.log(pt) - \
            (1 - alpha) * pt ** self.gamma * (1 - target) * torch.log(1 - pt)
        if self.reduction == 'elementwise_mean':
          loss = torch.mean(loss)
        elif self.reduction == 'sum':
          loss = torch.sum(loss)
        return loss
     
    
    
stage/:nmap的理解与利用(初级) 琴水玉:响应式编程库RxJava初探 CallmeJust:从一个面试官的角度谈软件工程师的面试 小创:React 入门-redux 和 react-redux Mr-Tsing:Redis-第五章节-8种数据类型 leesf:Lakehouse: 统一数据仓库和高级分析的新一代开放平台 嵌入式与Linux那些事:程序员如何写一份合格的简历?(附简历模 zzssdd2:QT串口助手(三):数据接收 NeilZhang:对“微信十年产品思考”的思考 r1chard:一种获取context中keys和values的高效方法 | golang 详解修改Anaconda中的Jupyter Notebook默认工作路径的三种方式 详解如何修改jupyter notebook的默认目录和默认浏览器 SpringBoot2.0集成WebSocket实现后台向前端推送信息 详解springboot集成websocket的两种实现方式 使用numpngw和matplotlib生成png动画的示例代码 c语言程序从哪里开始执行 c++清屏函数是什么 c++中不能重载的运算符有哪些 企业需谨防域名被抢注 互联网时代创业 价值共创时代 linux远程拷贝文件命令rcp,远程文件复制 linux远程拷贝文件夹命令, scp远程拷贝文件及文件夹写法 linux远程拷贝文件断点续传(linux限速和断点续传) linux远程拷贝文件到本地命令(复制远程主机上的文件到本地) linux远程拷贝文件到本地命令及用法 利用Python函数实现一个万历表完整示例 Python字符串对齐、删除字符串不需要的内容以及格式化打印字符 Java中ArrayList集合的常用方法大全 一个简单的Spring容器初始化流程详解 js简单粗暴的发布订阅示例代码