精华内容
下载资源
问答
  • 最好的双眼视功能训练方法
    千次阅读
    2020-12-30 13:11:10

    1

    1

    最好的双眼视功能训练方法

    1

    、同时视功能训练同时知觉是指两眼能同时看见一个物体,

    每眼所接受的物像都恰好落在视网膜黄斑部,传人大脑后被感觉

    成一个物像。同时知觉功能能反应双眼黄斑和视网膜对应正常与

    否。同时视功能训练是通过分视眼镜让每只眼看到各自的图象,

    利用闪烁刺激去除优势眼对弱视眼的抑制,建立正常的同时视功

    能,为融合功能的建立创造条件。它可以帮助患者削弱优势眼对

    劣势眼的抑制、建立起正常的同时视功能。

    2

    、融合视功能训练融合是指大脑能综合来自两眼的相同物

    象,并在知觉水平上形成一个完整印象的能力。这是在双眼同时

    知觉基础上,把落于

    2

    个视网膜对应点上的物像融合成一个完整

    印象的功能。能引起融合反射的视网膜物像移位幅度称为融合

    (fusion)

    范围。融合范围的大小可作为双眼视觉正常与否的标志

    之一。融合功能训练是分视双眼后,让每只眼看到相似度

    85%

    以上

    的两幅图片,利用多种运动方式诱导双眼产生融合、扩大融合范

    围,有效缓解视疲劳,为立体视的建立创造条件。它可以帮助患

    者建立起正常的视网膜对应关系、协调双眼运动、增加融合范

    围、矫正或减轻斜视症状。

    3

    、立体视功能训练立体视是人类对三维空间各种物体的远

    近、凸凹和深浅的感知能力,是双眼单视三级功能

    (

    同时知觉,融

    合功能,立体视觉

    )

    中的最高级视功能,是人类从事精细工作不可

    更多相关内容
  • 进一步的中介分析表明,功能性大脑网络的重组介导了神经反馈训练后目标大脑活动的自我调节对认知能力改善的影响。 这项研究的结果加深​​了我们对实时神经反馈的神经基础的理解,并提出了通过调节WM相关网络中的...
  • 运动训练对改善几种系统自身免疫疾病的内皮功能和降低动脉僵硬度有效。 但是,迄今为止,尚无研究评估患有全身自身免疫肌病(SAM)的患者。 方法。 前瞻评估了五名女性女性,这些女性患有明确的SAM(3个...
  • 背景:运动训练证明对多种风湿自身免疫疾病是安全的,并能促进其获益。... 结论:运动训练计划证明对提高有氧运动能力,肌肉力量和功能以及改善患者的身体成分有效。 需要进一步的研究来证实这些发现。
  • 悬吊训练法是一种发展核心力量、提高肌肉控制能力、预防运动损伤的有效方法,具有提高平衡能力、预防运动损伤的多种功能。从悬吊训练法的定义、特点以及训练方法出发,结合脚斗士运动员体能训练的实际状况,对悬吊训练...
  • 第一节 健瞳视功能训练优化系统应用操作规程 一.近点训练二.调节集合协同训练三.远点训练:四.精细调节训练五.双眼内旋外展训练六.眼球运动训练七.调节灵敏度训练八.精细视力训练九.空间频率刺激训练十.三...
  • 区分性训练和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

    展开全文
  • 完整实现利用tensorflow训练自己的图片数据集

    万次阅读 多人点赞 2018-07-22 17:04:21
    经过差不多一个礼拜的时间的学习,终于把完整的一个利用自己爬取的图片做训练数据集的卷积神经网络的实现(基于tensorflow) 目录 总体思路 第三部分:预处理 第四部分:网络模型 第五部分:训练 2019.4.22...

    经过差不多一个礼拜的时间的学习,终于把完整的一个利用自己爬取的图片做训练数据集的卷积神经网络的实现(基于tensorflow)

     

    目录

    总体思路

    第三部分:预处理

    第四部分:网络模型

    第五部分:训练

    2019.4.22更新

    第六部分:测试

    特别说明


     

     

    2019.1补充说明,针对评论区的几个问题做了一些改进和更新

    1、训练集和测试集的划分问题

    关于训练集和测试集的补充说明:

    训练集和测试集的划分很重要,我自己尝试过两种简单的方法:

    1)训练集和验证集在预处理的时候按比例随机划分。在PreWork.py添加了这部分代码

    2)一开始训练集和测试集就提前划分好存储在不同的.list文件里。

    读训练数据集就从train_list_path下读,读测试样本就从test_list_path下读

    train_list_path = './list/train.list'  # 训练样本的读入路径
    # test_list_path = './list/test.list'  # 测试样本的读入路径

    在实际应用中数据量不一定足够,可以采用交叉验证的方法划分训练集、验证集、测试集。这部分内容不详细展开,简单做个记录。

    • 留出法。将原样本随机划分为训练集和验证集(本博文使用的方法)。缺点:具有随机性,最后评估指标与原始分组有较大关系。
    • k折交叉验证。样本分为k个大小相等的样本子集,k-1个用来训练,1个用来测试,最后k次评估指标的平均值作为最终评估指标。
    • 留一法。每次留一个样本作为验证(是K折交叉验证的特殊情况),适用于数据缺乏的情况下。
    • 自助法。基于自助采用,对数据集随机采样,重复m次有得到m个子集,由于有部分样本没有被抽到过,有的重复多次抽到,那么将从未被抽到的作为验证集。

    2、测试代码的补充


     

    总体思路

    简单整理一下思路

    1. 获取数据集(上网爬取,或者直接找公开的图片数据集)
    2. 数据集的预处理,包括reshape、去噪、对比度增强、批量剪切、图片灰度、二值化、缩放、丰富数据等等(公开数据集一般已处理完)
    3. 对图片集进行处理,得到网络的输入(2、3都可以看成预处理部分)
    4. 搭建卷积神经网络框架
    5. 进行网络的训练
    6. 读取训练好的网络模型完成测试

    每三、四部分的参考和具体实现都在前面的两篇博客里提到了

    搭建一个卷积神经网络

    利用tensorflow训练自己的图片数据集——数据准备

    再附一下重点参考:江湖人称星爷的博客。给了我很大的指引和参考。现在附的跟前面有一点改动,基本思路是一样的。


    第一、二部分还有一些小问题,暂时先不放上来。

     

    第三部分:预处理

    新建PreWork.py文件

    '''
    PreWork.py
    功能:实现对指定大小的生成图片进行sample与label分类制作
    获得神经网络输入的get_files文件,同时为了方便网络的训练,输入数据进行batch处理。
    
    2018/7/19完成
    -------copyright@GCN-------
    '''
    
    import os
    import numpy as np
    from PIL import Image
    import tensorflow as tf
    import matplotlib.pyplot as plt
    from numpy import *
    
    angry = []
    label_angry = []
    disgusted = []
    label_disgusted = []
    fearful = []
    label_fearful = []
    happy = []
    label_happy = []
    sadness = []
    label_sadness = []
    surprised = []
    label_surprised = []
    
    
    def get_file(file_dir):
        # step1:获取路径下所有的图片路径名,存放到
        # 对应的列表中,同时贴上标签,存放到label列表中。
        for file in os.listdir(file_dir + '/angry'):
            angry.append(file_dir + '/angry' + '/' + file)
            label_angry.append(0)
        for file in os.listdir(file_dir + '/disgusted'):
            disgusted.append(file_dir + '/disgusted' + '/' + file)
            label_disgusted.append(1)
        for file in os.listdir(file_dir + '/fearful'):
            fearful.append(file_dir + '/fearful' + '/' + file)
            label_fearful.append(2)
        for file in os.listdir(file_dir + '/happy'):
            happy.append(file_dir + '/happy' + '/' + file)
            label_happy.append(3)
        for file in os.listdir(file_dir + '/sadness'):
            sadness.append(file_dir + '/sadness' + '/' + file)
            label_sadness.append(4)
        for file in os.listdir(file_dir + '/surprised'):
            surprised.append(file_dir + '/surprised' + '/' + file)
            label_surprised.append(5)
    
        # 打印出提取图片的情况,检测是否正确提取
        print("There are %d angry\nThere are %d disgusted\nThere are %d fearful\n" %(len(angry), len(disgusted), len(fearful)),end="")
        print("There are %d happy\nThere are %d sadness\nThere are %d surprised\n" %(len(happy),len(sadness),len(surprised)))
    
        # step2:对生成的图片路径和标签List做打乱处理把所有的合起来组成一个list(img和lab)
        # 合并数据numpy.hstack(tup)
        # tup可以是python中的元组(tuple)、列表(list),或者numpy中数组(array),函数作用是将tup在水平方向上(按列顺序)合并
        image_list = np.hstack((angry, disgusted, fearful, happy, sadness, surprised))
        label_list = np.hstack((label_angry, label_disgusted, label_fearful, label_happy, label_sadness, label_surprised))
        # 利用shuffle,转置、随机打乱
        temp = np.array([image_list, label_list])   # 转换成2维矩阵
        temp = temp.transpose()     # 转置
        # numpy.transpose(a, axes=None) 作用:将输入的array转置,并返回转置后的array
        np.random.shuffle(temp)     # 按行随机打乱顺序函数
    
        # 将所有的img和lab转换成list
        all_image_list = list(temp[:, 0])    # 取出第0列数据,即图片路径
        all_label_list = list(temp[:, 1])    # 取出第1列数据,即图片标签
        label_list = [int(i) for i in label_list]   # 转换成int数据类型
        
        ''' 
        # 将所得List分为两部分,一部分用来训练tra,一部分用来验证val
        n_sample = len(all_label_list)
        n_val = int(math.ceil(n_sample * ratio))  # 验证样本数, ratio是验证集的比例
        n_train = n_sample - n_val  # 训练样本数
    
        tra_images = all_image_list[0:n_train]
        tra_labels = all_label_list[0:n_train]
        tra_labels = [int(float(i)) for i in tra_labels]   # 转换成int数据类型
        val_images = all_image_list[n_train:-1]
        val_labels = all_label_list[n_train:-1]
        val_labels = [int(float(i)) for i in val_labels]   # 转换成int数据类型
    
        return tra_images, tra_labels, val_images, val_labels
        '''
    
        return image_list, label_list
    
    # 将image和label转为list格式数据,因为后边用到的的一些tensorflow函数接收的是list格式数据
    # 为了方便网络的训练,输入数据进行batch处理
    # image_W, image_H, :图像高度和宽度
    # batch_size:每个batch要放多少张图片
    # capacity:一个队列最大多少
    def get_batch(image, label, image_W, image_H, batch_size, capacity):
        # step1:将上面生成的List传入get_batch() ,转换类型,产生一个输入队列queue
        # tf.cast()用来做类型转换
        image = tf.cast(image, tf.string)   # 可变长度的字节数组.每一个张量元素都是一个字节数组
        label = tf.cast(label, tf.int32)
        # tf.train.slice_input_producer是一个tensor生成器
        # 作用是按照设定,每次从一个tensor列表中按顺序或者随机抽取出一个tensor放入文件名队列。
        input_queue = tf.train.slice_input_producer([image, label])
        label = input_queue[1]
        image_contents = tf.read_file(input_queue[0])   # tf.read_file()从队列中读取图像
    
        # step2:将图像解码,使用相同类型的图像
        image = tf.image.decode_jpeg(image_contents, channels=3)
        # jpeg或者jpg格式都用decode_jpeg函数,其他格式可以去查看官方文档
    
        # step3:数据预处理,对图像进行旋转、缩放、裁剪、归一化等操作,让计算出的模型更健壮。
        image = tf.image.resize_image_with_crop_or_pad(image, image_W, image_H)
        # 对resize后的图片进行标准化处理
        image = tf.image.per_image_standardization(image)
    
        # step4:生成batch
        # image_batch: 4D tensor [batch_size, width, height, 3], dtype = tf.float32
        # label_batch: 1D tensor [batch_size], dtype = tf.int32
        image_batch, label_batch = tf.train.batch([image, label], batch_size=batch_size, num_threads=16, capacity=capacity)
    
        # 重新排列label,行数为[batch_size]
        label_batch = tf.reshape(label_batch, [batch_size])
        # image_batch = tf.cast(image_batch, tf.uint8)    # 显示彩色图像
        image_batch = tf.cast(image_batch, tf.float32)    # 显示灰度图
        # print(label_batch) Tensor("Reshape:0", shape=(6,), dtype=int32)
        return image_batch, label_batch
        # 获取两个batch,两个batch即为传入神经网络的数据
    
    """
    def PreWork():
        # 对预处理的数据进行可视化,查看预处理的效果
        IMG_W = 256
        IMG_H = 256
        BATCH_SIZE = 6
        CAPACITY = 64
    
        train_dir = 'F:/Python/PycharmProjects/DeepLearning/CK+_part'
    
        # image_list, label_list, val_images, val_labels = get_file(train_dir)
        image_list, label_list = get_file(train_dir)
        image_batch, label_batch = get_batch(image_list, label_list, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
        print(label_batch.shape)
    
        lists = ('angry', 'disgusted', 'fearful', 'happy', 'sadness', 'surprised')
    
        with tf.Session() as sess:
            i = 0
            coord = tf.train.Coordinator()  # 创建一个线程协调器,用来管理之后在Session中启动的所有线程
            threads = tf.train.start_queue_runners(coord=coord)
            try:
                while not coord.should_stop() and i < 1:
                    # 提取出两个batch的图片并可视化。
                    img, label = sess.run([image_batch, label_batch])  # 在会话中取出img和label
                    # img = tf.cast(img, tf.uint8)
    
                    '''
                    1、range()返回的是range object,而np.arange()返回的是numpy.ndarray()
                    range(start, end, step),返回一个list对象,起始值为start,终止值为end,但不含终止值,步长为step。只能创建int型list。
                    arange(start, end, step),与range()类似,但是返回一个array对象。需要引入import numpy as np,并且arange可以使用float型数据。
                    
                    2、range()不支持步长为小数,np.arange()支持步长为小数
                    
                    3、两者都可用于迭代
                    range尽可用于迭代,而np.nrange作用远不止于此,它是一个序列,可被当做向量使用。
                    '''
                    for j in np.arange(BATCH_SIZE):
                        # np.arange()函数返回一个有终点和起点的固定步长的排列
                        print('label: %d' % label[j])
                        plt.imshow(img[j, :, :, :])
                        title = lists[int(label[j])]
                        plt.title(title)
                        plt.show()
                    i += 1
            except tf.errors.OutOfRangeError:
                print('done!')
            finally:
                coord.request_stop()
            coord.join(threads)
    
    if __name__ == '__main__':
        PreWork()
    """

     

    第四部分:网络模型

    新建CNNModel.py文件

    补充的知识点

    在TensorFlow的世界里,变量的定义和初始化是分开的,所有关于图变量的赋值和计算都要通过tf.Session的run来进行。
    
    想要将所有图变量进行集体初始化时应该使用tf.global_variables_initializer
    tf.placehold与tf.Variable的区别:
        tf.placehold 占位符
            主要为真实输入数据和输出标签的输入, 用于在 feed_dict中的变量,不需要指定初始值,具体值在feed_dict中的变量给出。
        tf.Variable 主要用于定义weights bias等可训练会改变的变量,必须指定初始值。
            通过Variable()构造函数后,此variable的类型和形状固定不能修改了,但值可以用assign方法修改。
    
    tf.get_variable和tf.Variable函数差别
    相同点:通过两函数创建变量的过程基本一样,
            tf.variable函数调用时提供的维度(shape)信息以及初始化方法(initializer)的参数和tf.Variable函数调用时提供的初始化过程中的参数基本类似。
    不同点:两函数指定变量名称的参数不同,
            对于tf.Variable函数,变量名称是一个可选的参数,通过name="v"的形式给出
            tf.get_variable函数,变量名称是一个必填的参数,它会根据变量名称去创建或者获取变量
    '''
    CNNModel.py
    含3层卷积池化层,2层全连接层,激活函数ReLU,采用dropout和softmax函数做分类器
    2018/7/18完成搭建,2018/7/19实现文件调用,2018/7/22修改网络结构
    -------copyright@GCN-------
    '''
    import tensorflow as tf
    
    
    # 函数申明
    def weight_variable(shape, n):
        # tf.truncated_normal(shape, mean, stddev)这个函数产生正态分布,均值和标准差自己设定。
        # shape表示生成张量的维度,mean是均值
        # stddev是标准差,,默认最大为1,最小为-1,均值为0
        initial = tf.truncated_normal(shape, stddev=n, dtype=tf.float32)
        return initial
    
    def bias_variable(shape):
        # 创建一个结构为shape矩阵也可以说是数组shape声明其行列,初始化所有值为0.1
        initial = tf.constant(0.1, shape=shape, dtype=tf.float32)
        return initial
    
    def conv2d(x, W):
        # 卷积遍历各方向步数为1,SAME:边缘外自动补0,遍历相乘
        # padding 一般只有两个值
        # 卷积层后输出图像大小为:(W+2P-f)/stride+1并向下取整
        return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
    
    def max_pool_2x2(x, name):
        # 池化卷积结果(conv2d)池化层采用kernel大小为3*3,步数也为2,SAME:周围补0,取最大值。数据量缩小了4倍
        # x 是 CNN 第一步卷积的输出量,其shape必须为[batch, height, weight, channels];
        # ksize 是池化窗口的大小, shape为[batch, height, weight, channels]
        # stride 步长,一般是[1,stride, stride,1]
        # 池化层输出图像的大小为(W-f)/stride+1,向上取整
        return tf.nn.max_pool(x, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding='SAME', name=name)
    
    
    # 一个简单的卷积神经网络,卷积+池化层 x2,全连接层x2,最后一个softmax层做分类。
    # 64个3x3的卷积核(3通道),padding=’SAME’,表示padding后卷积的图与原图尺寸一致,激活函数relu()
    def deep_CNN(images, batch_size, n_classes):
        # 搭建网络
        # 第一层卷积
        # 第一二参数值得卷积核尺寸大小,即patch;第三个参数是通道数;第四个是卷积核个数
        with tf.variable_scope('conv1') as scope:
            # 所谓名字的scope,指当绑定了一个名字到一个对象的时候,该名字在程序文本中的可见范围
            w_conv1 = tf.Variable(weight_variable([3, 3, 3, 64], 1.0), name='weights', dtype=tf.float32)
            b_conv1 = tf.Variable(bias_variable([64]), name='biases', dtype=tf.float32)   # 64个偏置值
            # tf.nn.bias_add 是 tf.add 的一个特例:tf.add(tf.matmul(x, w), b) == tf.matmul(x, w) + b
            # h_conv1 = tf.nn.relu(tf.nn.bias_add(conv2d(images, w_conv1), b_conv1), name=scope.name)
            h_conv1 = tf.nn.relu(conv2d(images, w_conv1)+b_conv1, name='conv1')  # 得到128*128*64(假设原始图像是128*128)
        # 第一层池化
        # 3x3最大池化,步长strides为2,池化后执行lrn()操作,局部响应归一化,增强了模型的泛化能力。
        # tf.nn.lrn(input,depth_radius=None,bias=None,alpha=None,beta=None,name=None)
        with tf.variable_scope('pooling1_lrn') as scope:
            pool1 = max_pool_2x2(h_conv1, 'pooling1')   # 得到64*64*64
            norm1 = tf.nn.lrn(pool1, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm1')
    
        # 第二层卷积
        # 32个3x3的卷积核(16通道),padding=’SAME’,表示padding后卷积的图与原图尺寸一致,激活函数relu()
        with tf.variable_scope('conv2') as scope:
            w_conv2 = tf.Variable(weight_variable([3, 3, 64, 32], 0.1), name='weights', dtype=tf.float32)
            b_conv2 = tf.Variable(bias_variable([32]), name='biases', dtype=tf.float32)   # 32个偏置值
            h_conv2 = tf.nn.relu(conv2d(norm1, w_conv2)+b_conv2, name='conv2')  # 得到64*64*32
    
        # 第二层池化
        # 3x3最大池化,步长strides为2,池化后执行lrn()操作
        with tf.variable_scope('pooling2_lrn') as scope:
            pool2 = max_pool_2x2(h_conv2, 'pooling2')  # 得到32*32*32
            norm2 = tf.nn.lrn(pool2, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm2')
    
        # 第三层卷积
        # 16个3x3的卷积核(16通道),padding=’SAME’,表示padding后卷积的图与原图尺寸一致,激活函数relu()
        with tf.variable_scope('conv3') as scope:
            w_conv3 = tf.Variable(weight_variable([3, 3, 32, 16], 0.1), name='weights', dtype=tf.float32)
            b_conv3 = tf.Variable(bias_variable([16]), name='biases', dtype=tf.float32)   # 16个偏置值
            h_conv3 = tf.nn.relu(conv2d(norm2, w_conv3)+b_conv3, name='conv3')  # 得到32*32*16
    
        # 第三层池化
        # 3x3最大池化,步长strides为2,池化后执行lrn()操作
        with tf.variable_scope('pooling3_lrn') as scope:
            pool3 = max_pool_2x2(h_conv3, 'pooling3')  # 得到16*16*16
            norm3 = tf.nn.lrn(pool3, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm3')
    
        # 第四层全连接层
        # 128个神经元,将之前pool层的输出reshape成一行,激活函数relu()
        with tf.variable_scope('local3') as scope:
            reshape = tf.reshape(norm3, shape=[batch_size, -1])
            dim = reshape.get_shape()[1].value
            w_fc1 = tf.Variable(weight_variable([dim, 128], 0.005),  name='weights', dtype=tf.float32)
            b_fc1 = tf.Variable(bias_variable([128]), name='biases', dtype=tf.float32)
            h_fc1 = tf.nn.relu(tf.matmul(reshape, w_fc1) + b_fc1, name=scope.name)
    
        # 第五层全连接层
        # 128个神经元,激活函数relu()
        with tf.variable_scope('local4') as scope:
            w_fc2 = tf.Variable(weight_variable([128 ,128], 0.005),name='weights', dtype=tf.float32)
            b_fc2 = tf.Variable(bias_variable([128]), name='biases', dtype=tf.float32)
            h_fc2 = tf.nn.relu(tf.matmul(h_fc1, w_fc2) + b_fc1, name=scope.name)
    
    
        # 对卷积结果执行dropout操作
        # keep_prob = tf.placeholder(tf.float32)
        h_fc2_dropout = tf.nn.dropout(h_fc2, 0.5)
        # tf.nn.dropout(x, keep_prob, noise_shape=None, seed=None, name=None)
        # 第二个参数keep_prob: 设置神经元被选中的概率,在初始化时keep_prob是一个占位符
    
        # Softmax回归层
        # 将前面的FC层输出,做一个线性回归,计算出每一类的得分,在这里是6类,所以这个层输出的是六个得分。
        with tf.variable_scope('softmax_linear') as scope:
            weights = tf.Variable(weight_variable([128, n_classes], 0.005), name='softmax_linear', dtype=tf.float32)
            biases = tf.Variable(bias_variable([n_classes]), name='biases', dtype=tf.float32)
            softmax_linear = tf.add(tf.matmul(h_fc2_dropout, weights), biases, name='softmax_linear')
            # softmax_linear = tf.nn.softmax(tf.add(tf.matmul(h_fc2_dropout, weights), biases, name='softmax_linear'))
        return softmax_linear
        # 最后返回softmax层的输出
    
    
    # loss计算
    # 传入参数:logits,网络计算输出值。labels,真实值,0或者1
    # 返回参数:loss,损失值
    def losses(logits, labels):
        with tf.variable_scope('loss') as scope:
            cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=labels, name='xentropy_per_example')
            loss = tf.reduce_mean(cross_entropy, name='loss')
            tf.summary.scalar(scope.name + '/loss', loss)
        return loss
    
    # loss损失值优化
    # 输入参数:loss。learning_rate,学习速率。
    # 返回参数:train_op,训练op,这个参数要输入sess.run中让模型去训练。
    def trainning(loss, learning_rate):
        with tf.name_scope('optimizer'):
            optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
            global_step = tf.Variable(0, name='global_step', trainable=False)
            train_op = optimizer.minimize(loss, global_step=global_step)
        return train_op
    
    # 评价/准确率计算
    # 输入参数:logits,网络计算值。labels,标签,也就是真实值,在这里是0或者1。
    # 返回参数:accuracy,当前step的平均准确率,也就是在这些batch中多少张图片被正确分类了。
    def evaluation(logits, labels):
        with tf.variable_scope('accuracy') as scope:
            correct = tf.nn.in_top_k(logits, labels, 1)
            accuracy = tf.reduce_mean(tf.cast(correct, tf.float16))
            tf.summary.scalar(scope.name + '/accuracy', accuracy)
        return accuracy
    
    

     

    第五部分:训练

    新建Train.py文件

    这部分代码基本来自参考博文。

    '''
    Train.py
    对搭建好的网络进行训练,并保存训练参数,以便下次使用
    2018/7/19实现文件调用,2018/7/22实现最终网络的训练
    -------copyright@GCN-------
    '''
    # 导入文件
    import os
    import numpy as np
    import tensorflow as tf
    from PreWork import get_file, get_batch
    from CNNModel import deep_CNN, losses, trainning, evaluation
    
    # 变量声明
    N_CLASSES = 6
    IMG_W = 28  # resize图像,太大的话训练时间久
    IMG_H = 28
    BATCH_SIZE = 20     # 每个batch要放多少张图片
    CAPACITY = 200      # 一个队列最大多少
    MAX_STEP = 10000 
    learning_rate = 0.0001  # 一般小于0.0001
    
    # 获取批次batch
    train_dir = './CK+_part'  # 训练样本的读入路径
    logs_train_dir = './CK+_part'  #logs存储路径
    train, train_label = get_file(train_dir)
    # 训练数据及标签
    train_batch, train_label_batch = get_batch(train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
    
    # 训练操作定义
    train_logits = deep_CNN(train_batch, BATCH_SIZE, N_CLASSES)
    train_loss = losses(train_logits, train_label_batch)
    train_op = trainning(train_loss, learning_rate)
    train_acc = evaluation(train_logits, train_label_batch)
    
    # 这个是log汇总记录
    summary_op = tf.summary.merge_all()
    
    # 产生一个会话
    sess = tf.Session()
    train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
    # 产生一个saver来存储训练好的模型
    saver = tf.train.Saver()
    # 所有节点初始化
    sess.run(tf.global_variables_initializer())
    # 队列监控
    coord = tf.train.Coordinator() # 设置多线程协调器
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    
    # 进行batch的训练
    try:
        # 执行MAX_STEP步的训练,一步一个batch
        for step in np.arange(MAX_STEP):
            if coord.should_stop():
                break
            # 启动以下操作节点,有个疑问,为什么train_logits在这里没有开启?
            _, tra_loss, tra_acc = sess.run([train_op, train_loss, train_acc])
    
            # 每隔50步打印一次当前的loss以及acc,同时记录log,写入writer
            if step % 100 == 0:
                print('Step %d, train loss = %.2f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc * 100.0))
                summary_str = sess.run(summary_op)
                train_writer.add_summary(summary_str, step)
    
            # 保存最后一次网络参数
            checkpoint_path = os.path.join(logs_train_dir, 'thing.ckpt')
            saver.save(sess, checkpoint_path)
    
            '''
            # 每隔100步,保存一次训练好的模型
            if (step + 1) == MAX_STEP:
                checkpoint_path = os.path.join(logs_train_dir, 'thing.ckpt')
                saver.save(sess, checkpoint_path, global_step=step)
            '''
            
    
    except tf.errors.OutOfRangeError:
        print('Done training -- epoch limit reached')
    
    finally:
        coord.request_stop()
    coord.join(threads)
    sess.close()
    
    
    
    

     

    2019.4.22更新

    之前用的数据集(CK+表情数据库)有一点问题:由于数据集中既有灰度图也有彩色图,在程序中设置通道数的时候就没有统一成一样的,所以测试的时候总出错。

    为了方便,直接把图片都换成3通道的彩色图像,修改测试代码。(当然也可以在预处理阶段,把所有的图片转换为统一通道数)

    从网上爬取了三个分类数据集(guitar, house, rabbit),将所有图片借用之前提到的参考文献的代码reshape成相同大小,数据集很小比较简单,所以跑了2000次,简单训练生成网络模型参数文件。

     

    测试代码终于可以跑通了,不过因为我模拟训练的时候数据不平衡,训练的样本也很小,实际测试的时候偶尔效果并不好。真正做的时候要根据实际问题的需求改进,这里只是做个示范就没有考虑这么多,仅供参考

     

     

    第六部分:测试

    新建Test.py文件,修改完成

    在‘hijacklei’的提醒下加了一行初始化代码

    '''
    Test.py
    2019/4/22完成最终网络的测试
    -------copyright@GCN-------
    '''
    # 导入必要的包
    import os
    import numpy as np
    from PIL import Image
    import tensorflow as tf
    import matplotlib.pyplot as plt
    from CNNModel import deep_CNN
    
    N_CLASSES = 3
    
    img_dir = './Input_data/test/'
    log_dir = './Input_data'
    lists = ['guitar', 'house', 'rabbit']
    
    
    # 从测试集中随机挑选一张图片看测试结果
    def get_one_image(img_dir):
        imgs = os.listdir(img_dir)
        img_num = len(imgs)
        # print(imgs, img_num)
        idn = np.random.randint(0, img_num)
        image = imgs[idn]
        image_dir = img_dir + image
        print(image_dir)
        image = Image.open(image_dir)
        plt.imshow(image)
        plt.show()
        image = image.resize([28, 28])
        image_arr = np.array(image)
        return image_arr
    
    
    def test(image_arr):
        with tf.Graph().as_default():
            image = tf.cast(image_arr, tf.float32)
            image = tf.image.per_image_standardization(image)
            image = tf.reshape(image, [1, 28, 28, 3])
            # print(image.shape)
            p = deep_CNN(image, 1, N_CLASSES)
            logits = tf.nn.softmax(p)
            x = tf.placeholder(tf.float32, shape=[28, 28, 3])
            saver = tf.train.Saver()
            sess = tf.Session()
            sess.run(tf.global_variables_initializer())
            ckpt = tf.train.get_checkpoint_state(log_dir)
            if ckpt and ckpt.model_checkpoint_path:
                # print(ckpt.model_checkpoint_path)
                saver.restore(sess, ckpt.model_checkpoint_path)
                # 调用saver.restore()函数,加载训练好的网络模型
                print('Loading success')
            prediction = sess.run(logits, feed_dict={x: image_arr})
            max_index = np.argmax(prediction)
            print('预测的标签为:', max_index, lists[max_index])
            print('预测的结果为:', prediction)
    
    
    if __name__ == '__main__':
        img = get_one_image(img_dir)
        test(img)
    

    说明:测试集不是训练集的一部分!测试集没有参与训练!

    来看一下测试效果,结果如下

    显示随机的测试图片

    关闭图片后会出现测试结果

     

     

     

    2019.08.14

    看到有评论说测试代码总是只能测出一个结果,我特地用二分类做了一下简单的测试,不规范是真的,最终结果应该没什么问题。

     我把这份完整的代码包括数据集和训练模型参数打包放到github上,剩下的大家就根据实际情况修改吧!

     

    特别说明

    注意,真实训练的时候,测试数据集应该是和训练数据集不一样的,这里只是做个示例。

    总的说来,现在看这份代码,其实有很多不规范的地方,所以仅作参考

     


    数据库用的是CK+表情数据库中的原图

    放上完整的项目链接CNN(from github)

    2019-8-14用二分类做的小测试完整项目A-Simple-Two-Classification-Problem-Based-on-CNN


     

    展开全文
  • Fast-ReID前期准备 文章目录 Fast-ReID前期准备 前言 一、Fast-ReID 介绍 Fast-ReID 特点 FastReID 架构 二、Fast-ReID 复现 前言 FastReID 是一...训练以及调优过程 下一节 Fast-ReID 训练自己的数据集调优记录(二)

    Fast-ReID前期准备



    前言

    FastReID 是一个 SOTA 级的 ReID 方法集合工具箱(SOTA ReID Methods and Toolbox),同时面向学术界和工业界落地,此外该团队还发布了在多个不同任务、多种数据集上的SOTA模型。
    FastReID中实现的四大ReID任务:
    行人重识别
    部分区域的行人重识别
    跨域的行人重识别
    车辆的重识别

    论文:https://arxiv.org/pdf/2006.02631.pdf
    代码:https://github.com/JDAI-CV/fast-reid

    一、Fast-ReID 介绍

    Fast-ReID 特点

    提供了针对ReID任务的完整的工具箱,包括训练、评估、微调和模型部署,另外实现了在多个任务中的最先进的模型。
    1)模块化和灵活的设计,方便研究者快速将新的模块插入和替换现有流程中,帮助学界快速验证新思路;

    2)易于管理的系统配置,FastReID用PyTorch实现,可提供在多GPU服务器的快速训练,模型结构、训练和测试可以用YAML文件方便定义,并对每一块提供了众多可定义选项(主干网、训练策略、聚合策略、损失函数等)。

    3)丰富的评估系统,不仅实现了CMC评估指标,还包括ROC、mINP等,可以更好的反应模型性能。

    4)易于工程部署,FastReID不仅提供了有效的知识蒸馏模块以得到精确且高效的轻量级模型,而且提供了PyTorch->Caffe和PyTorch->TensorRT模型转换工具。

    5)众多的State-of-the-art预训练模型,官方计划发布人员重识别(person re-id),部分可见的人员重识别( partial re-id), 跨域人员重识别(cross-domain re-id) 和 车辆重识别(vehicle re-id) 等众多模型。

    FastReID 架构

    在这里插入图片描述
    训练阶段包括模块:
    1)预处理Pre-processing,其实就是各种数据增广方法,如 Resize,Flipping,Random erasing,Auto-augment(automl 中的技巧,使用该技巧去实现有效的数据增强,提高特征的鲁棒性),Random patch,Cutout等;其中Random erasing在reid任务中效果显著。
    在这里插入图片描述
    2)骨干网(Backbone),包括主干网的选择(如ResNet,ResNest,ResNeXt等)和可以增强主干网表达能力的特殊模块(如non-local、instance batch normalization (IBN)模块等);

    3)聚合模块(Aggregation),用于将骨干网生成的特征聚合成一个全局特征,如max pooling, average pooling, GeM pooling , attention pooling等方法;

    4)Head 模块,用于对生成的全局特征进行归一化、纬度约减等。

    5)训练策略,包含Learning rate,warm-up,Backbone freeze,余弦衰减(consine decay)等。

    6)特别值得一提的是其损失函数,不仅包括常见的Cross-entropy loss, Triplet loss,Arcface loss,还实现了今年上半年刚出的旷视CVPR 2020 Oral 论文中的Circle loss!(被认为是目前在各种度量学习任务中表现最好的)可见FastReID开发团队紧跟前沿。

    在推理阶段,包含模块:
    1)度量部分,除支持常见的余弦和欧式距离,还添加了局部匹配方法 deep spatial reconstruction (DSR);

    2)后处理部分,指对检索结果的处理,包括K-reciprocal coding 和 Query Expansion (QE) 两种重排序方法。

    二、Fast-ReID 复现

    安装fast-reid: 代码会更新详情可见官方Installation
    conda create -n fastreid python=3.7
    conda activate fastreid
    conda install pytorch==1.6.0 torchvision tensorboard -c pytorch
    pip install -r requirements
    pip install faiss-cpu # faiss-cpu此方法能正确安装

    按照官方方法即可 Getting Started with Fastreid
    cd fastreid/evaluation/rank_cylib; make all

    pytorch支持半精度训练,需安装apex
    $ git clone https://github.com/NVIDIA/apex
    $ cd apex
    $ pip install -v --no-cache-dir --global-option="–pyprof" --global-option="–cpp_ext" --global-option="–cuda_ext" ./
    环境搞好后可先用Market1501数据集训练起来,说明安装没有问题。
    fast-reid封装的非常繁琐,初次一看很难看懂,下次将详细讲述fast-reid源码。训练以及调优过程

    下一节 Fast-ReID 代码讲解

    展开全文
  • yolov4训练自己的数据集实现安全帽佩戴检测

    万次阅读 多人点赞 2020-07-07 22:46:41
    修改voc_classes.txt 在训练前需要修改model_data里面的voc_classes.txt文件,需要将classes改成你自己的classes。 4.修改yolo_anchors.txt 运行kmeans_for_anchors.py生成yolo_anchors.txt 5.运行 运行train.py ...
  • yolov3训练自己的数据集——第一次实操完整记录

    万次阅读 多人点赞 2019-07-09 19:36:24
    make -j4 表示用4条线程编译(对应自己的电脑,看自己电脑cpu几核几线程) make -j32 用32线程编译 darknet源码解析 darknet概述 darknet是一个轻型的、完全基于C与CUDA的开源深度学习框架,支持CPU和GPU两...
  • C站(CSDN)软件工程师能力认证上线15天以来,小编跟随来自全国33所高校的同学自发组建的学习小组,发现了一套有效提升系统持续学习能力的模型: 明确学习路径+任务领取+刻意训练+大咖互动 基于C1能力模型,...
  • 通过大学生创新实验计划的推动,大力开展大学生创新能力训练、创新实验和发明创造活动,基本形成了基于课外科研项目、实验室开放、学科竞赛、社团活动4种大学生创新能力训练模式。建立和完善保障机制、搭建学生...
  • 详解tensorflow训练自己的数据集实现CNN图像分类

    万次阅读 多人点赞 2018-07-02 22:45:52
    教程并没有使用MNIST数据集,而是使用了真实的图片文件,并且教程代码包含了模型的保存、加载等功能,因此希望在日常项目中使用Tensorflow的朋友可以参考这篇教程。完整代码可在专知成员Hujun的Github中下载。...
  • v4目标检测算法详解及预训练模型使用与自己训练模型一、YOLO简介二、YOLO v3三、YOLO v4四、预训练模型使用(基于Darknet的GPU版本)五、自己训练模型(使用GPU) 一、YOLO简介 YOLO是目前比较流行的目标检测算法,...
  • 当我们需要一个比较好的GPU而我们的预算又不足的时候,我们可以租用一个服务器用来临时跑自己的深度学习模型,本文以Xshell远程连接GPU服务器的方式介绍如何将自己的模型上传到服务器并运行   1.安装...
  • YOLO3训练自己数据(超详细步骤)

    万次阅读 多人点赞 2019-01-18 14:51:33
    momentum=0.9 #滑动平均模型,在训练的过程中不断地对参数求滑动平均,这样能够更有效地保持稳定,使其对当前参数更新不敏感 decay=0.0005 #权重衰减,防止过拟合 angle=0 saturation = 1.5 exposure = 1.5 hue=.1...
  • 机器学习避坑指南:训练集/测试集分布一致检查

    千次阅读 多人点赞 2020-12-24 20:35:00
    缺失值处理、异常值处理、数据标准化、不平衡等问题大家应该都已经手到擒来小菜一碟了,本文我们探讨一个很容易被忽视的坑:数据一致。 众所周知,大部分机器学习算法都有一个前提假设:训练数据样本和位置的测试...
  • 零基础自学yolov5,学会简单使用和训练自己的数据集,在自己工作中使用
  • 2017 如何训练一个GAN网络

    千次阅读 2019-04-08 22:26:56
    GAN, 作为一种非常厉害的生成模型, 在近年来得到了广泛的应用. Soumith, PyTorch之父, 毕业于纽约大学... 他对GAN的理解相对深入, 特地总结了关于训练GAN的一些技巧和方式, 因为不同于一般任务, 像设置优化器, 计算l...
  • 使用opencv的Haar训练自己的人脸分类器

    万次阅读 热门讨论 2016-10-21 15:34:39
    样本间差异越大越好 正负样本比例为 1 : 3 最佳 ; 尺寸为 20x20 最佳。 1.1.1正样本  训练样本的尺寸为 20*20(opencv 推荐的最佳尺寸 ) ,且所有样本的尺寸必须一致。如果不一致的或者尺寸较大的,...
  • 深入理解深度学习——预训练模型

    万次阅读 2022-02-06 12:59:01
    近些年基于深度学习的NLP技术的重大进展主要包括NNLM(2003)、Word Embedding(2013)、Seq2Seq(2014)、Attention(2015)、Transformer(2017)、GPT(2018)、BERT(2018)、XLNet(...,主要预训练模型的大致发展脉络见下图...
  • 作者丨陈家铭学校丨中山大学硕士生研究方向丨半监督深度图像分类协同训练 Co-trainingCo-training 是基于分歧的方法,其假设每个数据可以从不同的角度(vi...
  • 核心工作:提出一种通过最小化分离误差解决标签排列问题的排列不变训练技术。 基于类的方法: 1. 通过预测所属目标类的源来进行网络优化,通常用于每个时频块; 2. 只能用于语音与背景噪声或音乐的分离,因为语音...
  • 训练模型简介

    千次阅读 2021-11-25 12:37:15
    训练模型 预训练模型把迁移学习很好地用起来了,让我们感到眼前一亮。这和小孩子读书一样,一开始语文、数学、化学都学,读书、网上游戏等,在脑子里积攒了很多。当他学习计算机时,实际上把他以前学到的所有知识...
  • 深度学习训练技巧总结

    万次阅读 多人点赞 2020-05-07 09:05:50
    模型训练技巧最直接的就是几个超参数的设置 根据图片大小来选择网络和超参数 如果图片不是很大比如3030,这种情况下做分类就不能用VGG和Resnet这样的网络。此时要么把图像变大要么就是选择小的网络,或者把VGG里...
  • 由于它自带的数据集完全不能够满足需要,只能从头开始自己训练。当然这必须要用python来做了,不能用C语言。。。 首先,我发现那个著名的Keras版本非常好:https://github.com/qqwweee/keras-yolo3。但它的一些地方...
  • 深度神经网络 (DNN) 已经发展到...添加到图像中的噪声是一种对抗扰动,我们将试图通过使这些神经网络不易受扰动来解决这个问题的训练方法将被称为对抗性训练。 由于最近提出的使用未标记分布 (UID) 数据的数据增强
  • Yolov5自定义图片训练测试及模型调优(详细过程)

    万次阅读 多人点赞 2021-07-04 16:11:13
    如果自定义训练自己的数据集,首先需要数据标注,至于数据来源可以是下载现有的开发数据集、拍照、爬虫等等。 如果是拍照、爬虫等获取的数据图片,需要进行数据标注,这个过程可以使用工具来做,但也需要一些手动...
  • 训练集、验证集、测试集的区别与应用

    万次阅读 多人点赞 2018-11-01 21:50:36
    今天想讲的是数据集的划分,即训练集,验证集和测试集分别是啥,又有啥用处,其区别是什么。目前网上讲述的大多相同,不同的讲解又太过简略,而且侧重点多半是讲述在不同方法上,而对于其确切内容没有一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 292,524
精华内容 117,009
关键字:

如何训练自己的性功能