精华内容
参与话题
问答
  • fp16和fp32

    千次阅读 2019-10-07 13:05:11
    1)TensorRT的FP16与FP32相比能有接近一倍的速度提升168,前提是GPU支持FP16(如最新的2070,2080,2080ti等) 2)减少显存。 缺点: 1) 会造成溢出 因此,在日常使用过程中,常使用双混合精度训练。如图: ...

    float : 1个符号位、8个指数位和23个尾数位

     

    利用fp16 代替 fp32

    优点:

    1)TensorRT的FP16与FP32相比能有接近一倍的速度提升168,前提是GPU支持FP16(如最新的2070,2080,2080ti等)

    2)减少显存。

     

    缺点:

    1) 会造成溢出

     

    因此,在日常使用过程中,常使用双混合精度训练。如图:

    此过程中的技术:

    1) Loss scaling  :会存在很多梯度在FP16表达范围外,我们为了让其落入半精度范围内,会给其进行等比放大后缩小。

    流程:

     

     

    展开全文
  • fp16与fp32简介与试验

    千次阅读 2020-05-02 01:38:42
    一、fp16和fp32介绍 fp16是指采用2字节(16位)进行编码存储的一种数据类型;同理fp32是指采用4字节(32位); 如上图,fp16第一位表示+-符号,接着5位表示指数,最后10位表示分数; 公式: 其中,sign位...

     

    目录

    一、fp16和fp32介绍

    二、为什么应用fp16训练:

    三、应用fp16存在问题

    四、实践对比

    引用:


    一、fp16和fp32介绍

    • fp16是指采用2字节(16位)进行编码存储的一种数据类型;同理fp32是指采用4字节(32位);

    • 如上图,fp16第一位表示+-符号,接着5位表示指数,最后10位表示分数;
      • 公式:

      • 其中,sign位表示正负,exponent位表示指数(  ),fraction位表示的是分数(  )。其中当指数为零的时候,下图加号左边为0,其他情况为1。
      • 具体计算情况可分为下面三种:

      • Exp:

      • 所以可以计算出,fp16值动态区间:精度其实为

         

         

      • fp32值动态区间:

    二、为什么应用fp16训练:

    • fp16和fp32相比对训练的优化:
      • 1.内存占用减少:很明显,应用fp16内存占用比原来更小,可以设置更大的batch_size
      • 2.加速计算:加速计算只在最近的一些新gpu中,这一块我还没有体验到好处...有论文指出fp16训练速度可以是fp32的2-8倍

    三、应用fp16存在问题

    • 由于fp16的值区间比fp32的值区间小很多,所以在计算过程中很容易出现上溢出(Overflow,>65504 )和下溢出(Underflow,<6x10^-8  )的错误,溢出之后就会出现“Nan”的问题
    • 借用别人例子:

    • 解决办法:
      • 1.混合精度加速:简单的讲就是使用fp16进行乘法和存储,只使用fp32进行加法操作,避免累加误差;
      • 2.损失放大化:
        • 反向传播前,将损失变化(dLoss)手动增大  倍,因此反向传播时得到的中间变量(激活函数梯度)则不会溢出;
        • 反向传播后,将权重梯度缩  倍,恢复正常值。

    四、实践对比

    实践代码:

    from apex import amp
    model, optimizer = amp.initialize(model, optimizer, opt_level="O1") # 这里是“欧一”,不是“零一”
    with amp.scale_loss(loss, optimizer) as scaled_loss:
        scaled_loss.backward()
    • 这里我直接应用fairseq代码的fp16参数:gpu用1080Ti简单试验了下
      • fp16:

      • fp32:

      • 总结:1080Ti应用fp16确实可以省内存,但是理论上是不能加速的啊,这里小朋友有比较多问号???
    • 混合精度加速,需要用到 Volta 结构的GPU,只有V100 和 TITAN V 系列是支持 TensorCore 加速计算

    引用:

     

    展开全文
  • 数据挖掘进阶之关联规则挖掘FP-Growth算法 绪 近期在写论文方面涉及到了数据挖掘,需要通过数据挖掘方法实现软件与用户间交互模式的获取、分析与分类研究。主要涉及到关联规则与序列模式挖掘两块。关联规则挖掘使用...

    数据挖掘进阶之关联规则挖掘FP-Growth算法

    近期在写论文方面涉及到了数据挖掘,需要通过数据挖掘方法实现软件与用户间交互模式的获取、分析与分类研究。主要涉及到关联规则与序列模式挖掘两块。关联规则挖掘使用基于有趣性度量标准的FP-Growth算法,序列模式挖掘使用基于有趣性度量标准的GSP算法。若想实现以上优化算法,首先必须了解其基本算法,并编程实现。关键点还是在于理解算法思想,只有懂得了算法思想,对其进行优化操作易如反掌。源代码方面,其实是自己从网络中查找并进行阅读,在理解的基础上进行优化。下面首先介绍一下基本的FP-Growth算法的实现过程:

    原理介绍

    基本思路:不断地迭代FP-tree的构造和投影过程。

    对于每个频繁项,构造它的条件投影数据库和投影FP-tree。对每个新构建的FP-tree重复这个过程,直到构造的新FP-tree为空,或者只包含一条路径。当构造的FP-tree为空时,其前缀即为频繁模式;当只包含一条路径时,通过枚举所有可能组合并与此树的前缀连接即可得到频繁模式。

    算法实现

    本算法采用Java实现,主要根据序列模式的情况,算法共有2个类:

    MyFptree类:算法核心类。FP-Growth算法的核心操作:建树挖掘频繁项操作都在这里实现。在使用该算法时,也是需要通过使用该类的方法来实现GSP算法。

    TreeNode2类:元素类。在本算法实现中,元素类中含有元素属性集,在使用时也是使用该属性。另外,在该类中还封装了对元素的操作以及一些其他操作。

    有关源码请点击下载

    有关序列模式挖掘的GSP算法,详见鄙人博客中“数据挖掘进阶之序列模式挖掘GSP算法”一文。

    展开全文
  • FP-growth:FP树的构建

    2020-02-15 17:55:13
    FP-growth是一个非常好的频繁项集发现算法,广泛应用于搜索引擎中(找出经常在一起出现的词对)相对于Apriori算法,FP-growth算法只用对数据库进行两次扫描,因此更适用于处理大数据。 关于FP-growth的理解,请参照...

    前言

    FP-growth是一个非常好的频繁项集发现算法,广泛应用于搜索引擎中(找出经常在一起出现的词对)相对于Apriori算法,FP-growth算法只用对数据库进行两次扫描,因此更适用于处理大数据。

    本文以代码为主。关于FP-growth的理解,请参照这个网址:https://www.cnblogs.com/pinard/p/6307064.html
    我自认是没有这个能力写的这么好的哈哈。

    FP-growth算法主要分成两部分:FP树的构建从FP树中挖掘频繁项集。本文主要介绍FP树的构建。

    FP树的构建

    这里,就假设大家已经了解了FP树是什么玩意了。在这里插入图片描述
    那么,就先从创建结点开始吧!

    FP树结点

    仔细观察上图,发现FP树的结点包括了以下信息:

    • name:结点的名字。比如图中的null, A等
    • count: 名字对应的计数值
    • nodelink:同名字结点之间的link。比如图中的虚线箭头
    • parent:父结点
    • children:子节点

    另外,还需要两个方法:

    • inc方法:用来更新该结点的计数值(在向树中插入事务时)
    • disp方法:将树以文本形式显示(对调试很有用)

    话不多说,直接上代码~

    class treeNode:
        def __init__(self, nameValue, numOccur, parentNode):
            self.name = nameValue
            self.count = numOccur
            self.nodeLink = None
            self.parent = parentNode
            self.children = {}
    
        def inc(self, numOccur):
            self.count += numOccur
    
        def disp(self, ind=1):
            print(' ' * ind, self.name, self.count)
            for child in self.children.values():
                child.disp(ind+1)
    
    

    构建FP树

    前文说过,FP-growth算法一共需要遍历两次数据集,那么究竟是哪两次呢

    第一步:遍历数据集,获得每个元素项的出现频率,并去掉不满足最小支持度的元素项,生成头指针表。打个比方,假设有以下事务:
    原始事务
    给定最小支持度为3,则生成的头指针表为:
    头指针表
    你问还有一些元素项去哪了?它们都因为出现频率小于最小支持度而被删除了。

    第二步:遍历数据集,根据头指针表,把数据集中的每一条事务中的元素按照其出现频率重新排序,并且删去没有出现在头指针表中的元素。再举个比方:
    过滤和重排后事务
    以事务1为例,首先元素项h, j, p未出现在头指针表中(也就是出现频率小于最小支持度),故被删除。而在头指针表中z排在r前面,因此处理后的事务1为z, r

    第三步,就是将处理后的事务,挨个插入FP树中啦。

    接下来就是代码部分。我不想像书上那样,把代码先放上来,再做阐释。我会先解释一下每个方法的作用,再给出代码,这样或许能好理解一点~不想看啰里啰唆的可以直接划到下面看代码哈

    FP构建函数一共有三个方法:

    方法1:createTree方法

    createTree方法有以下几个功能

    • 遍历数据集,构建头指针表headerTable和频繁项集freqItemSet
    • 遍历数据集,根据头指针表对原事务数据集进行过滤和重排,对处理后的事务oderedItems, 调用updateTree方法来更新树。

    代码如下:

    # 传入的数据集其实是个字典,key值为事务, value值为数据集中该事务的频次
    def createTree(dataSet, minSup=3):          
        headerTable = {}
        for trans in dataSet:
            for item in trans:
                headerTable[item] = headerTable.get(item, 0) + dataSet[trans]
                # 遍历数据集,构建headerTabel。其key为元素,value为元素出现频次
        for k in list(headerTable.keys()):
            # 如果元素频次小于最小支持度,则删去
            if headerTable[k] < minSup:
                del headerTable[k]              
        freqItemSet = set(headerTable.keys())
        if len(freqItemSet) == 0:
            return None, None
        for k in headerTable:
            # 拓展头指针表,第二项存储着指向该元素在树中第一次出现位置的指针
            headerTable[k] = [headerTable[k], None]
            # 建一棵空树
        retTree = treeNode('Null Set', 1, None)       
        for tranSet, count in dataSet.items():
            # localD存储过滤后的数据集
            localD = {}                          
            for item in tranSet:
                if item in freqItemSet:
                    localD[item] = headerTable[item][0]
            if len(localD) > 0:
                # orderedItems存储过滤并重排序后的数据集
                orderedItems = [v[0] for v in sorted(localD.items(),
                                                    key=lambda p: p[1], reverse=True)]  
                updateTree(orderedItems, retTree,
                               headerTable, count)   
        return retTree, headerTable
    

    方法2:updateTree方法

    (该部分最好一边画FP树再一边看)
    updateTree是一个不断迭代的方法,它对orderedItem列表中第一个元素进行处理,最后删去该元素,然后再对新的orderedItem调用updateTree方法。

    该函数首先测试第一个元素是否是作为子节点存在(从这里就看出为什么要对事务进行重排序了)。若是存在,则更新该元素的计数;若不存在,则创建一个treeNode并将其作为子节点添加到树中。

    之后,头指针表也会更新,调用updateHeader方法。可能你会问为什么要更新头指针表?这个问题在updateHeader方法里面再解释哈。

    def updateTree(items, inTree, headerTable, count):
        # 如果第一个元素项作为子节点存在,则更新计数值
        if items[0] in inTree.children:                                  
            inTree.children[items[0]].inc(count)
        else:
            # 否则创建一个新的子节点
            inTree.children[items[0]] = treeNode(items[0], count, inTree)
            # 如果在头指针表里该元素还没有指向的指针(即树上还没有出现该元素)
            if headerTable[items[0]][1] is None:                        
                headerTable[items[0]][1] = inTree.children[items[0]]
            else:
                updateHeader(headerTable[items[0]][1],
                             inTree.children[items[0]])
        # 如果事务中不止一个元素,则去掉第一个元素,再迭代
        if len(items) > 1:                                              
            updateTree(items[1::], inTree.children[items[0]],
                                       headerTable, count)
                                     
    

    方法3:updateHeader方法

    前面说过,头指针表headTable里面不仅存储着频繁元素,还存储着指向树中第一次出现该元素的指针。
    同时,大家如果仔细观察FP树的话,会发现树中同一个元素会有虚线相连,结点类中也有对应的属性,叫nodelink
    所以,updateHeader方法的作用就是:

    对于结点inTree.children[items[0]]和其对应元素, 此时在头指针表里该元素有指针存在(即树中已经有了该元素的存在),把这个元素所在结点和该元素上一次出现的结点“连”起来
    至于怎么找到该元素上一次出现的结点嘛~

    代码如下:

    def updateHeader(nodeToTeset, targetNode):
        while nodeToTeset.nodeLink is not None:
            nodeToTeset = nodeToTeset.nodeLink
        nodeToTeset.nodeLink = targetNode
    

    简单的数据集

    树的构建已经大功告成了,接下来我们只要创建一个数据集就可了。
    注意,我们要导入的不是事务的列表,而是一个键为事务,键值为事务出现频次的数据字典
    因此我们需要对原始数据集进行一番处理
    代码如下:

    def loadSimpDat():
        simpDat = [['r', 'z', 'h', 'j', 'p'],
                   ['z', 'y', 'x', 'w', 'v', 'u', 't', 's'],
                   ['z'],
                   ['r', 'x', 'n', 'o', 's'],
                   ['y', 'r', 'x', 'z', 'q', 't', 'p'],
                   ['y', 'z', 'x', 'e', 'q', 's', 't', 'm']]
        return simpDat
    
    
    def createInitSet(dataSet):
        retDict = {}
        for trans in dataSet:
            retDict[frozenset(trans)] = 1
        return retDict
    

    完整代码

    下面贴出完整代码:

    class treeNode:
        def __init__(self, nameValue, numOccur, parentNode):
            self.name = nameValue
            self.count = numOccur
            self.nodeLink = None
            self.parent = parentNode
            self.children = {}
    
        def inc(self, numOccur):
            self.count += numOccur
    
        def disp(self, ind=1):
            print(' ' * ind, self.name, self.count)
            for child in self.children.values():
                child.disp(ind+1)
    
    # 传入的数据集其实是个字典,key值为事务, value值为数据集中该事务的频次
    def createTree(dataSet, minSup=3):
        headerTable = {}
        for trans in dataSet:
            for item in trans:
                headerTable[item] = headerTable.get(item, 0) + dataSet[trans]
                # 遍历数据集,构建headerTabel。其key为元素,value为元素出现频次
        for k in list(headerTable.keys()):
            # 如果元素频次小于最小支持度,则删去
            if headerTable[k] < minSup:
                del headerTable[k]
        freqItemSet = set(headerTable.keys())
        if len(freqItemSet) == 0:
            return None, None
        for k in headerTable:
            # 拓展头指针表,第二项存储着指向该元素在树中第一次出现位置的指针
            headerTable[k] = [headerTable[k], None]
            # 建一棵空树
        retTree = treeNode('Null Set', 1, None)
        for tranSet, count in dataSet.items():
            # localD存储过滤后的数据集
            localD = {}
            for item in tranSet:
                if item in freqItemSet:
                    localD[item] = headerTable[item][0]
            if len(localD) > 0:
                # orderedItems存储过滤并重排序后的数据集
                orderedItems = [v[0] for v in sorted(localD.items(),
                                                    key=lambda p: p[1], reverse=True)]
                updateTree(orderedItems, retTree,
                               headerTable, count)
        return retTree, headerTable
    
    
    def updateTree(items, inTree, headerTable, count):
        # 如果第一个元素项作为子节点存在,则更新计数值
        if items[0] in inTree.children:
            inTree.children[items[0]].inc(count)
        else:
            # 否则创建一个新的子节点
            inTree.children[items[0]] = treeNode(items[0], count, inTree)
            # 如果在头指针表里该元素还没有指向的指针(即树上还没有出现该元素)
            if headerTable[items[0]][1] is None:
                headerTable[items[0]][1] = inTree.children[items[0]]
            else:
                updateHeader(headerTable[items[0]][1],
                             inTree.children[items[0]])
        # 如果事务中不止一个元素,则去掉第一个元素,再迭代
        if len(items) > 1:
            updateTree(items[1::], inTree.children[items[0]],
                                       headerTable, count)
    
    
    def updateHeader(nodeToTeset, targetNode):
        while nodeToTeset.nodeLink is not None:
            nodeToTeset = nodeToTeset.nodeLink
        nodeToTeset.nodeLink = targetNode
    
    
    def loadSimpDat():
        simpDat = [['r', 'z', 'h', 'j', 'p'],
                   ['z', 'y', 'x', 'w', 'v', 'u', 't', 's'],
                   ['z'],
                   ['r', 'x', 'n', 'o', 's'],
                   ['y', 'r', 'x', 'z', 'q', 't', 'p'],
                   ['y', 'z', 'x', 'e', 'q', 's', 't', 'm']]
        return simpDat
    
    
    def createInitSet(dataSet):
        retDict = {}
        for trans in dataSet:
            retDict[frozenset(trans)] = 1
        return retDict
    
    
    simpDat = loadSimpDat()
    initSet = createInitSet(simpDat)
    myFPtree, myHeaderTab = createTree(initSet, 3)
    myFPtree.disp()
    
    

    生成的结果如下:

    Null Set 1
       z 5
        r 1
        x 3
         s 2
          t 2
           y 2
         r 1
          t 1
           y 1
       x 1
        s 1
         r 1
    

    其中每个缩进表示所处的树的深度

    FP树的构建到此结束。至于怎么从树中挖掘频繁项集,请听下回分解~

    本文的代码来自《机器学习实战》的第12章

    展开全文
  • FPTree 理解

    千次阅读 多人点赞 2018-10-08 10:39:33
    FP Tree算法原理总结  在Apriori算法原理总结中,我们对Apriori算法的原理做了总结。作为一个挖掘频繁项集的...为了解决这个问题,FP Tree算法(也称FP Growth算法)采用了一些技巧,无论多少数据,只需要扫描两...
  • FP增长算法(FP Growth Algorithm)

    千次阅读 2017-03-03 10:23:08
    FP增长算法
  • FP-growth

    2019-06-24 18:17:32
    文章目录Fp-growth不用生成候选集用交易数据库建立FP-treeFP-tree结构的好处用FP-tree挖掘频繁集挖掘FP-tree 的主要步骤1. 从FP-tree到条件模式库2. 建立条件FP-tree3. 递归挖掘条件FP-tree频繁增长的原理为什么频繁...
  • FILE *fp

    千次阅读 2019-07-18 11:22:04
    FILE *fp 是声明,声明fp是指针,用来指向FILE类型的对象。 *fp是指向文件结构体的指针变量,通过fp可找到存放某个文件信息的结构变量,根据这个结构变量的信息找到该文件,实施对文件的操作。fp通常被成为一个指向...
  • 用TensorRT转换到INT8不成功的原因:使用了不支持的层,尽量使用默认的Conv或者BatchNorm来做 ...转换到fp16训练:使用英伟达自带的apex库,有个fp16util的代码,还有一个amp(混合精度)的代码,都可以用 ...
  • 从retail.dat文件中读取大量的数据,其中每一行代表一条交易记录。...④从FPTree的头表HashL1开始,按照每个频繁项的连接遍历FPTree ⑤遍历单个频繁项的链表找到所有前缀路径def PrePath,得到条件模式库ConPatBas...
  • 在GPU上,FP16最快。 测试环境:intel core i5 8500 应用:human_pose_estimation_demo 模型:human-pose-estimation-0001 数据:MOT16/test/MOT16-06 耗时(ms) CPU GPU FP16-INT8 124559 179275 FP16 ...
  • FPgrowth

    2017-04-18 10:05:41
    ************************FPgrowth概述和apirior的比较*********************************  频繁项集挖掘算法用于挖掘经常一起出现的item集合(称为频繁项集),通过挖掘出这些频繁项集,当在一个事务中出现频繁...
  • FP腔调研

    千次阅读 2019-05-18 18:38:09
    FP腔调研报告参考论文FP腔制作流程该文章中涉及到的两种FP腔结构Silica capillary encapsulated 125 μm F-P sensorSilica capillary encapsulated 50 μm F-P sensor如何改变文本的样式插入链接与图片如何插入一段...
  • 人脸数据集:CFP

    2018-11-07 16:37:59
    人脸数据集CFP:CFP consists of 500 subjects each with 10 frontal and 4 profile images. The evaluation protocol includes frontal-frontal (FF) and frontal-profile (FP) face verification, each ...
  • FP_TREE和FP_GROWTH算法

    2017-09-12 21:38:36
     FP树构造  FP Growth算法利用了巧妙的数据结构,大大降低了Aproir挖掘算法的代价,它不需要不断地生成候选项目队列和不断得扫描整个数据库进行比对。为了达到这样的效果,它采用了一种简洁的数据结构,叫做...
  • 获取京东的eid和fp

    千次阅读 多人点赞 2020-12-30 20:57:25
    在京东的购物车F12调出开发者模式 选择商品,点击结算,进入结算页面后。 在结算页面F12的Sources内右侧watch,点击加号填入_JdTdudfp,即可看到该参数的内容,edi与fp均在其中
  • FP Tree算法原理

    千次阅读 多人点赞 2019-06-17 09:59:57
    为了解决这个问题,FP Tree算法(也称FP Growth算法)采用了一些技巧,无论多少数据,只需要扫描两次数据集,因此提高了算法运行的效率。下面我们就对FP Tree算法做一个总结。 1. FP Tree数据结构 为了减少 I/O ...
  • 100G QSFP28与CFP,CFP2,CFP4光模块的比较 https://www.eefocus.com/etulink/blog/17-09/423967_5c520.html 数据中心网络发展真快. 在100G QSFP28光模块(一种可用来支持100G传输...
  • FP-Growth算法之FP-tree的构造(python)

    千次阅读 2015-07-04 00:18:33
    前言:关于 FP-Growth 算法介绍请见:FP-Growth算法的介绍。 本文主要介绍 FP-tree 的构造算法,关于伪代码请查看上面的文章。上接:FP-Growth算法python实现;下接:FP-Growth算法之频繁项集的挖掘(python)。 ...
  • Python实现FP

    千次阅读 2019-02-20 21:37:32
    FP树是用来挖掘最大频繁k项集的一种数据结构,相对来说难度较大,因为在前辈们的博客中,对于FP树的实现讲的是比较清楚了,但是对于FP的编程思路却提的很少。在这里做一个简单的梳理。 FP树的基础知识 首先请花...
  • FP-growth算法,fpgrowth算法详解

    万次阅读 2016-01-15 08:40:32
    FP-growth算法,fpgrowth算法详解 使用FP-growth算法来高效发现频繁项集 前言 你用过搜索引擎挥发现这样一个功能:输入一个单词或者单词的一部分,搜索引擎酒会自动补全查询词项,用户甚至实现都不知道搜索引擎...
  • paper的实验一个想法是对fp-tree进行改进,所以对spark里面的 fp-tree源码进行理解。记录一下。 资料:https://blog.csdn.net/LULIN60/article/details/52255242?utm_source=blogxgwz0 关于fp-tree的结点 /** ...
  • tensorflow fp16训练

    千次阅读 2019-05-02 21:48:00
    在混合精度训练中,权重,激活值和梯度是保存成fp16的形式,为了能够匹配fp32的网络精度,有一个权重的fp32的master copy。 在tensorflow中的具体实现 tensorflow支持fp16的存储和tensor计算。包含tf.float16...
  • FP16和FP32与INT8占位和计算问题

    千次阅读 2019-08-01 17:47:07
    FP32占用4个字节,共32位,其中1位为符号位,8为指数位,23为尾数位。 FP16占用2个字节,共16位,其中1位为符号位,5位指数位,十位有效数字位。 符号位:0为正,1为负。 指数位的计算方式为: 取基底数加上后面...
  • Spark MLlib中FPGrowth和FPTree详解之二

    千次阅读 2016-08-20 20:35:49
    这一章节,主要介绍FPGrowth源码,以及运行过程演示 2.3 FPGrowth源码详解 run方法是FPGrowth的入口函数,其代码注释如下: /**  * Computes an FP-Growth model that contains frequent itemsets.  * @...
  • python “fp.readline” vs “fp.readlines”使用 fp.readline 可能会无法识别行尾符和EOF,推荐使用 fp.readlines
  • FP-growth算法

    2017-11-08 21:09:50
    demo 代码:传送门引言上次...而本次分享的FP-growth(frequent patten)算法就能高效地发现频繁项集。 那么在现实生活中,是否存在应用FP-growth算法的产品呢?答案是存在的,如下图所示: 上图中,我们在Google搜

空空如也

1 2 3 4 5 ... 20
收藏数 33,409
精华内容 13,363
关键字:

fp