精华内容
下载资源
问答
  • BERT是目前最强大的NLP预...谷歌的研究人员提出新的优化器,使用1024块TPU,将BERT的训练时间从3成功缩短到76分钟,提速 65.2 倍! 去年,谷歌发布了最强预训练模型 BERT,宣告了NLP领域的项重大突破。 B...

    https://www.toutiao.com/a6675934997636973067/

     

    BERT是目前最强大的NLP预训练模型,也是工业界目前最耗时的应用,计算量远高于ImageNet。谷歌的研究人员提出新的优化器,使用1024块TPU,将BERT的训练时间从3天成功缩短到76分钟,提速 65.2 倍!

    去年,谷歌发布了最强预训练模型 BERT,宣告了NLP领域的一项重大突破。

    BERT 在 33 亿文本的语料上训练语言模型,再分别在不同的下游任务上微调,在11个不同的 NLP 任务均得到了目前为止最好的结果。

    不过,在 33 亿文本的语料上预训练一个 BERT 模型的成本是非常大的,谷歌用了 16 个自己的 TPU 集群(一共 64 块 TPU)来训练大号版本的 BERT,一共花了约4天的时间。

    如此巨大的训练成本,让普通研究者难以尝试自己去训练一个BERT。

    有没有办法加快BERT的训练呢?近日,来自Google、UC Berkeley、UCLA的几位研究人员提出新的优化器——LAMB 优化器,将训练的batch size推到硬件的极限,使用 TPU Pod ( 1024块 TPUv3 芯片),将BERT的训练时间从3天缩短到了76分钟

    从3天到1小时,谷歌给最耗时的BERT预训练时间狂吃加速

     

    论文地址:

    「链接」

    其中一作尤洋(Yang You)来自UC Berkeley,这项工作于他在Google Brain实习期间完成。

    接下来,新智元带来对这篇论文的译介:

    加快深度神经网络最有效的方法

    大批量训练 (large-batch training) 是加快大型分布式系统中深度神经网络训练的关键。然而, large-batch 训练是很困难的,因为它会产生一种泛化差距 (generalization gap)。直接优化通常会导致测试集的准确性下降。

    BERT 是一种最先进的深度学习模型,建立在用于语言理解的深度双向 transformers 之上。对 BERT 来说,当扩大批大小 (例如超过 8192) 时,以前的 large-batch 训练技术效果并不好。BERT 的预训练也需要很长时间才能完成 (使用 16 个 TPUv3 芯片大约需要 3 天)。

    为了解决这个问题,我们提出了 LAMB 优化器,它帮助我们将批大小扩大到 65536,而不会丢失准确性

    LAMB 是一个通用的优化器,适用于小批量和大批量,并且除了学习率外不需要超参数调优。基线 BERT-Large 模型需要 100 万次迭代才能完成预训练,而 batch size 为65536/32768 的 LAMB 只需要 8599 次迭代。我们将 batch size 推到 TPUv3 pod 的内存上限,可以在 76 分钟内完成 BERT 训练 (表 1)。

    从3天到1小时,谷歌给最耗时的BERT预训练时间狂吃加速

     

    表 1:我们使用 SQuAD-v1 的 F1 score 作为精度指标。F1 的基线成绩是由 BERT 的公共 github 提供的预训练模型 (BERT- large) 实现的 (截止到 2019 年 2 月 1 日)。我们在实验中使用 tpuv3。我们使用了与基线相同的设置:总 epochs 的前 9/10 使用序列长度128,最后 1/10 使用序列长度 512。所有的实验运行相同数量的 epochs。

    深度神经网络的训练是十分耗时的。目前,减少训练时间最有效的方法是使用多个芯片(如 CPU、GPU 和 TPU) 来并行化 SGD 变体的优化过程。由于前向传播和反向传播中不同层之间的数据依赖关系,使得跨层的并行化效率并不高。相反,研究人员在每次迭代中并行化小批量中的数据点。如果确定了训练的 epochs 的数量,那么线性地增大batch size 意味着会线性地减少迭代次数 (即更新权重的次数)。为了最小化训练时间,最大化 batch size 将是理想的。

    然而,大批量的训练是困难的。例如,使用大小为 512 的 batch size 训练在 ImageNet上训练 AlexNet,能实现 80% 以上的 top-5 测试精度。但将 batch size 扩大到 4096之后,直接训练可能只能获得 50% ~ 60% 的 top 5 精度。

    Keskar 等人 (10) 认为在大批量训练中存在一个泛化差距 (generalization gap)。Hoffer等人 (6) 认为,训练时间越长,泛化差距越小。然而,训练时间过长意味着进行大批量训练就没有好处了。

    因此,大批量训练的目标是在一定数量的 epochs 内达到可观的精度。通过设计一系列的学习率计划表,研究者已经可以将 ImageNet 训练的 batch size 扩大到 32K,并且精度损失较小。据我们所知, Ying et al. 实现了目前最快的 ImageNet 训练速度,并且达到了 76+% 的 top-1 精度。通过使用 LARS 优化器,将 batch size 扩展到 32K,,Ying等人使用 TPUv3 Pod,在 2.2 分钟内完成了 ResNet-50 的 ImageNet 训练。(最新,富士通研究院刷新了这一速度,将 ImageNet 训练时间降到 74.7 秒)

    BERT 是目前最先进的深度学习语言模型。BERT 建立在用于语言理解的深度双向transformers 之上。对 BERT 来说,当将 batch size 扩大到非常大时 (例如超过8192),以前的 large-batch 训练技术效果并不好。BERT 的预训练也需要很长时间才能完成 (使用 16 个 TPUv3 芯片大约需要 3 天)。

    为了扩大 BERT 的 batch size,本文提出 LAMB 优化器。LAMB 支持自适应 element-wise updating 和精确的逐层修正 (layer-wise correction)。

    LAMB 是一个适用于小批量和大批量的通用优化器。用户只需要调整学习率,不需要调其他超参数。使用 LAMB,我们可以将 BERT 预训练的批大小扩大到 64K,而不会丢失准确性。

    BERT 预训练包括两个阶段

    (1) 前 9/10 的 epochs 使用 128 的序列长度;

    (2) 后 1/10 epochs 使用 512 的序列长度。

    baseline 需要 100 万次迭代来完成 BERT 预训练,但我们只需要 8599 次迭代,这使我们能够将 BERT 训练时间从 3 天减少到 76 分钟。

    我们将批大小推到了 TPU Pod 的硬件极限。批大小大于 32768(序列长度为 512) 的话将耗尽内存。批大小大于 65536(序列长度为 128) 则不会带来任何加速。我们的优化器可以将批大小扩大到 128k,甚至更大。由于硬件限制,序列长度为 512 的设置下,我们在批大小达到 32768 时停下,在序列长度为 128 的设置下,批大小达到 65536 时停止。

    本文中所有的 BERT 模型都指 BERT-Large 模型。为了进行公平的比较,本文所有的实验都运行相同数量的 epochs(即固定数量的浮点运算)。我们的结果如表 1 所示。

    LAMB优化器

    LAMB的全称是Layer-wise Adaptive Moments optimizer for Batch training。

     

    BERT 训练的基线使用权重衰减的 Adam 作为优化器,这是 Adam 优化器的一个变体。另一个成功应用于大批量卷积神经网络训练的自适应优化器是 LARS。

    这些优化器启发我们提出了新的优化器,用于大批量 BERT 训练。我们提出的 LAMB 优化器的概述如算法 1 所示。

    从3天到1小时,谷歌给最耗时的BERT预训练时间狂吃加速

     

    实验和结果

    常规训练

    TPU 是浮点运算的强大计算硬件。我们在所有的实验中都使用了 TPUv3。TPUv3 Pod有 1024 个芯片,可以为混合精度计算提供超过 100 petaflops 的性能。我们的结果如表 1 所示。基线模型在预训练时使用 Wikipedia 和 BooksCorpus 数据集。

    我们使用了与原始 BERT 模型相同的数据集,即 Wikipedia 和 BooksCorpus,分别有2.5B 和 8 亿单词。原始 BERT 模型的作者首先以 128 的序列长度进行了 900k 次迭代训练,然后以 512 的序列长度进行了 100k 迭代训练。

    16 个 TPUv3 芯片的总训练时间约为 3 天。我们使用 SQuAD-v1 的 F1 分数作为精度指标。F1 得分越高,准确度越高。斯坦福问答数据集 (SQuAD) 是一个阅读理解数据集,包含众包工作者从维基百科的文章中提出的问题,每一个问题的答案都是对应阅读文章的一段文字,或者该问题无法回答。我们从 BERT 的公开 GitHub 库上下载了预训练好的模型。

    使用作者提供的脚本,baseline 的 F1 得分为 90.395。在我们的代码中,我们使用了BERT 的作者提供的数据集和基线模型,只修改了优化器。通过使用 LAMB 优化器,我们能够在批大小为 32768 的 15625 次迭代中获得 91.460 的 F1 分数 (序列长度为 128的 14063 次迭代和序列长度为 512 的 1562 次迭代)。

    我们把训练时间从 3 天减少到100 分钟左右。我们将批大小推到了 TPU Pod 的硬件极限。批大小大于 32768 时 (序列长度为 512) 将导致 TPU Pod 耗尽内存。

    我们实现了 76.7% 的弱扩展效率 (49.1 倍的加速,64 倍的计算资源)。由于我们在 TPU Pod 上使用同步数据并行来进行分布式训练,因此在互连上传输梯度会带来通信开销。梯度的大小与训练后的模型相同。

    Mixed-Batch 训练

    如前所述,BERT 预训练包括两个阶段:

    (1) 前 9/10 的 epoch 使用 128 的序列长度,

    (2) 最后 1/10 的 epoch 使用 512 的序列长度。

    对于第二阶段,由于内存限制,TPUv3 Pod 上的最大批大小为 32768,因此我们将第二阶段在批大小达到 32768 时停止。

    对于第一阶段,由于内存限制,TPUv3 Pod 上的最大批大小是 131072。但是,当我们将批大小从 65536 增加到 131072 时,并没有看到加速,因此我们在第一阶段批大小达到 65536 时停止。

    此前,Smith 等人也研究了混合批训练。但是,他们在训练中增大了批大小,而我们减小了批大小。

    我们能够从头到尾充分利用硬件资源。Smith 等人的研究只在最后阶段充分利用了硬件资源。增加批大小可以 warm-up 和稳定优化过程,但是减小批大小会给优化过程带来混乱,导致训练不收敛。

    在实验中,我们发现了一种有助于稳定第二阶段优化的方法。由于我们切换到一个不同的优化问题,有必要重新 warm-up 优化过程。在第二阶段,我们没有降低学习率,而是将学习率从零开始增加 (re-warm-up)。

    通过这些改变,我们只需要 8599 次迭代,可以在 76 分钟左右完成 BERT 训练,实现了 101.8% 的弱缩放效率 (weak scaling efficiency),提速 65.2 倍,利用了 64 倍的计算资源

    结论

    Large batch 技术是加快神经网络深度训练的关键。在本文中,我们提出了支持adaptive element-wise updating 和 layer-wise correction 的 LAMB 优化器。LAMB是一个通用的优化器,适用于小批量和大批量。通过使用 LAMB,我们可以将 BERT 预训练的 batch size 扩展到 64K,而不会丢失准确性。我们将 BERT 的训练时间从 3 天减少到 76 分钟左右,并将批大小推到了 TPU Pod 的硬件极限。我们正在研究 LAMB优化器的理论分析。

    展开全文
  • # 试题 入门训练 Fibonacci数列 资源限制 时间限制:1.0s 内存限制:256.0MB 问题描述 Fibonacci数列的递推公式为:Fn=Fn-1+Fn-2,其中F1=F2=1。 当n比较大时,Fn也非常大,现在我们想知道,Fn除以10007的余数是多少...

    scala实现Fibonacci数列

    试题 入门训练 Fibonacci数列

    资源限制
    时间限制:1.0s 内存限制:256.0MB
    问题描述
    Fibonacci数列的递推公式为:Fn=Fn-1+Fn-2,其中F1=F2=1。

    当n比较大时,Fn也非常大,现在我们想知道,Fn除以10007的余数是多少。

    输入格式
    输入包含一个整数n。
    输出格式
    输出一行,包含一个整数,表示Fn除以10007的余数。
    说明:在本题中,答案是要求Fn除以10007的余数,因此我们只要能算出这个余数即可,而不需要先计算出Fn的准确值,再将计算的结果除以10007取余数,直接计算余数往往比先算出原数再取余简单。

    样例输入
    10
    样例输出
    55
    样例输入
    22
    样例输出
    7704
    数据规模与约定
    1 <= n <= 1,000,000。

    代码一:

    import java.util.Scanner;
    class Main {
        public static void main(String[] args) {
            int f1 = 1;
            int f2 = 1;
            int n = new Scanner(System.in).nextInt();
            if (n < 3) {
                System.out.println(1);
                return;
            }
            int f3 = 0;
            for (int i = 3; i <= n; i++) {
                f3 = (f1 + f2) % 10007; //第三个数等于前两个数之和
                f1 = f2;
                f2 = f3;
            }
            System.out.println(f3);
        }
    }
    

    代码二:运行超时

    原因:该题目的目的是让我们:

    在本题中,答案是要求Fn除以10007的余数,因此我们只要能算出这个余数即可,而不需要先计算出Fn的准确值,再将计算的结果除以10007取余数,直接计算余数往往比先算出原数再取余简单

    比如:(7+6)%5=(2+1)%5

    我们的递归算法没有实现这一点,仍然先算出Fn再算Fn的余数,所以运行时间一定会很长

    import java.util.Scanner;
    
    class Main {
        public static void main(String[] args) {
            Main a = new Main();
            int n = new Scanner(System.in).nextInt();
            /*for (int i=1;i<11;i++){
                System.out.print(a.fib(i) % 10007+" ");
            }
        }*/
            System.out.print(a.fib(n) % 10007+" ");
        }
    
        private int fib(int n) {
            // 非尾递归
            if (n == 1)
                return 1;
            if (n == 2)
                return 1;
            return fib(n - 1) + fib(n - 2);
        }
    }
    
    展开全文
  • 蓝桥杯练习系统习题-算法训练6

    千次阅读 2018-02-04 13:14:49
    蓝桥杯练习系统习题-算法训练6 题目搜索方式:Ctrl+F—-> 输入题目名称—>定位到解答. 算法训练 数对 问题描述  编写个程序,该程序从用户读入个整数,然后列出所有的数对,每个数对的乘积即为该数。 ...

    文章推荐

    蓝桥杯练习系统习题-算法训练6

    题目搜索方式:Ctrl+F—-> 输入题目名称—>定位到解答.

    入门训练(详见 算法-蓝桥杯习题(1-1))

    基础练习(详见 算法-蓝桥杯习题(2-1))

    基础练习(详见 算法-蓝桥杯习题(2-2))

    算法训练(详见 算法-蓝桥杯习题(3-1))

    算法训练(详见 算法-蓝桥杯习题(3-2))

    算法训练(详见 算法-蓝桥杯习题(3-3))

    算法训练(详见 算法-蓝桥杯习题(3-4))

    算法训练(详见 算法-蓝桥杯习题(3-5))

    算法训练(详见 算法-蓝桥杯习题(3-6))

    算法提高(详见 算法-蓝桥杯习题(4-1))

    算法提高(详见 算法-蓝桥杯习题(4-2))

    历届试题(详见 算法-蓝桥杯习题(5-1))

    历届试题(详见 算法-蓝桥杯习题(5-2))

     

    算法训练 数对

    问题描述
      编写一个程序,该程序从用户读入一个整数,然后列出所有的数对,每个数对的乘积即为该数。
      输入格式:输入只有一行,即一个整数。
      输出格式:输出有若干行,每一行是一个乘法式子。(注意:运算符号与数字之间有一个空格)
      输入输出样例
    样例输入
    32
    样例输出
    1 * 32 = 32
    2 * 16 = 32
    4 * 8 = 32
    8 * 4 = 32
    16 * 2 = 32
    32 * 1 = 32

     #include <stdio.h>  
     void getResult(int num)  
     {  
         int i;  
         for(i=1;i<=num;i++)  
         {  
             if(num%i==0)  
             {  
                 printf("%d * %d = %d\n",i,num/i,num);  
             }  
         }  
         return ;  
     }  
     main()  
     {  
         int num;  
         scanf("%d",&num);  
         getResult(num);  
         return 0;  
     }  
    

    算法训练 完数

    问题描述
      一个数如果恰好等于它的因子之和,这个数就称为“完数”。例如,6的因子为1、2、3,而6=1+2+3,因此6就是“完数”。又如,28的因子为1、2、4、7、14,而28=1+2+4+7+14,因此28也是“完数”。编写一个程序,判断用户输入的一个数是否为“完数”。
      输入格式:输入只有一行,即一个整数。
      输出格式:输出只有一行,如果该数为完数,输出yes,否则输出no。
      输入输出样例
    样例输入
    6
    样例输出
    yes

     #include <stdio.h>  
     void getResult(int num)  
     {  
         int i,sum=0;  
         for(i=1;i<num;i++)  
         {  
             if(num%i==0)  
             {  
                 sum+=i;  
             }  
         }  
         if(sum==num)  
         {  
             printf("yes\n");  
         }  
         else  
         {  
             printf("no\n");  
         }  
     }  
     main()  
     {  
         int num;  
         scanf("%d",&num);  
         getResult(num);  
         return 0;  
     }  
    

    算法训练 阿尔法乘积

    问题描述
      计算一个整数的阿尔法乘积。对于一个整数x来说,它的阿尔法乘积是这样来计算的:如果x是一个个位数,那么它的阿尔法乘积就是它本身;否则的话,x的阿尔法乘积就等于它的各位非0的数字相乘所得到的那个整数的阿尔法乘积。例如:4018224312的阿尔法乘积等于8,它是按照以下的步骤来计算的:
      4018224312 → 418224312 → 3072 → 372 → 42 → 4*2 → 8
      编写一个程序,输入一个正整数(该整数不会超过6,000,000),输出它的阿尔法乘积。
      输入格式:输入只有一行,即一个正整数。
      输出格式:输出相应的阿尔法乘积。
      输入输出样例
    样例输入
    4018224312
    样例输出
    8

     #include <stdio.h>  
     void getResult(long long int num)  
     {  
         long long  int n=1;  
         int i;  
         //出口设计  
         if(num<10)  
         {  
             printf("%I64d\n",num);  
             return ;  
         }  
         //相似设计  
         do  
         {  
             i=num%10;  
             num/=10;  
             if(i)  
             {  
                 n*=i;  
             }  
         }  
         while(num);  
         //递归调用   
         getResult(n);  
     }  
     main()  
     {  
         long long int num;  
         scanf("%I64d",&num);  
         getResult(num);  
         return 0;   
     }  
    

    算法训练 黑色星期五

    问题描述
      有些西方人比较迷信,如果某个月的13号正好是星期五,他们就会觉得不太吉利,用古人的说法,就是“诸事不宜”。请你编写一个程序,统计出在某个特定的年份中,出现了多少次既是13号又是星期五的情形,以帮助你的迷信朋友解决难题。
      说明:(1)一年有365天,闰年有366天,所谓闰年,即能被4整除且不能被100整除的年份,或是既能被100整除也能被400整除的年份;(2)已知1998年1月1日是星期四,用户输入的年份肯定大于或等于1998年。
      输入格式:输入只有一行,即某个特定的年份(大于或等于1998年)。
      输出格式:输出只有一行,即在这一年中,出现了多少次既是13号又是星期五的情形。
      输入输出样例
    样例输入
    1998
    样例输出
    3

     #include <stdio.h>  
     int getWeekOfFirstDay(int year)  
     {  
         //已知199811日是星期四  
         int i=1998,week=3;  
         int days=0;  
         for(i=1998;i<year;i++)  
         {  
             if(i%400==0||(i%4==0&&i%100!=0))  
             days+=366;  
             else  
             days+=365;  
         }  
         return (days+week)%7;  
     }  
     void printBlackFridayTimes(int year)  
     {  
         int day[2][12]={{31,28,31,30,31,30,31,31,30,31,30},{31,29,31,30,31,30,31,31,30,31,30}};  
         int week=getWeekOfFirstDay(year),flag=year%400==0||(year%4==0&&year%100!=0)?1:0;  
         int times=0,i,days=0;  
         //遍历12个月   
         for(i=0;i<12;i++)  
         {  
             //判断每个月13号是否是黑色星期五   
             if((days+12+week)%7==4)  
             times++;  
             days+=day[flag][i];   
         }  
         printf("%d\n",times);  
         return ;  
     }   
     main()  
     {  
         int year;  
         scanf("%d",&year);  
         printBlackFridayTimes(year);  
         return 0;  
     }  
    

    算法训练 6-3判定字符位置

    返回给定字符串s中元音字母的首次出现位置。英语元音字母只有‘a’、‘e’、‘i’、‘o’、‘u’五个。
      若字符串中没有元音字母,则返回0。
      只考虑小写的情况。
    样例输入
    and
    样例输出
    1

     #include <stdio.h>  
     #include <string.h>  
     #define MaxSize 1000  
     main()  
     {  
         char str[MaxSize];  
         int lenth,i;  
         gets(str);  
         lenth=strlen(str);  
         for(i=0;i<lenth;i++)  
         {  
             if(str[i]=='a'||str[i]=='e'||str[i]=='i'||str[i]=='o'||str[i]=='u')  
             {  
                 printf("%d\n",i+1);  
                 return 0;  
             }  
         }  
         printf("0\n");  
         return 0;  
     }  
    

    算法训练 9-7链表数据求和操作

      读入10个复数,建立对应链表,然后求所有复数的和。
    样例输入
    1 2
    1 3
    4 5
    2 3
    3 1
    2 1
    4 2
    2 2
    3 3
    1 1
    样例输出
    23+23i

     #include <stdio.h>  
     main()  
     {  
         int i,j,k,time=10,m=0,n=0;  
         for(k=0;k<time;k++)  
         {  
             scanf("%d%d",&i,&j);  
             m+=i;  
             n+=j;  
         }  
         printf("%d+%di\n",m,n);  
         return 0;  
     }  
     #include <stdio.h> 
     #include <malloc.h> 
     typedef struct linknode 
     { 
         int x; 
         int y; 
         struct linknode *next; 
     }node; 
     int main() 
     { 
     node *begin=(node *)malloc(sizeof(node)); 
     node *q=begin,*p; 
     int m=0,n=0; 
     scanf("%d%d",&q->x,&q->y); 
     int i; 
     for(i=1;i<10;i++) 
     { 
         p=(node *)malloc(sizeof(node)); 
         scanf("%d%d",&p->x,&p->y); 
         q->next=p; 
         q=p; 
     } 
     p->next=NULL; 
     while(begin!=NULL) 
     { 
        m+=begin->x;     
        n+=begin->y; 
        begin=begin->next;     
     } 
     printf("%d+%di",m,n); 
         return 0; 
     } 
    

    算法训练 最大体积

    问题描述
      每个物品有一定的体积(废话),不同的物品组合,装入背包会战用一定的总体积。假如每个物品有无限件可用,那么有些体积是永远也装不出来的。为了尽量装满背包,附中的OIER想要研究一下物品不能装出的最大体积。题目保证有解,如果是有限解,保证不超过2,000,000,000
      如果是无限解,则输出0
    输入格式
      第一行一个整数n(n<=10),表示物品的件数
      第2行到N+1行: 每件物品的体积(1<= <=500)
    输出格式
      一个整数ans,表示不能用这些物品得到的最大体积。
    样例输入
    3
    3
    6
    10
    样例输出
    17

     #include <stdio.h>  
     int n;  
     int a[510];  
     int f[100001];  
     void swap(int *a,int *b)  
     {  
        int c;  
        c=*a;  
        *a=*b;  
        *b=c;  
     }  
     int gcd(int a,int b)  
     {  
         if(a>b)  
           swap(&a,&b);  
         if(a==0)  
           return b;  
         return gcd(b%a,a);  
     }  
     int main()  
     {  
         int i,j,t;  
         scanf("%d",&n);  
         for(i=1;i<=n;i++)  
             scanf("%d",&a[i]);  
         t=a[1];  
         for(i=2;i<=n;i++)  
             t=gcd(t,a[i]);  
         if(t!=1)  
         {  
             printf("0\n");  
             return 0;  
         }  
         else  
         {  
               f[0]=1;  
               for(i=1;i<=n;i++)  
               {  
                   for(j=a[i];j<=65536;j++)  
                       f[j] |= f[j-a[i]];  
               }  
               for(i=65536;i>=0;i--)  
               {  
                   if(!f[i])  
                   {  
                       printf("%d\n",i);  
                       return 0;  
                   }  
               }  
               printf("0\n");  
               return 0;  
         }  
     }  
    

    算法训练 貌似化学

    问题描述
      现在有a,b,c三种原料,如果他们按x:y:z混合,就能产生一种神奇的物品d。
      当然不一定只产生一份d,但a,b,c的最简比一定是x:y:z
      现在给你3种可供选择的物品:
      每个物品都是由a,b,c以一定比例组合成的,求出最少的物品数,使得他们能凑出整数个d物品(这里的最少是指三者个数的总和最少)
    输入格式
      第一行三个整数,表示d的配比(x,y,z)
      接下来三行,表示三种物品的配比,每行三个整数(<=10000)。
    输出格式
      四个整数,分别表示在最少物品总数的前提下a,b,c,d的个数(d是由a,b,c配得的)
      目标答案<=10000
      如果不存在满足条件的方案,输出NONE
    样例输入
    3 4 5
    1 2 3
    3 7 1
    2 1 2
    样例输出
    8 1 5 7

    算法训练 貌似化学

    问题描述
      现在有a,b,c三种原料,如果他们按x:y:z混合,就能产生一种神奇的物品d


      当然不一定只产生一份d,但a,b,c的最简比一定是x:y:z
      现在给你3种可供选择的物品:
      每个物品都是由a,b,c以一定比例组合成的,求出最少的物品数,使得他们

    能凑出整数个d物品(这里的最少是指三者个数的总和最少)
    输入格式
      第一行三个整数,表示d的配比(x,y,z)
      接下来三行,表示三种物品的配比,每行三个整数(<=10000)。
    输出格式
      四个整数,分别表示在最少物品总数的前提下a,b,c,d的个数(d是由a,b,c

    配得的)
      目标答案<=10000
      如果不存在满足条件的方案,输出NONE
    样例输入
    3 4 5
    1 2 3
    3 7 1
    2 1 2
    样例输出
    8 1 5 7

    #include <cstdio>  
     #include <cstring>  
     #define INF 214748326  
     double a[10][10];  
     double b[10][10];  
     double c[10];  
     int min=INF;  
     int ansx,ansy,ansz,ansk;  
     int trunc(double x){  
         if ((int)(x+0.5)>(int)x) return (int)x+1;  
         return (int)x;  
     }  
     int main(){  
         scanf("%lf%lf%lf",&a[1][4],&a[2][4],&a[3][4]);  
         scanf("%lf%lf%lf%lf%lf%lf%lf%lf%lf",&a[1][1],&a[2][1],&a[3][1],&a  
     [1][2],&a[2][2],&a[3][2],&a[1][3],&a[2][3],&a[3][3]);  
         memcpy(b,a,sizeof(a));  
         for (int k=1;k<=10000;k++){  
             for (int i=1;i<=3;i++) a[i][4]*=k;  
             for (int i=1;i<3;i++){  
                 for (int j=i+1;j<=3;j++){  
                     double t=1;  
                     if (a[j][i]!=0) t=a[i][i]/a[j][i];  
                     a[j][i]=0;  
                     for (int k=i+1;k<=4;k++){  
                         a[j][k]=t*a[j][k]-a[i][k];  
                     }  
                 }  
             }  
             memset(c,0,sizeof(c));  
             c[3]=a[3][4]/a[3][3];  
             for (int i=2;i>0;i--){  
                 double tot=0;  
                 for (int j=i+1;j<=3;j++){  
                     tot+=a[i][j]*c[j];  
                 }  
                 c[i]=(a[i][4]-tot)/a[i][i];  
             }  
             int x=trunc(c[1]);  
             int y=trunc(c[2]);  
             int z=trunc(c[3]);  
             if (b[1][1]*x+b[1][2]*y+b[1][3]*z==b[1][4]*k  
              && b[2][1]*x+b[2][2]*y+b[2][3]*z==b[2][4]*k  
              && b[3][1]*x+b[3][2]*y+b[3][3]*z==b[3][4]*k){  
                                                           if (min>x+y+z){  
     ansx=x;  
     ansy=y;  
     ansz=z;  
     ansk=k;  
     min=z+y+z;  
                                                           }  
              }  
              memcpy(a,b,sizeof(a));  
         }  
         if (ansx==0 && ansy==0 && ansz==0) printf("NONE");else  
         printf("%d %d %d %d\n",ansx,ansy,ansz,ansk);  
         return 0;  
     }  
    

    算法训练 字符串的展开

      在初赛普及组的“阅读程序写结果”的问题中,我们曾给出一个字符串展开的例子:如果在输入的字符串中,含有类似于“d-h”或者“4-8”的字串,我们就把它当作一种简写,输出时,用连续递增的字母获数字串替代其中的减号,即,将上面两个子串分别输出为“defgh”和“45678”。在本题中,我们通过增加一些参数的设置,使字符串的展开更为灵活。具体约定如下:
      (1) 遇到下面的情况需要做字符串的展开:在输入的字符串中,出现了减号“-”,减号两侧同为小写字母或同为数字,且按照ASCII码的顺序,减号右边的字符严格大于左边的字符。
      (2) 参数p1:展开方式。p1=1时,对于字母子串,填充小写字母;p1=2时,对于字母子串,填充大写字母。这两种情况下数字子串的填充方式相同。p1=3时,不论是字母子串还是数字字串,都用与要填充的字母个数相同的星号“”来填充。   (3) 参数p2:填充字符的重复个数。p2=k表示同一个字符要连续填充k个。例如,当p2=3时,子串“d-h”应扩展为“deeefffgggh”。减号两边的字符不变。   (4) 参数p3:是否改为逆序:p3=1表示维持原来顺序,p3=2表示采用逆序输出,注意这时候仍然不包括减号两端的字符。例如当p1=1、p2=2、p3=2时,子串“d-h”应扩展为“dggffeeh”。   (5) 如果减号右边的字符恰好是左边字符的后继,只删除中间的减号,例如:“d-e”应输出为“de”,“3-4”应输出为“34”。如果减号右边的字符按照ASCII码的顺序小于或等于左边字符,输出时,要保留中间的减号,例如:“d-d”应输出为“d-d”,“3-1”应输出为“3-1”。 输入格式   输入包括两行:   第1行为用空格隔开的3个正整数,一次表示参数p1,p2,p3。   第2行为一行字符串,仅由数字、小写字母和减号“-”组成。行首和行末均无空格。 输出格式   输出只有一行,为展开后的字符串。 输入输出样例1 输入格式 输出格式 1 2 1 abcs-w1234-9s-4zz abcsttuuvvw1234556677889s-4zz 输入输出样例2 输入格式 输出格式 2 3 2 a-d-d aCCCBBBd-d 输入输出样例3 输入格式 输出格式 3 4 2 di-jkstra2-6 dijkstra2*6
    数据规模和约定
      40%的数据满足:字符串长度不超过5
      100%的数据满足:1<=p1<=3,1<=p2<=8,1<=p3<=2。字符串长度不超过100

     #include<stdio.h>  
      #include<stdlib.h>  
      #include<string.h>  
      void fill(char a)  
      {  
      }  
      int main()  
      {  
          char s[120]={0};  
          memset(s,0,sizeof(s));  
          int p1,p2,p3,i,j,k;  
          scanf("%d%d%d",&p1,&p2,&p3);  
          scanf("%s",s);  
          for(i=0;i<strlen(s);i++)  
          {  
              if(s[i]=='-')  
              {  
                  if(s[i-1]>='a' && s[i-1]<='z' && s[i+1]>='a' && s[i+1]<='z' && s[i+1]>s[i-1]  
                  || s[i-1]>='0' && s[i-1]<='9' && s[i+1]>='0' && s[i+1]<='9' && s[i+1]>s[i-1])  
                  {  
                      if(p1==3)  
                      {  
                          for(j=1;j<=p2*(s[i+1]-s[i-1]-1);j++)  
                          {  
                              printf("*");  
                          }  
                      }  
                      else  
                      {  
                          if(s[i-1]>='0' && s[i-1]<='9' && s[i+1]>='0' && s[i+1]<='9')  
                          {  
                              if(p3==1)  
                              {  
                                  for(j=s[i-1]+1;j<=s[i+1]-1;j++)  
                                  {  
                                      for(k=1;k<=p2;k++)  
                                      {  
                                          printf("%c",j);  
                                      }  
                                  }  
                              }  
                              else  
                              {  
                                  for(j=s[i+1]-1;j>=s[i-1]+1;j--)  
                                  {  
                                      for(k=1;k<=p2;k++)  
                                      {  
                                          printf("%c",j);  
                                      }  
                                  }  
                              }  
                          }  
                          else  
                          {  
                              if(p3==1)  
                              {  
                                  for(j=s[i-1]+1;j<=s[i+1]-1;j++)  
                                  {  
                                      for(k=1;k<=p2;k++)  
                                      {  
                                          printf("%c",p1==1?j:j-32);  
                                      }  
                                  }  
                              }  
                              else  
                              {  
                                  for(j=s[i+1]-1;j>=s[i-1]+1;j--)  
                                  {  
                                      for(k=1;k<=p2;k++)  
                                      {  
                                          printf("%c",p1==1?j:j-32);  
                                      }  
                                  }  
                              }  
                          }  
                      }  
                  }  
                  else  
                  {  
                      printf("%c",s[i]);  
                  }  
              }  
              else  
              {  
                  printf("%c",s[i]);  
              }  
          }  
          return 0;  
      }  
    

    算法训练 明明的随机数

    问题描述
      明明想在学校中请一些同学一起做一项问卷调查,为了实验的客观性,他先用计算机生成了N个1到1000之间的随机整数(N≤100),对于其中重复的数字,只保留一个,把其余相同的数去掉,不同的数对应着不同的学生的学号。然后再把这些数从小到大排序,按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。
    输入格式
      输入有2行,第1行为1个正整数,表示所生成的随机数的个数:
      N
      第2行有N个用空格隔开的正整数,为所产生的随机数。
    输出格式
      输出也是2行,第1行为1个正整数M,表示不相同的随机数的个数。第2行为M个用空格隔开的正整数,为从小到大排好序的不相同的随机数。
    样例输入
    10
    20 40 32 67 40 20 89 300 400 15
    样例输出
    8
    15 20 32 40 67 89 300 400

     #include <stdio.h>  
     #define MaxSize 100+5  
     void printArray(int array[],int lenth)  
     {  
         int i;  
         printf("%d\n",lenth);  
         for(i=0;i<lenth;i++)  
         {  
             printf("%d ",array[i]);  
         }  
         printf("\n");  
         return ;  
     }   
     void sortArray(int array[],int lenth)  
     {  
         int i,j;  
         for(i=0;i<lenth;i++)  
         {  
             for(j=lenth-1;j>i;j--)  
             {  
                 if(array[j]<array[j-1])  
                 {  
                     int temp;  
                     temp=array[j];  
                     array[j]=array[j-1];  
                     array[j-1]=temp;  
                 }  
             }  
         }  
         return ;  
     }   
     main()  
     {  
         int N,m,i,j;  
         int array[MaxSize];  
         scanf("%d",&N);  
         m=N;  
         for(i=0;i<m;i++)  
         {  
             scanf("%d",&array[i]);  
             for(j=0;j<i;j++)  
             {  
                 if(array[i]==array[j])  
                 {  
                     i--;  
                     m--;  
                     continue;  
                 }  
             }  
         }  
         sortArray(array,m);  
         printArray(array,m);  
         return 0;  
     }  
    

    展开全文
  • 区分性训练和mmi(

    千次阅读 2019-04-03 21:01:13
    目录写在前面信息论中的一些概念最大似然估计MLEmle缺点区分性训练DT和最大互信息MMI区分性训练MMI区分性训练缺点MMI训练过程Lattice对于它的训练:MMI的问题:reference @author yuxiang.kong 写在前面 最近我在看...


    @author yuxiang.kong

    写在前面

    最近我在看区分性训练的代码和论文,但我始终搞不懂它为什么叫区分性训练,为啥叫mmi,为啥现在很多地方用mmi取代了ce。当我试图去在论文中或者大部分博客中找到这个答案的时候,它们告诉我的都是一个公式:
    在这里插入图片描述
    公式虽然也不难懂,但就是搞不清是为什么。于是找了好几天的资料,从头开始补习,总结了这篇博客。

    搜集资料的思路:mmi -> DT -> mle -> ce -> 熵 -> 互信息。 每一步都是考虑了公式和意义的,所以我在行文的过程中会多次提到公式该如何理解,起了什么样的作用。所以并没有特别客观

    行文思路: 熵以及信息论的基础概念 -> mle -> dt&mmi -> 论文中的描述(主要是lf-mmi)->kaldi中的实现。

    我将分几篇进行描述,本篇描述的是基础内容,mle和mmi。

    信息论中的一些概念

    1. 熵(热力学中定义)
      热力学中的熵的定义, 熵是用来描述混乱程度的单位。定义为 k ∗ l n w k*lnw klnw w是微观状态数,k是玻尔兹曼常量,用来表示能量和温度的关系,取对数是因为希望两个系统结合为一个的时候是用简单的加法运算。
      比如:
      一个骰子的状态数是6,两个骰子的状态数是36。则一个骰子的混乱程度是kln6,两个是 k l n 6 2 = 2 k l n 6 kln6^{2}=2kln6 kln62=2kln6

    2. 信息量
      l o g a 1 / p ( x i ) log_{a} 1/p(x_i) loga1/p(xi)可以看出,这里的状态数用概率的倒数进行表示。也就是说一个事件的概率越大,系统状态数也就越少,所包含的信息也就越小。


    3. H ( p ) = ∑ p ( x i ) log ⁡ a 1 / p ( x i ) H(p)=\sum {p(x_i)\log_{a} 1/p(x_i)} H(p)=p(xi)loga1/p(xi) 约定 0 ≤ p ≤ 1 0\leq p\leq 1 0p1 ∑ p = 1 \sum {p} = 1 p=1,用来描述整体的不确定程度。
      实际上熵可以看作对系统状态数的期望。

    4. 交叉熵(cross entropy)
      H ( p , q ) = ∑ p ( x i ) l o g 1 / q ( x i ) H(p,q) = \sum p(x_i) log {1/q(x_i)} H(p,q)=p(xi)log1/q(xi) 其中,p是真实分布的概率,q是自己估计出来的概率。交叉熵也是一种熵,也就是一种估计的熵值。
      根据定律,交叉熵一定大于真是分布的熵。
      因此我们平时训练就是希望ce越小越好,越小就越接近真实分布。(后面会继续提到这个问题)

    5. 相对熵(KL散度)
      作用:是用来衡量两种分布之间的差异。
      D ( p ∣ ∣ q ) = H ( p , q ) − H ( p ) = ∑ p l o g p − p l o g q D(p||q) =H(p,q)-H(p) = \sum p log {p}-plog{q} D(pq)=H(p,q)H(p)=plogpplogq
      也就是交叉熵与独立熵的差值。
      实际上,相对熵和交叉熵有着异曲同工的效果。

    6. 条件熵
      H ( Y ∣ X ) H(Y|X) H(YX)意为在X的条件下,Y的概率分布熵,对X的期望。或者说是X的情况下,Y的不确定性。
      H ( Y ∣ X ) = H ( X , Y ) − H ( X ) = − ∑ x , y p ( x , y ) l o g ( p ( y / x ) ) H(Y|X)=H(X,Y)-H(X)=-\sum_{x,y} p(x,y) log(p(y/x)) H(YX)=H(X,Y)H(X)=x,yp(x,y)log(p(y/x))
      = ∑ x p ( x ) H ( Y ∣ X = x ) =\sum_{x} p(x)H(Y|X=x) =xp(x)H(YX=x)
      从公式看,可以理解为联合熵减去独立熵。“熵是数学期望,条件熵是数学期望的数学期望”。可以理解为,有X的时候Y的熵。

    7. 互信息(mutual information)
      两个随机变量的关联程度。我看到一种说法很好滴解释了互信息的意义:“有y的时候x的熵-没y的时候x的熵”。
      I ( X , Y ) = H ( Y ) − H ( Y ∣ X ) I(X,Y) = H(Y)-H(Y|X) I(X,Y)=H(Y)H(YX) 熵 − 条 件 熵 熵-条件熵
      所以我们所说的mmi准则实际上就是最大化互信息的缩写。这就是我们为什么要研究什么是互信息。

    (以上这些是基于个人理解写的,如果不是很清楚的,可以去查看一些关于信息论的博客,大多写的很好。)
    为什么我们之前一直用的是交叉熵,下面我们从MLE进行解释。

    最大似然估计MLE

    最大似然估计,即假设一种分布,用现在已知的数据去估计这种分布的参数。
    然后看交叉熵,我们用估计的分布算出一个交叉熵,然后让交叉熵尽可能小达到估计真实的分布。因此我们之前的训练是属于mle,用的是交叉熵。交叉熵也就是mle的一种实现,同样如果是kl散度,也是属于mle的实现,正如我们前面说的这样。
    我们语音识别的目的是最大化 P ( W ∣ O ) P(W|O) P(WO). w是words o是指观测序列
    P ( W ∣ O ) = P ( O ∣ W ) P ( W ) / P ( O ) P(W|O)=P(O|W)P(W)/P(O) P(WO)=P(OW)P(W)/P(O) . P ( O ) P(O) P(O)对于每个任务都是一样的, P ( W ) P(W) P(W)是由语言模型确定, P ( O ∣ W ) P(O|W) P(OW)是由声学模型确定,也称之为后验概率。
    hmm也就是对 P ( O ∣ W ) P(O|W) P(OW)进行的建模,我们所用的神经网络实际上也就是学习hmm的发射矩阵B。

    mle缺点

    1. 我们所学习模拟的分布是已知的。要求模型假设必须正确。
    2. 训练时数据应趋向于无穷多。
    3. 在解码时语言模型是趋向于真实的语言分布。

    对于第一点,我们是通过gmm去模拟语音的真实分布,因为我们认为gmm可以模拟出任意一种分布。然后在此基础上去对齐训练。但是如果gmm训练的不到位呢。第二点第三点就不用再说了。

    于是提出了区分性训练

    区分性训练DT和最大互信息MMI

    区分性训练

    于是对于这些问题,就有了区分性训练,区分性训练实际上就是希望通过设置一个目标函数达到奖励正确的同时处罚错误的这样一个目的,来进行训练。(关于区分性训练我没有找到它的准确定义,于是用这种通俗易懂的方式来理解它就好了。)
    它有几种实现方法,其中一种是mmi,最大化互信息,其他的还有mpe,之类的。
    我们前面说到,互信息是描述两个随机变量的关联程度,于是在这里就是描述观测序列和文本的关联程度
    再来看一下互信息公式,具体的公式你不用看,只用关心 I ( x , y ) = H ( x ) − H ( x ∣ y ) I(x,y) = H(x)-H(x|y) I(x,y)=H(x)H(xy)。因此最大化互信息,就等于最小化条件熵。

    MMI

    公式:
    在这里插入图片描述
    MMI公式本身它可以看成,正确路径得分与所有路径得分的比值。当正确路径得分提升的同时,错误路径得分会减少,因此是一种区分性训练。
    实际上我们就可以看成 ∑ log ⁡ ( P ( O r ∣ w r ) P ( w r ) / ∑ w P ( O r ∣ w ) P ( w ) ) \sum \log (P(O_r|w_r)P(w_r)/\sum{w} P(O_r|w)P(w)) log(P(Orwr)P(wr)/wP(Orw)P(w))
    = ∑ log ⁡ P ( O r ∣ w r ) P ( w r ) / P ( O r ) = P ( W ∣ O ) = \sum \log P(O_r|w_r)P(w_r)/P(O_r) = P(W|O) =logP(Orwr)P(wr)/P(Or)=P(WO)
    也就是我们是以P(W|O)作为目标函数,而不是以P(O|W)作为目标函数了。可以看到,实际上,mmi把语言模型的东西也考虑进去了。这样做相对于MLE的好处就是,即使假设的分布不是很好,得到的结果也不会太差。

    区分性训练缺点

    训练的数据泛化能力不强。 我的理解是,我们把一个正确的路径学的太多了,导致相对于这个训练集的错误路径的分数太低太低,因此为了增强它的泛化能力,我们适当增加错误路径的得分。或者说让声学模型在其中更具主导性,而不是一味地让语言模型进行主导。

    MMI训练过程

    我们在对一些参数进行更新的时候,需要用到的是前向后向算法,并且需要对分子和分母分别进行前向后向算法。这个是hmm中使用的一种方法。

    Lattice

    对于分子来说,这个算法是可行的,但对于分母来说,这个算法的计算量就太大了。所以为了计算可行性,我们使用lattice来进行计算,lattice实际上就是词格,词网络。我们通常使用的网络是状态级别的网络,而这里使用的词网络,这就是我们在训练前要进行对齐lats。然后我们为了方便统计信息,我们在每个词节点中加入状态信息。
    所以,我们在训练chain-model的时候,使用的是wer,而不是cer。同时,值得注意的是,我们在实际使用的时候,wer也是更值得关注一些。
    当然,对分母的优化只有这一点是远远不够的,在lf-mmi中会大量提及对分母的优化,包括hmm的优化,解码图的优化,以及各种tricks。这里先只提及从状态级别的转向lattice级别的优化。在这里插入图片描述
    (图自:An Overview of Discriminative Training for Speech Recognition --Keith Vertanen)
    注意:这里要强调一点,正确的路径可能不止一条,因为可能会有多音字的情况。

    对于它的训练:

    • 我们还是使用MLE(CE)准则训练的模型去进行对齐得到lats。
    • 一般来说,在整个训练过程中这些lats不会改变的,但也有随着训练过程而变化的情况,这样得到的效果也是不错的。
    • 解码图,每个分子的解码图是根据当前句子定的,但分母的解码图都是一样的。
    • 但实际上我们在kaldi训练的过程中不是这样的,kaldi中实现的是lf-mmi

    MMI的问题:

    对于mmi的一个问题就是,训练的数据泛化能力不强。我的理解是,我们把一个正确的路径学的太多了,导致相对于这个训练集的错误路径的分数太低太低,因此为了增强它的泛化能力,我们适当增加错误路径的得分。或者说让声学模型在其中更具主导性,而不是一味地让语言模型进行主导。
    因此有几种解决方法,这里只列举几种:

    • 声学参数k,增加声学参数的影响
    • lat使用一个简单的语言模型,一般来说,在分母的解码图的语言模型实际上使用的是一个word-level的bigram
    • boosted mmi

    在这里插入图片描述
    我们可以看到,和mmi相比,bmmi在分母上增加了一项,exp(-bA(s,sr)) 其中A(s,sr)表示的是用来描述s和sr的准确性的一个参数。

    • 包括在lf-mmi中也有一些方法去解决泛化能力

    大多是自己的理解,请多多包涵。

    reference

    https://www.cnblogs.com/welen/p/7515614.html
    https://www.cnblogs.com/jenny1000000/p/7745458.html
    An Overview of Discriminative Training for Speech Recognition --Keith Vertanen
    https://liuyanfeier.github.io/2018/12/16/区分性训练(Discriminative-Training)及其在语音识别(ASR)上的运用/
    BOOSTED MMI FOR MODEL AND FEATURE-SPACE DISCRIMINATIVE TRAINING – Dan Povey

    展开全文
  • YOLO2训练

    千次阅读 2017-06-27 10:02:14
     用了600张图像,制作训练集,设置batch = 30,subdivisions = 6, 设置每10个batch后就输出个中间模型,我把yolo-voc_20.weights,yolo-voc_30.weights,yolo-voc_40.weights分别test,yolo-voc_20.weights,...
  • 以下链接是个人关于DenseFusion(6D姿态估计) 所有见解,如有错误欢迎大家指出,我会第时间纠正。有兴趣的朋友可以加微信:a944284742相互讨论技术。若是帮助到了你什么,一定要记得点赞!因为这是对我最大的鼓励。...
  • 这两一直致力于利用YOLOv3的Pytorch版本进行模型的训练,奈何他的版本更新的太快,找了半天的cfg配置文件发现在最新版本里已经升级了。于是不断在YOLOv3和YOLOv5之间辗转。 决定从最简单的东西入手,一步一步来...
  • mtcnn训练

    千次阅读 2017-11-15 17:55:06
    最近在搞人脸检测,准备学习一下如何训练,先参考一下试试,后续更新内容 https://github.com/dlunion/mtcnn
  • 由于初次使用,遇到不少大坑,花了两时间才完整的实现。 要实现的功能: - 安装anaconda管理库 - 远程访问jupyter notebook - 将本地文件和服务器端文件互传 - 安装tensorflow的GPU版本 - ...
  • 训练模型

    千次阅读 多人点赞 2019-06-20 17:10:57
    1 预训练模型由来 预训练模型是深度学习架构,已经过训练以执行大量数据上的特定任务(例如,识别图片中的分类问题)。这种训练不容易执行,并且通常需要大量资源,超出许多可用于深度学习模型的人可用的资源,我就...
  •  这一点虽然老师早就给打了预防针,仍然没有预料到会这么大,6天完成两大章内容,虽然有高中的一点基础撑着,仍然是相当吃不消。到了后期虚到几乎就是在在集训室都能睡着的地步。不过学到的东西挺多的,虽然不如...
  • BERT模型从训练到部署

    万次阅读 多人点赞 2019-04-15 23:38:03
    BERT模型从训练到部署全流程 Tag: BERT 训练 部署 ...在下面我将以个“手机评论的情感分类”为例子,简要说明从训练到部署的全部流程。最终完成后可以使用个网页进行交互,实时地对输入的评...
  • part:手把手教你用tensorflow object-detection API 训练自己的模型机器和系统的配置1.原理1.1使用迁移学习的... 训练自己的模型6. 检测我们训练的模型 机器和系统的配置 方法:本人使用系统是Ubuntu16.04 ...
  • OpenCV实现手写体数字训练与识别

    万次阅读 热门讨论 2017-09-12 10:39:06
    OpenCV实现手写体数字训练与识别机器学习(ML)是OpenCV模块之,对于常见的数字识别与英文字母识别都可以做到很高的识别率,完成这类应用的主要思想与方法是首选对训练图像数据完成预处理与特征提取,根据特征数据...
  • 编程逻辑思维训练

    万次阅读 多人点赞 2018-03-30 10:52:12
    1.你让工人为你工作7,给工人的回报是根金条。金条平分成相连的7段,你必须在每天结束时给他们段金条,如果只许你两次把金条弄断,你如何给你的工人付费? 2.请把盒蛋糕切成8份,分给8个人,但蛋糕盒里还...
  • 女生初级健身训练计划

    千次阅读 2017-05-06 13:53:27
    初级训练计划给女票制定的健身计划…训练节奏 热身 无氧训练 拉伸 有氧训练 ...无氧训练一天肩部胸部练习肩部 肩绕环 向前向后肩部绕环 站姿肩部深层激活 哑铃侧平举 胸部 哑铃平地飞鸟 哑铃平地卧推 拉
  • 从0~109,个录入程序,最后会自动保存文件txt。 以后每次打开软件,就直接点击“读取文件”,就可以进行后面的练习。 2. 单组练习 分两种单组练习,是看数字反应编码,二是看编码反应数字。   3.多组...
  • 机器学习模型训练全流程!

    千次阅读 2020-08-11 08:47:24
    机器学习模型训练全流程! 周末在家无聊闲逛github,发现个很有趣的开源项目,作者用手绘图的方式讲解了机器学习模型构建的全流程,逻辑清晰、生动形象。同时,作者也对几张图进行了详细的讲解,学习...
  • () yolov3训练voc 数据集
  • 程序员的思维训练

    千次阅读 2016-03-30 14:26:36
    程序员的思维训练本文内容为阅读Andy Hunt 《程序员的思维修炼:开发认知潜能的九堂课》的笔记与心得感悟。约定:本文以引用的方式来记录原书的内容,其余内容为个人的看法与认知程序员的思维训练 从新手到专家的...
  • 我的第篇关于mask rcnn训练自己数据的博文,基于python代码,虽然可以跑,但是不能真正用到工程领域中,工程领域更多的是基于C++和C,如果编译tensorflow C++ API也是可以,然后利用api调用模型,但是会比较麻烦,...
  • 训练营总结与感悟

    千次阅读 2018-09-07 09:14:03
     加入训练营的初衷是为了早起,抱着试试的态度加入,刚开始几天的状态很敷衍,一天一讲的时间管理笔记输出,保证自己在6点之前起床&amp;打卡。几天后,组长长霞霞姐抛出三个问题,我认真思考并制定了自己内心真...
  • 点击上方“AI公园”,关注公众号,选择加“星标“或“置顶”作者:David Page编译:ronghuaiyang导读这个系列介绍了如何在CIFAR10上高效的训练Res...
  • 机器学习—滚动训练模块介绍

    千次阅读 2019-01-12 11:21:13
    实现平台:BigQuant—人工智能量化投资平台 可在文末前往原文一键克隆代码进行进一步研究 滚动训练模块简介 ...我们希望训练一个模型,训练集数据从2016-01-01起到最新数据止,每次模型训练所用数...
  • Caffe训练自己的数据

    千次阅读 热门讨论 2016-08-13 17:46:06
    1、准备训练数据首先为训练数据和测试数据,新建两个文件夹,名称任意,存放数据: trian(存放训练数据) val(存放测试数据) 在tiran和val中,放入统一尺寸的图片,如320x320。保证这些图像的名称,不包含...
  • Java实现蓝桥杯VIP算法训练 最大获利

    万次阅读 多人点赞 2020-03-04 15:17:31
    在初期的市场调研中,他将一天划分为M个时间段,并且知道第i个饭店在第j个时间段内,会有Aij位服务员当值和Bij位客户光临。他还分析了不同饭店不同时间段客户的需求,得到第i个饭店在第j个时间段内,平均每位客...
  • BERT(Bidirectional Encoder Representations from Transformers),基于自注意力机制的双向编码表示模型(本质仍然是种语言模型),是谷歌在今年10月份提出的个新的预训练语言表示模型,一经提出就刷爆NLP圈,因为...
  • 这两在使用yolov3-tiny,记录下一些训练参数和其取值的意义。 在不检测目标占比小的情况时,可以选用的yolov3-tiny模型 1.模型训练参数 yolo训练时输出的各项参数(这图用的是yolov3-tiny训练,所以只有16和23这...
  • 混合精度训练-Pytorch

    千次阅读 2019-11-24 09:43:36
    目录1、需求解读2、F16和FP32的区别与联系3、F16优点简介4、F16缺点简介5、混合精度训练代码实战5.1 代码实现5.2 代码解析6、F16训练效果展示7、个人总结参考资料注意事项 1、需求解读   作为名算法工程师,我们...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,670
精华内容 27,468
关键字:

一天训练6小时