2017-01-08 21:27:40 lhanchao 阅读数 10803
  • 机器学习&深度学习系统实战!

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 数学原理推导与案例实战紧密结合,由机器学习经典算法过度到深度学习的世界,结合深度学习两大主流框架Caffe与Tensorflow,选择经典项目实战人脸检测与验证码识别。原理推导,形象解读,案例实战缺一不可!具体课程内容涉及回归算法原理推导、决策树与随机森林、实战样本不均衡数据解决方案、支持向量机、Xgboost集成算法、神经网络基础、神经网络整体架构、卷积神经网络、深度学习框架--Tensorflow实战、案例实战--验证码识别、案例实战--人脸检测。 专属会员卡优惠链接:http://edu.csdn.net/lecturer/1079

    39679 人正在学习 去看看 唐宇迪

我们都知道,深度学习的成功的原因主要有两点:
(1)当前计算机的计算能力有很大提升;
(2)随着大数据时代的到来,当前的训练样本数目有很大的提升。
然而深度学习的一大问题是,有的问题并没有大量的训练数据,而由于深度神经网络具有非常强的学习能力,如果没有大量的训练数据,会造成过拟合,训练出的模型难以应用。

因此对于一些没有足够样本数量的问题,可以通过已有的样本,对其进行变化,人工增加训练样本。

对于图像而言,常用的增加训练样本的方法主要有对图像进行旋转、移位等仿射变换,也可以使用镜像变换等等,这里介绍一种常用于字符样本上的变换方法,弹性变换算法(Elastic Distortion)。该算法最先是由Patrice等人在2003年的ICDAR上发表的《Best Practices for Convolutional Neural Networks Applied to Visual Document Analysis》提出的,最开始应用在mnist手写体数字识别数据集中,发现对原图像进行弹性变换的操作扩充样本以后,对于手写体数字的识别效果有明显的提升。当前也有很多人把该方法应用到手写体汉字的识别问题中,是一种很普遍的扩充字符样本图像的方式。

下面来详细介绍一下算法流程:

(1)首先需要对图像中的每个像素点(x,y)产生两个-1~1之间的随机数,Δx(x,y)和Δy(x,y),分别表示该像素点的x方向和y方向的移动距离;

(2)生成一个以0为均值,以σ为标准差的高斯核k_nn,并用前面的随机数与之做卷积,并将结果作用于原图像。

作者在这里提出σ的大小与弹性变换的处理结果息息相关,如果σ过小,则生成的结果类似与对图像每个像素进行随机移动,而如果σ过大,则生成的结果与原图基本类似。

但是作者在文中并没有解释高斯核k_nn中n的大小对图像处理结果的影响,下面我的操作结果以n和σ为变量,进行了实验,我的原图是573*573大小,产生的卷积结果实验结果Δx(x,y)和Δy(x,y)各自扩大了100倍(因为Δx(x,y)和Δy(x,y)是-1~1的,如果不扩大的话基本看不出变化),实验结果如下图所示:

(1)n = 5,σ=4,8,16时:


(2)n = 21,σ= 4,8,16时:

(3)n = 105,σ = 4,8,16时:


可以看出来,只有在n足够大(与要处理的图像相比),且σ大小合适时才能够到合适的扭曲图像,如图所示,这里n = 105且σ=8时比较合适。

现在的论文中,只是介绍了算法流程,但具体的实现方法并没有介绍,我在实现的过程中一直很不清楚把Δx(x,y)和Δy(x,y)和卷积核做卷积具体是怎样做,而且也不太清楚卷积核的大小是多少,最终自己摸索这得到结果,应该是像我代码的方法。我的代码如下,对于高斯卷积和图像的读取使用的Opencv的函数,最终也可以自己在实现的函数中添加变量控制n和σ,我这里图方便,懒得加了。

Mat elasticDistort(Mat& img)
{
    //转成灰度图像
    cvtColor(img,img,CV_RGB2GRAY);
    //分别存放原图各个像素点对应的Δx(x,y)和Δy(x,y)
    Mat Xmv(img.rows,img.cols,CV_32FC1);
    Mat Ymv(img.rows,img.cols,CV_32FC1);
    //初始化Xmv
    srand(time(NULL));
    for(int i = 0; i<img.rows; i++)
    {
        float* p = Xmv.ptr<float>(i);
        for(int j = 0; j<img.cols; j++)
        {
            p[j] = (rand() % 3 - 1) * 100;//注意,Xmv和Ymv两个矩阵是产生随机数的基础上进行高斯模糊得到的,这里是产生随机数。2017-04-26
        }
    }
    //初始化Ymv
    srand(time(NULL) + 100);
    for(int i = 0; i<img.rows; i++)
    {
        float* p = Ymv.ptr<float>(i);
        for(int j = 0; j<img.cols; j++)
        {
            p[j] = (rand() % 3 - 1) * 100;//注意,Xmv和Ymv两个矩阵是产生随机数的基础上进行高斯模糊得到的,这里是产生随机数。2017-04-26
        }
    }

    //使用Opencv函数,对Xmv和Ymv分别做卷积,这里的105和4分别为n和σ
    GaussianBlur(Xmv,Xmv,Size(105,105),4,4);
    GaussianBlur(Ymv,Ymv,Size(105,105),4,4);

    //处理结果图像
    Mat result(img.rows,img.cols,img.type());
    result.setTo(255);
    //把Xmv和Ymv作用到原图像中,得到结果图像
    for(int i = 0; i<img.rows; i++)
    {
        for(int j = 0; j<img.cols; j++)
        {
            int newX = i + cvRound(Xmv.at<float>(i,j));
            int newY = j + cvRound(Ymv.at<float>(i,j));

            newX = newX < 0 ? 0 : newX;
            newY = newY < 0 ? 0 : newY;
            newX = newX >= img.rows ? img.rows - 1 : newX;
            newY = newY >= img.cols ? img.cols - 1 : newY;

            result.at<uchar>(newX,newY) = img.at<uchar>(i,j);
        }
    }
    
    //先对图像做腐蚀操作,再做膨胀操作,可以去掉字符中的白色纹理
    //Mat element = getStructuringElement(MORPH_RECT, Size(2, 2));
    //erode(result,result,element);
    //dilate(result,result, element);
    
    return result;
}


——————————————————————————————————分割线——————————————————————————————————

更新:添加了一个average的过程,这样可以起到一定的平滑作用使得生成的图像更自然

//对图像进行弹性变换,扩充训练数据量,这种方法相比对图像进行仿射变换效果要好
Mat elasticDistort(Mat& img,int gaussianWindowSize,double gaussianKernelSize)
{
    cvtColor(img,img,CV_RGB2GRAY);
    Mat Xmv(img.rows,img.cols,CV_32FC1);
    Mat Ymv(img.rows,img.cols,CV_32FC1);
    //srand(time(NULL));
    for(int i = 0; i<img.rows; i++)
    {
        float* p = Xmv.ptr<float>(i);
        for(int j = 0; j<img.cols; j++)
        {
            p[j] = (rand() % 3 - 1) * 10;//注意,Xmv和Ymv两个矩阵是产生随机数的基础上进行高斯模糊得到的,这里是产生随机数。2017-04-26
        }
    }
    //srand(time(NULL) + 100);
    srand(clock());
    for(int i = 0; i<img.rows; i++)
    {
        float* p = Ymv.ptr<float>(i);
        for(int j = 0; j<img.cols; j++)
        {
            p[j] = (rand() % 3 - 1) * 10;//注意,Xmv和Ymv两个矩阵是产生随机数的基础上进行高斯模糊得到的,这里是产生随机数。2017-04-26
        }
    }
    GaussianBlur(Xmv,Xmv,Size(gaussianWindowSize,gaussianWindowSize),gaussianKernelSize,gaussianKernelSize);
    GaussianBlur(Ymv,Ymv,Size(gaussianWindowSize,gaussianWindowSize),gaussianKernelSize,gaussianKernelSize);

    
    Mat result(img.rows,img.cols,img.type());
    result.setTo(255);
    for(int i = 0; i<img.rows; i++)
    {
        for(int j = 0; j<img.cols; j++)//这里进行了更改!
        {   
            int newX_low = i + cvFloor(Xmv.at<float>(i,j));
            int newX_high = i + cvCeil(Xmv.at<float>(i,j));
            int newY_low = j + cvFloor(Ymv.at<float>(i,j));
            int newY_high = j + cvCeil(Ymv.at<float>(i,j));


            newX_low = newX_low < 0 ? 0 : newX_low;
            newX_high = newX_high < 0 ? 0 : newX_high;
            newY_low = newY_low < 0 ? 0 : newY_low;
            newY_high = newY_high < 0 ? 0 : newY_high;


            newX_low = newX_low >= img.rows ? img.rows - 1 : newX_low;
            newX_high = newX_high >= img.rows ? img.rows - 1 : newX_high;
            newY_low = newY_low >= img.cols ? img.cols - 1 : newY_low;
            newY_high = newY_high >= img.cols ? img.cols - 1 : newY_high;


            int sum = img.at<uchar>(newX_low,newY_low) + img.at<uchar>(newX_low,newY_high)+
                         img.at<uchar>(newX_high,newY_low) + img.at<uchar>(newX_high,newY_high);
            double avg = sum * 1.0 * 0.25;
            if(avg < 110)
            {
                avg = 0;
            }
            else if(avg > 145)
                avg = 255;
            result.at<uchar>(i,j) = avg;
            //result.at<uchar>(newX,newY) = img.at<uchar>(i,j);
        }
    }
    //cout<<result<<endl;
    return result;
}

————————————————————2017年4月26日更新——————————————————————

    Mat Xmv(img.rows,img.cols,CV_32FC1);
    Mat Ymv(img.rows,img.cols,CV_32FC1);
    //srand(time(NULL));
    for(int i = 0; i<img.rows; i++)
    {
        float* p = Xmv.ptr<float>(i);
        for(int j = 0; j<img.cols; j++)
        {
            p[j] = (rand() % 3 - 1) * 10;//注意,Xmv和Ymv两个矩阵是产生随机数的基础上进行高斯模糊得到的,这里是产生随机数。2017-04-26
        }
    }
    //srand(time(NULL) + 100);
    srand(clock());
    for(int i = 0; i<img.rows; i++)
    {
        float* p = Ymv.ptr<float>(i);
        for(int j = 0; j<img.cols; j++)
        {
            p[j] = (rand() % 3 - 1) * 10;//注意,Xmv和Ymv两个矩阵是产生随机数的基础上进行高斯模糊得到的,这里是产生随机数。2017-04-26
        }
    }
    GaussianBlur(Xmv,Xmv,Size(gaussianWindowSize,gaussianWindowSize),gaussianKernelSize,gaussianKernelSize);
    GaussianBlur(Ymv,Ymv,Size(gaussianWindowSize,gaussianWindowSize),gaussianKernelSize,gaussianKernelSize);

上面的代码是Xmv和Ymv矩阵的生成代码,从代码中Xmv和Ymv的生成方法实际上就是先产生两个随机矩阵,然后在该随机矩阵上进行高斯模糊,上面两个for循环做的就是生成随机矩阵,如果要弹性变形的图像比较大,可以考虑在较大的范围内生成随机数,如p[j] = (rand() % 5 - 2) * 10,即生成-20到20之间的随机数,这样会更适合较大的图像的随机弹性形变样本生成。



2018-02-11 11:04:35 u013102349 阅读数 11457
  • 机器学习&深度学习系统实战!

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 数学原理推导与案例实战紧密结合,由机器学习经典算法过度到深度学习的世界,结合深度学习两大主流框架Caffe与Tensorflow,选择经典项目实战人脸检测与验证码识别。原理推导,形象解读,案例实战缺一不可!具体课程内容涉及回归算法原理推导、决策树与随机森林、实战样本不均衡数据解决方案、支持向量机、Xgboost集成算法、神经网络基础、神经网络整体架构、卷积神经网络、深度学习框架--Tensorflow实战、案例实战--验证码识别、案例实战--人脸检测。 专属会员卡优惠链接:http://edu.csdn.net/lecturer/1079

    39679 人正在学习 去看看 唐宇迪

在深度学习中,样本不均衡是指不同类别的数据量差别较大,利用不均衡样本训练出来的模型泛化能力差并且容易发生过拟合。

对不平衡样本的处理手段主要分为两大类:数据层面 (简单粗暴)算法层面 (复杂) 。

数据层面

采样(Sample)

数据重采样:上采样或者下采样

 上采样下采样
使用情况数据不足时数据充足 (支撑得起你的浪费)
数据集变化增加间接减少(量大类被截流了)
具体手段大量复制量少类样本批处理训练时,控制从量大类取的图像数量
风险过拟合

数据合成

数据合成方法是利用已有样本生成更多的样本。其中最常见的一种方法叫做SMOTE,它利用小众样本在特征空间的相似性来生成新样本。对于小众样本xi∈Smin,从它属于小种类的K近邻中随机选取一个样本,生成一个新的小众样本xnew:


上图是SMOTE方法在K=6近邻下的示意图,黑色圆点是生成的新样本。

算法层面

在目标函数中,增加量少类样本被错分损失值 

准确度这个评价指标在类别不均衡的分类任务中并不能work.

代价敏感学习算法(Cost-Sensitive Learning)

不同类型的五分类情况导致的代价是不一样的。因此定义代价矩阵,Cij表示将类别j误分类为i的代价,显然C00=C11=0.C01和C10为两种不同的误分类代价,当两者相等时为代价不敏感的学习问题。


代价敏感学习方法主要有以下的实现方式:

(1)从学习模型出发,着眼于对某一具体学习方法的改造,使之能适应不平衡数据下的学习,研究者们针对不同的学习模型如感知机,支持向量机,决策树,神经网络等分别提出了其代价敏感的版本。以代价敏感的决策树为例,可从三个方面对其进行改进以适应不平衡数据的学习,这三个方面分别是决策阈值的选择方面、分裂标准的选择方面、剪枝方面,这三个方面中都可以将代价矩阵引入。

(2)从贝叶斯风险理论出发,把代价敏感学习看成是分类结果的一种后处理,按照传统方法学习到一个模型,以实现损失最小为目标对结果进行调整,优化公式如下所示。此方法的优点在于它可以不依赖所用具体的分类器,但是缺点也很明显它要求分类器输出值为概率。


(3)从预处理的角度出发,将代价用于权重的调整,使得分类器满足代价敏感的特性。


参考:

[1] http://blog.csdn.net/jningwei/article/details/79249195

[2] https://www.jianshu.com/p/3e8b9f2764c8

[3] http://blog.csdn.net/lujiandong1/article/details/52658675



2019-09-08 15:41:34 qq_16236875 阅读数 147
  • 机器学习&深度学习系统实战!

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 数学原理推导与案例实战紧密结合,由机器学习经典算法过度到深度学习的世界,结合深度学习两大主流框架Caffe与Tensorflow,选择经典项目实战人脸检测与验证码识别。原理推导,形象解读,案例实战缺一不可!具体课程内容涉及回归算法原理推导、决策树与随机森林、实战样本不均衡数据解决方案、支持向量机、Xgboost集成算法、神经网络基础、神经网络整体架构、卷积神经网络、深度学习框架--Tensorflow实战、案例实战--验证码识别、案例实战--人脸检测。 专属会员卡优惠链接:http://edu.csdn.net/lecturer/1079

    39679 人正在学习 去看看 唐宇迪

两个方面: 1 数据抽样,2 从算法角度出发,考虑不同误分类情况代价的差异性对算法进行优化。

1-1 欠采样:随机采样

1-2 过采样:smote 算法

SMOTE算法: 即合成少数类过采样技术,它是基于随机过采样算法的一种改进方案,由于随机过采样采取简单复制样本的策略来增加少数类样本,这样容易产生模型过拟合的问题,即使得模型学到的信息过于特别而不够泛化,SMOTE 算法的实习是对少数样本进行分析并根据少数样本人工合成新样本。

(1) 对少数类中的每个样本,以欧式距离为标准计算它到少数样本集中所有样本的距离,得到其k 近邻。

(2) 根据样本不平衡比例设置一个采样比例以确定采样倍率,对每个少数样本,从其k近邻中随机选择若干个样本。

(3) 对于每个随机选出的近邻,分别与原样本按照如下公式构建新样本

1-3 代价敏感学习

(1) 代价矩阵

算法: 代价敏感学习算法

costij 表示将第i 类样本预测为第j 类样本的代价,一般来说,costij =0 若将0 类判别为第1 类所造成的损失更大,则cost01> cost10,损失程度相差越大,cost01 与cost10的值差别越大,当cost01 和cost10 相等时为代价不敏感的学习问题。

(2) 代价敏感学习方法:

三种实现方式:

1) 从学习模型出发,对某一具体学习方法的改造,是之能适应不平衡数据,例如感知机,SVM,决策树,神经网络,以决策树为例: 可以从三个方面对其进行改造以适应不平衡数据的学习,这三个方面是决策阈值的选择方面,分裂标准的选择方面,剪枝方面,这三个方面都可以将代价矩阵引入。

2) 从贝叶斯风险理论出发,把代价敏感学习看成是分类结果的一种后处理。按照传统方法学习到一个模型,以实现损失最小为目标对结果进行调整,优化公式如下: 优点在于它可以不依赖所用的具体分类器,但是缺点也很明显,它要求分类器输出值为概率。

3) 从预处理的角度出发,将代价用于权重调整,使得分类器满足代价敏感的特性。

2.4 不平衡学习的评价方法

(1)F1 度量

(3)ROC 曲线和AUC面积

(4) ROC 和PRC

ROC曲线有个很好的特性:当测试集中的正负样本的分布变化的时候,ROC曲线能够保持不变。

对不平衡数据,PRC很敏感。

PRC相对的优势

当正负样本差距不大的情况下,ROC和PR的趋势是差不多的,但是当负样本很多时候,两者就截然不同了,ROC的效果看似很好,但是PR 上反映效果一般。

一般用ROC。

https://blog.csdn.net/pipisorry/article/details/51788927

https://zhuanlan.zhihu.com/p/36381828

 

2019-08-11 16:11:57 weixin_43283397 阅读数 38
  • 机器学习&深度学习系统实战!

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 数学原理推导与案例实战紧密结合,由机器学习经典算法过度到深度学习的世界,结合深度学习两大主流框架Caffe与Tensorflow,选择经典项目实战人脸检测与验证码识别。原理推导,形象解读,案例实战缺一不可!具体课程内容涉及回归算法原理推导、决策树与随机森林、实战样本不均衡数据解决方案、支持向量机、Xgboost集成算法、神经网络基础、神经网络整体架构、卷积神经网络、深度学习框架--Tensorflow实战、案例实战--验证码识别、案例实战--人脸检测。 专属会员卡优惠链接:http://edu.csdn.net/lecturer/1079

    39679 人正在学习 去看看 唐宇迪

神经网络和深度学习目前提供了针对图像识别,语音识别和自然语言处理领域诸多问题的最佳解决方案。传统的编程方法中,我们告诉计算机如何去做。而神经网络不需要我们告诉计算机如何处理问题,而是通过从观测数据中学习,计算出他自己的解决方案。


问题: 如何训练神经网络使得它比传统的方法更好?
:深度学习是为了训练神经网络,让他(计算机)自己能够从数据中学习。神经网络使用样本自动地推断规则,通过增加训练样本的数量,该网络可以学到更多,并且更加准确。


两种重要类型的神经元:

1、感知机
感知机是一类人造神经元
在这里插入图片描述
它用权重w1,w2…w1,w2…来表示各个输入对输出的重要性。神经元的输出,要么是0要么是1,由权重和jwjxj\sum_{j} w_{j} x_{j}的值是否小于或者大于某一阈值。

output ={0 if jwjxj threshold 1 if jwjxj> threshold =\left\{\begin{array}{ll}{0} & {\text { if } \sum_{j} w_{j} x_{j} \leq \text { threshold }} \\ {1} & {\text { if } \sum_{j} w_{j} x_{j}>\text { threshold }}\end{array}\right.

以上就是感知机的工作原理,简化一下就是:

output ={0 if wx+b01 if wx+b>0=\left\{\begin{array}{ll}{0} & {\text { if } w \cdot x+b \leq 0} \\ {1} & {\text { if } w \cdot x+b>0}\end{array}\right.

用向量点积的方式代替了jwjxj\sum_{j} w_{j} x_{j} ,其中W和X分别是权重值和输入值所组成的向量, 即b=−threshold,其中b被称为感知机的偏差
把偏差b看作衡量感知机输出1的难易程度

2、Sigmoid神经元
Sigmoid神经元和感知机很相似,但是它却可以实现当对权重和偏差做微小的改变时,输出量的改变也是微小的。这将使得sigmoid神经元网络可以学习成为了可能。
和感知机一样,sigmoid函数也拥有输入向量,但是它的输入向量不再仅限于0和1,而是0到1之间的连续值。比如,0.1314可以作为sigmoid神经元的输入值。同样,sigmoid神经元对每个输入都有分配权重和一个总的偏差。但是输出也不再是0和1,而是σ(w⋅x)+b,其中σ被称为sigmoid函数,定义为:

σ(z)11+ez\sigma(z) \equiv \frac{1}{1+e^{-z}}

一个拥有输入x1,x2…x1,x2…权重w1,w2…w1,w2…偏差b的sigmoid神经元的输出为:

11+exp(jwjxjb)\frac{1}{1+\exp \left(-\sum_{j} w_{j} x_{j}-b\right)}

为了体现和感知机的相似性,假设z=w⋅x+b是一个很大的正数,那么e−z≈0,那么σ(z)≈1。也就是说当z=w⋅x+b是一个很大的正数时,sigmoid神经元的输出就接近于1,这就像一个感知机一样。反之当z=w⋅x+b是一个很小的负数时,sigmoid的输出结果趋近于0,这和感知机的行为很相似。只有当w⋅x+b的值不大不小的时候,sigmoid的输出才和感知机不一样。

对于σ的代数式我们该如何理解?事实上,对于σ的精确表达并不重要,重要的是σ所形成的函数图形:

在这里插入图片描述
如果σ改为一个阶跃函数,那么sigmoid神经元就等同于感知机,如下图所示:
在这里插入图片描述
Sigmoid 激活函数的局限:

  Sigmoid 函数的一个局限性是当 xx 增大或者减小时,它的梯度变得越来越小。如果使用梯度下降或类似的方法,这就是梯度消失问题。因为随着梯度变小,参数值的变化导致网络输出的变化会很小。这将极大减慢学习速度。 这样的话使用线性整流激活函数(RELU),这个函数只有在输出为正的时候,他才允许激活。而且由于它只是一个简单的取最大值操作,使用该函数网络比具有S形激活函数的网络要快得多。这也提高了神经网络的稀疏性,因为当随机初始化时,整个网络中大约一半的神经元将被设置为0.

说明:如果神经元的输出接近1,可以认为它是"活跃的"(或者说是"激活的");如果其输出值接近于0,则为 “不活跃的”。稀疏性把神经元在大部分时间限制在不活跃的状态。这通常会得到更好的泛化性能。

3、Softmax 函数:
Softmax函数实质上是Sigmoid函数的泛化。该函数通常应用于神经网络的最后一层,同时主要用于执行多分类任务。由于Softmax函数给出了输出属于每一类的概率,因此 Softmax 值的总和总是等于1.

到目前为止,我们所讨论的神经网络都是上一层的输出作为下一层的输入。这样的网络被称为前馈神经网
然而,有些人造神经网络中存在反馈回路是可能的。这样的模型称为递归神经网络


神经网络与黑盒子

   尽管神经网络通过训练得到的模型在测试集上表现良好,但是其学习的内部细节依然不能转化为对问题的理解。权重是神经网络学习到的内容,但是权重不可能告诉我们太多的信息。特别是,神经网络的工作方式是将学习分布到不同的链接权重中。这种方式使得神经网络对损坏具有弹性类比生物的大脑,当大脑受到不正常的碰撞之后,还能保持正常思维。因此,删除一个节点甚至相当多的节点,都不太可能彻底破坏神经网络良好的工作能力。


神经元个数的选择:

输入层:与需要求解问题的特征维数有关
隐藏层:神经元的个数与网络的层数与求解问题的复杂度有关
输出层:与求解问题的类型有关。如果是个二分类问题,那么输出神经元的个数就是 2,且每个都是概率值;如果是一个回归问题,输出层就只有一个神经元


针对问题合理选择网络

尽管现在网络种类复杂多样,但选用哪一种网络,需要根据问题来定。假如面对的数据是线性可分,那么感知机足矣。但现实世界中的数据大多线性不可分,所以引入多层神经网络来挖掘数据特征,更好的解决实际问题。


神经网络注意点

1.隐藏层节点的激活函数将非线性引入网络中

2.为了在权重上执行梯度下降算法,激活函数需要是可微的


神经网络快速地近似任何函数:

汉阳大学 Jechang Jeong 等人开发了一种深度神经网络方法,实时去除图像中的雾气,这对于不可见的图像是很有效的,他们认为:

图像中的雾可以通过未知的复杂函数进行数学模拟,我们利用深度神经网络来近似相应的雾的数学模型

研究人员 Hornik 等发现,一个隐藏层足以模拟任何分段连续函数。他们的定理是:设 F 是 n 维空间有界子集上的连续函数,那么存在一个包含有限个隐藏单元的双层神经网络F1,它近似等于 F。也就是说,对于 F 域中所有的 x,|F(x) - F1(x) < eplison|

这个定理说明了对于任何连续函数 F 和一定的容错 eplison, 可以构建一个单隐藏层的神经网络用于计算 F。这至少在理论上说明一个隐藏层对于很多问题是足够的。


神经网络选择最佳层数的原则:

方法一:频繁的尝试和试错

方法二:如果将每个隐藏层视为一个特征检测器,层数越多,就可以学到越复杂的特征检测器。这就总结出了一个简单的法则 —— 函数越复杂,需要使用的层数就越多

2018-07-04 22:05:57 albertyzy 阅读数 50
  • 机器学习&深度学习系统实战!

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 数学原理推导与案例实战紧密结合,由机器学习经典算法过度到深度学习的世界,结合深度学习两大主流框架Caffe与Tensorflow,选择经典项目实战人脸检测与验证码识别。原理推导,形象解读,案例实战缺一不可!具体课程内容涉及回归算法原理推导、决策树与随机森林、实战样本不均衡数据解决方案、支持向量机、Xgboost集成算法、神经网络基础、神经网络整体架构、卷积神经网络、深度学习框架--Tensorflow实战、案例实战--验证码识别、案例实战--人脸检测。 专属会员卡优惠链接:http://edu.csdn.net/lecturer/1079

    39679 人正在学习 去看看 唐宇迪

记录一些看过的比较好的深度学习文章。

深度 | 从修正Adam到理解泛化:概览2017年深度学习优化算法的最新研究进展 机器之心翻译的Sebastian Ruder的blog

概览深度学习中的五大正则化方法和七大优化策略 知乎专栏,也是机器之心

要点:正则化避免参数数量多于样本数量的模型过拟合,有助于泛化。而增加样本数量也可以防止过拟合。防止过拟合还可使用数据增强、L1 正则化、L2 正则化、Dropout、DropConnect 和早停(Early stopping)法等。

深度学习中常见的优化方法(from SGD to AMSGRAD)和正则化技巧 方宇SLAM学习之旅

要点:参数初始化:将参数初始化为高斯分布或者均匀分布,Xavier初始化。BN的位置一般是在卷积之后,激活函数之前,本质上BN有效的原因是因为规范化了输入,这样可以把各个层的尺度都统一起来,解决了梯度的问题。

神经网络与深度学习 复旦大学邱锡鹏的书,写得很好

要点:重点关注了一下RNN的LSTM原理和BPTT推导,还有几种attention机制。

A Comprehensive Guide to Understand and Implement Text Classification in Python 一些文本分类算法的代码,实现方法有Naive Bayes,Linear Classification,SVM,Bagging,Boosting,Shallow NN和LSTM,GRU等DNN。

深度学习中的trick

阅读数 4878

没有更多推荐了,返回首页