diff --git a/2020/01/19/King Back/index.html b/2020/01/19/King Back/index.html index 5d0d273a..3f60a6ad 100644 --- a/2020/01/19/King Back/index.html +++ b/2020/01/19/King Back/index.html @@ -508,7 +508,7 @@

  • - 编译原理 + 数据库系统
  • @@ -516,15 +516,15 @@

  • - Hexo + 编译原理
  • - 数据库系统 + Go
  • - Go + Hexo
  • diff --git "a/2020/03/15/\347\274\226\347\240\201/index.html" "b/2020/03/15/\347\274\226\347\240\201/index.html" index bee1aedf..d10c4ed5 100644 --- "a/2020/03/15/\347\274\226\347\240\201/index.html" +++ "b/2020/03/15/\347\274\226\347\240\201/index.html" @@ -211,12 +211,11 @@

    数值数据表示的三要素：
    1.进位计数制
    2.定点、浮点表示
    3.如何用二进制编码
    即：要确定一个数值数据的值必须先确定这三个要素。
    例如机器数 01011001的值是多少？答案是不知道

    -

    原码

    原码范围:-127~+127

    - -

    [+127]=01111111
    [-127]=11111111
    0有两种：
    [+0]=00000000
    [-0]=10000000

    +

    原码

    原码范围:-127~+127

    [+127]=01111111
    [-127]=11111111
    0有两种：
    [+0]=00000000
    [-0]=10000000

    反码

    $X原->X反$
    正数：X反=X原
    负数： X原符号位为1，数值为按位取反
    反码范围：-127~+127
    [+127]=01111111
    [-127]=10000000
    0有两种：
    [+0]=00000000
    [-0]=11111111

    -

    补码

    $X原->X补$
    正数：X补=X原
    负数：符号位为1，数值为按位取反，末尾加1
    补码范围：**-128~+127**
    [+127]=01111111
    [-128]=10000000
    [-1] = 11111111
    0只有一种表示[+0]补=[-0]补=00000000

    -

    移码

    移码通常表示浮点数的阶码
    移码一般为整数，故移码通常只用于表示整数
    对定点正数，阶码为n，他的移码是：
    $$X_移=2^{n-1}+X_原$$
    0的移码和补码一样
    $X原->X移$
    正数：将原码符号位一起变反
    负数：将原码连同符号位一起变反，末尾再加1
    $X补->X移$
    符号相反，数值位相同
    移码的表示范围与补码一致：-128~+127

    +

    补码

    $X原->X补$
    正数：X补=X原
    负数：符号位为1，数值为按位取反，末尾加1
    补码范围：-128~+127
    [+127]=01111111
    [-128]=10000000
    [-1] = 11111111
    0只有一种表示[+0]补=[-0]补=00000000

    +

    移码

    移码通常表示浮点数的阶码
    移码一般为整数，故移码通常只用于表示整数
    对定点正数，阶码为n，他的移码是：

    +

    0的移码和补码一样
    $X原->X移$
    正数：将原码符号位一起变反
    负数：将原码连同符号位一起变反，末尾再加1
    $X补->X移$
    符号相反，数值位相同
    移码的表示范围与补码一致：-128~+127

    定点数

    数的小数点固定在同一位置不变

    1.带符号的定点小数

    约定所有数的小数点的位置，固定在符号位之后
    符号位+“.”+数值位

    字长n+1位时，表示范围是$-(1-2^{-n})=>(1-2^{-n})$

    2.带符号的定点整数

    小数点固定在最低数值位之后
    符号位+数值位+“.”

    @@ -527,7 +526,7 @@
    - 编译原理 + 数据库系统

  • @@ -535,15 +534,15 @@
    - Hexo + 编译原理
  • - 数据库系统 + Go
  • - Go + Hexo
  • diff --git "a/2020/07/09/\344\272\272\345\210\260\345\244\247\344\272\214\344\272\272\347\224\237\350\277\267\350\214\253\357\274\210\344\270\223\344\270\232\346\225\231\350\202\262\350\242\253\350\277\253\345\206\231\346\226\207\357\274\211/index.html" "b/2020/07/09/\344\272\272\345\210\260\345\244\247\344\272\214\344\272\272\347\224\237\350\277\267\350\214\253\357\274\210\344\270\223\344\270\232\346\225\231\350\202\262\350\242\253\350\277\253\345\206\231\346\226\207\357\274\211/index.html" index 64955baa..29def302 100644 --- "a/2020/07/09/\344\272\272\345\210\260\345\244\247\344\272\214\344\272\272\347\224\237\350\277\267\350\214\253\357\274\210\344\270\223\344\270\232\346\225\231\350\202\262\350\242\253\350\277\253\345\206\231\346\226\207\357\274\211/index.html" +++ "b/2020/07/09/\344\272\272\345\210\260\345\244\247\344\272\214\344\272\272\347\224\237\350\277\267\350\214\253\357\274\210\344\270\223\344\270\232\346\225\231\350\202\262\350\242\253\350\277\253\345\206\231\346\226\207\357\274\211/index.html" @@ -519,7 +519,7 @@

  • - 编译原理 + 数据库系统
  • @@ -527,15 +527,15 @@

  • - Hexo + 编译原理
  • - 数据库系统 + Go
  • - Go + Hexo
  • diff --git "a/2020/07/10/Hexo\345\215\232\345\256\242\346\220\255\345\273\272/index.html" "b/2020/07/10/Hexo\345\215\232\345\256\242\346\220\255\345\273\272/index.html" index fdde794e..52251f4e 100644 --- "a/2020/07/10/Hexo\345\215\232\345\256\242\346\220\255\345\273\272/index.html" +++ "b/2020/07/10/Hexo\345\215\232\345\256\242\346\220\255\345\273\272/index.html" @@ -217,7 +217,7 @@

    -

    Hexo博客搭建

    鸽了半年的hexo博客搭建，阿里云都快过了半年了，把自己的一些踩坑和修改写一下吧，首先放一下我hexo博客搭建的时候的一些参考吧，这几个链接应该按道理没有很多踩坑的地方，我使用的主题是yilia主题所以说下面几个链接主要是关于yilia的，不过其实hexo博客框架的那个js和css名字都一样，配置文件的语法和格式也是一致的，所以说还是可以提供到一些帮助的，而且我自己在搭建一些操作的时候也学习了其他主题的一些方法。
    从0开始搭建一个hexo博客无坑教程，是真的无坑版本，一切顺利（这里需要感谢一位b站的良心up主codesheep，他其他的视频也不错哦）：
    手把手教你从0开始搭建自己的个人博客 |无坑版视频教程| hexo
    美化相关链接：

    +

    Hexo博客搭建

    鸽了半年的hexo博客搭建，阿里云都快过了半年了，把自己的一些踩坑和修改写一下吧，首先放一下我hexo博客搭建的时候的一些参考吧，这几个链接应该按道理没有很多踩坑的地方，我使用的主题是yilia主题所以说下面几个链接主要是关于yilia的，不过其实hexo博客框架的那个js和css名字都一样，配置文件的语法和格式也是一致的，所以说还是可以提供到一些帮助的，而且我自己在搭建一些操作的时候也学习了其他主题的一些方法。
    从0开始搭建一个hexo博客无坑教程，是真的无坑版本，一切顺利（这里需要感谢一位b站的良心up主codesheep，他其他的视频也不错哦）：
    手把手教你从0开始搭建自己的个人博客 |无坑版视频教程| hexo
    美化相关链接：

    • 参考链接1
    • 参考链接2
      • @@ -226,18 +226,10 @@

      安装git，nodejs

      安装git和nodejs这个我就不过多介绍了，大家去csdn找找最新的相关安装教程就行了，在codesheep的视频里面也有教大家怎么做，记得切换一下node源到淘宝镜像cnpm，有的时候npm下载特别慢或者是报错。2024-10-9更新：安装node现在最好使用nvm安装管理node版本，再来通过npm装hexo

      -

      官网下载hexo博客框架

      hexo官网，如果在hexo的使用过程有什么问题也可以去看hexo的官方文档
      在这里插入图片描述
      在git或者cmd下面都可以使用该命令完成hexo博客的安装

      -
      npm install -g hexo-cli#建议用这个全局安装
      -

      高级用户可能更喜欢安装和使用hexo软件包。

      -
      npm install hexo
      -

      初始化hexo博客

      安装Hexo后，输入以下命令以创建一个新文件夹初始化Hexo，注意这个文件夹就是我们的以后存放博客等各种主题等配置文件的文件夹了，如果配置过程博客出了问题，重新建一个新文件夹就行了，问题不大，注意信息备份。

      -
      hexo init <folder>
      cd <folder>
      npm install
      -

      npm instal以后目录中会出现这些文件

      +

      官网下载hexo博客框架

      hexo官网，如果在hexo的使用过程有什么问题也可以去看hexo的官方文档
      在这里插入图片描述
      在git或者cmd下面都可以使用该命令完成hexo博客的安装

      npm install -g hexo-cli#建议用这个全局安装

      高级用户可能更喜欢安装和使用hexo软件包。
      npm install hexo

      +

      初始化hexo博客

      安装Hexo后，输入以下命令以创建一个新文件夹初始化Hexo，注意这个文件夹就是我们的以后存放博客等各种主题等配置文件的文件夹了，如果配置过程博客出了问题，重新建一个新文件夹就行了，问题不大，注意信息备份。

      hexo init <folder>
      cd <folder>
      npm install

      npm instal以后目录中会出现这些文件

      ├── _config.yml  最重要的配置文件
      ├── package.json
      ├── scaffolds
      ├── source 这里会存放你的博客文件
      |   ├── _drafts
      |   └── _posts
      └── themes 这里存放各种主题
      - -

      这样完了以后其实我们的博客就已经搭建完成了，你可以在你初始化后的博客目录下输入一下命令，然后就会开启hexo服务，在浏览器输入http://localhost:4000
      就可以看到你生成的博客了，默认情况下hexo博客主题是landspace

      -
      hexo s
      -

      开启hexo
      默认主题

      +

      这样完了以后其实我们的博客就已经搭建完成了，你可以在你初始化后的博客目录下输入一下命令，然后就会开启hexo服务，在浏览器输入http://localhost:4000
      就可以看到你生成的博客了，默认情况下hexo博客主题是landspace

      hexo s

      开启hexo
      默认主题

      github部署

      对于github上进行部署的话我们首先需要新建一个repo，并且必须命名为：你的github账户名.github.io，建议大家最好配置好ssh这样就不用每次输入密码了
      然后我们需要在博客根目录下npm一个用于部署的模块deploy-git 

      npm install hexo-deployer-git --save

      github对于hexo博客的部署是非常方便的，只需要在主配置文件_config.yml下添加一项配置就可以了，配置到服务器上也是如此
      这里我直接将github和服务器都配置好了提交，你如果没有服务器端的配置就直接删掉那一行就行。

      @@ -245,9 +237,7 @@ 

      #建议每次提交都执行这三个命令，
      #当然了你也可以在直接写成bat文件或者sh文件，就不用每次自己手动输入了
      hexo clean
      hexo g
      hexo d

      他就会自动将我们所写的博客和所需要展示的内容转成htmlcssjs等文件push到我们的github上去,所以说大家如果有配置和修改自己选择的主题的话，可能你需要备份一下，不然到时候就没了，在部署的网页上这些npmmodules和你修改的样式都是直接打包好了的，你的源代码是不会提交上去的。

      -

      常用操作

      好了其实到这里我们的博客搭建就已经完成了，这里我们介绍几个常用的命令和操作吧，

      -
      hexo clean 清除生成的文件
      hexo g 重新生成博客的文件
      hexo s 开启hexo服务，我们可以预览自己新写的博客在网页上的样子
      hexo d 提交部署到服务器上包括github

      hexo new "my first blog" 新建一个名为my first blog的博客，会显示在你的博客根目录的`source/_posts`下面
      -

      在这里插入图片描述
      大家可能会注意到我这里好像不仅生成了文件还生成了一个同名的文件夹，这个文件夹是用于引入同名博客的图片的。
      当然了其实我建议最好在csdn上写好自己的博客发表以后就变成网图了，然后直接复制csdn的博文在commit到hexo上面这样就不用存图片啥的，不过这里还是介绍一下本地图片引入吧

      +

      常用操作

      好了其实到这里我们的博客搭建就已经完成了，这里我们介绍几个常用的命令和操作吧，

      hexo clean 清除生成的文件
      hexo g 重新生成博客的文件
      hexo s 开启hexo服务，我们可以预览自己新写的博客在网页上的样子
      hexo d 提交部署到服务器上包括github

      hexo new "my first blog" 新建一个名为my first blog的博客，会显示在你的博客根目录的`source/_posts`下面

      在这里插入图片描述
      大家可能会注意到我这里好像不仅生成了文件还生成了一个同名的文件夹，这个文件夹是用于引入同名博客的图片的。
      当然了其实我建议最好在csdn上写好自己的博客发表以后就变成网图了，然后直接复制csdn的博文在commit到hexo上面这样就不用存图片啥的，不过这里还是介绍一下本地图片引入吧

      1. 把主页配置文件_config.yml 里的post_asset_folder:这个选项设置为true
      2. 在你的hexo目录下执行这样一句话npm install hexo-asset-image --save，这是下载安装一个可以上传本地图片的插件
        3. @@ -561,7 +551,7 @@

        - 编译原理 + 数据库系统
      3. @@ -569,15 +559,15 @@

        - Hexo + 编译原理

      4. - 数据库系统 + Go
      5. - Go + Hexo
      6. diff --git "a/2020/07/12/python\345\256\236\347\216\260\351\201\227\344\274\240\347\256\227\346\263\225/index.html" "b/2020/07/12/python\345\256\236\347\216\260\351\201\227\344\274\240\347\256\227\346\263\225/index.html" index 740163f2..9afc76b8 100644 --- "a/2020/07/12/python\345\256\236\347\216\260\351\201\227\344\274\240\347\256\227\346\263\225/index.html" +++ "b/2020/07/12/python\345\256\236\347\216\260\351\201\227\344\274\240\347\256\227\346\263\225/index.html" @@ -214,8 +214,7 @@

        -

        今天研究了一下遗传算法，发现原理还是很好懂的，不过在应用层面上还是有很多要学习的方法，如何定义编码解码的过程，如何进行选择和交叉变异，这都是我们需要解决的事情，估计还是要多学多用才能学会，当然了如果大家对我写的这些内容如果有什么不同的看法的话也建议大家提出，毕竟算法小白一个。

        - +

        今天研究了一下遗传算法，发现原理还是很好懂的，不过在应用层面上还是有很多要学习的方法，如何定义编码解码的过程，如何进行选择和交叉变异，这都是我们需要解决的事情，估计还是要多学多用才能学会，当然了如果大家对我写的这些内容如果有什么不同的看法的话也建议大家提出，毕竟算法小白一个。

        遗传算法介绍

        所谓遗传算法其实就是一种仿生算法，一种仿生全局优化算法模仿生物的遗传进化原理，通过自然选择（selection）、交叉（crossover）与变异（mutation）等操作机制，逐步淘汰掉适应度不够高的个体，使种群中个体的适应性（fitness）不断提高。
        核心思想：物竞天择，适者生存
        在这里插入图片描述
        主要的一些应用领域主要是在

        -

        这里我们要明白的一点就是，遗传算法只是提供了一个迭代的模板，具体的适应度函数也就是我们选择优化的相关指标和他的表示都是需要根据题目里面的问题来建模，然后编码解码的方式说白了其实就是如何表示我们要的可行解，比如说求一个函数的极值且精确到多少位那么他的可行解就是自变量，这里我们通常采用二进制编码，如果是TSP问题，那么可行解就可以表示成为各个配送点编号构成的一个数组，进行实数数组序列的方式编码，自然而然解码的方法和含义我们也都清楚了

        -

        求函数极值的问题

        这里是我根据网上莫烦的python视频教程，来写的一个算法，这里我们要做的问题是求出$f(x)=sin(10x)×x+cos(2x)×x$的极大值。

        import numpy as np
        import pandas as pd
        import matplotlib.pyplot as plt

        DNA_SIZE=10          #编码DNA的长度
        POP_SIZE=100         #初始化种群的大小
        CROSS_RATE=0.8       #DNA交叉概率
        MUTATION_RATE=0.003  #DNA变异概率
        N_GENERATIONS=200    #迭代次数
        X_BOUND=[0,5]        #x upper and lower bounds x的区间

        def F(x):
            return np.sin(10*x)*x+np.cos(2*x)*x


        def get_fitness(pred):
            return pred+1e-3-np.min(pred)
            #获得适应值，这里是与min比较，越大则适应度越大，便于我们寻找最大值，为了防止结果为0特意加了一个较小的数来作为偏正

        def translateDNA(pop):#DNA的二进制序列映射到x范围内
            return pop.dot(2 ** np.arange(DNA_SIZE)[::-1]) / float(2**DNA_SIZE-1) * (X_BOUND[1]-X_BOUND[0])

        def select(pop,fitness):

            idx = np.random.choice(np.arange(POP_SIZE), size=POP_SIZE, replace=True,p=fitness / fitness.sum())
            #我们只要按照适应程度 fitness 来选 pop 中的 parent 就好. fitness 越大, 越有可能被选到.
            return pop[idx]

        #交叉
        def crossover(parent,pop):
            if np.random.rand() < CROSS_RATE:
                i_ = np.random.randint(0, POP_SIZE, size=1)  # 选择一个母本的index
                print("i_:",i_)
                print("i_.size:",i_.size)
                cross_points = np.random.randint(0, 2, size=DNA_SIZE).astype(np.bool)  # choose crossover points
                print("cross_point",cross_points)
                print("corsssize:",cross_points.size)
                print(parent[cross_points])
                print(pop[i_, cross_points])
                parent[cross_points] = pop[i_, cross_points]  # mating and produce one child
                print(parent[cross_points])
            return parent

        #变异
        def mutate(child):
            for point in range(DNA_SIZE):
                if np.random.rand() < MUTATION_RATE:
                    child[point] = 1 if child[point] == 0 else 0
            return child

        pop = np.random.randint(2, size=(POP_SIZE, DNA_SIZE))   # initialize the pop DNA

        plt.ion()       # something about plotting
        x = np.linspace(*X_BOUND, 200)
        plt.plot(x, F(x))

        for _ in range(N_GENERATIONS):
            F_values = F(translateDNA(pop))    # compute function value by extracting DNA

            # something about plotting
            # if 'sca' in globals():
            #     sca.remove()
            # sca = plt.scatter(translateDNA(pop), F_values, s=200, lw=0, c='red', alpha=0.5)
            # plt.pause(0.05)

            # GA part (evolution)
            fitness = get_fitness(F_values)
            print("Most fitted DNA: ", pop[np.argmax(fitness), :])
            pop = select(pop, fitness)
            pop_copy = pop.copy()
            for parent in pop:
                child = crossover(parent, pop_copy)
                child = mutate(child)
                parent[:] = child       # parent is replaced by its child
        plt.scatter(translateDNA(pop), F_values, s=200, lw=0, c='red', alpha=0.5)
        print("x:",translateDNA(pop))
        print(type(translateDNA(pop)))
        print(len(translateDNA(pop)))
        print("max:",F_values)
        plt.ioff()
        plt.show()
        -

        最后我们可以展示一个结果，注意这个看似只有一个红点，其实这是100个种群个体集中得到的结果。，所以你最后打印的时候是一个100个解构成的1×100的解向量，最终都集中到了这个极值附近。
        在这里插入图片描述
        轮盘赌说的很复杂其实在python的random函数里可以说是封装好了，这里我们可以着重看看这个choice函数

        -
        np.random.choice(a, size=None, replace=True, p=None)
        -

        a表示我们需要选取的数组。
        size表示我们需要提取的数据个数。
        replace 代表的意思是抽样之后还放不放回去，如果是False的话，抽取不放回，如果是True的话， 抽取放回。
        p表示的就是概率数组，代表每一个数被抽取出来的概率。
        在我们代码中是写的

        +

        最后我们可以展示一个结果，注意这个看似只有一个红点，其实这是100个种群个体集中得到的结果。，所以你最后打印的时候是一个100个解构成的1×100的解向量，最终都集中到了这个极值附近。
        在这里插入图片描述
        轮盘赌说的很复杂其实在python的random函数里可以说是封装好了，这里我们可以着重看看这个choice函数

        np.random.choice(a, size=None, replace=True, p=None)

        a表示我们需要选取的数组。
        size表示我们需要提取的数据个数。
        replace 代表的意思是抽样之后还放不放回去，如果是False的话，抽取不放回，如果是True的话， 抽取放回。
        p表示的就是概率数组，代表每一个数被抽取出来的概率。
        在我们代码中是写的

        idx = np.random.choice(np.arange(POP_SIZE), size=POP_SIZE, replace=True,p=fitness / fitness.sum())
        -

        直接就抽取出了种群pop中每个个体的下标编号，这里我们的概率数组是使用的按照比例的适应度分配比例方法提取,而概率是以这种方式来建模计算的。
        $$P_{i}=\frac{fitness(i)}{\sum_{i=0}^{n}{fitness(i)}}$$
        在这里插入图片描述

        +

        直接就抽取出了种群pop中每个个体的下标编号，这里我们的概率数组是使用的按照比例的适应度分配比例方法提取,而概率是以这种方式来建模计算的。

        +

        在这里插入图片描述

        求解TSP最短路的问题

        tsp问题主要就是用户从某一起点出发然后经过所有的点一次并回到起点的最短路径，同时约定任意两点之前是互通可达的，我们要注意的是，可能两点之间的距离有时候是欧式距离，有的时候可能是哈密顿距离，自己要根据题意去判断。
        这里我们主要讲解一下他的fitness函数主要是最短路径的总距离，编码序列则是最短路的编号，然后我们要注意这个问题在交叉变异的时候，我们一定要保证他首先是一条正确的可行解！不要出现有顶点重合或缺失的情况。
        这里我们在解决交叉的时候是先随机选取一部分父类的基因编号，然后再从母本的DNA序列里面选出子类中缺少的基因，从而获得基因重组。
        而变异的时候也不同于例1里面的修改二进制编码，而是采用的调换两个基因序号来完成，从而保证我们的结果一定是一条规范正确的回路。

        import matplotlib.pyplot as plt
        import numpy as np
        import pandas as pd

        N_CITIES = 20  # 城市数量
        CROSS_RATE = 0.1 #交叉概率
        MUTATE_RATE = 0.02 #变异概率
        POP_SIZE = 500 #种群概率
        N_GENERATIONS = 500 #迭代次数

        class GA(object):
            def __init__(self, DNA_size, cross_rate, mutation_rate, pop_size, ):
                self.DNA_size = DNA_size
                self.cross_rate = cross_rate
                self.mutate_rate = mutation_rate
                self.pop_size = pop_size

                self.pop = np.vstack([np.random.permutation(DNA_size) for _ in range(pop_size)])

            def translateDNA(self, DNA, city_position):     # get cities' coord in order
                line_x = np.empty_like(DNA, dtype=np.float64)
                line_y = np.empty_like(DNA, dtype=np.float64)
                for i, d in enumerate(DNA):
                    city_coord = city_position[d]
                    line_x[i, :] = city_coord[:, 0]
                    line_y[i, :] = city_coord[:, 1]
                return line_x, line_y

            def get_fitness(self, line_x, line_y):
                total_distance = np.empty((line_x.shape[0],), dtype=np.float64)
                for i, (xs, ys) in enumerate(zip(line_x, line_y)):
                    total_distance[i] = np.sum(np.sqrt(np.square(np.diff(xs)) + np.square(np.diff(ys))))
                fitness = np.exp(self.DNA_size * 2 / total_distance)#把欧氏距离的影响扩大化
                return fitness, total_distance

            def select(self, fitness):
                idx = np.random.choice(np.arange(self.pop_size), size=self.pop_size, replace=True, p=fitness / fitness.sum())
                return self.pop[idx]

            def crossover(self, parent, pop):
                if np.random.rand() < self.cross_rate:
                    i_ = np.random.randint(0, self.pop_size, size=1)                        # select another individual from pop
                    cross_points = np.random.randint(0, 2, self.DNA_size).astype(np.bool)   # choose crossover points
                    keep_city = parent[~cross_points]                                       # find the city number
                    swap_city = pop[i_, np.isin(pop[i_].ravel(), keep_city, invert=True)]
                    parent[:] = np.concatenate((keep_city, swap_city))
                return parent

            def mutate(self, child):
                for point in range(self.DNA_size):
                    if np.random.rand() < self.mutate_rate:
                        swap_point = np.random.randint(0, self.DNA_size)
                        swapA, swapB = child[point], child[swap_point]
                        child[point], child[swap_point] = swapB, swapA
                return child

            def evolve(self, fitness):
                pop = self.select(fitness)
                pop_copy = pop.copy()
                for parent in pop:  # for every parent
                    child = self.crossover(parent, pop_copy)
                    child = self.mutate(child)
                    parent[:] = child
                self.pop = pop


        class TravelSalesPerson(object):
            def __init__(self, n_cities):
                self.city_position = np.random.rand(n_cities, 2)
                plt.ion()

            def plotting(self, lx, ly, total_d):
                plt.cla()
                plt.scatter(self.city_position[:, 0].T, self.city_position[:, 1].T, s=100, c='k')
                plt.plot(lx.T, ly.T, 'r-')
                plt.text(-0.05, -0.05, "Total distance=%.2f" % total_d, fontdict={'size': 20, 'color': 'red'})
                plt.xlim((-0.1, 1.1))
                plt.ylim((-0.1, 1.1))
                plt.pause(0.01)


        ga = GA(DNA_size=N_CITIES, cross_rate=CROSS_RATE, mutation_rate=MUTATE_RATE, pop_size=POP_SIZE)

        env = TravelSalesPerson(N_CITIES)
        for generation in range(N_GENERATIONS):
            lx, ly = ga.translateDNA(ga.pop, env.city_position)#city_position（x,y）
            fitness, total_distance = ga.get_fitness(lx, ly)#根据获得的路径计算路程
            ga.evolve(fitness)
            best_idx = np.argmax(fitness)
            print('Gen:', generation, '| best fit: %.2f' % fitness[best_idx],)

            # env.plotting(lx[best_idx], ly[best_idx], total_distance[best_idx])
        env.plotting(lx[best_idx], ly[best_idx], total_distance[best_idx])
        plt.ioff()
        plt.show()
        - -

        在这里插入图片描述
        在最后我附上我学习的这个视频教程吧,多看看知乎csdn还有很多解释。明天我的京东快递《matlab智能算法30个案例分析》就要到了，真的是本好书，顺带一提学校培训真累啊，还啥都不会。
        莫烦python遗传算法

        +

        在这里插入图片描述
        在最后我附上我学习的这个视频教程吧,多看看知乎csdn还有很多解释。明天我的京东快递《matlab智能算法30个案例分析》就要到了，真的是本好书，顺带一提学校培训真累啊，还啥都不会。
        莫烦python遗传算法

        @@ -548,7 +543,7 @@

      7. - 编译原理 + 数据库系统
      8. @@ -556,15 +551,15 @@

      9. - Hexo + 编译原理
      10. - 数据库系统 + Go
      11. - Go + Hexo
      12. diff --git "a/2020/07/15/\346\250\241\346\213\237\351\200\200\347\201\253matlab\345\256\236\347\216\260\357\274\210TSP\344\270\272\344\276\213\357\274\211/index.html" "b/2020/07/15/\346\250\241\346\213\237\351\200\200\347\201\253matlab\345\256\236\347\216\260\357\274\210TSP\344\270\272\344\276\213\357\274\211/index.html" index 27d5f0a0..2077abc4 100644 --- "a/2020/07/15/\346\250\241\346\213\237\351\200\200\347\201\253matlab\345\256\236\347\216\260\357\274\210TSP\344\270\272\344\276\213\357\274\211/index.html" +++ "b/2020/07/15/\346\250\241\346\213\237\351\200\200\347\201\253matlab\345\256\236\347\216\260\357\274\210TSP\344\270\272\344\276\213\357\274\211/index.html" @@ -213,41 +213,28 @@

        最近学习了模拟退火智能算法，顺便学习了一下matlab，顺带一提matlba真香，对矩阵的操作会比python的numpy操作要更加方便，这里我们是以TSP问题为例子，因为比较好理解。

        -

        模拟退火介绍

        模拟退火总的来说还是一种优化算法，他模拟的是淬火冶炼的一个过程，通过升温增强分子的热运动，然后再慢慢降温，使其达到稳定的状态。

        - -

        在这里插入图片描述
        初始解
        通常是以一个随机解作为初始解. 并保证理论上能够生成解空间中任意的解，也可以是一个经挑选过的较好的解，初始解不宜“太好”, 否则很难从这个解的邻域跳出，针对问题去分析。
        扰动邻解
        邻解生成函数应尽可能保证产生的侯选解能够遍布解空间，邻域应尽可能的小，能够在少量循环步中允分探测.，但每次的改变不应该引起太大的变化。
        初始温度

        +

        模拟退火介绍

        模拟退火总的来说还是一种优化算法，他模拟的是淬火冶炼的一个过程，通过升温增强分子的热运动，然后再慢慢降温，使其达到稳定的状态。

        在这里插入图片描述
        初始解
        通常是以一个随机解作为初始解. 并保证理论上能够生成解空间中任意的解，也可以是一个经挑选过的较好的解，初始解不宜“太好”, 否则很难从这个解的邻域跳出，针对问题去分析。
        扰动邻解
        邻解生成函数应尽可能保证产生的侯选解能够遍布解空间，邻域应尽可能的小，能够在少量循环步中允分探测.，但每次的改变不应该引起太大的变化。
        初始温度

        • 初始温度应该设置的尽可能的高, 以确保最终解不受初始解
          影响. 但过高又会增加计算时间.
        • 均匀抽样一组状态，以各状态目标值的方差为初温.
          • -
        • 如果能确定邻解间目标函数(COST 函数) 的最大差值, 就可以确定出初始温度$T_{0}$,以使初始接受概率$P=e^{-|\Delta C|_{max}/T}$足够大。$|\Delta C|_{max}$ 可由随机产生一组状态的最大目标值差来替代.
          • +
        • 如果能确定邻解间目标函数(COST 函数) 的最大差值, 就可以确定出初始温度$T{0}$,以使初始接受概率$P=e^{-|\Delta C|\{max}/T}$足够大。$|\Delta C|_{max}$ 可由随机产生一组状态的最大目标值差来替代.
        • 在正式开始退火算法前, 可进行一个升温过程确定初始温度:逐渐增加温度, 直到所有的尝试尝试运动都被接受, 将此时的温度设置为初始温度.
          • -
        • 由经验给出, 或通过尝试找到较好的初始温度.
          • -
        -

        等温步数

        -
          +
        • 由经验给出, 或通过尝试找到较好的初始温度.
          等温步数
        • 等温步数也称Metropolis 抽样稳定准则, 用于决定在各温度下产生候选解的数目. 通常取决于解空间和邻域的大小.
        • 等温过程是为了让系统达到平衡, 因此可通过检验目标函数的均值是否稳定(或连续若干步的目标值变化较小) 来确定等温步数.
        • 等温步数受温度的影响. 高温时, 等温步数可以较小, 温度较小时, 等温步数要大. 随着温度的降低, 增加等温步数.
          • -
        • 有时为了考虑方便, 也可直接按一定的步数抽样。
          • +
        • 有时为了考虑方便, 也可直接按一定的步数抽样。
          Metropolis法则
          Metropolis法则是SA接受新解的概率。 $x$是表示当前解，$x’$是新解，其实这也是模拟退火区别于贪心的一点，我们在更新新解的时候对于不满足条件的情况，我们也有一定的概率来进行选取，从而可以使得退火模拟可以跳出局部最优解。
        -

        Metropolis法则
        Metropolis法则是SA接受新解的概率。
        $$P(x=>x’)=
        \begin{cases}
        1 &\text{$,f(x’)<f(x)$} \\
        e^{-\frac{f(x’)-f(x)}{T}} & \text{$,f(x’)>f(x)$}\
        \end{cases}
        $$
        $x$是表示当前解，$x’$是新解，其实这也是模拟退火区别于贪心的一点，我们在更新新解的时候对于不满足条件的情况，我们也有一定的概率来进行选取，从而可以使得退火模拟可以跳出局部最优解。

        -

        降温公式
        经典模拟退火算法的降温方式：
        $$T(t)=\frac{T_0}{log(1+t)}$$
        快速模拟退火算法的降温方式:
        $$T(t)=\frac{T_0}{1+t}$$
        常用的模拟退火算法的降温方式还有(通常$0.8<\alpha<0.99$)
        $$T(t+\Delta t)=\alpha T(t)$$
        终止条件自己设定阈值即可。
        花费函数COST
        这个基本就是分析题目，一般设置为我们需要求解的目标函数最值。

        -

        TSP问题

        已知中国34 个省会城市(包括直辖市) 的经纬度, 要求从北京出发, 游遍34 个城市, 最后回到北京. 用模拟退火算法求最短路径。
        1.main.m
        主函数

        -
        clc
        clear;
        %% 
        load('china.mat');
        plotcities(province, border, city);%画出地图
        cityaccount=length(city);%城市数量
        dis=distancematrix(city)%距离矩阵

        route =randperm(cityaccount);%路径格式
        temperature=1000;%初始化温度
        cooling_rate=0.95;%温度下降比率
        item=1;%用来控制降温的循环记录次数
        distance=totaldistance(route,dis);%计算路径总长度
        temperature_iterations = 1;
        % This is a flag used to plot the current route after 200 iterations
        plot_iterations = 1;

        plotroute(city, route, distance,temperature);%画出路线

        %% 
        while temperature>1.0 %循环条件
            temp_route=change(route,'reverse');%产生扰动。分子序列变化
        %     fprintf("%d\n",temp_route(1));
            temp_distance=totaldistance(temp_route,dis);%产生变化后的长度
            dist=temp_distance-distance;%两个路径的差距
            if(dist<0)||(rand < exp(-dist/(temperature)))
                route=temp_route;
                distance=temp_distance;
                item=item+1;
                temperature_iterations=temperature_iterations+1;
                plot_iterations=plot_iterations+1;
            end
            if temperature_iterations>=10
                temperature=cooling_rate*temperature;
                temperature_iterations=0;
            end
            
            if plot_iterations >= 20
               plotroute(city, route, distance,temperature);%画出路线
               plot_iterations = 0;
            end
        %     fprintf("it=%d",item);
        end
        -

        2.distance.m
        计算两点之间的距离

        -
        function d = distance(lat1, long1, lat2, long2, R)
        % DISTANCE
        % d = DISTANCE(lat1, long1, lat2, long2, R) compute distance between points
        % on sphere with radians R.
        %
        % Latitude/Longitude Distance Calculation:
        % http://www.mathforum.com/library/drmath/view/51711.html
         
        y1 = lat1/180*pi; x1 = long1/180*pi;
        y2 = lat2/180*pi; x2 = long2/180*pi;
        dy = y1-y2; dx = x1-x2;
        d = 2*R*asin(sqrt(sin(dy/2)^2+sin(dx/2)^2*cos(y1)*cos(y2)));
        end
        -

        3.totaldistance.m
        一条route路线的总路程，也是我们需要优化的目标函数

        -
        function totaldis = totaldistance(route,dis)%传入距离矩阵和当前路线
        %TOTALDISTANCE 此处显示有关此函数的摘要
        %   此处显示详细说明

        % fprintf("%d\n",route(1));
        totaldis=dis(route(end),route(1));
        % totaldis=dis(route(end),route(1));
        for k=1:length(route)-1
            totaldis=totaldis+dis(route(k),route(k+1));%直接加两个点之间的距离
        end
        -

        4.distancematrix.m
        任意两点之间的距离矩阵

        -
        function dis = distancematrix(city)
        %DISTANCEMATRIX 此处显示有关此函数的摘要
        %   此处显示详细说明
        cityacount=length(city);
        R=6378.137;%地球半径用于求两个城市的球面距离
          for i = 1:cityacount
              for j = i+1:cityacount
                  dis(i,j)=distance(city(i).lat,city(i).long,...
                                      city(j).lat,city(j).long,R);%distance函数原来是设计来计算球面上距离的
                  dis(j,i)=dis(i,j);%对称，无向图
              end
          end
        end
        - -

        5.change.m
        产生分子扰动，求当前解的邻解

        -
        function route = change(pre_route,method)
        %CHANGE 此处显示有关此函数的摘要
        %   此处显示详细说明
        route=pre_route;
        cityaccount=length(route);
        %随机取数，相当于把0-34个城市映射到0-1的等概率抽取上，再取整
        city1=ceil(cityaccount*rand); % [1, 2, ..., n-1, n]
        city2=ceil(cityaccount*rand); % 1<=city1, city2<=n
        switch method
            case 'reverse' %[1 2 3 4 5 6] -> [1 5 4 3 2 6]
                cmin = min(city1,city2);
                cmax = max(city1,city2);
                route(cmin:cmax) = route(cmax:-1:cmin);%反转某一段
            case 'swap' %[1 2 3 4 5 6] -> [1 5 3 4 2 6]
                route([city1, city2]) = route([city2, city1]);
        end
        -

        6.plotcities.m
        画出city

        -
        function h = plotcities(province, border, city)
        % PLOTCITIES
        % h = PLOTCITIES(province, border, city) draw the map of China, and return 
        % the route handle.

        global h;
        % draw the map of China
        plot(province.long, province.lat, 'color', [0.7,0.7,0.7])
        hold on
        plot(border.long  , border.lat  , 'color', [0.5,0.5,0.5], 'linewidth', 1.5);
         

        % plot a NaN route, and global the handle h.
        h = plot(NaN, NaN, 'b-', 'linewidth', 1);

        % plot cities as green dots
        plot([city(2:end).long], [city(2:end).lat], 'o', 'markersize', 3, ...
                                      'MarkerEdgeColor','b','MarkerFaceColor','g');
        % plot Beijing as a red pentagram
        plot([city(1).long],[city(1).lat],'p','markersize',5, ...
                                      'MarkerEdgeColor','r','MarkerFaceColor','g');
        axis([70 140 15 55]);
        -

        7.plotroute.m
        画出路线

        -
        function plotroute(city, route, current_distance, temperature)
        % PLOTROUTE
        % PLOTROUTE(city, route, current_distance, temperature) plots the route and
        % display current temperautre and distance.

        global h;
        cycle = route([1:end, 1]);
        % update route
        set(h,'Xdata',[city(cycle).long],'Ydata',[city(cycle).lat]);

        % display current temperature and total distance
        xlabel(sprintf('T = %6.1f        Total Distance = %6.1f', ...
                            temperature,                  current_distance));
        drawnow
        -

        一开始的路径
        在这里插入图片描述
        最后运行出来的最优化路径
        在这里插入图片描述
        有需要的朋友可以下载相关的数据集下载链接

        +

        降温公式
        经典模拟退火算法的降温方式：

        +

        快速模拟退火算法的降温方式:

        +

        常用的模拟退火算法的降温方式还有(通常$0.8<\alpha<0.99$)

        +

        终止条件自己设定阈值即可。
        花费函数COST
        这个基本就是分析题目，一般设置为我们需要求解的目标函数最值。

        +

        TSP问题

        已知中国34 个省会城市(包括直辖市) 的经纬度, 要求从北京出发, 游遍34 个城市, 最后回到北京. 用模拟退火算法求最短路径。
        1.main.m
        主函数

        clc
        clear;
        %% 
        load('china.mat');
        plotcities(province, border, city);%画出地图
        cityaccount=length(city);%城市数量
        dis=distancematrix(city)%距离矩阵

        route =randperm(cityaccount);%路径格式
        temperature=1000;%初始化温度
        cooling_rate=0.95;%温度下降比率
        item=1;%用来控制降温的循环记录次数
        distance=totaldistance(route,dis);%计算路径总长度
        temperature_iterations = 1;
        % This is a flag used to plot the current route after 200 iterations
        plot_iterations = 1;

        plotroute(city, route, distance,temperature);%画出路线

        %% 
        while temperature>1.0 %循环条件
            temp_route=change(route,'reverse');%产生扰动。分子序列变化
        %     fprintf("%d\n",temp_route(1));
            temp_distance=totaldistance(temp_route,dis);%产生变化后的长度
            dist=temp_distance-distance;%两个路径的差距
            if(dist<0)||(rand < exp(-dist/(temperature)))
                route=temp_route;
                distance=temp_distance;
                item=item+1;
                temperature_iterations=temperature_iterations+1;
                plot_iterations=plot_iterations+1;
            end
            if temperature_iterations>=10
                temperature=cooling_rate*temperature;
                temperature_iterations=0;
            end
            
            if plot_iterations >= 20
               plotroute(city, route, distance,temperature);%画出路线
               plot_iterations = 0;
            end
        %     fprintf("it=%d",item);
        end

        2.distance.m
        计算两点之间的距离
        function d = distance(lat1, long1, lat2, long2, R)
        % DISTANCE
        % d = DISTANCE(lat1, long1, lat2, long2, R) compute distance between points
        % on sphere with radians R.
        %
        % Latitude/Longitude Distance Calculation:
        % http://www.mathforum.com/library/drmath/view/51711.html
         
        y1 = lat1/180*pi; x1 = long1/180*pi;
        y2 = lat2/180*pi; x2 = long2/180*pi;
        dy = y1-y2; dx = x1-x2;
        d = 2*R*asin(sqrt(sin(dy/2)^2+sin(dx/2)^2*cos(y1)*cos(y2)));
        end

        3.totaldistance.m
        一条route路线的总路程，也是我们需要优化的目标函数
        function totaldis = totaldistance(route,dis)%传入距离矩阵和当前路线
        %TOTALDISTANCE 此处显示有关此函数的摘要
        %   此处显示详细说明

        % fprintf("%d\n",route(1));
        totaldis=dis(route(end),route(1));
        % totaldis=dis(route(end),route(1));
        for k=1:length(route)-1
            totaldis=totaldis+dis(route(k),route(k+1));%直接加两个点之间的距离
        end

        4.distancematrix.m
        任意两点之间的距离矩阵
        function dis = distancematrix(city)
        %DISTANCEMATRIX 此处显示有关此函数的摘要
        %   此处显示详细说明
        cityacount=length(city);
        R=6378.137;%地球半径用于求两个城市的球面距离
          for i = 1:cityacount
              for j = i+1:cityacount
                  dis(i,j)=distance(city(i).lat,city(i).long,...
                                      city(j).lat,city(j).long,R);%distance函数原来是设计来计算球面上距离的
                  dis(j,i)=dis(i,j);%对称，无向图
              end
          end
        end

        +

        5.change.m
        产生分子扰动，求当前解的邻解

        function route = change(pre_route,method)
        %CHANGE 此处显示有关此函数的摘要
        %   此处显示详细说明
        route=pre_route;
        cityaccount=length(route);
        %随机取数，相当于把0-34个城市映射到0-1的等概率抽取上，再取整
        city1=ceil(cityaccount*rand); % [1, 2, ..., n-1, n]
        city2=ceil(cityaccount*rand); % 1<=city1, city2<=n
        switch method
            case 'reverse' %[1 2 3 4 5 6] -> [1 5 4 3 2 6]
                cmin = min(city1,city2);
                cmax = max(city1,city2);
                route(cmin:cmax) = route(cmax:-1:cmin);%反转某一段
            case 'swap' %[1 2 3 4 5 6] -> [1 5 3 4 2 6]
                route([city1, city2]) = route([city2, city1]);
        end

        6.plotcities.m
        画出city
        function h = plotcities(province, border, city)
        % PLOTCITIES
        % h = PLOTCITIES(province, border, city) draw the map of China, and return 
        % the route handle.

        global h;
        % draw the map of China
        plot(province.long, province.lat, 'color', [0.7,0.7,0.7])
        hold on
        plot(border.long  , border.lat  , 'color', [0.5,0.5,0.5], 'linewidth', 1.5);
         

        % plot a NaN route, and global the handle h.
        h = plot(NaN, NaN, 'b-', 'linewidth', 1);

        % plot cities as green dots
        plot([city(2:end).long], [city(2:end).lat], 'o', 'markersize', 3, ...
                                      'MarkerEdgeColor','b','MarkerFaceColor','g');
        % plot Beijing as a red pentagram
        plot([city(1).long],[city(1).lat],'p','markersize',5, ...
                                      'MarkerEdgeColor','r','MarkerFaceColor','g');
        axis([70 140 15 55]);

        7.plotroute.m
        画出路线
        function plotroute(city, route, current_distance, temperature)
        % PLOTROUTE
        % PLOTROUTE(city, route, current_distance, temperature) plots the route and
        % display current temperautre and distance.

        global h;
        cycle = route([1:end, 1]);
        % update route
        set(h,'Xdata',[city(cycle).long],'Ydata',[city(cycle).lat]);

        % display current temperature and total distance
        xlabel(sprintf('T = %6.1f        Total Distance = %6.1f', ...
                            temperature,                  current_distance));
        drawnow

        一开始的路径
        在这里插入图片描述
        最后运行出来的最优化路径
        在这里插入图片描述
        有需要的朋友可以下载相关的数据集下载链接

        @@ -552,7 +539,7 @@

      13. - 编译原理 + 数据库系统
      14. @@ -560,15 +547,15 @@

      15. - Hexo + 编译原理
      16. - 数据库系统 + Go
      17. - Go + Hexo
      18. diff --git "a/2020/07/16/matlab\347\256\200\345\215\225\345\276\256\345\210\206\346\226\271\347\250\213\346\261\202\350\247\243/index.html" "b/2020/07/16/matlab\347\256\200\345\215\225\345\276\256\345\210\206\346\226\271\347\250\213\346\261\202\350\247\243/index.html" index 043e24a4..51e759ea 100644 --- "a/2020/07/16/matlab\347\256\200\345\215\225\345\276\256\345\210\206\346\226\271\347\250\213\346\261\202\350\247\243/index.html" +++ "b/2020/07/16/matlab\347\256\200\345\215\225\345\276\256\345\210\206\346\226\271\347\250\213\346\261\202\350\247\243/index.html" @@ -221,22 +221,13 @@

        -

        时隔半年，我又重回微分方程的学习了，现在学确实挺难搞的，很多知识和理论思路都忘了，数学还是很重要啊，其实一个蛮简单的东西我看了很久很久才慢慢的又懂了，话不多说，直接写文。
        首先要明确的一点就是，我们求微分方程的时候，要注意有解析解和数值解，解析解又有通解和特解，这在我们编写代码的时候可以通过初始点的值来获得特解。其实今天老师讲的还挺不错的，举出了很多的例子，基本上与物理有关，其实要说这一个模块最稳妥的办法其实是如果能够求出通解，一般最好手动进行微分方程的求解，然后用计算机检验，用计算机求微分方程的情况大多数是求数值解。所以说这一部分的话，其实对建模的要求更高，求解我们到时候可以看到matlab调用函数就可以了

        - +

        时隔半年，我又重回微分方程的学习了，现在学确实挺难搞的，很多知识和理论思路都忘了，数学还是很重要啊，其实一个蛮简单的东西我看了很久很久才慢慢的又懂了，话不多说，直接写文。
        首先要明确的一点就是，我们求微分方程的时候，要注意有解析解和数值解，解析解又有通解和特解，这在我们编写代码的时候可以通过初始点的值来获得特解。其实今天老师讲的还挺不错的，举出了很多的例子，基本上与物理有关，其实要说这一个模块最稳妥的办法其实是如果能够求出通解，一般最好手动进行微分方程的求解，然后用计算机检验，用计算机求微分方程的情况大多数是求数值解。所以说这一部分的话，其实对建模的要求更高，求解我们到时候可以看到matlab调用函数就可以了

        dsolve函数的妙用

        在这里插入图片描述
        在这里插入图片描述

        -

        求解常微分方程通解

        $求微分方程\frac{du}{dx}=1+u^2和x^2+y+(x-2y)y’的通解$

        -
        dsolve('Du=1+u^2','t');
        dsolve('x^2+y+(x-2*y)*Dy=0','x');
        -

        求解常微分方程特解

        $求y’’’-y’’=x，y(1)=8，y’(1)=7，y’’(2)=4的特解$

        -
        y=dsolve('D3y-D2y=x','y(1)=8','Dy(1)=7','D2y(2)=4','x');
        -
        ```
        #### 求解微分方程组
        ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200716230752510.png#pic_center)
        ```matlab
        [x,y,z]=dsolve('Dx=2*x-3*y+3*z','Dy=4*x-5*y+3*z','Dz=4*x-4*y+2*z','t');
        x=simplify(x);%化简
        y=simplify(y);
        z=simplify(z);
        -

        在这里插入图片描述

        +

        求解常微分方程通解

        $求微分方程\frac{du}{dx}=1+u^2和x^2+y+(x-2y)y’的通解$

        dsolve('Du=1+u^2','t');
        dsolve('x^2+y+(x-2*y)*Dy=0','x');

        +

        求解常微分方程特解

        $求y’’’-y’’=x，y(1)=8，y’(1)=7，y’’(2)=4的特解$

        y=dsolve('D3y-D2y=x','y(1)=8','Dy(1)=7','D2y(2)=4','x');

        ```
        #### 求解微分方程组
        ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200716230752510.png#pic_center)
        ```matlab
        [x,y,z]=dsolve('Dx=2*x-3*y+3*z','Dy=4*x-5*y+3*z','Dz=4*x-4*y+2*z','t');
        x=simplify(x);%化简
        y=simplify(y);
        z=simplify(z);

        在这里插入图片描述

        equ1='D2f+3*g=sin(x)';
        equ2='Dg+Df=cos(x)';
        [general_f,general_g]=dsolve(equ1,equ2,'x');  %通解
        [f,g]=dsolve(equ1,equ2,'Df(2)=0,f(3)=3,g(5)=1','x');

        龙哥库塔求数值解

        在介绍龙哥库塔求数值解的时候，我们先要介绍一下这个刚性方程组的定义
        在这里插入图片描述
        然后matlab里面提供了几个非常好的解刚性常微分方程的功能函数如ode15s,ode45,ode113,ode23,ode23s,ode23t,ode23tb,
        在这里插入图片描述
        然后在介绍求解的知识之前，我需要先让你对这个过程做一个了解，以至于你写的时候不会觉得很晕，其实很简单的，估计我是忘了老师怎么教的了，看了半天我才慢慢明白。
        其实他的思路就是，用当前可以得到的函数值和自变量来导出我们所需要的求得微分变量，如果出现了高阶得情况，则将每一个高阶都逐一替换成导数用函数值表示的公式，前几阶导数完全可以嵌套定义表示出来，可能你还是没用很懂，不过等你看到我下面的分析的时候，你应该就懂了，而且通过我的发现，基本上告诉你几个初始值，一般你就要求多少阶的导数。

        -

        简单的一阶方程初值问题

        在这里插入图片描述
        在这里插入图片描述
        F2.m

        -
        function dy = F2(t,y)
        %F2 此处显示有关此函数的摘要
        %   此处显示详细说明
        dy=-2*y+2*t^2+2*t;
        end
        -

        main.m

        -
        [T,Y]=ode45('F2',[0,500],[1]);
        plot(T,Y(:,1),'-');
        -

        在这里插入图片描述

        +

        简单的一阶方程初值问题

        在这里插入图片描述
        在这里插入图片描述
        F2.m

        function dy = F2(t,y)
        %F2 此处显示有关此函数的摘要
        %   此处显示详细说明
        dy=-2*y+2*t^2+2*t;
        end

        main.m
        [T,Y]=ode45('F2',[0,500],[1]);
        plot(T,Y(:,1),'-');

        在这里插入图片描述

        高阶微分方程

        做变量替换，转化成多个一阶微分方程
        在这里插入图片描述
        F.m

        %y1=y
        %y2=y1'=y'
        %y2'=y''
        %y0=2,y1=0
        function dy=F(t,y)%虽然这里我们没用上自变量但是这个参数还是要加，毕竟是调库函数所以说还是得按他的规矩
        dy=zeros(2,1);
        dy(1)=y(2);
        dy(2)=1000*(1-y(1)^2)*y(2)-y(1);

        main.m

        @@ -546,7 +537,7 @@

      19. - 编译原理 + 数据库系统
      20. @@ -554,15 +545,15 @@

      21. - Hexo + 编译原理
      22. - 数据库系统 + Go
      23. - Go + Hexo
      24. diff --git "a/2020/09/09/java\347\232\204String\345\270\270\347\224\250\346\223\215\344\275\234/index.html" "b/2020/09/09/java\347\232\204String\345\270\270\347\224\250\346\223\215\344\275\234/index.html" index 9fa98b7d..845c7b77 100644 --- "a/2020/09/09/java\347\232\204String\345\270\270\347\224\250\346\223\215\344\275\234/index.html" +++ "b/2020/09/09/java\347\232\204String\345\270\270\347\224\250\346\223\215\344\275\234/index.html" @@ -209,17 +209,11 @@

        java的String类常用操作

        最近在准备蓝桥杯，补题目，顺便也是稍微缓一下暑假自闭，主要还是不想浪费300，顺便回顾一下java的基本语法，java的String类这一块感觉还是挺多操作的，字符串的不可变性也使得其操作和c++存在一些差别。这里需要推荐一个十分好的博客就是廖雪峰的java教程,其实菜鸟教程也不错的。

        -

        Java字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。

        - -

        创建字符串

        创建字符串主要是两种常用方法吧，一个是new还有一个就是直接定义，毕竟已经是一个关键字了。

        -

        public class Main {
            public static void main(String[] args) {
                String a="hello";
                a+="121";//Strin的+操作
                char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
                String helloString = new String(helloArray);
                System.out.println(a);
                System.out.println(helloString);
            }
        }
        -

        当然如果需要对字符串转换成char数组的话也是封装好了函数的toCharArray()

        -
        public class Main {
            public static void main(String[] args) {
                str="Hello";
                char[] lisc = str.toCharArray();
                String s = new String(lisc);
                System.out.println(s);
            }
        }
        +

        Java字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。

        +

        创建字符串

        创建字符串主要是两种常用方法吧，一个是new还有一个就是直接定义，毕竟已经是一个关键字了。


        public class Main {
            public static void main(String[] args) {
                String a="hello";
                a+="121";//Strin的+操作
                char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
                String helloString = new String(helloArray);
                System.out.println(a);
                System.out.println(helloString);
            }
        }

        当然如果需要对字符串转换成char数组的话也是封装好了函数的toCharArray()
        public class Main {
            public static void main(String[] args) {
                str="Hello";
                char[] lisc = str.toCharArray();
                String s = new String(lisc);
                System.out.println(s);
            }
        }

        String的长度——length()

        public class Main {
            public static void main(String[] args) {
                String str = "abcde";
                int len = str.length();
                System.out.println("len="+len);
            }
        }
        -

        字符串比较

        当我们想要比较两个字符串是否相同时，要特别注意，我们实际上是想比较字符串的内容是否相同。必须使用equals()方法而不能用==。==比较的是两个变量是否指向同一个字符串对象。可以看一下下面两个结果，有什么不同。

        public class Main {
            public static void main(String[] args) {
                String s1 = "hello";
                String s2 = "HELLO".toLowerCase();
                System.out.println(s1 == s2);
                System.out.println(s1.equals(s2));
            }
        }
        -

        这里还有一个用于比较java的字符串方法的compareTo()方法

        compareTo()方法用于两种方式的比较：

          @@ -233,16 +227,10 @@ 

          int compareTo(Object o)
          int compareTo(String anotherString)
          - -

          下面是一个demo

          -
          public class Test {
           
              public static void main(String args[]) {
                  System.out.println("Hello World!");
                  String str1 = "Strings";
                  String str2 = "Strings";
                  String str3 = "Strin1212";
                  String str4 = "Stringr";

                  int result = str1.compareTo( str2 );
                  System.out.println(result);

                  result = str2.compareTo( str3 );
                  System.out.println(result);

                  result = str3.compareTo( str1 );
                  System.out.println(result);
              }
          }
          - +

          下面是一个demo

          public class Test {
           
              public static void main(String args[]) {
                  System.out.println("Hello World!");
                  String str1 = "Strings";
                  String str2 = "Strings";
                  String str3 = "Strin1212";
                  String str4 = "Stringr";

                  int result = str1.compareTo( str2 );
                  System.out.println(result);

                  result = str2.compareTo( str3 );
                  System.out.println(result);

                  result = str3.compareTo( str1 );
                  System.out.println(result);
              }
          }

          String遍历——charAt() 方法

          charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。

          public class Test {
              public static void main(String args[]) {
                  String first="hello";
                  for(int i=0;i<len1;i++)
                      {
                          char c1 = first.charAt(i);
                      }
              }
          }
          - -

          如果已经变成了char[]了，不同于普通循环，你还能使用for each来循环,类似python的操作。

          -
          char[] charlist={'a','b','c'};
          for(char c: charlist)
          {
              System.out.println(c);
          }
          - +

          如果已经变成了char[]了，不同于普通循环，你还能使用for each来循环,类似python的操作。

          char[] charlist={'a','b','c'};
          for(char c: charlist)
          {
              System.out.println(c);
          }

          去除首尾空白字符

          其实用的不太多，具体可以看廖雪峰的教程，一般就是trim()方法,截去字符串两端的空格，但对于中间的空格不处理。

          查找indexOf()

          这个菜鸟教程讲的挺细的可以看看。indexOf() 方法有以下四种形式：

            @@ -256,24 +244,14 @@ 

            public int indexOf(int ch )
            public int indexOf(int ch, int fromIndex)
            int indexOf(String str)
            int indexOf(String str, int fromIndex)
            - - -

            lastIndexOf() 则差不多，进行反向搜索
            还有startsWith(),endsWith()

            字串提取

            contains()可以判断给定字串是否存在于原string当中

            String str = "abcde";
            int index = str.indexOf(“bcd”); 
            //判断是否包含指定字符串，包含则返回第一次出现该字符串的索引，不包含则返回-1
            boolean b2 = str.contains("bcd");
            //判断是否包含指定字符串，包含返回true，不包含返回false
            - -

            substring()方法,索引从 0 开始。返回一个新字符串。

            -
            public String substring(int beginIndex)

            public String substring(int beginIndex, int endIndex)
            - +

            substring()方法,索引从 0 开始。返回一个新字符串。

            public String substring(int beginIndex)

            public String substring(int beginIndex, int endIndex)

            public class Test {
                public static void main(String args[]) {
                    String Str = new String("12345678908868");
             
                    System.out.print("返回值 :" );
                    System.out.println(Str.substring(4) );
             
                    System.out.print("返回值 :" );
                    System.out.println(Str.substring(4, 10) );
                }
            }
            - -

            替换子串replace()

            要在字符串中替换子串，有两种方法即根据字符或字符串替换replace()

            -
            String s = "hello";
            s.replace('l', 'w'); 
            s.replace("ll", "~~");
            - +

            替换子串replace()

            要在字符串中替换子串，有两种方法即根据字符或字符串替换replace()

            String s = "hello";
            s.replace('l', 'w'); 
            s.replace("ll", "~~");

            分割字符串split()

            split()方法，里面可以用正则表达式 

            String s = "A,B,C,D";
            String[] ss = s.split("\\,");
            -

            valueOf()

            做题的话感觉，主要用于char[]，其他数字类型的转换，当让也能用之前new的方法操作。

            public class Test {
                public static void main(String args[]) {
                    double d = 1100.00;
                    boolean b = true;
                    long l = 1234567890;
                    char[] arr = {'r', 'u', 'n', 'o', 'o', 'b' };

                    System.out.println("返回值 : " + String.valueOf(d) );
                    System.out.println("返回值 : " + String.valueOf(b) );
                    System.out.println("返回值 : " + String.valueOf(l) );
                    System.out.println("返回值 : " + String.valueOf(arr) );
                }
            }
            @@ -579,7 +557,7 @@

          • - 编译原理 + 数据库系统
          • @@ -587,15 +565,15 @@

          • - Hexo + 编译原理
          • - 数据库系统 + Go
          • - Go + Hexo
          • diff --git "a/2020/09/10/\346\225\260\346\215\256\345\272\223E-R\345\233\276\344\273\213\347\273\215/index.html" "b/2020/09/10/\346\225\260\346\215\256\345\272\223E-R\345\233\276\344\273\213\347\273\215/index.html" index 4e238041..05ace924 100644 --- "a/2020/09/10/\346\225\260\346\215\256\345\272\223E-R\345\233\276\344\273\213\347\273\215/index.html" +++ "b/2020/09/10/\346\225\260\346\215\256\345\272\223E-R\345\233\276\344\273\213\347\273\215/index.html" @@ -212,8 +212,7 @@

            -

            教师节快乐，害，今天听了一整天的新裤子的关于夜晚和失眠的世界，果然我还是喜欢music和乐队还有老歌，9月10号嗯，今天的到来其实也宣告暑假的一切都告一段落了（祝国赛的朋友们都能取得好成绩！），新学期开始了，害又要开始学习了，第一节课老师就来整英语，真难为我，呜呜呜。行吧，正好做作业就写写数据库的东西吧，首先声明这篇博客差不多是一种笔记吧，大部分的文字来源于书本和网上的博客，书本是王珊和萨师煊的《数据库系统概论》，博客的话参考了比较多，这里就挂一两个吧E-R 图简介,数据库的设计

            - +

            教师节快乐，害，今天听了一整天的新裤子的关于夜晚和失眠的世界，果然我还是喜欢music和乐队还有老歌，9月10号嗯，今天的到来其实也宣告暑假的一切都告一段落了（祝国赛的朋友们都能取得好成绩！），新学期开始了，害又要开始学习了，第一节课老师就来整英语，真难为我，呜呜呜。行吧，正好做作业就写写数据库的东西吧，首先声明这篇博客差不多是一种笔记吧，大部分的文字来源于书本和网上的博客，书本是王珊和萨师煊的《数据库系统概论》，博客的话参考了比较多，这里就挂一两个吧E-R 图简介,数据库的设计

            数据库E-R图介绍

            E-R模型是指Entity Relationship Diagrams（实体关系模型）
            E-R图3个要素：实体，属性，关系。E-R图提供了表示实体型、属性和联系的方法。

            实例——图书借阅管理系统

            数据库要求提供下述服务：

            XGBoost是陈天奇等人开发的一个开源机器学习项目，高效地实现了GBDT算法并进行了算法和工程上的许多改进，被广泛应用在Kaggle竞赛及其他许多机器学习竞赛中并取得了不错的成绩。XGBoost本质上还是一个GBDT，但是力争把速度和效率发挥到极致，所以叫X (Extreme) GBoosted， 包括前面说过，两者都是boosting方法。XGBoost是一个优化的分布式梯度增强库，旨在实现高效，灵活和便携。 它在Gradient Boosting框架下实现机器学习算法。 XGBoost提供了并行树提升（也称为GBDT，GBM），可以快速准确地解决许多数据科学问题。 相同的代码在主要的分布式环境（Hadoop，SGE，MPI）上运行，并且可以解决超过数十亿个样例的问题。XGBoost利用了核外计算并且能够使数据科学家在一个主机上处理数亿的样本数据。最终，将这些技术进行结合来做一个端到端的系统以最少的集群系统来扩展到更大的数据集上。Xgboost以CART决策树为子模型，通过Gradient Tree Boosting实现多棵CART树的集成学习，得到最终模型。下面我们来看看XGBoost的最终模型构建：

            引用陈天奇的论文，我们的数据为：$\mathcal{D}=\left{\left(\mathbf{x}{i}, y{i}\right)\right}\left(|\mathcal{D}|=n, \mathbf{x}{i} \in \mathbb{R}^{m}, y{i} \in \mathbb{R}\right)$
            (1) 构造目标函数：
            假设有K棵树，则第i个样本的输出为$\hat{y}{i}=\phi\left(\mathrm{x}{i}\right)=\sum_{k=1}^{K} f_{k}\left(\mathrm{x}{i}\right), \quad f{k} \in \mathcal{F}$，其中，$\mathcal{F}=\left{f(\mathbf{x})=w_{q(\mathbf{x})}\right}\left(q: \mathbb{R}^{m} \rightarrow T, w \in \mathbb{R}^{T}\right)$
            因此，目标函数的构建为：
            $$
            \mathcal{L}(\phi)=\sum_{i} l\left(\hat{y}{i}, y{i}\right)+\sum_{k} \Omega\left(f_{k}\right)
            $$
            其中，$\sum_{i} l\left(\hat{y}{i}, y{i}\right)$为loss function，$\sum_{k} \Omega\left(f_{k}\right)$为正则化项。
            (2) 叠加式的训练(Additive Training)：
            给定样本$x_i$，$\hat{y}i^{(0)} = 0$(初始预测)，$\hat{y}_i^{(1)} = \hat{y}_i^{(0)} + f_1(x_i)$，$\hat{y}_i^{(2)} = \hat{y}_i^{(0)} + f_1(x_i) + f_2(x_i) = \hat{y}_i^{(1)} + f_2(x_i)$…….以此类推，可以得到：$ \hat{y}_i^{(K)} = \hat{y}_i^{(K-1)} + f_K(x_i)$ ，其中，$ \hat{y}_i^{(K-1)} $ 为前K-1棵树的预测结果，$ f_K(x_i)$ 为第K棵树的预测结果。
            因此，目标函数可以分解为：
            $$
            \mathcal{L}^{(K)}=\sum            {i=1}^{n} l\left(y_{i}, \hat{y}{i}^{(K-1)}+f{K}\left(\mathrm{x}{i}\right)\right)+\sum{k} \Omega\left(f_{k}\right)
            $$
            由于正则化项也可以分解为前K-1棵树的复杂度加第K棵树的复杂度，因此：$\mathcal{L}^{(K)}=\sum_{i=1}^{n} l\left(y_{i}, \hat{y}{i}^{(K-1)}+f{K}\left(\mathrm{x}{i}\right)\right)+\sum{k=1} ^{K-1}\Omega\left(f_{k}\right)+\Omega\left(f_{K}\right)$，由于$\sum_{k=1} ^{K-1}\Omega\left(f_{k}\right)$在模型构建到第K棵树的时候已经固定，无法改变，因此是一个已知的常数，可以在最优化的时候省去，故：
            $$
            \mathcal{L}^{(K)}=\sum_{i=1}^{n} l\left(y_{i}, \hat{y}{i}^{(K-1)}+f{K}\left(\mathrm{x}{i}\right)\right)+\Omega\left(f{K}\right)
            $$
            (3) 使用泰勒级数近似目标函数：
            $$
            \mathcal{L}^{(K)} \simeq \sum_{i=1}^{n}\left[l\left(y_{i}, \hat{y}^{(K-1)}\right)+g_{i} f_{K}\left(\mathrm{x}{i}\right)+\frac{1}{2} h{i} f_{K}^{2}\left(\mathrm{x}{i}\right)\right]+\Omega\left(f{K}\right)
            $$
            其中，$g_{i}=\partial_{\hat{y}(t-1)} l\left(y_{i}, \hat{y}^{(t-1)}\right)$和$h_{i}=\partial_{\hat{y}^{(t-1)}}^{2} l\left(y_{i}, \hat{y}^{(t-1)}\right)$
            在这里，我们补充下泰勒级数的相关知识：
            在数学中，泰勒级数（英语：Taylor series）用无限项连加式——级数来表示一个函数，这些相加的项由函数在某一点的导数求得。具体的形式如下：
            $$
            f(x)=\frac{f\left(x_{0}\right)}{0 !}+\frac{f^{\prime}\left(x_{0}\right)}{1 !}\left(x-x_{0}\right)+\frac{f^{\prime \prime}\left(x_{0}\right)}{2 !}\left(x-x_{0}\right)^{2}+\ldots+\frac{f^{(n)}\left(x_{0}\right)}{n !}\left(x-x_{0}\right)^{n}+……
            $$
            由于$\sum_{i=1}^{n}l\left(y_{i}, \hat{y}^{(K-1)}\right)$在模型构建到第K棵树的时候已经固定，无法改变，因此是一个已知的常数，可以在最优化的时候省去，故：
            $$
            \tilde{\mathcal{L}}^{(K)}=\sum_{i=1}^{n}\left[g_{i} f_{K}\left(\mathbf{x}{i}\right)+\frac{1}{2} h{i} f_{K}^{2}\left(\mathbf{x}{i}\right)\right]+\Omega\left(f{K}\right)
            $$
            (4) 如何定义一棵树：
            为了说明如何定义一棵树的问题，我们需要定义几个概念：第一个概念是样本所在的节点位置$q(x)$，第二个概念是有哪些样本落在节点j上$I_{j}=\left{i \mid q\left(\mathbf{x}{i}\right)=j\right}$，第三个概念是每个结点的预测值$w{q(x)}$，第四个概念是模型复杂度$\Omega\left(f_{K}\right)$，它可以由叶子节点的个数以及节点函数值来构建，则：$\Omega\left(f_{K}\right) = \gamma T+\frac{1}{2} \lambda \sum_{j=1}^{T} w_{j}^{2}$。如下图的例子：
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t1tei3pE-1623946035306)(./16.png)]
            $q(x_1) = 1,q(x_2) = 3,q(x_3) = 1,q(x_4) = 2,q(x_5) = 3$，$I_1 = {1,3},I_2 = {4},I_3 = {2,5}$，$w = (15,12,20)$
            因此，目标函数用以上符号替代后：
            $$
            \begin{aligned}
            \tilde{\mathcal{L}}^{(K)} &=\sum_{i=1}^{n}\left[g_{i} f_{K}\left(\mathrm{x}{i}\right)+\frac{1}{2} h{i} f_{K}^{2}\left(\mathrm{x}{i}\right)\right]+\gamma T+\frac{1}{2} \lambda \sum{j=1}^{T} w_{j}^{2} \
            &=\sum_{j=1}^{T}\left[\left(\sum_{i \in I_{j}} g_{i}\right) w_{j}+\frac{1}{2}\left(\sum_{i \in I_{j}} h_{i}+\lambda\right) w_{j}^{2}\right]+\gamma T
            \end{aligned}
            $$
            由于我们的目标就是最小化目标函数，现在的目标函数化简为一个关于w的二次函数：$\tilde{\mathcal{L}}^{(K)}=\sum_{j=1}^{T}\left[\left(\sum_{i \in I_{j}} g_{i}\right) w_{j}+\frac{1}{2}\left(\sum_{i \in I_{j}} h_{i}+\lambda\right) w_{j}^{2}\right]+\gamma T$，根据二次函数求极值的公式：$y=ax^2 bx c$求极值，对称轴在$x=-\frac{b}{2 a}$，极值为$y=\frac{4 a c-b^{2}}{4 a}$，因此：
            $$
            w_{j}^{*}=-\frac{\sum_{i \in I_{j}} g_{i}}{\sum_{i \in I_{j}} h_{i}+\lambda}
            $$
            以及
            $$
            \tilde{\mathcal{L}}^{(K)}(q)=-\frac{1}{2} \sum_{j=1}^{T} \frac{\left(\sum_{i \in I_{j}} g_{i}\right)^{2}}{\sum_{i \in I_{j}} h_{i}+\lambda}+\gamma T
            $$
            (5) 如何寻找树的形状：
            不难发现，刚刚的讨论都是基于树的形状已经确定了计算$w$和$L$，但是实际上我们需要像学习决策树一样找到树的形状。因此，我们借助决策树学习的方式，使用目标函数的变化来作为分裂节点的标准。我们使用一个例子来说明：
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nCrhWA4S-1623946035310)(./17.png)]
            例子中有8个样本，分裂方式如下，因此:
            $$
            \tilde{\mathcal{L}}^{(old)} = -\frac{1}{2}[\frac{(g_7 + g_8)^2}{H_7+H_8 + \lambda} + \frac{(g_1 +…+ g_6)^2}{H_1+…+H_6 + \lambda}] + 2\gamma \
            \tilde{\mathcal{L}}^{(new)} = -\frac{1}{2}[\frac{(g_7 + g_8)^2}{H_7+H_8 + \lambda} + \frac{(g_1 +…+ g_3)^2}{H_1+…+H_3 + \lambda} + \frac{(g_4 +…+ g_6)^2}{H_4+…+H_6 + \lambda}] + 3\gamma\
            \tilde{\mathcal{L}}^{(old)} - \tilde{\mathcal{L}}^{(new)} = \frac{1}{2}[ \frac{(g_1 +…+ g_3)^2}{H_1+…+H_3 + \lambda} + \frac{(g_4 +…+ g_6)^2}{H_4+…+H_6 + \lambda} - \frac{(g_1+…+g_6)^2}{h_1+…+h_6+\lambda}] - \gamma
            $$
            因此，从上面的例子看出：分割节点的标准为$max{\tilde{\mathcal{L}}^{(old)} - \tilde{\mathcal{L}}^{(new)} }$，即：
            $$
            \mathcal{L}{\text {split }}=\frac{1}{2}\left[\frac{\left(\sum{i \in I_{L}} g_{i}\right)^{2}}{\sum_{i \in I_{L}} h_{i}+\lambda}+\frac{\left(\sum_{i \in I_{R}} g_{i}\right)^{2}}{\sum_{i \in I_{R}} h_{i}+\lambda}-\frac{\left(\sum_{i \in I} g_{i}\right)^{2}}{\sum_{i \in I} h_{i}+\lambda}\right]-\gamma
            $$
            (6.1) 精确贪心分裂算法：
            XGBoost在生成新树的过程中，最基本的操作是节点分裂。节点分裂中最重 要的环节是找到最优特征及最优切分点, 然后将叶子节点按照最优特征和最优切 分点进行分裂。选取最优特征和最优切分点的一种思路如下：首先找到所有的候 选特征及所有的候选切分点, 一一求得其 $\mathcal{L}{\text {split }}$, 然后选择$\mathcal{L}{\mathrm{split}}$ 最大的特征及 对应切分点作为最优特征和最优切分点。我们称此种方法为精确贪心算法。该算法是一种启发式算法, 因为在节点分裂时只选择当前最优的分裂策略, 而非全局最优的分裂策略。精确贪心算法的计算过程如下所示：

            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HRrbM0fp-1623946035312)(./18.png)]

            (6.2) 基于直方图的近似算法：
            精确贪心算法在选择最优特征和最优切分点时是一种十分有效的方法。它计算了所有特征、所有切分点的收益, 并从中选择了最优的, 从而保证模型能比较好地拟合了训练数据。但是当数据不能完全加载到内存时，精确贪心算法会变得 非常低效，算法在计算过程中需要不断在内存与磁盘之间进行数据交换，这是个非常耗时的过程, 并且在分布式环境中面临同样的问题。为了能够更高效地选 择最优特征及切分点, XGBoost提出一种近似算法来解决该问题。 基于直方图的近似算法的主要思想是：对某一特征寻找最优切分点时，首先对该特征的所有切分点按分位数 (如百分位) 分桶, 得到一个候选切分点集。特征的每一个切分点都可以分到对应的分桶; 然后，对每个桶计算特征统计G和H得到直方图, G为该桶内所有样本一阶特征统计g之和, H为该桶内所有样本二阶特征统计h之和; 最后，选择所有候选特征及候选切分点中对应桶的特征统计收益最大的作为最优特征及最优切分点。基于直方图的近似算法的计算过程如下所示：

            1. 对于每个特征 $k=1,2, \cdots, m,$ 按分位数对特征 $k$ 分桶 $\Theta,$ 可得候选切分点, $S_{k}=\left{S_{k 1}, S_{k 2}, \cdots, S_{k l}\right}^{1}$
            2. 对于每个特征 $k=1,2, \cdots, m,$ 有：
              $$
              \begin{array}{l}
              G_{k v} \leftarrow=\sum_{j \in\left{j \mid s_{k, v} \geq \mathbf{x}{j k}>s{k, v-1;}\right}} g_{j} \
              H_{k v} \leftarrow=\sum_{j \in\left{j \mid s_{k, v} \geq \mathbf{x}{j k}>s{k, v-1;}\right}} h_{j}
              \end{array}
              $$
            3. 类似精确贪心算法，依据梯度统计找到最大增益的候选切分点。
              下面用一个例子说明基于直方图的近似算法：
              假设有一个年龄特征，其特征的取值为18、19、21、31、36、37、55、57，我们需要使用近似算法找到年龄这个特征的最佳分裂点：
              [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MKLD2poX-1623946035314)(./19.png)]

            近似算法实现了两种候选切分点的构建策略：全局策略和本地策略。全局策略是在树构建的初始阶段对每一个特征确定一个候选切分点的集合, 并在该树每一层的节点分裂中均采用此集合计算收益, 整个过程候选切分点集合不改变。本地策略则是在每一次节点分裂时均重新确定候选切分点。全局策略需要更细的分桶才能达到本地策略的精确度, 但全局策略在选取候选切分点集合时比本地策略更简单。在XGBoost系统中, 用户可以根据需求自由选择使用精确贪心算法、近似算法全局策略、近似算法本地策略, 算法均可通过参数进行配置。

            以上是XGBoost的理论部分，下面我们对XGBoost系统进行详细的讲解：
            官方文档：https://xgboost.readthedocs.io/en/latest/python/python_intro.html
            知乎总结：https://zhuanlan.zhihu.com/p/143009353 

            # XGBoost原生工具库的上手：
            import xgboost as xgb  # 引入工具库
            # read in data
            dtrain = xgb.DMatrix('demo/data/agaricus.txt.train')   # XGBoost的专属数据格式，但是也可以用dataframe或者ndarray
            dtest = xgb.DMatrix('demo/data/agaricus.txt.test')  # # XGBoost的专属数据格式，但是也可以用dataframe或者ndarray
            # specify parameters via map
            param = {'max_depth':2, 'eta':1, 'objective':'binary:logistic' }    # 设置XGB的参数，使用字典形式传入
            num_round = 2     # 使用线程数
            bst = xgb.train(param, dtrain, num_round)   # 训练
            # make prediction
            preds = bst.predict(dtest)   # 预测

            XGBoost的参数设置(括号内的名称为sklearn接口对应的参数名字):
            推荐博客：https://link.zhihu.com/?target=https%3A//blog.csdn.net/luanpeng825485697/article/details/79907149
            推荐官方文档：https://link.zhihu.com/?target=https%3A//xgboost.readthedocs.io/en/latest/parameter.html

            XGBoost的参数分为三种：

            • 通用参数：（两种类型的booster，因为tree的性能比线性回归好得多，因此我们很少用线性回归。）

              • booster:使用哪个弱学习器训练，默认gbtree，可选gbtree，gblinear 或dart
              • nthread：用于运行XGBoost的并行线程数，默认为最大可用线程数
              • verbosity：打印消息的详细程度。有效值为0（静默），1（警告），2（信息），3（调试）。
              • Tree Booster的参数：
                • eta（learning_rate）：learning_rate，在更新中使用步长收缩以防止过度拟合，默认= 0.3，范围：[0,1]；典型值一般设置为：0.01-0.2
                • gamma（min_split_loss）：默认= 0，分裂节点时，损失函数减小值只有大于等于gamma节点才分裂，gamma值越大，算法越保守，越不容易过拟合，但性能就不一定能保证，需要平衡。范围：[0，∞]
                • max_depth：默认= 6，一棵树的最大深度。增加此值将使模型更复杂，并且更可能过度拟合。范围：[0，∞]
                • min_child_weight：默认值= 1，如果新分裂的节点的样本权重和小于min_child_weight则停止分裂 。这个可以用来减少过拟合，但是也不能太高，会导致欠拟合。范围：[0，∞]
                • max_delta_step：默认= 0，允许每个叶子输出的最大增量步长。如果将该值设置为0，则表示没有约束。如果将其设置为正值，则可以帮助使更新步骤更加保守。通常不需要此参数，但是当类极度不平衡时，它可能有助于逻辑回归。将其设置为1-10的值可能有助于控制更新。范围：[0，∞]
                • subsample：默认值= 1，构建每棵树对样本的采样率，如果设置成0.5，XGBoost会随机选择一半的样本作为训练集。范围：（0,1]
                • sampling_method：默认= uniform，用于对训练实例进行采样的方法。
                  • uniform：每个训练实例的选择概率均等。通常将subsample> = 0.5 设置 为良好的效果。
                  • gradient_based：每个训练实例的选择概率与规则化的梯度绝对值成正比，具体来说就是$\sqrt{g^2+\lambda h^2}$，subsample可以设置为低至0.1，而不会损失模型精度。
                • colsample_bytree：默认= 1，列采样率，也就是特征采样率。范围为（0，1]
                • lambda（reg_lambda）：默认=1，L2正则化权重项。增加此值将使模型更加保守。
                • alpha（reg_alpha）：默认= 0，权重的L1正则化项。增加此值将使模型更加保守。
                • tree_method：默认=auto，XGBoost中使用的树构建算法。
                  • auto：使用启发式选择最快的方法。
                    • 对于小型数据集，exact将使用精确贪婪（）。
                    • 对于较大的数据集，approx将选择近似算法（）。它建议尝试hist，gpu_hist，用大量的数据可能更高的性能。（gpu_hist）支持。external memory外部存储器。
                  • exact：精确的贪婪算法。枚举所有拆分的候选点。
                  • approx：使用分位数和梯度直方图的近似贪婪算法。
                  • hist：更快的直方图优化的近似贪婪算法。（LightGBM也是使用直方图算法）
                  • gpu_hist：GPU hist算法的实现。
                • scale_pos_weight:控制正负权重的平衡，这对于不平衡的类别很有用。Kaggle竞赛一般设置sum(negative instances) / sum(positive instances)，在类别高度不平衡的情况下，将参数设置大于0，可以加快收敛。
                • num_parallel_tree：默认=1，每次迭代期间构造的并行树的数量。此选项用于支持增强型随机森林。
                • monotone_constraints：可变单调性的约束，在某些情况下，如果有非常强烈的先验信念认为真实的关系具有一定的质量，则可以使用约束条件来提高模型的预测性能。（例如params_constrained[‘monotone_constraints’] = “(1,-1)”，(1,-1)我们告诉XGBoost对第一个预测变量施加增加的约束，对第二个预测变量施加减小的约束。）
              • Linear Booster的参数：
                • lambda（reg_lambda）：默认= 0，L2正则化权重项。增加此值将使模型更加保守。归一化为训练示例数。
                • alpha（reg_alpha）：默认= 0，权重的L1正则化项。增加此值将使模型更加保守。归一化为训练示例数。
                • updater：默认= shotgun。
                  • shotgun：基于shotgun算法的平行坐标下降算法。使用“ hogwild”并行性，因此每次运行都产生不确定的解决方案。
                  • coord_descent：普通坐标下降算法。同样是多线程的，但仍会产生确定性的解决方案。
                • feature_selector：默认= cyclic。特征选择和排序方法
                  • cyclic：通过每次循环一个特征来实现的。
                  • shuffle：类似于cyclic，但是在每次更新之前都有随机的特征变换。
                  • random：一个随机(有放回)特征选择器。
                  • greedy：选择梯度最大的特征。（贪婪选择）
                  • thrifty：近似贪婪特征选择（近似于greedy）
                • top_k：要选择的最重要特征数（在greedy和thrifty内）

            • 任务参数（这个参数用来控制理想的优化目标和每一步结果的度量方法。）

              • objective：默认=reg:squarederror，表示最小平方误差。
                • reg:squarederror,最小平方误差。
                • reg:squaredlogerror,对数平方损失。$\frac{1}{2}[log(pred+1)-log(label+1)]^2$
                • reg:logistic,逻辑回归
                • reg:pseudohubererror,使用伪Huber损失进行回归，这是绝对损失的两倍可微选择。
                • binary:logistic,二元分类的逻辑回归，输出概率。
                • binary:logitraw：用于二进制分类的逻辑回归，逻辑转换之前的输出得分。
                • binary:hinge：二进制分类的铰链损失。这使预测为0或1，而不是产生概率。（SVM就是铰链损失函数）
                • count:poisson –计数数据的泊松回归，泊松分布的输出平均值。
                • survival:cox：针对正确的生存时间数据进行Cox回归（负值被视为正确的生存时间）。
                • survival:aft：用于检查生存时间数据的加速故障时间模型。
                • aft_loss_distribution：survival:aft和aft-nloglik度量标准使用的概率密度函数。
                • multi:softmax：设置XGBoost以使用softmax目标进行多类分类，还需要设置num_class（类数）
                • multi:softprob：与softmax相同，但输出向量，可以进一步重整为矩阵。结果包含属于每个类别的每个数据点的预测概率。
                • rank:pairwise：使用LambdaMART进行成对排名，从而使成对损失最小化。
                • rank:ndcg：使用LambdaMART进行列表式排名，使标准化折让累积收益（NDCG）最大化。
                • rank:map：使用LambdaMART进行列表平均排名，使平均平均精度（MAP）最大化。
                • reg:gamma：使用对数链接进行伽马回归。输出是伽马分布的平均值。
                • reg:tweedie：使用对数链接进行Tweedie回归。
                • 自定义损失函数和评价指标：https://xgboost.readthedocs.io/en/latest/tutorials/custom_metric_obj.html
              • eval_metric：验证数据的评估指标，将根据目标分配默认指标（回归均方根，分类误差，排名的平均平均精度），用户可以添加多个评估指标
                • rmse，均方根误差； rmsle：均方根对数误差； mae：平均绝对误差；mphe：平均伪Huber错误；logloss：负对数似然； error：二进制分类错误率；
                • merror：多类分类错误率； mlogloss：多类logloss； auc：曲线下面积； aucpr：PR曲线下的面积；ndcg：归一化累计折扣；map：平均精度；
              • seed ：随机数种子，[默认= 0]。

            • 命令行参数（这里不说了，因为很少用命令行控制台版本）

            from IPython.display import IFrame
            IFrame('https://xgboost.readthedocs.io/en/latest/parameter.html', width=1400, height=800)

            XGBoost的调参说明：

            参数调优的一般步骤

              1. 确定学习速率和提升参数调优的初始值
              1. max_depth 和 min_child_weight 参数调优
              1. gamma参数调优
              1. subsample 和 colsample_bytree 参数优
              1. 正则化参数alpha调优
              1. 降低学习速率和使用更多的决策树

            XGBoost详细攻略：
            具体的api请查看：https://xgboost.readthedocs.io/en/latest/python/python_api.html
            推荐github：https://github.com/dmlc/xgboost/tree/master/demo/guide-python

            安装XGBoost：
            方式1：pip3 install xgboost
            方式2：pip install xgboost

            数据接口（XGBoost可处理的数据格式DMatrix）

            # 1.LibSVM文本格式文件
            dtrain = xgb.DMatrix('train.svm.txt')
            dtest = xgb.DMatrix('test.svm.buffer')
            # 2.CSV文件(不能含类别文本变量，如果存在文本变量请做特征处理如one-hot)
            dtrain = xgb.DMatrix('train.csv?format=csv&label_column=0')
            dtest = xgb.DMatrix('test.csv?format=csv&label_column=0')
            # 3.NumPy数组
            data = np.random.rand(5, 10)  # 5 entities, each contains 10 features
            label = np.random.randint(2, size=5)  # binary target
            dtrain = xgb.DMatrix(data, label=label)
            # 4.scipy.sparse数组
            csr = scipy.sparse.csr_matrix((dat, (row, col)))
            dtrain = xgb.DMatrix(csr)
            # pandas数据框dataframe
            data = pandas.DataFrame(np.arange(12).reshape((4,3)), columns=['a', 'b', 'c'])
            label = pandas.DataFrame(np.random.randint(2, size=4))
            dtrain = xgb.DMatrix(data, label=label)

            笔者推荐：先保存到XGBoost二进制文件中将使加载速度更快，然后再加载进来

            # 1.保存DMatrix到XGBoost二进制文件中
            dtrain = xgb.DMatrix('train.svm.txt')
            dtrain.save_binary('train.buffer')
            # 2. 缺少的值可以用DMatrix构造函数中的默认值替换：
            dtrain = xgb.DMatrix(data, label=label, missing=-999.0)
            # 3.可以在需要时设置权重：
            w = np.random.rand(5, 1)
            dtrain = xgb.DMatrix(data, label=label, missing=-999.0, weight=w)

            参数的设置方式：

            import pandas as pd
            # 加载并处理数据
            df_wine = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data',header=None)
            df_wine.columns = ['Class label', 'Alcohol','Malic acid', 'Ash','Alcalinity of ash','Magnesium', 'Total phenols',
                               'Flavanoids', 'Nonflavanoid phenols','Proanthocyanins','Color intensity', 'Hue','OD280/OD315 of diluted wines','Proline'] 
            df_wine = df_wine[df_wine['Class label'] != 1]  # drop 1 class      
            y = df_wine['Class label'].values
            X = df_wine[['Alcohol','OD280/OD315 of diluted wines']].values
            from sklearn.model_selection import train_test_split  # 切分训练集与测试集
            from sklearn.preprocessing import LabelEncoder   # 标签化分类变量
            le = LabelEncoder()
            y = le.fit_transform(y)
            X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1,stratify=y)
            dtrain = xgb.DMatrix(X_train, label=y_train)
            dtest = xgb.DMatrix(X_test)
            # 1.Booster 参数
            params = {
                'booster': 'gbtree',
                'objective': 'multi:softmax',  # 多分类的问题
                'num_class': 10,               # 类别数，与 multisoftmax 并用
                'gamma': 0.1,                  # 用于控制是否后剪枝的参数,越大越保守，一般0.1、0.2这样子。
                'max_depth': 12,               # 构建树的深度，越大越容易过拟合
                'lambda': 2,                   # 控制模型复杂度的权重值的L2正则化项参数，参数越大，模型越不容易过拟合。
                'subsample': 0.7,              # 随机采样训练样本
                'colsample_bytree': 0.7,       # 生成树时进行的列采样
                'min_child_weight': 3,
                'silent': 1,                   # 设置成1则没有运行信息输出，最好是设置为0.
                'eta': 0.007,                  # 如同学习率
                'seed': 1000,
                'nthread': 4,                  # cpu 线程数
                'eval_metric':'auc'
            }
            plst = list(params.items())
            # evallist = [(dtest, 'eval'), (dtrain, 'train')]   # 指定验证集

            训练：

            # 2.训练
            num_round = 10
            bst = xgb.train(plst, dtrain, num_round)
            #bst = xgb.train( plst, dtrain, num_round, evallist )

            保存模型：

            # 3.保存模型
            bst.save_model('0001.model')
            # dump model
            bst.dump_model('dump.raw.txt')
            # dump model with feature map
            #bst.dump_model('dump.raw.txt', 'featmap.txt')

            加载保存的模型：

            # 4.加载保存的模型：
            bst = xgb.Booster({'nthread': 4})  # init model
            bst.load_model('0001.model')  # load data

            设置早停机制：

            # 5.也可以设置早停机制（需要设置验证集）
            train(..., evals=evals, early_stopping_rounds=10)

            预测：

            # 6.预测
            ypred = bst.predict(dtest)

            绘制重要性特征图：

            # 1.绘制重要性
            xgb.plot_importance(bst)
            # 2.绘制输出树
            #xgb.plot_tree(bst, num_trees=2)
            # 3.使用xgboost.to_graphviz()将目标树转换为graphviz
            #xgb.to_graphviz(bst, num_trees=2)

            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ir9Nm1ZN-1623946035316)(output_27_1.png)]

            7. Xgboost算法案例

            分类案例

            from sklearn.datasets import load_iris
            import xgboost as xgb
            from xgboost import plot_importance
            import matplotlib.pyplot as plt
            from sklearn.model_selection import train_test_split
            from sklearn.metrics import accuracy_score # 准确率
            # 加载样本数据集
            iris = load_iris()
            X,y = iris.data,iris.target
            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234565) # 数据集分割

            params = {
                'booster' : 'gbtree',
                'objective': 'multi:softmax', # 多分类的问题
                'num_class': 3,
                'gamma': 0.1, # 默认= 0，分裂节点时，损失函数减小值只有大于等于gamma节点才分裂，gamma值越大，算法越保守，越不容易过拟合，但性能就不一定能保证，需要平衡。
                'max_depth': 12, # 树的最大深度
                'lambda': 2, # 控制模型复杂度的权重值的L2正则化项参数，参数越大，模型越不容易过拟合。
                'subsample': 0.7, # 随机采样训练样本
                'colsample_bytree': 0.7, # 生成树时进行的列采样,列采样率，也就是特征采样率
                'min_child_weight': 3,
                'silent': 0,
                'eta': 0.1,
                'seed': 1,
                'nthread': 4,
            }

            plst = list(params.items())
            dtrain = xgb.DMatrix(X_train,y_train)
            num_rounds = 500
            model = xgb.train(plst,dtrain,num_rounds) # xgboost模型训练

            # 对测试集进行预测
            dtest = xgb.DMatrix(X_test)
            y_pred = model.predict(dtest)

            # 计算准确率
            accuracy = accuracy_score(y_test,y_pred)
            print("accuarcy: %.2f%%" % (accuracy*100.0))

            # 显示重要特征
            plot_importance(model)
            plt.show()

            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8vD1cJWm-1623946035317)(output_30_1.png)]

            回归案例

            import xgboost as xgb
            from xgboost import plot_importance
            from matplotlib import pyplot as plt
            from sklearn.model_selection import train_test_split
            from sklearn.datasets import load_boston
            from sklearn.metrics import mean_squared_error


            # 加载数据集
            boston = load_boston()
            X,y = boston.data,boston.target

            # XGBoost训练过程
            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

            params = {
                'booster': 'gbtree',
                'objective': 'reg:squarederror',
                'gamma': 0.1,
                'max_depth': 5,
                'lambda': 3,
                'subsample': 0.7,
                'colsample_bytree': 0.7,
                'min_child_weight': 3,
                'silent': 1,
                'eta': 0.1,
                'seed': 1000,
                'nthread': 4,
            }

            dtrain = xgb.DMatrix(X_train, y_train)
            num_rounds = 300
            plst = list(params.items())
            model = xgb.train(plst, dtrain, num_rounds)

            # 对测试集进行预测
            dtest = xgb.DMatrix(X_test)
            ans = model.predict(dtest)

            # 显示重要特征
            plot_importance(model)
            plt.show()

            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Zu2NWnA-1623946035318)(output_32_1.png)]

            XGBoost调参（结合sklearn网格搜索）

            代码参考：https://www.jianshu.com/p/1100e333fcab

            import xgboost as xgb
            import pandas as pd
            from sklearn.model_selection import train_test_split
            from sklearn.model_selection import GridSearchCV
            from sklearn.metrics import roc_auc_score

            iris = load_iris()
            X,y = iris.data,iris.target
            col = iris.target_names 
            train_x, valid_x, train_y, valid_y = train_test_split(X, y, test_size=0.3, random_state=1)   # 分训练集和验证集
            parameters = {
                          'max_depth': [5, 10, 15, 20, 25],
                          'learning_rate': [0.01, 0.02, 0.05, 0.1, 0.15],
                          'n_estimators': [500, 1000, 2000, 3000, 5000],
                          'min_child_weight': [0, 2, 5, 10, 20],
                          'max_delta_step': [0, 0.2, 0.6, 1, 2],
                          'subsample': [0.6, 0.7, 0.8, 0.85, 0.95],
                          'colsample_bytree': [0.5, 0.6, 0.7, 0.8, 0.9],
                          'reg_alpha': [0, 0.25, 0.5, 0.75, 1],
                          'reg_lambda': [0.2, 0.4, 0.6, 0.8, 1],
                          'scale_pos_weight': [0.2, 0.4, 0.6, 0.8, 1]

            }

            xlf = xgb.XGBClassifier(max_depth=10,
                        learning_rate=0.01,
                        n_estimators=2000,
                        silent=True,
                        objective='multi:softmax',
                        num_class=3 ,          
                        nthread=-1,
                        gamma=0,
                        min_child_weight=1,
                        max_delta_step=0,
                        subsample=0.85,
                        colsample_bytree=0.7,
                        colsample_bylevel=1,
                        reg_alpha=0,
                        reg_lambda=1,
                        scale_pos_weight=1,
                        seed=0,
                        missing=None)

            gs = GridSearchCV(xlf, param_grid=parameters, scoring='accuracy', cv=3)
            gs.fit(train_x, train_y)

            print("Best score: %0.3f" % gs.best_score_)
            print("Best parameters set: %s" % gs.best_params_ )

            Best score: 0.933
            Best parameters set: {‘max_depth’: 5}

            8. LightGBM算法

            LightGBM也是像XGBoost一样，是一类集成算法，他跟XGBoost总体来说是一样的，算法本质上与Xgboost没有出入，只是在XGBoost的基础上进行了优化，因此就不对原理进行重复介绍，在这里我们来看看几种算法的差别：

            • 优化速度和内存使用
              • 降低了计算每个分割增益的成本。
              • 使用直方图减法进一步提高速度。
              • 减少内存使用。
              • 减少并行学习的计算成本。
            • 稀疏优化
              • 用离散的bin替换连续的值。如果#bins较小，则可以使用较小的数据类型（例如uint8_t）来存储训练数据 。
              • 无需存储其他信息即可对特征数值进行预排序 。
            • 精度优化
              • 使用叶子数为导向的决策树建立算法而不是树的深度导向。
              • 分类特征的编码方式的优化
              • 通信网络的优化
              • 并行学习的优化
              • GPU支持

            LightGBM的优点：

            　　1）更快的训练效率

            　　2）低内存使用

            　　3）更高的准确率

            　　4）支持并行化学习

            　　5）可以处理大规模数据

            1.速度对比：
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W562LSSA-1623946035318)(./速度对比.png)]
            2.准确率对比：
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J4JVvKjX-1623946035319)(./准确率对比.png)]
            3.内存使用量对比：
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-glXaoZd6-1623946035320)(./内存使用量.png)]

            LightGBM参数说明：
            推荐文档1：https://lightgbm.apachecn.org/#/docs/6
            推荐文档2：https://lightgbm.readthedocs.io/en/latest/Parameters.html

            1.核心参数：（括号内名称是别名）

            • objective（objective，app ，application）：默认regression，用于设置损失函数
              • 回归问题：
                • L2损失：regression（regression_l2，l2，mean_squared_error，mse，l2_root，root_mean_squared_error，rmse）
                • L1损失：regression_l1（l1, mean_absolute_error, mae）
                • 其他损失：huber，fair，poisson，quantile，mape，gamma，tweedie
              • 二分类问题：二进制对数损失分类（或逻辑回归）：binary
              • 多类别分类：
                • softmax目标函数： multiclass（softmax）
                • One-vs-All 目标函数：multiclassova（multiclass_ova，ova，ovr）
              • 交叉熵：
                • 用于交叉熵的目标函数（具有可选的线性权重）：cross_entropy（xentropy）
                • 交叉熵的替代参数化：cross_entropy_lambda（xentlambda）
            • boosting ：默认gbdt，设置提升类型，选项有gbdt，rf，dart，goss，别名：boosting_type，boost
              • gbdt（gbrt）:传统的梯度提升决策树
              • rf（random_forest）：随机森林
              • dart：多个加性回归树的DROPOUT方法 Dropouts meet Multiple Additive Regression Trees，参见：https://arxiv.org/abs/1505.01866
              • goss：基于梯度的单边采样 Gradient-based One-Side Sampling
            • data（train，train_data，train_data_file，data_filename）：用于训练的数据或数据file
            • valid （test，valid_data，valid_data_file，test_data，test_data_file，valid_filenames）：验证/测试数据的路径，LightGBM将输出这些数据的指标
            • num_iterations：默认=100，类型= INT
            • n_estimators：提升迭代次数，*LightGBM构造用于多类分类问题的树num_class * num_iterations*
            • learning_rate（shrinkage_rate，eta） ：收缩率，默认=0.1
            • num_leaves（num_leaf，max_leaves，max_leaf） ：默认=31，一棵树上的最大叶子数
            • tree_learner （tree，tree_type，tree_learner_type）：默认=serial，可选：serial，feature，data，voting
              • serial：单台机器的 tree learner
              • feature：特征并行的 tree learner
              • data：数据并行的 tree learner
              • voting：投票并行的 tree learner
            • num_threads（num_thread, nthread）：LightGBM 的线程数，为了更快的速度, 将此设置为真正的 CPU 内核数, 而不是线程的数量 (大多数 CPU 使用超线程来使每个 CPU 内核生成 2 个线程)，当你的数据集小的时候不要将它设置的过大 (比如, 当数据集有 10,000 行时不要使用 64 线程)，对于并行学习, 不应该使用全部的 CPU 内核, 因为这会导致网络性能不佳。
            • device（device_type）：默认cpu，为树学习选择设备, 你可以使用 GPU 来获得更快的学习速度，可选cpu, gpu。
            • seed （random_seed，random_state）：与其他种子相比，该种子具有较低的优先级，这意味着如果您明确设置其他种子，它将被覆盖。

            2.用于控制模型学习过程的参数：

            • max_depth：限制树模型的最大深度. 这可以在 #data 小的情况下防止过拟合. 树仍然可以通过 leaf-wise 生长。
            • min_data_in_leaf： 默认=20，一个叶子上数据的最小数量. 可以用来处理过拟合。
            • min_sum_hessian_in_leaf（min_sum_hessian_per_leaf, min_sum_hessian, min_hessian）：默认=1e-3，一个叶子上的最小 hessian 和. 类似于 min_data_in_leaf, 可以用来处理过拟合.
            • feature_fraction：default=1.0，如果 feature_fraction 小于 1.0, LightGBM 将会在每次迭代中随机选择部分特征. 例如, 如果设置为 0.8, 将会在每棵树训练之前选择 80% 的特征，可以用来加速训练，可以用来处理过拟合。
            • feature_fraction_seed：默认=2，feature_fraction 的随机数种子。
            • bagging_fraction（sub_row, subsample）：默认=1，不进行重采样的情况下随机选择部分数据
            • bagging_freq（subsample_freq）：bagging 的频率, 0 意味着禁用 bagging. k 意味着每 k 次迭代执行bagging
            • bagging_seed（bagging_fraction_seed） ：默认=3，bagging 随机数种子。
            • early_stopping_round（early_stopping_rounds, early_stopping）：默认=0，如果一个验证集的度量在 early_stopping_round 循环中没有提升, 将停止训练
            • lambda_l1（reg_alpha）：L1正则化系数
            • lambda_l2（reg_lambda）：L2正则化系数
            • min_split_gain（min_gain_to_split）：执行切分的最小增益，默认=0.
            • cat_smooth：默认=10，用于分类特征，可以降低噪声在分类特征中的影响, 尤其是对数据很少的类别

            3.度量参数：

            • metric：default={l2 for regression}, {binary_logloss for binary classification}, {ndcg for lambdarank}, type=multi-enum, options=l1, l2, ndcg, auc, binary_logloss, binary_error …
              • l1, absolute loss, alias=mean_absolute_error, mae
              • l2, square loss, alias=mean_squared_error, mse
              • l2_root, root square loss, alias=root_mean_squared_error, rmse
              • quantile, Quantile regression
              • huber, Huber loss
              • fair, Fair loss
              • poisson, Poisson regression
              • ndcg, NDCG
              • map, MAP
              • auc, AUC
              • binary_logloss, log loss
              • binary_error, 样本: 0 的正确分类, 1 错误分类
              • multi_logloss, mulit-class 损失日志分类
              • multi_error, error rate for mulit-class 出错率分类
              • xentropy, cross-entropy (与可选的线性权重), alias=cross_entropy
              • xentlambda, “intensity-weighted” 交叉熵, alias=cross_entropy_lambda
              • kldiv, Kullback-Leibler divergence, alias=kullback_leibler
              • 支持多指标, 使用 , 分隔
            • train_metric（training_metric, is_training_metric）：默认=False，如果你需要输出训练的度量结果则设置 true

            4.GPU 参数：

            • gpu_device_id：default为-1, 这个default意味着选定平台上的设备。

            LightGBM与网格搜索结合调参：
            参考代码：https://blog.csdn.net/u012735708/article/details/83749703

            import lightgbm as lgb
            from sklearn import metrics
            from sklearn.datasets import load_breast_cancer
            from sklearn.model_selection import train_test_split
             
            canceData=load_breast_cancer()
            X=canceData.data
            y=canceData.target
            X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=0,test_size=0.2)
             
            ### 数据转换
            print('数据转换')
            lgb_train = lgb.Dataset(X_train, y_train, free_raw_data=False)
            lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train,free_raw_data=False)
             
            ### 设置初始参数--不含交叉验证参数
            print('设置参数')
            params = {
                      'boosting_type': 'gbdt',
                      'objective': 'binary',
                      'metric': 'auc',
                      'nthread':4,
                      'learning_rate':0.1
                      }
             
            ### 交叉验证(调参)
            print('交叉验证')
            max_auc = float('0')
            best_params = {}
             
            # 准确率
            print("调参1：提高准确率")
            for num_leaves in range(5,100,5):
                for max_depth in range(3,8,1):
                    params['num_leaves'] = num_leaves
                    params['max_depth'] = max_depth
             
                    cv_results = lgb.cv(
                                        params,
                                        lgb_train,
                                        seed=1,
                                        nfold=5,
                                        metrics=['auc'],
                                        early_stopping_rounds=10,
                                        verbose_eval=True
                                        )
                        
                    mean_auc = pd.Series(cv_results['auc-mean']).max()
                    boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
                        
                    if mean_auc >= max_auc:
                        max_auc = mean_auc
                        best_params['num_leaves'] = num_leaves
                        best_params['max_depth'] = max_depth
            if 'num_leaves' and 'max_depth' in best_params.keys():          
                params['num_leaves'] = best_params['num_leaves']
                params['max_depth'] = best_params['max_depth']
             
            # 过拟合
            print("调参2：降低过拟合")
            for max_bin in range(5,256,10):
                for min_data_in_leaf in range(1,102,10):
                        params['max_bin'] = max_bin
                        params['min_data_in_leaf'] = min_data_in_leaf
                        
                        cv_results = lgb.cv(
                                            params,
                                            lgb_train,
                                            seed=1,
                                            nfold=5,
                                            metrics=['auc'],
                                            early_stopping_rounds=10,
                                            verbose_eval=True
                                            )
                                
                        mean_auc = pd.Series(cv_results['auc-mean']).max()
                        boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
             
                        if mean_auc >= max_auc:
                            max_auc = mean_auc
                            best_params['max_bin']= max_bin
                            best_params['min_data_in_leaf'] = min_data_in_leaf
            if 'max_bin' and 'min_data_in_leaf' in best_params.keys():
                params['min_data_in_leaf'] = best_params['min_data_in_leaf']
                params['max_bin'] = best_params['max_bin']
             
            print("调参3：降低过拟合")
            for feature_fraction in [0.6,0.7,0.8,0.9,1.0]:
                for bagging_fraction in [0.6,0.7,0.8,0.9,1.0]:
                    for bagging_freq in range(0,50,5):
                        params['feature_fraction'] = feature_fraction
                        params['bagging_fraction'] = bagging_fraction
                        params['bagging_freq'] = bagging_freq
                        
                        cv_results = lgb.cv(
                                            params,
                                            lgb_train,
                                            seed=1,
                                            nfold=5,
                                            metrics=['auc'],
                                            early_stopping_rounds=10,
                                            verbose_eval=True
                                            )
                                
                        mean_auc = pd.Series(cv_results['auc-mean']).max()
                        boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
             
                        if mean_auc >= max_auc:
                            max_auc=mean_auc
                            best_params['feature_fraction'] = feature_fraction
                            best_params['bagging_fraction'] = bagging_fraction
                            best_params['bagging_freq'] = bagging_freq
             
            if 'feature_fraction' and 'bagging_fraction' and 'bagging_freq' in best_params.keys():
                params['feature_fraction'] = best_params['feature_fraction']
                params['bagging_fraction'] = best_params['bagging_fraction']
                params['bagging_freq'] = best_params['bagging_freq']
             
             
            print("调参4：降低过拟合")
            for lambda_l1 in [1e-5,1e-3,1e-1,0.0,0.1,0.3,0.5,0.7,0.9,1.0]:
                for lambda_l2 in [1e-5,1e-3,1e-1,0.0,0.1,0.4,0.6,0.7,0.9,1.0]:
                    params['lambda_l1'] = lambda_l1
                    params['lambda_l2'] = lambda_l2
                    cv_results = lgb.cv(
                                        params,
                                        lgb_train,
                                        seed=1,
                                        nfold=5,
                                        metrics=['auc'],
                                        early_stopping_rounds=10,
                                        verbose_eval=True
                                        )
                            
                    mean_auc = pd.Series(cv_results['auc-mean']).max()
                    boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
             
                    if mean_auc >= max_auc:
                        max_auc=mean_auc
                        best_params['lambda_l1'] = lambda_l1
                        best_params['lambda_l2'] = lambda_l2
            if 'lambda_l1' and 'lambda_l2' in best_params.keys():
                params['lambda_l1'] = best_params['lambda_l1']
                params['lambda_l2'] = best_params['lambda_l2']
             
            print("调参5：降低过拟合2")
            for min_split_gain in [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]:
                params['min_split_gain'] = min_split_gain
                
                cv_results = lgb.cv(
                                    params,
                                    lgb_train,
                                    seed=1,
                                    nfold=5,
                                    metrics=['auc'],
                                    early_stopping_rounds=10,
                                    verbose_eval=True
                                    )
                        
                mean_auc = pd.Series(cv_results['auc-mean']).max()
                boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
             
                if mean_auc >= max_auc:
                    max_auc=mean_auc
                    
                    best_params['min_split_gain'] = min_split_gain
            if 'min_split_gain' in best_params.keys():
                params['min_split_gain'] = best_params['min_split_gain']
             
            print(best_params)

            {‘bagging_fraction’: 0.7,
            ‘bagging_freq’: 30,
            ‘feature_fraction’: 0.8,
            ‘lambda_l1’: 0.1,
            ‘lambda_l2’: 0.0,
            ‘max_bin’: 255,
            ‘max_depth’: 4,
            ‘min_data_in_leaf’: 81,
            ‘min_split_gain’: 0.1,
            ‘num_leaves’: 10}

            9. 结语

            本章中，我们主要探讨了基于Boosting方式的集成方法，其中主要讲解了基于错误率驱动的Adaboost，基于残差改进的提升树，基于梯度提升的GBDT，基于泰勒二阶近似的Xgboost以及LightGBM。在实际的比赛或者工程中，基于Boosting的集成学习方式是非常有效且应用非常广泛的。更多的学习有待读者更深入阅读文献，包括原作者论文以及论文复现等。下一章我们即将探讨另一种集成学习方式：Stacking集成学习方式，这种集成方式虽然没有Boosting应用广泛，但是在比赛中或许能让你的模型更加出众。

            本章作业：
            本章在最后介绍LightGBM的时候并没有详细介绍它的原理以及它与XGBoost的不一样的地方，希望读者好好看看别的文章分享，总结LigntGBM与XGBoost的不同，然后使用一个具体的案例体现两者的不同。
            参考链接： https://blog.csdn.net/weixin_30279315/article/details/95504220

            ]]> + XGBoost算法

            • XGBoost是陈天奇等人开发的一个开源机器学习项目，高效地实现了GBDT算法并进行了算法和工程上的许多改进，被广泛应用在Kaggle竞赛及其他许多机器学习竞赛中并取得了不错的成绩。XGBoost本质上还是一个GBDT，但是力争把速度和效率发挥到极致，所以叫X (Extreme) GBoosted， 包括前面说过，两者都是boosting方法。XGBoost是一个优化的分布式梯度增强库，旨在实现高效，灵活和便携。 它在Gradient Boosting框架下实现机器学习算法。 XGBoost提供了并行树提升（也称为GBDT，GBM），可以快速准确地解决许多数据科学问题。 相同的代码在主要的分布式环境（Hadoop，SGE，MPI）上运行，并且可以解决超过数十亿个样例的问题。XGBoost利用了核外计算并且能够使数据科学家在一个主机上处理数亿的样本数据。最终，将这些技术进行结合来做一个端到端的系统以最少的集群系统来扩展到更大的数据集上。Xgboost以CART决策树为子模型，通过Gradient Tree Boosting实现多棵CART树的集成学习，得到最终模型。下面我们来看看XGBoost的最终模型构建：

            引用陈天奇的论文，我们的数据为：$\mathcal{D}=\left{\left(\mathbf{x}{i}, y{i}\right)\right}\left(|\mathcal{D}|=n, \mathbf{x}{i} \in \mathbb{R}^{m}, y{i} \in \mathbb{R}\right)$
            (1) 构造目标函数：
            假设有K棵树，则第i个样本的输出为$\hat{y}{i}=\phi\left(\mathrm{x}{i}\right)=\sum{k=1}^{K} f{k}\left(\mathrm{x}{i}\right), \quad f{k} \in \mathcal{F}$，其中，$\mathcal{F}=\left{f(\mathbf{x})=w_{q(\mathbf{x})}\right}\left(q: \mathbb{R}^{m} \rightarrow T, w \in \mathbb{R}^{T}\right)$
            因此，目标函数的构建为：

            其中，$\sum{i} l\left(\hat{y}{i}, y{i}\right)$为loss function，$\sum{k} \Omega\left(f_{k}\right)$为正则化项。
            (2) 叠加式的训练(Additive Training)：
            给定样本$x_i$，$\hat{y}_i^{(0)} = 0$(初始预测)，$\hat{y}_i^{(1)} = \hat{y}_i^{(0)} + f_1(x_i)$，$\hat{y}_i^{(2)} = \hat{y}_i^{(0)} + f_1(x_i) + f_2(x_i) = \hat{y}_i^{(1)} + f_2(x_i)$…….以此类推，可以得到：$ \hat{y}_i^{(K)} = \hat{y}_i^{(K-1)} + f_K(x_i)$ ，其中，$ \hat{y}_i^{(K-1)} $ 为前K-1棵树的预测结果，$ f_K(x_i)$ 为第K棵树的预测结果。
            因此，目标函数可以分解为：

            由于正则化项也可以分解为前K-1棵树的复杂度加第K棵树的复杂度，因此：$\mathcal{L}^{(K)}=\sum{i=1}^{n} l\left(y{i}, \hat{y}{i}^{(K-1)}+f{K}\left(\mathrm{x}{i}\right)\right)+\sum{k=1} ^{K-1}\Omega\left(f{k}\right)+\Omega\left(f{K}\right)$，由于$\sum{k=1} ^{K-1}\Omega\left(f{k}\right)$在模型构建到第K棵树的时候已经固定，无法改变，因此是一个已知的常数，可以在最优化的时候省去，故：

            (3) 使用泰勒级数近似目标函数：

            其中，$g{i}=\partial{\hat{y}(t-1)} l\left(y{i}, \hat{y}^{(t-1)}\right)$和$h{i}=\partial{\hat{y}^{(t-1)}}^{2} l\left(y{i}, \hat{y}^{(t-1)}\right)$
            在这里，我们补充下泰勒级数的相关知识：
            在数学中，泰勒级数（英语：Taylor series）用无限项连加式——级数来表示一个函数，这些相加的项由函数在某一点的导数求得。具体的形式如下：

            由于$\sum{i=1}^{n}l\left(y{i}, \hat{y}^{(K-1)}\right)$在模型构建到第K棵树的时候已经固定，无法改变，因此是一个已知的常数，可以在最优化的时候省去，故：

            (4) 如何定义一棵树：
            为了说明如何定义一棵树的问题，我们需要定义几个概念：第一个概念是样本所在的节点位置$q(x)$，第二个概念是有哪些样本落在节点j上$I{j}=\left{i \mid q\left(\mathbf{x}{i}\right)=j\right}$，第三个概念是每个结点的预测值$w{q(x)}$，第四个概念是模型复杂度$\Omega\left(f{K}\right)$，它可以由叶子节点的个数以及节点函数值来构建，则：$\Omega\left(f{K}\right) = \gamma T+\frac{1}{2} \lambda \sum{j=1}^{T} w_{j}^{2}$。如下图的例子：
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t1tei3pE-1623946035306)(./16.png)]
            $q(x_1) = 1,q(x_2) = 3,q(x_3) = 1,q(x_4) = 2,q(x_5) = 3$，$I_1 = {1,3},I_2 = {4},I_3 = {2,5}$，$w = (15,12,20)$
            因此，目标函数用以上符号替代后：

            由于我们的目标就是最小化目标函数，现在的目标函数化简为一个关于w的二次函数：$\tilde{\mathcal{L}}^{(K)}=\sum{j=1}^{T}\left[\left(\sum{i \in I{j}} g{i}\right) w{j}+\frac{1}{2}\left(\sum{i \in I{j}} h{i}+\lambda\right) w_{j}^{2}\right]+\gamma T$，根据二次函数求极值的公式：$y=ax^2 bx c$求极值，对称轴在$x=-\frac{b}{2 a}$，极值为$y=\frac{4 a c-b^{2}}{4 a}$，因此：

            以及

            (5) 如何寻找树的形状：
            不难发现，刚刚的讨论都是基于树的形状已经确定了计算$w$和$L$，但是实际上我们需要像学习决策树一样找到树的形状。因此，我们借助决策树学习的方式，使用目标函数的变化来作为分裂节点的标准。我们使用一个例子来说明：
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nCrhWA4S-1623946035310)(./17.png)]
            例子中有8个样本，分裂方式如下，因此:

            因此，从上面的例子看出：分割节点的标准为$max{\tilde{\mathcal{L}}^{(old)} - \tilde{\mathcal{L}}^{(new)} }$，即：

            (6.1) 精确贪心分裂算法：
            XGBoost在生成新树的过程中，最基本的操作是节点分裂。节点分裂中最重 要的环节是找到最优特征及最优切分点, 然后将叶子节点按照最优特征和最优切 分点进行分裂。选取最优特征和最优切分点的一种思路如下：首先找到所有的候 选特征及所有的候选切分点, 一一求得其 $\mathcal{L}{\text {split }}$, 然后选择$\mathcal{L}{\mathrm{split}}$ 最大的特征及 对应切分点作为最优特征和最优切分点。我们称此种方法为精确贪心算法。该算法是一种启发式算法, 因为在节点分裂时只选择当前最优的分裂策略, 而非全局最优的分裂策略。精确贪心算法的计算过程如下所示：

            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HRrbM0fp-1623946035312)(./18.png)]

            (6.2) 基于直方图的近似算法：
            精确贪心算法在选择最优特征和最优切分点时是一种十分有效的方法。它计算了所有特征、所有切分点的收益, 并从中选择了最优的, 从而保证模型能比较好地拟合了训练数据。但是当数据不能完全加载到内存时，精确贪心算法会变得 非常低效，算法在计算过程中需要不断在内存与磁盘之间进行数据交换，这是个非常耗时的过程, 并且在分布式环境中面临同样的问题。为了能够更高效地选 择最优特征及切分点, XGBoost提出一种近似算法来解决该问题。 基于直方图的近似算法的主要思想是：对某一特征寻找最优切分点时，首先对该特征的所有切分点按分位数 (如百分位) 分桶, 得到一个候选切分点集。特征的每一个切分点都可以分到对应的分桶; 然后，对每个桶计算特征统计G和H得到直方图, G为该桶内所有样本一阶特征统计g之和, H为该桶内所有样本二阶特征统计h之和; 最后，选择所有候选特征及候选切分点中对应桶的特征统计收益最大的作为最优特征及最优切分点。基于直方图的近似算法的计算过程如下所示：
            1) 对于每个特征 $k=1,2, \cdots, m,$ 按分位数对特征 $k$ 分桶 $\Theta,$ 可得候选切分点, $S{k}=\left{S{k 1}, S{k 2}, \cdots, S{k l}\right}^{1}$
            2) 对于每个特征 $k=1,2, \cdots, m,$ 有：

            3) 类似精确贪心算法，依据梯度统计找到最大增益的候选切分点。
            下面用一个例子说明基于直方图的近似算法：
            假设有一个年龄特征，其特征的取值为18、19、21、31、36、37、55、57，我们需要使用近似算法找到年龄这个特征的最佳分裂点：
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MKLD2poX-1623946035314)(./19.png)]

            近似算法实现了两种候选切分点的构建策略：全局策略和本地策略。全局策略是在树构建的初始阶段对每一个特征确定一个候选切分点的集合, 并在该树每一层的节点分裂中均采用此集合计算收益, 整个过程候选切分点集合不改变。本地策略则是在每一次节点分裂时均重新确定候选切分点。全局策略需要更细的分桶才能达到本地策略的精确度, 但全局策略在选取候选切分点集合时比本地策略更简单。在XGBoost系统中, 用户可以根据需求自由选择使用精确贪心算法、近似算法全局策略、近似算法本地策略, 算法均可通过参数进行配置。

            以上是XGBoost的理论部分，下面我们对XGBoost系统进行详细的讲解：
            官方文档：https://xgboost.readthedocs.io/en/latest/python/python_intro.html
            知乎总结：https://zhuanlan.zhihu.com/p/143009353 

            # XGBoost原生工具库的上手：
            import xgboost as xgb  # 引入工具库
            # read in data
            dtrain = xgb.DMatrix('demo/data/agaricus.txt.train')   # XGBoost的专属数据格式，但是也可以用dataframe或者ndarray
            dtest = xgb.DMatrix('demo/data/agaricus.txt.test')  # # XGBoost的专属数据格式，但是也可以用dataframe或者ndarray
            # specify parameters via map
            param = {'max_depth':2, 'eta':1, 'objective':'binary:logistic' }    # 设置XGB的参数，使用字典形式传入
            num_round = 2     # 使用线程数
            bst = xgb.train(param, dtrain, num_round)   # 训练
            # make prediction
            preds = bst.predict(dtest)   # 预测

            XGBoost的参数设置(括号内的名称为sklearn接口对应的参数名字):
            推荐博客：https://link.zhihu.com/?target=https%3A//blog.csdn.net/luanpeng825485697/article/details/79907149
            推荐官方文档：https://link.zhihu.com/?target=https%3A//xgboost.readthedocs.io/en/latest/parameter.html

            XGBoost的参数分为三种：

            • 通用参数：（两种类型的booster，因为tree的性能比线性回归好得多，因此我们很少用线性回归。）
              • booster:使用哪个弱学习器训练，默认gbtree，可选gbtree，gblinear 或dart
              • nthread：用于运行XGBoost的并行线程数，默认为最大可用线程数
              • verbosity：打印消息的详细程度。有效值为0（静默），1（警告），2（信息），3（调试）。
              • Tree Booster的参数：
                • eta（learning_rate）：learning_rate，在更新中使用步长收缩以防止过度拟合，默认= 0.3，范围：[0,1]；典型值一般设置为：0.01-0.2
                • gamma（min_split_loss）：默认= 0，分裂节点时，损失函数减小值只有大于等于gamma节点才分裂，gamma值越大，算法越保守，越不容易过拟合，但性能就不一定能保证，需要平衡。范围：[0，∞]
                • max_depth：默认= 6，一棵树的最大深度。增加此值将使模型更复杂，并且更可能过度拟合。范围：[0，∞]
                • min_child_weight：默认值= 1，如果新分裂的节点的样本权重和小于min_child_weight则停止分裂 。这个可以用来减少过拟合，但是也不能太高，会导致欠拟合。范围：[0，∞]
                • max_delta_step：默认= 0，允许每个叶子输出的最大增量步长。如果将该值设置为0，则表示没有约束。如果将其设置为正值，则可以帮助使更新步骤更加保守。通常不需要此参数，但是当类极度不平衡时，它可能有助于逻辑回归。将其设置为1-10的值可能有助于控制更新。范围：[0，∞]
                • subsample：默认值= 1，构建每棵树对样本的采样率，如果设置成0.5，XGBoost会随机选择一半的样本作为训练集。范围：（0,1]
                • sampling_method：默认= uniform，用于对训练实例进行采样的方法。
                  • uniform：每个训练实例的选择概率均等。通常将subsample> = 0.5 设置 为良好的效果。
                  • gradient_based：每个训练实例的选择概率与规则化的梯度绝对值成正比，具体来说就是$\sqrt{g^2+\lambda h^2}$，subsample可以设置为低至0.1，而不会损失模型精度。
                • colsample_bytree：默认= 1，列采样率，也就是特征采样率。范围为（0，1]
                • lambda（reg_lambda）：默认=1，L2正则化权重项。增加此值将使模型更加保守。
                • alpha（reg_alpha）：默认= 0，权重的L1正则化项。增加此值将使模型更加保守。
                • tree_method：默认=auto，XGBoost中使用的树构建算法。
                  • auto：使用启发式选择最快的方法。
                    • 对于小型数据集，exact将使用精确贪婪（）。
                    • 对于较大的数据集，approx将选择近似算法（）。它建议尝试hist，gpu_hist，用大量的数据可能更高的性能。（gpu_hist）支持。external memory外部存储器。
                  • exact：精确的贪婪算法。枚举所有拆分的候选点。
                  • approx：使用分位数和梯度直方图的近似贪婪算法。
                  • hist：更快的直方图优化的近似贪婪算法。（LightGBM也是使用直方图算法）
                  • gpu_hist：GPU hist算法的实现。
                • scale_pos_weight:控制正负权重的平衡，这对于不平衡的类别很有用。Kaggle竞赛一般设置sum(negative instances) / sum(positive instances)，在类别高度不平衡的情况下，将参数设置大于0，可以加快收敛。
                • num_parallel_tree：默认=1，每次迭代期间构造的并行树的数量。此选项用于支持增强型随机森林。
                • monotone_constraints：可变单调性的约束，在某些情况下，如果有非常强烈的先验信念认为真实的关系具有一定的质量，则可以使用约束条件来提高模型的预测性能。（例如params_constrained[‘monotone_constraints’] = “(1,-1)”，(1,-1)我们告诉XGBoost对第一个预测变量施加增加的约束，对第二个预测变量施加减小的约束。）
              • Linear Booster的参数：
                • lambda（reg_lambda）：默认= 0，L2正则化权重项。增加此值将使模型更加保守。归一化为训练示例数。
                • alpha（reg_alpha）：默认= 0，权重的L1正则化项。增加此值将使模型更加保守。归一化为训练示例数。
                • updater：默认= shotgun。
                  • shotgun：基于shotgun算法的平行坐标下降算法。使用“ hogwild”并行性，因此每次运行都产生不确定的解决方案。
                  • coord_descent：普通坐标下降算法。同样是多线程的，但仍会产生确定性的解决方案。
                • feature_selector：默认= cyclic。特征选择和排序方法
                  • cyclic：通过每次循环一个特征来实现的。
                  • shuffle：类似于cyclic，但是在每次更新之前都有随机的特征变换。
                  • random：一个随机(有放回)特征选择器。
                  • greedy：选择梯度最大的特征。（贪婪选择）
                  • thrifty：近似贪婪特征选择（近似于greedy）
                • top_k：要选择的最重要特征数（在greedy和thrifty内）

            • 任务参数（这个参数用来控制理想的优化目标和每一步结果的度量方法。）

              • objective：默认=reg:squarederror，表示最小平方误差。
                • reg:squarederror,最小平方误差。
                • reg:squaredlogerror,对数平方损失。$\frac{1}{2}[log(pred+1)-log(label+1)]^2$
                • reg:logistic,逻辑回归
                • reg:pseudohubererror,使用伪Huber损失进行回归，这是绝对损失的两倍可微选择。
                • binary:logistic,二元分类的逻辑回归，输出概率。
                • binary:logitraw：用于二进制分类的逻辑回归，逻辑转换之前的输出得分。
                • binary:hinge：二进制分类的铰链损失。这使预测为0或1，而不是产生概率。（SVM就是铰链损失函数）
                • count:poisson –计数数据的泊松回归，泊松分布的输出平均值。
                • survival:cox：针对正确的生存时间数据进行Cox回归（负值被视为正确的生存时间）。
                • survival:aft：用于检查生存时间数据的加速故障时间模型。
                • aft_loss_distribution：survival:aft和aft-nloglik度量标准使用的概率密度函数。
                • multi:softmax：设置XGBoost以使用softmax目标进行多类分类，还需要设置num_class（类数）
                • multi:softprob：与softmax相同，但输出向量，可以进一步重整为矩阵。结果包含属于每个类别的每个数据点的预测概率。
                • rank:pairwise：使用LambdaMART进行成对排名，从而使成对损失最小化。
                • rank:ndcg：使用LambdaMART进行列表式排名，使标准化折让累积收益（NDCG）最大化。
                • rank:map：使用LambdaMART进行列表平均排名，使平均平均精度（MAP）最大化。
                • reg:gamma：使用对数链接进行伽马回归。输出是伽马分布的平均值。
                • reg:tweedie：使用对数链接进行Tweedie回归。
                • 自定义损失函数和评价指标：https://xgboost.readthedocs.io/en/latest/tutorials/custom_metric_obj.html
              • eval_metric：验证数据的评估指标，将根据目标分配默认指标（回归均方根，分类误差，排名的平均平均精度），用户可以添加多个评估指标
                • rmse，均方根误差； rmsle：均方根对数误差； mae：平均绝对误差；mphe：平均伪Huber错误；logloss：负对数似然； error：二进制分类错误率；
                • merror：多类分类错误率； mlogloss：多类logloss； auc：曲线下面积； aucpr：PR曲线下的面积；ndcg：归一化累计折扣；map：平均精度；
              • seed ：随机数种子，[默认= 0]。

            • 命令行参数（这里不说了，因为很少用命令行控制台版本）

            from IPython.display import IFrame
            IFrame('https://xgboost.readthedocs.io/en/latest/parameter.html', width=1400, height=800)

            XGBoost的调参说明：

            参数调优的一般步骤

              1. 确定学习速率和提升参数调优的初始值
              1. max_depth 和 min_child_weight 参数调优
              1. gamma参数调优
              1. subsample 和 colsample_bytree 参数优
              1. 正则化参数alpha调优
              1. 降低学习速率和使用更多的决策树

            XGBoost详细攻略：
            具体的api请查看：https://xgboost.readthedocs.io/en/latest/python/python_api.html
            推荐github：https://github.com/dmlc/xgboost/tree/master/demo/guide-python

            安装XGBoost：
            方式1：pip3 install xgboost
            方式2：pip install xgboost

            数据接口（XGBoost可处理的数据格式DMatrix）

            # 1.LibSVM文本格式文件
            dtrain = xgb.DMatrix('train.svm.txt')
            dtest = xgb.DMatrix('test.svm.buffer')
            # 2.CSV文件(不能含类别文本变量，如果存在文本变量请做特征处理如one-hot)
            dtrain = xgb.DMatrix('train.csv?format=csv&label_column=0')
            dtest = xgb.DMatrix('test.csv?format=csv&label_column=0')
            # 3.NumPy数组
            data = np.random.rand(5, 10)  # 5 entities, each contains 10 features
            label = np.random.randint(2, size=5)  # binary target
            dtrain = xgb.DMatrix(data, label=label)
            # 4.scipy.sparse数组
            csr = scipy.sparse.csr_matrix((dat, (row, col)))
            dtrain = xgb.DMatrix(csr)
            # pandas数据框dataframe
            data = pandas.DataFrame(np.arange(12).reshape((4,3)), columns=['a', 'b', 'c'])
            label = pandas.DataFrame(np.random.randint(2, size=4))
            dtrain = xgb.DMatrix(data, label=label)

            笔者推荐：先保存到XGBoost二进制文件中将使加载速度更快，然后再加载进来

            # 1.保存DMatrix到XGBoost二进制文件中
            dtrain = xgb.DMatrix('train.svm.txt')
            dtrain.save_binary('train.buffer')
            # 2. 缺少的值可以用DMatrix构造函数中的默认值替换：
            dtrain = xgb.DMatrix(data, label=label, missing=-999.0)
            # 3.可以在需要时设置权重：
            w = np.random.rand(5, 1)
            dtrain = xgb.DMatrix(data, label=label, missing=-999.0, weight=w)

            参数的设置方式：

            import pandas as pd
            # 加载并处理数据
            df_wine = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data',header=None)
            df_wine.columns = ['Class label', 'Alcohol','Malic acid', 'Ash','Alcalinity of ash','Magnesium', 'Total phenols',
                               'Flavanoids', 'Nonflavanoid phenols','Proanthocyanins','Color intensity', 'Hue','OD280/OD315 of diluted wines','Proline'] 
            df_wine = df_wine[df_wine['Class label'] != 1]  # drop 1 class      
            y = df_wine['Class label'].values
            X = df_wine[['Alcohol','OD280/OD315 of diluted wines']].values
            from sklearn.model_selection import train_test_split  # 切分训练集与测试集
            from sklearn.preprocessing import LabelEncoder   # 标签化分类变量
            le = LabelEncoder()
            y = le.fit_transform(y)
            X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1,stratify=y)
            dtrain = xgb.DMatrix(X_train, label=y_train)
            dtest = xgb.DMatrix(X_test)
            # 1.Booster 参数
            params = {
                'booster': 'gbtree',
                'objective': 'multi:softmax',  # 多分类的问题
                'num_class': 10,               # 类别数，与 multisoftmax 并用
                'gamma': 0.1,                  # 用于控制是否后剪枝的参数,越大越保守，一般0.1、0.2这样子。
                'max_depth': 12,               # 构建树的深度，越大越容易过拟合
                'lambda': 2,                   # 控制模型复杂度的权重值的L2正则化项参数，参数越大，模型越不容易过拟合。
                'subsample': 0.7,              # 随机采样训练样本
                'colsample_bytree': 0.7,       # 生成树时进行的列采样
                'min_child_weight': 3,
                'silent': 1,                   # 设置成1则没有运行信息输出，最好是设置为0.
                'eta': 0.007,                  # 如同学习率
                'seed': 1000,
                'nthread': 4,                  # cpu 线程数
                'eval_metric':'auc'
            }
            plst = list(params.items())
            # evallist = [(dtest, 'eval'), (dtrain, 'train')]   # 指定验证集

            训练：

            # 2.训练
            num_round = 10
            bst = xgb.train(plst, dtrain, num_round)
            #bst = xgb.train( plst, dtrain, num_round, evallist )

            保存模型：

            # 3.保存模型
            bst.save_model('0001.model')
            # dump model
            bst.dump_model('dump.raw.txt')
            # dump model with feature map
            #bst.dump_model('dump.raw.txt', 'featmap.txt')

            加载保存的模型：

            # 4.加载保存的模型：
            bst = xgb.Booster({'nthread': 4})  # init model
            bst.load_model('0001.model')  # load data

            设置早停机制：

            # 5.也可以设置早停机制（需要设置验证集）
            train(..., evals=evals, early_stopping_rounds=10)

            预测：

            # 6.预测
            ypred = bst.predict(dtest)

            绘制重要性特征图：

            # 1.绘制重要性
            xgb.plot_importance(bst)
            # 2.绘制输出树
            #xgb.plot_tree(bst, num_trees=2)
            # 3.使用xgboost.to_graphviz()将目标树转换为graphviz
            #xgb.to_graphviz(bst, num_trees=2)

            \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ir9Nm1ZN-1623946035316)(output_27_1.png)\]

            7. Xgboost算法案例

            分类案例

            from sklearn.datasets import load_iris
            import xgboost as xgb
            from xgboost import plot_importance
            import matplotlib.pyplot as plt
            from sklearn.model_selection import train_test_split
            from sklearn.metrics import accuracy_score # 准确率
            # 加载样本数据集
            iris = load_iris()
            X,y = iris.data,iris.target
            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234565) # 数据集分割

            params = {
                'booster' : 'gbtree',
                'objective': 'multi:softmax', # 多分类的问题
                'num_class': 3,
                'gamma': 0.1, # 默认= 0，分裂节点时，损失函数减小值只有大于等于gamma节点才分裂，gamma值越大，算法越保守，越不容易过拟合，但性能就不一定能保证，需要平衡。
                'max_depth': 12, # 树的最大深度
                'lambda': 2, # 控制模型复杂度的权重值的L2正则化项参数，参数越大，模型越不容易过拟合。
                'subsample': 0.7, # 随机采样训练样本
                'colsample_bytree': 0.7, # 生成树时进行的列采样,列采样率，也就是特征采样率
                'min_child_weight': 3,
                'silent': 0,
                'eta': 0.1,
                'seed': 1,
                'nthread': 4,
            }

            plst = list(params.items())
            dtrain = xgb.DMatrix(X_train,y_train)
            num_rounds = 500
            model = xgb.train(plst,dtrain,num_rounds) # xgboost模型训练

            # 对测试集进行预测
            dtest = xgb.DMatrix(X_test)
            y_pred = model.predict(dtest)

            # 计算准确率
            accuracy = accuracy_score(y_test,y_pred)
            print("accuarcy: %.2f%%" % (accuracy*100.0))

            # 显示重要特征
            plot_importance(model)
            plt.show()

            \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8vD1cJWm-1623946035317)(output_30_1.png)\]

            回归案例

            import xgboost as xgb
            from xgboost import plot_importance
            from matplotlib import pyplot as plt
            from sklearn.model_selection import train_test_split
            from sklearn.datasets import load_boston
            from sklearn.metrics import mean_squared_error


            # 加载数据集
            boston = load_boston()
            X,y = boston.data,boston.target

            # XGBoost训练过程
            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

            params = {
                'booster': 'gbtree',
                'objective': 'reg:squarederror',
                'gamma': 0.1,
                'max_depth': 5,
                'lambda': 3,
                'subsample': 0.7,
                'colsample_bytree': 0.7,
                'min_child_weight': 3,
                'silent': 1,
                'eta': 0.1,
                'seed': 1000,
                'nthread': 4,
            }

            dtrain = xgb.DMatrix(X_train, y_train)
            num_rounds = 300
            plst = list(params.items())
            model = xgb.train(plst, dtrain, num_rounds)

            # 对测试集进行预测
            dtest = xgb.DMatrix(X_test)
            ans = model.predict(dtest)

            # 显示重要特征
            plot_importance(model)
            plt.show()

            \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Zu2NWnA-1623946035318)(output_32_1.png)\]

            XGBoost调参（结合sklearn网格搜索）

            代码参考：https://www.jianshu.com/p/1100e333fcab

            import xgboost as xgb
            import pandas as pd
            from sklearn.model_selection import train_test_split
            from sklearn.model_selection import GridSearchCV
            from sklearn.metrics import roc_auc_score

            iris = load_iris()
            X,y = iris.data,iris.target
            col = iris.target_names 
            train_x, valid_x, train_y, valid_y = train_test_split(X, y, test_size=0.3, random_state=1)   # 分训练集和验证集
            parameters = {
                          'max_depth': [5, 10, 15, 20, 25],
                          'learning_rate': [0.01, 0.02, 0.05, 0.1, 0.15],
                          'n_estimators': [500, 1000, 2000, 3000, 5000],
                          'min_child_weight': [0, 2, 5, 10, 20],
                          'max_delta_step': [0, 0.2, 0.6, 1, 2],
                          'subsample': [0.6, 0.7, 0.8, 0.85, 0.95],
                          'colsample_bytree': [0.5, 0.6, 0.7, 0.8, 0.9],
                          'reg_alpha': [0, 0.25, 0.5, 0.75, 1],
                          'reg_lambda': [0.2, 0.4, 0.6, 0.8, 1],
                          'scale_pos_weight': [0.2, 0.4, 0.6, 0.8, 1]

            }

            xlf = xgb.XGBClassifier(max_depth=10,
                        learning_rate=0.01,
                        n_estimators=2000,
                        silent=True,
                        objective='multi:softmax',
                        num_class=3 ,          
                        nthread=-1,
                        gamma=0,
                        min_child_weight=1,
                        max_delta_step=0,
                        subsample=0.85,
                        colsample_bytree=0.7,
                        colsample_bylevel=1,
                        reg_alpha=0,
                        reg_lambda=1,
                        scale_pos_weight=1,
                        seed=0,
                        missing=None)

            gs = GridSearchCV(xlf, param_grid=parameters, scoring='accuracy', cv=3)
            gs.fit(train_x, train_y)

            print("Best score: %0.3f" % gs.best_score_)
            print("Best parameters set: %s" % gs.best_params_ )

            Best score: 0.933
            Best parameters set: {‘max_depth’: 5}

            8. LightGBM算法

            LightGBM也是像XGBoost一样，是一类集成算法，他跟XGBoost总体来说是一样的，算法本质上与Xgboost没有出入，只是在XGBoost的基础上进行了优化，因此就不对原理进行重复介绍，在这里我们来看看几种算法的差别：

            • 优化速度和内存使用
              • 降低了计算每个分割增益的成本。
              • 使用直方图减法进一步提高速度。
              • 减少内存使用。
              • 减少并行学习的计算成本。
            • 稀疏优化
              • 用离散的bin替换连续的值。如果#bins较小，则可以使用较小的数据类型（例如uint8_t）来存储训练数据 。
              • 无需存储其他信息即可对特征数值进行预排序 。
            • 精度优化
              • 使用叶子数为导向的决策树建立算法而不是树的深度导向。
              • 分类特征的编码方式的优化
              • 通信网络的优化
              • 并行学习的优化
              • GPU支持

            LightGBM的优点：

            　　1）更快的训练效率

            　　2）低内存使用

            　　3）更高的准确率

            　　4）支持并行化学习

            　　5）可以处理大规模数据

            1.速度对比：
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W562LSSA-1623946035318)(./速度对比.png)]
            2.准确率对比：
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J4JVvKjX-1623946035319)(./准确率对比.png)]
            3.内存使用量对比：
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-glXaoZd6-1623946035320)(./内存使用量.png)]

            LightGBM参数说明：
            推荐文档1：https://lightgbm.apachecn.org/#/docs/6
            推荐文档2：https://lightgbm.readthedocs.io/en/latest/Parameters.html

            1.核心参数：（括号内名称是别名）

            • objective（objective，app ，application）：默认regression，用于设置损失函数
              • 回归问题：
                • L2损失：regression（regression_l2，l2，mean_squared_error，mse，l2_root，root_mean_squared_error，rmse）
                • L1损失：regression_l1（l1, mean_absolute_error, mae）
                • 其他损失：huber，fair，poisson，quantile，mape，gamma，tweedie
              • 二分类问题：二进制对数损失分类（或逻辑回归）：binary
              • 多类别分类：
                • softmax目标函数： multiclass（softmax）
                • One-vs-All 目标函数：multiclassova（multiclass_ova，ova，ovr）
              • 交叉熵：
                • 用于交叉熵的目标函数（具有可选的线性权重）：cross_entropy（xentropy）
                • 交叉熵的替代参数化：cross_entropy_lambda（xentlambda）
            • boosting ：默认gbdt，设置提升类型，选项有gbdt，rf，dart，goss，别名：boosting_type，boost
              • gbdt（gbrt）:传统的梯度提升决策树
              • rf（random_forest）：随机森林
              • dart：多个加性回归树的DROPOUT方法 Dropouts meet Multiple Additive Regression Trees，参见：https://arxiv.org/abs/1505.01866
              • goss：基于梯度的单边采样 Gradient-based One-Side Sampling
            • data（train，train_data，train_data_file，data_filename）：用于训练的数据或数据file
            • valid （test，valid_data，valid_data_file，test_data，test_data_file，valid_filenames）：验证/测试数据的路径，LightGBM将输出这些数据的指标
            • num_iterations：默认=100，类型= INT
            • n_estimators：提升迭代次数，LightGBM构造用于多类分类问题的树num_class * num_iterations
            • learning_rate（shrinkage_rate，eta） ：收缩率，默认=0.1
            • num_leaves（num_leaf，max_leaves，max_leaf） ：默认=31，一棵树上的最大叶子数
            • tree_learner （tree，tree_type，tree_learner_type）：默认=serial，可选：serial，feature，data，voting
              • serial：单台机器的 tree learner
              • feature：特征并行的 tree learner
              • data：数据并行的 tree learner
              • voting：投票并行的 tree learner
            • num_threads（num_thread, nthread）：LightGBM 的线程数，为了更快的速度, 将此设置为真正的 CPU 内核数, 而不是线程的数量 (大多数 CPU 使用超线程来使每个 CPU 内核生成 2 个线程)，当你的数据集小的时候不要将它设置的过大 (比如, 当数据集有 10,000 行时不要使用 64 线程)，对于并行学习, 不应该使用全部的 CPU 内核, 因为这会导致网络性能不佳。
            • device（device_type）：默认cpu，为树学习选择设备, 你可以使用 GPU 来获得更快的学习速度，可选cpu, gpu。
            • seed （random_seed，random_state）：与其他种子相比，该种子具有较低的优先级，这意味着如果您明确设置其他种子，它将被覆盖。

            2.用于控制模型学习过程的参数：

            • max_depth：限制树模型的最大深度. 这可以在 #data 小的情况下防止过拟合. 树仍然可以通过 leaf-wise 生长。
            • min_data_in_leaf： 默认=20，一个叶子上数据的最小数量. 可以用来处理过拟合。
            • min_sum_hessian_in_leaf（min_sum_hessian_per_leaf, min_sum_hessian, min_hessian）：默认=1e-3，一个叶子上的最小 hessian 和. 类似于 min_data_in_leaf, 可以用来处理过拟合.
            • feature_fraction：default=1.0，如果 feature_fraction 小于 1.0, LightGBM 将会在每次迭代中随机选择部分特征. 例如, 如果设置为 0.8, 将会在每棵树训练之前选择 80% 的特征，可以用来加速训练，可以用来处理过拟合。
            • feature_fraction_seed：默认=2，feature_fraction 的随机数种子。
            • bagging_fraction（sub_row, subsample）：默认=1，不进行重采样的情况下随机选择部分数据
            • bagging_freq（subsample_freq）：bagging 的频率, 0 意味着禁用 bagging. k 意味着每 k 次迭代执行bagging
            • bagging_seed（bagging_fraction_seed） ：默认=3，bagging 随机数种子。
            • early_stopping_round（early_stopping_rounds, early_stopping）：默认=0，如果一个验证集的度量在 early_stopping_round 循环中没有提升, 将停止训练
            • lambda_l1（reg_alpha）：L1正则化系数
            • lambda_l2（reg_lambda）：L2正则化系数
            • min_split_gain（min_gain_to_split）：执行切分的最小增益，默认=0.
            • cat_smooth：默认=10，用于分类特征，可以降低噪声在分类特征中的影响, 尤其是对数据很少的类别

            3.度量参数：

            • metric：default={l2 for regression}, {binary_logloss for binary classification}, {ndcg for lambdarank}, type=multi-enum, options=l1, l2, ndcg, auc, binary_logloss, binary_error …
              • l1, absolute loss, alias=mean_absolute_error, mae
              • l2, square loss, alias=mean_squared_error, mse
              • l2_root, root square loss, alias=root_mean_squared_error, rmse
              • quantile, Quantile regression
              • huber, Huber loss
              • fair, Fair loss
              • poisson, Poisson regression
              • ndcg, NDCG
              • map, MAP
              • auc, AUC
              • binary_logloss, log loss
              • binary_error, 样本: 0 的正确分类, 1 错误分类
              • multi_logloss, mulit-class 损失日志分类
              • multi_error, error rate for mulit-class 出错率分类
              • xentropy, cross-entropy (与可选的线性权重), alias=cross_entropy
              • xentlambda, “intensity-weighted” 交叉熵, alias=cross_entropy_lambda
              • kldiv, Kullback-Leibler divergence, alias=kullback_leibler
              • 支持多指标, 使用 , 分隔
            • train_metric（training_metric, is_training_metric）：默认=False，如果你需要输出训练的度量结果则设置 true

            4.GPU 参数：

            • gpu_device_id：default为-1, 这个default意味着选定平台上的设备。

            LightGBM与网格搜索结合调参：
            参考代码：https://blog.csdn.net/u012735708/article/details/83749703

            import lightgbm as lgb
            from sklearn import metrics
            from sklearn.datasets import load_breast_cancer
            from sklearn.model_selection import train_test_split
             
            canceData=load_breast_cancer()
            X=canceData.data
            y=canceData.target
            X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=0,test_size=0.2)
             
            ### 数据转换
            print('数据转换')
            lgb_train = lgb.Dataset(X_train, y_train, free_raw_data=False)
            lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train,free_raw_data=False)
             
            ### 设置初始参数--不含交叉验证参数
            print('设置参数')
            params = {
                      'boosting_type': 'gbdt',
                      'objective': 'binary',
                      'metric': 'auc',
                      'nthread':4,
                      'learning_rate':0.1
                      }
             
            ### 交叉验证(调参)
            print('交叉验证')
            max_auc = float('0')
            best_params = {}
             
            # 准确率
            print("调参1：提高准确率")
            for num_leaves in range(5,100,5):
                for max_depth in range(3,8,1):
                    params['num_leaves'] = num_leaves
                    params['max_depth'] = max_depth
             
                    cv_results = lgb.cv(
                                        params,
                                        lgb_train,
                                        seed=1,
                                        nfold=5,
                                        metrics=['auc'],
                                        early_stopping_rounds=10,
                                        verbose_eval=True
                                        )
                        
                    mean_auc = pd.Series(cv_results['auc-mean']).max()
                    boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
                        
                    if mean_auc >= max_auc:
                        max_auc = mean_auc
                        best_params['num_leaves'] = num_leaves
                        best_params['max_depth'] = max_depth
            if 'num_leaves' and 'max_depth' in best_params.keys():          
                params['num_leaves'] = best_params['num_leaves']
                params['max_depth'] = best_params['max_depth']
             
            # 过拟合
            print("调参2：降低过拟合")
            for max_bin in range(5,256,10):
                for min_data_in_leaf in range(1,102,10):
                        params['max_bin'] = max_bin
                        params['min_data_in_leaf'] = min_data_in_leaf
                        
                        cv_results = lgb.cv(
                                            params,
                                            lgb_train,
                                            seed=1,
                                            nfold=5,
                                            metrics=['auc'],
                                            early_stopping_rounds=10,
                                            verbose_eval=True
                                            )
                                
                        mean_auc = pd.Series(cv_results['auc-mean']).max()
                        boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
             
                        if mean_auc >= max_auc:
                            max_auc = mean_auc
                            best_params['max_bin']= max_bin
                            best_params['min_data_in_leaf'] = min_data_in_leaf
            if 'max_bin' and 'min_data_in_leaf' in best_params.keys():
                params['min_data_in_leaf'] = best_params['min_data_in_leaf']
                params['max_bin'] = best_params['max_bin']
             
            print("调参3：降低过拟合")
            for feature_fraction in [0.6,0.7,0.8,0.9,1.0]:
                for bagging_fraction in [0.6,0.7,0.8,0.9,1.0]:
                    for bagging_freq in range(0,50,5):
                        params['feature_fraction'] = feature_fraction
                        params['bagging_fraction'] = bagging_fraction
                        params['bagging_freq'] = bagging_freq
                        
                        cv_results = lgb.cv(
                                            params,
                                            lgb_train,
                                            seed=1,
                                            nfold=5,
                                            metrics=['auc'],
                                            early_stopping_rounds=10,
                                            verbose_eval=True
                                            )
                                
                        mean_auc = pd.Series(cv_results['auc-mean']).max()
                        boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
             
                        if mean_auc >= max_auc:
                            max_auc=mean_auc
                            best_params['feature_fraction'] = feature_fraction
                            best_params['bagging_fraction'] = bagging_fraction
                            best_params['bagging_freq'] = bagging_freq
             
            if 'feature_fraction' and 'bagging_fraction' and 'bagging_freq' in best_params.keys():
                params['feature_fraction'] = best_params['feature_fraction']
                params['bagging_fraction'] = best_params['bagging_fraction']
                params['bagging_freq'] = best_params['bagging_freq']
             
             
            print("调参4：降低过拟合")
            for lambda_l1 in [1e-5,1e-3,1e-1,0.0,0.1,0.3,0.5,0.7,0.9,1.0]:
                for lambda_l2 in [1e-5,1e-3,1e-1,0.0,0.1,0.4,0.6,0.7,0.9,1.0]:
                    params['lambda_l1'] = lambda_l1
                    params['lambda_l2'] = lambda_l2
                    cv_results = lgb.cv(
                                        params,
                                        lgb_train,
                                        seed=1,
                                        nfold=5,
                                        metrics=['auc'],
                                        early_stopping_rounds=10,
                                        verbose_eval=True
                                        )
                            
                    mean_auc = pd.Series(cv_results['auc-mean']).max()
                    boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
             
                    if mean_auc >= max_auc:
                        max_auc=mean_auc
                        best_params['lambda_l1'] = lambda_l1
                        best_params['lambda_l2'] = lambda_l2
            if 'lambda_l1' and 'lambda_l2' in best_params.keys():
                params['lambda_l1'] = best_params['lambda_l1']
                params['lambda_l2'] = best_params['lambda_l2']
             
            print("调参5：降低过拟合2")
            for min_split_gain in [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]:
                params['min_split_gain'] = min_split_gain
                
                cv_results = lgb.cv(
                                    params,
                                    lgb_train,
                                    seed=1,
                                    nfold=5,
                                    metrics=['auc'],
                                    early_stopping_rounds=10,
                                    verbose_eval=True
                                    )
                        
                mean_auc = pd.Series(cv_results['auc-mean']).max()
                boost_rounds = pd.Series(cv_results['auc-mean']).idxmax()
             
                if mean_auc >= max_auc:
                    max_auc=mean_auc
                    
                    best_params['min_split_gain'] = min_split_gain
            if 'min_split_gain' in best_params.keys():
                params['min_split_gain'] = best_params['min_split_gain']
             
            print(best_params)

            {‘bagging_fraction’: 0.7,
            ‘bagging_freq’: 30,
            ‘feature_fraction’: 0.8,
            ‘lambda_l1’: 0.1,
            ‘lambda_l2’: 0.0,
            ‘max_bin’: 255,
            ‘max_depth’: 4,
            ‘min_data_in_leaf’: 81,
            ‘min_split_gain’: 0.1,
            ‘num_leaves’: 10}

            9. 结语

            本章中，我们主要探讨了基于Boosting方式的集成方法，其中主要讲解了基于错误率驱动的Adaboost，基于残差改进的提升树，基于梯度提升的GBDT，基于泰勒二阶近似的Xgboost以及LightGBM。在实际的比赛或者工程中，基于Boosting的集成学习方式是非常有效且应用非常广泛的。更多的学习有待读者更深入阅读文献，包括原作者论文以及论文复现等。下一章我们即将探讨另一种集成学习方式：Stacking集成学习方式，这种集成方式虽然没有Boosting应用广泛，但是在比赛中或许能让你的模型更加出众。

            本章作业：
            本章在最后介绍LightGBM的时候并没有详细介绍它的原理以及它与XGBoost的不一样的地方，希望读者好好看看别的文章分享，总结LigntGBM与XGBoost的不同，然后使用一个具体的案例体现两者的不同。
            参考链接： https://blog.csdn.net/weixin_30279315/article/details/95504220

            ]]> - <h1 id="XGBoost算法"><a href="#XGBoost算法" class="headerlink" title="XGBoost算法"></a>XGBoost算法</h1><p>XGBoost是陈天奇等人开发的一个开源机器学习项目，高效地实现了GBDT算法并进行了算法和工程上的许多改进，被广泛应用在Kaggle竞赛及其他许多机器学习竞赛中并取得了不错的成绩。<strong>XGBoost本质上还是一个GBDT，但是力争把速度和效率发挥到极致，所以叫X (Extreme) GBoosted，</strong> 包括前面说过，两者都是boosting方法。XGBoost是一个优化的分布式梯度增强库，旨在实现高效，灵活和便携。 它在Gradient Boosting框架下实现机器学习算法。 XGBoost提供了<strong>并行树提升</strong>（也称为GBDT，GBM），可以快速准确地解决许多数据科学问题。 相同的代码在主要的分布式环境（Hadoop，SGE，MPI）上运行，并且可以解决超过数十亿个样例的问题。XGBoost利用了核外计算并且能够使数据科学家在一个主机上处理数亿的样本数据。最终，将这些技术进行结合来做一个端到端的系统以最少的集群系统来扩展到更大的数据集上。Xgboost<strong>以CART决策树为子模型</strong>，通过Gradient Tree Boosting实现多棵CART树的集成学习，得到最终模型。下面我们来看看XGBoost的最终模型构建：</p> + <h1 id="XGBoost算法"><a href="#XGBoost算法" class="headerlink" title="XGBoost算法"></a>XGBoost算法</h1><p>XGBoost是陈天奇等人开发的一个开源机器学习项目，高效地实现了GBDT算法并进行了算法和工程上的许多改进，被广泛应用在Kaggle竞赛及其他许多机器学习竞赛中并取得了不错的成绩。<strong>XGBoost本质上还是一个GBDT，但是力争把速度和效率发挥到极致，所以叫X (Extreme) GBoosted，</strong> 包括前面说过，两者都是boosting方法。XGBoost是一个优化的分布式梯度增强库，旨在实现高效，灵活和便携。 它在Gradient Boosting框架下实现机器学习算法。 XGBoost提供了<strong>并行树提升</strong>（也称为GBDT，GBM），可以快速准确地解决许多数据科学问题。 相同的代码在主要的分布式环境（Hadoop，SGE，MPI）上运行，并且可以解决超过数十亿个样例的问题。XGBoost利用了核外计算并且能够使数据科学家在一个主机上处理数亿的样本数据。最终，将这些技术进行结合来做一个端到端的系统以最少的集群系统来扩展到更大的数据集上。Xgboost<strong>以CART决策树为子模型</strong>，通过Gradient Tree Boosting实现多棵CART树的集成学习，得到最终模型。下面我们来看看XGBoost的最终模型构建：<br></p> @@ -194,11 +194,11 @@ 2021-06-17T15:59:00.000Z 2024-10-09T07:33:09.914Z - 梯度提升决策树(GBDT)

            • (1) 基于残差学习的提升树算法：
            在前面的学习过程中，我们一直讨论的都是分类树，比如Adaboost算法，并没有涉及回归的例子。在上一小节我们提到了一个加法模型+前向分步算法的框架，那能否使用这个框架解决回归的例子呢？答案是肯定的。接下来我们来探讨下如何使用加法模型+前向分步算法的框架实现回归问题。
            在使用加法模型+前向分步算法的框架解决问题之前，我们需要首先确定框架内使用的基函数是什么，在这里我们使用决策树分类器。前面第二章我们已经学过了回归树的基本原理，树算法最重要是寻找最佳的划分点，分类树用纯度来判断最佳划分点使用信息增益（ID3算法），信息增益比（C4.5算法），基尼系数（CART分类树）。但是在回归树中的样本标签是连续数值，可划分点包含了所有特征的所有可取的值。所以再使用熵之类的指标不再合适，取而代之的是平方误差，它能很好的评判拟合程度。 基函数确定了以后，我们需要确定每次提升的标准是什么。回想Adaboost算法，在Adaboost算法内使用了分类错误率修正样本权重以及计算每个基本分类器的权重，那回归问题没有分类错误率可言，也就没办法在这里的回归问题使用了，因此我们需要另辟蹊径。模仿分类错误率，我们用每个样本的残差表示每次使用基函数预测时没有解决的那部分问题。因此，我们可以得出如下算法：

            输入数据集$T=\left{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right}, x_{i} \in \mathcal{X} \subseteq \mathbf{R}^{n}, y_{i} \in \mathcal{Y} \subseteq \mathbf{R}$，输出最终的提升树$f_{M}(x)$

            • 初始化$f_0(x) = 0$
            • 对m = 1,2,…,M：
              • 计算每个样本的残差:$r_{m i}=y_{i}-f_{m-1}\left(x_{i}\right), \quad i=1,2, \cdots, N$
              • 拟合残差$r_{mi}$学习一棵回归树，得到$T\left(x ; \Theta_{m}\right)$
              • 更新$f_{m}(x)=f_{m-1}(x)+T\left(x ; \Theta_{m}\right)$
            • 得到最终的回归问题的提升树：$f_{M}(x)=\sum_{m=1}^{M} T\left(x ; \Theta_{m}\right)$

            下面我们用一个实际的案例来使用这个算法：(案例来源：李航老师《统计学习方法》)
            训练数据如下表，学习这个回归问题的提升树模型，考虑只用树桩作为基函数。
            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6RIHgryn-1623945003185)(./1.png)]
            在这里插入图片描述
            在这里插入图片描述
            在这里插入图片描述
            在这里插入图片描述

            至此，我们已经能够建立起依靠加法模型+前向分步算法的框架解决回归问题的算法，叫提升树算法。那么，这个算法还是否有提升的空间呢？
            (2) 梯度提升决策树算法(GBDT)：
            提升树利用加法模型和前向分步算法实现学习的过程，当损失函数为平方损失和指数损失时，每一步优化是相当简单的，也就是我们前面探讨的提升树算法和Adaboost算法。但是对于一般的损失函数而言，往往每一步的优化不是那么容易，针对这一问题，我们得分析问题的本质，也就是是什么导致了在一般损失函数条件下的学习困难。对比以下损失函数：
            $$
            \begin{array}{l|l|l}
            \hline \text { Setting } & \text { Loss Function } & -\partial L\left(y_{i}, f\left(x_{i}\right)\right) / \partial f\left(x_{i}\right) \
            \hline \text { Regression } & \frac{1}{2}\left[y_{i}-f\left(x_{i}\right)\right]^{2} & y_{i}-f\left(x_{i}\right) \
            \hline \text { Regression } & \left|y_{i}-f\left(x_{i}\right)\right| & \operatorname{sign}\left[y_{i}-f\left(x_{i}\right)\right] \
            \hline \text { Regression } & \text { Huber } & y_{i}-f\left(x_{i}\right) \text { for }\left|y_{i}-f\left(x_{i}\right)\right| \leq \delta_{m} \
            & & \delta_{m} \operatorname{sign}\left[y_{i}-f\left(x_{i}\right)\right] \text { for }\left|y_{i}-f\left(x_{i}\right)\right|>\delta_{m} \
            & & \text { where } \delta_{m}=\alpha \text { th-quantile }\left{\left|y_{i}-f\left(x_{i}\right)\right|\right} \
            \hline \text { Classification } & \text { Deviance } & k \text { th component: } I\left(y_{i}=\mathcal{G}{k}\right)-p{k}\left(x_{i}\right) \
            \hline
            \end{array}
            $$
            观察Huber损失函数：
            $$
            L_{\delta}(y, f(x))=\left{\begin{array}{ll}
            \frac{1}{2}(y-f(x))^{2} & \text { for }|y-f(x)| \leq \delta \
            \delta|y-f(x)|-\frac{1}{2} \delta^{2} & \text { otherwise }
            \end{array}\right.
            $$
            针对上面的问题，Freidman提出了梯度提升算法(gradient boosting)，这是利用最速下降法的近似方法，利用损失函数的负梯度在当前模型的值$-\left[\frac{\partial L\left(y, f\left(x_{i}\right)\right)}{\partial f\left(x_{i}\right)}\right]{f(x)=f{m-1}(x)}$作为回归问题提升树算法中的残差的近似值，拟合回归树。与其说负梯度作为残差的近似值，不如说残差是负梯度的一种特例。
            以下开始具体介绍梯度提升算法：
            输入训练数据集$T=\left{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right}, x_{i} \in \mathcal{X} \subseteq \mathbf{R}^{n}, y_{i} \in \mathcal{Y} \subseteq \mathbf{R}$和损失函数$L(y, f(x))$，输出回归树$\hat{f}(x)$

            • 初始化$f_{0}(x)=\arg \min {c} \sum{i=1}^{N} L\left(y_{i}, c\right)$
            • 对于m=1,2,…,M：
              • 对i = 1,2,…,N计算：$r_{m i}=-\left[\frac{\partial L\left(y_{i}, f\left(x_{i}\right)\right)}{\partial f\left(x_{i}\right)}\right]{f(x)=f{m-1}(x)}$
              • 对$r_{mi}$拟合一个回归树，得到第m棵树的叶结点区域$R_{m j}, j=1,2, \cdots, J$
              • 对j=1,2,…J，计算：$c_{m j}=\arg \min {c} \sum{x_{i} \in R_{m j}} L\left(y_{i}, f_{m-1}\left(x_{i}\right)+c\right)$
              • 更新$f_{m}(x)=f_{m-1}(x)+\sum_{j=1}^{J} c_{m j} I\left(x \in R_{m j}\right)$
            • 得到回归树：$\hat{f}(x)=f_{M}(x)=\sum_{m=1}^{M} \sum_{j=1}^{J} c_{m j} I\left(x \in R_{m j}\right)$

            下面，我们来使用一个具体的案例来说明GBDT是如何运作的(案例来源：https://blog.csdn.net/zpalyq110/article/details/79527653 )：
            下面的表格是数据：
            在这里插入图片描述

            学习率：learning_rate=0.1，迭代次数：n_trees=5，树的深度：max_depth=3
            平方损失的负梯度为：
            $$
            -\left[\frac{\left.\partial L\left(y, f\left(x_{i}\right)\right)\right)}{\partial f\left(x_{i}\right)}\right]{f(x)=f{t-1}(x)}=y-f\left(x_{i}\right)
            $$
            $c=(1.1+1.3+1.7+1.8)/4=1.475，f_{0}(x)=c=1.475$
            在这里插入图片描述

            学习决策树，分裂结点：
            在这里插入图片描述

            在这里插入图片描述

            对于左节点，只有0，1两个样本，那么根据下表我们选择年龄7进行划分：
            在这里插入图片描述

            对于右节点，只有2，3两个样本，那么根据下表我们选择年龄30进行划分：
            在这里插入图片描述

            在这里插入图片描述

            因此根据$\Upsilon_{j 1}=\underbrace{\arg \min }{\Upsilon} \sum{x_{i} \in R_{j 1}} L\left(y_{i}, f_{0}\left(x_{i}\right)+\Upsilon\right)$：
            $$
            \begin{array}{l}
            \left(x_{0} \in R_{11}\right), \quad \Upsilon_{11}=-0.375 \
            \left(x_{1} \in R_{21}\right), \quad \Upsilon_{21}=-0.175 \
            \left(x_{2} \in R_{31}\right), \quad \Upsilon_{31}=0.225 \
            \left(x_{3} \in R_{41}\right), \quad \Upsilon_{41}=0.325
            \end{array}
            $$
            这里其实和上面初始化学习器是一个道理，平方损失，求导，令导数等于零，化简之后得到每个叶子节点的参数$\Upsilon$,其实就是标签值的均值。
            最后得到五轮迭代：
            在这里插入图片描述

            最后的强学习器为：$f(x)=f_{5}(x)=f_{0}(x)+\sum_{m=1}^{5} \sum_{j=1}^{4} \Upsilon_{j m} I\left(x \in R_{j m}\right)$。
            其中：
            $$
            \begin{array}{ll}
            f_{0}(x)=1.475 & f_{2}(x)=0.0205 \
            f_{3}(x)=0.1823 & f_{4}(x)=0.1640 \
            f_{5}(x)=0.1476
            \end{array}
            $$
            预测结果为：
            $$
            f(x)=1.475+0.1 *(0.2250+0.2025+0.1823+0.164+0.1476)=1.56714
            $$
            为什么要用学习率呢？这是Shrinkage的思想，如果每次都全部加上（学习率为1）很容易一步学到位导致过拟合。

            下面我们来使用sklearn来使用GBDT： 

            from sklearn.metrics import mean_squared_error
            from sklearn.datasets import make_friedman1
            from sklearn.ensemble import GradientBoostingRegressor
            '''
            GradientBoostingRegressor参数解释：
            loss：{‘ls’, ‘lad’, ‘huber’, ‘quantile’}, default=’ls’：‘ls’ 指最小二乘回归. ‘lad’ (最小绝对偏差) 是仅基于输入变量的顺序信息的高度鲁棒的损失函数。. ‘huber’ 是两者的结合. ‘quantile’允许分位数回归（用于alpha指定分位数）
            learning_rate：学习率缩小了每棵树的贡献learning_rate。在learning_rate和n_estimators之间需要权衡。
            n_estimators：要执行的提升次数。
            subsample：用于拟合各个基础学习者的样本比例。如果小于1.0，则将导致随机梯度增强。subsample与参数n_estimators。选择会导致方差减少和偏差增加。subsample < 1.0
            criterion：{'friedman_mse'，'mse'，'mae'}，默认='friedman_mse'：“ mse”是均方误差，“ mae”是平均绝对误差。默认值“ friedman_mse”通常是最好的，因为在某些情况下它可以提供更好的近似值。
            min_samples_split：拆分内部节点所需的最少样本数
            min_samples_leaf：在叶节点处需要的最小样本数。
            min_weight_fraction_leaf：在所有叶节点处（所有输入样本）的权重总和中的最小加权分数。如果未提供sample_weight，则样本的权重相等。
            max_depth：各个回归模型的最大深度。最大深度限制了树中节点的数量。调整此参数以获得最佳性能；最佳值取决于输入变量的相互作用。
            min_impurity_decrease：如果节点分裂会导致杂质的减少大于或等于该值，则该节点将被分裂。
            min_impurity_split：提前停止树木生长的阈值。如果节点的杂质高于阈值，则该节点将分裂
            max_features{‘auto’, ‘sqrt’, ‘log2’}，int或float：寻找最佳分割时要考虑的功能数量：

            如果为int，则max_features在每个分割处考虑特征。

            如果为float，max_features则为小数，并在每次拆分时考虑要素。int(max_features * n_features)

            如果“auto”，则max_features=n_features。

            如果是“ sqrt”，则max_features=sqrt(n_features)。

            如果为“ log2”，则为max_features=log2(n_features)。

            如果没有，则max_features=n_features。
            '''

            X, y = make_friedman1(n_samples=1200, random_state=0, noise=1.0)
            X_train, X_test = X[:200], X[200:]
            y_train, y_test = y[:200], y[200:]
            reg = GradientBoostingRegressor(n_estimators=100, 
                learning_rate=0.1,max_depth=1, random_state=0, loss='ls')
            est = reg.fit(X_train, y_train)
            mean_squared_error(y_test, est.predict(X_test))
            from sklearn.datasets import make_regression
            from sklearn.ensemble import GradientBoostingRegressor
            from sklearn.model_selection import train_test_split
            X, y = make_regression(random_state=0)
            X_train, X_test, y_train, y_test = train_test_split(
                X, y, random_state=0)
            reg = GradientBoostingRegressor(random_state=0)
            reg.fit(X_train, y_train)
            reg.score(X_test, y_test)

            GradientBoostingRegressor与GradientBoostingClassifier函数的各个参数的参考文档：

            ]]> + 梯度提升决策树(GBDT)

        (1) 基于残差学习的提升树算法：
        在前面的学习过程中，我们一直讨论的都是分类树，比如Adaboost算法，并没有涉及回归的例子。在上一小节我们提到了一个加法模型+前向分步算法的框架，那能否使用这个框架解决回归的例子呢？答案是肯定的。接下来我们来探讨下如何使用加法模型+前向分步算法的框架实现回归问题。
        在使用加法模型+前向分步算法的框架解决问题之前，我们需要首先确定框架内使用的基函数是什么，在这里我们使用决策树分类器。前面第二章我们已经学过了回归树的基本原理，树算法最重要是寻找最佳的划分点，分类树用纯度来判断最佳划分点使用信息增益（ID3算法），信息增益比（C4.5算法），基尼系数（CART分类树）。但是在回归树中的样本标签是连续数值，可划分点包含了所有特征的所有可取的值。所以再使用熵之类的指标不再合适，取而代之的是平方误差，它能很好的评判拟合程度。 基函数确定了以后，我们需要确定每次提升的标准是什么。回想Adaboost算法，在Adaboost算法内使用了分类错误率修正样本权重以及计算每个基本分类器的权重，那回归问题没有分类错误率可言，也就没办法在这里的回归问题使用了，因此我们需要另辟蹊径。模仿分类错误率，我们用每个样本的残差表示每次使用基函数预测时没有解决的那部分问题。因此，我们可以得出如下算法：

        输入数据集$T=\left{\left(x{1}, y{1}\right),\left(x{2}, y{2}\right), \cdots,\left(x{N}, y{N}\right)\right}, x{i} \in \mathcal{X} \subseteq \mathbf{R}^{n}, y{i} \in \mathcal{Y} \subseteq \mathbf{R}$，输出最终的提升树$f_{M}(x)$

        • 初始化$f_0(x) = 0$
        • 对m = 1,2,…,M：
          • 计算每个样本的残差:$r{m i}=y{i}-f{m-1}\left(x{i}\right), \quad i=1,2, \cdots, N$
          • 拟合残差$r{mi}$学习一棵回归树，得到$T\left(x ; \Theta{m}\right)$
          • 更新$f{m}(x)=f{m-1}(x)+T\left(x ; \Theta_{m}\right)$
        • 得到最终的回归问题的提升树：$f{M}(x)=\sum{m=1}^{M} T\left(x ; \Theta_{m}\right)$

        下面我们用一个实际的案例来使用这个算法：(案例来源：李航老师《统计学习方法》)
        训练数据如下表，学习这个回归问题的提升树模型，考虑只用树桩作为基函数。
        \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6RIHgryn-1623945003185)(./1.png)\]
        在这里插入图片描述
        在这里插入图片描述
        在这里插入图片描述
        在这里插入图片描述

        至此，我们已经能够建立起依靠加法模型+前向分步算法的框架解决回归问题的算法，叫提升树算法。那么，这个算法还是否有提升的空间呢？
        (2) 梯度提升决策树算法(GBDT)：
        提升树利用加法模型和前向分步算法实现学习的过程，当损失函数为平方损失和指数损失时，每一步优化是相当简单的，也就是我们前面探讨的提升树算法和Adaboost算法。但是对于一般的损失函数而言，往往每一步的优化不是那么容易，针对这一问题，我们得分析问题的本质，也就是是什么导致了在一般损失函数条件下的学习困难。对比以下损失函数：

        观察Huber损失函数：

        针对上面的问题，Freidman提出了梯度提升算法(gradient boosting)，这是利用最速下降法的近似方法，利用损失函数的负梯度在当前模型的值$-\left[\frac{\partial L\left(y, f\left(x{i}\right)\right)}{\partial f\left(x{i}\right)}\right]{f(x)=f{m-1}(x)}$作为回归问题提升树算法中的残差的近似值，拟合回归树。与其说负梯度作为残差的近似值，不如说残差是负梯度的一种特例。
        以下开始具体介绍梯度提升算法：
        输入训练数据集$T=\left{\left(x{1}, y{1}\right),\left(x{2}, y{2}\right), \cdots,\left(x{N}, y{N}\right)\right}, x{i} \in \mathcal{X} \subseteq \mathbf{R}^{n}, y{i} \in \mathcal{Y} \subseteq \mathbf{R}$和损失函数$L(y, f(x))$，输出回归树$\hat{f}(x)$

        • 初始化$f{0}(x)=\arg \min {c} \sum{i=1}^{N} L\left(y{i}, c\right)$
        • 对于m=1,2,…,M：
          • 对i = 1,2,…,N计算：$r{m i}=-\left[\frac{\partial L\left(y{i}, f\left(x{i}\right)\right)}{\partial f\left(x{i}\right)}\right]{f(x)=f{m-1}(x)}$
          • 对$r{mi}$拟合一个回归树，得到第m棵树的叶结点区域$R{m j}, j=1,2, \cdots, J$
          • 对j=1,2,…J，计算：$c{m j}=\arg \min {c} \sum{x{i} \in R{m j}} L\left(y{i}, f{m-1}\left(x{i}\right)+c\right)$
          • 更新$f{m}(x)=f{m-1}(x)+\sum{j=1}^{J} c{m j} I\left(x \in R_{m j}\right)$
        • 得到回归树：$\hat{f}(x)=f{M}(x)=\sum{m=1}^{M} \sum{j=1}^{J} c{m j} I\left(x \in R_{m j}\right)$

        下面，我们来使用一个具体的案例来说明GBDT是如何运作的(案例来源：https://blog.csdn.net/zpalyq110/article/details/79527653 )：
        下面的表格是数据：
        在这里插入图片描述

        学习率：learning_rate=0.1，迭代次数：n_trees=5，树的深度：max_depth=3
        平方损失的负梯度为：

        $c=(1.1+1.3+1.7+1.8)/4=1.475，f_{0}(x)=c=1.475$
        在这里插入图片描述

        学习决策树，分裂结点：
        在这里插入图片描述

        在这里插入图片描述

        对于左节点，只有0，1两个样本，那么根据下表我们选择年龄7进行划分：
        在这里插入图片描述

        对于右节点，只有2，3两个样本，那么根据下表我们选择年龄30进行划分：
        在这里插入图片描述

        在这里插入图片描述

        因此根据$\Upsilon{j 1}=\underbrace{\arg \min }{\Upsilon} \sum{x{i} \in R{j 1}} L\left(y{i}, f{0}\left(x{i}\right)+\Upsilon\right)$：

        这里其实和上面初始化学习器是一个道理，平方损失，求导，令导数等于零，化简之后得到每个叶子节点的参数$\Upsilon$,其实就是标签值的均值。
        最后得到五轮迭代：
        在这里插入图片描述

        最后的强学习器为：$f(x)=f{5}(x)=f{0}(x)+\sum{m=1}^{5} \sum{j=1}^{4} \Upsilon{j m} I\left(x \in R{j m}\right)$。
        其中：

        预测结果为：

        为什么要用学习率呢？这是Shrinkage的思想，如果每次都全部加上（学习率为1）很容易一步学到位导致过拟合。

        下面我们来使用sklearn来使用GBDT： 

        from sklearn.metrics import mean_squared_error
        from sklearn.datasets import make_friedman1
        from sklearn.ensemble import GradientBoostingRegressor
        '''
        GradientBoostingRegressor参数解释：
        loss：{‘ls’, ‘lad’, ‘huber’, ‘quantile’}, default=’ls’：‘ls’ 指最小二乘回归. ‘lad’ (最小绝对偏差) 是仅基于输入变量的顺序信息的高度鲁棒的损失函数。. ‘huber’ 是两者的结合. ‘quantile’允许分位数回归（用于alpha指定分位数）
        learning_rate：学习率缩小了每棵树的贡献learning_rate。在learning_rate和n_estimators之间需要权衡。
        n_estimators：要执行的提升次数。
        subsample：用于拟合各个基础学习者的样本比例。如果小于1.0，则将导致随机梯度增强。subsample与参数n_estimators。选择会导致方差减少和偏差增加。subsample < 1.0
        criterion：{'friedman_mse'，'mse'，'mae'}，默认='friedman_mse'：“ mse”是均方误差，“ mae”是平均绝对误差。默认值“ friedman_mse”通常是最好的，因为在某些情况下它可以提供更好的近似值。
        min_samples_split：拆分内部节点所需的最少样本数
        min_samples_leaf：在叶节点处需要的最小样本数。
        min_weight_fraction_leaf：在所有叶节点处（所有输入样本）的权重总和中的最小加权分数。如果未提供sample_weight，则样本的权重相等。
        max_depth：各个回归模型的最大深度。最大深度限制了树中节点的数量。调整此参数以获得最佳性能；最佳值取决于输入变量的相互作用。
        min_impurity_decrease：如果节点分裂会导致杂质的减少大于或等于该值，则该节点将被分裂。
        min_impurity_split：提前停止树木生长的阈值。如果节点的杂质高于阈值，则该节点将分裂
        max_features{‘auto’, ‘sqrt’, ‘log2’}，int或float：寻找最佳分割时要考虑的功能数量：

        如果为int，则max_features在每个分割处考虑特征。

        如果为float，max_features则为小数，并在每次拆分时考虑要素。int(max_features * n_features)

        如果“auto”，则max_features=n_features。

        如果是“ sqrt”，则max_features=sqrt(n_features)。

        如果为“ log2”，则为max_features=log2(n_features)。

        如果没有，则max_features=n_features。
        '''

        X, y = make_friedman1(n_samples=1200, random_state=0, noise=1.0)
        X_train, X_test = X[:200], X[200:]
        y_train, y_test = y[:200], y[200:]
        reg = GradientBoostingRegressor(n_estimators=100, 
            learning_rate=0.1,max_depth=1, random_state=0, loss='ls')
        est = reg.fit(X_train, y_train)
        mean_squared_error(y_test, est.predict(X_test))
        from sklearn.datasets import make_regression
        from sklearn.ensemble import GradientBoostingRegressor
        from sklearn.model_selection import train_test_split
        X, y = make_regression(random_state=0)
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, random_state=0)
        reg = GradientBoostingRegressor(random_state=0)
        reg.fit(X_train, y_train)
        reg.score(X_test, y_test)

        GradientBoostingRegressor与GradientBoostingClassifier函数的各个参数的参考文档：

        ]]> - <h2 id="梯度提升决策树-GBDT"><a href="#梯度提升决策树-GBDT" class="headerlink" title="梯度提升决策树(GBDT)"></a>梯度提升决策树(GBDT)</h2><p>(1) 基于残差学习的提升树算法：<br>在前面的学习过程中，我们一直讨论的都是分类树，比如Adaboost算法，并没有涉及回归的例子。在上一小节我们提到了一个加法模型+前向分步算法的框架，那能否使用这个框架解决回归的例子呢？答案是肯定的。接下来我们来探讨下如何使用加法模型+前向分步算法的框架实现回归问题。<br>在使用加法模型+前向分步算法的框架解决问题之前，我们需要首先确定框架内使用的基函数是什么，在这里我们使用决策树分类器。前面第二章我们已经学过了回归树的基本原理，<strong>树算法最重要是寻找最佳的划分点，分类树用纯度来判断最佳划分点使用信息增益（ID3算法），信息增益比（C4.5算法），基尼系数（CART分类树）。但是在回归树中的样本标签是连续数值，可划分点包含了所有特征的所有可取的值。所以再使用熵之类的指标不再合适，取而代之的是平方误差，它能很好的评判拟合程度。</strong> 基函数确定了以后，我们需要确定每次提升的标准是什么。回想Adaboost算法，在Adaboost算法内使用了分类错误率修正样本权重以及计算每个基本分类器的权重，那回归问题没有分类错误率可言，也就没办法在这里的回归问题使用了，因此我们需要另辟蹊径。模仿分类错误率，我们用每个样本的残差表示每次使用基函数预测时没有解决的那部分问题。因此，我们可以得出如下算法： </p> + <h2 id="梯度提升决策树-GBDT"><a href="#梯度提升决策树-GBDT" class="headerlink" title="梯度提升决策树(GBDT)"></a>梯度提升决策树(GBDT)</h2><p>(1) 基于残差学习的提升树算法：<br>在前面的学习过程中，我们一直讨论的都是分类树，比如Adaboost算法，并没有涉及回归的例子。在上一小节我们提到了一个加法模型+前向分步算法的框架，那能否使用这个框架解决回归的例子呢？答案是肯定的。接下来我们来探讨下如何使用加法模型+前向分步算法的框架实现回归问题。<br>在使用加法模型+前向分步算法的框架解决问题之前，我们需要首先确定框架内使用的基函数是什么，在这里我们使用决策树分类器。前面第二章我们已经学过了回归树的基本原理，<strong>树算法最重要是寻找最佳的划分点，分类树用纯度来判断最佳划分点使用信息增益（ID3算法），信息增益比（C4.5算法），基尼系数（CART分类树）。但是在回归树中的样本标签是连续数值，可划分点包含了所有特征的所有可取的值。所以再使用熵之类的指标不再合适，取而代之的是平方误差，它能很好的评判拟合程度。</strong> 基函数确定了以后，我们需要确定每次提升的标准是什么。回想Adaboost算法，在Adaboost算法内使用了分类错误率修正样本权重以及计算每个基本分类器的权重，那回归问题没有分类错误率可言，也就没办法在这里的回归问题使用了，因此我们需要另辟蹊径。模仿分类错误率，我们用每个样本的残差表示每次使用基函数预测时没有解决的那部分问题。因此，我们可以得出如下算法：<br></p> @@ -217,11 +217,11 @@ 2021-06-17T15:15:00.000Z 2024-10-09T07:33:09.915Z - 1. 导论

        25. 在前面的学习中，我们探讨了一系列简单而实用的回归和分类模型，同时也探讨了如何使用集成学习家族中的Bagging思想去优化最终的模型。Bagging思想的实质是：通过Bootstrap 的方式对全样本数据集进行抽样得到抽样子集，对不同的子集使用同一种基本模型进行拟合，然后投票得出最终的预测。我们也从前面的探讨知道：Bagging主要通过降低方差的方式减少预测误差。那么，本章介绍的Boosting是与Bagging截然不同的思想，Boosting方法是使用同一组数据集进行反复学习，得到一系列简单模型，然后组合这些模型构成一个预测性能十分强大的机器学习模型。 显然，Boosting思想提高最终的预测效果是通过不断减少偏差的形式，与Bagging有着本质的不同。在Boosting这一大类方法中，笔者主要介绍两类常用的Boosting方式：Adaptive Boosting 和 Gradient Boosting 以及它们的变体Xgboost、LightGBM以及Catboost。

        2. Boosting方法的基本思路

        在正式介绍Boosting思想之前，我想先介绍两个例子：
        第一个例子：不知道大家有没有做过错题本，我们将每次测验的错的题目记录在错题本上，不停的翻阅，直到我们完全掌握(也就是能够在考试中能够举一反三)。
        第二个例子：对于一个复杂任务来说，将多个专家的判断进行适当的综合所作出的判断，要比其中任何一个专家单独判断要好。实际上这是一种“三个臭皮匠顶个诸葛亮的道理”。
        这两个例子都说明Boosting的道理，也就是不错地重复学习达到最终的要求。
        Boosting的提出与发展离不开Valiant和 Kearns的努力，历史上正是Valiant和 Kearns提出了”强可学习”和”弱可学习”的概念。那什么是”强可学习”和”弱可学习”呢？在概率近似正确PAC学习的框架下：

        • 弱学习：识别错误率小于1/2（即准确率仅比随机猜测略高的学习算法）
        • 强学习：识别准确率很高并能在多项式时间内完成的学习算法

        非常有趣的是，在PAC 学习的框架下，强可学习和弱可学习是等价的，也就是说一个概念是强可学习的充分必要条件是这个概念是弱可学习的。这样一来，问题便是：在学习中，如果已经发现了弱可学习算法，能否将他提升至强可学习算法。因为，弱可学习算法比强可学习算法容易得多。提升方法就是从弱学习算法出发，反复学习，得到一系列弱分类器(又称为基本分类器)，然后通过一定的形式去组合这些弱分类器构成一个强分类器。大多数的Boosting方法都是通过改变训练数据集的概率分布(训练数据不同样本的权值)，针对不同概率分布的数据调用弱分类算法学习一系列的弱分类器。
        对于Boosting方法来说，有两个问题需要给出答案：第一个是每一轮学习应该如何改变数据的概率分布，第二个是如何将各个弱分类器组合起来。关于这两个问题，不同的Boosting算法会有不同的答案，我们接下来介绍一种最经典的Boosting算法—-Adaboost，我们需要理解Adaboost是怎么处理这两个问题以及为什么这么处理的。

        3. Adaboost算法

        Adaboost的基本原理

        对于Adaboost来说，解决上述的两个问题的方式是：

        • 提高那些被前一轮分类器错误分类的样本的权重，而降低那些被正确分类的样本的权重。这样一来，那些在上一轮分类器中没有得到正确分类的样本，由于其权重的增大而在后一轮的训练中“备受关注”。
        • 各个弱分类器的组合是通过采取加权多数表决的方式，具体来说，加大分类错误率低的弱分类器的权重，因为这些分类器能更好地完成分类任务，而减小分类错误率较大的弱分类器的权重，使其在表决中起较小的作用。

        现在，我们来具体介绍Adaboost算法：(参考李航老师的《统计学习方法》)
        假设给定一个二分类的训练数据集：$T=\left{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right}$ ，其中每个样本点由特征与类别组成。特征$x_{i} \in \mathcal{X} \subseteq \mathbf{R}^{n}$，类别$y_{i} \in \mathcal{Y}={-1,+1}$，$\mathcal{X}$是特征空间，$ \mathcal{Y}$是类别集合，输出最终分类器$G(x)$。Adaboost算法如下：
        (1) 初始化训练数据的分布：$D_{1}=\left(w_{11}, \cdots, w_{1 i}, \cdots, w_{1 N}\right), \quad w_{1 i}=\frac{1}{N}, \quad i=1,2, \cdots, N$
        (2) 对于m=1,2,…,M

        • 使用具有权值分布$D_m$的训练数据集进行学习，得到基本分类器：$G_{m}(x): \mathcal{X} \rightarrow{-1,+1}$

        • 计算$G_m(x)$在训练集上的分类误差率$e_{m}=\sum_{i=1}^{N} P\left(G_{m}\left(x_{i}\right) \neq y_{i}\right)=\sum_{i=1}^{N} w_{m i} I\left(G_{m}\left(x_{i}\right) \neq y_{i}\right)$

        • 计算$G_m(x)$的系数$\alpha_{m}=\frac{1}{2} \log \frac{1-e_{m}}{e_{m}}$，这里的log是自然对数ln

        • 更新训练数据集的权重分布
          $$
          \begin{array}{c}
          D_{m+1}=\left(w_{m+1,1}, \cdots, w_{m+1, i}, \cdots, w_{m+1, N}\right) \
          w_{m+1, i}=\frac{w_{m i}}{Z_{m}} \exp \left(-\alpha_{m} y_{i} G_{m}\left(x_{i}\right)\right), \quad i=1,2, \cdots, N
          \end{array}
          $$

          这里的$Z_m$是规范化因子，使得$D_{m+1}$称为概率分布，$Z_{m}=\sum_{i=1}^{N} w_{m i} \exp \left(-\alpha_{m} y_{i} G_{m}\left(x_{i}\right)\right)$

        (3) 构建基本分类器的线性组合$f(x)=\sum_{m=1}^{M} \alpha_{m} G_{m}(x)$，得到最终的分类器

        $$
        \begin{aligned}
        G(x) &=\operatorname{sign}(f(x)) \
        &=\operatorname{sign}\left(\sum_{m=1}^{M} \alpha_{m} G_{m}(x)\right)
        \end{aligned}
        $$

        下面对Adaboost算法做如下说明：
        对于步骤(1)，假设训练数据的权值分布是均匀分布，是为了使得第一次没有先验信息的条件下每个样本在基本分类器的学习中作用一样。
        对于步骤(2)，每一次迭代产生的基本分类器$G_m(x)$在加权训练数据集上的分类错误率$\begin{aligned}e_{m} &=\sum_{i=1}^{N} P\left(G_{m}\left(x_{i}\right) \neq y_{i}\right) =\sum_{G_{m}\left(x_{i}\right) \neq y_{i}} w_{m i}\end{aligned}$代表了在$G_m(x)$中分类错误的样本权重和，这点直接说明了权重分布$D_m$与$G_m(x)$的分类错误率$e_m$有直接关系。同时，在步骤(2)中，计算基本分类器$G_m(x)$的系数$\alpha_m$，$\alpha_{m}=\frac{1}{2} \log \frac{1-e_{m}}{e_{m}}$，它表示了$G_m(x)$在最终分类器的重要性程度，$\alpha_m$的取值由基本分类器$G_m(x)$的分类错误率有直接关系，当$e_{m} \leqslant \frac{1}{2}$时，$\alpha_{m} \geqslant 0$，并且$\alpha_m$随着$e_m$的减少而增大，因此分类错误率越小的基本分类器在最终分类器的作用越大！
        **最重要的，对于步骤(2)中的样本权重的更新： **
        $$
        w_{m+1, i}=\left{\begin{array}{ll}
        \frac{w_{m i}}{Z_{m}} \mathrm{e}^{-\alpha_{m}}, & G_{m}\left(x_{i}\right)=y_{i} \
        \frac{w_{m i}}{Z_{m}} \mathrm{e}^{\alpha_{m}}, & G_{m}\left(x_{i}\right) \neq y_{i}
        \end{array}\right.
        $$
        因此，从上式可以看到：被基本分类器$G_m(x)$错误分类的样本的权重扩大，被正确分类的样本权重减少，二者相比相差$\mathrm{e}^{2 \alpha_{m}}=\frac{1-e_{m}}{e_{m}}$倍。
        对于步骤(3)，线性组合$f(x)$实现了将M个基本分类器的加权表决，系数$\alpha_m$标志了基本分类器$G_m(x)$的重要性，值得注意的是：所有的$\alpha_m$之和不为1。$f(x)$的符号决定了样本x属于哪一类。

        下面，我们使用一组简单的数据来手动计算Adaboost算法的过程：(例子来源：http://www.csie.edu.tw)

        训练数据如下表，假设基本分类器的形式是一个分割$x<v$或$x>v$表示，阈值v由该基本分类器在训练数据集上分类错误率$e_m$最低确定。
        $$
        \begin{array}{ccccccccccc}
        \hline \text { 序号 } & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 \
        \hline x & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \
        y & 1 & 1 & 1 & -1 & -1 & -1 & 1 & 1 & 1 & -1 \
        \hline
        \end{array}
        $$
        解：
        初始化样本权值分布
        $$
        \begin{aligned}
        D_{1} &=\left(w_{11}, w_{12}, \cdots, w_{110}\right) \
        w_{1 i} &=0.1, \quad i=1,2, \cdots, 10
        \end{aligned}
        $$
        对m=1:

        • 在权值分布$D_1$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=2.5时分类误差率最低，那么基本分类器为：
          $$
          G_{1}(x)=\left{\begin{array}{ll}
          1, & x<2.5 \
        • 1, & x>2.5
          \end{array}\right.
          $$
        • $G_1(x)$在训练数据集上的误差率为$e_{1}=P\left(G_{1}\left(x_{i}\right) \neq y_{i}\right)=0.3$。
        • 计算$G_1(x)$的系数：$\alpha_{1}=\frac{1}{2} \log \frac{1-e_{1}}{e_{1}}=0.4236$
        • 更新训练数据的权值分布：
          $$
          \begin{aligned}
          D_{2}=&\left(w_{21}, \cdots, w_{2 i}, \cdots, w_{210}\right) \
          w_{2 i}=& \frac{w_{1 i}}{Z_{1}} \exp \left(-\alpha_{1} y_{i} G_{1}\left(x_{i}\right)\right), \quad i=1,2, \cdots, 10 \
          D_{2}=&(0.07143,0.07143,0.07143,0.07143,0.07143,0.07143,\
          &0.16667,0.16667,0.16667,0.07143) \
          f_{1}(x) &=0.4236 G_{1}(x)
          \end{aligned}
          $$

        对于m=2：

        • 在权值分布$D_2$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=8.5时分类误差率最低，那么基本分类器为：
          $$
          G_{2}(x)=\left{\begin{array}{ll}
          1, & x<8.5 \
        • 1, & x>8.5
          \end{array}\right.
          $$
        • $G_2(x)$在训练数据集上的误差率为$e_2 = 0.2143$
        • 计算$G_2(x)$的系数：$\alpha_2 = 0.6496$
        • 更新训练数据的权值分布：
          $$
          \begin{aligned}
          D_{3}=&(0.0455,0.0455,0.0455,0.1667,0.1667,0.1667\
          &0.1060,0.1060,0.1060,0.0455) \
          f_{2}(x) &=0.4236 G_{1}(x)+0.6496 G_{2}(x)
          \end{aligned}
          $$

        对m=3：

        • 在权值分布$D_3$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=5.5时分类误差率最低，那么基本分类器为：
          $$
          G_{3}(x)=\left{\begin{array}{ll}
          1, & x>5.5 \
        • 1, & x<5.5
          \end{array}\right.
          $$
        • $G_3(x)$在训练数据集上的误差率为$e_3 = 0.1820$
        • 计算$G_3(x)$的系数：$\alpha_3 = 0.7514$
        • 更新训练数据的权值分布：
          $$
          D_{4}=(0.125,0.125,0.125,0.102,0.102,0.102,0.065,0.065,0.065,0.125)
          $$

        于是得到：$f_{3}(x)=0.4236 G_{1}(x)+0.6496 G_{2}(x)+0.7514 G_{3}(x)$，分类器$\operatorname{sign}\left[f_{3}(x)\right]$在训练数据集上的误分类点的个数为0。
        于是得到最终分类器为：$G(x)=\operatorname{sign}\left[f_{3}(x)\right]=\operatorname{sign}\left[0.4236 G_{1}(x)+0.6496 G_{2}(x)+0.7514 G_{3}(x)\right]$

        下面，我们使用sklearn对Adaboost算法进行建模：

        本次案例我们使用一份UCI的机器学习库里的开源数据集：葡萄酒数据集，该数据集可以在 ( https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data )上获得。该数据集包含了178个样本和13个特征，从不同的角度对不同的化学特性进行描述，我们的任务是根据这些数据预测红酒属于哪一个类别。(案例来源《python机器学习(第二版》)

        # 引入数据科学相关工具包：
        import numpy as np
        import pandas as pd 
        import matplotlib.pyplot as plt
        plt.style.use("ggplot")
        %matplotlib inline
        import seaborn as sns
        # 加载训练数据：         
        wine = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data",header=None)
        wine.columns = ['Class label', 'Alcohol', 'Malic acid', 'Ash', 'Alcalinity of ash','Magnesium', 'Total phenols','Flavanoids', 'Nonflavanoid phenols', 
                        'Proanthocyanins','Color intensity', 'Hue','OD280/OD315 of diluted wines','Proline']
        # 数据查看：
        print("Class labels",np.unique(wine["Class label"]))
        wine.head()

        下面对数据做简单解读：

        • Class label：分类标签
        • Alcohol：酒精
        • Malic acid：苹果酸
        • Ash：灰
        • Alcalinity of ash：灰的碱度
        • Magnesium：镁
        • Total phenols：总酚
        • Flavanoids：黄酮类化合物
        • Nonflavanoid phenols：非黄烷类酚类
        • Proanthocyanins：原花青素
        • Color intensity：色彩强度
        • Hue：色调
        • OD280/OD315 of diluted wines：稀释酒OD280 OD350
        • Proline：脯氨酸 
        # 数据预处理
        # 仅仅考虑2，3类葡萄酒，去除1类
        wine = wine[wine['Class label']!=1]
        y = wine['Class label'].values
        X = wine[['Alcohol','OD280/OD315 of diluted wines']].values
        # 将分类标签变成二进制编码：
        from sklearn.preprocessing import LabelEncoder
        le = LabelEncoder()
        y = le.fit_transform(y)

        # 按8：2分割训练集和测试集
        from sklearn.model_selection import train_test_split
        X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1,stratify=y) # stratify参数代表了按照y的类别等比例抽样

        使用单一决策树建模

        from sklearn.tree import DecisionTreeClassifier
        tree = DecisionTreeClassifier(criterion='entropy',random_state=1,max_depth=1)
        from sklearn.metrics import accuracy_score
        tree = tree.fit(X_train,y_train)
        y_train_pred = tree.predict(X_train)
        y_test_pred = tree.predict(X_test)
        tree_train = accuracy_score(y_train,y_train_pred)
        tree_test = accuracy_score(y_test,y_test_pred)
        print('Decision tree train/test accuracies %.3f/%.3f' % (tree_train,tree_test))

        使用sklearn实现Adaboost(基分类器为决策树)

        # 使用sklearn实现Adaboost(基分类器为决策树)
        '''
        AdaBoostClassifier相关参数：
        base_estimator：基本分类器，默认为DecisionTreeClassifier(max_depth=1)
        n_estimators：终止迭代的次数
        learning_rate：学习率
        algorithm：训练的相关算法，{'SAMME'，'SAMME.R'}，默认='SAMME.R'
        random_state：随机种子
        '''
        from sklearn.ensemble import AdaBoostClassifier
        adaboost = AdaBoostClassifier(base_estimator=tree,n_estimators=500,learning_rate=0.1,random_state=1)
        adaboost = adaboost.fit(X_train,y_train)
        y_train_pred = adaboost.predict(X_train)
        y_test_pred = adaboost.predict(X_test)
        ada_train = accuracy_score(y_train,y_train_pred)
        ada_test = accuracy_score(y_test,y_test_pred)
        print('Adaboost train/test accuracies %.3f/%.3f' % (ada_train,ada_test))

        结果分析：单层决策树似乎对训练数据欠拟合，而Adaboost模型正确地预测了训练数据的所有分类标签，而且与单层决策树相比，Adaboost的测试性能也略有提高。然而，为什么模型在训练集和测试集的性能相差这么大呢？我们使用图像来简单说明下这个道理！

        # 画出单层决策树与Adaboost的决策边界：
        x_min = X_train[:, 0].min() - 1
        x_max = X_train[:, 0].max() + 1
        y_min = X_train[:, 1].min() - 1
        y_max = X_train[:, 1].max() + 1
        # 生成网格矩阵
        xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),np.arange(y_min, y_max, 0.1))
        f, axarr = plt.subplots(nrows=1, ncols=2,sharex='col',sharey='row',figsize=(12, 6))
        for idx, clf, tt in zip([0, 1],[tree, adaboost],['Decision tree', 'Adaboost']):
            clf.fit(X_train, y_train)
            Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
            Z = Z.reshape(xx.shape)
            axarr[idx].contourf(xx, yy, Z, alpha=0.3)
            axarr[idx].scatter(X_train[y_train==0, 0],X_train[y_train==0, 1],c='blue', marker='^')
            axarr[idx].scatter(X_train[y_train==1, 0],X_train[y_train==1, 1],c='red', marker='o')
            axarr[idx].set_title(tt)

        在这里插入图片描述

        从上面的决策边界图可以看到：Adaboost模型的决策边界比单层决策树的决策边界要复杂的多。也就是说，Adaboost试图用增加模型复杂度而降低偏差的方式去减少总误差，但是过程中引入了方差，可能出现过拟合，因此在训练集和测试集之间的性能存在较大的差距，这就简单地回答的刚刚问题。
        值的注意的是：与单个分类器相比，Adaboost等Boosting模型增加了计算的复杂度，在实践中需要仔细思考是否愿意为预测性能的相对改善而增加计算成本，而且Boosting方式无法做到现在流行的并行计算的方式进行训练，因为每一步迭代都要基于上一部的基本分类器。

        4. 前向分步算法

        回看Adaboost的算法内容，我们需要通过计算M个基本分类器，每个分类器的错误率、样本权重以及模型权重。我们可以认为：Adaboost每次学习单一分类器以及单一分类器的参数(权重)。接下来，我们抽象出Adaboost算法的整体框架逻辑，构建集成学习的一个非常重要的框架—-前向分步算法，有了这个框架，我们不仅可以解决分类问题，也可以解决回归问题。
        (1) 加法模型：
        在Adaboost模型中，我们把每个基本分类器合成一个复杂分类器的方法是每个基本分类器的加权和，即：$f(x)=\sum_{m=1}^{M} \beta_{m} b\left(x ; \gamma_{m}\right)$，其中，$b\left(x ; \gamma_{m}\right)$为即基本分类器，$\gamma_{m}$为基本分类器的参数，$\beta_m$为基本分类器的权重，显然这与第二章所学的加法模型。为什么这么说呢？大家把$b(x ; \gamma_{m})$看成是即函数即可。
        在给定训练数据以及损失函数$L(y, f(x))$的条件下，学习加法模型$f(x)$就是：
        $$
        \min {\beta{m}, \gamma_{m}} \sum_{i=1}^{N} L\left(y_{i}, \sum_{m=1}^{M} \beta_{m} b\left(x_{i} ; \gamma_{m}\right)\right)
        $$
        通常这是一个复杂的优化问题，很难通过简单的凸优化的相关知识进行解决。前向分步算法可以用来求解这种方式的问题，它的基本思路是：因为学习的是加法模型，如果从前向后，每一步只优化一个基函数及其系数，逐步逼近目标函数，那么就可以降低优化的复杂度。具体而言，每一步只需要优化：
        $$
        \min {\beta, \gamma} \sum{i=1}^{N} L\left(y_{i}, \beta b\left(x_{i} ; \gamma\right)\right)
        $$
        (2) 前向分步算法：
        给定数据集$T=\left{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right}$，$x_{i} \in \mathcal{X} \subseteq \mathbf{R}^{n}$，$y_{i} \in \mathcal{Y}={+1,-1}$。损失函数$L(y, f(x))$，基函数集合${b(x ; \gamma)}$，我们需要输出加法模型$f(x)$。

        • 初始化：$f_{0}(x)=0$
        • 对m = 1,2,…,M:
          • (a) 极小化损失函数：
            $$
            \left(\beta_{m}, \gamma_{m}\right)=\arg \min {\beta, \gamma} \sum{i=1}^{N} L\left(y_{i}, f_{m-1}\left(x_{i}\right)+\beta b\left(x_{i} ; \gamma\right)\right)
            $$
            得到参数$\beta_{m}$与$\gamma_{m}$
          • (b) 更新：
            $$
            f_{m}(x)=f_{m-1}(x)+\beta_{m} b\left(x ; \gamma_{m}\right)
            $$
        • 得到加法模型：
          $$
          f(x)=f_{M}(x)=\sum_{m=1}^{M} \beta_{m} b\left(x ; \gamma_{m}\right)
          $$

        这样，前向分步算法将同时求解从m=1到M的所有参数$\beta_{m}$，$\gamma_{m}$的优化问题简化为逐次求解各个$\beta_{m}$，$\gamma_{m}$的问题。
        (3) 前向分步算法与Adaboost的关系：
        由于这里不是我们的重点，我们主要阐述这里的结论，不做相关证明，具体的证明见李航老师的《统计学习方法》第八章的3.2节。Adaboost算法是前向分步算法的特例，Adaboost算法是由基本分类器组成的加法模型，损失函数为指数损失函数。

        ]]> + 1. 导论

        25. 在前面的学习中，我们探讨了一系列简单而实用的回归和分类模型，同时也探讨了如何使用集成学习家族中的Bagging思想去优化最终的模型。Bagging思想的实质是：通过Bootstrap 的方式对全样本数据集进行抽样得到抽样子集，对不同的子集使用同一种基本模型进行拟合，然后投票得出最终的预测。我们也从前面的探讨知道：Bagging主要通过降低方差的方式减少预测误差。那么，本章介绍的Boosting是与Bagging截然不同的思想，Boosting方法是使用同一组数据集进行反复学习，得到一系列简单模型，然后组合这些模型构成一个预测性能十分强大的机器学习模型。 显然，Boosting思想提高最终的预测效果是通过不断减少偏差的形式，与Bagging有着本质的不同。在Boosting这一大类方法中，笔者主要介绍两类常用的Boosting方式：Adaptive Boosting 和 Gradient Boosting 以及它们的变体Xgboost、LightGBM以及Catboost。

        2. Boosting方法的基本思路

        在正式介绍Boosting思想之前，我想先介绍两个例子：
        第一个例子：不知道大家有没有做过错题本，我们将每次测验的错的题目记录在错题本上，不停的翻阅，直到我们完全掌握(也就是能够在考试中能够举一反三)。
        第二个例子：对于一个复杂任务来说，将多个专家的判断进行适当的综合所作出的判断，要比其中任何一个专家单独判断要好。实际上这是一种“三个臭皮匠顶个诸葛亮的道理”。
        这两个例子都说明Boosting的道理，也就是不错地重复学习达到最终的要求。
        Boosting的提出与发展离不开Valiant和 Kearns的努力，历史上正是Valiant和 Kearns提出了”强可学习”和”弱可学习”的概念。那什么是”强可学习”和”弱可学习”呢？在概率近似正确PAC学习的框架下：

        • 弱学习：识别错误率小于1/2（即准确率仅比随机猜测略高的学习算法）
        • 强学习：识别准确率很高并能在多项式时间内完成的学习算法

        非常有趣的是，在PAC 学习的框架下，强可学习和弱可学习是等价的，也就是说一个概念是强可学习的充分必要条件是这个概念是弱可学习的。这样一来，问题便是：在学习中，如果已经发现了弱可学习算法，能否将他提升至强可学习算法。因为，弱可学习算法比强可学习算法容易得多。提升方法就是从弱学习算法出发，反复学习，得到一系列弱分类器(又称为基本分类器)，然后通过一定的形式去组合这些弱分类器构成一个强分类器。大多数的Boosting方法都是通过改变训练数据集的概率分布(训练数据不同样本的权值)，针对不同概率分布的数据调用弱分类算法学习一系列的弱分类器。
        对于Boosting方法来说，有两个问题需要给出答案：第一个是每一轮学习应该如何改变数据的概率分布，第二个是如何将各个弱分类器组合起来。关于这两个问题，不同的Boosting算法会有不同的答案，我们接下来介绍一种最经典的Boosting算法——Adaboost，我们需要理解Adaboost是怎么处理这两个问题以及为什么这么处理的。

        3. Adaboost算法

        Adaboost的基本原理

        对于Adaboost来说，解决上述的两个问题的方式是：

        • 提高那些被前一轮分类器错误分类的样本的权重，而降低那些被正确分类的样本的权重。这样一来，那些在上一轮分类器中没有得到正确分类的样本，由于其权重的增大而在后一轮的训练中“备受关注”。
        • 各个弱分类器的组合是通过采取加权多数表决的方式，具体来说，加大分类错误率低的弱分类器的权重，因为这些分类器能更好地完成分类任务，而减小分类错误率较大的弱分类器的权重，使其在表决中起较小的作用。

        现在，我们来具体介绍Adaboost算法：(参考李航老师的《统计学习方法》)
        假设给定一个二分类的训练数据集：$T=\left{\left(x{1}, y{1}\right),\left(x{2}, y{2}\right), \cdots,\left(x{N}, y{N}\right)\right}$ ，其中每个样本点由特征与类别组成。特征$x{i} \in \mathcal{X} \subseteq \mathbf{R}^{n}$，类别$y{i} \in \mathcal{Y}={-1,+1}$，$\mathcal{X}$是特征空间，$ \mathcal{Y}$是类别集合，输出最终分类器$G(x)$。Adaboost算法如下：
        (1) 初始化训练数据的分布：$D{1}=\left(w{11}, \cdots, w{1 i}, \cdots, w{1 N}\right), \quad w_{1 i}=\frac{1}{N}, \quad i=1,2, \cdots, N$
        (2) 对于m=1,2,…,M

        • 使用具有权值分布$Dm$的训练数据集进行学习，得到基本分类器：$G{m}(x): \mathcal{X} \rightarrow{-1,+1}$
        • 计算$Gm(x)$在训练集上的分类误差率$e{m}=\sum{i=1}^{N} P\left(G{m}\left(x{i}\right) \neq y{i}\right)=\sum{i=1}^{N} w{m i} I\left(G{m}\left(x{i}\right) \neq y_{i}\right)$
        • 计算$Gm(x)$的系数$\alpha{m}=\frac{1}{2} \log \frac{1-e{m}}{e{m}}$，这里的log是自然对数ln

        • 更新训练数据集的权重分布

          这里的$Zm$是规范化因子，使得$D{m+1}$称为概率分布，$Z{m}=\sum{i=1}^{N} w{m i} \exp \left(-\alpha{m} y{i} G{m}\left(x_{i}\right)\right)$

        (3) 构建基本分类器的线性组合$f(x)=\sum{m=1}^{M} \alpha{m} G_{m}(x)$，得到最终的分类器

        下面对Adaboost算法做如下说明：
        对于步骤(1)，假设训练数据的权值分布是均匀分布，是为了使得第一次没有先验信息的条件下每个样本在基本分类器的学习中作用一样。
        对于步骤(2)，每一次迭代产生的基本分类器$Gm(x)$在加权训练数据集上的分类错误率$\begin{aligned}e{m} &=\sum{i=1}^{N} P\left(G{m}\left(x{i}\right) \neq y{i}\right) =\sum{G{m}\left(x{i}\right) \neq y{i}} w{m i}\end{aligned}$代表了在$G_m(x)$中分类错误的样本权重和，这点直接说明了权重分布$D_m$与$G_m(x)$的分类错误率$e_m$有直接关系。同时，在步骤(2)中，计算基本分类器$G_m(x)$的系数$\alpha_m$，$\alpha{m}=\frac{1}{2} \log \frac{1-e{m}}{e{m}}$，它表示了$Gm(x)$在最终分类器的重要性程度，$\alpha_m$的取值由基本分类器$G_m(x)$的分类错误率有直接关系，当$e{m} \leqslant \frac{1}{2}$时，$\alpha_{m} \geqslant 0$，并且$\alpha_m$随着$e_m$的减少而增大，因此分类错误率越小的基本分类器在最终分类器的作用越大！
        最重要的，对于步骤(2)中的样本权重的更新：

        因此，从上式可以看到：被基本分类器$Gm(x)$错误分类的样本的权重扩大，被正确分类的样本权重减少，二者相比相差$\mathrm{e}^{2 \alpha{m}}=\frac{1-e{m}}{e{m}}$倍。
        对于步骤(3)，线性组合$f(x)$实现了将M个基本分类器的加权表决，系数$\alpha_m$标志了基本分类器$G_m(x)$的重要性，值得注意的是：所有的$\alpha_m$之和不为1。$f(x)$的符号决定了样本x属于哪一类。

        下面，我们使用一组简单的数据来手动计算Adaboost算法的过程：(例子来源：http://www.csie.edu.tw)

        训练数据如下表，假设基本分类器的形式是一个分割$xv$表示，阈值v由该基本分类器在训练数据集上分类错误率$e_m$最低确定。

        解：
        初始化样本权值分布

        对m=1:

        • 在权值分布$D_1$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=2.5时分类误差率最低，那么基本分类器为：
        • $G1(x)$在训练数据集上的误差率为$e{1}=P\left(G{1}\left(x{i}\right) \neq y_{i}\right)=0.3$。
        • 计算$G1(x)$的系数：$\alpha{1}=\frac{1}{2} \log \frac{1-e{1}}{e{1}}=0.4236$
        • 更新训练数据的权值分布：

        对于m=2：

        • 在权值分布$D_2$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=8.5时分类误差率最低，那么基本分类器为：
        • $G_2(x)$在训练数据集上的误差率为$e_2 = 0.2143$
        • 计算$G_2(x)$的系数：$\alpha_2 = 0.6496$
        • 更新训练数据的权值分布：

        对m=3：

        • 在权值分布$D_3$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=5.5时分类误差率最低，那么基本分类器为：
        • $G_3(x)$在训练数据集上的误差率为$e_3 = 0.1820$
        • 计算$G_3(x)$的系数：$\alpha_3 = 0.7514$
        • 更新训练数据的权值分布：

        于是得到：$f{3}(x)=0.4236 G{1}(x)+0.6496 G{2}(x)+0.7514 G{3}(x)$，分类器$\operatorname{sign}\left[f{3}(x)\right]$在训练数据集上的误分类点的个数为0。
        于是得到最终分类器为：$G(x)=\operatorname{sign}\left[f        {3}(x)\right]=\operatorname{sign}\left[0.4236 G{1}(x)+0.6496 G{2}(x)+0.7514 G_{3}(x)\right]$

        下面，我们使用sklearn对Adaboost算法进行建模：

        本次案例我们使用一份UCI的机器学习库里的开源数据集：葡萄酒数据集，该数据集可以在 ( https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data )上获得。该数据集包含了178个样本和13个特征，从不同的角度对不同的化学特性进行描述，我们的任务是根据这些数据预测红酒属于哪一个类别。(案例来源《python机器学习(第二版》)

        # 引入数据科学相关工具包：
        import numpy as np
        import pandas as pd 
        import matplotlib.pyplot as plt
        plt.style.use("ggplot")
        %matplotlib inline
        import seaborn as sns
        # 加载训练数据：         
        wine = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data",header=None)
        wine.columns = ['Class label', 'Alcohol', 'Malic acid', 'Ash', 'Alcalinity of ash','Magnesium', 'Total phenols','Flavanoids', 'Nonflavanoid phenols', 
                        'Proanthocyanins','Color intensity', 'Hue','OD280/OD315 of diluted wines','Proline']
        # 数据查看：
        print("Class labels",np.unique(wine["Class label"]))
        wine.head()

        下面对数据做简单解读：

        • Class label：分类标签
        • Alcohol：酒精
        • Malic acid：苹果酸
        • Ash：灰
        • Alcalinity of ash：灰的碱度
        • Magnesium：镁
        • Total phenols：总酚
        • Flavanoids：黄酮类化合物
        • Nonflavanoid phenols：非黄烷类酚类
        • Proanthocyanins：原花青素
        • Color intensity：色彩强度
        • Hue：色调
        • OD280/OD315 of diluted wines：稀释酒OD280 OD350
        • Proline：脯氨酸 
        # 数据预处理
        # 仅仅考虑2，3类葡萄酒，去除1类
        wine = wine[wine['Class label']!=1]
        y = wine['Class label'].values
        X = wine[['Alcohol','OD280/OD315 of diluted wines']].values
        # 将分类标签变成二进制编码：
        from sklearn.preprocessing import LabelEncoder
        le = LabelEncoder()
        y = le.fit_transform(y)

        # 按8：2分割训练集和测试集
        from sklearn.model_selection import train_test_split
        X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1,stratify=y) # stratify参数代表了按照y的类别等比例抽样

        使用单一决策树建模

        from sklearn.tree import DecisionTreeClassifier
        tree = DecisionTreeClassifier(criterion='entropy',random_state=1,max_depth=1)
        from sklearn.metrics import accuracy_score
        tree = tree.fit(X_train,y_train)
        y_train_pred = tree.predict(X_train)
        y_test_pred = tree.predict(X_test)
        tree_train = accuracy_score(y_train,y_train_pred)
        tree_test = accuracy_score(y_test,y_test_pred)
        print('Decision tree train/test accuracies %.3f/%.3f' % (tree_train,tree_test))

        使用sklearn实现Adaboost(基分类器为决策树)

        # 使用sklearn实现Adaboost(基分类器为决策树)
        '''
        AdaBoostClassifier相关参数：
        base_estimator：基本分类器，默认为DecisionTreeClassifier(max_depth=1)
        n_estimators：终止迭代的次数
        learning_rate：学习率
        algorithm：训练的相关算法，{'SAMME'，'SAMME.R'}，默认='SAMME.R'
        random_state：随机种子
        '''
        from sklearn.ensemble import AdaBoostClassifier
        adaboost = AdaBoostClassifier(base_estimator=tree,n_estimators=500,learning_rate=0.1,random_state=1)
        adaboost = adaboost.fit(X_train,y_train)
        y_train_pred = adaboost.predict(X_train)
        y_test_pred = adaboost.predict(X_test)
        ada_train = accuracy_score(y_train,y_train_pred)
        ada_test = accuracy_score(y_test,y_test_pred)
        print('Adaboost train/test accuracies %.3f/%.3f' % (ada_train,ada_test))

        结果分析：单层决策树似乎对训练数据欠拟合，而Adaboost模型正确地预测了训练数据的所有分类标签，而且与单层决策树相比，Adaboost的测试性能也略有提高。然而，为什么模型在训练集和测试集的性能相差这么大呢？我们使用图像来简单说明下这个道理！

        # 画出单层决策树与Adaboost的决策边界：
        x_min = X_train[:, 0].min() - 1
        x_max = X_train[:, 0].max() + 1
        y_min = X_train[:, 1].min() - 1
        y_max = X_train[:, 1].max() + 1
        # 生成网格矩阵
        xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),np.arange(y_min, y_max, 0.1))
        f, axarr = plt.subplots(nrows=1, ncols=2,sharex='col',sharey='row',figsize=(12, 6))
        for idx, clf, tt in zip([0, 1],[tree, adaboost],['Decision tree', 'Adaboost']):
            clf.fit(X_train, y_train)
            Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
            Z = Z.reshape(xx.shape)
            axarr[idx].contourf(xx, yy, Z, alpha=0.3)
            axarr[idx].scatter(X_train[y_train==0, 0],X_train[y_train==0, 1],c='blue', marker='^')
            axarr[idx].scatter(X_train[y_train==1, 0],X_train[y_train==1, 1],c='red', marker='o')
            axarr[idx].set_title(tt)

        在这里插入图片描述

        从上面的决策边界图可以看到：Adaboost模型的决策边界比单层决策树的决策边界要复杂的多。也就是说，Adaboost试图用增加模型复杂度而降低偏差的方式去减少总误差，但是过程中引入了方差，可能出现过拟合，因此在训练集和测试集之间的性能存在较大的差距，这就简单地回答的刚刚问题。
        值的注意的是：与单个分类器相比，Adaboost等Boosting模型增加了计算的复杂度，在实践中需要仔细思考是否愿意为预测性能的相对改善而增加计算成本，而且Boosting方式无法做到现在流行的并行计算的方式进行训练，因为每一步迭代都要基于上一部的基本分类器。

        4. 前向分步算法

        回看Adaboost的算法内容，我们需要通过计算M个基本分类器，每个分类器的错误率、样本权重以及模型权重。我们可以认为：Adaboost每次学习单一分类器以及单一分类器的参数(权重)。接下来，我们抽象出Adaboost算法的整体框架逻辑，构建集成学习的一个非常重要的框架——前向分步算法，有了这个框架，我们不仅可以解决分类问题，也可以解决回归问题。
        (1) 加法模型：
        在Adaboost模型中，我们把每个基本分类器合成一个复杂分类器的方法是每个基本分类器的加权和，即：$f(x)=\sum{m=1}^{M} \beta{m} b\left(x ; \gamma{m}\right)$，其中，$b\left(x ; \gamma{m}\right)$为即基本分类器，$\gamma{m}$为基本分类器的参数，$\beta_m$为基本分类器的权重，显然这与第二章所学的加法模型。为什么这么说呢？大家把$b(x ; \gamma{m})$看成是即函数即可。
        在给定训练数据以及损失函数$L(y, f(x))$的条件下，学习加法模型$f(x)$就是：

        通常这是一个复杂的优化问题，很难通过简单的凸优化的相关知识进行解决。前向分步算法可以用来求解这种方式的问题，它的基本思路是：因为学习的是加法模型，如果从前向后，每一步只优化一个基函数及其系数，逐步逼近目标函数，那么就可以降低优化的复杂度。具体而言，每一步只需要优化：

        (2) 前向分步算法：
        给定数据集$T=\left{\left(x{1}, y{1}\right),\left(x{2}, y{2}\right), \cdots,\left(x{N}, y{N}\right)\right}$，$x{i} \in \mathcal{X} \subseteq \mathbf{R}^{n}$，$y{i} \in \mathcal{Y}={+1,-1}$。损失函数$L(y, f(x))$，基函数集合${b(x ; \gamma)}$，我们需要输出加法模型$f(x)$。

        • 初始化：$f_{0}(x)=0$
        • 对m = 1,2,…,M:
          • (a) 极小化损失函数：得到参数$\beta{m}$与$\gamma{m}$
          • (b) 更新：
        • 得到加法模型：

        这样，前向分步算法将同时求解从m=1到M的所有参数$\beta{m}$，$\gamma{m}$的优化问题简化为逐次求解各个$\beta{m}$，$\gamma{m}$的问题。
        (3) 前向分步算法与Adaboost的关系：
        由于这里不是我们的重点，我们主要阐述这里的结论，不做相关证明，具体的证明见李航老师的《统计学习方法》第八章的3.2节。Adaboost算法是前向分步算法的特例，Adaboost算法是由基本分类器组成的加法模型，损失函数为指数损失函数。

        ]]> - <h1 id="1-导论"><a href="#1-导论" class="headerlink" title="1. 导论"></a>1. 导论</h1><p>在前面的学习中，我们探讨了一系列简单而实用的回归和分类模型，同时也探讨了如何使用集成学习家族中的Bagging思想去优化最终的模型。Bagging思想的实质是：通过Bootstrap 的方式对全样本数据集进行抽样得到抽样子集，对不同的子集使用同一种基本模型进行拟合，然后投票得出最终的预测。我们也从前面的探讨知道：Bagging主要通过降低方差的方式减少预测误差。<strong>那么，本章介绍的Boosting是与Bagging截然不同的思想，Boosting方法是使用同一组数据集进行反复学习，得到一系列简单模型，然后组合这些模型构成一个预测性能十分强大的机器学习模型。</strong> 显然，Boosting思想提高最终的预测效果是通过不断减少偏差的形式，与Bagging有着本质的不同。在Boosting这一大类方法中，笔者主要介绍两类常用的Boosting方式：Adaptive Boosting 和 Gradient Boosting 以及它们的变体Xgboost、LightGBM以及Catboost。</p> + <h1 id="1-导论"><a href="#1-导论" class="headerlink" title="1. 导论"></a>1. 导论</h1><p>在前面的学习中，我们探讨了一系列简单而实用的回归和分类模型，同时也探讨了如何使用集成学习家族中的Bagging思想去优化最终的模型。Bagging思想的实质是：通过Bootstrap 的方式对全样本数据集进行抽样得到抽样子集，对不同的子集使用同一种基本模型进行拟合，然后投票得出最终的预测。我们也从前面的探讨知道：Bagging主要通过降低方差的方式减少预测误差。<strong>那么，本章介绍的Boosting是与Bagging截然不同的思想，Boosting方法是使用同一组数据集进行反复学习，得到一系列简单模型，然后组合这些模型构成一个预测性能十分强大的机器学习模型。</strong> 显然，Boosting思想提高最终的预测效果是通过不断减少偏差的形式，与Bagging有着本质的不同。在Boosting这一大类方法中，笔者主要介绍两类常用的Boosting方式：Adaptive Boosting 和 Gradient Boosting 以及它们的变体Xgboost、LightGBM以及Catboost。<br></p> @@ -240,7 +240,7 @@ 2021-06-16T15:55:00.000Z 2024-10-09T07:33:09.916Z - 投票法的思路

        投票法是集成学习中常用的技巧，可以帮助我们提高模型的泛化能力，减少模型的错误率。举个例子，在航空航天领域，每个零件发出的电信号都对航空器的成功发射起到重要作用。如果我们有一个二进制形式的信号：

        11101100100111001011011011011

        在传输过程中第二位发生了翻转

        10101100100111001011011011011

        这导致的结果可能是致命的。一个常用的纠错方法是重复多次发送数据，并以少数服从多数的方法确定正确的传输数据。一般情况下，错误总是发生在局部，因此融合多个数据是降低误差的一个好方法，这就是投票法的基本思路。

        对于回归模型来说，投票法最终的预测结果是多个其他回归模型预测结果的平均值。

        对于分类模型，硬投票法的预测结果是多个模型预测结果中出现次数最多的类别，软投票对各类预测结果的概率进行求和，最终选取概率之和最大的类标签。

        投票法的原理分析

        投票法是一种遵循少数服从多数原则的集成学习模型，通过多个模型的集成降低方差，从而提高模型的鲁棒性。在理想情况下，投票法的预测效果应当优于任何一个基模型的预测效果。

        投票法在回归模型与分类模型上均可使用：

        • 回归投票法：预测结果是所有模型预测结果的平均值。
        • 分类投票法：预测结果是所有模型种出现最多的预测结果。

        分类投票法又可以被划分为硬投票与软投票：

        • 硬投票：预测结果是所有投票结果最多出现的类。
        • 软投票：预测结果是所有投票结果中概率加和最大的类。

        下面我们使用一个例子说明硬投票：

        对于某个样本：

        模型 1 的预测结果是 类别 A

        模型 2 的预测结果是 类别 B

        模型 3 的预测结果是 类别 B

        有2/3的模型预测结果是B，因此硬投票法的预测结果是B

        同样的例子说明软投票：

        对于某个样本：

        模型 1 的预测结果是 类别 A 的概率为 99%

        模型 2 的预测结果是 类别 A 的概率为 49%

        模型 3 的预测结果是 类别 A 的概率为 49%

        最终对于类别A的预测概率的平均是 (99 + 49 + 49) / 3 = 65.67%，因此软投票法的预测结果是A。

        从这个例子我们可以看出，软投票法与硬投票法可以得出完全不同的结论。相对于硬投票，软投票法考虑到了预测概率这一额外的信息，因此可以得出比硬投票法更加准确的预测结果。

        在投票法中，我们还需要考虑到不同的基模型可能产生的影响。理论上，基模型可以是任何已被训练好的模型。但在实际应用上，想要投票法产生较好的结果，需要满足两个条件：

        • 基模型之间的效果不能差别过大。当某个基模型相对于其他基模型效果过差时，该模型很可能成为噪声。
        • 基模型之间应该有较小的同质性。例如在基模型预测效果近似的情况下，基于树模型与线性模型的投票，往往优于两个树模型或两个线性模型。

        当投票合集中使用的模型能预测出清晰的类别标签时，适合使用硬投票。当投票集合中使用的模型能预测类别的概率时，适合使用软投票。软投票同样可以用于那些本身并不预测类成员概率的模型，只要他们可以输出类似于概率的预测分数值（例如支持向量机、k-最近邻和决策树）。

        投票法的局限性在于，它对所有模型的处理是一样的，这意味着所有模型对预测的贡献是一样的。如果一些模型在某些情况下很好，而在其他情况下很差，这是使用投票法时需要考虑到的一个问题。

        投票法的案例分析(基于sklearn，介绍pipe管道的使用以及voting的使用)

        Sklearn中提供了 VotingRegressor 与 VotingClassifier 两个投票方法。 这两种模型的操作方式相同，并采用相同的参数。使用模型需要提供一个模型列表，列表中每个模型采用Tuple的结构表示，第一个元素代表名称，第二个元素代表模型，需要保证每个模型必须拥有唯一的名称。

        例如这里，我们定义两个模型：

        models = [('lr',LogisticRegression()),('svm',SVC())]
        ensemble = VotingClassifier(estimators=models)

        有时某些模型需要一些预处理操作，我们可以为他们定义Pipeline完成模型预处理工作：

        models = [('lr',LogisticRegression()),('svm',make_pipeline(StandardScaler(),SVC()))]
        ensemble = VotingClassifier(estimators=models)

        模型还提供了voting参数让我们选择软投票或者硬投票：

        models = [('lr',LogisticRegression()),('svm',SVC())]
        ensemble = VotingClassifier(estimators=models, voting='soft')

        下面我们使用一个完整的例子演示投票法的使用：

        首先我们创建一个1000个样本，20个特征的随机数据集：

        # test classification dataset
        from sklearn.datasets import make_classification
        # define dataset
        X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=2)
        # summarize the dataset
        print(X.shape, y.shape)

        我们使用多个KNN模型作为基模型演示投票法，其中每个模型采用不同的邻居值K参数：

        # get a voting ensemble of models
        def get_voting():
        # define the base models
        models = list()
        models.append(('knn1', KNeighborsClassifier(n_neighbors=1)))
        models.append(('knn3', KNeighborsClassifier(n_neighbors=3)))
        models.append(('knn5', KNeighborsClassifier(n_neighbors=5)))
        models.append(('knn7', KNeighborsClassifier(n_neighbors=7)))
        models.append(('knn9', KNeighborsClassifier(n_neighbors=9)))
        # define the voting ensemble
        ensemble = VotingClassifier(estimators=models, voting='hard')
        return ensemble

        然后，我们可以创建一个模型列表来评估投票带来的提升，包括KNN模型配置的每个独立版本和硬投票模型。下面的get_models()函数可以为我们创建模型列表进行评估。

        # get a list of models to evaluate
        def get_models():
        models = dict()
        models['knn1'] = KNeighborsClassifier(n_neighbors=1)
        models['knn3'] = KNeighborsClassifier(n_neighbors=3)
        models['knn5'] = KNeighborsClassifier(n_neighbors=5)
        models['knn7'] = KNeighborsClassifier(n_neighbors=7)
        models['knn9'] = KNeighborsClassifier(n_neighbors=9)
        models['hard_voting'] = get_voting()
        return models

        下面的evaluate_model()函数接收一个模型实例，并以分层10倍交叉验证三次重复的分数列表的形式返回。

        # evaluate a give model using cross-validation
        def evaluate_model(model, X, y):
        cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
        scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
        return scores

        然后，我们可以报告每个算法的平均性能，还可以创建一个箱形图和须状图来比较每个算法的精度分数分布。

        # define dataset
        X, y = get_dataset()
        # get the models to evaluate
        models = get_models()
        # evaluate the models and store results
        results, names = list(), list()
        for name, model in models.items():
        scores = evaluate_model(model, X, y)
        results.append(scores)
        names.append(name)
        print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
        # plot model performance for comparison
        pyplot.boxplot(results, labels=names, showmeans=True)
        pyplot.show()

        我们得到的结果如下：

        >knn1 0.873 (0.030)
        >knn3 0.889 (0.038)
        >knn5 0.895 (0.031)
        >knn7 0.899 (0.035)
        >knn9 0.900 (0.033)
        >hard_voting 0.902 (0.034)

        显然投票的效果略大于任何一个基模型。

        Box Plot of Hard Voting Ensemble Compared to Standalone Models for Binary Classification

        通过箱形图我们可以看到硬投票方法对交叉验证整体预测结果分布带来的提升。

        bagging的思路

        与投票法不同的是，Bagging不仅仅集成模型最后的预测结果，同时采用一定策略来影响基模型训练，保证基模型可以服从一定的假设。 在上一章中我们提到，希望各个模型之间具有较大的差异性，而在实际操作中的模型却往往是同质的，因此一个简单的思路是通过不同的采样增加模型的差异性。

        bagging的原理分析

        Bagging的核心在于自助采样(bootstrap)这一概念，即有放回的从数据集中进行采样，也就是说，同样的一个样本可能被多次进行采样。 一个自助采样的小例子是我们希望估计全国所有人口年龄的平均值，那么我们可以在全国所有人口中随机抽取不同的集合（这些集合可能存在交集），计算每个集合的平均值，然后将所有平均值的均值作为估计值。

        首先我们随机取出一个样本放入采样集合中，再把这个样本放回初始数据集，重复K次采样，最终我们可以获得一个大小为K的样本集合。同样的方法， 我们可以采样出T个含K个样本的采样集合，然后基于每个采样集合训练出一个基学习器，再将这些基学习器进行结合，这就是Bagging的基本流程。

        对回归问题的预测是通过预测取平均值来进行的。对于分类问题的预测是通过对预测取多数票预测来进行的。Bagging方法之所以有效，是因为每个模型都是在略微不同的训练数据集上拟合完成的，这又使得每个基模型之间存在略微的差异，使每个基模型拥有略微不同的训练能力。

        Bagging同样是一种降低方差的技术，因此它在不剪枝决策树、神经网络等易受样本扰动的学习器上效果更加明显。在实际的使用中，加入列采样的Bagging技术对高维小样本往往有神奇的效果。

        bagging的案例分析(基于sklearn，介绍随机森林的相关理论以及实例)

        Sklearn为我们提供了 BaggingRegressor 与 BaggingClassifier 两种Bagging方法的API，我们在这里通过一个完整的例子演示Bagging在分类问题上的具体应用。这里两种方法的默认基模型是树模型。

        我们创建一个含有1000个样本20维特征的随机分类数据集：

        # test classification dataset
        from sklearn.datasets import make_classification
        # define dataset
        X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=5)
        # summarize the dataset
        print(X.shape, y.shape)

        我们将使用重复的分层k-fold交叉验证来评估该模型，一共重复3次，每次有10个fold。我们将评估该模型在所有重复交叉验证中性能的平均值和标准差。

        # evaluate bagging algorithm for classification
        from numpy import mean
        from numpy import std
        from sklearn.datasets import make_classification
        from sklearn.model_selection import cross_val_score
        from sklearn.model_selection import RepeatedStratifiedKFold
        from sklearn.ensemble import BaggingClassifier
        # define dataset
        X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=5)
        # define the model
        model = BaggingClassifier()
        # evaluate the model
        cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
        n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
        # report performance
        print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

        最终模型的效果是Accuracy: 0.856 标准差0.037

        ]]> + 投票法的思路

        25. 投票法是集成学习中常用的技巧，可以帮助我们提高模型的泛化能力，减少模型的错误率。举个例子，在航空航天领域，每个零件发出的电信号都对航空器的成功发射起到重要作用。如果我们有一个二进制形式的信号：

        11101100100111001011011011011

        在传输过程中第二位发生了翻转

        10101100100111001011011011011

        这导致的结果可能是致命的。一个常用的纠错方法是重复多次发送数据，并以少数服从多数的方法确定正确的传输数据。一般情况下，错误总是发生在局部，因此融合多个数据是降低误差的一个好方法，这就是投票法的基本思路。

        对于回归模型来说，投票法最终的预测结果是多个其他回归模型预测结果的平均值。

        对于分类模型，硬投票法的预测结果是多个模型预测结果中出现次数最多的类别，软投票对各类预测结果的概率进行求和，最终选取概率之和最大的类标签。

        投票法的原理分析

        投票法是一种遵循少数服从多数原则的集成学习模型，通过多个模型的集成降低方差，从而提高模型的鲁棒性。在理想情况下，投票法的预测效果应当优于任何一个基模型的预测效果。

        投票法在回归模型与分类模型上均可使用：

        • 回归投票法：预测结果是所有模型预测结果的平均值。
        • 分类投票法：预测结果是所有模型种出现最多的预测结果。

        分类投票法又可以被划分为硬投票与软投票：

        • 硬投票：预测结果是所有投票结果最多出现的类。
        • 软投票：预测结果是所有投票结果中概率加和最大的类。

        下面我们使用一个例子说明硬投票：

        对于某个样本：

        模型 1 的预测结果是 类别 A

        模型 2 的预测结果是 类别 B

        模型 3 的预测结果是 类别 B

        有2/3的模型预测结果是B，因此硬投票法的预测结果是B

        同样的例子说明软投票：

        对于某个样本：

        模型 1 的预测结果是 类别 A 的概率为 99%

        模型 2 的预测结果是 类别 A 的概率为 49%

        模型 3 的预测结果是 类别 A 的概率为 49%

        最终对于类别A的预测概率的平均是 (99 + 49 + 49) / 3 = 65.67%，因此软投票法的预测结果是A。

        从这个例子我们可以看出，软投票法与硬投票法可以得出完全不同的结论。相对于硬投票，软投票法考虑到了预测概率这一额外的信息，因此可以得出比硬投票法更加准确的预测结果。

        在投票法中，我们还需要考虑到不同的基模型可能产生的影响。理论上，基模型可以是任何已被训练好的模型。但在实际应用上，想要投票法产生较好的结果，需要满足两个条件：

        • 基模型之间的效果不能差别过大。当某个基模型相对于其他基模型效果过差时，该模型很可能成为噪声。
        • 基模型之间应该有较小的同质性。例如在基模型预测效果近似的情况下，基于树模型与线性模型的投票，往往优于两个树模型或两个线性模型。

        当投票合集中使用的模型能预测出清晰的类别标签时，适合使用硬投票。当投票集合中使用的模型能预测类别的概率时，适合使用软投票。软投票同样可以用于那些本身并不预测类成员概率的模型，只要他们可以输出类似于概率的预测分数值（例如支持向量机、k-最近邻和决策树）。

        投票法的局限性在于，它对所有模型的处理是一样的，这意味着所有模型对预测的贡献是一样的。如果一些模型在某些情况下很好，而在其他情况下很差，这是使用投票法时需要考虑到的一个问题。

        投票法的案例分析(基于sklearn，介绍pipe管道的使用以及voting的使用)

        Sklearn中提供了 VotingRegressor 与 VotingClassifier 两个投票方法。 这两种模型的操作方式相同，并采用相同的参数。使用模型需要提供一个模型列表，列表中每个模型采用Tuple的结构表示，第一个元素代表名称，第二个元素代表模型，需要保证每个模型必须拥有唯一的名称。

        例如这里，我们定义两个模型：

        models = [('lr',LogisticRegression()),('svm',SVC())]
        ensemble = VotingClassifier(estimators=models)

        有时某些模型需要一些预处理操作，我们可以为他们定义Pipeline完成模型预处理工作：

        models = [('lr',LogisticRegression()),('svm',make_pipeline(StandardScaler(),SVC()))]
        ensemble = VotingClassifier(estimators=models)

        模型还提供了voting参数让我们选择软投票或者硬投票：

        models = [('lr',LogisticRegression()),('svm',SVC())]
        ensemble = VotingClassifier(estimators=models, voting='soft')

        下面我们使用一个完整的例子演示投票法的使用：

        首先我们创建一个1000个样本，20个特征的随机数据集：

        # test classification dataset
        from sklearn.datasets import make_classification
        # define dataset
        X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=2)
        # summarize the dataset
        print(X.shape, y.shape)

        我们使用多个KNN模型作为基模型演示投票法，其中每个模型采用不同的邻居值K参数：

        # get a voting ensemble of models
        def get_voting():
        # define the base models
        models = list()
        models.append(('knn1', KNeighborsClassifier(n_neighbors=1)))
        models.append(('knn3', KNeighborsClassifier(n_neighbors=3)))
        models.append(('knn5', KNeighborsClassifier(n_neighbors=5)))
        models.append(('knn7', KNeighborsClassifier(n_neighbors=7)))
        models.append(('knn9', KNeighborsClassifier(n_neighbors=9)))
        # define the voting ensemble
        ensemble = VotingClassifier(estimators=models, voting='hard')
        return ensemble

        然后，我们可以创建一个模型列表来评估投票带来的提升，包括KNN模型配置的每个独立版本和硬投票模型。下面的get_models()函数可以为我们创建模型列表进行评估。

        # get a list of models to evaluate
        def get_models():
        models = dict()
        models['knn1'] = KNeighborsClassifier(n_neighbors=1)
        models['knn3'] = KNeighborsClassifier(n_neighbors=3)
        models['knn5'] = KNeighborsClassifier(n_neighbors=5)
        models['knn7'] = KNeighborsClassifier(n_neighbors=7)
        models['knn9'] = KNeighborsClassifier(n_neighbors=9)
        models['hard_voting'] = get_voting()
        return models

        下面的evaluate_model()函数接收一个模型实例，并以分层10倍交叉验证三次重复的分数列表的形式返回。

        # evaluate a give model using cross-validation
        def evaluate_model(model, X, y):
        cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
        scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
        return scores

        然后，我们可以报告每个算法的平均性能，还可以创建一个箱形图和须状图来比较每个算法的精度分数分布。

        # define dataset
        X, y = get_dataset()
        # get the models to evaluate
        models = get_models()
        # evaluate the models and store results
        results, names = list(), list()
        for name, model in models.items():
        scores = evaluate_model(model, X, y)
        results.append(scores)
        names.append(name)
        print('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))
        # plot model performance for comparison
        pyplot.boxplot(results, labels=names, showmeans=True)
        pyplot.show()

        我们得到的结果如下：

        >knn1 0.873 (0.030)
        >knn3 0.889 (0.038)
        >knn5 0.895 (0.031)
        >knn7 0.899 (0.035)
        >knn9 0.900 (0.033)
        >hard_voting 0.902 (0.034)

        显然投票的效果略大于任何一个基模型。

        Box Plot of Hard Voting Ensemble Compared to Standalone Models for Binary Classification

        通过箱形图我们可以看到硬投票方法对交叉验证整体预测结果分布带来的提升。

        bagging的思路

        与投票法不同的是，Bagging不仅仅集成模型最后的预测结果，同时采用一定策略来影响基模型训练，保证基模型可以服从一定的假设。 在上一章中我们提到，希望各个模型之间具有较大的差异性，而在实际操作中的模型却往往是同质的，因此一个简单的思路是通过不同的采样增加模型的差异性。

        bagging的原理分析

        Bagging的核心在于自助采样(bootstrap)这一概念，即有放回的从数据集中进行采样，也就是说，同样的一个样本可能被多次进行采样。 一个自助采样的小例子是我们希望估计全国所有人口年龄的平均值，那么我们可以在全国所有人口中随机抽取不同的集合（这些集合可能存在交集），计算每个集合的平均值，然后将所有平均值的均值作为估计值。

        首先我们随机取出一个样本放入采样集合中，再把这个样本放回初始数据集，重复K次采样，最终我们可以获得一个大小为K的样本集合。同样的方法， 我们可以采样出T个含K个样本的采样集合，然后基于每个采样集合训练出一个基学习器，再将这些基学习器进行结合，这就是Bagging的基本流程。

        对回归问题的预测是通过预测取平均值来进行的。对于分类问题的预测是通过对预测取多数票预测来进行的。Bagging方法之所以有效，是因为每个模型都是在略微不同的训练数据集上拟合完成的，这又使得每个基模型之间存在略微的差异，使每个基模型拥有略微不同的训练能力。

        Bagging同样是一种降低方差的技术，因此它在不剪枝决策树、神经网络等易受样本扰动的学习器上效果更加明显。在实际的使用中，加入列采样的Bagging技术对高维小样本往往有神奇的效果。

        bagging的案例分析(基于sklearn，介绍随机森林的相关理论以及实例)

        Sklearn为我们提供了 BaggingRegressor 与 BaggingClassifier 两种Bagging方法的API，我们在这里通过一个完整的例子演示Bagging在分类问题上的具体应用。这里两种方法的默认基模型是树模型。

        我们创建一个含有1000个样本20维特征的随机分类数据集：

        # test classification dataset
        from sklearn.datasets import make_classification
        # define dataset
        X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=5)
        # summarize the dataset
        print(X.shape, y.shape)

        我们将使用重复的分层k-fold交叉验证来评估该模型，一共重复3次，每次有10个fold。我们将评估该模型在所有重复交叉验证中性能的平均值和标准差。

        # evaluate bagging algorithm for classification
        from numpy import mean
        from numpy import std
        from sklearn.datasets import make_classification
        from sklearn.model_selection import cross_val_score
        from sklearn.model_selection import RepeatedStratifiedKFold
        from sklearn.ensemble import BaggingClassifier
        # define dataset
        X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=5)
        # define the model
        model = BaggingClassifier()
        # evaluate the model
        cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
        n_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
        # report performance
        print('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))

        最终模型的效果是Accuracy: 0.856 标准差0.037

        ]]> @@ -250,7 +250,7 @@ <p>10101100100111001011011011011</p> <p>这导致的结果可能是致命的。一个常用的纠错方法是重复多次发送数据，并以少数服从多数的方法确定正确的传输数据。一般情况下，错误总是发生在局部，因此融合多个数据是降低误差的一个好方法，这就是投票法的基本思路。</p> <p>对于回归模型来说，投票法最终的预测结果是多个其他回归模型预测结果的平均值。</p> -<p>对于分类模型，<strong>硬投票法</strong>的预测结果是多个模型预测结果中出现次数最多的类别，<strong>软投票</strong>对各类预测结果的概率进行求和，最终选取概率之和最大的类标签。</p> +<p>对于分类模型，<strong>硬投票法</strong>的预测结果是多个模型预测结果中出现次数最多的类别，<strong>软投票</strong>对各类预测结果的概率进行求和，最终选取概率之和最大的类标签。<br></p> @@ -269,11 +269,11 @@ 2021-06-15T13:48:00.000Z 2024-10-09T07:33:09.908Z - 数据结构与算法——二分

        25. 最近leetcode每日一题经常出二分的题目，正好对前段时间学过的二分进行一些总结，首先这里要明确的一点是，二分的本质并不是单调性，而是通过某种条件将整个区间划分成满足条件和不满足条件的两端即可进行二分查找。
        在二分这个专题，主要有两种类型的划分方式，一种是整数划分，一种是浮点数划分，前一种一般是我们最熟悉的二分查找的题型，也是出题比较灵活考的比较多的一种，后一种主要是为控制实数精度而设置的浮点数二分法（建议用double，float有时候会出现精度丢失）。

        整数二分

        这里我们拿一道经典例题来给出我们二分的两个十分精妙的模板。AcWing789. 数的范围

        bool check(int x) {/* ... */} // 检查x是否满足某种性质

        // 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
        int bsearch_1(int l, int r)
        {
            while(l < r)
            {
            int mid = l + r >> 1; // 如果写r=mid则这里不需要+1
            if(check(mid)) r = mid; // check()判断mid是否满足性质
            else l = mid + 1;
            }
            return l; //退出时 l与r相等
        }
        // 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
        int bsearch_2(int l, int r)
        {
            while(l < r)
            {
            int mid = l + r + 1 >> 1;
            if(check(mid)) l = mid;
            else  r = mid - 1;
            }
            return l;
        }

        浮点数二分

        浮点数二分考的比较少，主要是实现对于高精度答案的控制。AcWing 790. 数的三次方根
        这里有个小bug需要提醒一下，我们以求二次方根为例，我们可以知道，$x=0.01$时，$\sqrt{x}=0.1>x$，所以当我们把二分的区间设置成$[0,x]$时，我们则无法找到答案，所以设置区间的时候我们最好可以设置大一点的区间，或者设置成$[0,\max(1,x)]$
        在这里插入图片描述

        bool check(double x) {/* ... */} // 检查x是否满足某种性质

        double bsearch_3(double l, double r)
        {
            const double eps = 1e-8;   // eps 表示精度，取决于题目对精度的要求
            while(r - l > eps)
            {
            double mid = (l + r) / 2; // 对于浮点数二分则不需要考虑+1的问题
            if(check(mid)) r = mid;
            else l = mid;
        }
        return l;
        }

        STL

        做题当中手写二分的题其实比较少，基本上记忆上述模板就能解决所以的问题，同时我们在日常做题的时候，为了方便，我们通常是使用STL当中的函数来实现二分，且支持vector，map，set等操作，还有结构体大小比较，这里就有三个一定要记住的API。头文件引入：#include<algorithm>
        binary_search
        功能：二分查找某个元素是否出现。
        返回值：在数组中以二分法检索的方式查找，若在数组(要求数组元素非递减)中查找到indx元素则真，若查找不到则返回值为假。
        用法实例：
        a.数组用法

        int a[100]= {4,10,11,30,69,70,96,100};
        int b=binary_search(a,a+9,4);//查找成功，返回1
        cout<<"在数组中查找元素4，结果为："<<b<<endl;

        b.vector用法

        vector<int> res = {1,2,3};
        cout<<binary_search(res.begin(),res.end(),3)<<endl;

        lower_bound
        功能：查找非递减序列[first,last) 内第一个大于或等于某个元素的位置。
        返回值：如果找到返回找到元素的地址否则返回数组边界的下一个元素的地址。（这样不注意的话会越界，小心）
        用法实例：

        int a[100]= {4,10,11,30,69,70,96,100};
        int d=lower_bound(a,a+9,10)-a;
        cout<<"在数组中查找第一个大于等于10的元素位置，结果为："<<d<<endl;
        int e=lower_bound(a,a+9,101)-a;
        cout<<"在数组中查找第一个大于等于101的元素位置，结果为："<<e<<endl;

        b.vector用法

        vector<int> res = {1,2,3};
        vector<int>::iterator it =  lower_bound(res.begin(),res.end(),3);//返回迭代器的位置
        //如果不存在，迭代器的位置会返回res.end()
        if(it==res.end()) cout<<"不存在"<<endl;
        else cout<<"求出下标:"<<(it - res.begin())<<endl;
        //也可以添加偏移量
        vector<int>::iterator it =  lower_bound(res.begin()+1,res.end(),3);

        upper_bound

        功能：查找非递减序列[first,last) 内第一个大于某个元素的位置。

        返回值：如果找到返回找到元素的地址，否则返回数组边界的下一个元素的地址。（同样这样不注意的话会越界，小心）
        用法实例：

        int a[100]= {4,10,11,30,69,70,96,100};
        int d=upper_bound(a,a+9,10)-a;
        cout<<"在数组中查找第一个大于等于10的元素位置，结果为："<<d<<endl;
        int e=upper_bound(a,a+9,101)-a;
        cout<<"在数组中查找第一个大于等于101的元素位置，结果为："<<e<<endl;

        b.vector用法

        vector<int> res = {1,2,3};
        vector<int>::iterator it =  upper_bound(res.begin(),res.end(),3);//返回迭代器的位置
        //如果不存在，迭代器的位置会返回res.end()
        if(it==res.end()) cout<<"不存在"<<endl;
        else cout<<"求出下标:"<<(it - res.begin())<<endl;
        //也可以添加偏移量
        vector<int>::iterator it =  upper_bound(res.begin()+1,res.end(),3);

        经典例题

        这里我顺便给出这两天的每日一题的解题方案，里面还涉及到了一个防止溢出的二分处理trick。
        猜数字大小
        在这里插入图片描述

        /** 
         * Forward declaration of guess API.
         * @param  num   your guess
         * @return      -1 if num is lower than the guess number
         *      1 if num is higher than the guess number
         *               otherwise return 0
         * int guess(int num);
         */

        class Solution {
        public:
            int guessNumber(int n) {
                int l = 1;
                int r = n;
                while(l<r)
                {
                    int mid = l + (r - l >> 1);//防止溢出
                    if(guess(mid)<=0) 
                        r = mid;
                    else 
                        l = mid + 1;
                }
                return r;
            }
        };

        山脉数组的峰顶索引
        在这里插入图片描述

        class Solution {
        public:
            int peakIndexInMountainArray(vector<int>& arr) {
                int l = 0;
                int r = arr.size() - 1;
                while(l<r)
                {
                    int mid = l + r >> 1;
                    if(arr[mid]>arr[mid+1]) r = mid;
                    else l = mid+1;
                }
                return l;
            }
        };

        这是三叶姐姐的二分经典题型汇总，大家也可以参考一下。
        在这里插入图片描述

        ]]> + 数据结构与算法——二分

        最近leetcode每日一题经常出二分的题目，正好对前段时间学过的二分进行一些总结，首先这里要明确的一点是，二分的本质并不是单调性，而是通过某种条件将整个区间划分成满足条件和不满足条件的两端即可进行二分查找。
        在二分这个专题，主要有两种类型的划分方式，一种是整数划分，一种是浮点数划分，前一种一般是我们最熟悉的二分查找的题型，也是出题比较灵活考的比较多的一种，后一种主要是为控制实数精度而设置的浮点数二分法（建议用double，float有时候会出现精度丢失）。

        整数二分

        这里我们拿一道经典例题来给出我们二分的两个十分精妙的模板。AcWing789. 数的范围

        bool check(int x) {/* ... */} // 检查x是否满足某种性质

        // 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
        int bsearch_1(int l, int r)
        {
            while(l < r)
            {
            int mid = l + r >> 1; // 如果写r=mid则这里不需要+1
            if(check(mid)) r = mid; // check()判断mid是否满足性质
            else l = mid + 1;
            }
            return l; //退出时 l与r相等
        }
        // 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
        int bsearch_2(int l, int r)
        {
            while(l < r)
            {
            int mid = l + r + 1 >> 1;
            if(check(mid)) l = mid;
            else  r = mid - 1;
            }
            return l;
        }

        浮点数二分

        浮点数二分考的比较少，主要是实现对于高精度答案的控制。AcWing 790. 数的三次方根
        这里有个小bug需要提醒一下，我们以求二次方根为例，我们可以知道，$x=0.01$时，$\sqrt{x}=0.1>x$，所以当我们把二分的区间设置成$[0,x]$时，我们则无法找到答案，所以设置区间的时候我们最好可以设置大一点的区间，或者设置成$[0,\max(1,x)]$
        在这里插入图片描述

        bool check(double x) {/* ... */} // 检查x是否满足某种性质

        double bsearch_3(double l, double r)
        {
            const double eps = 1e-8;   // eps 表示精度，取决于题目对精度的要求
            while(r - l > eps)
            {
            double mid = (l + r) / 2; // 对于浮点数二分则不需要考虑+1的问题
            if(check(mid)) r = mid;
            else l = mid;
        }
        return l;
        }

        STL

        做题当中手写二分的题其实比较少，基本上记忆上述模板就能解决所以的问题，同时我们在日常做题的时候，为了方便，我们通常是使用STL当中的函数来实现二分，且支持vector，map，set等操作，还有结构体大小比较，这里就有三个一定要记住的API。头文件引入：#include<algorithm>
        binary_search
        功能：二分查找某个元素是否出现。
        返回值：在数组中以二分法检索的方式查找，若在数组(要求数组元素非递减)中查找到indx元素则真，若查找不到则返回值为假。
        用法实例：
        a.数组用法

        int a[100]= {4,10,11,30,69,70,96,100};
        int b=binary_search(a,a+9,4);//查找成功，返回1
        cout<<"在数组中查找元素4，结果为："<<b<<endl;

        b.vector用法
        vector<int> res = {1,2,3};
        cout<<binary_search(res.begin(),res.end(),3)<<endl;

        lower_bound
        功能：查找非递减序列[first,last) 内第一个大于或等于某个元素的位置。
        返回值：如果找到返回找到元素的地址否则返回数组边界的下一个元素的地址。（这样不注意的话会越界，小心）
        用法实例：
        int a[100]= {4,10,11,30,69,70,96,100};
        int d=lower_bound(a,a+9,10)-a;
        cout<<"在数组中查找第一个大于等于10的元素位置，结果为："<<d<<endl;
        int e=lower_bound(a,a+9,101)-a;
        cout<<"在数组中查找第一个大于等于101的元素位置，结果为："<<e<<endl;

        b.vector用法
        vector<int> res = {1,2,3};
        vector<int>::iterator it =  lower_bound(res.begin(),res.end(),3);//返回迭代器的位置
        //如果不存在，迭代器的位置会返回res.end()
        if(it==res.end()) cout<<"不存在"<<endl;
        else cout<<"求出下标:"<<(it - res.begin())<<endl;
        //也可以添加偏移量
        vector<int>::iterator it =  lower_bound(res.begin()+1,res.end(),3);

        upper_bound

        功能：查找非递减序列[first,last) 内第一个大于某个元素的位置。

        返回值：如果找到返回找到元素的地址，否则返回数组边界的下一个元素的地址。（同样这样不注意的话会越界，小心）
        用法实例：

        int a[100]= {4,10,11,30,69,70,96,100};
        int d=upper_bound(a,a+9,10)-a;
        cout<<"在数组中查找第一个大于等于10的元素位置，结果为："<<d<<endl;
        int e=upper_bound(a,a+9,101)-a;
        cout<<"在数组中查找第一个大于等于101的元素位置，结果为："<<e<<endl;

        b.vector用法
        vector<int> res = {1,2,3};
        vector<int>::iterator it =  upper_bound(res.begin(),res.end(),3);//返回迭代器的位置
        //如果不存在，迭代器的位置会返回res.end()
        if(it==res.end()) cout<<"不存在"<<endl;
        else cout<<"求出下标:"<<(it - res.begin())<<endl;
        //也可以添加偏移量
        vector<int>::iterator it =  upper_bound(res.begin()+1,res.end(),3);

        经典例题

        这里我顺便给出这两天的每日一题的解题方案，里面还涉及到了一个防止溢出的二分处理trick。
        猜数字大小
        在这里插入图片描述

        /** 
         * Forward declaration of guess API.
         * @param  num   your guess
         * @return      -1 if num is lower than the guess number
         *      1 if num is higher than the guess number
         *               otherwise return 0
         * int guess(int num);
         */

        class Solution {
        public:
            int guessNumber(int n) {
                int l = 1;
                int r = n;
                while(l<r)
                {
                    int mid = l + (r - l >> 1);//防止溢出
                    if(guess(mid)<=0) 
                        r = mid;
                    else 
                        l = mid + 1;
                }
                return r;
            }
        };

        山脉数组的峰顶索引
        在这里插入图片描述
        class Solution {
        public:
            int peakIndexInMountainArray(vector<int>& arr) {
                int l = 0;
                int r = arr.size() - 1;
                while(l<r)
                {
                    int mid = l + r >> 1;
                    if(arr[mid]>arr[mid+1]) r = mid;
                    else l = mid+1;
                }
                return l;
            }
        };

        这是三叶姐姐的二分经典题型汇总，大家也可以参考一下。
        在这里插入图片描述

        ]]> - <h2 id="数据结构与算法——二分"><a href="#数据结构与算法——二分" class="headerlink" title="数据结构与算法——二分"></a>数据结构与算法——二分</h2><p>最近leetcode每日一题经常出二分的题目，正好对前段时间学过的二分进行一些总结，首先这里要明确的一点是，<strong>二分的本质并不是单调性，而是通过某种条件将整个区间划分成满足条件和不满足条件的两端即可进行二分查找。</strong><br>在二分这个专题，主要有两种类型的划分方式，一种是整数划分，一种是浮点数划分，前一种一般是我们最熟悉的二分查找的题型，也是出题比较灵活考的比较多的一种，后一种主要是为控制实数精度而设置的浮点数二分法（建议用<code>double</code>，<code>float</code>有时候会出现精度丢失）。</p> + <h2 id="数据结构与算法——二分"><a href="#数据结构与算法——二分" class="headerlink" title="数据结构与算法——二分"></a>数据结构与算法——二分</h2><p>最近leetcode每日一题经常出二分的题目，正好对前段时间学过的二分进行一些总结，首先这里要明确的一点是，<strong>二分的本质并不是单调性，而是通过某种条件将整个区间划分成满足条件和不满足条件的两端即可进行二分查找。</strong><br>在二分这个专题，主要有两种类型的划分方式，一种是整数划分，一种是浮点数划分，前一种一般是我们最熟悉的二分查找的题型，也是出题比较灵活考的比较多的一种，后一种主要是为控制实数精度而设置的浮点数二分法（建议用<code>double</code>，<code>float</code>有时候会出现精度丢失）。<br></p> @@ -290,11 +290,11 @@ 2021-06-13T07:49:00.000Z 2024-10-09T07:33:09.908Z - 数据结构与刷题——链表

        25. 在这里插入图片描述

        在这里插入图片描述

        单链表代码模板

        代码实现单链表的方法有很多种，但是对于acm刷题来说，我们通常使用的是静态链表的方式，这样代码运行速度更快，防止被卡时间。

        const int N = 100010;
        int head; // 头指针
        int e[N]; // e[i]表示第i个节点的
        int ne[N];// 第i个节点的next指针，表示当前节点的直接后继的节点编号
        int idx;//记录已经存储了多少个节点

        void init()
        {
        head = -1;//用-1表示空节点
        idx = 0;
        }

        //在第k个节点后面插入一个新节点，节点的值为x
        void insert(int k,int x)
        {
        e[idx] = x;
        ne[idx] = ne[k];
        ne[k] = idx++; 
        }

        // 删除第k+1个节点,即将将该节点的指针指向他的下一个元素
        void delete_node(int k)
        {
        ne[k] = ne[ne[k]];
        }

        void delete_head()
        {
        head = ne[head];
        }

        //遍历过程
        for(int i = head; i!=-1;i = ne[i])
        {
        cout<<e[i]<<endl;
        }

        双链表

        在实际的代码编写过程当中，我们也是直接使用静态链表来设置双链表，我们首先设置0号点和1号点为左右边界head，tail。之后我们就只需要在这两者之间插入节点构造双链表。
        在这里插入图片描述
        在这里插入图片描述

        在这里插入图片描述

        const int N = 100010;
        int e[N];
        int l[N];
        int r[N];
        int idx;

        //初始化直接初始化出左右端点的下标，从而避免边界问题
        void init()
        {
            //初始化的左右别搞反了
            r[0] = 1;
            l[1] = 0;
            idx =2;
        }

        // 在k节点的右侧插入一个x,其实也相当于左侧插入节点
        void add(int k,int x)
        {
            e[idx] = x;
            //操作新节点的左右指针
            r[idx] = r[k];
            l[idx] = k;
            //再操作原数组的节点
            l[r[k]] = idx;
            r[k] = idx++;
        }

        void remove(int k)
        {
            l[r[k]] = l[k]; //右节点的左侧，指向左节点
            r[l[k]] = r[k]; //左节点的右侧，指向右节点
        }

        经典例题

        以上两种实现方式都是通过静态链表实现的，主要是来自y总的AcWing经典例题。
        AcWing826. 单链表
        AcWing827. 双链表
        使用指针的实现方式，在leetcode当中用的比较多，这里给大家补充一些leetcode中出现的链表类型的题目，主要涉及到链表的遍历，双指针算法，和一些小技巧，高阶一点的题目会涉及到树和递归的问题。
        我做的主要是leetcode上程序员面试经典和剑指offer的例题，不过个人感觉这些题也大部分涵盖了链表题型的大部分考法，而且题解也十分详细。
        在这里插入图片描述
        在这里插入图片描述

        ]]> + 数据结构与刷题——链表

        25. 在这里插入图片描述

        在这里插入图片描述

        单链表代码模板

        代码实现单链表的方法有很多种，但是对于acm刷题来说，我们通常使用的是静态链表的方式，这样代码运行速度更快，防止被卡时间。

        const int N = 100010;
        int head; // 头指针
        int e[N]; // e[i]表示第i个节点的
        int ne[N];// 第i个节点的next指针，表示当前节点的直接后继的节点编号
        int idx;//记录已经存储了多少个节点

        void init()
        {
        head = -1;//用-1表示空节点
        idx = 0;
        }

        //在第k个节点后面插入一个新节点，节点的值为x
        void insert(int k,int x)
        {
        e[idx] = x;
        ne[idx] = ne[k];
        ne[k] = idx++; 
        }

        // 删除第k+1个节点,即将将该节点的指针指向他的下一个元素
        void delete_node(int k)
        {
        ne[k] = ne[ne[k]];
        }

        void delete_head()
        {
        head = ne[head];
        }

        //遍历过程
        for(int i = head; i!=-1;i = ne[i])
        {
        cout<<e[i]<<endl;
        }

        双链表

        在实际的代码编写过程当中，我们也是直接使用静态链表来设置双链表，我们首先设置0号点和1号点为左右边界head，tail。之后我们就只需要在这两者之间插入节点构造双链表。
        在这里插入图片描述
        在这里插入图片描述

        在这里插入图片描述

        const int N = 100010;
        int e[N];
        int l[N];
        int r[N];
        int idx;

        //初始化直接初始化出左右端点的下标，从而避免边界问题
        void init()
        {
            //初始化的左右别搞反了
            r[0] = 1;
            l[1] = 0;
            idx =2;
        }

        // 在k节点的右侧插入一个x,其实也相当于左侧插入节点
        void add(int k,int x)
        {
            e[idx] = x;
            //操作新节点的左右指针
            r[idx] = r[k];
            l[idx] = k;
            //再操作原数组的节点
            l[r[k]] = idx;
            r[k] = idx++;
        }

        void remove(int k)
        {
            l[r[k]] = l[k]; //右节点的左侧，指向左节点
            r[l[k]] = r[k]; //左节点的右侧，指向右节点
        }

        经典例题

        以上两种实现方式都是通过静态链表实现的，主要是来自y总的AcWing经典例题。
        AcWing826. 单链表
        AcWing827. 双链表
        使用指针的实现方式，在leetcode当中用的比较多，这里给大家补充一些leetcode中出现的链表类型的题目，主要涉及到链表的遍历，双指针算法，和一些小技巧，高阶一点的题目会涉及到树和递归的问题。
        我做的主要是leetcode上程序员面试经典和剑指offer的例题，不过个人感觉这些题也大部分涵盖了链表题型的大部分考法，而且题解也十分详细。
        在这里插入图片描述
        在这里插入图片描述

        ]]> - <h2 id="数据结构与刷题——链表"><a href="#数据结构与刷题——链表" class="headerlink" title="数据结构与刷题——链表"></a>数据结构与刷题——链表</h2><p><img src="https://img-blog.csdnimg.cn/20210607085716429.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0phY2tfX19F,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"></p> + <h2 id="数据结构与刷题——链表"><a href="#数据结构与刷题——链表" class="headerlink" title="数据结构与刷题——链表"></a>数据结构与刷题——链表</h2><p><img src="https://img-blog.csdnimg.cn/20210607085716429.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0phY2tfX19F,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"><br></p> @@ -311,11 +311,11 @@ 2021-06-06T12:33:00.000Z 2024-10-09T07:33:09.908Z - 前言

        最近在复习数据结构，顺便整理之前刷题的一些模板和技巧，希望对大家都有帮助，博客会侧重讲解的是OJ代码实现，理论部分偏少但也会写一些自己的理解。
        在之前大二上数据结构的时候我也有写过一个关于排序的专题介绍数据结构复习——内部排序

        快速排序

        快速排序主要就是通过选取一个基准点，将一个区间内的数分成大于和小于两个部分，然后对左右区间再进行上述操作，直到子区间的长度为空为止。快速排序是不稳定的排序，如果需要变成稳定排序通过双关键字排序即可，通过下标控制绝对大小就能得到稳定的排序结果。
        快速排序分三步走：

        • 确定分界点
        • 调整左右区间
        • 递归处理左右子区间

        在代码实现当中，我们一般选取中间分位点会比较好，这样划分的区间比较平均。在遍历的过程当中每次调整区间的时间是$O(n)$，而区间递归的深度类似二叉树是$O(logn)$
        在最好情况下，对于递归型的算法，我们利用主定理公式来计算快速排序时间复杂度得到$O(nlogn)$
        $$
        T(n) = 2 T\left(\frac{n}{2}\right)+\Theta(n)
        $$
        当然在最坏情况下，也就是数组是有序或者逆序的情况下，我们如果选择左右端点作为基准点，那么整个算法就相当于冒泡排序，递归的层数也就变成了$n$，则最坏时间复杂度为$O(n^2)$

        代码实现

        void quick_sort(int[] q,int l,int r)
        {
        if(l>=r) return;
        // 1.确定分界点
        int i = l - 1, j = r + 1, mid = q[l + r >> 1];
        // 2.调整左右区间
        while(i<j)
        {
        do i++; while(q[i]<mid);
        do j--; while(q[j]>mid);
        if(i<j) swap(q[i],q[j]);
        }
        //3.递归处理左右子区间
        quick_sort(l,j);
        quick_sort(j+1,r);
        }

        经典例题

        洛谷P1177 【模板】快速排序

        归并排序

        归并排序也是基于分治的思想，每次将区间对半分，逐步递归合并有序化子区间，最终实现所有的左右区间的有序归并，但是跟快速排序不同的是，我们需要开一个辅助数组来存储有序的部分，所以时间复杂度为$O(nlogn)$。归并排序是稳定的排序，在元素相等情况下我们总是放入数组下标较小的元素。
        归并排序分三步走：

        • 确定分界点
        • 递归处理子序列
        • 合并有序序列

        olor_FFFFFF,t_70)

        代码实现

        const int N=100010;
        int a[N],tmp[N];
        void merge_sort(int q[],int l,int r)
        {
            if(l>=r)
                return;
            //确定分界点
            int mid = l + r >> 1;

            //递归处理子序列
            merge_sort(q,l,mid);
            merge_sort(q,mid+1,r);

            //合并有序序列
            int k = l,i = l,j = mid + 1;
            while(i <= mid && j <= r)
            {
                if(q[i]<=q[j])// 取等号，保证归并排序的稳定性
                    tmp[k++]=q[i++];
                else
                    tmp[k++]=q[j++];
            }

            while(i<=mid) 
                tmp[k++]=q[i++];
            while(j<=r) 
                tmp[k++]=q[j++];

            for(i=l;i<=r;i++)
                q[i]=tmp[i];
        }

        经典例题

        AcWing 787. 归并排序
        AcWing 788. 逆序对的数量

        排序相关时间复杂度整理

        在这里插入图片描述

        ]]> + 前言

        25. 最近在复习数据结构，顺便整理之前刷题的一些模板和技巧，希望对大家都有帮助，博客会侧重讲解的是OJ代码实现，理论部分偏少但也会写一些自己的理解。
        在之前大二上数据结构的时候我也有写过一个关于排序的专题介绍数据结构复习——内部排序

        快速排序

        快速排序主要就是通过选取一个基准点，将一个区间内的数分成大于和小于两个部分，然后对左右区间再进行上述操作，直到子区间的长度为空为止。快速排序是不稳定的排序，如果需要变成稳定排序通过双关键字排序即可，通过下标控制绝对大小就能得到稳定的排序结果。
        快速排序分三步走：

        • 确定分界点
        • 调整左右区间
        • 递归处理左右子区间

        在代码实现当中，我们一般选取中间分位点会比较好，这样划分的区间比较平均。在遍历的过程当中每次调整区间的时间是$O(n)$，而区间递归的深度类似二叉树是$O(logn)$
        在最好情况下，对于递归型的算法，我们利用主定理公式来计算快速排序时间复杂度得到$O(nlogn)$

        当然在最坏情况下，也就是数组是有序或者逆序的情况下，我们如果选择左右端点作为基准点，那么整个算法就相当于冒泡排序，递归的层数也就变成了$n$，则最坏时间复杂度为$O(n^2)$

        代码实现

        void quick_sort(int[] q,int l,int r)
        {
        if(l>=r) return;
        // 1.确定分界点
        int i = l - 1, j = r + 1, mid = q[l + r >> 1];
        // 2.调整左右区间
        while(i<j)
        {
        do i++; while(q[i]<mid);
        do j--; while(q[j]>mid);
        if(i<j) swap(q[i],q[j]);
        }
        //3.递归处理左右子区间
        quick_sort(l,j);
        quick_sort(j+1,r);
        }

        经典例题

        洛谷P1177 【模板】快速排序

        归并排序

        归并排序也是基于分治的思想，每次将区间对半分，逐步递归合并有序化子区间，最终实现所有的左右区间的有序归并，但是跟快速排序不同的是，我们需要开一个辅助数组来存储有序的部分，所以时间复杂度为$O(nlogn)$。归并排序是稳定的排序，在元素相等情况下我们总是放入数组下标较小的元素。
        归并排序分三步走：

        • 确定分界点
        • 递归处理子序列
        • 合并有序序列

        olor_FFFFFF,t_70)

        代码实现

        const int N=100010;
        int a[N],tmp[N];
        void merge_sort(int q[],int l,int r)
        {
            if(l>=r)
                return;
            //确定分界点
            int mid = l + r >> 1;

            //递归处理子序列
            merge_sort(q,l,mid);
            merge_sort(q,mid+1,r);

            //合并有序序列
            int k = l,i = l,j = mid + 1;
            while(i <= mid && j <= r)
            {
                if(q[i]<=q[j])// 取等号，保证归并排序的稳定性
                    tmp[k++]=q[i++];
                else
                    tmp[k++]=q[j++];
            }

            while(i<=mid) 
                tmp[k++]=q[i++];
            while(j<=r) 
                tmp[k++]=q[j++];

            for(i=l;i<=r;i++)
                q[i]=tmp[i];
        }

        经典例题

        AcWing 787. 归并排序
        AcWing 788. 逆序对的数量

        排序相关时间复杂度整理

        在这里插入图片描述

        ]]> - <h2 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h2><p>最近在复习数据结构，顺便整理之前刷题的一些模板和技巧，希望对大家都有帮助，博客会侧重讲解的是OJ代码实现，理论部分偏少但也会写一些自己的理解。<br>在之前大二上数据结构的时候我也有写过一个关于排序的专题介绍<a href="https://blog.csdn.net/Jack___E/article/details/102875285?spm=1001.2014.3001.5502" target="_blank" rel="noopener">数据结构复习——内部排序</a></p> + <h2 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h2><p>最近在复习数据结构，顺便整理之前刷题的一些模板和技巧，希望对大家都有帮助，博客会侧重讲解的是OJ代码实现，理论部分偏少但也会写一些自己的理解。<br>在之前大二上数据结构的时候我也有写过一个关于排序的专题介绍<a href="https://blog.csdn.net/Jack___E/article/details/102875285?spm=1001.2014.3001.5502" target="_blank" rel="noopener">数据结构复习——内部排序</a><br></p> @@ -332,14 +332,14 @@ 2021-05-09T09:44:00.000Z 2024-10-09T07:33:09.884Z - EfficientNet论文解读和pytorch代码实现

    传送门

    论文地址：https://arxiv.org/pdf/1905.11946.pdf
    官方github：https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet
    github参考：https://github.com/qubvel/efficientnet
    github参考：https://github.com/lukemelas/EfficientNet-PyTorch

    摘要

    谷歌的文章总是能让我印象深刻，不管从实验上还是论文的书写上都让人十分的佩服，不得不说这确实是一个非常creative的公司!
    Convolutional Neural Networks (ConvNets) are commonly developed at a fixed resource budget, and then scaled up for better accuracy if more resources are available. In this paper, we systematically study model scaling and identify that carefully balancing network depth, width, and resolution can lead to better performance. Based on this observation, we propose a new scaling method that uniformly scales all dimensions of depth/width/resolution using a simple yet highly effective compound coefficient. We demonstrate the effectiveness of this method on scaling up MobileNets and ResNet.
    卷积神经网络通常是在固定的资源预算下进行计算和发展的，如果有更多可用的资源，模型能通过缩放和扩展获得更好的效果，本文系统研究（工作量很充足）了模型缩放，并且证明了细致地平衡网络的深度，宽度，和分辨率能够得到更好的效果，基于这个观点，我们提出了一个新的尺度缩放的方法，我们提出了一个新的尺度缩放的方法即：使用一个简单且高效的复合系数统一地缩放所有网络层的深度/宽度/分辨率的维度。我们证明了该方法在扩大MobileNets和ResNet方面的有效性。

    To go even further, we use neural architecture search to design a new baseline network and scale it up to obtain a family of models, called EfficientNets, which achieve much better accuracy and efficiency than previous ConvNets. In particular, our EfficientNet-B7 achieves state-of-the-art 84.3% top-1 accuracy on ImageNet, while being 8.4x smaller and 6.1x faster on inference than the best existing ConvNet. Our EfficientNets also transfer well and achieve state-of-the-art accuracy on CIFAR-100 (91.7%), Flowers (98.8%), and 3 other transfer learning datasets, with an order of magnitude fewer parameters. Source code is athttps://github.com/tensorflow/tpu/tree/
    master/models/official/efficientnet.

    更进一步，我们使用神经网络结构搜索设计了一个新的baseline网络架构并且对其进行缩放得到了一组模型，我们把他叫做EfficientNets。EfficientNets相比之前的ConvNets，有着更好的准确率和更高的效率。在ImageNet上达到了最好的水平即top-1准确率84.4%/top-5准确率97.1%，然而却比已有的最好的ConvNet模型小了8.4倍并且推理时间快了6.1倍。我们的EfficientNet迁移学习的效果也好，达到了最好的准确率水平CIFAR-100（91.7%），Flowers（98.8%），和其他3个迁移学习数据集合，参数少了一个数量级（with an order of magnitude fewer parameters）。

    论文思想

    在之前的一些工作当中，我们可以看到，有的会通过增加网络的width即增加卷积核的个数（从而增大channels）来提升网络的性能，有的会通过增加网络的深度即使用更多的层结构来提升网络的性能，有的会通过增加输入网络的分辨率来提升网络的性能。而在Efficientnet当中则重新探究了这个问题，并提出了一种组合条件这三者的网络结构，同时量化了这三者的指标。
    在这里插入图片描述

    The intuition is that deeper ConvNet can capture richer and more complex features, and generalize well on new tasks. However, deeper networks are also more difficult to train due to the vanishing gradient problem
    增加网络的深度depth能够得到更加丰富、复杂的特征并且能够在其他新任务中很好的泛化性能。但是，由于逐渐消失的梯度问题，更深层的网络也更难以训练。

    wider networks tend to be able to capture more fine-grained features and are easier to train. However, extremely wide but shallow networks tend to have difficulties in capturing higher level features
    with更广的网络往往能够捕获更多细粒度的功能，并且更易于训练。但是，极其宽泛但较浅的网络在捕获更高级别的特征时往往会遇到困难

    With higher resolution input images, ConvNets can potentially capture more fine-grained pattern,but the accuracy gain diminishes for very high resolutions
    使用更高分辨率的输入图像，ConvNets可以捕获更细粒度的图案，但对于非常高分辨率的图片，准确度会降低。

    作者在论文中对整个网络的运算过程和复合扩展方法进行了抽象：
    首先定义了每一层卷积网络为$\mathcal{F}{i}\left(X{i}\right)$，而$X_i$是输入张量，$Y_i$是输出张量，而tensor的形状是$<H_i,W_i,C_i>$
    整个卷积网络由 k 个卷积层组成，可以表示为$\mathcal{N}=\mathcal{F}{k} \odot \ldots \odot \mathcal{F}{2} \odot \mathcal{F}{1}\left(X{1}\right)=\bigodot_{j=1 \ldots k} \mathcal{F}{j}\left(X{1}\right)$
    从而得到我们的整个卷积网络:
    $$
    \mathcal{N}=\bigodot_{i=1 \ldots s} \mathcal{F}{i}^{L{i}}\left(X_{\left\langle H_{i}, W_{i}, C_{i}\right\rangle}\right)
    $$

    下标 i(从 1 到 s) 表示的是 stage 的序号，$\mathcal{F}{i}^{L{i}}$表示第 i 个 stage ，它表示卷积层 $\mathcal{F}{i}$重复了${L{i}}$ 次。

    为了探究$d , r , w$这三个因子对最终准确率的影响，则将$d , r , w$加入到公式中，我们可以得到抽象化后的优化问题（在指定资源限制下），其中$s.t.$代表限制条件：
    在这里插入图片描述

    我们限制$\alpha \cdot \beta^{2} \cdot \gamma^{2} \approx 2$所以对于任意给定的$\phi$值，我们总共的运算量将大约增加$2^{\phi}$

    网络结构

    文中给出了Efficientnet-B0的基准框架，在Efficientnet当中，我们所使用的激活函数是swish激活函数，整个网络分为了9个stage，在第2到第8stage是一直在堆叠MBConv结构，表格当中MBConv结构后面的数字（1或6）表示的就是MBConv中第一个1x1的卷积层会将输入特征矩阵的channels扩充为n倍。Channels表示通过该Stage后输出特征矩阵的Channels。
    在这里插入图片描述

    MBConv结构

    MBConv的结构相对来说还是十分好理解的，这里是我自己画的一张结构图。
    在这里插入图片描述
    MBConv结构主要由一个1x1的expand conv（升维作用，包含BN和Swish激活函数）提升维度的倍率正是之前网络结构中看到的1和6，一个KxK的卷积深度可分离卷积Depthwise Conv（包含BN和Swish）k的具体值可看EfficientNet-B0的网络框架主要有3x3和5x5两种情况，一个SE模块，一个1x1的pointer conv降维作用，包含BN），一个Droupout层构成，一般情况下都添加上了残差边模块Shortcut，从而得到输出特征矩阵。
    首先关于深度可分离卷积的概念是是我们需要了解的，相当于将卷积的过程拆成运算和合并两个过程，分别对应depthwise和point两个过程，这里给一个参考连接给大家就不在详细描述了Depthwise卷积与Pointwise卷积
    在这里插入图片描述
    1.由于该模块最初是用tensorflow来实现的与pytorch有一些小差别，所以在使用pytorch实现的时候我们最好将tensorflow当中的samepadding操作重新实现一下
    2.在batchnormal时候的动量设置也是有一些不一样的，论文当中设置的batch_norm_momentum=0.99,在pytorch当中需要先执行1-momentum再设为参数与tensorflow不同。

    # Batch norm parameters
    momentum= 1 - batch_norm_momentum  # pytorch's difference from tensorflow
    eps= batch_norm_epsilon
    nn.BatchNorm2d(num_features=out_channels, momentum=momentum, eps=eps)
    class Conv2dSamePadding(nn.Conv2d):
        """2D Convolutions like TensorFlow, for a dynamic image size.
           The padding is operated in forward function by calculating dynamically.
        """

        # Tips for 'SAME' mode padding.
        #     Given the following:
        #         i: width or height
        #         s: stride
        #         k: kernel size
        #         d: dilation
        #         p: padding
        #     Output after Conv2d:
        #         o = floor((i+p-((k-1)*d+1))/s+1)
        # If o equals i, i = floor((i+p-((k-1)*d+1))/s+1),
        # => p = (i-1)*s+((k-1)*d+1)-i

        def __init__(self, in_channels, out_channels, kernel_size,padding=0, stride=1, dilation=1,
                     groups=1, bias=True, padding_mode = 'zeros'):
            super().__init__(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias)
            self.stride = self.stride if len(self.stride) == 2 else [self.stride[0]] * 2

        def forward(self, x):
            ih, iw = x.size()[-2:] # input
            kh, kw = self.weight.size()[-2:] # because kernel size equals to weight size
            sh, sw = self.stride # stride

            # change the output size according to stride
            oh, ow = math.ceil(ih/sh), math.ceil(iw/sw) # output
            """
                kernel effective receptive field size: (kernel_size-1) x dilation + 1
            """
            pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0)
            pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0)

            if pad_h > 0 or pad_w > 0:
                x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])

            return F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups)

    MBConvBlock模块结构

    class ConvBNActivation(nn.Module):
        """Convolution BN Activation"""
        def __init__(self,in_channels,out_channels,kernel_size,stride=1,groups=1,
                     bias=False,momentum=0.01,eps=1e-3,active=False):
            super().__init__()
            self.layer=nn.Sequential(
                Conv2dSamePadding(in_channels,out_channels,kernel_size=kernel_size,
                                  stride=stride,groups=groups, bias=bias),
                nn.BatchNorm2d(num_features=out_channels, momentum=momentum, eps=eps)
            )
            self.active=active
            self.swish = Swish()

        def forward(self, x):
            x = self.layer(x)
            if self.active:
                x=self.swish(x)
            return x




    class MBConvBlock(nn.Module):
        def __init__(self,in_channels,out_channels,kernel_size,stride,
                     expand_ratio=1, momentum=0.01,eps=1e-3,
                     drop_connect_ratio=0.2,training=True,
                     se_ratio=0.25,skip=True, image_size=None):
            super().__init__()
            self.expand_ratio = expand_ratio
            self.se_ratio = se_ratio
            self.has_se = (se_ratio is not None) and (0 < se_ratio <= 1)
            self.skip = skip and stride == 1 and in_channels == out_channels

            # 1x1 convolution channels expansion phase
            expand_channels = in_channels * self.expand_ratio  # number of output channels

            if self.expand_ratio != 1:
                self.expand_conv = ConvBNActivation(in_channels=in_channels,out_channels=expand_channels,
                                                    momentum=momentum,eps=eps,
                                                    kernel_size=1,bias=False,active=False)

            # Depthwise convolution phase
            self.depthwise_conv = ConvBNActivation(in_channels=expand_channels,out_channels=expand_channels,
                                                   momentum=momentum,eps=eps,
                                                   kernel_size=kernel_size,stride=stride,groups=expand_channels,bias=False,active=False)

            # Squeeze and Excitation module
            if self.has_se:
                sequeeze_channels = max(1,int(expand_channels*self.se_ratio))
                self.se = SEModule(expand_channels,sequeeze_channels)

            # Pointwise convolution phase
            self.project_conv = ConvBNActivation(expand_channels,out_channels,momentum=momentum,eps=eps,
                                                 kernel_size=1,bias=False,active=True)

            self.drop_connect = DropConnect(drop_connect_ratio,training)

        def forward(self,x):
            input_x = x
            if self.expand_ratio != 1:
                x = self.expand_conv(x)
            x = self.depthwise_conv(x)
            if self.has_se:
                x = self.se(x)
            x = self.project_conv(x)
            if self.skip:
                x = self.drop_connect(x)
                x = x + input_x
            return x

    SE模块

    SE模块是通道注意力模块，该模块能够关注channel之间的关系，可以让模型自主学习到不同channel特征的重要程度。由一个全局平均池化，两个全连接层组成。第一个全连接层的节点个数是输入该MBConv特征矩阵channels的1/4 ，且使用Swish激活函数。第二个全连接层的节点个数等于Depthwise Conv层输出的特征矩阵channels，且使用Sigmoid激活函数，这里引用一下别人画好的示意图。
    在这里插入图片描述
    在这里插入图片描述

    class SEModule(nn.Module):
        """Squeeze and Excitation module for channel attention"""
        def __init__(self,in_channels,squeezed_channels):
            super().__init__()
            self.global_avg_pool = nn.AdaptiveAvgPool2d(1)
            self.sequential = nn.Sequential(
                nn.Conv2d(in_channels,squeezed_channels,1),  # use 1x1 convolution instead of linear
                Swish(),
                nn.Conv2d(squeezed_channels,in_channels,1),
                nn.Sigmoid()
            )

        def forward(self,x):
            x= self.global_avg_pool(x)
            y = self.sequential(x)
            return x * y

    swish激活函数

    Swish是Google提出的一种新型激活函数,其原始公式为:f(x)=x * sigmod(x),变形Swish-B激活函数的公式则为f(x)=x * sigmod(b * x),其拥有不饱和,光滑,非单调性的特征,Google在论文中的多项测试表明Swish以及Swish-B激活函数的性能即佳,在不同的数据集上都表现出了要优于当前最佳激活函数的性能。
    $$f(x)=x \cdot \operatorname{sigmoid}(\beta x)$$
    其中$\beta$是个常数或可训练的参数，Swish 具备无上界有下界、平滑、非单调的特性。

    class Swish(nn.Module):
        """ swish activation function"""
        def forward(self,x):
            return x * torch.sigmoid(x)

    droupout代码实现

    class DropConnect(nn.Module):
        """Drop Connection"""
        def __init__(self,ratio,training):
            super().__init__()
            assert 0 <= ratio <= 1
            self.keep_prob = 1 - ratio
            self.training=training

        def forward(self,x):
            if not self.training:
                return x
            batch_size = x.shape[0]

            random_tensor = self.keep_prob
            random_tensor += torch.rand([batch_size,1,1,1],dtype=x.dtype,device=x.device)
            # generate binary_tensor mask according to probability (p for 0, 1-p for 1)
            binary_tensor = torch.floor(random_tensor)

            output = x / self.keep_prob * binary_tensor
            return output

    总结

    这里我们只给出了b0结构的代码实现，对于其他结构的实现过程就是在b0的基础上对wdith，depth，resolution都通过倍率因子统一缩放，这个部分在这个博客里面有详细的介绍EfficientNet(B0-B7)参数设置。
    在本文中，我们系统地研究了ConvNet的缩放比例，分析了各因素对网络结构的影响，并确定仔细平衡网络的宽度，深度和分辨率，这是目前网络训练最重要但缺乏研究的部分，也是我们无法获得更好的准确性和效率忽略的一个部分。为解决此问题，本文作者提出了一种简单而高效的复合缩放方法，通过一个倍率因子统一缩放各部分比例并添加上通道注意力机制和残差模块，从而改善网络架构得到SOTA的效果，同时对模型各成分因子进行量化十分具有创新性。

    参考连接
    EfficientNet网络详解
    神经网络学习小记录50——Pytorch EfficientNet模型的复现详解
    论文翻译
    令人拍案叫绝的EfficientNet和EfficientDet
    swish激活函数
    Depthwise卷积与Pointwise卷积
    CV领域常用的注意力机制模块（SE、CBAM）
    Global Average Pooling

    ]]> + EfficientNet论文解读和pytorch代码实现

    • 传送门

    论文地址：https://arxiv.org/pdf/1905.11946.pdf
    官方github：https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet
    github参考：https://github.com/qubvel/efficientnet
    github参考：https://github.com/lukemelas/EfficientNet-PyTorch

    摘要

    谷歌的文章总是能让我印象深刻，不管从实验上还是论文的书写上都让人十分的佩服，不得不说这确实是一个非常creative的公司!
    Convolutional Neural Networks (ConvNets) are commonly developed at a fixed resource budget, and then scaled up for better accuracy if more resources are available. In this paper, we systematically study model scaling and identify that carefully balancing network depth, width, and resolution can lead to better performance. Based on this observation, we propose a new scaling method that uniformly scales all dimensions of depth/width/resolution using a simple yet highly effective compound coefficient. We demonstrate the effectiveness of this method on scaling up MobileNets and ResNet.
    卷积神经网络通常是在固定的资源预算下进行计算和发展的，如果有更多可用的资源，模型能通过缩放和扩展获得更好的效果，本文系统研究（工作量很充足）了模型缩放，并且证明了细致地平衡网络的深度，宽度，和分辨率能够得到更好的效果，基于这个观点，我们提出了一个新的尺度缩放的方法，我们提出了一个新的尺度缩放的方法即：使用一个简单且高效的复合系数统一地缩放所有网络层的深度/宽度/分辨率的维度。我们证明了该方法在扩大MobileNets和ResNet方面的有效性。

    To go even further, we use neural architecture search to design a new baseline network and scale it up to obtain a family of models, called EfficientNets, which achieve much better accuracy and efficiency than previous ConvNets. In particular, our EfficientNet-B7 achieves state-of-the-art 84.3% top-1 accuracy on ImageNet, while being 8.4x smaller and 6.1x faster on inference than the best existing ConvNet. Our EfficientNets also transfer well and achieve state-of-the-art accuracy on CIFAR-100 (91.7%), Flowers (98.8%), and 3 other transfer learning datasets, with an order of magnitude fewer parameters. Source code is athttps://github.com/tensorflow/tpu/tree/
    master/models/official/efficientnet.

    更进一步，我们使用神经网络结构搜索设计了一个新的baseline网络架构并且对其进行缩放得到了一组模型，我们把他叫做EfficientNets。EfficientNets相比之前的ConvNets，有着更好的准确率和更高的效率。在ImageNet上达到了最好的水平即top-1准确率84.4%/top-5准确率97.1%，然而却比已有的最好的ConvNet模型小了8.4倍并且推理时间快了6.1倍。我们的EfficientNet迁移学习的效果也好，达到了最好的准确率水平CIFAR-100（91.7%），Flowers（98.8%），和其他3个迁移学习数据集合，参数少了一个数量级（with an order of magnitude fewer parameters）。

    论文思想

    在之前的一些工作当中，我们可以看到，有的会通过增加网络的width即增加卷积核的个数（从而增大channels）来提升网络的性能，有的会通过增加网络的深度即使用更多的层结构来提升网络的性能，有的会通过增加输入网络的分辨率来提升网络的性能。而在Efficientnet当中则重新探究了这个问题，并提出了一种组合条件这三者的网络结构，同时量化了这三者的指标。
    在这里插入图片描述

    The intuition is that deeper ConvNet can capture richer and more complex features, and generalize well on new tasks. However, deeper networks are also more difficult to train due to the vanishing gradient problem
    增加网络的深度depth能够得到更加丰富、复杂的特征并且能够在其他新任务中很好的泛化性能。但是，由于逐渐消失的梯度问题，更深层的网络也更难以训练。

    wider networks tend to be able to capture more fine-grained features and are easier to train. However, extremely wide but shallow networks tend to have difficulties in capturing higher level features
    with更广的网络往往能够捕获更多细粒度的功能，并且更易于训练。但是，极其宽泛但较浅的网络在捕获更高级别的特征时往往会遇到困难

    With higher resolution input images, ConvNets can potentially capture more fine-grained pattern,but the accuracy gain diminishes for very high resolutions
    使用更高分辨率的输入图像，ConvNets可以捕获更细粒度的图案，但对于非常高分辨率的图片，准确度会降低。

    作者在论文中对整个网络的运算过程和复合扩展方法进行了抽象：
    首先定义了每一层卷积网络为$\mathcal{F}{i}\left(X{i}\right)$，而$Xi$是输入张量，$Y_i$是输出张量，而tensor的形状是$$
    整个卷积网络由 k 个卷积层组成，可以表示为$\mathcal{N}=\mathcal{F}    {k} \odot \ldots \odot \mathcal{F}{2} \odot \mathcal{F}{1}\left(X{1}\right)=\bigodot{j=1 \ldots k} \mathcal{F}{j}\left(X{1}\right)$
    从而得到我们的整个卷积网络:

    下标 i(从 1 到 s) 表示的是 stage 的序号，$\mathcal{F}{i}^{L{i}}$表示第 i 个 stage ，它表示卷积层 $\mathcal{F}{i}$重复了${L{i}}$ 次。

    为了探究$d , r , w$这三个因子对最终准确率的影响，则将$d , r , w$加入到公式中，我们可以得到抽象化后的优化问题（在指定资源限制下），其中$s.t.$代表限制条件：
    在这里插入图片描述

    网络结构

    文中给出了Efficientnet-B0的基准框架，在Efficientnet当中，我们所使用的激活函数是swish激活函数，整个网络分为了9个stage，在第2到第8stage是一直在堆叠MBConv结构，表格当中MBConv结构后面的数字（1或6）表示的就是MBConv中第一个1x1的卷积层会将输入特征矩阵的channels扩充为n倍。Channels表示通过该Stage后输出特征矩阵的Channels。
    在这里插入图片描述

    MBConv结构

    MBConv的结构相对来说还是十分好理解的，这里是我自己画的一张结构图。
    在这里插入图片描述
    MBConv结构主要由一个1x1的expand conv（升维作用，包含BN和Swish激活函数）提升维度的倍率正是之前网络结构中看到的1和6，一个KxK的卷积深度可分离卷积Depthwise Conv（包含BN和Swish）k的具体值可看EfficientNet-B0的网络框架主要有3x3和5x5两种情况，一个SE模块，一个1x1的pointer conv降维作用，包含BN），一个Droupout层构成，一般情况下都添加上了残差边模块Shortcut，从而得到输出特征矩阵。
    首先关于深度可分离卷积的概念是是我们需要了解的，相当于将卷积的过程拆成运算和合并两个过程，分别对应depthwise和point两个过程，这里给一个参考连接给大家就不在详细描述了Depthwise卷积与Pointwise卷积
    在这里插入图片描述
    1.由于该模块最初是用tensorflow来实现的与pytorch有一些小差别，所以在使用pytorch实现的时候我们最好将tensorflow当中的samepadding操作重新实现一下
    2.在batchnormal时候的动量设置也是有一些不一样的，论文当中设置的batch_norm_momentum=0.99,在pytorch当中需要先执行1-momentum再设为参数与tensorflow不同。

    # Batch norm parameters
    momentum= 1 - batch_norm_momentum  # pytorch's difference from tensorflow
    eps= batch_norm_epsilon
    nn.BatchNorm2d(num_features=out_channels, momentum=momentum, eps=eps)

    class Conv2dSamePadding(nn.Conv2d):
        """2D Convolutions like TensorFlow, for a dynamic image size.
           The padding is operated in forward function by calculating dynamically.
        """

        # Tips for 'SAME' mode padding.
        #     Given the following:
        #         i: width or height
        #         s: stride
        #         k: kernel size
        #         d: dilation
        #         p: padding
        #     Output after Conv2d:
        #         o = floor((i+p-((k-1)*d+1))/s+1)
        # If o equals i, i = floor((i+p-((k-1)*d+1))/s+1),
        # => p = (i-1)*s+((k-1)*d+1)-i

        def __init__(self, in_channels, out_channels, kernel_size,padding=0, stride=1, dilation=1,
                     groups=1, bias=True, padding_mode = 'zeros'):
            super().__init__(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias)
            self.stride = self.stride if len(self.stride) == 2 else [self.stride[0]] * 2

        def forward(self, x):
            ih, iw = x.size()[-2:] # input
            kh, kw = self.weight.size()[-2:] # because kernel size equals to weight size
            sh, sw = self.stride # stride

            # change the output size according to stride
            oh, ow = math.ceil(ih/sh), math.ceil(iw/sw) # output
            """
                kernel effective receptive field size: (kernel_size-1) x dilation + 1
            """
            pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0)
            pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0)

            if pad_h > 0 or pad_w > 0:
                x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])

            return F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups)

    MBConvBlock模块结构

    class ConvBNActivation(nn.Module):
        """Convolution BN Activation"""
        def __init__(self,in_channels,out_channels,kernel_size,stride=1,groups=1,
                     bias=False,momentum=0.01,eps=1e-3,active=False):
            super().__init__()
            self.layer=nn.Sequential(
                Conv2dSamePadding(in_channels,out_channels,kernel_size=kernel_size,
                                  stride=stride,groups=groups, bias=bias),
                nn.BatchNorm2d(num_features=out_channels, momentum=momentum, eps=eps)
            )
            self.active=active
            self.swish = Swish()

        def forward(self, x):
            x = self.layer(x)
            if self.active:
                x=self.swish(x)
            return x




    class MBConvBlock(nn.Module):
        def __init__(self,in_channels,out_channels,kernel_size,stride,
                     expand_ratio=1, momentum=0.01,eps=1e-3,
                     drop_connect_ratio=0.2,training=True,
                     se_ratio=0.25,skip=True, image_size=None):
            super().__init__()
            self.expand_ratio = expand_ratio
            self.se_ratio = se_ratio
            self.has_se = (se_ratio is not None) and (0 < se_ratio <= 1)
            self.skip = skip and stride == 1 and in_channels == out_channels

            # 1x1 convolution channels expansion phase
            expand_channels = in_channels * self.expand_ratio  # number of output channels

            if self.expand_ratio != 1:
                self.expand_conv = ConvBNActivation(in_channels=in_channels,out_channels=expand_channels,
                                                    momentum=momentum,eps=eps,
                                                    kernel_size=1,bias=False,active=False)

            # Depthwise convolution phase
            self.depthwise_conv = ConvBNActivation(in_channels=expand_channels,out_channels=expand_channels,
                                                   momentum=momentum,eps=eps,
                                                   kernel_size=kernel_size,stride=stride,groups=expand_channels,bias=False,active=False)

            # Squeeze and Excitation module
            if self.has_se:
                sequeeze_channels = max(1,int(expand_channels*self.se_ratio))
                self.se = SEModule(expand_channels,sequeeze_channels)

            # Pointwise convolution phase
            self.project_conv = ConvBNActivation(expand_channels,out_channels,momentum=momentum,eps=eps,
                                                 kernel_size=1,bias=False,active=True)

            self.drop_connect = DropConnect(drop_connect_ratio,training)

        def forward(self,x):
            input_x = x
            if self.expand_ratio != 1:
                x = self.expand_conv(x)
            x = self.depthwise_conv(x)
            if self.has_se:
                x = self.se(x)
            x = self.project_conv(x)
            if self.skip:
                x = self.drop_connect(x)
                x = x + input_x
            return x

    SE模块

    SE模块是通道注意力模块，该模块能够关注channel之间的关系，可以让模型自主学习到不同channel特征的重要程度。由一个全局平均池化，两个全连接层组成。第一个全连接层的节点个数是输入该MBConv特征矩阵channels的1/4 ，且使用Swish激活函数。第二个全连接层的节点个数等于Depthwise Conv层输出的特征矩阵channels，且使用Sigmoid激活函数，这里引用一下别人画好的示意图。
    在这里插入图片描述
    在这里插入图片描述

    class SEModule(nn.Module):
        """Squeeze and Excitation module for channel attention"""
        def __init__(self,in_channels,squeezed_channels):
            super().__init__()
            self.global_avg_pool = nn.AdaptiveAvgPool2d(1)
            self.sequential = nn.Sequential(
                nn.Conv2d(in_channels,squeezed_channels,1),  # use 1x1 convolution instead of linear
                Swish(),
                nn.Conv2d(squeezed_channels,in_channels,1),
                nn.Sigmoid()
            )

        def forward(self,x):
            x= self.global_avg_pool(x)
            y = self.sequential(x)
            return x * y

    swish激活函数

    Swish是Google提出的一种新型激活函数,其原始公式为:f(x)=x sigmod(x),变形Swish-B激活函数的公式则为f(x)=x sigmod(b * x),其拥有不饱和,光滑,非单调性的特征,Google在论文中的多项测试表明Swish以及Swish-B激活函数的性能即佳,在不同的数据集上都表现出了要优于当前最佳激活函数的性能。

    其中$\beta$是个常数或可训练的参数，Swish 具备无上界有下界、平滑、非单调的特性。

    class Swish(nn.Module):
        """ swish activation function"""
        def forward(self,x):
            return x * torch.sigmoid(x)

    droupout代码实现

    class DropConnect(nn.Module):
        """Drop Connection"""
        def __init__(self,ratio,training):
            super().__init__()
            assert 0 <= ratio <= 1
            self.keep_prob = 1 - ratio
            self.training=training

        def forward(self,x):
            if not self.training:
                return x
            batch_size = x.shape[0]

            random_tensor = self.keep_prob
            random_tensor += torch.rand([batch_size,1,1,1],dtype=x.dtype,device=x.device)
            # generate binary_tensor mask according to probability (p for 0, 1-p for 1)
            binary_tensor = torch.floor(random_tensor)

            output = x / self.keep_prob * binary_tensor
            return output

    总结

    这里我们只给出了b0结构的代码实现，对于其他结构的实现过程就是在b0的基础上对wdith，depth，resolution都通过倍率因子统一缩放，这个部分在这个博客里面有详细的介绍EfficientNet(B0-B7)参数设置。
    在本文中，我们系统地研究了ConvNet的缩放比例，分析了各因素对网络结构的影响，并确定仔细平衡网络的宽度，深度和分辨率，这是目前网络训练最重要但缺乏研究的部分，也是我们无法获得更好的准确性和效率忽略的一个部分。为解决此问题，本文作者提出了一种简单而高效的复合缩放方法，通过一个倍率因子统一缩放各部分比例并添加上通道注意力机制和残差模块，从而改善网络架构得到SOTA的效果，同时对模型各成分因子进行量化十分具有创新性。

    参考连接
    EfficientNet网络详解
    神经网络学习小记录50——Pytorch EfficientNet模型的复现详解
    论文翻译
    令人拍案叫绝的EfficientNet和EfficientDet
    swish激活函数
    Depthwise卷积与Pointwise卷积
    CV领域常用的注意力机制模块（SE、CBAM）
    Global Average Pooling

    ]]> <h2 id="EfficientNet论文解读和pytorch代码实现"><a href="#EfficientNet论文解读和pytorch代码实现" class="headerlink" title="EfficientNet论文解读和pytorch代码实现"></a>EfficientNet论文解读和pytorch代码实现</h2><h2 id="传送门"><a href="#传送门" class="headerlink" title="传送门"></a>传送门</h2><blockquote> <p>论文地址：<a href="https://arxiv.org/pdf/1905.11946.pdf" target="_blank" rel="noopener">https://arxiv.org/pdf/1905.11946.pdf</a><br>官方github：<a href="https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet" target="_blank" rel="noopener">https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet</a><br>github参考：<a href="https://github.com/qubvel/efficientnet" target="_blank" rel="noopener">https://github.com/qubvel/efficientnet</a><br>github参考：<a href="https://github.com/lukemelas/EfficientNet-PyTorch" target="_blank" rel="noopener">https://github.com/lukemelas/EfficientNet-PyTorch</a></p> </blockquote> -<h2 id="摘要"><a href="#摘要" class="headerlink" title="摘要"></a>摘要</h2><p>谷歌的文章总是能让我印象深刻，不管从实验上还是论文的书写上都让人十分的佩服，不得不说这确实是一个非常creative的公司!<br><code>Convolutional Neural Networks (ConvNets) are commonly developed at a fixed resource budget, and then scaled up for better accuracy if more resources are available. In this paper, we systematically study model scaling and identify that carefully balancing network depth, width, and resolution can lead to better performance. Based on this observation, we propose a new scaling method that uniformly scales all dimensions of depth/width/resolution using a simple yet highly effective compound coefficient. We demonstrate the effectiveness of this method on scaling up MobileNets and ResNet. </code><br>卷积神经网络通常是在固定的资源预算下进行计算和发展的，如果有更多可用的资源，模型能通过缩放和扩展获得更好的效果，本文<strong>系统研究（工作量很充足）</strong>了模型缩放，并且证明了<strong>细致地平衡网络的深度，宽度，和分辨率能够得到更好的效果</strong>，基于这个观点，我们提出了一个新的尺度缩放的方法，我们提出了一个新的尺度缩放的方法即：<strong>使用一个简单且高效的复合系数统一地缩放所有网络层的深度/宽度/分辨率的维度</strong>。我们证明了该方法在扩大MobileNets和ResNet方面的有效性。</p> +<h2 id="摘要"><a href="#摘要" class="headerlink" title="摘要"></a>摘要</h2><p>谷歌的文章总是能让我印象深刻，不管从实验上还是论文的书写上都让人十分的佩服，不得不说这确实是一个非常creative的公司!<br><code>Convolutional Neural Networks (ConvNets) are commonly developed at a fixed resource budget, and then scaled up for better accuracy if more resources are available. In this paper, we systematically study model scaling and identify that carefully balancing network depth, width, and resolution can lead to better performance. Based on this observation, we propose a new scaling method that uniformly scales all dimensions of depth/width/resolution using a simple yet highly effective compound coefficient. We demonstrate the effectiveness of this method on scaling up MobileNets and ResNet.</code><br>卷积神经网络通常是在固定的资源预算下进行计算和发展的，如果有更多可用的资源，模型能通过缩放和扩展获得更好的效果，本文<strong>系统研究（工作量很充足）</strong>了模型缩放，并且证明了<strong>细致地平衡网络的深度，宽度，和分辨率能够得到更好的效果</strong>，基于这个观点，我们提出了一个新的尺度缩放的方法，我们提出了一个新的尺度缩放的方法即：<strong>使用一个简单且高效的复合系数统一地缩放所有网络层的深度/宽度/分辨率的维度</strong>。我们证明了该方法在扩大MobileNets和ResNet方面的有效性。<br></p> @@ -356,11 +356,11 @@ 2021-04-22T02:20:00.000Z 2024-10-09T07:33:09.898Z - yolov1-3论文解析

    最近在看经典目标检测算法yolo的思想，为了更好的了解yolo系列的相关文章，我从最初版本的论文思想开始看的，之后有时间会把yolov4和yolov5再认真看看，目前来说yolov3的spp版本是使用得最为广泛的一种，整体上来说yolo的设计思想还是很有创造性的数学也比较严谨。

    yolov1论文思想

    物体检测主流的算法框架大致分为one-stage与two-stage。two-stage算法代表有R-CNN系列，one-stage算法代表有Yolo系列。按笔者理解，two-stage算法将步骤一与步骤二分开执行，输入图像先经过候选框生成网络（例如faster rcnn中的RPN网络），再经过分类网络；one-stage算法将步骤一与步骤二同时执行，输入图像只经过一个网络，生成的结果中同时包含位置与类别信息。two-stage与one-stage相比，精度高，但是计算量更大，所以运算较慢。

    We present YOLO, a new approach to object detection. Prior work on object detection repurposes classifiers to perform detection. Instead, we frame object detection as a regression problem to spatially separated bounding boxes and associated class probabilities.

    yolo相比其他R-CNN等方法最大的一个不同就是他将这个识别和定位的过程转化成了一个空间定位并分类的回归问题，这也是他为什么能够利用网络进行端到端直接同时预测的重要原因。

    yolo的特点

    1.YOLO速度非常快。由于我们的检测是当做一个回归问题，不需要很复杂的流程。在测试的时候我们只需将一个新的图片输入网络来检测物体。
    First, YOLO is extremely fast. Since we frame detection as a regression problem we don’t need a complex pipeline
    2.Yolo会基于整张图片信息进行预测，与基于滑动窗口和候选区域的方法不同，在训练和测试期间YOLO可以看到整个图像，所以它隐式地记录了分类类别的上下文信息及它的全貌
    Second, YOLO reasons globally about the image when making predictions Unlike sliding window and region proposal-based techniques, YOLO sees the entire image during training and test time so it implicitly encodes contextual information about classes as well as their appearance
    3.第三，YOLO能学习到目标的泛化表征。作者尝试了用自然图片数据集进行训练，用艺术画作品进行预测，Yolo的检测效果更佳。
    Third, YOLO learns generalizable representations of objects. Since YOLO is highly generalizable it is less likely to break down when applied to new domains or unexpected inputs

    backbone-darknet

    在这里插入图片描述
    yolov1这块的话，由于是比较早期的网络所以在设计时没有使用batchnormal，激活函数上采用leaky relu，输入图像大小为448x448，经过许多卷积层与池化层，变为7x7x1024张量，最后经过两层全连接层，输出张量维度为7x7x30。除了最后一层的输出使用了线性激活函数，其他层全部使用Leaky Relu激活函数。
    $$\phi(x)= \begin{cases}
    x,& \text{if x>0} \
    0.1x,& \text{otherwise}
    \end{cases}$$

    输出维度

    yolov1最精髓的地方应该就是他的输出维度，论文当中有放出这样一张图片，看完以后我们能对yolo算法的特点有更加深刻的理解。在上图的backbone当中我们可以看到的是
    在这里插入图片描述yolo的输出相当于把原图片分割成了$S \times S$个区域，然后对预测目标标定他的boundingbox，boundingbox由中心点的坐标,长宽以及物体的置信分数组成$x,y,w,h,confidence$，图中的$B$表示的是boundingbox的个数。置信分数在yolo当中是这样定义的：$Pr(Object)IOU_{pred}^{truth}$对于$Pr(Object)=1 \text{ if detect object else 0}$，其实置信分数就是boudingbox与groundtruth之间的IOU，并对每个小网格对应的$C$个类别都预测出他的条件概率：$Pr(Class_i|Object)$。
    在推理时，我们可以得到当前网格对于每个类别的预测置信分数：$$Pr(Class_i)*IOU_{pred}^{truth} = Pr(Class_i|Object)*Pr(Object)*IOU_{pred}^{truth}$$
    这样一种严谨的条件概率的方式得到我们的最终概率是十分可行和合适的。
    YOLO imposes strong spatial constraints on bounding box predictions since each grid cell only predicts two boxes and can only have one class. This spatial constraint limits the number of nearby objects that our model can predict. Our model struggles with small objects that appear in groups, such as flocks of birds.
    *    不过在原论文当中也有提到的一点是：YOLO给边界框预测强加空间约束，因为每个网格单元只预测两个框和只能有一个类别。这个空间约束限制了我们的模型可以预测的邻近目标的数量。我们的模型难以预测群组中出现的小物体（比如鸟群）。**

    损失函数

    在损失函数方面，由于公式比较长所以就直接截图过来了，损失函数的设计放方面作者也考虑的比较周全，
    在这里插入图片描述
    预测框的中心点$(x,y)$。预测框的宽高$w,h$，其中$\mathbb{1}_{i j}^{\text {obj }}$为控制函数，在标签中包含物体的那些格点处，该值为 1 ，若格点不含有物体，该值为 0

    在计算损失函数的时候作者最开始使用的是最简单的平方损失函数来计算检测，因为它是计算简单且容易优化的，但是它并不完全符合我们最大化平均精度的目标，原因如下：
    It weights localization error equally with classification error which may not be ideal.
    1.它对定位错误的权重与分类错误的权重相等，这可能不是理想的选择。
    Also, in every image many grid cells do not contain any object. This pushes the “confidence” scores of those cells towards zero, often overpowering the gradient from cells that do contain objects. This can lead to model instability, causing training to diverge early on.
    而且，在每个图像中，许多网格单元不包含任何对象。这就把这些网格的置信度分数推到零，往往超过了包含对象的网格的梯度。2.这可能导致模型不稳定，导致训练早期发散难以训练。

    解决方案：增加边界框坐标预测的损失，并且减少了不包含对象的框的置信度预测的损失。我们使用两个参数来实现这一点。$\lambda_{coord}=5，\lambda_{noobj}=0.5$，其实这也是yolo面临的一个样本数目不均衡的典型例子。主要目的是让含有物体的格点，在损失函数中的权重更大，让模型更加注重含有物体的格点所造成的损失。
    我们的损失函数则只会对那些有真实物体所属的格点进行损失计算，若该格点不包含物体，那么预测数值不对损失函数造成影响。

    这里对$w,h$在损失函数中的处理分别取了根号，原因在于，如果不取根号，损失函数往往更倾向于调整尺寸比较大的预测框。例如，20个像素点的偏差，对于800x600的预测框几乎没有影响，此时的IOU数值还是很大，但是对于30x40的预测框影响就很大。取根号是为了尽可能的消除大尺寸框与小尺寸框之间的差异。

    预测框的置信度$C_i$。当该格点不含有物体时，该置信度的标签为0；若含有物体时，该置信度的标签为预测框与真实物体框的IOU数值（。
    物体类别概率$P_i$，对应的类别位置，该标签数值为1，其余位置为0，与分类网络相同。

    yolov2：Better, Faster, Stronger

    yolov2的论文里面其实更多的是对训练数据集的组合和扩充，然后再添加了很多计算机视觉方面新出的trick，然后达到了性能的提升。同时yolov2方面所使用的trick也是现在计算机视觉常用的方法，我认为这些都是我们需要好好掌握的，同时也是面试和kaggle上都经常使用的一些方法。

    Batch Normalization

    BN是由Google于2015年提出，论文是《Batch Normalization_ Accelerating Deep Network Training by Reducing Internal Covariate Shift》，这是一个深度神经网络训练的技巧，主要是让数据的分布变得一致，从而使得训练深层网络模型更加容易和稳定。
    这里有一些相关的链接可以参考一下

    https://www.cnblogs.com/itmorn/p/11241236.html
    https://zhuanlan.zhihu.com/p/24810318
    https://zhuanlan.zhihu.com/p/93643523
    莫烦python
    李宏毅yyds

    算法具体过程：
    在这里插入图片描述

    这里要提一下这个$\gamma和\beta$是可训练参数，维度等于张量的通道数，主要是为了在反向传播更新网络时使得标准化后的数据分布与原始数据尽可能保持一直，从而很好的抽象和保留整个batch的数据分布。

    Batch Normalization的作用：
    将这些输入值或卷积网络的张量在batch维度上进行类似标准化的操作，将其放缩到合适的范围，加快模型训练时的收敛速度，使得模型训练过程更加稳定，避免梯度爆炸或者梯度消失，并且起到一定的正则化作用。

    High Resolution Classifier

    在Yolov1中，网络的backbone部分会在ImageNet数据集上进行预训练，训练时网络输入图像的分辨率为224x224。在v2中，将分类网络在输入图片分辨率为448x448的ImageNet数据集上训练10个epoch，再使用检测数据集（例如coco）进行微调。高分辨率预训练使mAP提高了大约4%。

    Convolutional With Anchor Boxes

    predicts these offsets at every location in a feature map
    Predicting offsets instead of coordinates simplifies the problem and makes it easier for the network to learn.
    第一篇解读v1时提到，每个格点预测两个矩形框，在计算loss时，只让与ground truth最接近的框产生loss数值，而另一个框不做修正。这样规定之后，作者发现两个框在物体的大小、长宽比、类别上逐渐有了分工。在v2中，神经网络不对预测矩形框的宽高的绝对值进行预测，而是预测与Anchor框的偏差（offset），每个格点指定n个Anchor框。在训练时，最接近ground truth的框产生loss，其余框不产生loss。在引入Anchor Box操作后，mAP由69.5下降至69.2，原因在于，每个格点预测的物体变多之后，召回率大幅上升，准确率有所下降，总体mAP略有下降。

    Dimension Clusters

    Instead of choosing priors by hand, we run k-means clustering on the training set bounding boxes to automatically find good priors.
    这里算是作者数据处理上的一个创新点，这里作者提到之前的工作当中先Anchor Box都是认为设定的比例和大小，而这里作者时采用无监督的方式将训练数据集中的矩形框全部拿出来，用kmeans聚类得到先验框的宽和高。使用（1-IOU）数值作为两个矩形框的的距离函数，这个处理也十分的聪明。
    $$
    d(\text { box }, \text { centroid })=1-\operatorname{IOU}(\text { box }, \text { centroid })
    $$
    在这里插入图片描述

    Direct location prediction

    Yolo中的位置预测方法是预测的左上角的格点坐标预测偏移量。网络预测输出要素图中每个单元格的5个边界框。网络为每个边界框预测$t_x，t_y，t_h，t_w和t_o$这5个坐标。如果单元格从图像的左上角偏移了$(c_x，c_y)$并且先验边界框的宽度和高度为$p_w，p_h$，则预测对应于：
    $$
    \begin{array}{l}
    x=\left(t_{x} * w_{a}\right)-x_{a} \
    y=\left(t_{y} * h_{a}\right)-y_{a}
    \end{array}
    $$
    在这里插入图片描述
    $$
    \begin{aligned}
    b_{x} &=\sigma\left(t_{x}\right)+c_{x} \
    b_{y} &=\sigma\left(t_{y}\right)+c_{y} \
    b_{w} &=p_{w} e^{t_{w}} \
    b_{h} &=p_{h} e^{t_{h}} \
    \operatorname{Pr}(\text { object }) * I O U(b, \text { object }) &=\sigma\left(t_{o}\right)
    \end{aligned}
    $$
    由于我们约束位置预测，参数化更容易学习，使得网络更稳定使用维度集群以及直接预测边界框中心位置使YOLO比具有anchor box的版本提高了近5％的mAP。

    Fine-Grained Features

    在2626的特征图，经过卷积层等，变为1313的特征图后，作者认为损失了很多细粒度的特征，导致小尺寸物体的识别效果不佳，所以在此加入了passthrough层。
    传递层通过将相邻特征堆叠到不同的通道而不是堆叠到空间位置，将较高分辨率特征与低分辨率特征相连，类似于ResNet中的标识映射。这将26×26×512特征映射转换为13×13×2048特征映射，其可以与原始特征连接。
    在这里插入图片描述

    Multi-Scale Training

    我觉得这个也是yolo为什么性能提升的一个很重要的点，解决了yolo1当中对于多个小物体检测的问题。
    原始的YOLO使用448×448的输入分辨率。添加anchor box后，我们将分辨率更改为416×416。然而，由于我们的模型只使用卷积层和池化层,相比yolo1删除了全连接层，它可以在运行中调整大小（应该是使用了1x1卷积不过我没看代码）。我们希望YOLOv2能够在不同大小的图像上运行，因此我们将其训练到模型中。
    instead of fixing the input image size we change the network every few iterations. Every 10 batches our network randomly chooses a new image dimension size.
    不固定输入图像的大小，我们每隔几次迭代就更改网络。在每10个batch之后，我们的网络就会随机resize成{320, 352, …, 608}中的一种。不同的输入，最后产生的格点数不同，比如输入图片是320320，那么输出格点是1010，如果每个格点的先验框个数设置为5，那么总共输出500个预测结果；如果输入图片大小是608608，输出格点就是1919，共1805个预测结果。
    YOLO’s convolutional layers downsample the image by a factor of 32 so by using an input image of 416 we get an output feature map of 13 × 13.
    We do this because we want an odd number of locations in our feature map so there is a single center cell.
    关于416×416也是有说法的，主要是下采样是32的倍数，而且最后的输出是13x13是奇数然后会有一个中心点更加易于目标检测。
    这种训练方法迫使网络学习在各种输入维度上很好地预测。这意味着相同的网络可以预测不同分辨率的检测。
    关于yolov2最大的一个提升还有一个原因就是WordTree组合数据集的训练方法，不过这里我就不再赘述，可以看参考资料有详细介绍，这里主要讲网络和思路

    yolov3论文改进

    yolov3的论文改进就有很多方面了，而且yolov3-spp的网络效果很不错，和yolov4，yolov5的效果差别也不是特别大，这也是为什么yolov3网络被广泛应用的原因之一。

    backbone：Darknet-53

    相比yolov1的网络，在网络上有了很大的改进，借鉴了Resnet、Densenet、FPN的做法结合了当前网络中十分有效的
    在这里插入图片描述
    1.Yolov3中，全卷积，对于输入图片尺寸没有特别限制，可通过调节卷积步长控制输出特征图的尺寸。
    2.Yolov3借鉴了金字塔特征图思想，小尺寸特征图用于检测大尺寸物体，而大尺寸特征图检测小尺寸物体。特征图的输出维度为$N \times N \times (3 \times (4+1+80))$， NxN为输出特征图格点数，一共3个Anchor框，每个框有4维预测框数值 $t_x,t_y,t_w,t_h$ ，1维预测框置信度，80维物体类别数。所以第一层特征图的输出维度为8x8x255
    3.Yolov3总共输出3个特征图，第一个特征图下采样32倍，第二个特征图下采样16倍，第三个下采样8倍。每个特征图进行一次3X3、步长为2的卷积，然后保存该卷积layer，再进行一次1X1的卷积和一次3X3的卷积，并把这个结果加上layer作为最后的结果。三个特征层进行5次卷积处理，处理完后一部分用于输出该特征层对应的预测结果，一部分用于进行反卷积UmSampling2d后与其它特征层进行结合。
    4.concat和resiual加操作，借鉴DenseNet将特征图按照通道维度直接进行拼接，借鉴Resnet添加残差边，缓解了在深度神经网络中增加深度带来的梯度消失问题。
    5.上采样层(upsample)：作用是将小尺寸特征图通过插值等方法，生成大尺寸图像。例如使用最近邻插值算法，将88的图像变换为1616。上采样层不改变特征图的通道数。

    对于yolo3的模型来说，网络最后输出的内容就是三个特征层每个网格点对应的预测框及其种类，即三个特征层分别对应着图片被分为不同size的网格后，每个网格点上三个先验框对应的位置、置信度及其种类。然后对输出进行解码，解码过程也就是yolov2上面的Direct location prediction方法一样，每个网格点加上它对应的x_offset和y_offset，加完后的结果就是预测框的中心，然后再利用 先验框和h、w结合 计算出预测框的长和宽。这样就能得到整个预测框的位置了。

    CIoU loss

    在yolov3当中我们使用的不再是传统的IoU loss，而是一个非常优秀的loss设计，整个发展过程也可以多了解了解IoU->GIoU->DIoU->CIoU，完整的考虑了重合面积，中心点距离，长宽比。
    $$CIoU=IoU-(\frac{\rho(b,b^{gt}}{c^2}+\alpha v))$$
    $$v=\frac{4}{\pi^2}(\arctan\frac{w^{gt}}{h^{gt}}-\arctan\frac{w}{h})^2$$
    $$\alpha = \frac{v}{(1-IoU)+v}$$
    其中， $b$ ， $b^{gt}$ 分别代表了预测框和真实框的中心点，且 $\rho$代表的是计算两个中心点间的欧式距离。 [公式] 代表的是能够同时包含预测框和真实框的最小闭包区域的对角线距离。
    在介绍CIoU之前，我们可以先介绍一下DIoU loss
    在这里插入图片描述
    其实这两项就是我们的DIoU
    $$DIoU = IoU-(\frac{\rho(b,b^{gt}}{c^2})$$
    则我们可以提出DIoU loss函数
    $$
    L_{\text {DIoU }}=1-D I o U \
    0 \leq L_{\text {DloU}} \leq 2
    $$
    DloU损失能够直接最小化两个boxes之间的距离，因此收敛速度更快。
    而我们的CIoU则比DIoU考虑更多的东西，也就是长宽比即最后一项。而$v$用来度量长宽比的相似性,$\alpha$是权重
    在损失函数这块，有知乎大佬写了一下，其实就是对yolov1上的损失函数进行了一下变形。
    在这里插入图片描述

    Spatial Pyramid Pooling

    在yolov3的spp版本中使用了spp模块，实现了不同尺度的特征融合，spp模块最初来源于何凯明大神的论文SPP-net，主要用来解决输入图像尺寸不统一的问题，而目前的图像预处理操作中，resize，crop等都会造成一定程度的图像失真，因此影响了最终的精度。SPP模块，使用固定分块的池化操作，可以对不同尺寸的输入实现相同大小的输出，因此能够避免这一问题。
    同时SPP模块中不同大小特征的融合，有利于待检测图像中目标大小差异较大的情况，也相当于增大了多重感受野吧，尤其是对于yolov3一般针对的复杂多目标图像。
    在yolov3的darknet53输出到第一个特征图计算之前我们插入了一个spp模块。
    在这里插入图片描述
    SPP的这几个模块stride=1，而且会对外补padding，所以最后的输出特征图大小是一致的，然后在深度方向上进行concatenate，使得深度增大了4倍。
    在这里插入图片描述
    在这里插入图片描述
    可以看出随着输入网络尺度的增大，spp的效果会更好。多个spp的效果增大也就是spp3和spp1的效果是差不多的，为了保证推理速度就只使用了一个spp

    Mosaic图像增强

    在yolov3-spp包括yolov4当中我们都使用了mosaic数据增强，有点类似cutmix。cutmix是合并两张图片进行预测，mosaic数据增强利用了四张图片，对四张图片进行拼接，每一张图片都有其对应的框框，将四张图片拼接之后就获得一张新的图片，同时也获得这张图片对应的框框，然后我们将这样一张新的图片传入到神经网络当中去学习，相当于一下子传入四张图片进行学习了。论文中说这极大丰富了检测物体的背景，且在标准化BN计算的时候一下子会计算四张图片的数据。
    在这里插入图片描述
    作用：增加数据的多样性，增加目标个数，BN能一次性归一化多张图片组合的分布，会更加接近原数据的分布。

    focal loss

    最后我们提一下focal loss，虽然在原论文当中作者说focal loss效果反而下降了，但是我认为还是有必要了解一下何凯明的这篇bestpaper。作者提出focal loss的出发点也是希望one-stage detector可以达到two-stage detector的准确率，同时不影响原有的速度。作者认为造成这种情况的原因是样本的类别不均衡导致的。
    对于二分类的CrossEntropy，我们有如下表示方法：
    $$
    \mathrm{CE}(p, y)=\left{\begin{array}{ll}
    -\log (p) & \text { if } y=1 \
    -\log (1-p) & \text { otherwise. }
    \end{array}\right.
    $$
    我们定义$p_t$：
    $$
    p_{\mathrm{t}}=\left{\begin{array}{ll}
    p & \text { if } y=1 \
    1-p & \text { otherwise }
    \end{array}\right.
    $$
    则重写交叉熵
    $$
    \operatorname{CE}(n, y)=C E(p_t)=-\log (p_t)
    $$
    接着我们提出改进思路就是在计算CE时添加了一个平衡因子，是一个可训练的参数
    $$
    \mathrm{CE}\left(p_{\mathrm{t}}\right)=-\alpha_{\mathrm{t}} \log \left(p_{\mathrm{t}}\right)
    $$
    其中
    $$
    \alpha_{\mathrm{t}}=\left{\begin{array}{ll}
    \alpha_{\mathrm{t}} & \text { if } y=1 \
    1-\alpha_{\mathrm{t}} & \text { otherwise }
    \end{array}\right.
    $$
    相当于给正负样本加上权重，负样本出现的频次多，那么就降低负样本的权重，正样本数量少，就相对提高正样本的权重。因此可以通过设定a的值来控制正负样本对总的loss的共享权重。a取比较小的值来降低负样本（多的那类样本）的权重。
    但是何凯明认为这个还是不能完全解决样本不平衡的问题，虽然这个平衡因子可以控制正负样本的权重，但是没法控制容易分类和难分类样本的权重

    As our experiments will show, the large class imbalance encountered during training of dense detectors overwhelms the cross entropy loss. Easily classified negatives comprise the majority of the loss and dominate the gradient. While
    α balances the importance of positive/negative examples, it does not differentiate between easy/hard examples. Instead, we propose to reshape the loss function to down-weight easy examples and thus focus training on hard negatives

    于是提出了一种新的损失函数Focal Loss
    $$
    \mathrm{FL}\left(p_{\mathrm{t}}\right)=-\left(1-p_{\mathrm{t}}\right)^{\gamma} \log \left(p_{\mathrm{t}}\right)
    $$
    在这里插入图片描述

    focal loss的两个重要性质

    1、当一个样本被分错的时候，pt是很小的，那么调制因子（1-Pt）接近1，损失不被影响；当Pt→1，因子（1-Pt）接近0，那么分的比较好的（well-classified）样本的权值就被调低了。因此调制系数就趋于1，也就是说相比原来的loss是没有什么大的改变的。当pt趋于1的时候（此时分类正确而且是易分类样本），调制系数趋于0，也就是对于总的loss的贡献很小。

    2、当γ=0的时候，focal loss就是传统的交叉熵损失，当γ增加的时候，调制系数也会增加。 专注参数γ平滑地调节了易分样本调低权值的比例。γ增大能增强调制因子的影响，实验发现γ取2最好。直觉上来说，调制因子减少了易分样本的损失贡献，拓宽了样例接收到低损失的范围。当γ一定的时候，比如等于2，一样easy example(pt=0.9)的loss要比标准的交叉熵loss小100+倍，当pt=0.968时，要小1000+倍，但是对于hard example(pt < 0.5)，loss最多小了4倍。这样的话hard example的权重相对就提升了很多。这样就增加了那些误分类的重要性

    focal loss的两个性质算是核心，其实就是用一个合适的函数去度量难分类和易分类样本对总的损失的贡献。

    然后作者又提出了最终的focal loss形式
    $$
    \mathrm{FL}\left(p_{\mathrm{t}}\right)=-\alpha_{\mathrm{t}}\left(1-p_{\mathrm{t}}\right)^{\gamma} \log \left(p_{\mathrm{t}}\right)
    $$
    $$
    F L(p)\left{\begin{array}{ll}
    -\alpha(1-p)^{\gamma} \log (p) & \text { if } y=1 \
    -(1-\alpha) p^{\gamma} \log (1-p) & \text { otherwise }
    \end{array}\right.
    $$
    这样既能调整正负样本的权重，又能控制难易分类样本的权重
    在实验中a的选择范围也很广，一般而言当γ增加的时候，a需要减小一点（实验中γ=2，a=0.25的效果最好）

    总结

    yolo和yolov2的严谨数学推理和网络相结合的做法令人十分惊艳，而yolov3相比之前的两个版本不管是在数据处理还是网络性质上都有很大的改变，也使用了很多流行的tirck来实现目标检测，基本上结合了很多cv领域的精髓，博客中有很多部分由于时间关系没有太细讲，其实每个部分都可以去原论文中找到很多可以学习的地方，之后有时候会补上yolov4和yolov5的讲解，后面的网络添加了注意力机制模块效果应该是更加work的。

    参考文献

    yolov3-spp
    focal loss
    batch normal
    IoU系列
    yolov1论文翻译
    yolo1-3三部曲
    Bubbliiiing的教程里
    还有很多但是没找到之后会补上的

    ]]>     + yolov1-3论文解析

    最近在看经典目标检测算法yolo的思想，为了更好的了解yolo系列的相关文章，我从最初版本的论文思想开始看的，之后有时间会把yolov4和yolov5再认真看看，目前来说yolov3的spp版本是使用得最为广泛的一种，整体上来说yolo的设计思想还是很有创造性的数学也比较严谨。

    yolov1论文思想

    物体检测主流的算法框架大致分为one-stage与two-stage。two-stage算法代表有R-CNN系列，one-stage算法代表有Yolo系列。按笔者理解，two-stage算法将步骤一与步骤二分开执行，输入图像先经过候选框生成网络（例如faster rcnn中的RPN网络），再经过分类网络；one-stage算法将步骤一与步骤二同时执行，输入图像只经过一个网络，生成的结果中同时包含位置与类别信息。two-stage与one-stage相比，精度高，但是计算量更大，所以运算较慢。

    We present YOLO, a new approach to object detection. Prior work on object detection repurposes classifiers to perform detection. Instead, we frame object detection as a regression problem to spatially separated bounding boxes and associated class probabilities.

    yolo相比其他R-CNN等方法最大的一个不同就是他将这个识别和定位的过程转化成了一个空间定位并分类的回归问题，这也是他为什么能够利用网络进行端到端直接同时预测的重要原因。

    yolo的特点

    1.YOLO速度非常快。由于我们的检测是当做一个回归问题，不需要很复杂的流程。在测试的时候我们只需将一个新的图片输入网络来检测物体。
    First, YOLO is extremely fast. Since we frame detection as a regression problem we don’t need a complex pipeline
    2.Yolo会基于整张图片信息进行预测，与基于滑动窗口和候选区域的方法不同，在训练和测试期间YOLO可以看到整个图像，所以它隐式地记录了分类类别的上下文信息及它的全貌
    Second, YOLO reasons globally about the image when making predictions Unlike sliding window and region proposal-based techniques, YOLO sees the entire image during training and test time so it implicitly encodes contextual information about classes as well as their appearance
    3.第三，YOLO能学习到目标的泛化表征。作者尝试了用自然图片数据集进行训练，用艺术画作品进行预测，Yolo的检测效果更佳。
    Third, YOLO learns generalizable representations of objects. Since YOLO is highly generalizable it is less likely to break down when applied to new domains or unexpected inputs

    backbone-darknet

    在这里插入图片描述
    yolov1这块的话，由于是比较早期的网络所以在设计时没有使用batchnormal，激活函数上采用leaky relu，输入图像大小为448x448，经过许多卷积层与池化层，变为7x7x1024张量，最后经过两层全连接层，输出张量维度为7x7x30。除了最后一层的输出使用了线性激活函数，其他层全部使用Leaky Relu激活函数。

    输出维度

    yolov1最精髓的地方应该就是他的输出维度，论文当中有放出这样一张图片，看完以后我们能对yolo算法的特点有更加深刻的理解。在上图的backbone当中我们可以看到的是
    在这里插入图片描述yolo的输出相当于把原图片分割成了$S \times S$个区域，然后对预测目标标定他的boundingbox，boundingbox由中心点的坐标,长宽以及物体的置信分数组成$x,y,w,h,confidence$，图中的$B$表示的是boundingbox的个数。置信分数在yolo当中是这样定义的：$Pr(Object)IOU_{pred}^{truth}$对于$Pr(Object)=1 \text{ if detect object else 0}$，其实置信分数就是boudingbox与groundtruth之间的IOU，并对每个小网格对应的$C$个类别都预测出他的条件概率：$Pr(Class_i|Object)$。
    在推理时，我们可以得到当前网格对于每个类别的预测置信分数：$$Pr(Class_i)    IOU{pred}^{truth} = Pr(Class_i|Object)Pr(Object)IOU{pred}^{truth}$$
    这样一种严谨的条件概率的方式得到我们的最终概率是十分可行和合适的。
    YOLO imposes strong spatial constraints on bounding box predictions since each grid cell only predicts two boxes and can only have one class. This spatial constraint limits the number of nearby objects that our model can predict. Our model struggles with small objects that appear in groups, such as flocks of birds.
    不过在原论文当中也有提到的一点是：YOLO给边界框预测强加空间约束，因为每个网格单元只预测两个框和只能有一个类别。这个空间约束限制了我们的模型可以预测的邻近目标的数量。我们的模型难以预测群组中出现的小物体（比如鸟群）。

    损失函数

    在损失函数方面，由于公式比较长所以就直接截图过来了，损失函数的设计放方面作者也考虑的比较周全，
    在这里插入图片描述
    预测框的中心点$(x,y)$。预测框的宽高$w,h$，其中$\mathbb{1}_{i j}^{\text {obj }}$为控制函数，在标签中包含物体的那些格点处，该值为 1 ，若格点不含有物体，该值为 0

    在计算损失函数的时候作者最开始使用的是最简单的平方损失函数来计算检测，因为它是计算简单且容易优化的，但是它并不完全符合我们最大化平均精度的目标，原因如下：
    It weights localization error equally with classification error which may not be ideal.
    1.它对定位错误的权重与分类错误的权重相等，这可能不是理想的选择。
    Also, in every image many grid cells do not contain any object. This pushes the “confidence” scores of those cells towards zero, often overpowering the gradient from cells that do contain objects. This can lead to model instability, causing training to diverge early on.
    而且，在每个图像中，许多网格单元不包含任何对象。这就把这些网格的置信度分数推到零，往往超过了包含对象的网格的梯度。2.这可能导致模型不稳定，导致训练早期发散难以训练。

    解决方案：增加边界框坐标预测的损失，并且减少了不包含对象的框的置信度预测的损失。我们使用两个参数来实现这一点。$\lambda{coord}=5，\lambda{noobj}=0.5$，其实这也是yolo面临的一个样本数目不均衡的典型例子。主要目的是让含有物体的格点，在损失函数中的权重更大，让模型更加注重含有物体的格点所造成的损失。
    我们的损失函数则只会对那些有真实物体所属的格点进行损失计算，若该格点不包含物体，那么预测数值不对损失函数造成影响。

    这里对$w,h$在损失函数中的处理分别取了根号，原因在于，如果不取根号，损失函数往往更倾向于调整尺寸比较大的预测框。例如，20个像素点的偏差，对于800x600的预测框几乎没有影响，此时的IOU数值还是很大，但是对于30x40的预测框影响就很大。取根号是为了尽可能的消除大尺寸框与小尺寸框之间的差异。

    预测框的置信度$C_i$。当该格点不含有物体时，该置信度的标签为0；若含有物体时，该置信度的标签为预测框与真实物体框的IOU数值（。
    物体类别概率$P_i$，对应的类别位置，该标签数值为1，其余位置为0，与分类网络相同。

    yolov2：Better, Faster, Stronger

    yolov2的论文里面其实更多的是对训练数据集的组合和扩充，然后再添加了很多计算机视觉方面新出的trick，然后达到了性能的提升。同时yolov2方面所使用的trick也是现在计算机视觉常用的方法，我认为这些都是我们需要好好掌握的，同时也是面试和kaggle上都经常使用的一些方法。

    Batch Normalization

    BN是由Google于2015年提出，论文是《Batch Normalization_ Accelerating Deep Network Training by Reducing Internal Covariate Shift》，这是一个深度神经网络训练的技巧，主要是让数据的分布变得一致，从而使得训练深层网络模型更加容易和稳定。
    这里有一些相关的链接可以参考一下

    https://www.cnblogs.com/itmorn/p/11241236.html
    https://zhuanlan.zhihu.com/p/24810318
    https://zhuanlan.zhihu.com/p/93643523
    莫烦python
    李宏毅yyds

    算法具体过程：
    在这里插入图片描述

    这里要提一下这个$\gamma和\beta$是可训练参数，维度等于张量的通道数，主要是为了在反向传播更新网络时使得标准化后的数据分布与原始数据尽可能保持一直，从而很好的抽象和保留整个batch的数据分布。

    Batch Normalization的作用：
    将这些输入值或卷积网络的张量在batch维度上进行类似标准化的操作，将其放缩到合适的范围，加快模型训练时的收敛速度，使得模型训练过程更加稳定，避免梯度爆炸或者梯度消失，并且起到一定的正则化作用。

    High Resolution Classifier

    在Yolov1中，网络的backbone部分会在ImageNet数据集上进行预训练，训练时网络输入图像的分辨率为224x224。在v2中，将分类网络在输入图片分辨率为448x448的ImageNet数据集上训练10个epoch，再使用检测数据集（例如coco）进行微调。高分辨率预训练使mAP提高了大约4%。

    Convolutional With Anchor Boxes

    predicts these offsets at every location in a feature map
    Predicting offsets instead of coordinates simplifies the problem and makes it easier for the network to learn.
    第一篇解读v1时提到，每个格点预测两个矩形框，在计算loss时，只让与ground truth最接近的框产生loss数值，而另一个框不做修正。这样规定之后，作者发现两个框在物体的大小、长宽比、类别上逐渐有了分工。在v2中，神经网络不对预测矩形框的宽高的绝对值进行预测，而是预测与Anchor框的偏差（offset），每个格点指定n个Anchor框。在训练时，最接近ground truth的框产生loss，其余框不产生loss。在引入Anchor Box操作后，mAP由69.5下降至69.2，原因在于，每个格点预测的物体变多之后，召回率大幅上升，准确率有所下降，总体mAP略有下降。

    Dimension Clusters

    Instead of choosing priors by hand, we run k-means clustering on the training set bounding boxes to automatically find good priors.
    这里算是作者数据处理上的一个创新点，这里作者提到之前的工作当中先Anchor Box都是认为设定的比例和大小，而这里作者时采用无监督的方式将训练数据集中的矩形框全部拿出来，用kmeans聚类得到先验框的宽和高。使用（1-IOU）数值作为两个矩形框的的距离函数，这个处理也十分的聪明。

    在这里插入图片描述

    Direct location prediction

    Yolo中的位置预测方法是预测的左上角的格点坐标预测偏移量。网络预测输出要素图中每个单元格的5个边界框。网络为每个边界框预测$t_x，t_y，t_h，t_w和t_o$这5个坐标。如果单元格从图像的左上角偏移了$(c_x，c_y)$并且先验边界框的宽度和高度为$p_w，p_h$，则预测对应于：

    在这里插入图片描述

    由于我们约束位置预测，参数化更容易学习，使得网络更稳定使用维度集群以及直接预测边界框中心位置使YOLO比具有anchor box的版本提高了近5％的mAP。

    Fine-Grained Features

    在2626的特征图，经过卷积层等，变为1313的特征图后，作者认为损失了很多细粒度的特征，导致小尺寸物体的识别效果不佳，所以在此加入了passthrough层。
    传递层通过将相邻特征堆叠到不同的通道而不是堆叠到空间位置，将较高分辨率特征与低分辨率特征相连，类似于ResNet中的标识映射。这将26×26×512特征映射转换为13×13×2048特征映射，其可以与原始特征连接。
    在这里插入图片描述

    Multi-Scale Training

    我觉得这个也是yolo为什么性能提升的一个很重要的点，解决了yolo1当中对于多个小物体检测的问题。
    原始的YOLO使用448×448的输入分辨率。添加anchor box后，我们将分辨率更改为416×416。然而，由于我们的模型只使用卷积层和池化层,相比yolo1删除了全连接层，它可以在运行中调整大小（应该是使用了1x1卷积不过我没看代码）。我们希望YOLOv2能够在不同大小的图像上运行，因此我们将其训练到模型中。
    instead of fixing the input image size we change the network every few iterations. Every 10 batches our network randomly chooses a new image dimension size.
    不固定输入图像的大小，我们每隔几次迭代就更改网络。在每10个batch之后，我们的网络就会随机resize成{320, 352, …, 608}中的一种。不同的输入，最后产生的格点数不同，比如输入图片是320320，那么输出格点是1010，如果每个格点的先验框个数设置为5，那么总共输出500个预测结果；如果输入图片大小是608608，输出格点就是1919，共1805个预测结果。
    YOLO’s convolutional layers downsample the image by a factor of 32 so by using an input image of 416 we get an output feature map of 13 × 13.
    We do this because we want an odd number of locations in our feature map so there is a single center cell.
    关于416×416也是有说法的，主要是下采样是32的倍数，而且最后的输出是13x13是奇数然后会有一个中心点更加易于目标检测。
    这种训练方法迫使网络学习在各种输入维度上很好地预测。这意味着相同的网络可以预测不同分辨率的检测。
    关于yolov2最大的一个提升还有一个原因就是WordTree组合数据集的训练方法，不过这里我就不再赘述，可以看参考资料有详细介绍，这里主要讲网络和思路

    yolov3论文改进

    yolov3的论文改进就有很多方面了，而且yolov3-spp的网络效果很不错，和yolov4，yolov5的效果差别也不是特别大，这也是为什么yolov3网络被广泛应用的原因之一。

    backbone：Darknet-53

    相比yolov1的网络，在网络上有了很大的改进，借鉴了Resnet、Densenet、FPN的做法结合了当前网络中十分有效的
    在这里插入图片描述
    1.Yolov3中，全卷积，对于输入图片尺寸没有特别限制，可通过调节卷积步长控制输出特征图的尺寸。
    2.Yolov3借鉴了金字塔特征图思想，小尺寸特征图用于检测大尺寸物体，而大尺寸特征图检测小尺寸物体。特征图的输出维度为$N \times N \times (3 \times (4+1+80))$， NxN为输出特征图格点数，一共3个Anchor框，每个框有4维预测框数值 $t_x,t_y,t_w,t_h$ ，1维预测框置信度，80维物体类别数。所以第一层特征图的输出维度为8x8x255
    3.Yolov3总共输出3个特征图，第一个特征图下采样32倍，第二个特征图下采样16倍，第三个下采样8倍。每个特征图进行一次3X3、步长为2的卷积，然后保存该卷积layer，再进行一次1X1的卷积和一次3X3的卷积，并把这个结果加上layer作为最后的结果。三个特征层进行5次卷积处理，处理完后一部分用于输出该特征层对应的预测结果，一部分用于进行反卷积UmSampling2d后与其它特征层进行结合。
    4.concat和resiual加操作，借鉴DenseNet将特征图按照通道维度直接进行拼接，借鉴Resnet添加残差边，缓解了在深度神经网络中增加深度带来的梯度消失问题。
    5.上采样层(upsample)：作用是将小尺寸特征图通过插值等方法，生成大尺寸图像。例如使用最近邻插值算法，将88的图像变换为1616。上采样层不改变特征图的通道数。

    对于yolo3的模型来说，网络最后输出的内容就是三个特征层每个网格点对应的预测框及其种类，即三个特征层分别对应着图片被分为不同size的网格后，每个网格点上三个先验框对应的位置、置信度及其种类。然后对输出进行解码，解码过程也就是yolov2上面的Direct location prediction方法一样，每个网格点加上它对应的x_offset和y_offset，加完后的结果就是预测框的中心，然后再利用 先验框和h、w结合 计算出预测框的长和宽。这样就能得到整个预测框的位置了。

    CIoU loss

    在yolov3当中我们使用的不再是传统的IoU loss，而是一个非常优秀的loss设计，整个发展过程也可以多了解了解IoU->GIoU->DIoU->CIoU，完整的考虑了重合面积，中心点距离，长宽比。

    其中， $b$ ， $b^{gt}$ 分别代表了预测框和真实框的中心点，且 $\rho$代表的是计算两个中心点间的欧式距离。 [公式] 代表的是能够同时包含预测框和真实框的最小闭包区域的对角线距离。
    在介绍CIoU之前，我们可以先介绍一下DIoU loss
    在这里插入图片描述
    其实这两项就是我们的DIoU

    则我们可以提出DIoU loss函数

    DloU损失能够直接最小化两个boxes之间的距离，因此收敛速度更快。
    而我们的CIoU则比DIoU考虑更多的东西，也就是长宽比即最后一项。而$v$用来度量长宽比的相似性,$\alpha$是权重
    在损失函数这块，有知乎大佬写了一下，其实就是对yolov1上的损失函数进行了一下变形。
    在这里插入图片描述

    Spatial Pyramid Pooling

    在yolov3的spp版本中使用了spp模块，实现了不同尺度的特征融合，spp模块最初来源于何凯明大神的论文SPP-net，主要用来解决输入图像尺寸不统一的问题，而目前的图像预处理操作中，resize，crop等都会造成一定程度的图像失真，因此影响了最终的精度。SPP模块，使用固定分块的池化操作，可以对不同尺寸的输入实现相同大小的输出，因此能够避免这一问题。
    同时SPP模块中不同大小特征的融合，有利于待检测图像中目标大小差异较大的情况，也相当于增大了多重感受野吧，尤其是对于yolov3一般针对的复杂多目标图像。
    在yolov3的darknet53输出到第一个特征图计算之前我们插入了一个spp模块。
    在这里插入图片描述
    SPP的这几个模块stride=1，而且会对外补padding，所以最后的输出特征图大小是一致的，然后在深度方向上进行concatenate，使得深度增大了4倍。
    在这里插入图片描述
    在这里插入图片描述
    可以看出随着输入网络尺度的增大，spp的效果会更好。多个spp的效果增大也就是spp3和spp1的效果是差不多的，为了保证推理速度就只使用了一个spp

    Mosaic图像增强

    在yolov3-spp包括yolov4当中我们都使用了mosaic数据增强，有点类似cutmix。cutmix是合并两张图片进行预测，mosaic数据增强利用了四张图片，对四张图片进行拼接，每一张图片都有其对应的框框，将四张图片拼接之后就获得一张新的图片，同时也获得这张图片对应的框框，然后我们将这样一张新的图片传入到神经网络当中去学习，相当于一下子传入四张图片进行学习了。论文中说这极大丰富了检测物体的背景，且在标准化BN计算的时候一下子会计算四张图片的数据。
    在这里插入图片描述
    作用：增加数据的多样性，增加目标个数，BN能一次性归一化多张图片组合的分布，会更加接近原数据的分布。

    focal loss

    最后我们提一下focal loss，虽然在原论文当中作者说focal loss效果反而下降了，但是我认为还是有必要了解一下何凯明的这篇bestpaper。作者提出focal loss的出发点也是希望one-stage detector可以达到two-stage detector的准确率，同时不影响原有的速度。作者认为造成这种情况的原因是样本的类别不均衡导致的。
    对于二分类的CrossEntropy，我们有如下表示方法：

    我们定义$p_t$：

    则重写交叉熵

    接着我们提出改进思路就是在计算CE时添加了一个平衡因子，是一个可训练的参数

    其中

    相当于给正负样本加上权重，负样本出现的频次多，那么就降低负样本的权重，正样本数量少，就相对提高正样本的权重。因此可以通过设定a的值来控制正负样本对总的loss的共享权重。a取比较小的值来降低负样本（多的那类样本）的权重。
    但是何凯明认为这个还是不能完全解决样本不平衡的问题，虽然这个平衡因子可以控制正负样本的权重，但是没法控制容易分类和难分类样本的权重

    As our experiments will show, the large class imbalance encountered during training of dense detectors overwhelms the cross entropy loss. Easily classified negatives comprise the majority of the loss and dominate the gradient. While
    α balances the importance of positive/negative examples, it does not differentiate between easy/hard examples. Instead, we propose to reshape the loss function to down-weight easy examples and thus focus training on hard negatives

    于是提出了一种新的损失函数Focal Loss

    在这里插入图片描述

    focal loss的两个重要性质

    1、当一个样本被分错的时候，pt是很小的，那么调制因子（1-Pt）接近1，损失不被影响；当Pt→1，因子（1-Pt）接近0，那么分的比较好的（well-classified）样本的权值就被调低了。因此调制系数就趋于1，也就是说相比原来的loss是没有什么大的改变的。当pt趋于1的时候（此时分类正确而且是易分类样本），调制系数趋于0，也就是对于总的loss的贡献很小。

    2、当γ=0的时候，focal loss就是传统的交叉熵损失，当γ增加的时候，调制系数也会增加。 专注参数γ平滑地调节了易分样本调低权值的比例。γ增大能增强调制因子的影响，实验发现γ取2最好。直觉上来说，调制因子减少了易分样本的损失贡献，拓宽了样例接收到低损失的范围。当γ一定的时候，比如等于2，一样easy example(pt=0.9)的loss要比标准的交叉熵loss小100+倍，当pt=0.968时，要小1000+倍，但是对于hard example(pt < 0.5)，loss最多小了4倍。这样的话hard example的权重相对就提升了很多。这样就增加了那些误分类的重要性

    focal loss的两个性质算是核心，其实就是用一个合适的函数去度量难分类和易分类样本对总的损失的贡献。

    然后作者又提出了最终的focal loss形式

    这样既能调整正负样本的权重，又能控制难易分类样本的权重
    在实验中a的选择范围也很广，一般而言当γ增加的时候，a需要减小一点（实验中γ=2，a=0.25的效果最好）

    总结

    yolo和yolov2的严谨数学推理和网络相结合的做法令人十分惊艳，而yolov3相比之前的两个版本不管是在数据处理还是网络性质上都有很大的改变，也使用了很多流行的tirck来实现目标检测，基本上结合了很多cv领域的精髓，博客中有很多部分由于时间关系没有太细讲，其实每个部分都可以去原论文中找到很多可以学习的地方，之后有时候会补上yolov4和yolov5的讲解，后面的网络添加了注意力机制模块效果应该是更加work的。

    参考文献

    yolov3-spp
    focal loss
    batch normal
    IoU系列
    yolov1论文翻译
    yolo1-3三部曲
    Bubbliiiing的教程里
    还有很多但是没找到之后会补上的

    ]]>     - <h2 id="yolov1-3论文解析"><a href="#yolov1-3论文解析" class="headerlink" title="yolov1-3论文解析"></a>yolov1-3论文解析</h2><p>最近在看经典目标检测算法yolo的思想，为了更好的了解yolo系列的相关文章，我从最初版本的论文思想开始看的，之后有时间会把yolov4和yolov5再认真看看，目前来说yolov3的spp版本是使用得最为广泛的一种，整体上来说yolo的设计思想还是很有创造性的数学也比较严谨。</p> + <h2 id="yolov1-3论文解析"><a href="#yolov1-3论文解析" class="headerlink" title="yolov1-3论文解析"></a>yolov1-3论文解析</h2><p>最近在看经典目标检测算法yolo的思想，为了更好的了解yolo系列的相关文章，我从最初版本的论文思想开始看的，之后有时间会把yolov4和yolov5再认真看看，目前来说yolov3的spp版本是使用得最为广泛的一种，整体上来说yolo的设计思想还是很有创造性的数学也比较严谨。<br></p> @@ -377,7 +377,7 @@ 2021-04-12T00:39:00.000Z 2024-10-09T07:33:09.887Z - MTCNN人脸检测和pytorch代码实现解读

    传送门

    论文地址：https://arxiv.org/ftp/arxiv/papers/1604/1604.02878.pdf
    我的论文笔记：https://khany.top/file/paper/mtcnn.pdf
    本文csdn链接：https://blog.csdn.net/Jack___E/article/details/115601474
    github参考：https://github.com/Sierkinhane/mtcnn-pytorch
    github参考：https://github.com/GitHberChen/MTCNN_Pytorch

    abstract

    abstract—Face detection and alignment in unconstrained environment are challenging due to various poses, illuminations and occlusions. Recent studies show that deep learning approaches can achieve impressive performance on these two tasks. In this paper, we propose a deep cascaded multi-task framework which exploits the inherent correlation between detection and alignment
    to boost up their performance. In particular, our framework leverages a cascaded architecture with three stages of carefully designed deep convolutional networks to predict face and landmark location in a coarse-to-fine manner. In addition, we propose a new online hard sample mining strategy that further improves the performance in practice. Our method achieves superior accuracy over the state-of-the-art techniques on the challenging FDDB and WIDER FACE benchmarks for face detection, and AFLW benchmark for face alignment, while keeps real time performance.

    在无约束条件的环境下进行人脸检测和校准人脸检测和校准是非常具挑战性的，因为你要考虑复杂的姿势，光照因素以及面部遮挡问题的影响，最近的研究表明，使用深度学习的方法能够在这两项任务上有不错的效果。本文作者探索和研究了人脸检测和校准之间的内在联系，提出了一个深层级的多任务框架有效提升了网络的性能。我们的深层级联合架构包含三个阶段的卷积神经网络从粗略到细致逐步实现人脸检测和面部特征点标记。此外，我们还提出了一种新的线上进行困难样本的预测的策略可以在实际使用过程中有效提升网络的性能。我们的方法目前在FDDB和WIDER FACE人脸检测任务和AFLW面部对准任务上超越了最佳模型方法的性能标准，同时该模型具有不错的实时检测效果。

    my English is not so well，if there are some mistakes in translations, please contact me in blog comments.

    简介

    人脸检测和脸部校准任务对于很多面部任务和应用来说都是十分重要的，比如说人脸识别，人脸表情分析。不过在现实生活当中，面部特征时常会因为一些遮挡物，强烈的光照对比，复杂的姿势发生很大的变化，这使得这些任务变得具有很大挑战性。Viola和Jones 提出的级联人脸检测器利用Haar特征和AdaBoost训练级联分类器，实现了具有实时效率的良好性能。 然而，也有相当一部分的工作表明，这种分类器可能在现实生活的应用中效果显着降低，即使具有更高级的特征和分类器。，之后人们又提出了DPM的方式，这些年来基于CNN的一些解决方案也层出不穷，基于CNN的方案主要是为了识别出面部的一些特征来实现。作者认为这种方式其实是需要花费更多的时间来对面部进行校准来训练同时还忽略了面部的重要特征点位置和边框问题。
    对于人脸校准的话目前也有大致的两个方向：一个是基于回归的方法还有一个就是基于模板拟合的方式进行，主要是对特征识别起到一个辅助的工作。
    作者认为关于人脸识别和面部对准这两个任务其实是有内在关联的，而目前大多数的方法则忽略了这一点，所以本文所提出的方案就是将这两者都结合起来，构建出一个三阶段的模型实现一个端到端的人脸检测并校准面部特征点的过程。
    第一阶段：通过浅层CNN快速生成候选窗口。
    第二阶段：通过more complex的CNN拒绝大量非面部窗口来细化窗口。
    第三阶段：使用more powerful的CNN再次细化结果并输出五个面部标志位置。

    方法

    Image pyramid图像金字塔

    在进入stage-1之前，作者先构建了一组多尺度的图像金字塔缩放，这一块要理解起来还是有一点费力的，这里我们需要了解的是在训练网络的过程当中，作者都是把WIDER FACE的图片随机剪切成12x12size的大小进行单尺度训练的，不能满足任意大小的人脸检测，所以为了检测到不同尺寸的人脸，所以在推理时需要先生成图像金字塔生成一组不同scale的图像输入P-net进行来实现人脸的检测，同时也这是为什么P-net要使用FCN的原因。
    在这里插入图片描述

    def calculateScales(img):
    min_face_size = 20 # 最小的人脸尺寸
    width, height = img.size
    min_length = min(height, width)
    min_detection_size = 12
    factor = 0.707  # sqrt(0.5)
    scales = []
    m = min_detection_size / min_face_size
    min_length *= m
    factor_count = 0
    # 图像尺寸缩小到不大于min_detection_size
    while min_length > min_detection_size:
        scales.append(m * factor ** factor_count)
        min_length *= factor
        factor_count += 1

    $$\text{length} =\text{length} \times (\frac{\text{min detection size}}{\text{min face size}} )\times factor^{count} $$
    $\text{here we define in our code:} factor=\frac{1}{\sqrt{2}}, \text{min face size}=20,\text{min detection size}=12$

    min_face_size和factor对推理过程会产生什么样的影响？
    min_face_size越大，factor越小，图像最短边就越快缩放到接近min_detect_size,从而生成图像金字塔的耗时就越短，同时各尺度的跨度也更大。因此，加大min_face_size、减小factor能加速图像金字塔的生成，但同时也更易造成漏检。

    Stage 1 P-Net(Proposal Network)

    这是一个全卷积网络，也就是说这个网络可以兼容任意大小的输入，他的整个网络其实十分简单，该层的作用主要是为了获得人脸检测的大量候选框，这一层我们最大的作用就是要尽可能的提升recall，然后在获得许多候选框后再使用非极大抑制的方法合并高度重叠的候选区域。
    在这里插入图片描述
    P-Net的示意图当中我们也可以看到的是作者输入12x12大小最终的output为一个1x1x2的face label classification概率和一个1x1x4的boudingbox(左上角和右下角的坐标)以及一个1x1x10的landmark(双眼，鼻子，左右嘴角的坐标)
    注意虽然这里作者举例是12x12的图片大小，但是他的意思并不是说这个P-Net的图片输入大小必须是12，我们可以知道这个网络是FCN，这就意味着不同输入的大小都是可以输入其中的，最后我们所得到的featuremap$[m \times n \times (2+4+10) ]$每一个小像素点映射到输入图像所在的12x12区域是否包含人脸的分类结果,候选框左上和右下基准点以及landmark，然后根据图像金字塔的我们再根据scale和resize的逆过程将其映射到原图像上

    P-net structure

    class P_Net(nn.Module):
        def __init__(self):
            super(P_Net, self).__init__()
            self.pre_layer = nn.Sequential(
                # 12x12x3
                nn.Conv2d(3, 10, kernel_size=3, stride=1),  # conv1
                nn.PReLU(),  # PReLU1
                # 10x10x10
                nn.MaxPool2d(kernel_size=2, stride=2),  # pool1
                # 5x5x10
                nn.Conv2d(10, 16, kernel_size=3, stride=1),  # conv2
                # 3x3x16
                nn.PReLU(),  # PReLU2
                nn.Conv2d(16, 32, kernel_size=3, stride=1),  # conv3
                # 1x1x32
                nn.PReLU()  # PReLU3
            )
            # detection
            self.conv4_1 = nn.Conv2d(32, 1, kernel_size=1, stride=1)
            # bounding box regresion
            self.conv4_2 = nn.Conv2d(32, 4, kernel_size=1, stride=1)
            # landmark localization
            self.conv4_3 = nn.Conv2d(32, 10, kernel_size=1, stride=1)
            # weight initiation with xavier
            self.apply(weights_init)

        def forward(self, x):
            x = self.pre_layer(x)
            det = torch.sigmoid(self.conv4_1(x))
            box = self.conv4_2(x)
            landmark = self.conv4_3(x)
            # det:[,2,1,1], box:[,4,1,1], landmark:[,10,1,1]
            return det, box, landmark

    这里要提一下nn.PReLU()，有点类似Leaky ReLU，可以看下面的博客深入了解一下
    在这里插入图片描述

    https://blog.csdn.net/qq_23304241/article/details/80300149
    https://blog.csdn.net/shuzfan/article/details/51345832

    然后在P-Net之后我们通过非极大抑制的方法和将所有的boudingbox都修正为框的最长边为边长的正方形框，主要是避免后面的Rnet在resize的时候因为尺寸原因出现信息的损失。
    在这里插入图片描述

    Non-Maximum Suppression非极大抑制

    其实关于非极大抑制这个trick最初是在目标检测任务当中提出的来的，其思想是搜素局部最大值，抑制极大值，主要用在目标检测当中，最传统的非极大抑制所采用的评价指标就是交并比IoU(intersection-over-union)即两个groud truth和bounding box的交集部分除以它们的并集.
    在这里插入图片描述
    $$IoU = \frac{area(C) \cap area(G)}{area(C) \cup area(G)}$$

    def IoU(box, boxes):
        """Compute IoU between detect box and gt boxes

        Parameters:
        ----------
        box: numpy array , shape (5, ): x1, y1, x2, y2, score
            input box
        boxes: numpy array, shape (n, 4): x1, y1, x2, y2
            input ground truth boxes

        Returns:
        -------
        ovr: numpy.array, shape (n, )
            IoU
        """
        box_area = (box[2] - box[0] + 1) * (box[3] - box[1] + 1)
        area = (boxes[:, 2] - boxes[:, 0] + 1) * (boxes[:, 3] - boxes[:, 1] + 1)
        xx1 = np.maximum(box[0], boxes[:, 0])
        xx2 = np.minimum(box[2], boxes[:, 2])
        yy1 = np.maximum(box[1], boxes[:, 1])
        yy2 = np.minimum(box[3], boxes[:, 3])

        # compute the width and height of the bounding box
        w = np.maximum(0, xx2 - xx1 + 1)
        h = np.maximum(0, yy2 - yy1 + 1)

        inter = w * h
        ovr = np.true_divide(inter,(box_area + area - inter))
        #ovr = inter / (box_area + area - inter)
        return ovr

    使用非极大抑制的前提是，我们已经得到了一组候选框和对应label的置信分数，以及groud truth的信息，通过设定阈值来删除重合度较高的候选框。
    算法流程如下：

    def nms(dets,threshod,mode="Union"):
        """
        greedily select boxes with high confidence
        keep boxes overlap <= thresh
        rule out overlap > thresh
        :param dets: [[x1, y1, x2, y2 score]]
        :param threshod: retain overlap <= thresh
        :return: indexes to keep
        """
        x1 = dets[:,0]
        y1 = dets[;,1]
        x2 = dets[:,2]
        y2 = dets[:,3]

        scores = dets[:,4]

        areas = (x2 - x1 + 1) * (y2 - y1 + 1)
        order = areas.argsort()[::-1] # reverse

        keep=[]

        while order.size()>0:
            i = order[0]
            keep.append(i)
            # A & B left top position 
            xx1 = np.maximun(x1[i],x1[order[1,:]])
            yy1 = np.maximun(y1[i],y1[order[1,:]])
            # A & B right down position
            xx2 = np.minimum(x2[i],x2[order[1,:]])
            yy2 = np.minimum(y2[i], y2[order[1:]])

            w = np.maximum(0.0, xx2 - xx1 + 1)
            h = np.maximum(0.0, yy2 - yy1 + 1)

            inter = w * h

            # cacaulate the IOU between box which have largest score with other boxes
            if mode == "Union":
                # area[i]: the area of largest score
                ovr = inter / (areas[i] + areas[order[1:]] - inter)
            elif mode == "Minimum":
                ovr = inter / np.minimum(areas[i], areas[order[1:]])
            # delete the IoU that higher than threshod 
            inds = np.where(ovr <= threshod)[0]
            order = order[inds + 1] # +1: eliminates the first element in order
        
        return keep

    边框修正

    以最大边作为边长将矩形修正为正方形，同时包含的信息也更多，以免在后面resize输入下一个网络时减少信息的损失。

    def convert_to_square(bboxes):
        """
        Convert bounding boxes to a square form.
        """
        # 将矩形对称扩大为正方形
        square_bboxes = np.zeros_like(bboxes)
        x1, y1, x2, y2 = [bboxes[:, i] for i in range(4)]
        h = y2 - y1 + 1.0
        w = x2 - x1 + 1.0
        max_side = np.maximum(h, w)
        square_bboxes[:, 0] = x1 + w * 0.5 - max_side * 0.5
        square_bboxes[:, 1] = y1 + h * 0.5 - max_side * 0.5
        square_bboxes[:, 2] = square_bboxes[:, 0] + max_side - 1.0
        square_bboxes[:, 3] = square_bboxes[:, 1] + max_side - 1.0
        return square_bboxes

    Stage 2 R-Net(Refine Network)

    R-net的输入是固定的，必须是24x24，所以对于P-net产生的大量boundingbox我们需要先进行resize然后再输入R-Net，在论文中我们了解到该网络层的作用主要是对大量的boundingbox进行有效过滤，获得更加精细的候选框。
    在这里插入图片描述

    R-net structure

    class R_Net(nn.Module):
        def __init__(self):
            super(R_Net, self).__init__()
            self.pre_layer = nn.Sequential(
                # 24x24x3
                nn.Conv2d(3, 28, kernel_size=3, stride=1),  # conv1
                nn.PReLU(),  # prelu1
                # 22x22x28
                nn.MaxPool2d(kernel_size=3, stride=2),  # pool1
                # 10x10x28
                nn.Conv2d(28, 48, kernel_size=3, stride=1),  # conv2
                nn.PReLU(),  # prelu2
                # 8x8x48
                nn.MaxPool2d(kernel_size=3, stride=2),  # pool2
                # 3x3x48
                nn.Conv2d(48, 64, kernel_size=2, stride=1),  # conv3
                # 2x2x64
                nn.PReLU()  # prelu3
            )
            # 2x2x64
            self.conv4 = nn.Linear(64 * 2 * 2, 128)  # conv4
            # 128
            self.prelu4 = nn.PReLU()  # prelu4
            # detection
            self.conv5_1 = nn.Linear(128, 1)
            # bounding box regression
            self.conv5_2 = nn.Linear(128, 4)
            # lanbmark localization
            self.conv5_3 = nn.Linear(128, 10)
            # weight initiation weih xavier
            self.apply(weights_init)

        def forward(self, x):
            x = self.pre_layer(x)
            x = x.view(x.size(0), -1)
            x = self.conv4(x)
            x = self.prelu4(x)
            det = torch.sigmoid(self.conv5_1(x))
            box = self.conv5_2(x)
            landmark = self.conv5_3(x)
            return det, box, landmark

    然后在P-Net之后我们通过非极大抑制的方法和将所有的boudingbox都修正为框的最长边为边长的正方形框，也是避免后面的Onet在resize的时候出现因为尺寸原因出现信息的损失。
    在这里插入图片描述

    Stage 3 O-Net(Output?[作者未指出命名] Network)

    在这里插入图片描述
    Onet与Rnet工作流程类似。只不过输入的尺寸变成了48x48，对于R-net当中的框再次进行处理，得到的网络结构的输出则是最终的label classfication，boundingbox，landmark。
    O-net structure

    class O_Net(nn.Module):
        def __init__(self):
            super(O_Net, self).__init__()
            self.pre_layer = nn.Sequential(
                nn.Conv2d(3, 32, kernel_size=3, stride=1),  # conv1
                nn.PReLU(),  # prelu1
                nn.MaxPool2d(kernel_size=3, stride=2),  # pool1
                nn.Conv2d(32, 64, kernel_size=3, stride=1),  # conv2
                nn.PReLU(),  # prelu2
                nn.MaxPool2d(kernel_size=3, stride=2),  # pool2
                nn.Conv2d(64, 64, kernel_size=3, stride=1),  # conv3
                nn.PReLU(),  # prelu3
                nn.MaxPool2d(kernel_size=2, stride=2),  # pool3
                nn.Conv2d(64, 128, kernel_size=2, stride=1),  # conv4
                nn.PReLU()  # prelu4
            )
            self.conv5 = nn.Linear(128 * 2 * 2, 256)  # conv5
            self.prelu5 = nn.PReLU()  # prelu5
            # detection
            self.conv6_1 = nn.Linear(256, 1)
            # bounding box regression
            self.conv6_2 = nn.Linear(256, 4)
            # lanbmark localization
            self.conv6_3 = nn.Linear(256, 10)
            # weight initiation weih xavier
            self.apply(weights_init)

        def forward(self, x):
            x = self.pre_layer(x)
            x = x.view(x.size(0), -1)
            x = self.conv5(x)
            x = self.prelu5(x)
            # detection
            det = torch.sigmoid(self.conv6_1(x))
            box = self.conv6_2(x)
            landmark = self.conv6_3(x)
            return det, box, landmark

    在这里插入图片描述
    注意，其实在之前的两个网络当中我们也预测了landmark的位置，只是在论文的图示当中没有展示而已，从作者描述的网络结构图的输出当中是详细指出了landmarkposition的卷积块的

    损失函数

    在研究完网络结构以后我们可以来看看这个mtcnn模型的一个损失函数，作者将损失函数分为了3个部分：Face classification、Bounding box regression、Facial landmark localization。

    Face classification

    对于第一部分的损失就是用的是最常用的交叉熵损失函数，就本质上来说人脸识别还是一个二分类问题，这里就使用Cross Entropy是最简单也是最合适的选择。
    $$L_i^{det} = -(y_i^{det} \log(p_i) + (1-y_i^det)(1-\log(p_i)))$$
    $p_i$是预测为face的可能性，$y_i^{det}$指的是真实标签也就是groud truth label

    Bounding box regression

    对于目标边界框的损失来说，对于每一个候选框我们都需要对与他最接近的真实目标边界框进行比较，the bounding box$（left, top, height, and width）$
    $$L_i^{box} = ||y_j^{box}-y_i^{box} ||_2^2$$

    Facial landmark localization

    而对于boundingbox和landmark来说整个框的调整过程其实可以看作是一个连续的变化过程，固使用的是欧氏距离回归损失计算方法。比较的是各个点的坐标与真实面部关键点坐标的差异。
    $$L_i^{landmark} = ||y_j^{landmark}-y_i^{landmark} ||_2^2$$

    total loss

    最终我们得到的损失函数是有上述这三部分加权而成
    $$\min{\sum_{i=1}^{N}{\sum_{j \in {det,box,landmark}} \alpha_j \beta_i^j L_i^j}}$$
    其中$\alpha_j$表示权重，$\beta_i^j$表示第i个样本的类型，也可以说是第i个样本在任务j中是否需要贡献loss，如果不存在人脸即label为0时则无需计算loss。
    对于不同的网络我们所设置的权重是不一样的
    in P-net & R-net(在这两层我们更注重classification的识别)
    $$alpha_{det}=1, alpha_{box}=0.5,alpha_{landmark}=0.5$$
    in O-net(在这层我们提高了对于注意关键点的预测精度)
    $$alpha_{det}=1, alpha_{box}=0.5,alpha_{landmark}=1 $$
    文中也有提到，采用的是随机梯度下降优化器进行的训练。

    OHEM（Online Hard Example Mining）

    作者对于困难样本的在线预测所做的trick也比较简单，就是挑选损失最大的前70%作为困难样本，在反向传播时仅使用这70%困难样本产生的损失，这样就剔除了很容易预测的easy sample对训练结果的影响，不过在我参考的这两个版本的代码里面似乎没有这么做。

    实验

    实验这块的话也比较充分，验证了每个修改部分对于实验结果的有效性验证，主要是讲述了实验过程对于训练数据集的处理和划分，验证了在线硬样本挖掘的有效性，联合检测和校准的有效性，分别评估了face detection和lanmark的贡献，面部检测评估，面部校准评估以及与SOTA的对比，这一块的话就没有细看了，分享的网站也有详细解释，论文原文也写了。
    在这里插入图片描述
    在这里插入图片描述

    总结

    这篇论文是中科院深圳先进技术研究院的乔宇老师团队所作，2016ECCV，看完这篇文章的话给我的感觉的话就是idea和实现过程包括实验都是很充分的，创新点这块的话主要是挖掘了人脸特征关键点和目标检测的一些联系，结合了人脸检测和对准两个任务来进行人脸检测，相比其他经典的目标检测网络如yolov3,R-CNN系列，在网络和损失函数上的创新确实略有不足，但是也让我收到了一些启发，看似几个简单的model和常见的loss联合，在对数据进行有效处理的基础上也是可以实现达到十分不错的效果的，不过这个方案的话在训练的时候其实是很花费时间的，毕竟需要对于不同scale的图片都进行输入训练，然后就是这种输入输出的结构其实还是存在一些局限性的，对于图像检测框和关键点的映射我个人觉得也比较繁杂或者说浪费了一些时间，毕竟是一篇2016年的论文之后应该会有更好的实现方式。

    参考资料

    参考链接： https://zhuanlan.zhihu.com/p/337690783
    参考链接：https://zhuanlan.zhihu.com/p/60199964?utm_source=qq&utm_medium=social&utm_oi=1221207556791963648
    参考链接： https://blog.csdn.net/weixin_44791964/article/details/103530206
    参考链接：https://blog.csdn.net/qq_34714751/article/details/85536669
    参考链接：https://www.bilibili.com/video/BV1fJ411C7AJ?from=search&seid=2691296178499711503

    ]]>     + MTCNN人脸检测和pytorch代码实现解读

    传送门

    论文地址：https://arxiv.org/ftp/arxiv/papers/1604/1604.02878.pdf
    我的论文笔记：https://khany.top/file/paper/mtcnn.pdf
    本文csdn链接：https://blog.csdn.net/Jack___E/article/details/115601474
    github参考：https://github.com/Sierkinhane/mtcnn-pytorch
    github参考：https://github.com/GitHberChen/MTCNN_Pytorch

    abstract

    abstract—Face detection and alignment in unconstrained environment are challenging due to various poses, illuminations and occlusions. Recent studies show that deep learning approaches can achieve impressive performance on these two tasks. In this paper, we propose a deep cascaded multi-task framework which exploits the inherent correlation between detection and alignment
    to boost up their performance. In particular, our framework leverages a cascaded architecture with three stages of carefully designed deep convolutional networks to predict face and landmark location in a coarse-to-fine manner. In addition, we propose a new online hard sample mining strategy that further improves the performance in practice. Our method achieves superior accuracy over the state-of-the-art techniques on the challenging FDDB and WIDER FACE benchmarks for face detection, and AFLW benchmark for face alignment, while keeps real time performance.

    在无约束条件的环境下进行人脸检测和校准人脸检测和校准是非常具挑战性的，因为你要考虑复杂的姿势，光照因素以及面部遮挡问题的影响，最近的研究表明，使用深度学习的方法能够在这两项任务上有不错的效果。本文作者探索和研究了人脸检测和校准之间的内在联系，提出了一个深层级的多任务框架有效提升了网络的性能。我们的深层级联合架构包含三个阶段的卷积神经网络从粗略到细致逐步实现人脸检测和面部特征点标记。此外，我们还提出了一种新的线上进行困难样本的预测的策略可以在实际使用过程中有效提升网络的性能。我们的方法目前在FDDB和WIDER FACE人脸检测任务和AFLW面部对准任务上超越了最佳模型方法的性能标准，同时该模型具有不错的实时检测效果。

    my English is not so well，if there are some mistakes in translations, please contact me in blog comments.

    简介

    人脸检测和脸部校准任务对于很多面部任务和应用来说都是十分重要的，比如说人脸识别，人脸表情分析。不过在现实生活当中，面部特征时常会因为一些遮挡物，强烈的光照对比，复杂的姿势发生很大的变化，这使得这些任务变得具有很大挑战性。Viola和Jones 提出的级联人脸检测器利用Haar特征和AdaBoost训练级联分类器，实现了具有实时效率的良好性能。 然而，也有相当一部分的工作表明，这种分类器可能在现实生活的应用中效果显着降低，即使具有更高级的特征和分类器。，之后人们又提出了DPM的方式，这些年来基于CNN的一些解决方案也层出不穷，基于CNN的方案主要是为了识别出面部的一些特征来实现。作者认为这种方式其实是需要花费更多的时间来对面部进行校准来训练同时还忽略了面部的重要特征点位置和边框问题。
    对于人脸校准的话目前也有大致的两个方向：一个是基于回归的方法还有一个就是基于模板拟合的方式进行，主要是对特征识别起到一个辅助的工作。
    作者认为关于人脸识别和面部对准这两个任务其实是有内在关联的，而目前大多数的方法则忽略了这一点，所以本文所提出的方案就是将这两者都结合起来，构建出一个三阶段的模型实现一个端到端的人脸检测并校准面部特征点的过程。
    第一阶段：通过浅层CNN快速生成候选窗口。
    第二阶段：通过more complex的CNN拒绝大量非面部窗口来细化窗口。
    第三阶段：使用more powerful的CNN再次细化结果并输出五个面部标志位置。

    方法

    Image pyramid图像金字塔

    在进入stage-1之前，作者先构建了一组多尺度的图像金字塔缩放，这一块要理解起来还是有一点费力的，这里我们需要了解的是在训练网络的过程当中，作者都是把WIDER FACE的图片随机剪切成12x12size的大小进行单尺度训练的，不能满足任意大小的人脸检测，所以为了检测到不同尺寸的人脸，所以在推理时需要先生成图像金字塔生成一组不同scale的图像输入P-net进行来实现人脸的检测，同时也这是为什么P-net要使用FCN的原因。
    在这里插入图片描述

    def calculateScales(img):
    min_face_size = 20 # 最小的人脸尺寸
    width, height = img.size
    min_length = min(height, width)
    min_detection_size = 12
    factor = 0.707  # sqrt(0.5)
    scales = []
    m = min_detection_size / min_face_size
    min_length *= m
    factor_count = 0
    # 图像尺寸缩小到不大于min_detection_size
    while min_length > min_detection_size:
        scales.append(m * factor ** factor_count)
        min_length *= factor
        factor_count += 1

    $\text{here we define in our code:} factor=\frac{1}{\sqrt{2}}, \text{min face size}=20,\text{min detection size}=12$

    min_face_size和factor对推理过程会产生什么样的影响？
    min_face_size越大，factor越小，图像最短边就越快缩放到接近min_detect_size,从而生成图像金字塔的耗时就越短，同时各尺度的跨度也更大。因此，加大min_face_size、减小factor能加速图像金字塔的生成，但同时也更易造成漏检。

    Stage 1 P-Net(Proposal Network)

    这是一个全卷积网络，也就是说这个网络可以兼容任意大小的输入，他的整个网络其实十分简单，该层的作用主要是为了获得人脸检测的大量候选框，这一层我们最大的作用就是要尽可能的提升recall，然后在获得许多候选框后再使用非极大抑制的方法合并高度重叠的候选区域。
    在这里插入图片描述
    P-Net的示意图当中我们也可以看到的是作者输入12x12大小最终的output为一个1x1x2的face label classification概率和一个1x1x4的boudingbox(左上角和右下角的坐标)以及一个1x1x10的landmark(双眼，鼻子，左右嘴角的坐标)
    注意虽然这里作者举例是12x12的图片大小，但是他的意思并不是说这个P-Net的图片输入大小必须是12，我们可以知道这个网络是FCN，这就意味着不同输入的大小都是可以输入其中的，最后我们所得到的featuremap$[m \times n \times (2+4+10) ]$每一个小像素点映射到输入图像所在的12x12区域是否包含人脸的分类结果,候选框左上和右下基准点以及landmark，然后根据图像金字塔的我们再根据scale和resize的逆过程将其映射到原图像上

    P-net structure

    class P_Net(nn.Module):
        def __init__(self):
            super(P_Net, self).__init__()
            self.pre_layer = nn.Sequential(
                # 12x12x3
                nn.Conv2d(3, 10, kernel_size=3, stride=1),  # conv1
                nn.PReLU(),  # PReLU1
                # 10x10x10
                nn.MaxPool2d(kernel_size=2, stride=2),  # pool1
                # 5x5x10
                nn.Conv2d(10, 16, kernel_size=3, stride=1),  # conv2
                # 3x3x16
                nn.PReLU(),  # PReLU2
                nn.Conv2d(16, 32, kernel_size=3, stride=1),  # conv3
                # 1x1x32
                nn.PReLU()  # PReLU3
            )
            # detection
            self.conv4_1 = nn.Conv2d(32, 1, kernel_size=1, stride=1)
            # bounding box regresion
            self.conv4_2 = nn.Conv2d(32, 4, kernel_size=1, stride=1)
            # landmark localization
            self.conv4_3 = nn.Conv2d(32, 10, kernel_size=1, stride=1)
            # weight initiation with xavier
            self.apply(weights_init)

        def forward(self, x):
            x = self.pre_layer(x)
            det = torch.sigmoid(self.conv4_1(x))
            box = self.conv4_2(x)
            landmark = self.conv4_3(x)
            # det:[,2,1,1], box:[,4,1,1], landmark:[,10,1,1]
            return det, box, landmark

    这里要提一下nn.PReLU()，有点类似Leaky ReLU，可以看下面的博客深入了解一下
    在这里插入图片描述

    https://blog.csdn.net/qq_23304241/article/details/80300149
    https://blog.csdn.net/shuzfan/article/details/51345832

    然后在P-Net之后我们通过非极大抑制的方法和将所有的boudingbox都修正为框的最长边为边长的正方形框，主要是避免后面的Rnet在resize的时候因为尺寸原因出现信息的损失。
    在这里插入图片描述

    Non-Maximum Suppression非极大抑制

    其实关于非极大抑制这个trick最初是在目标检测任务当中提出的来的，其思想是搜素局部最大值，抑制极大值，主要用在目标检测当中，最传统的非极大抑制所采用的评价指标就是交并比IoU(intersection-over-union)即两个groud truth和bounding box的交集部分除以它们的并集.
    在这里插入图片描述

    def IoU(box, boxes):
        """Compute IoU between detect box and gt boxes

        Parameters:
        ----------
        box: numpy array , shape (5, ): x1, y1, x2, y2, score
            input box
        boxes: numpy array, shape (n, 4): x1, y1, x2, y2
            input ground truth boxes

        Returns:
        -------
        ovr: numpy.array, shape (n, )
            IoU
        """
        box_area = (box[2] - box[0] + 1) * (box[3] - box[1] + 1)
        area = (boxes[:, 2] - boxes[:, 0] + 1) * (boxes[:, 3] - boxes[:, 1] + 1)
        xx1 = np.maximum(box[0], boxes[:, 0])
        xx2 = np.minimum(box[2], boxes[:, 2])
        yy1 = np.maximum(box[1], boxes[:, 1])
        yy2 = np.minimum(box[3], boxes[:, 3])

        # compute the width and height of the bounding box
        w = np.maximum(0, xx2 - xx1 + 1)
        h = np.maximum(0, yy2 - yy1 + 1)

        inter = w * h
        ovr = np.true_divide(inter,(box_area + area - inter))
        #ovr = inter / (box_area + area - inter)
        return ovr

    使用非极大抑制的前提是，我们已经得到了一组候选框和对应label的置信分数，以及groud truth的信息，通过设定阈值来删除重合度较高的候选框。
    算法流程如下：

    def nms(dets,threshod,mode="Union"):
        """
        greedily select boxes with high confidence
        keep boxes overlap <= thresh
        rule out overlap > thresh
        :param dets: [[x1, y1, x2, y2 score]]
        :param threshod: retain overlap <= thresh
        :return: indexes to keep
        """
        x1 = dets[:,0]
        y1 = dets[;,1]
        x2 = dets[:,2]
        y2 = dets[:,3]

        scores = dets[:,4]

        areas = (x2 - x1 + 1) * (y2 - y1 + 1)
        order = areas.argsort()[::-1] # reverse

        keep=[]

        while order.size()>0:
            i = order[0]
            keep.append(i)
            # A & B left top position 
            xx1 = np.maximun(x1[i],x1[order[1,:]])
            yy1 = np.maximun(y1[i],y1[order[1,:]])
            # A & B right down position
            xx2 = np.minimum(x2[i],x2[order[1,:]])
            yy2 = np.minimum(y2[i], y2[order[1:]])

            w = np.maximum(0.0, xx2 - xx1 + 1)
            h = np.maximum(0.0, yy2 - yy1 + 1)

            inter = w * h

            # cacaulate the IOU between box which have largest score with other boxes
            if mode == "Union":
                # area[i]: the area of largest score
                ovr = inter / (areas[i] + areas[order[1:]] - inter)
            elif mode == "Minimum":
                ovr = inter / np.minimum(areas[i], areas[order[1:]])
            # delete the IoU that higher than threshod 
            inds = np.where(ovr <= threshod)[0]
            order = order[inds + 1] # +1: eliminates the first element in order
        
        return keep

    边框修正

    以最大边作为边长将矩形修正为正方形，同时包含的信息也更多，以免在后面resize输入下一个网络时减少信息的损失。

    def convert_to_square(bboxes):
        """
        Convert bounding boxes to a square form.
        """
        # 将矩形对称扩大为正方形
        square_bboxes = np.zeros_like(bboxes)
        x1, y1, x2, y2 = [bboxes[:, i] for i in range(4)]
        h = y2 - y1 + 1.0
        w = x2 - x1 + 1.0
        max_side = np.maximum(h, w)
        square_bboxes[:, 0] = x1 + w * 0.5 - max_side * 0.5
        square_bboxes[:, 1] = y1 + h * 0.5 - max_side * 0.5
        square_bboxes[:, 2] = square_bboxes[:, 0] + max_side - 1.0
        square_bboxes[:, 3] = square_bboxes[:, 1] + max_side - 1.0
        return square_bboxes

    Stage 2 R-Net(Refine Network)

    R-net的输入是固定的，必须是24x24，所以对于P-net产生的大量boundingbox我们需要先进行resize然后再输入R-Net，在论文中我们了解到该网络层的作用主要是对大量的boundingbox进行有效过滤，获得更加精细的候选框。
    在这里插入图片描述

    R-net structure

    class R_Net(nn.Module):
        def __init__(self):
            super(R_Net, self).__init__()
            self.pre_layer = nn.Sequential(
                # 24x24x3
                nn.Conv2d(3, 28, kernel_size=3, stride=1),  # conv1
                nn.PReLU(),  # prelu1
                # 22x22x28
                nn.MaxPool2d(kernel_size=3, stride=2),  # pool1
                # 10x10x28
                nn.Conv2d(28, 48, kernel_size=3, stride=1),  # conv2
                nn.PReLU(),  # prelu2
                # 8x8x48
                nn.MaxPool2d(kernel_size=3, stride=2),  # pool2
                # 3x3x48
                nn.Conv2d(48, 64, kernel_size=2, stride=1),  # conv3
                # 2x2x64
                nn.PReLU()  # prelu3
            )
            # 2x2x64
            self.conv4 = nn.Linear(64 * 2 * 2, 128)  # conv4
            # 128
            self.prelu4 = nn.PReLU()  # prelu4
            # detection
            self.conv5_1 = nn.Linear(128, 1)
            # bounding box regression
            self.conv5_2 = nn.Linear(128, 4)
            # lanbmark localization
            self.conv5_3 = nn.Linear(128, 10)
            # weight initiation weih xavier
            self.apply(weights_init)

        def forward(self, x):
            x = self.pre_layer(x)
            x = x.view(x.size(0), -1)
            x = self.conv4(x)
            x = self.prelu4(x)
            det = torch.sigmoid(self.conv5_1(x))
            box = self.conv5_2(x)
            landmark = self.conv5_3(x)
            return det, box, landmark

    然后在P-Net之后我们通过非极大抑制的方法和将所有的boudingbox都修正为框的最长边为边长的正方形框，也是避免后面的Onet在resize的时候出现因为尺寸原因出现信息的损失。
    在这里插入图片描述

    Stage 3 O-Net(Output?[作者未指出命名] Network)

    在这里插入图片描述
    Onet与Rnet工作流程类似。只不过输入的尺寸变成了48x48，对于R-net当中的框再次进行处理，得到的网络结构的输出则是最终的label classfication，boundingbox，landmark。
    O-net structure

    class O_Net(nn.Module):
        def __init__(self):
            super(O_Net, self).__init__()
            self.pre_layer = nn.Sequential(
                nn.Conv2d(3, 32, kernel_size=3, stride=1),  # conv1
                nn.PReLU(),  # prelu1
                nn.MaxPool2d(kernel_size=3, stride=2),  # pool1
                nn.Conv2d(32, 64, kernel_size=3, stride=1),  # conv2
                nn.PReLU(),  # prelu2
                nn.MaxPool2d(kernel_size=3, stride=2),  # pool2
                nn.Conv2d(64, 64, kernel_size=3, stride=1),  # conv3
                nn.PReLU(),  # prelu3
                nn.MaxPool2d(kernel_size=2, stride=2),  # pool3
                nn.Conv2d(64, 128, kernel_size=2, stride=1),  # conv4
                nn.PReLU()  # prelu4
            )
            self.conv5 = nn.Linear(128 * 2 * 2, 256)  # conv5
            self.prelu5 = nn.PReLU()  # prelu5
            # detection
            self.conv6_1 = nn.Linear(256, 1)
            # bounding box regression
            self.conv6_2 = nn.Linear(256, 4)
            # lanbmark localization
            self.conv6_3 = nn.Linear(256, 10)
            # weight initiation weih xavier
            self.apply(weights_init)

        def forward(self, x):
            x = self.pre_layer(x)
            x = x.view(x.size(0), -1)
            x = self.conv5(x)
            x = self.prelu5(x)
            # detection
            det = torch.sigmoid(self.conv6_1(x))
            box = self.conv6_2(x)
            landmark = self.conv6_3(x)
            return det, box, landmark

    在这里插入图片描述
    注意，其实在之前的两个网络当中我们也预测了landmark的位置，只是在论文的图示当中没有展示而已，从作者描述的网络结构图的输出当中是详细指出了landmarkposition的卷积块的

    损失函数

    在研究完网络结构以后我们可以来看看这个mtcnn模型的一个损失函数，作者将损失函数分为了3个部分：Face classification、Bounding box regression、Facial landmark localization。

    Face classification

    对于第一部分的损失就是用的是最常用的交叉熵损失函数，就本质上来说人脸识别还是一个二分类问题，这里就使用Cross Entropy是最简单也是最合适的选择。

    $p_i$是预测为face的可能性，$y_i^{det}$指的是真实标签也就是groud truth label

    Bounding box regression

    对于目标边界框的损失来说，对于每一个候选框我们都需要对与他最接近的真实目标边界框进行比较，the bounding box$（left, top, height, and width）$

    Facial landmark localization

    而对于boundingbox和landmark来说整个框的调整过程其实可以看作是一个连续的变化过程，固使用的是欧氏距离回归损失计算方法。比较的是各个点的坐标与真实面部关键点坐标的差异。

    total loss

    最终我们得到的损失函数是有上述这三部分加权而成

    其中$\alpha_j$表示权重，$\beta_i^j$表示第i个样本的类型，也可以说是第i个样本在任务j中是否需要贡献loss，如果不存在人脸即label为0时则无需计算loss。
    对于不同的网络我们所设置的权重是不一样的
    in P-net & R-net(在这两层我们更注重classification的识别)

    in O-net(在这层我们提高了对于注意关键点的预测精度)

    文中也有提到，采用的是随机梯度下降优化器进行的训练。

    OHEM（Online Hard Example Mining）

    作者对于困难样本的在线预测所做的trick也比较简单，就是挑选损失最大的前70%作为困难样本，在反向传播时仅使用这70%困难样本产生的损失，这样就剔除了很容易预测的easy sample对训练结果的影响，不过在我参考的这两个版本的代码里面似乎没有这么做。

    实验

    实验这块的话也比较充分，验证了每个修改部分对于实验结果的有效性验证，主要是讲述了实验过程对于训练数据集的处理和划分，验证了在线硬样本挖掘的有效性，联合检测和校准的有效性，分别评估了face detection和lanmark的贡献，面部检测评估，面部校准评估以及与SOTA的对比，这一块的话就没有细看了，分享的网站也有详细解释，论文原文也写了。
    在这里插入图片描述
    在这里插入图片描述

    总结

    这篇论文是中科院深圳先进技术研究院的乔宇老师团队所作，2016ECCV，看完这篇文章的话给我的感觉的话就是idea和实现过程包括实验都是很充分的，创新点这块的话主要是挖掘了人脸特征关键点和目标检测的一些联系，结合了人脸检测和对准两个任务来进行人脸检测，相比其他经典的目标检测网络如yolov3,R-CNN系列，在网络和损失函数上的创新确实略有不足，但是也让我收到了一些启发，看似几个简单的model和常见的loss联合，在对数据进行有效处理的基础上也是可以实现达到十分不错的效果的，不过这个方案的话在训练的时候其实是很花费时间的，毕竟需要对于不同scale的图片都进行输入训练，然后就是这种输入输出的结构其实还是存在一些局限性的，对于图像检测框和关键点的映射我个人觉得也比较繁杂或者说浪费了一些时间，毕竟是一篇2016年的论文之后应该会有更好的实现方式。

    参考资料

    参考链接： https://zhuanlan.zhihu.com/p/337690783
    参考链接：https://zhuanlan.zhihu.com/p/60199964?utm_source=qq&utm_medium=social&utm_oi=1221207556791963648
    参考链接： https://blog.csdn.net/weixin_44791964/article/details/103530206
    参考链接：https://blog.csdn.net/qq_34714751/article/details/85536669
    参考链接：https://www.bilibili.com/video/BV1fJ411C7AJ?from=search&seid=2691296178499711503

    ]]>     @@ -401,14 +401,12 @@ 2021-02-24T16:03:00.000Z 2024-10-09T07:33:09.891Z - commit镜像

    在这里插入图片描述

    数据卷操作实战：mysql同步

    mysql运行容器，需要做数据挂载，安装启动mysql是需要配置密码的这一点要注意，所以要去docker hub官方文档上面去看官方配置

    docker pull mysql:5.7

    docker运行，docker run的常用参数这里我们再次回顾一下

    -d 后台运行
    -p 端口映射
    -v 卷挂载
    -e 环境配置
    --name 环境名字

    通过docker hub我们找到了官方的命令：docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag，在修改一下得到我们最终的输入命令

    docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=12345678 --name mysql01 mysql:5.7
    CREATE DATABASE test_db;

    在这里插入图片描述

    在这里插入图片描述
    删除这个镜像后数据则依旧保存下来了
    在这里插入图片描述

    具名/匿名挂载

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    大多数情况下，为了方便，我们会使用具名挂载
    在这里插入图片描述

    Dockerfile

    Dockerfile就是用来构建docker镜像的文件，命令脚本，通过这个脚本可以生成镜像。
    构建步骤

    1. 编写一个Dockerfile

    2. docker build 构建成为一个镜像

    3. docker run 运行镜像

    4. docker push 发布镜像(DockerHub，阿里云镜像)

      这里我们可以先看看Docker Hub官方是怎么做的
      在这里插入图片描述
      在这里插入图片描述
      官方镜像是比较基础的，有很多命令和功能都省去了，所以我们通常需要在基础的镜像上来构建我们自己的镜像
      在这里插入图片描述

    Dockerfile命令

    常用命令用法
    FROM基础镜像，一切从这开始构建
    MAINTAINER镜像是谁写的，姓名+邮箱
    RUN镜像构建的时候需要运行的命令
    ADD添加内容，如tomcat压缩包
    WORKDIR镜像的工作目录
    VOLUME挂载的目录
    CMD指定这个容器启动时要运行的命令，只有最后一个会生效，可被替代
    ENTRYPOINT指定这个容器启动时要运行的命令，可以追加命令
    ONBUILD当构建一个被继承DockerFile这个时候就会执行ONBUILD命令
    COPY类似ADD将文件拷贝到镜像当中
    ENV构建的时候设置环境变量

    在这里插入图片描述

    创建一个自己的centos

    Dockerfile中99%的镜像都来自于这个scratch镜像，然后配置需要的软件和配置来进行构建。

    mkdir dockerfile
    cd dockerfile
    vim mydockerfile-centos

    编写mydockerfile-centos

    FROM centos
    MAINTAINER khan<khany@foxmail.com>
    ENV MYPATH /usr/local
    WORKDIR $MYPATH
    RUN yum -y install vim
    RUN yum -y install net-tools
    EXPOSE 80
    CMD echo $MYPATH
    CMD echo "---end---"
    CMD /bin/bash

    然后我们进入docker build,注意后面一定要有一个.号

    docker build -f mydockerfile-centos  -t mycentos:1.0 .

    然后我们通过docker run -it mycentos:1.0 命令进入我们自己创建的镜像测试运行我们新安装的包和命令是否能正常运行。
    在这里插入图片描述
    我们可以通过 docker history +容器名称/容器id看到这个容器的构建过程。
    在这里插入图片描述

    CMD和ENTRYPOINT区别

    在这里插入图片描述

    dockerfile-cmd-test：

    FROM centos
    CMD ["ls","-a"]

    dockerfile-entrypoint-test：

    FROM centos
    ENTRYPOINT ["ls","-a"]

    执行命令 docker run 容器名称 -l在CMD下会报错，命令会被后面追加的-l替代，而-l并不是有效的linux命令，所以报错，而ENTRYPOINT则是可以追加的则该命令会变为ls -al
    在这里插入图片描述

    发布镜像

    发布到Docker Hub

    1. 地址 https://hub.docker.com/ 注册自己的账号
    2. 确定这个账号可以登录
    3. 在我们服务器上提交自己的镜像
    4. 登录成功，通过push命令提交镜像,记得注意添加版本号
      在这里插入图片描述
      这里出了一点小问题：

    在build自己的镜像的时候添加tag时必须在前面加上自己的dockerhub的username，然后再push就可以了
    在这里插入图片描述

    docker tag 镜像id YOUR_DOCKERHUB_NAME/firstimage
    docker push YOUR_DOCKERHUB_NAME/firstimage

    在这里插入图片描述
    提交成功，可以在docker hub上找到你提交的镜像
    在这里插入图片描述

    阿里云镜像提交

    在阿里云的容器镜像服务里面，创建一个新的镜像仓库，然后就会有详细的教学，做法与docker hub基本一致，提交成功能在镜像版本当中查看到，这里就不再重复讲解了。
    在这里插入图片描述

    Docker镜像操作过程总结

    在这里插入图片描述
    在这里插入图片描述

    参考链接：【狂神说Java】Docker最新超详细版教程通俗易懂

    ]]>     + commit镜像

    在这里插入图片描述

    数据卷操作实战：mysql同步

    mysql运行容器，需要做数据挂载，安装启动mysql是需要配置密码的这一点要注意，所以要去docker hub官方文档上面去看官方配置

    docker pull mysql:5.7

    docker运行，docker run的常用参数这里我们再次回顾一下

    -d 后台运行
    -p 端口映射
    -v 卷挂载
    -e 环境配置
    --name 环境名字

    通过docker hub我们找到了官方的命令：docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag，在修改一下得到我们最终的输入命令

    docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=12345678 --name mysql01 mysql:5.7
    CREATE DATABASE test_db;

    在这里插入图片描述

    在这里插入图片描述
    删除这个镜像后数据则依旧保存下来了
    在这里插入图片描述

    具名/匿名挂载

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    大多数情况下，为了方便，我们会使用具名挂载
    在这里插入图片描述

    Dockerfile

    Dockerfile就是用来构建docker镜像的文件，命令脚本，通过这个脚本可以生成镜像。
    构建步骤

    1. 编写一个Dockerfile
    2. docker build 构建成为一个镜像
    3. docker run 运行镜像

    4. docker push 发布镜像(DockerHub，阿里云镜像)

      这里我们可以先看看Docker Hub官方是怎么做的
      在这里插入图片描述
      在这里插入图片描述
      官方镜像是比较基础的，有很多命令和功能都省去了，所以我们通常需要在基础的镜像上来构建我们自己的镜像
      在这里插入图片描述

    Dockerfile命令

    常用命令用法
    FROM基础镜像，一切从这开始构建
    MAINTAINER镜像是谁写的，姓名+邮箱
    RUN镜像构建的时候需要运行的命令
    ADD添加内容，如tomcat压缩包
    WORKDIR镜像的工作目录
    VOLUME挂载的目录
    CMD指定这个容器启动时要运行的命令，只有最后一个会生效，可被替代
    ENTRYPOINT指定这个容器启动时要运行的命令，可以追加命令
    ONBUILD当构建一个被继承DockerFile这个时候就会执行ONBUILD命令
    COPY类似ADD将文件拷贝到镜像当中
    ENV构建的时候设置环境变量

    在这里插入图片描述

    创建一个自己的centos

    Dockerfile中99%的镜像都来自于这个scratch镜像，然后配置需要的软件和配置来进行构建。

    mkdir dockerfile
    cd dockerfile
    vim mydockerfile-centos

    编写mydockerfile-centos

    FROM centos
    MAINTAINER khan<khany@foxmail.com>
    ENV MYPATH /usr/local
    WORKDIR $MYPATH
    RUN yum -y install vim
    RUN yum -y install net-tools
    EXPOSE 80
    CMD echo $MYPATH
    CMD echo "---end---"
    CMD /bin/bash

    然后我们进入docker build,注意后面一定要有一个.号

    docker build -f mydockerfile-centos  -t mycentos:1.0 .

    然后我们通过docker run -it mycentos:1.0命令进入我们自己创建的镜像测试运行我们新安装的包和命令是否能正常运行。
    在这里插入图片描述
    我们可以通过 docker history +容器名称/容器id看到这个容器的构建过程。
    在这里插入图片描述

    CMD和ENTRYPOINT区别

    在这里插入图片描述

    dockerfile-cmd-test：

    FROM centos
    CMD ["ls","-a"]

    dockerfile-entrypoint-test：
    FROM centos
    ENTRYPOINT ["ls","-a"]

    执行命令docker run 容器名称 -l在CMD下会报错，命令会被后面追加的-l替代，而-l并不是有效的linux命令，所以报错，而ENTRYPOINT则是可以追加的则该命令会变为ls -al
    在这里插入图片描述

    发布镜像

    发布到Docker Hub

    1. 地址 https://hub.docker.com/ 注册自己的账号
    2. 确定这个账号可以登录
    3. 在我们服务器上提交自己的镜像
    4. 登录成功，通过push命令提交镜像,记得注意添加版本号
      在这里插入图片描述
      这里出了一点小问题：
      在build自己的镜像的时候添加tag时必须在前面加上自己的dockerhub的username，然后再push就可以了
      在这里插入图片描述
    docker tag 镜像id YOUR_DOCKERHUB_NAME/firstimage
    docker push YOUR_DOCKERHUB_NAME/firstimage

    在这里插入图片描述
    提交成功，可以在docker hub上找到你提交的镜像
    在这里插入图片描述

    阿里云镜像提交

    在阿里云的容器镜像服务里面，创建一个新的镜像仓库，然后就会有详细的教学，做法与docker hub基本一致，提交成功能在镜像版本当中查看到，这里就不再重复讲解了。
    在这里插入图片描述

    Docker镜像操作过程总结

    在这里插入图片描述
    在这里插入图片描述

    参考链接：【狂神说Java】Docker最新超详细版教程通俗易懂

    ]]>     <h2 id="commit镜像"><a href="#commit镜像" class="headerlink" title="commit镜像"></a>commit镜像</h2><p><img src="https://img-blog.csdnimg.cn/20210224162521454.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0phY2tfX19F,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"></p> -<h2 id="数据卷操作实战：mysql同步"><a href="#数据卷操作实战：mysql同步" class="headerlink" title="数据卷操作实战：mysql同步"></a>数据卷操作实战：mysql同步</h2><p><strong>mysql运行容器，需要做数据挂载，安装启动mysql是需要配置密码的这一点要注意，所以要去docker hub官方文档上面去看官方配置</strong></p> -<figure class="highlight powershell"><table><tr><td class="code"><pre><code class="hljs powershell">docker pull mysql:<span class="hljs-number">5.7</span><br></code></pre></td></tr></table></figure> - +<h2 id="数据卷操作实战：mysql同步"><a href="#数据卷操作实战：mysql同步" class="headerlink" title="数据卷操作实战：mysql同步"></a>数据卷操作实战：mysql同步</h2><p><strong>mysql运行容器，需要做数据挂载，安装启动mysql是需要配置密码的这一点要注意，所以要去docker hub官方文档上面去看官方配置</strong><br><figure class="highlight powershell"><table><tr><td class="code"><pre><code class="hljs powershell">docker pull mysql:<span class="hljs-number">5.7</span><br></code></pre></td></tr></table></figure></p> <p>docker运行，docker run的常用参数这里我们再次回顾一下</p> <figure class="highlight powershell"><table><tr><td class="code"><pre><code class="hljs powershell"><span class="hljs-literal">-d</span> 后台运行<br><span class="hljs-literal">-p</span> 端口映射<br><span class="hljs-literal">-v</span> 卷挂载<br><span class="hljs-literal">-e</span> 环境配置<br>-<span class="hljs-literal">-name</span> 环境名字<br></code></pre></td></tr></table></figure> @@ -427,41 +425,44 @@ 2021-02-24T07:30:00.000Z 2024-10-09T07:33:09.890Z - Docker 常用命令

    帮助命令

    docker version #显示docker版本信息
    docker info #显示docker的系统信息，包括镜像和容器的数量
    docker 命令 --help # 帮助命令

    镜像命令

    1.docker images查看所有本地的主机镜像

    docker images显示字段解释
    REPOSITORY镜像的仓库源
    TAG镜像的标签
    IMAGE ID镜像的id
    CREATED镜像的创建时间
    SIZE镜像的大小
    (base) [root@iZuf69rye0flkbn4kbxrobZ ~]# docker images
    REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
    hello-world   latest    bf756fb1ae65   13 months ago   13.3kB
    (base) [root@iZuf69rye0flkbn4kbxrobZ ~]# docker images --help

    Usage:  docker images [OPTIONS] [REPOSITORY[:TAG]]

    List images

    Options:
      -a, --all             Show all images 
      -q, --quiet           Only show image IDs

    在这里插入图片描述
    2.docker search命令搜索镜像
    搜索镜像可以去docker hub网站上直接搜索，也可以通过命令行来搜索，通过万能帮助命令能更快的看到他的一些用法，这两种方法结果是一样的
    在这里插入图片描述
    在这里插入图片描述

    我们也可以通过--filter来进行条件筛选
    比如docker search mysql --filter=STARS=3000

    (base) [root@iZuf69rye0flkbn4kbxrobZ ~]# docker search mysql --filter=STARS=3000
    NAME      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
    mysql     MySQL is a widely used, open-source relation…   10538     [OK]       
    mariadb   MariaDB is a community-developed fork of MyS…   3935      [OK]

    3.docker pull下载镜像
    这个命令其实信息量很大，这也是docker高明的地方，关于指定版本下载一定要是docker hub官网上面支持和提供的版本
    在这里插入图片描述
    我这里使用了

    docker pull mysql
    docker pull mysql:5.7

    在这里插入图片描述
    4.docker rmi删除镜像
    删除可以通过REPOSITORY来删，也可以通过IMAGE ID来删除
    在这里插入图片描述

    容器命令

    说明：我们有了镜像才可以创建容器，linux，下载一个centos镜像来测试学习

    docker pull centos

    1.新建容器并启动
    通过docker run命令进入下载的centos容器里面后我们可以发现的是，我们的rootname不一样了
    在这里插入图片描述在这里插入图片描述

    2.列出所有运行的容器
    docker ps命令
    在这里插入图片描述
    3.exit退出命令

    exit #直接容器停止并退出
    Ctrl + P + Q  #容器不停止并退出

    在执行exit命令后，我们看到rootname又变回来了
    在这里插入图片描述

    4.删除容器

    docker rm 容器id #删除指定的容器，不能删除正在运行的容器，如果要强制删除，需要使用 rm -f
    docker rm $(docker ps -aq) #删除全部的容器
    docker ps -a -q|xargs docker rm #删除全部容器

    5.启动和停止容器
    在这里插入图片描述

    日志元数据进程查看


    在这里插入图片描述
    1.docker top 容器id查看容器中的进程

    在这里插入图片描述
    2.docker inspect 容器id查看元数据

    3.进入当前正在运行的容器

    方式1： docker exec -it 容器id bashshell并可通过ps -ef查看容器当中的进程

    方式2：docker attach 容器id进入容器，如果当前有正在执行的容器则会直接进入到当前正在执行的进程当中

    在这里插入图片描述

    从容器内拷贝到主机上

    即使容器已经停止也是可以进行拷贝的

    docker cp 容器id:容器内路径 目的主机路径

    在这里插入图片描述

    docker部署nginx

    $ docker search nginx
    $ docker pull nginx
    $ docker run -d --name nginx01 -p 8083:80 nginx
    $ docker ps
    $ curl localhost:8083

    docker stop 后则无法再访问
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    portainer可视化管理

    docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

    在这里插入图片描述
    进入后选择local模式，然后就能看到这个版面了
    在这里插入图片描述
    参考链接：
    【狂神说Java】Docker最新超详细版教程通俗易懂

    ]]>     + Docker 常用命令

    帮助命令

    docker version #显示docker版本信息
    docker info #显示docker的系统信息，包括镜像和容器的数量
    docker 命令 --help # 帮助命令

    镜像命令

    1.docker images查看所有本地的主机镜像

    docker images显示字段解释
    REPOSITORY镜像的仓库源
    TAG镜像的标签
    IMAGE ID镜像的id
    CREATED镜像的创建时间
    SIZE镜像的大小
    (base) [root@iZuf69rye0flkbn4kbxrobZ ~]# docker images
    REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
    hello-world   latest    bf756fb1ae65   13 months ago   13.3kB
    (base) [root@iZuf69rye0flkbn4kbxrobZ ~]# docker images --help

    Usage:  docker images [OPTIONS] [REPOSITORY[:TAG]]

    List images

    Options:
      -a, --all             Show all images 
      -q, --quiet           Only show image IDs

    在这里插入图片描述
    2.docker search命令搜索镜像
    搜索镜像可以去docker hub网站上直接搜索，也可以通过命令行来搜索，通过万能帮助命令能更快的看到他的一些用法，这两种方法结果是一样的
    在这里插入图片描述
    在这里插入图片描述

    我们也可以通过--filter来进行条件筛选
    比如docker search mysql --filter=STARS=3000

    (base) [root@iZuf69rye0flkbn4kbxrobZ ~]# docker search mysql --filter=STARS=3000
    NAME      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
    mysql     MySQL is a widely used, open-source relation…   10538     [OK]       
    mariadb   MariaDB is a community-developed fork of MyS…   3935      [OK]

    3.docker pull下载镜像
    这个命令其实信息量很大，这也是docker高明的地方，关于指定版本下载一定要是docker hub官网上面支持和提供的版本
    在这里插入图片描述
    我这里使用了

    docker pull mysql
    docker pull mysql:5.7

    在这里插入图片描述
    4.docker rmi删除镜像
    删除可以通过REPOSITORY来删，也可以通过IMAGE ID来删除
    在这里插入图片描述

    容器命令

    说明：我们有了镜像才可以创建容器，linux，下载一个centos镜像来测试学习

    docker pull centos

    1.新建容器并启动
    通过docker run命令进入下载的centos容器里面后我们可以发现的是，我们的rootname不一样了
    在这里插入图片描述在这里插入图片描述

    2.列出所有运行的容器
    docker ps命令
    在这里插入图片描述
    3.exit退出命令

    exit #直接容器停止并退出
    Ctrl + P + Q  #容器不停止并退出

    在执行exit命令后，我们看到rootname又变回来了
    在这里插入图片描述

    4.删除容器

    docker rm 容器id #删除指定的容器，不能删除正在运行的容器，如果要强制删除，需要使用 rm -f
    docker rm $(docker ps -aq) #删除全部的容器
    docker ps -a -q|xargs docker rm #删除全部容器

    5.启动和停止容器
    在这里插入图片描述

    日志元数据进程查看


    在这里插入图片描述
    1.docker top 容器id查看容器中的进程

    在这里插入图片描述
    2.docker inspect 容器id查看元数据

    3.进入当前正在运行的容器

    方式1： docker exec -it 容器id bashshell并可通过ps -ef查看容器当中的进程

    方式2：docker attach 容器id进入容器，如果当前有正在执行的容器则会直接进入到当前正在执行的进程当中

    在这里插入图片描述

    从容器内拷贝到主机上

    即使容器已经停止也是可以进行拷贝的

    docker cp 容器id:容器内路径 目的主机路径

    在这里插入图片描述

    docker部署nginx

    $ docker search nginx
    $ docker pull nginx
    $ docker run -d --name nginx01 -p 8083:80 nginx
    $ docker ps
    $ curl localhost:8083

    docker stop 后则无法再访问
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    portainer可视化管理

    docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

    在这里插入图片描述
    进入后选择local模式，然后就能看到这个版面了
    在这里插入图片描述
    参考链接：
    【狂神说Java】Docker最新超详细版教程通俗易懂

    ]]>     <h1 id="Docker-常用命令"><a href="#Docker-常用命令" class="headerlink" title="Docker 常用命令"></a>Docker 常用命令</h1><h2 id="帮助命令"><a href="#帮助命令" class="headerlink" title="帮助命令"></a>帮助命令</h2><figure class="highlight bash"><table><tr><td class="code"><pre><code class="hljs bash">docker version <span class="hljs-comment">#显示docker版本信息</span><br>docker info <span class="hljs-comment">#显示docker的系统信息，包括镜像和容器的数量</span><br>docker 命令 --<span class="hljs-built_in">help</span> <span class="hljs-comment"># 帮助命令</span><br></code></pre></td></tr></table></figure> - <h2 id="镜像命令"><a href="#镜像命令" class="headerlink" title="镜像命令"></a>镜像命令</h2><p><strong>1.<code>docker images</code>查看所有本地的主机镜像</strong></p> +<div class="table-container"> <table> <thead> <tr> -<th align="left">docker images显示字段</th> -<th align="left">解释</th> +<th style="text-align:left">docker images显示字段</th> +<th style="text-align:left">解释</th> </tr> </thead> -<tbody><tr> -<td align="left">REPOSITORY</td> -<td align="left">镜像的仓库源</td> +<tbody> +<tr> +<td style="text-align:left">REPOSITORY</td> +<td style="text-align:left">镜像的仓库源</td> </tr> <tr> -<td align="left">TAG</td> -<td align="left">镜像的标签</td> +<td style="text-align:left">TAG</td> +<td style="text-align:left">镜像的标签</td> </tr> <tr> -<td align="left">IMAGE ID</td> -<td align="left">镜像的id</td> +<td style="text-align:left">IMAGE ID</td> +<td style="text-align:left">镜像的id</td> </tr> <tr> -<td align="left">CREATED</td> -<td align="left">镜像的创建时间</td> +<td style="text-align:left">CREATED</td> +<td style="text-align:left">镜像的创建时间</td> </tr> <tr> -<td align="left">SIZE</td> -<td align="left">镜像的大小</td> +<td style="text-align:left">SIZE</td> +<td style="text-align:left">镜像的大小</td> </tr> -</tbody></table> +</tbody> +</table> +</div> @@ -500,7 +501,7 @@ 2021-02-23T06:55:00.000Z 2024-10-09T07:33:09.889Z - 零基础入门语义分割-Task4 评价函数与损失函数

    本章主要介绍语义分割的评价函数和各类损失函数。

    4 评价函数与损失函数

    4.1 学习目标

    • 掌握常见的评价函数和损失函数Dice、IoU、BCE、Focal Loss、Lovász-Softmax；
    • 掌握评价/损失函数的实践；

    4.2 TP TN FP FN

    在讲解语义分割中常用的评价函数和损失函数之前，先补充一**TP(真正例 true positive) TN(真反例 true negative) FP(假正例 false positive) FN(假反例 false negative)**的知识。在分类问题中，我们经常看到上述的表述方式，以二分类为例，我们可以将所有的样本预测结果分成TP、TN、 FP、FN四类，并且每一类含有的样本数量之和为总样本数量，即TP+FP+FN+TN=总样本数量。其混淆矩阵如下：

    在这里插入图片描述

    上述的概念都是通过以预测结果的视角定义的，可以依据下面方式理解：

    • 预测结果中的正例 → 在实际中是正例 → 的所有样本被称为真正例（TP）<预测正确>

    • 预测结果中的正例 → 在实际中是反例 → 的所有样本被称为假正例（FP）<预测错误>

    • 预测结果中的反例 → 在实际中是正例 → 的所有样本被称为假反例（FN）<预测错误>

    • 预测结果中的反例 → 在实际中是反例 → 的所有样本被称为真反例（TN）<预测正确>

    这里就不得不提及精确率（precision）和召回率（recall）：
    $$
    Precision=\frac{TP}{TP+FP} \
    Recall=\frac{TP}{TP+FN}
    $$
    $Precision$代表了预测的正例中真正的正例所占比例；$Recall$代表了真正的正例中被正确预测出来的比例。

    转移到语义分割任务中来，我们可以将语义分割看作是对每一个图像像素的的分类问题。根据混淆矩阵中的定义，我们亦可以将特定像素所属的集合或区域划分成TP、TN、 FP、FN四类。

    在这里插入图片描述

    以上面的图片为例，图中左子图中的人物区域（黄色像素集合）是我们真实标注的前景信息（target），其他区域（紫色像素集合）为背景信息。当经过预测之后，我们会得到的一张预测结果，图中右子图中的黄色像素为预测的前景（prediction），紫色像素为预测的背景区域。此时，我们便能够将预测结果分成4个部分：

    • 预测结果中的黄色无线区域 → 真实的前景 → 的所有像素集合被称为真正例（TP）<预测正确>

    • 预测结果中的蓝色斜线区域 → 真实的背景 → 的所有像素集合被称为假正例（FP）<预测错误>

    • 预测结果中的红色斜线区域 → 真实的前景 → 的所有像素集合被称为假反例（FN）<预测错误>

    • 预测结果中的白色斜线区域 → 真实的背景 → 的所有像素集合被称为真反例（TN）<预测正确>

    4.3 Dice评价指标

    Dice系数

    Dice系数（Dice coefficient）是常见的评价分割效果的方法之一，同样也可以改写成损失函数用来度量prediction和target之间的距离。Dice系数定义如下：

    $$
    Dice (T, P) = \frac{2 |T \cap P|}{|T| \cup |P|} = \frac{2TP}{FP+2TP+FN}
    $$
    式中：$T$表示真实前景（target），$P$表示预测前景（prediction）。Dice系数取值范围为$[0,1]$，其中值为1时代表预测与真实完全一致。仔细观察，Dice系数与分类评价指标中的F1 score很相似：

    $$
    \frac{1}{F1} = \frac{1}{Precision} + \frac{1}{Recall}
    $$

    $$
    F1 = \frac{2TP}{FP+2TP+FN}
    $$

    所以，Dice系数不仅在直观上体现了target与prediction的相似程度，同时其本质上还隐含了精确率和召回率两个重要指标。

    计算Dice时，将$|T \cap P|$近似为prediction与target对应元素相乘再相加的结果。$|T|$ 和$|P|$的计算直接进行简单的元素求和（也有一些做法是取平方求和），如下示例：
    $$
    |T \cap P| =
    \begin{bmatrix}
    0.01 & 0.03 & 0.02 & 0.02 \
    0.05 & 0.12 & 0.09 & 0.07 \
    0.89 & 0.85 & 0.88 & 0.91 \
    0.99 & 0.97 & 0.95 & 0.97 \
    \end{bmatrix} *
    \begin{bmatrix}
    0 & 0 & 0 & 0 \
    0 & 0 & 0 & 0 \
    1 & 1 & 1 & 1 \
    1 & 1 & 1 & 1 \
    \end{bmatrix} \stackrel{}{\rightarrow}
    \begin{bmatrix}
    0 & 0 & 0 & 0 \
    0 & 0 & 0 & 0 \
    0.89 & 0.85 & 0.88 & 0.91 \
    0.99 & 0.97 & 0.95 & 0.97 \
    \end{bmatrix} \stackrel{sum}{\rightarrow} 7.41
    $$

    $$
    |T| =
    \begin{bmatrix}
    0.01 & 0.03 & 0.02 & 0.02 \
    0.05 & 0.12 & 0.09 & 0.07 \
    0.89 & 0.85 & 0.88 & 0.91 \
    0.99 & 0.97 & 0.95 & 0.97 \
    \end{bmatrix} \stackrel{sum}{\rightarrow} 7.82
    $$

    $$
    |P| =
    \begin{bmatrix}
    0 & 0 & 0 & 0 \
    0 & 0 & 0 & 0 \
    1 & 1 & 1 & 1 \
    1 & 1 & 1 & 1 \
    \end{bmatrix} \stackrel{sum}{\rightarrow} 8
    $$

    Dice Loss

    Dice Loss是在V-net模型中被提出应用的，是通过Dice系数转变而来，其实为了能够实现最小化的损失函数，以方便模型训练，以$1 - Dice$的形式作为损失函数：
    $$
    L = 1-\frac{2 |T \cap P|}{|T| \cup |P|}
    $$
    在一些场合还可以添加上Laplace smoothing减少过拟合：
    $$
    L = 1-\frac{2 |T \cap P| + 1}{|T| \cup |P|+1}
    $$

    代码实现

    import numpy as np

    def dice(output, target):
        '''计算Dice系数'''
        smooth = 1e-6 # 避免0为除数
        intersection = (output * target).sum()
        return (2. * intersection + smooth) / (output.sum() + target.sum() + smooth)

    # 生成随机两个矩阵测试
    target = np.random.randint(0, 2, (3, 3))
    output = np.random.randint(0, 2, (3, 3))

    d = dice(output, target)
    # ----------------------------
    target = array([[1, 0, 0],
           [0, 1, 1],
        [0, 0, 1]])
    output = array([[1, 0, 1],
           [0, 1, 0],
           [0, 0, 0]])
    d = 0.5714286326530524

    4.4 IoU评价指标

    IoU（intersection over union）指标就是常说的交并比，不仅在语义分割评价中经常被使用，在目标检测中也是常用的评价指标。顾名思义，交并比就是指target与prediction两者之间交集与并集的比值：
    $$
    IoU=\frac{T \cap P}{T \cup P}=\frac{TP}{FP+TP+FN}
    $$
    仍然以人物前景分割为例，如下图，其IoU的计算就是使用$intersection / union$。

    targetprediction
    在这里插入图片描述在这里插入图片描述
    Intersection( $T \cap P$)union($T \cup P$)
    在这里插入图片描述在这里插入图片描述

    代码实现

    def iou_score(output, target):
        '''计算IoU指标'''
    intersection = np.logical_and(target, output) 
        union = np.logical_or(target, output) 
        return np.sum(intersection) / np.sum(union)

    # 生成随机两个矩阵测试
    target = np.random.randint(0, 2, (3, 3))
    output = np.random.randint(0, 2, (3, 3))

    d = iou_score(output, target)
    # ----------------------------
    target = array([[1, 0, 0],
           [0, 1, 1],
        [0, 0, 1]])
    output = array([[1, 0, 1],
           [0, 1, 0],
           [0, 0, 0]])
    d = 0.4

    4.5 BCE损失函数

    BCE损失函数（Binary Cross-Entropy Loss）是交叉熵损失函数（Cross-Entropy Loss）的一种特例，BCE Loss只应用在二分类任务中。针对分类问题，单样本的交叉熵损失为：
    $$
    l(\pmb y, \pmb{\hat y})=- \sum_{i=1}^{c}y_i \cdot log\hat y_i
    $$
    式中，$\pmb{y}={y_1,y_2,…,y_c,}$，其中$y_i$是非0即1的数字，代表了是否属于第$i$类，为真实值；$\hat y_i$代表属于第i类的概率，为预测值。可以看出，交叉熵损失考虑了多类别情况，针对每一种类别都求了损失。针对二分类问题，上述公式可以改写为：
    $$
    l(y,\hat y)=-[y \cdot log\hat y +(1-y)\cdot log (1-\hat y)]
    $$
    式中,$y$为真实值，非1即0；$\hat y$为所属此类的概率值，为预测值。这个公式也就是BCE损失函数，即二分类任务时的交叉熵损失。值得强调的是，公式中的$\hat y$为概率分布形式，因此在使用BCE损失前，都应该将预测出来的结果转变成概率值，一般为sigmoid激活之后的输出。

    代码实现

    在pytorch中，官方已经给出了BCE损失函数的API，免去了自己编写函数的痛苦：

    torch.nn.BCELoss(weight: Optional[torch.Tensor] = None, size_average=None, reduce=None, reduction: str = 'mean')
    $$
    ℓ(y,\hat y)=L={l_1,…,l_N }^⊤,\ \ \ l_n=-w_n[y_n \cdot log\hat y_n +(1-y_n)\cdot log (1-\hat y_n)]
    $$
    参数：
    weight(Tensor)- 为每一批量下的loss添加一个权重，很少使用
    size_average(bool)- 弃用中
    reduce(bool)- 弃用中
    reduction(str) - ‘none’ | ‘mean’ | ‘sum’：为代替上面的size_average和reduce而生。——为mean时返回的该批量样本loss的平均值；为sum时，返回的该批量样本loss之和

    同时，pytorch还提供了已经结合了Sigmoid函数的BCE损失：torch.nn.BCEWithLogitsLoss()，相当于免去了实现进行Sigmoid激活的操作。

    import torch
    import torch.nn as nn

    bce = nn.BCELoss()
    bce_sig = nn.BCEWithLogitsLoss()

    input = torch.randn(5, 1, requires_grad=True)
    target = torch.empty(5, 1).random_(2)
    pre = nn.Sigmoid()(input)

    loss_bce = bce(pre, target)
    loss_bce_sig = bce_sig(input, target)

    # ------------------------
    input = tensor([[-0.2296],
            [-0.6389],
            [-0.2405],
            [ 1.3451],
            [ 0.7580]], requires_grad=True)
    output = tensor([[1.],
             [0.],
             [0.],
             [1.],
             [1.]])
    pre = tensor([[0.4428],
              [0.3455],
              [0.4402],
              [0.7933],
              [0.6809]], grad_fn=<SigmoidBackward>)

    print(loss_bce)
    tensor(0.4869, grad_fn=<BinaryCrossEntropyBackward>)

    print(loss_bce_sig)
    tensor(0.4869, grad_fn=<BinaryCrossEntropyWithLogitsBackward>)

    4.6 Focal Loss

    Focal loss最初是出现在目标检测领域，主要是为了解决正负样本比例失调的问题。那么对于分割任务来说，如果存在数据不均衡的情况，也可以借用focal loss来进行缓解。Focal loss函数公式如下所示：

    $$
    loss = -\frac{1}{N} \sum_{i=1}^{N}\left(\alpha y_{i}\left(1-p_{i}\right)^{\gamma} \log p_{i}+(1-\alpha)\left(1-y_{i}\right) p_{i}^{\gamma} \log \left(1-p_{i}\right)\right)
    $$
    仔细观察就不难发现，它其实是BCE扩展而来，对比BCE其实就多了个
    $$
    \alpha(1-p_{i})^{\gamma}和(1-\alpha)p_{i}^{\gamma}
    $$
    为什么多了这个就能缓解正负样本不均衡的问题呢？见下图：

    在这里插入图片描述

    简单来说：$α$解决样本不平衡问题，$γ$解决样本难易问题。

    也就是说，当数据不均衡时，可以根据比例设置合适的$α$，这个很好理解，为了能够使得正负样本得到的损失能够均衡，因此对loss前面加上一定的权重，其中负样本数量多，因此占用的权重可以设置的小一点；正样本数量少，就对正样本产生的损失的权重设的高一点。

    那γ具体怎么起作用呢？以图中$γ=5$曲线为例，假设$gt$类别为1，当模型预测结果为1的概率$p_t$比较大时，我们认为模型预测的比较准确，也就是说这个样本比较简单。而对于比较简单的样本，我们希望提供的loss小一些而让模型主要学习难一些的样本，也就是$p_t→ 1$则loss接近于0，既不用再特别学习；当分类错误时，$p_t → 0$则loss正常产生，继续学习。对比图中蓝色和绿色曲线，可以看到，γ值越大，当模型预测结果比较准确的时候能提供更小的loss，符合我们为简单样本降低loss的预期。

    代码实现：

    import torch.nn as nn
    import torch
    import torch.nn.functional as F

    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# 如果BEC带logits则损失函数在计算BECloss之前会自动计算softmax/sigmoid将其映射到[0,1]
            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

    # ------------------------

    FL1 = FocalLoss(logits=False)
    FL2 = FocalLoss(logits=True)

    inputs = torch.randn(5, 1, requires_grad=True)
    targets = torch.empty(5, 1).random_(2)
    pre = nn.Sigmoid()(inputs)

    f_loss_1 = FL1(pre, targets)
    f_loss_2 = FL2(inputs, targets)

    # ------------------------

    print('inputs:', inputs)
    inputs: tensor([[-1.3521],
            [ 0.4975],
            [-1.0178],
            [-0.3859],
            [-0.2923]], requires_grad=True)
        
    print('targets:', targets)
    targets: tensor([[1.],
            [1.],
            [0.],
            [1.],
            [1.]])
        
    print('pre:', pre)
    pre: tensor([[0.2055],
            [0.6219],
            [0.2655],
            [0.4047],
            [0.4274]], grad_fn=<SigmoidBackward>)
        
    print('f_loss_1:', f_loss_1)
    f_loss_1: tensor(0.3375, grad_fn=<MeanBackward0>)
        
    print('f_loss_2', f_loss_2)
    f_loss_2 tensor(0.3375, grad_fn=<MeanBackward0>)

    4.7 Lovász-Softmax

    IoU是评价分割模型分割结果质量的重要指标，因此很自然想到能否用$1-IoU$（即Jaccard loss）来做损失函数，但是它是一个离散的loss，不能直接求导，所以无法直接用来作为损失函数。为了克服这个离散的问题，可以采用lLovász extension将离散的Jaccard loss 变得连续，从而可以直接求导，使得其作为分割网络的loss function。Lovász-Softmax相比于交叉熵函数具有更好的效果。

    论文地址：
    paper on CVF open access
    arxiv paper

    首先明确定义，在语义分割任务中，给定真实像素标签向量$\pmb{y^*}$和预测像素标签$\pmb{\hat{y} }$，则所属类别$c$的IoU（也称为Jaccard index）如下，其取值范围为$[0,1]$，并规定$0/0=1$：

    $$J_c(\pmb{y^*},\pmb{\hat{y} })=\frac{|{\pmb{y^*}=c} \cap {\pmb{\hat{y} }=c}|}{|{\pmb{y^*}=c} \cup {\pmb{\hat{y} }=c}|}
    $$

    则Jaccard loss为：
    $$\Delta_{J_c}(\pmb{y^*},\pmb{\hat{y} }) =1-J_c(\pmb{y^*},\pmb{\hat{y} })
    $$

    针对类别$c$，所有未被正确预测的像素集合定义为：

    $$
    M_c(\pmb{y^*},\pmb{\hat{y} })={ \pmb{y^*}=c, \pmb{\hat{y} } \neq c} \cup { \pmb{y^*}\neq c, \pmb{\hat{y} } = c }
    $$

    则可将Jaccard loss改写为关于$M_c$的子模集合函数（submodular set functions）：
    $$\Delta_{J_c}:M_c \in {0,1}^{p} \mapsto \frac{|M_c|}{|{\pmb{y^*}=c}\cup M_c|}
    $$

    方便理解，此处可以把${0,1}^p$理解成如图像mask展开成离散一维向量的形式。

    Lovász extension可以求解子模最小化问题，并且子模的Lovász extension是凸函数，可以高效实现最小化。在论文中作者对$\Delta$（集合函数）和$\overline{\Delta}$（集合函数的Lovász extension）进行了定义，为不涉及过多概念以方便理解，此处不再过多讨论。我们可以将$\overline{\Delta}$理解为一个线性插值函数，可以将${0,1}^p$这种离散向量连续化，主要是为了方便后续反向传播、求梯度等等。因此我们可以通过这个线性插值函数得到$\Delta_{J_c}$的Lovász extension$\overline{\Delta_{J_c} }$。

    在具有$c(c>2)$个类别的语义分割任务中，我们使用Softmax函数将模型的输出映射到概率分布形式，类似传统交叉熵损失函数所进行的操作：
    $$p_i(c)=\frac{e^{F_i(c)} }{\sum_{c^{‘}\in C}e^{F_i(c^{‘})} }　　\forall i \in [1,p],\forall c \in C
    $$
    式中，$p_i(c)$表示了像素$i$所属类别$c$的概率。通过上式可以构建每个像素产生的误差$m(c)$：

    $$m_i(c)=\left {
    \begin{array}{c}
    1-p_i(c),\ \ if \ \ c=y^{*}_{i} \
    p_i(c),\ \ \ \ \ \ \ otherwise
    \end{array}
    \right.
    $$

    可知，对于一张图像中所有像素则误差向量为$m(c)\in {0, 1}^p$，则可以建立关于$\Delta_{J_c}$的代理损失函数：
    $$
    loss(p(c))=\overline{\Delta_{J_c} }(m(c))
    $$
    当我们考虑整个数据集是，一般会使用mIoU进行度量，因此我们对上述损失也进行平均化处理，则定义的Lovász-Softmax损失函数为：
    $$
    loss(\pmb{p})=\frac{1}{|C|}\sum_{c\in C}\overline{\Delta_{J_c} }(m(c))
    $$

    代码实现

    论文作者已经给出了Lovász-Softmax实现代码，并且有pytorch和tensorflow两种版本，并提供了使用demo。此处将针对多分类任务的Lovász-Softmax源码进行展示。

    Lovász-Softmax实现链接

    import torch
    from torch.autograd import Variable
    import torch.nn.functional as F
    import numpy as np
    try:
        from itertools import  ifilterfalse
    except ImportError: # py3k
        from itertools import  filterfalse as ifilterfalse
        
    # --------------------------- MULTICLASS LOSSES ---------------------------
    def lovasz_softmax(probas, labels, classes='present', per_image=False, ignore=None):
        """
        Multi-class Lovasz-Softmax loss
          probas: [B, C, H, W] Variable, class probabilities at each prediction (between 0 and 1).
                  Interpreted as binary (sigmoid) output with outputs of size [B, H, W].
          labels: [B, H, W] Tensor, ground truth labels (between 0 and C - 1)
          classes: 'all' for all, 'present' for classes present in labels, or a list of classes to average.
          per_image: compute the loss per image instead of per batch
          ignore: void class labels
        """
        if per_image:
            loss = mean(lovasz_softmax_flat(*flatten_probas(prob.unsqueeze(0), lab.unsqueeze(0), ignore), classes=classes)
                              for prob, lab in zip(probas, labels))
        else:
            loss = lovasz_softmax_flat(*flatten_probas(probas, labels, ignore), classes=classes)
        return loss


    def lovasz_softmax_flat(probas, labels, classes='present'):
        """
        Multi-class Lovasz-Softmax loss
          probas: [P, C] Variable, class probabilities at each prediction (between 0 and 1)
          labels: [P] Tensor, ground truth labels (between 0 and C - 1)
          classes: 'all' for all, 'present' for classes present in labels, or a list of classes to average.
        """
        if probas.numel() == 0:
            # only void pixels, the gradients should be 0
            return probas * 0.
        C = probas.size(1)
        losses = []
        class_to_sum = list(range(C)) if classes in ['all', 'present'] else classes
        for c in class_to_sum:
            fg = (labels == c).float() # foreground for class c
            if (classes is 'present' and fg.sum() == 0):
                continue
            if C == 1:
                if len(classes) > 1:
                    raise ValueError('Sigmoid output possible only with 1 class')
                class_pred = probas[:, 0]
            else:
                class_pred = probas[:, c]
            errors = (Variable(fg) - class_pred).abs()
            errors_sorted, perm = torch.sort(errors, 0, descending=True)
            perm = perm.data
            fg_sorted = fg[perm]
            losses.append(torch.dot(errors_sorted, Variable(lovasz_grad(fg_sorted))))
        return mean(losses)


    def flatten_probas(probas, labels, ignore=None):
        """
        Flattens predictions in the batch
        """
        if probas.dim() == 3:
            # assumes output of a sigmoid layer
            B, H, W = probas.size()
            probas = probas.view(B, 1, H, W)
        B, C, H, W = probas.size()
        probas = probas.permute(0, 2, 3, 1).contiguous().view(-1, C)  # B * H * W, C = P, C
        labels = labels.view(-1)
        if ignore is None:
            return probas, labels
        valid = (labels != ignore)
        vprobas = probas[valid.nonzero().squeeze()]
        vlabels = labels[valid]
        return vprobas, vlabels


    def xloss(logits, labels, ignore=None):
        """
        Cross entropy loss
        """
        return F.cross_entropy(logits, Variable(labels), ignore_index=255)

    # --------------------------- HELPER FUNCTIONS ---------------------------
    def isnan(x):
        return x != x
        
    def mean(l, ignore_nan=False, empty=0):
        """
        nanmean compatible with generators.
        """
        l = iter(l)
        if ignore_nan:
            l = ifilterfalse(isnan, l)
        try:
            n = 1
            acc = next(l)
        except StopIteration:
            if empty == 'raise':
                raise ValueError('Empty mean')
            return empty
        for n, v in enumerate(l, 2):
            acc += v
        if n == 1:
            return acc
        return acc / n

    4.8 参考链接

    语义分割的评价指标IoU

    医学图像分割常用的损失函数

    What is “Dice loss” for image segmentation?

    pytorch loss-functions

    Submodularity and the Lovász extension

    4.9 本章小结

    本章对各类评价指标进行介绍，并进行具体代码实践。

    ]]>     + 零基础入门语义分割-Task4 评价函数与损失函数

    本章主要介绍语义分割的评价函数和各类损失函数。

    4 评价函数与损失函数

    4.1 学习目标

    • 掌握常见的评价函数和损失函数Dice、IoU、BCE、Focal Loss、Lovász-Softmax；
    • 掌握评价/损失函数的实践；

    4.2 TP TN FP FN

    在讲解语义分割中常用的评价函数和损失函数之前，先补充一TP(真正例 true positive) TN(真反例 true negative) FP(假正例 false positive) FN(假反例 false negative)的知识。在分类问题中，我们经常看到上述的表述方式，以二分类为例，我们可以将所有的样本预测结果分成TP、TN、 FP、FN四类，并且每一类含有的样本数量之和为总样本数量，即TP+FP+FN+TN=总样本数量。其混淆矩阵如下：

    在这里插入图片描述

    上述的概念都是通过以预测结果的视角定义的，可以依据下面方式理解：

    • 预测结果中的正例 → 在实际中是正例 → 的所有样本被称为真正例（TP）<预测正确>

    • 预测结果中的正例 → 在实际中是反例 → 的所有样本被称为假正例（FP）<预测错误>

    • 预测结果中的反例 → 在实际中是正例 → 的所有样本被称为假反例（FN）<预测错误>

    • 预测结果中的反例 → 在实际中是反例 → 的所有样本被称为真反例（TN）<预测正确>

    这里就不得不提及精确率（precision）和召回率（recall）：

    $Precision$代表了预测的正例中真正的正例所占比例；$Recall$代表了真正的正例中被正确预测出来的比例。

    转移到语义分割任务中来，我们可以将语义分割看作是对每一个图像像素的的分类问题。根据混淆矩阵中的定义，我们亦可以将特定像素所属的集合或区域划分成TP、TN、 FP、FN四类。

    在这里插入图片描述

    以上面的图片为例，图中左子图中的人物区域（黄色像素集合）是我们真实标注的前景信息（target），其他区域（紫色像素集合）为背景信息。当经过预测之后，我们会得到的一张预测结果，图中右子图中的黄色像素为预测的前景（prediction），紫色像素为预测的背景区域。此时，我们便能够将预测结果分成4个部分：

    • 预测结果中的黄色无线区域 → 真实的前景 → 的所有像素集合被称为真正例（TP）<预测正确>

    • 预测结果中的蓝色斜线区域 → 真实的背景 → 的所有像素集合被称为假正例（FP）<预测错误>

    • 预测结果中的红色斜线区域 → 真实的前景 → 的所有像素集合被称为假反例（FN）<预测错误>

    • 预测结果中的白色斜线区域 → 真实的背景 → 的所有像素集合被称为真反例（TN）<预测正确>

    4.3 Dice评价指标

    Dice系数

    Dice系数（Dice coefficient）是常见的评价分割效果的方法之一，同样也可以改写成损失函数用来度量prediction和target之间的距离。Dice系数定义如下：

    式中：$T$表示真实前景（target），$P$表示预测前景（prediction）。Dice系数取值范围为$[0,1]$，其中值为1时代表预测与真实完全一致。仔细观察，Dice系数与分类评价指标中的F1 score很相似：

    所以，Dice系数不仅在直观上体现了target与prediction的相似程度，同时其本质上还隐含了精确率和召回率两个重要指标。

    计算Dice时，将$|T \cap P|$近似为prediction与target对应元素相乘再相加的结果。$|T|$ 和$|P|$的计算直接进行简单的元素求和（也有一些做法是取平方求和），如下示例：

    Dice Loss

    Dice Loss是在V-net模型中被提出应用的，是通过Dice系数转变而来，其实为了能够实现最小化的损失函数，以方便模型训练，以$1 - Dice$的形式作为损失函数：

    在一些场合还可以添加上Laplace smoothing减少过拟合：

    代码实现

    import numpy as np

    def dice(output, target):
        '''计算Dice系数'''
        smooth = 1e-6 # 避免0为除数
        intersection = (output * target).sum()
        return (2. * intersection + smooth) / (output.sum() + target.sum() + smooth)

    # 生成随机两个矩阵测试
    target = np.random.randint(0, 2, (3, 3))
    output = np.random.randint(0, 2, (3, 3))

    d = dice(output, target)
    # ----------------------------
    target = array([[1, 0, 0],
           [0, 1, 1],
        [0, 0, 1]])
    output = array([[1, 0, 1],
           [0, 1, 0],
           [0, 0, 0]])
    d = 0.5714286326530524

    4.4 IoU评价指标

    IoU（intersection over union）指标就是常说的交并比，不仅在语义分割评价中经常被使用，在目标检测中也是常用的评价指标。顾名思义，交并比就是指target与prediction两者之间交集与并集的比值：

    仍然以人物前景分割为例，如下图，其IoU的计算就是使用$intersection / union$。

    targetprediction
    在这里插入图片描述在这里插入图片描述
    Intersection( $T \cap P$)union($T \cup P$)
    在这里插入图片描述在这里插入图片描述

    代码实现

    def iou_score(output, target):
        '''计算IoU指标'''
    intersection = np.logical_and(target, output) 
        union = np.logical_or(target, output) 
        return np.sum(intersection) / np.sum(union)

    # 生成随机两个矩阵测试
    target = np.random.randint(0, 2, (3, 3))
    output = np.random.randint(0, 2, (3, 3))

    d = iou_score(output, target)
    # ----------------------------
    target = array([[1, 0, 0],
           [0, 1, 1],
        [0, 0, 1]])
    output = array([[1, 0, 1],
           [0, 1, 0],
           [0, 0, 0]])
    d = 0.4

    4.5 BCE损失函数

    BCE损失函数（Binary Cross-Entropy Loss）是交叉熵损失函数（Cross-Entropy Loss）的一种特例，BCE Loss只应用在二分类任务中。针对分类问题，单样本的交叉熵损失为：

    式中，$\pmb{y}={y_1,y_2,…,y_c,}$，其中$y_i$是非0即1的数字，代表了是否属于第$i$类，为真实值；$\hat y_i$代表属于第i类的概率，为预测值。可以看出，交叉熵损失考虑了多类别情况，针对每一种类别都求了损失。针对二分类问题，上述公式可以改写为：

    式中,$y$为真实值，非1即0；$\hat y$为所属此类的概率值，为预测值。这个公式也就是BCE损失函数，即二分类任务时的交叉熵损失。值得强调的是，公式中的$\hat y$为概率分布形式，因此在使用BCE损失前，都应该将预测出来的结果转变成概率值，一般为sigmoid激活之后的输出。

    代码实现

    在pytorch中，官方已经给出了BCE损失函数的API，免去了自己编写函数的痛苦：

    torch.nn.BCELoss(weight: Optional[torch.Tensor] = None, size_average=None, reduce=None, reduction: str = 'mean')

    参数：
    weight(Tensor)- 为每一批量下的loss添加一个权重，很少使用
    size_average(bool)- 弃用中
    reduce(bool)- 弃用中
    reduction(str) - ‘none’ | ‘mean’ | ‘sum’：为代替上面的size_average和reduce而生。——为mean时返回的该批量样本loss的平均值；为sum时，返回的该批量样本loss之和

    同时，pytorch还提供了已经结合了Sigmoid函数的BCE损失：torch.nn.BCEWithLogitsLoss()，相当于免去了实现进行Sigmoid激活的操作。

    import torch
    import torch.nn as nn

    bce = nn.BCELoss()
    bce_sig = nn.BCEWithLogitsLoss()

    input = torch.randn(5, 1, requires_grad=True)
    target = torch.empty(5, 1).random_(2)
    pre = nn.Sigmoid()(input)

    loss_bce = bce(pre, target)
    loss_bce_sig = bce_sig(input, target)

    # ------------------------
    input = tensor([[-0.2296],
            [-0.6389],
            [-0.2405],
            [ 1.3451],
            [ 0.7580]], requires_grad=True)
    output = tensor([[1.],
             [0.],
             [0.],
             [1.],
             [1.]])
    pre = tensor([[0.4428],
              [0.3455],
              [0.4402],
              [0.7933],
              [0.6809]], grad_fn=<SigmoidBackward>)

    print(loss_bce)
    tensor(0.4869, grad_fn=<BinaryCrossEntropyBackward>)

    print(loss_bce_sig)
    tensor(0.4869, grad_fn=<BinaryCrossEntropyWithLogitsBackward>)

    4.6 Focal Loss

    Focal loss最初是出现在目标检测领域，主要是为了解决正负样本比例失调的问题。那么对于分割任务来说，如果存在数据不均衡的情况，也可以借用focal loss来进行缓解。Focal loss函数公式如下所示：

    仔细观察就不难发现，它其实是BCE扩展而来，对比BCE其实就多了个

    为什么多了这个就能缓解正负样本不均衡的问题呢？见下图：

    在这里插入图片描述

    简单来说：$α$解决样本不平衡问题，$γ$解决样本难易问题。

    也就是说，当数据不均衡时，可以根据比例设置合适的$α$，这个很好理解，为了能够使得正负样本得到的损失能够均衡，因此对loss前面加上一定的权重，其中负样本数量多，因此占用的权重可以设置的小一点；正样本数量少，就对正样本产生的损失的权重设的高一点。

    那γ具体怎么起作用呢？以图中$γ=5$曲线为例，假设$gt$类别为1，当模型预测结果为1的概率$p_t$比较大时，我们认为模型预测的比较准确，也就是说这个样本比较简单。而对于比较简单的样本，我们希望提供的loss小一些而让模型主要学习难一些的样本，也就是$p_t→ 1$则loss接近于0，既不用再特别学习；当分类错误时，$p_t → 0$则loss正常产生，继续学习。对比图中蓝色和绿色曲线，可以看到，γ值越大，当模型预测结果比较准确的时候能提供更小的loss，符合我们为简单样本降低loss的预期。

    代码实现：

    import torch.nn as nn
    import torch
    import torch.nn.functional as F

    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# 如果BEC带logits则损失函数在计算BECloss之前会自动计算softmax/sigmoid将其映射到[0,1]
            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

    # ------------------------

    FL1 = FocalLoss(logits=False)
    FL2 = FocalLoss(logits=True)

    inputs = torch.randn(5, 1, requires_grad=True)
    targets = torch.empty(5, 1).random_(2)
    pre = nn.Sigmoid()(inputs)

    f_loss_1 = FL1(pre, targets)
    f_loss_2 = FL2(inputs, targets)

    # ------------------------

    print('inputs:', inputs)
    inputs: tensor([[-1.3521],
            [ 0.4975],
            [-1.0178],
            [-0.3859],
            [-0.2923]], requires_grad=True)
        
    print('targets:', targets)
    targets: tensor([[1.],
            [1.],
            [0.],
            [1.],
            [1.]])
        
    print('pre:', pre)
    pre: tensor([[0.2055],
            [0.6219],
            [0.2655],
            [0.4047],
            [0.4274]], grad_fn=<SigmoidBackward>)
        
    print('f_loss_1:', f_loss_1)
    f_loss_1: tensor(0.3375, grad_fn=<MeanBackward0>)
        
    print('f_loss_2', f_loss_2)
    f_loss_2 tensor(0.3375, grad_fn=<MeanBackward0>)

    4.7 Lovász-Softmax

    IoU是评价分割模型分割结果质量的重要指标，因此很自然想到能否用$1-IoU$（即Jaccard loss）来做损失函数，但是它是一个离散的loss，不能直接求导，所以无法直接用来作为损失函数。为了克服这个离散的问题，可以采用lLovász extension将离散的Jaccard loss 变得连续，从而可以直接求导，使得其作为分割网络的loss function。Lovász-Softmax相比于交叉熵函数具有更好的效果。

    论文地址：
    paper on CVF open access
    arxiv paper

    首先明确定义，在语义分割任务中，给定真实像素标签向量$\pmb{y^*}$和预测像素标签$\pmb{\hat{y} }$，则所属类别$c$的IoU（也称为Jaccard index）如下，其取值范围为$[0,1]$，并规定$0/0=1$：

    则Jaccard loss为：

    针对类别$c$，所有未被正确预测的像素集合定义为：

    则可将Jaccard loss改写为关于$M_c$的子模集合函数（submodular set functions）：

    方便理解，此处可以把${0,1}^p$理解成如图像mask展开成离散一维向量的形式。

    Lovász extension可以求解子模最小化问题，并且子模的Lovász extension是凸函数，可以高效实现最小化。在论文中作者对$\Delta$（集合函数）和$\overline{\Delta}$（集合函数的Lovász extension）进行了定义，为不涉及过多概念以方便理解，此处不再过多讨论。我们可以将$\overline{\Delta}$理解为一个线性插值函数，可以将${0,1}^p$这种离散向量连续化，主要是为了方便后续反向传播、求梯度等等。因此我们可以通过这个线性插值函数得到$\Delta{J_c}$的Lovász extension$\overline{\Delta{J_c} }$。

    在具有$c(c>2)$个类别的语义分割任务中，我们使用Softmax函数将模型的输出映射到概率分布形式，类似传统交叉熵损失函数所进行的操作：

    式中，$p_i(c)$表示了像素$i$所属类别$c$的概率。通过上式可以构建每个像素产生的误差$m(c)$：

    可知，对于一张图像中所有像素则误差向量为$m(c)\in {0, 1}^p$，则可以建立关于$\Delta_{J_c}$的代理损失函数：

    当我们考虑整个数据集是，一般会使用mIoU进行度量，因此我们对上述损失也进行平均化处理，则定义的Lovász-Softmax损失函数为：

    代码实现

    论文作者已经给出了Lovász-Softmax实现代码，并且有pytorch和tensorflow两种版本，并提供了使用demo。此处将针对多分类任务的Lovász-Softmax源码进行展示。

    Lovász-Softmax实现链接

    import torch
    from torch.autograd import Variable
    import torch.nn.functional as F
    import numpy as np
    try:
        from itertools import  ifilterfalse
    except ImportError: # py3k
        from itertools import  filterfalse as ifilterfalse
        
    # --------------------------- MULTICLASS LOSSES ---------------------------
    def lovasz_softmax(probas, labels, classes='present', per_image=False, ignore=None):
        """
        Multi-class Lovasz-Softmax loss
          probas: [B, C, H, W] Variable, class probabilities at each prediction (between 0 and 1).
                  Interpreted as binary (sigmoid) output with outputs of size [B, H, W].
          labels: [B, H, W] Tensor, ground truth labels (between 0 and C - 1)
          classes: 'all' for all, 'present' for classes present in labels, or a list of classes to average.
          per_image: compute the loss per image instead of per batch
          ignore: void class labels
        """
        if per_image:
            loss = mean(lovasz_softmax_flat(*flatten_probas(prob.unsqueeze(0), lab.unsqueeze(0), ignore), classes=classes)
                              for prob, lab in zip(probas, labels))
        else:
            loss = lovasz_softmax_flat(*flatten_probas(probas, labels, ignore), classes=classes)
        return loss


    def lovasz_softmax_flat(probas, labels, classes='present'):
        """
        Multi-class Lovasz-Softmax loss
          probas: [P, C] Variable, class probabilities at each prediction (between 0 and 1)
          labels: [P] Tensor, ground truth labels (between 0 and C - 1)
          classes: 'all' for all, 'present' for classes present in labels, or a list of classes to average.
        """
        if probas.numel() == 0:
            # only void pixels, the gradients should be 0
            return probas * 0.
        C = probas.size(1)
        losses = []
        class_to_sum = list(range(C)) if classes in ['all', 'present'] else classes
        for c in class_to_sum:
            fg = (labels == c).float() # foreground for class c
            if (classes is 'present' and fg.sum() == 0):
                continue
            if C == 1:
                if len(classes) > 1:
                    raise ValueError('Sigmoid output possible only with 1 class')
                class_pred = probas[:, 0]
            else:
                class_pred = probas[:, c]
            errors = (Variable(fg) - class_pred).abs()
            errors_sorted, perm = torch.sort(errors, 0, descending=True)
            perm = perm.data
            fg_sorted = fg[perm]
            losses.append(torch.dot(errors_sorted, Variable(lovasz_grad(fg_sorted))))
        return mean(losses)


    def flatten_probas(probas, labels, ignore=None):
        """
        Flattens predictions in the batch
        """
        if probas.dim() == 3:
            # assumes output of a sigmoid layer
            B, H, W = probas.size()
            probas = probas.view(B, 1, H, W)
        B, C, H, W = probas.size()
        probas = probas.permute(0, 2, 3, 1).contiguous().view(-1, C)  # B * H * W, C = P, C
        labels = labels.view(-1)
        if ignore is None:
            return probas, labels
        valid = (labels != ignore)
        vprobas = probas[valid.nonzero().squeeze()]
        vlabels = labels[valid]
        return vprobas, vlabels


    def xloss(logits, labels, ignore=None):
        """
        Cross entropy loss
        """
        return F.cross_entropy(logits, Variable(labels), ignore_index=255)

    # --------------------------- HELPER FUNCTIONS ---------------------------
    def isnan(x):
        return x != x
        
    def mean(l, ignore_nan=False, empty=0):
        """
        nanmean compatible with generators.
        """
        l = iter(l)
        if ignore_nan:
            l = ifilterfalse(isnan, l)
        try:
            n = 1
            acc = next(l)
        except StopIteration:
            if empty == 'raise':
                raise ValueError('Empty mean')
            return empty
        for n, v in enumerate(l, 2):
            acc += v
        if n == 1:
            return acc
        return acc / n

    4.8 参考链接

    语义分割的评价指标IoU

    医学图像分割常用的损失函数

    What is “Dice loss” for image segmentation?

    pytorch loss-functions

    Submodularity and the Lovász extension

    4.9 本章小结

    本章对各类评价指标进行介绍，并进行具体代码实践。

    ]]>     diff --git a/categories/index.html b/categories/index.html index a158ffc3..9f9e465c 100644 --- a/categories/index.html +++ b/categories/index.html @@ -481,7 +481,7 @@

  • - 编译原理 + 数据库系统
  • @@ -489,15 +489,15 @@

  • - Hexo + 编译原理
  • - 数据库系统 + Go
  • - Go + Hexo
  • diff --git a/index.html b/index.html index a9583d14..052dc7af 100644 --- a/index.html +++ b/index.html @@ -207,7 +207,7 @@

    -

    最近有在折腾一些Ubuntu日常化的东西，给电脑重新装了双系统，相比前几年，ubuntu22.04之后系统确实变得非常好用了，软件生态支持也变多了，为了更加日常化的使用折腾了一些相关软件的安装，这边做一个简单的记录。

    +

    最近有在折腾一些Ubuntu日常化的东西，给电脑重新装了双系统，相比前几年，ubuntu22.04之后系统确实变得非常好用了，软件生态支持也变多了，为了更加日常化的使用折腾了一些相关软件的安装，这边做一个简单的记录。

    @@ -361,7 +361,7 @@

    既往不恋，纵情向前，江湖再见——22岁那年，在北京的日子

    2022年3月31日0:52，睡不着，日常拖延症+强迫症导致清东西到现在，等会还想清扫一下弄脏的地板。

    莲竹花园甲2号楼一门101，从今天起，这里将不再是我的家，本来是昨天的机票，天气不似预期，不打算买高铁，还想再飞上一次云霄，所以倔强的又改签了机票，不过正好也让我多看一眼这里吧，最近东航事件其实让我也有一点小慌，希望能平安到达吧。

    -

    不出所料，我对这个城市并没有什么留恋，每天晚上我都会思考很多，有天夜里我的脑海里突然冒出来了那句：劝君更进一杯酒，西出阳关无故人。 这一刻我才真正明白什么是独在异乡为异客的感觉，什么才是我心里最想要的。

    +

    不出所料，我对这个城市并没有什么留恋，每天晚上我都会思考很多，有天夜里我的脑海里突然冒出来了那句：劝君更进一杯酒，西出阳关无故人。 这一刻我才真正明白什么是独在异乡为异客的感觉，什么才是我心里最想要的。

    @@ -675,7 +675,7 @@

    -

    XGBoost算法

    XGBoost是陈天奇等人开发的一个开源机器学习项目，高效地实现了GBDT算法并进行了算法和工程上的许多改进，被广泛应用在Kaggle竞赛及其他许多机器学习竞赛中并取得了不错的成绩。XGBoost本质上还是一个GBDT，但是力争把速度和效率发挥到极致，所以叫X (Extreme) GBoosted， 包括前面说过，两者都是boosting方法。XGBoost是一个优化的分布式梯度增强库，旨在实现高效，灵活和便携。 它在Gradient Boosting框架下实现机器学习算法。 XGBoost提供了并行树提升（也称为GBDT，GBM），可以快速准确地解决许多数据科学问题。 相同的代码在主要的分布式环境（Hadoop，SGE，MPI）上运行，并且可以解决超过数十亿个样例的问题。XGBoost利用了核外计算并且能够使数据科学家在一个主机上处理数亿的样本数据。最终，将这些技术进行结合来做一个端到端的系统以最少的集群系统来扩展到更大的数据集上。Xgboost以CART决策树为子模型，通过Gradient Tree Boosting实现多棵CART树的集成学习，得到最终模型。下面我们来看看XGBoost的最终模型构建：

    +

    XGBoost算法

    XGBoost是陈天奇等人开发的一个开源机器学习项目，高效地实现了GBDT算法并进行了算法和工程上的许多改进，被广泛应用在Kaggle竞赛及其他许多机器学习竞赛中并取得了不错的成绩。XGBoost本质上还是一个GBDT，但是力争把速度和效率发挥到极致，所以叫X (Extreme) GBoosted， 包括前面说过，两者都是boosting方法。XGBoost是一个优化的分布式梯度增强库，旨在实现高效，灵活和便携。 它在Gradient Boosting框架下实现机器学习算法。 XGBoost提供了并行树提升（也称为GBDT，GBM），可以快速准确地解决许多数据科学问题。 相同的代码在主要的分布式环境（Hadoop，SGE，MPI）上运行，并且可以解决超过数十亿个样例的问题。XGBoost利用了核外计算并且能够使数据科学家在一个主机上处理数亿的样本数据。最终，将这些技术进行结合来做一个端到端的系统以最少的集群系统来扩展到更大的数据集上。Xgboost以CART决策树为子模型，通过Gradient Tree Boosting实现多棵CART树的集成学习，得到最终模型。下面我们来看看XGBoost的最终模型构建：

    @@ -753,7 +753,7 @@

    -

    梯度提升决策树(GBDT)

    (1) 基于残差学习的提升树算法：
    在前面的学习过程中，我们一直讨论的都是分类树，比如Adaboost算法，并没有涉及回归的例子。在上一小节我们提到了一个加法模型+前向分步算法的框架，那能否使用这个框架解决回归的例子呢？答案是肯定的。接下来我们来探讨下如何使用加法模型+前向分步算法的框架实现回归问题。
    在使用加法模型+前向分步算法的框架解决问题之前，我们需要首先确定框架内使用的基函数是什么，在这里我们使用决策树分类器。前面第二章我们已经学过了回归树的基本原理，树算法最重要是寻找最佳的划分点，分类树用纯度来判断最佳划分点使用信息增益（ID3算法），信息增益比（C4.5算法），基尼系数（CART分类树）。但是在回归树中的样本标签是连续数值，可划分点包含了所有特征的所有可取的值。所以再使用熵之类的指标不再合适，取而代之的是平方误差，它能很好的评判拟合程度。 基函数确定了以后，我们需要确定每次提升的标准是什么。回想Adaboost算法，在Adaboost算法内使用了分类错误率修正样本权重以及计算每个基本分类器的权重，那回归问题没有分类错误率可言，也就没办法在这里的回归问题使用了，因此我们需要另辟蹊径。模仿分类错误率，我们用每个样本的残差表示每次使用基函数预测时没有解决的那部分问题。因此，我们可以得出如下算法：

    +

    梯度提升决策树(GBDT)

    (1) 基于残差学习的提升树算法：
    在前面的学习过程中，我们一直讨论的都是分类树，比如Adaboost算法，并没有涉及回归的例子。在上一小节我们提到了一个加法模型+前向分步算法的框架，那能否使用这个框架解决回归的例子呢？答案是肯定的。接下来我们来探讨下如何使用加法模型+前向分步算法的框架实现回归问题。
    在使用加法模型+前向分步算法的框架解决问题之前，我们需要首先确定框架内使用的基函数是什么，在这里我们使用决策树分类器。前面第二章我们已经学过了回归树的基本原理，树算法最重要是寻找最佳的划分点，分类树用纯度来判断最佳划分点使用信息增益（ID3算法），信息增益比（C4.5算法），基尼系数（CART分类树）。但是在回归树中的样本标签是连续数值，可划分点包含了所有特征的所有可取的值。所以再使用熵之类的指标不再合适，取而代之的是平方误差，它能很好的评判拟合程度。 基函数确定了以后，我们需要确定每次提升的标准是什么。回想Adaboost算法，在Adaboost算法内使用了分类错误率修正样本权重以及计算每个基本分类器的权重，那回归问题没有分类错误率可言，也就没办法在这里的回归问题使用了，因此我们需要另辟蹊径。模仿分类错误率，我们用每个样本的残差表示每次使用基函数预测时没有解决的那部分问题。因此，我们可以得出如下算法：

    @@ -831,7 +831,7 @@

    -

    1. 导论

    在前面的学习中，我们探讨了一系列简单而实用的回归和分类模型，同时也探讨了如何使用集成学习家族中的Bagging思想去优化最终的模型。Bagging思想的实质是：通过Bootstrap 的方式对全样本数据集进行抽样得到抽样子集，对不同的子集使用同一种基本模型进行拟合，然后投票得出最终的预测。我们也从前面的探讨知道：Bagging主要通过降低方差的方式减少预测误差。那么，本章介绍的Boosting是与Bagging截然不同的思想，Boosting方法是使用同一组数据集进行反复学习，得到一系列简单模型，然后组合这些模型构成一个预测性能十分强大的机器学习模型。 显然，Boosting思想提高最终的预测效果是通过不断减少偏差的形式，与Bagging有着本质的不同。在Boosting这一大类方法中，笔者主要介绍两类常用的Boosting方式：Adaptive Boosting 和 Gradient Boosting 以及它们的变体Xgboost、LightGBM以及Catboost。

    +

    1. 导论

    在前面的学习中，我们探讨了一系列简单而实用的回归和分类模型，同时也探讨了如何使用集成学习家族中的Bagging思想去优化最终的模型。Bagging思想的实质是：通过Bootstrap 的方式对全样本数据集进行抽样得到抽样子集，对不同的子集使用同一种基本模型进行拟合，然后投票得出最终的预测。我们也从前面的探讨知道：Bagging主要通过降低方差的方式减少预测误差。那么，本章介绍的Boosting是与Bagging截然不同的思想，Boosting方法是使用同一组数据集进行反复学习，得到一系列简单模型，然后组合这些模型构成一个预测性能十分强大的机器学习模型。 显然，Boosting思想提高最终的预测效果是通过不断减少偏差的形式，与Bagging有着本质的不同。在Boosting这一大类方法中，笔者主要介绍两类常用的Boosting方式：Adaptive Boosting 和 Gradient Boosting 以及它们的变体Xgboost、LightGBM以及Catboost。

    @@ -915,7 +915,7 @@

    10101100100111001011011011011

    这导致的结果可能是致命的。一个常用的纠错方法是重复多次发送数据，并以少数服从多数的方法确定正确的传输数据。一般情况下，错误总是发生在局部，因此融合多个数据是降低误差的一个好方法，这就是投票法的基本思路。

    对于回归模型来说，投票法最终的预测结果是多个其他回归模型预测结果的平均值。

    -

    对于分类模型，硬投票法的预测结果是多个模型预测结果中出现次数最多的类别，软投票对各类预测结果的概率进行求和，最终选取概率之和最大的类标签。

    +

    对于分类模型，硬投票法的预测结果是多个模型预测结果中出现次数最多的类别，软投票对各类预测结果的概率进行求和，最终选取概率之和最大的类标签。

    @@ -1205,7 +1205,7 @@

  • - 编译原理 + 数据库系统
  • @@ -1213,15 +1213,15 @@

  • - Hexo + 编译原理
  • - 数据库系统 + Go
  • - Go + Hexo
  • diff --git a/live2d-widget-old/README.html b/live2d-widget-old/README.html index 1796522e..d82de013 100644 --- a/live2d-widget-old/README.html +++ b/live2d-widget-old/README.html @@ -1,39 +1,44 @@ -

    Live2D Widget






    +

    Live2D Widget






    特性 Feature

    在网页中添加 Live2D 看板娘。兼容 PJAX，支持无刷新加载。
    Add Live2D widget to web page. Compatible with PJAX.

    警告：本项目使用了大量 ES6 语法，且依赖于 WebGL。不支持 IE 11 等老旧浏览器。
    WARNING: This project does not support legacy browsers such as IE 11.

    -

    示例 Demo

    在米米的博客的左下角可查看效果。

    -



    +

    示例 Demo

    在米米的博客的左下角可查看效果。

    +



    这个仓库中也提供了两个 Demo，即

    依赖 Dependencies

    本插件需要 Font Awesome 4.7.0 支持，请确保相关样式表已在页面中加载，例如在 <head> 中加入：
    Font Awesome 4.7.0 is required for this plugin. You can add this to <head>:

    -
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/font-awesome/css/font-awesome.min.css">
    +
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/font-awesome/css/font-awesome.min.css">
+

    否则无法正常显示。（如果网页中已经加载了 Font Awesome，就不要重复加载了）

    使用 Usage

    将这一行代码加入 <head> 或 <body>，即可展现出效果：

    -
    <script src="https://cdn.jsdelivr.net/gh/stevenjoezhang/live2d-widget@latest/autoload.js"></script>
    +
    <script src="https://cdn.jsdelivr.net/gh/stevenjoezhang/live2d-widget@latest/autoload.js"></script>
+

    如果网站启用了 PJAX，由于看板娘不必每页刷新，因此要注意将相关脚本放到 PJAX 刷新区域之外。

    换句话说，如果你是小白，或者只需要最基础的功能，就只用把这一行代码，连同前面加载 Font Awesome 的一行代码，一起放到 html 的 <head> 中即可。
    对于用各种模版引擎（例如 Nunjucks，Jinja 或者 PHP）生成的页面，也要自行修改，方法类似，只是可能略为麻烦。以 Hexo 为例，需要在主题相关的 ejs 或 njk 模版中正确配置路径，才可以加载。

    但是！我们强烈推荐自己进行配置，否则很多功能是不完整的，并且可能产生问题！
    如果你有兴趣自己折腾的话，请看下面的详细说明。

    Using CDN

    要自定义有关内容，可以把这个仓库 Fork 一份，然后进行修改。这时，使用方法对应地变为

    -
    <script src="https://cdn.jsdelivr.net/gh/username/live2d-widget@latest/autoload.js"></script>
    +
    <script src="https://cdn.jsdelivr.net/gh/username/live2d-widget@latest/autoload.js"></script>
+

    将 username 替换为你的 GitHub 用户名即可。

    Self-host

    你也可以直接把这些文件放到服务器上，而不是通过 CDN 加载。

      -
    • 如果你能够通过 ssh 访问你的主机，请把整个仓库克隆到服务器上。执行：
      cd /path/to/your/webroot
+
    • 如果你能够通过 ssh 访问你的主机，请把整个仓库克隆到服务器上。执行：
      cd /path/to/your/webroot
 # Clone this repository
-git clone https://github.com/stevenjoezhang/live2d-widget.git
      
+git clone https://github.com/stevenjoezhang/live2d-widget.git
+
    • 如果你的主机无法用 ssh 连接（例如一般的虚拟主机），请选择 Download ZIP，然后通过 ftp 等方式上传到主机上，再解压到网站的目录下。
    • 如果你是通过 Hexo 等工具部署的静态博客，请在本地开命令行进入博客目录，例如 source 下与 _posts 同级的目录，然后再执行前述的 git clone 命令。重新部署博客时，相关文件就会自动上传到对应的路径下。

    这样，整个项目就可以通过你的服务器 IP 或者域名从公网访问了。不妨试试能否正常地通过浏览器打开 autoload.js 和 live2d.min.js 等文件，并确认这些文件的内容是正确的，没有出现乱码。
    一切正常的话，接下来修改一些配置就行了。（需要通过服务器上的文本编辑器修改；你也可以先在本地完成这一步骤，再上传到服务器上）
    修改 autoload.js 中的常量 live2d_path 为 live2d-widget 这一文件夹在公网上的路径。比如说，如果你能够通过

    -
    https://www.example.com/path/to/live2d-widget/live2d.min.js
    -

    访问到 live2d.min.js，那么就把 live2d_path 的值修改为

    -
    https://www.example.com/path/to/live2d-widget/
    -

    路径末尾的 / 一定要加上。具体可以参考 autoload.js 内的注释。
    完成后，在你要添加看板娘的界面加入

    -
    <script src="https://www.example.com/path/to/live2d-widget/autoload.js"></script>
    +
    https://www.example.com/path/to/live2d-widget/live2d.min.js
+

    访问到 live2d.min.js，那么就把 live2d_path 的值修改为

    +
    https://www.example.com/path/to/live2d-widget/
+

    路径末尾的 / 一定要加上。具体可以参考 autoload.js 内的注释。
    完成后，在你要添加看板娘的界面加入

    +
    <script src="https://www.example.com/path/to/live2d-widget/autoload.js"></script>
+

    就可以加载了。

    目录结构 Files

    • waifu-tips.json 中包含了触发条件（selector，选择器）和触发时显示的文字（text）；
      • @@ -41,16 +46,16 @@

      源文件是对 Hexo 的 NexT 主题有效的，为了适用于你自己的网页，可能需要自行修改，或增加新内容。
      警告：作者不对包括但不限于 waifu-tips.json 和 waifu-tips.js 文件中的内容负责，请自行确保它们是合适的。

      如果有任何疑问，欢迎提 Issue。如果有任何修改建议，欢迎提 Pull Request。

      -

      鸣谢 Credits

      +

      鸣谢 Credits

      感谢 BrowserStack 容许我们在真实的浏览器中测试此项目。
      Thanks to BrowserStack for allowing us to test this project in real browsers.

      代码自这篇博文魔改而来：
      https://www.fghrsh.net/post/123.html

      -

      点击看板娘的纸飞机按钮时，会出现一个彩蛋，这来自于 WebsiteAsteroids。

      +

      点击看板娘的纸飞机按钮时，会出现一个彩蛋，这来自于 WebsiteAsteroids。

      更多 More

      更多内容可以参考：
      https://imjad.cn/archives/lab/add-dynamic-poster-girl-with-live2d-to-your-blog-02
      https://github.com/xiazeyu/live2d-widget.js
      https://github.com/summerscar/live2dDemo

      还可以自行搭建后端 API，并增加模型（需要修改的内容比较多，此处不再赘述）：
      https://github.com/fghrsh/live2d_api
      https://github.com/xiazeyu/live2d-widget-models
      https://github.com/xiaoski/live2d_models_collection

      除此之外，还有桌面版本：
      https://github.com/amorist/platelet
      https://github.com/akiroz/Live2D-Widget

      许可证 License

      Released under the GNU General Public License v3
      http://www.gnu.org/licenses/gpl-3.0.html

      本仓库中涉及的所有 Live2D 模型、图片、动作数据等版权均属于其原作者，仅供研究学习，不得用于商业用途。

      -

      Live2D 官方网站：
      https://www.live2d.com/en/
      https://live2d.github.io

      +

      Live2D 官方网站：
      https://www.live2d.com/en/
      https://live2d.github.io

      Live2D Cubism Core は Live2D Proprietary Software License で提供しています。
      https://www.live2d.com/eula/live2d-proprietary-software-license-agreement_en.html
      Live2D Cubism Components は Live2D Open Software License で提供しています。
      http://www.live2d.com/eula/live2d-open-software-license-agreement_en.html

      The terms and conditions do prohibit modification, but obfuscating in live2d.min.js would not be considered illegal modification.

      diff --git a/live2d-widget/README.html b/live2d-widget/README.html index d04e445a..bcf8255e 100644 --- a/live2d-widget/README.html +++ b/live2d-widget/README.html @@ -1,18 +1,20 @@ -

      Live2D Widget






      +

      Live2D Widget






      特性 Feature

      在网页中添加 Live2D 看板娘。兼容 PJAX，支持无刷新加载。
      Add Live2D widget to web page. Compatible with PJAX.

      （注：以上人物模型仅供展示之用，本仓库并不包含任何模型。）

      你也可以查看示例网页：

      使用 Usage

      如果你是小白，或者只需要最基础的功能，那么只用将这一行代码加入 html 页面的 head 或 body 中，即可加载看板娘：

      -
      <script src="https://fastly.jsdelivr.net/gh/stevenjoezhang/live2d-widget@latest/autoload.js"></script>
      -

      添加代码的位置取决于你的网站的构建方式。例如，如果你使用的是 Hexo，那么需要在主题的模版文件中添加以上代码。对于用各种模版引擎生成的页面，修改方法类似。
      如果网站启用了 PJAX，由于看板娘不必每页刷新，需要注意将该脚本放到 PJAX 刷新区域之外。

      +
      <script src="https://fastly.jsdelivr.net/gh/stevenjoezhang/live2d-widget@latest/autoload.js"></script>
+
      +

      添加代码的位置取决于你的网站的构建方式。例如，如果你使用的是 Hexo，那么需要在主题的模版文件中添加以上代码。对于用各种模版引擎生成的页面，修改方法类似。
      如果网站启用了 PJAX，由于看板娘不必每页刷新，需要注意将该脚本放到 PJAX 刷新区域之外。

      但是！我们强烈推荐自己进行配置，让看板娘更加适合你的网站！
      如果你有兴趣自己折腾的话，请看下面的详细说明。

      配置 Configuration

      你可以对照 autoload.js 的源码查看可选的配置项目。autoload.js 会自动加载三个文件：waifu.css，live2d.min.js 和 waifu-tips.js。waifu-tips.js 会创建 initWidget 函数，这就是加载看板娘的主函数。initWidget 函数接收一个 Object 类型的参数，作为看板娘的配置。以下是配置选项：

      +
      @@ -22,7 +24,8 @@

      说明

      - + + @@ -46,7 +49,9 @@

      见 autoload.js

      -
      waifuPath string https://fastly.jsdelivr.net/gh/stevenjoezhang/live2d-widget@latest/waifu-tips.json加载的小工具按钮，可选参数
      + + +

      其中，apiPath 和 cdnPath 两个参数设置其中一项即可。apiPath 是后端 API 的 URL，可以自行搭建，并增加模型（需要修改的内容比较多，此处不再赘述），可以参考 live2d_api。而 cdnPath 则是通过 jsDelivr 这样的 CDN 服务加载资源，更加稳定。

      自定义 Customization

      如果以上「配置」部分提供的选项还不足以满足你的需求，那么你可以自己进行修改。本仓库的目录结构如下：

        @@ -57,13 +62,15 @@

        NexT 主题 有效的，为了适用于你自己的网页，可能需要自行修改，或增加新内容。
        警告：waifu-tips.json 中的内容可能不适合所有年龄段，或不宜在工作期间访问。在使用时，请自行确保它们是合适的。

        要在本地部署本项目的开发测试环境，你需要安装 Node.js 和 npm，然后执行以下命令：

        -
        git clone https://github.com/stevenjoezhang/live2d-widget.git
+
        git clone https://github.com/stevenjoezhang/live2d-widget.git
 npm install
-npm run build
        
+npm run build
+

        如果有任何疑问，欢迎提 Issue。如果有任何修改建议，欢迎提 Pull Request。

        部署 Deploy

        在本地完成了修改后，你可以将修改后的项目部署在服务器上，或者通过 CDN 加载，以便在网页中使用。

        Using CDN

        要自定义有关内容，可以把这个仓库 Fork 一份，然后把修改后的内容通过 git push 到你的仓库中。这时，使用方法对应地变为

        -
        <script src="https://fastly.jsdelivr.net/gh/username/live2d-widget@latest/autoload.js"></script>
        +
        <script src="https://fastly.jsdelivr.net/gh/username/live2d-widget@latest/autoload.js"></script>
+

        将此处的 username 替换为你的 GitHub 用户名。为了使 CDN 的内容正常刷新，需要创建新的 git tag 并推送至 GitHub 仓库中，否则此处的 @latest 仍然指向更新前的文件。此外 CDN 本身存在缓存，因此改动可能需要一定的时间生效。相关文档：

        • Git Basics - Tagging
          • @@ -76,11 +83,12 @@

          如果你是通过 Hexo 等工具部署的静态博客，请把本项目的代码放在博客源文件目录下（例如 source 目录）。重新部署博客时，相关文件就会自动上传到对应的路径下。为了避免这些文件被 Hexo 插件错误地修改，可能需要设置 skip_render。

        这样，整个项目就可以通过你的域名访问了。不妨试试能否正常地通过浏览器打开 autoload.js 和 live2d.min.js 等文件，并确认这些文件的内容是完整和正确的。
        一切正常的话，接下来修改 autoload.js 中的常量 live2d_path 为 live2d-widget 这一目录的 URL 即可。比如说，如果你能够通过

        -
        https://example.com/path/to/live2d-widget/live2d.min.js
        -

        访问到 live2d.min.js，那么就把 live2d_path 的值修改为

        -
        https://example.com/path/to/live2d-widget/
        -

        路径末尾的 / 一定要加上。
        完成后，在你要添加看板娘的界面加入

        -
        <script src="https://example.com/path/to/live2d-widget/autoload.js"></script>
        +
        https://example.com/path/to/live2d-widget/live2d.min.js
+

        访问到 live2d.min.js，那么就把 live2d_path 的值修改为

        +
        https://example.com/path/to/live2d-widget/
+

        路径末尾的 / 一定要加上。
        完成后，在你要添加看板娘的界面加入

        +
        <script src="https://example.com/path/to/live2d-widget/autoload.js"></script>
+

        就可以加载了。

        鸣谢 Thanks

        BrowserStack Logo

        @@ -91,15 +99,15 @@

        https://www.fghrsh.net/post/123.html

        -

        感谢 一言 提供的语句接口。

        -

        点击看板娘的纸飞机按钮时，会出现一个彩蛋，这来自于 WebsiteAsteroids。

        +

        感谢 一言 提供的语句接口。

        +

        点击看板娘的纸飞机按钮时，会出现一个彩蛋，这来自于 WebsiteAsteroids。

        更多 More

        更多内容可以参考：
        https://nocilol.me/archives/lab/add-dynamic-poster-girl-with-live2d-to-your-blog-02
        https://github.com/xiazeyu/live2d-widget.js
        https://github.com/summerscar/live2dDemo

        关于后端 API 模型：
        https://github.com/xiazeyu/live2d-widget-models
        https://github.com/xiaoski/live2d_models_collection

        除此之外，还有桌面版本：
        https://github.com/amorist/platelet
        https://github.com/akiroz/Live2D-Widget
        https://github.com/zenghongtu/PPet
        https://github.com/LikeNeko/L2dPetForMac

        以及 Wallpaper Engine：
        https://github.com/guansss/nep-live2d

        许可证 License

        Released under the GNU General Public License v3
        http://www.gnu.org/licenses/gpl-3.0.html

        本仓库并不包含任何模型，用作展示的所有 Live2D 模型、图片、动作数据等版权均属于其原作者，仅供研究学习，不得用于商业用途。

        -

        Live2D 官方网站：
        https://www.live2d.com/en/
        https://live2d.github.io

        +

        Live2D 官方网站：
        https://www.live2d.com/en/
        https://live2d.github.io

        Live2D Cubism Core は Live2D Proprietary Software License で提供しています。
        https://www.live2d.com/eula/live2d-proprietary-software-license-agreement_en.html
        Live2D Cubism Components は Live2D Open Software License で提供しています。
        http://www.live2d.com/eula/live2d-open-software-license-agreement_en.html

        The terms and conditions do prohibit modification, but obfuscating in live2d.min.js would not be considered illegal modification.

        diff --git a/page/2/index.html b/page/2/index.html index 5443e198..3a17f219 100644 --- a/page/2/index.html +++ b/page/2/index.html @@ -207,7 +207,7 @@

        -

        数据结构与算法——二分

        最近leetcode每日一题经常出二分的题目，正好对前段时间学过的二分进行一些总结，首先这里要明确的一点是，二分的本质并不是单调性，而是通过某种条件将整个区间划分成满足条件和不满足条件的两端即可进行二分查找。
        在二分这个专题，主要有两种类型的划分方式，一种是整数划分，一种是浮点数划分，前一种一般是我们最熟悉的二分查找的题型，也是出题比较灵活考的比较多的一种，后一种主要是为控制实数精度而设置的浮点数二分法（建议用double，float有时候会出现精度丢失）。

        +

        数据结构与算法——二分

        最近leetcode每日一题经常出二分的题目，正好对前段时间学过的二分进行一些总结，首先这里要明确的一点是，二分的本质并不是单调性，而是通过某种条件将整个区间划分成满足条件和不满足条件的两端即可进行二分查找。
        在二分这个专题，主要有两种类型的划分方式，一种是整数划分，一种是浮点数划分，前一种一般是我们最熟悉的二分查找的题型，也是出题比较灵活考的比较多的一种，后一种主要是为控制实数精度而设置的浮点数二分法（建议用double，float有时候会出现精度丢失）。

        @@ -281,7 +281,7 @@

        -

        数据结构与刷题——链表

        在这里插入图片描述

        +

        数据结构与刷题——链表

        在这里插入图片描述

        @@ -355,7 +355,7 @@

        -

        前言

        最近在复习数据结构，顺便整理之前刷题的一些模板和技巧，希望对大家都有帮助，博客会侧重讲解的是OJ代码实现，理论部分偏少但也会写一些自己的理解。
        在之前大二上数据结构的时候我也有写过一个关于排序的专题介绍数据结构复习——内部排序

        +

        前言

        最近在复习数据结构，顺便整理之前刷题的一些模板和技巧，希望对大家都有帮助，博客会侧重讲解的是OJ代码实现，理论部分偏少但也会写一些自己的理解。
        在之前大二上数据结构的时候我也有写过一个关于排序的专题介绍数据结构复习——内部排序

        @@ -432,7 +432,7 @@

        EfficientNet论文解读和pytorch代码实现

        传送门

        论文地址：https://arxiv.org/pdf/1905.11946.pdf
        官方github：https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet
        github参考：https://github.com/qubvel/efficientnet
        github参考：https://github.com/lukemelas/EfficientNet-PyTorch

        -

        摘要

        谷歌的文章总是能让我印象深刻，不管从实验上还是论文的书写上都让人十分的佩服，不得不说这确实是一个非常creative的公司!
        Convolutional Neural Networks (ConvNets) are commonly developed at a fixed resource budget, and then scaled up for better accuracy if more resources are available. In this paper, we systematically study model scaling and identify that carefully balancing network depth, width, and resolution can lead to better performance. Based on this observation, we propose a new scaling method that uniformly scales all dimensions of depth/width/resolution using a simple yet highly effective compound coefficient. We demonstrate the effectiveness of this method on scaling up MobileNets and ResNet.
        卷积神经网络通常是在固定的资源预算下进行计算和发展的，如果有更多可用的资源，模型能通过缩放和扩展获得更好的效果，本文系统研究（工作量很充足）了模型缩放，并且证明了细致地平衡网络的深度，宽度，和分辨率能够得到更好的效果，基于这个观点，我们提出了一个新的尺度缩放的方法，我们提出了一个新的尺度缩放的方法即：使用一个简单且高效的复合系数统一地缩放所有网络层的深度/宽度/分辨率的维度。我们证明了该方法在扩大MobileNets和ResNet方面的有效性。

        +

        摘要

        谷歌的文章总是能让我印象深刻，不管从实验上还是论文的书写上都让人十分的佩服，不得不说这确实是一个非常creative的公司!
        Convolutional Neural Networks (ConvNets) are commonly developed at a fixed resource budget, and then scaled up for better accuracy if more resources are available. In this paper, we systematically study model scaling and identify that carefully balancing network depth, width, and resolution can lead to better performance. Based on this observation, we propose a new scaling method that uniformly scales all dimensions of depth/width/resolution using a simple yet highly effective compound coefficient. We demonstrate the effectiveness of this method on scaling up MobileNets and ResNet.
        卷积神经网络通常是在固定的资源预算下进行计算和发展的，如果有更多可用的资源，模型能通过缩放和扩展获得更好的效果，本文系统研究（工作量很充足）了模型缩放，并且证明了细致地平衡网络的深度，宽度，和分辨率能够得到更好的效果，基于这个观点，我们提出了一个新的尺度缩放的方法，我们提出了一个新的尺度缩放的方法即：使用一个简单且高效的复合系数统一地缩放所有网络层的深度/宽度/分辨率的维度。我们证明了该方法在扩大MobileNets和ResNet方面的有效性。

        @@ -506,7 +506,7 @@

        -

        yolov1-3论文解析

        最近在看经典目标检测算法yolo的思想，为了更好的了解yolo系列的相关文章，我从最初版本的论文思想开始看的，之后有时间会把yolov4和yolov5再认真看看，目前来说yolov3的spp版本是使用得最为广泛的一种，整体上来说yolo的设计思想还是很有创造性的数学也比较严谨。

        +

        yolov1-3论文解析

        最近在看经典目标检测算法yolo的思想，为了更好的了解yolo系列的相关文章，我从最初版本的论文思想开始看的，之后有时间会把yolov4和yolov5再认真看看，目前来说yolov3的spp版本是使用得最为广泛的一种，整体上来说yolo的设计思想还是很有创造性的数学也比较严谨。

        @@ -658,9 +658,7 @@

        commit镜像

        在这里插入图片描述

        -

        数据卷操作实战：mysql同步

        mysql运行容器，需要做数据挂载，安装启动mysql是需要配置密码的这一点要注意，所以要去docker hub官方文档上面去看官方配置

        -
        docker pull mysql:5.7
        - +

        数据卷操作实战：mysql同步

        mysql运行容器，需要做数据挂载，安装启动mysql是需要配置密码的这一点要注意，所以要去docker hub官方文档上面去看官方配置

        docker pull mysql:5.7

        docker运行，docker run的常用参数这里我们再次回顾一下

        -d 后台运行
        -p 端口映射
        -v 卷挂载
        -e 环境配置
        --name 环境名字
        @@ -737,36 +735,39 @@

        Docker 常用命令

        帮助命令

        docker version #显示docker版本信息
        docker info #显示docker的系统信息，包括镜像和容器的数量
        docker 命令 --help # 帮助命令
        -

        镜像命令

        1.docker images查看所有本地的主机镜像

        +
        - - + + - - - + + + + - - + + - - + + - - + + - - + + -
        docker images显示字段解释docker images显示字段解释
        REPOSITORY镜像的仓库源
        REPOSITORY镜像的仓库源
        TAG镜像的标签TAG镜像的标签
        IMAGE ID镜像的idIMAGE ID镜像的id
        CREATED镜像的创建时间CREATED镜像的创建时间
        SIZE镜像的大小SIZE镜像的大小
        + + +
        @@ -1209,7 +1210,7 @@

      • - 编译原理 + 数据库系统
      • @@ -1217,15 +1218,15 @@

      • - Hexo + 编译原理
      • - 数据库系统 + Go
      • - Go + Hexo
      • diff --git a/page/3/index.html b/page/3/index.html index 974325ef..ac66d2fd 100644 --- a/page/3/index.html +++ b/page/3/index.html @@ -207,7 +207,7 @@

        -

        datawhale语义分割-Task3 语义分割模型发展

        本章主要讲解的是语义分割网络模型的发展：FCN 、SegNet、Unet、DeepLab、RefineNet、PSPNet、GAN语义分割。

        +

        datawhale语义分割-Task3 语义分割模型发展

        本章主要讲解的是语义分割网络模型的发展：FCN 、SegNet、Unet、DeepLab、RefineNet、PSPNet、GAN语义分割。

        @@ -285,7 +285,7 @@

        -

        语义分割-Task2 数据扩增

        本章对语义分割任务中常见的数据扩增方法进行介绍，并使用OpenCV和albumentations两个库完成具体的数据扩增操作。
        干货链接：
        albumentations 数据增强工具的使用
        Pytorch：transforms的二十二个方法
        Pytorch使用albumentations实现数据增强

        +

        语义分割-Task2 数据扩增

        本章对语义分割任务中常见的数据扩增方法进行介绍，并使用OpenCV和albumentations两个库完成具体的数据扩增操作。
        干货链接：
        albumentations 数据增强工具的使用
        Pytorch：transforms的二十二个方法
        Pytorch使用albumentations实现数据增强

        @@ -443,8 +443,7 @@

        缺失数据

        import numpy as np
        import pandas as pd
        - -

        一、缺失值的统计和删除

        1. 缺失信息的统计

        缺失数据可以使用 isna 或 isnull （两个函数没有区别）来查看每个单元格是否缺失，结合 mean 可以计算出每列缺失值的比例：

        +

        一、缺失值的统计和删除

        1. 缺失信息的统计

        缺失数据可以使用 isna 或 isnull （两个函数没有区别）来查看每个单元格是否缺失，结合 mean 可以计算出每列缺失值的比例：

        @@ -523,8 +522,7 @@

        datawhale-pandas数据分析预备

        列表推导式

        def my_func(x):
            return 2*x
        - -

        [* for i in *]

        其中，第一个 * 为映射函数，其输入为后面 i 指代的内容，第二个 * 表示迭代的对象。

        +

        [ for i in ]

        其中，第一个 为映射函数，其输入为后面 i 指代的内容，第二个 表示迭代的对象。

        @@ -602,7 +600,7 @@

        -

        理发师问题

        7.8 The Sleeping-Barber Problem. A barbershop consists of a waiting room with n chairs and the barber room containing the barber chair. If there are no customers to be served,the barber goes to sleep. If a customer enters the barbershop and all chairs are occupied, then the customer leaves the shop.If the barber is busy but chairs are available, then the customer sits in one of the free chairs. If the barber is asleep, the customer wakes up the barber. Write a program to coordinate the barber and the customers.

        +

        理发师问题

        7.8 The Sleeping-Barber Problem. A barbershop consists of a waiting room with n chairs and the barber room containing the barber chair. If there are no customers to be served,the barber goes to sleep. If a customer enters the barbershop and all chairs are occupied, then the customer leaves the shop.If the barber is busy but chairs are available, then the customer sits in one of the free chairs. If the barber is asleep, the customer wakes up the barber. Write a program to coordinate the barber and the customers.

        @@ -676,7 +674,7 @@

        -

        复习题

        Use only the INVENTORY table to answer Review Questions 2.17 through 2.40:

        +

        复习题

        Use only the INVENTORY table to answer Review Questions 2.17 through 2.40:

        @@ -827,7 +825,7 @@

        通常操作系统提供的主要功能都是由内核程序实现的，处理机在运行上层程序时，能进入操作系统内核运行的唯一途径就是中断或者异常。

        -

        中断和异常基本概念

        中断(Interruption)：也称外中断，指来自处理机执行指令以外的事件发生。
        异常(Exception)：也称内中断、例外、自陷(trap),指源自处理机执行指令内部的事件。

        +

        中断和异常基本概念

        中断(Interruption)：也称外中断，指来自处理机执行指令以外的事件发生。
        异常(Exception)：也称内中断、例外、自陷(trap),指源自处理机执行指令内部的事件。

        @@ -901,7 +899,7 @@

        -

        操作系统比较硬核，不过最近发现了王道考研这个比较好的课程。这里是一些学习笔记总结。

        +

        操作系统比较硬核，不过最近发现了王道考研这个比较好的课程。这里是一些学习笔记总结。

        @@ -1187,7 +1185,7 @@

      • - 编译原理 + 数据库系统
      • @@ -1195,15 +1193,15 @@

      • - Hexo + 编译原理
      • - 数据库系统 + Go
      • - Go + Hexo
      • diff --git a/page/4/index.html b/page/4/index.html index 7ea91949..6c86e662 100644 --- a/page/4/index.html +++ b/page/4/index.html @@ -207,7 +207,7 @@

        -

        对象与属性

        同其他语言里面所描述的对象一样，在js里，一个对象就是一系列属性的集合，一个属性包含一个名和一个值。一个属性的值可以是函数，这种情况下属性也被称为方法。一个对象的属性可以被解释成一个附加到对象上的变量。对象有时也被叫作关联数组, 因为每个属性都有一个用于访问它的字符串值。

        +

        对象与属性

        同其他语言里面所描述的对象一样，在js里，一个对象就是一系列属性的集合，一个属性包含一个名和一个值。一个属性的值可以是函数，这种情况下属性也被称为方法。一个对象的属性可以被解释成一个附加到对象上的变量。对象有时也被叫作关联数组, 因为每个属性都有一个用于访问它的字符串值。

        @@ -287,7 +287,7 @@

        语言和文法

        编译原理第二章文法分类，紫书内容和mooc知识总结，重新回顾了4种文法的知识。

        文法分类

        乔姆斯基把语言文法分成4类，0型，1型，2型，3型，这几类文法的差别主要在于对产生式的限制不同，等级越高，限制越严格。

        -

        0型文法

        0型文法是文法限制最弱的一种类型，0型文法的能力又被相当于图灵机模型，或者说任何0型文法都是递归可枚举的，反之，递归可枚举的一定是一个0型语言。

        +

        0型文法

        0型文法是文法限制最弱的一种类型，0型文法的能力又被相当于图灵机模型，或者说任何0型文法都是递归可枚举的，反之，递归可枚举的一定是一个0型语言。

        @@ -361,7 +361,7 @@

        -

        SQL又称结构化查询语句（Structed Query Language）是关系数据库的标准语言，也是一个通用的，功能极强的关系数据库语言。
        SQL集数据查询、数据操纵、数据定义、数据控制功能于一体。
        目前没有一个数据库系统能支持SQL标准的所有概念和特性。但同时许多软件厂商对SQL基本命令集还进行了不同程度的扩充和修改，又可以支持标准以外的一些功能特性。

        +

        SQL又称结构化查询语句（Structed Query Language）是关系数据库的标准语言，也是一个通用的，功能极强的关系数据库语言。
        SQL集数据查询、数据操纵、数据定义、数据控制功能于一体。
        目前没有一个数据库系统能支持SQL标准的所有概念和特性。但同时许多软件厂商对SQL基本命令集还进行了不同程度的扩充和修改，又可以支持标准以外的一些功能特性。

        @@ -435,7 +435,7 @@

        -

        这次要介绍的是js的数组对象，其实在js里面他本质上是一种object对象（他的原型），创建和使用方法和python有点类似,最重要的一点数组里面的数据类型可以是各种类型。

        +

        这次要介绍的是js的数组对象，其实在js里面他本质上是一种object对象（他的原型），创建和使用方法和python有点类似,最重要的一点数组里面的数据类型可以是各种类型。

        @@ -513,7 +513,7 @@

        -

        这一块关于闭包和箭头函数理解还不够，先提交一点记录一下，后期再补

        +

        这一块关于闭包和箭头函数理解还不够，先提交一点记录一下，后期再补

        @@ -591,7 +591,7 @@

        -

        本文将记录学习JavaScript(包含有ES)语法基础,主要来自MDN的官方文档

        +

        本文将记录学习JavaScript(包含有ES)语法基础,主要来自MDN的官方文档

        @@ -743,7 +743,7 @@

        -

        进程是支持程序执行的机制，可以理解为程序对数据或请求的处理过程，是一个独立功能的程序关于数据集合的一次运动活动，是操作系统进行资源分配的一个单位。在介绍相关知识之前，首先我们需要了解几个重要概念。
        进程实体主要包含PCB，程序段，数据段三个部分构成进程实体又称进程映像。
        PCB是指系统为每个运行的程序分配了一个数据结构被称为进程控制块。PCB是进程存在的唯一标志，创建进程和撤销进程实质上都是创建和撤销PCB。
        进程实体是静态的指进程三要素存放的数据，而进程是一个动态执行的过程，一般我们不区分进程和进程实体的概念，所以也可以说进程是由PCB，程序段，数据段组成。

        +

        进程是支持程序执行的机制，可以理解为程序对数据或请求的处理过程，是一个独立功能的程序关于数据集合的一次运动活动，是操作系统进行资源分配的一个单位。在介绍相关知识之前，首先我们需要了解几个重要概念。
        进程实体主要包含PCB，程序段，数据段三个部分构成进程实体又称进程映像。
        PCB是指系统为每个运行的程序分配了一个数据结构被称为进程控制块。PCB是进程存在的唯一标志，创建进程和撤销进程实质上都是创建和撤销PCB。
        进程实体是静态的指进程三要素存放的数据，而进程是一个动态执行的过程，一般我们不区分进程和进程实体的概念，所以也可以说进程是由PCB，程序段，数据段组成。

        @@ -817,7 +817,7 @@

        -

        Business Intelligence(BI) System介绍

        本文内容笔记摘录自王珊和萨师煊的《数据库系统概论》以及网上写的比较好的博客Business Intelligence,商务智能系统的组成,以及百度百科。

        +

        Business Intelligence(BI) System介绍

        本文内容笔记摘录自王珊和萨师煊的《数据库系统概论》以及网上写的比较好的博客Business Intelligence,商务智能系统的组成,以及百度百科。

        @@ -891,7 +891,7 @@

        -

        Concurrency-control mechanisms并发控制机制的必要性

        事务是并发控制的基本单位，保证事务的ACID特性是事务处理的重要任务，而事务的 ACID 特性可能遭到破坏的原因之一是多个事务对数据库的并发操作造成的。为了保证事务的隔离性和一致性，数据库管理系统需要对并发操作进行正确。并发操作带来的数据不一致性包括丢失修改、不可重复读和读“脏”数据。

        +

        Concurrency-control mechanisms并发控制机制的必要性

        事务是并发控制的基本单位，保证事务的ACID特性是事务处理的重要任务，而事务的 ACID 特性可能遭到破坏的原因之一是多个事务对数据库的并发操作造成的。为了保证事务的隔离性和一致性，数据库管理系统需要对并发操作进行正确。并发操作带来的数据不一致性包括丢失修改、不可重复读和读“脏”数据。

        @@ -1177,7 +1177,7 @@

        - 编译原理 + 数据库系统

      • @@ -1185,15 +1185,15 @@

        - Hexo + 编译原理

      • - 数据库系统 + Go
      • - Go + Hexo
      • diff --git a/page/5/index.html b/page/5/index.html index 08838ee7..9e8ff9fa 100644 --- a/page/5/index.html +++ b/page/5/index.html @@ -207,7 +207,7 @@

        -

        教师节快乐，害，今天听了一整天的新裤子的关于夜晚和失眠的世界，果然我还是喜欢music和乐队还有老歌，9月10号嗯，今天的到来其实也宣告暑假的一切都告一段落了（祝国赛的朋友们都能取得好成绩！），新学期开始了，害又要开始学习了，第一节课老师就来整英语，真难为我，呜呜呜。行吧，正好做作业就写写数据库的东西吧，首先声明这篇博客差不多是一种笔记吧，大部分的文字来源于书本和网上的博客，书本是王珊和萨师煊的《数据库系统概论》，博客的话参考了比较多，这里就挂一两个吧E-R 图简介,数据库的设计

        +

        教师节快乐，害，今天听了一整天的新裤子的关于夜晚和失眠的世界，果然我还是喜欢music和乐队还有老歌，9月10号嗯，今天的到来其实也宣告暑假的一切都告一段落了（祝国赛的朋友们都能取得好成绩！），新学期开始了，害又要开始学习了，第一节课老师就来整英语，真难为我，呜呜呜。行吧，正好做作业就写写数据库的东西吧，首先声明这篇博客差不多是一种笔记吧，大部分的文字来源于书本和网上的博客，书本是王珊和萨师煊的《数据库系统概论》，博客的话参考了比较多，这里就挂一两个吧E-R 图简介,数据库的设计

        @@ -282,7 +282,7 @@

        java的String类常用操作

        最近在准备蓝桥杯，补题目，顺便也是稍微缓一下暑假自闭，主要还是不想浪费300，顺便回顾一下java的基本语法，java的String类这一块感觉还是挺多操作的，字符串的不可变性也使得其操作和c++存在一些差别。这里需要推荐一个十分好的博客就是廖雪峰的java教程,其实菜鸟教程也不错的。

        -

        Java字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。

        +

        Java字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。

        @@ -356,7 +356,7 @@

        -

        时隔半年，我又重回微分方程的学习了，现在学确实挺难搞的，很多知识和理论思路都忘了，数学还是很重要啊，其实一个蛮简单的东西我看了很久很久才慢慢的又懂了，话不多说，直接写文。
        首先要明确的一点就是，我们求微分方程的时候，要注意有解析解和数值解，解析解又有通解和特解，这在我们编写代码的时候可以通过初始点的值来获得特解。其实今天老师讲的还挺不错的，举出了很多的例子，基本上与物理有关，其实要说这一个模块最稳妥的办法其实是如果能够求出通解，一般最好手动进行微分方程的求解，然后用计算机检验，用计算机求微分方程的情况大多数是求数值解。所以说这一部分的话，其实对建模的要求更高，求解我们到时候可以看到matlab调用函数就可以了

        +

        时隔半年，我又重回微分方程的学习了，现在学确实挺难搞的，很多知识和理论思路都忘了，数学还是很重要啊，其实一个蛮简单的东西我看了很久很久才慢慢的又懂了，话不多说，直接写文。
        首先要明确的一点就是，我们求微分方程的时候，要注意有解析解和数值解，解析解又有通解和特解，这在我们编写代码的时候可以通过初始点的值来获得特解。其实今天老师讲的还挺不错的，举出了很多的例子，基本上与物理有关，其实要说这一个模块最稳妥的办法其实是如果能够求出通解，一般最好手动进行微分方程的求解，然后用计算机检验，用计算机求微分方程的情况大多数是求数值解。所以说这一部分的话，其实对建模的要求更高，求解我们到时候可以看到matlab调用函数就可以了

        @@ -431,7 +431,7 @@

        最近学习了模拟退火智能算法，顺便学习了一下matlab，顺带一提matlba真香，对矩阵的操作会比python的numpy操作要更加方便，这里我们是以TSP问题为例子，因为比较好理解。

        -

        模拟退火介绍

        模拟退火总的来说还是一种优化算法，他模拟的是淬火冶炼的一个过程，通过升温增强分子的热运动，然后再慢慢降温，使其达到稳定的状态。

        +

        模拟退火介绍

        模拟退火总的来说还是一种优化算法，他模拟的是淬火冶炼的一个过程，通过升温增强分子的热运动，然后再慢慢降温，使其达到稳定的状态。

        @@ -505,7 +505,7 @@

        -

        今天研究了一下遗传算法，发现原理还是很好懂的，不过在应用层面上还是有很多要学习的方法，如何定义编码解码的过程，如何进行选择和交叉变异，这都是我们需要解决的事情，估计还是要多学多用才能学会，当然了如果大家对我写的这些内容如果有什么不同的看法的话也建议大家提出，毕竟算法小白一个。

        +

        今天研究了一下遗传算法，发现原理还是很好懂的，不过在应用层面上还是有很多要学习的方法，如何定义编码解码的过程，如何进行选择和交叉变异，这都是我们需要解决的事情，估计还是要多学多用才能学会，当然了如果大家对我写的这些内容如果有什么不同的看法的话也建议大家提出，毕竟算法小白一个。

        @@ -579,7 +579,7 @@

        -

        Hexo博客搭建

        鸽了半年的hexo博客搭建，阿里云都快过了半年了，把自己的一些踩坑和修改写一下吧，首先放一下我hexo博客搭建的时候的一些参考吧，这几个链接应该按道理没有很多踩坑的地方，我使用的主题是yilia主题所以说下面几个链接主要是关于yilia的，不过其实hexo博客框架的那个js和css名字都一样，配置文件的语法和格式也是一致的，所以说还是可以提供到一些帮助的，而且我自己在搭建一些操作的时候也学习了其他主题的一些方法。
        从0开始搭建一个hexo博客无坑教程，是真的无坑版本，一切顺利（这里需要感谢一位b站的良心up主codesheep，他其他的视频也不错哦）：
        手把手教你从0开始搭建自己的个人博客 |无坑版视频教程| hexo
        美化相关链接：

        +

        Hexo博客搭建

        鸽了半年的hexo博客搭建，阿里云都快过了半年了，把自己的一些踩坑和修改写一下吧，首先放一下我hexo博客搭建的时候的一些参考吧，这几个链接应该按道理没有很多踩坑的地方，我使用的主题是yilia主题所以说下面几个链接主要是关于yilia的，不过其实hexo博客框架的那个js和css名字都一样，配置文件的语法和格式也是一致的，所以说还是可以提供到一些帮助的，而且我自己在搭建一些操作的时候也学习了其他主题的一些方法。
        从0开始搭建一个hexo博客无坑教程，是真的无坑版本，一切顺利（这里需要感谢一位b站的良心up主codesheep，他其他的视频也不错哦）：
        手把手教你从0开始搭建自己的个人博客 |无坑版视频教程| hexo
        美化相关链接：

        • 参考链接1
        • 参考链接2
          • @@ -735,7 +735,7 @@

          数值数据表示的三要素：
          1.进位计数制
          2.定点、浮点表示
          3.如何用二进制编码
          即：要确定一个数值数据的值必须先确定这三个要素。
          例如机器数 01011001的值是多少？答案是不知道

          -

          原码

          原码范围:-127~+127

          +

          原码

          原码范围:-127~+127

          @@ -1095,7 +1095,7 @@

        • - 编译原理 + 数据库系统
        • @@ -1103,15 +1103,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git a/tags/Go/index.html b/tags/Go/index.html index 94db5e6e..47347933 100644 --- a/tags/Go/index.html +++ b/tags/Go/index.html @@ -466,7 +466,7 @@

        • - 编译原理 + 数据库系统
        • @@ -474,15 +474,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git a/tags/Hexo/index.html b/tags/Hexo/index.html index 65f6e7ba..543c5dd4 100644 --- a/tags/Hexo/index.html +++ b/tags/Hexo/index.html @@ -466,7 +466,7 @@

        • - 编译原理 + 数据库系统
        • @@ -474,15 +474,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git a/tags/Java/index.html b/tags/Java/index.html index fdfd2dbd..ff9fe519 100644 --- a/tags/Java/index.html +++ b/tags/Java/index.html @@ -466,7 +466,7 @@

        • - 编译原理 + 数据库系统
        • @@ -474,15 +474,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git a/tags/JavaScript/index.html b/tags/JavaScript/index.html index c7179570..4ceb135a 100644 --- a/tags/JavaScript/index.html +++ b/tags/JavaScript/index.html @@ -596,7 +596,7 @@

        • - 编译原理 + 数据库系统
        • @@ -604,15 +604,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git a/tags/datawhale/index.html b/tags/datawhale/index.html index 8adefa4b..a2c1fbf6 100644 --- a/tags/datawhale/index.html +++ b/tags/datawhale/index.html @@ -858,7 +858,7 @@

        • - 编译原理 + 数据库系统
        • @@ -866,15 +866,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git a/tags/docker/index.html b/tags/docker/index.html index c62ca68e..442800b3 100644 --- a/tags/docker/index.html +++ b/tags/docker/index.html @@ -542,7 +542,7 @@

        • - 编译原理 + 数据库系统
        • @@ -550,15 +550,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git a/tags/linux/index.html b/tags/linux/index.html index b7ddfde0..c82bafbf 100644 --- a/tags/linux/index.html +++ b/tags/linux/index.html @@ -466,7 +466,7 @@

        • - 编译原理 + 数据库系统
        • @@ -474,15 +474,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git a/tags/pandas/index.html b/tags/pandas/index.html index 58c332ad..711e2fc7 100644 --- a/tags/pandas/index.html +++ b/tags/pandas/index.html @@ -522,7 +522,7 @@

        • - 编译原理 + 数据库系统
        • @@ -530,15 +530,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git "a/tags/web\345\237\272\347\241\200/index.html" "b/tags/web\345\237\272\347\241\200/index.html" index af424d76..3c513c8d 100644 --- "a/tags/web\345\237\272\347\241\200/index.html" +++ "b/tags/web\345\237\272\347\241\200/index.html" @@ -634,7 +634,7 @@

        • - 编译原理 + 数据库系统
        • @@ -642,15 +642,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git a/tags/youth/index.html b/tags/youth/index.html index 5875470b..1d3d76c6 100644 --- a/tags/youth/index.html +++ b/tags/youth/index.html @@ -670,7 +670,7 @@

        • - 编译原理 + 数据库系统
        • @@ -678,15 +678,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git "a/tags/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" "b/tags/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" index 1bcb7f4d..6009d469 100644 --- "a/tags/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" +++ "b/tags/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" @@ -580,7 +580,7 @@

        • - 编译原理 + 数据库系统
        • @@ -588,15 +588,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git "a/tags/\346\225\260\345\255\246\345\273\272\346\250\241/index.html" "b/tags/\346\225\260\345\255\246\345\273\272\346\250\241/index.html" index fbd6059b..18e2025e 100644 --- "a/tags/\346\225\260\345\255\246\345\273\272\346\250\241/index.html" +++ "b/tags/\346\225\260\345\255\246\345\273\272\346\250\241/index.html" @@ -542,7 +542,7 @@

        • - 编译原理 + 数据库系统
        • @@ -550,15 +550,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git "a/tags/\346\225\260\346\215\256\345\272\223\347\263\273\347\273\237/index.html" "b/tags/\346\225\260\346\215\256\345\272\223\347\263\273\347\273\237/index.html" index c66f2ae1..ab33ac0e 100644 --- "a/tags/\346\225\260\346\215\256\345\272\223\347\263\273\347\273\237/index.html" +++ "b/tags/\346\225\260\346\215\256\345\272\223\347\263\273\347\273\237/index.html" @@ -618,7 +618,7 @@

        • - 编译原理 + 数据库系统
        • @@ -626,15 +626,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git "a/tags/\346\225\260\346\215\256\347\273\223\346\236\204/index.html" "b/tags/\346\225\260\346\215\256\347\273\223\346\236\204/index.html" index b14b603d..272d9d01 100644 --- "a/tags/\346\225\260\346\215\256\347\273\223\346\236\204/index.html" +++ "b/tags/\346\225\260\346\215\256\347\273\223\346\236\204/index.html" @@ -580,7 +580,7 @@

        • - 编译原理 + 数据库系统
        • @@ -588,15 +588,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git "a/tags/\346\234\272\345\231\250\345\255\246\344\271\240/index.html" "b/tags/\346\234\272\345\231\250\345\255\246\344\271\240/index.html" index 416fa573..6a743aca 100644 --- "a/tags/\346\234\272\345\231\250\345\255\246\344\271\240/index.html" +++ "b/tags/\346\234\272\345\231\250\345\255\246\344\271\240/index.html" @@ -596,7 +596,7 @@

        • - 编译原理 + 数据库系统
        • @@ -604,15 +604,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git "a/tags/\347\274\226\350\257\221\345\216\237\347\220\206/index.html" "b/tags/\347\274\226\350\257\221\345\216\237\347\220\206/index.html" index e038d4a8..09fd4152 100644 --- "a/tags/\347\274\226\350\257\221\345\216\237\347\220\206/index.html" +++ "b/tags/\347\274\226\350\257\221\345\216\237\347\220\206/index.html" @@ -466,7 +466,7 @@

        • - 编译原理 + 数据库系统
        • @@ -474,15 +474,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git "a/tags/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/index.html" "b/tags/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/index.html" index 589d696d..42163866 100644 --- "a/tags/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/index.html" +++ "b/tags/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/index.html" @@ -466,7 +466,7 @@

        • - 编译原理 + 数据库系统
        • @@ -474,15 +474,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo
        • diff --git "a/tags/\350\256\241\347\256\227\346\234\272\350\247\206\350\247\211/index.html" "b/tags/\350\256\241\347\256\227\346\234\272\350\247\206\350\247\211/index.html" index a12e5cde..acd420a6 100644 --- "a/tags/\350\256\241\347\256\227\346\234\272\350\247\206\350\247\211/index.html" +++ "b/tags/\350\256\241\347\256\227\346\234\272\350\247\206\350\247\211/index.html" @@ -762,7 +762,7 @@

        • - 编译原理 + 数据库系统
        • @@ -770,15 +770,15 @@

        • - Hexo + 编译原理
        • - 数据库系统 + Go
        • - Go + Hexo