2018-02-23 14:01:37 github_37472200 阅读数 331
  • CTO讲堂:海量日志分析智能运维

    大数据分析正在被广泛应用,大数据里90%都是非结构化数据。日志是重要的非结构化数据,日志无处不在,所以能够从日志里面挖掘的价值非常高,可用于运维监控、安全审计、用户数据以及业务数据分析。那么,如何大限度发挥日志的价值成为业内人士研究思考多的问题之一。拥有19年IT经验的日志易创始人兼CEO陈军为大家分享当前海量日志分析的相关应用场景、技术难点以及趋势发展等。

    2527 人正在学习 去看看 CSDN讲师

深度学习日记

第一章:

有监督学习

 是指人们在获得训练的向量数据后在没有标签的情况下尝试找出其内部蕴含关系的一种挖掘工作,这个过程中使用者除了可能要设置一些必要的超参数(hyper-parameter)以外,不用对这些样本做任何的标记甚至是过程干预;

无监督学习

  每一个样本都有着明确的标签,最后我们只是要总结出这些训练样本向量与标签的映射关系

聚类(clustering)
  • 一种典型的“无监督学习”,是把物理对象或抽象对象的集合分组为由彼此类似的对象组成的多个类的分析过程。
    人类天生具备这种归纳和总结的能力,能够把认知的相似事物放到一起作为一类事物,它们之间可以有彼此的不同,但是有一个我们心里的“限度”,只要在这个限度内,特征稍有区别并无大碍,它们仍然还是这一类事物。
  • 比较常用的聚类算法有K-Means、DBSCAN等几种,基本思路都是利用每个向量之间的“距离”——空间中的欧氏距离或者曼哈顿距离,从远近判断是否从属于同一类别

  在用机器做聚类学习的时候,我们每种算法都对应有相应的计算原则,可以把输入的各种看上去彼此“相近”的向量分在一个群组中。然后下一步,人们通常更有针对性地去研究每一组聚在一起的对象所拥有的共性以及那些远离各个群组的孤立点——这种孤立点研究在刑侦、特殊疾病排查等方面都有应用。在这个过程中,从获得到具体的样本向量,到得出聚类结果,人们是不用进行干预的,这就是“非监督”一词的由来。

回归


  • 线性回归

  • 所谓线性回归,就是在观察和归纳样本的过程中认为向量和最终的函数值呈现线性的关系。而后设计这种关系为:y=f(x)=wx+b
  • 非线性回归
  • 非线性回归类中,在机器学习领域应用最多的当属逻辑回归。它和线性回归都叫回归,但是逻辑回归看上去更像分类。我们先在回归这一节提一下这种回归的工作方式。与前面我们说的线性回归不同,在这种模型中观察者假设的前提是y只有两种值:一种是1,一种是0,或者说“是”或“否”的这种判断。

分类


  • 分类是机器学习中使用的最多的一大类算法,我们通常也喜欢把分类算法叫做“分类器”。这个说法其实也非常形象,在我们看来,这就是一个黑盒子,有个入口,有个出口。我们在入口丢进去一个“样本”,在出口期望得到一个分类的“标签”。

  • 第一,输入样本和分类标签。
  • 第二,建立映射假说的某个y=f(x)的模型。
  • 第三,求解出全局的损失函数Loss和待定系数w的映射关系,Loss=g(w)。
  • 第四,通过迭代优化逐步降低Loss,最终找到一个w能使召回率和精确率满足当前场景需要。注意,这里尤其指在验证数据集上的表现。

总结


  • 聚类:把多个多种不同对象的特征都抽取出来,获取一个限度(标准),把近似值的对象放进同一个群组,从获得到具体的样本向量,到得出聚类结果
  • 回归:个人感觉是聚类的延伸应用,线性回归是对聚类结果的校正,而非线性回归是对聚类结果在实际中的应用。
  • 分类:


  • KNN(最近邻算法)

  • 上面都是在网上根据关键字找的资料。
  • 第一章概念较强,但没有什么太难懂东西,如果有什么看不懂的,反复看上几遍,然后再想想
  • 不要给我赞,不要给我赞,不要给我赞,原因我就不说了。
  • 第二章:

    激励函数


    • Sigmoid函数
    • Tanh函数
    • ReLU函数
    • Linear函数
    • 神经网络
    • 深度神经网络

    • 反正我是看着目录看完本章节的

    第三章:


    • Python3.6可直接下载。exe文件直接安装
    • 安装python时记得选中PIP
    • 然后使用pip安装TensorFlow:pip install TensorFlow
    • Python编译器建议使用PyCharm 作为Android Studio的兄弟编译器有很多共同点,相信你很快就会上手

    以上是安装,还有作者推荐的:Anaconda 它集成了python的环境和通用包,就像以前es集成环境,但是该折腾还是得折腾

  • 多环境与集群支持
    + 首先,TensorFlow支持在PC的CPU环境、GPU环境甚至是安卓环境中运行。它不仅可以支持在单个计算单元(一颗CPU的多核心或一颗GPU的多核心)上进行运算,也支持一台机器上多个CPU或多个GPU上并行计算。可以在网络上的所有计算机都参与计算,但是如果计算量小的那就得不偿失了,因为数据传输也是需要时间的。
  • TensorBoard——看得见的训练
    + TensorFlow有一个比较友好的组件,它可以让工作人员在训练网络的过程中通过仪表盘看到网络目前的表现情况。
    + #启动: tensorboard –logdir=path/to/logs
  • TensorFlow Serving——模型
    + TensorFlow Serving系统非常适用于大规模运行能够基于真实情况的数据并会发生动态改变的多重模型。它能够实现:
    • 模型生命周期管理。
    • 使用多重算法进行试验。
    • GPU资源有效使用。
    • 如何选择好的框架
    • 从三个方面:性能、使用人数、支持的语言
    2017-08-07 13:33:27 qq_23947237 阅读数 553
    • CTO讲堂:海量日志分析智能运维

      大数据分析正在被广泛应用,大数据里90%都是非结构化数据。日志是重要的非结构化数据,日志无处不在,所以能够从日志里面挖掘的价值非常高,可用于运维监控、安全审计、用户数据以及业务数据分析。那么,如何大限度发挥日志的价值成为业内人士研究思考多的问题之一。拥有19年IT经验的日志易创始人兼CEO陈军为大家分享当前海量日志分析的相关应用场景、技术难点以及趋势发展等。

      2527 人正在学习 去看看 CSDN讲师

    暑期深度学习实训笔记


    本笔记包含深度学习的整体框架的summary:

    • 机器学习的大概流程
    • 得分函数
    • 损失函数
    • 寻参K近邻与交叉验证
    • 梯度下降
    • 神经网络的基本流程

    目录

    (一) 机器学习的大概流程

    • 数据收集数据,加定标签
    • 训练训练分类器,完成分类任务
    • 测评测试、评估当前分类器效果

    (二) 得分函数

    f(xw)=f(x,w) = 每个类别的得分值。

    • x:输入
    • w:参数

    score function such as f(xw)=wx+bf(x,w)=w*x+b

    • 输入高维向量经过得分函数得到一个对应于每个类别的得分数值,分数越高则代表属于该类别的概率越大。

    • 一组得分值可经过e指数放大差别,再归一化得到一个[0,1]的概率值;也可以通过s型神经元σ函数映射到[0,1]。

    (三) 损失函数

    得分函数的分类效果好坏需要有损失函数来评估调整。得分函数分类得分的结果是由score function的 w 参数决定的,输入的 x 通过合理的 w 得到的得分才能更接近于正确的分类。

    Loss function的值越大代表分类效果越差,越小越好,为0是理想状态。在softmax分类器中概率越接近于0,loss值越大;概率接近于1,loss值越小。

    loss


    • softmax函数:一组得分值可经过e指数放大差别,再归一化得到一组[0,1]的概率值。

    soft max


    (四) 寻参的K近邻与交叉验证

    (一) K近邻(KNN)分类算法,简单的机器学习算法之一。

    knn

    (1) k值参数不同,分类结果不同。若K=3,由于红点所占比例为2/3,绿点将被赋予红色类,若K=5,由于蓝点比例为3/5,因此绿点被赋予蓝色类。

    (2) 给定一个训练数据集:对新的输入实例,在数据集中找到与该实例最邻近的k个实例,若这k个实例中大多数属于某个类,则把输入实例分为这个类。

    (3) 算法中,当训练集、距离度量、k值和分类决策规则确定后,对于任何一个新的输入实例,它所属的类唯一确定。例如图像处理对动物的分类中,取L1度量,得到度量值取前10个(k=10),根据10个当中的标签类别比例,来得出分类结果。

    交叉

    (二) 数据可分为traintest,数据量并不大很宝贵。充分利用数据可采用交叉验证

    (1) 将数据分为train、validation、test。做法为:假设5重交叉验证,将训练集分为5份,选择其中4份作为train,另一份作为val,train经过5次同时也val经过5次,将5次的平均作为该参数下的val结果。

    **t {1/2/3/4} --------- v {5}**
    **t {1/2/3/5} --------- v {4}**
    **t {1/2/4/5} --------- v {3}**
    **t {1/3/4/5} --------- v {2}**
    **t {2/3/4/5} --------- v {1}**

    (2) 然后对于不同的参数,重复这样的训练。选择准确率最高的参数作为最后的参数。在训练过程中不test,最终才test。

    (五) 梯度下降

    • 优化loss function,达到最优。
    • 跟随梯度去寻找山坡的最低点,梯度是山坡的一个最陡峭的方向,我们沿着这个最陡峭的方向可以最快的走到山坡的最低点。
    • 沿着梯度的反方向去走,这就是梯度下降。由于梯度方向是使得LOSS值增加幅度最大的方向,所以为了LOSS能减少就要朝着梯度下降的方向去寻找最小点。
    • 多次迭代梯度下降更新参数以致收敛,一次沿着这个梯度下降的方向走多远叫做学习率。学习率对最优化问题起着决定性的作用,因为如果学习率太大有可能有跳过最低点才寻到的不是最小值,而学习率太小又会使得网络收敛太慢。

    (六) 神经网络的基本流程

    神经网络

    • 1、前向传播

    • 得分 → lossloss → 正则化惩罚 → LOSSLOSS

    • 正则化就是对权重参数进行惩罚,目的就是找到一组更平滑的参数项。正则化项的结果就是对于不同权重参数 WW 进行不同力度的惩罚惩罚也就是增加其 LOSSLOSS。正则化对于整个分类模型来说非常重要,可以很有效的抑制了过拟合现象。

    • LOSSLOSS:即损失函数的最终版公式。LOSSLOSS由两部分组成的,一部分是得分函数对应的 lossloss;另一部分是正则化惩罚项值

    公式

    • 参考网址:http://blog.csdn.net/tangyudi/article/details/52090167

    • 正则化,防止过拟合。λ在这里我们称做正则化参数。若λ变大说明目标函数的作用变小,正则化项的作用变大,对参数的限制能力加强,这会使得参数的变化不那么剧烈,减少代价函数对特定参数的敏感性。参数代入正则化后的代价函数,代价值比未正则化时少了。例如2个维度的参数是10和1000,相差990,都乘以1/2变成5和500,相差495。

    • 2、反向传播

    • 对于X,Y,Z若干个输入来说分别对于LOSS值做了多大的贡献,链式求导法则

    • 加法门 : 均分

    • 乘法门 : 互换

    • MAX门 : 取最大

    • 3、更新参数

    1.非线性的函数:激活函数。**σ函数在某些位置斜率接近于0,在反向传播链式求导过程中梯度为0,难以更新。**因此,用MAX函数代替。

    drop

    2.drop-out防止过拟合。Dropout的出现很好的可以解决这个问题,每次做完dropout,相当于从原始的网络中找到一个更瘦的网络,让某些指定的神经元不参与计算和更新。让某个神经元的激活值以一定的概率p,让其停止工作。 test用全部神经元,训练只用部分。不工作的那些节点可以暂时认为不是网络结构的一部分,但是它的权重需要保留仅仅只是暂时不更新而已,因为下次样本输入时它可能又要工作了。
    3.权重初始化不可以全部设置为0,因为这样会导致各项参数会沿着相同的方向更新。

    (七) 结尾

    深度学习的基础为神经网络,基本上它的框架理清了。
    2017.8.7

    2019-11-26 19:33:09 qq_41132565 阅读数 12
    • CTO讲堂:海量日志分析智能运维

      大数据分析正在被广泛应用,大数据里90%都是非结构化数据。日志是重要的非结构化数据,日志无处不在,所以能够从日志里面挖掘的价值非常高,可用于运维监控、安全审计、用户数据以及业务数据分析。那么,如何大限度发挥日志的价值成为业内人士研究思考多的问题之一。拥有19年IT经验的日志易创始人兼CEO陈军为大家分享当前海量日志分析的相关应用场景、技术难点以及趋势发展等。

      2527 人正在学习 去看看 CSDN讲师

    吴恩达 神经网络和深度学习 第二周

    一些在看视频和做课后题过程中学到的用通俗的语言记下来怕自己忘

    np.random.rand() 生成的数据是零到一之间
    np.random.randn() 生成的数据是从标准正态分布中随机取的
    np.exp(x) e的x次幂
    np.array() 生成数组,shape自己定,数据自己填;并且array生成的数组可以被依次执行操作,比如依次求幂,

    import numpy as np
    a = np.array([1,2,3])
    x = np.exp(a)
    print(x)
    ----------------------------------------------
    [ 2.71828183  7.3890561  20.08553692]
    

    全都加上某个数,

    import numpy as np
    a = np.array([3,4,5])
    print(a+10)
    ----------------------------------------------
    [13 14 15]
    

    如果有一向量v的shape是(a,b,c),要把v reshape成(a*b,c),应该这样写

    import numpy as np
    v = np.ones(2,3,4)
    print(v)
    v = v.reshape((v.shape[0]*v.shape[1],v.shape[2])) 
    ##v.shape读取维数  v.shape[0]=a  v.shape[1]=b v.shape[2]=c
    print(v)
    ----------------------------------------------
    [[[1. 1. 1. 1.]
      [1. 1. 1. 1.]
      [1. 1. 1. 1.]]
    
     [[1. 1. 1. 1.]
      [1. 1. 1. 1.]
      [1. 1. 1. 1.]]]
    [[1. 1. 1. 1.]
     [1. 1. 1. 1.]
     [1. 1. 1. 1.]
     [1. 1. 1. 1.]
     [1. 1. 1. 1.]
     [1. 1. 1. 1.]]
    

    np.linalg.norm(x, ord=None, axis=None, keepdims=False) 对矩阵里的数据求范数(数据归一化用得到), x表示要被操作的矩阵,引用一张图,axis为0的时候求竖着的,为1的时候求横着的,keepdims设置成True保持形状,False还没试

    ————————————————
    版权声明:本文为CSDN博主「IIYMGF」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/hqh131360239/article/details/79061535
    在这里插入图片描述

    A.sum(axis=0) 列求和,axis=1行求和

    import numpy as np
    v = np.ones((3,8))
    print(v)
    a = v.sum(axis=0)
    b = v.sum(axis=1)
    
    print(a)
    
    print(b)
    ---------------------------------------
    [[1. 1. 1. 1. 1. 1. 1. 1.]
     [1. 1. 1. 1. 1. 1. 1. 1.]
     [1. 1. 1. 1. 1. 1. 1. 1.]]
    [3. 3. 3. 3. 3. 3. 3. 3.]
    [8. 8. 8.]
    

    本人所写都是为了给自己查阅,用词不准确只求自己能看懂回忆起来,有错误欢迎指出我会尽快更正。

    2019-12-31 20:26:23 sz3321 阅读数 6
    • CTO讲堂:海量日志分析智能运维

      大数据分析正在被广泛应用,大数据里90%都是非结构化数据。日志是重要的非结构化数据,日志无处不在,所以能够从日志里面挖掘的价值非常高,可用于运维监控、安全审计、用户数据以及业务数据分析。那么,如何大限度发挥日志的价值成为业内人士研究思考多的问题之一。拥有19年IT经验的日志易创始人兼CEO陈军为大家分享当前海量日志分析的相关应用场景、技术难点以及趋势发展等。

      2527 人正在学习 去看看 CSDN讲师

    1 数据流

    根据任务需要读取数据
    包括:(原始数据-可以输入模型的数据)
    数据的组织形式: one task需要的数据形式
    数据内容: 需要什么样的预处理 如:归一,数据增强等

    数据输入模型前需要部署到cuda上

    Variable(samples).cuda(GPU)
    

    2 模型

    定义模型

    将模型定义在一个类中
    通常有init(模型初始化)forward(执行模型–前向传播)方法
    该类继承nn.Module,可以调用nn.module中的属性或方法

    class RelationNetwork(nn.Module):
        def __init__(self,input_size,hidden_size):
            super(RelationNetwork, self).__init__()
            self.layer1 = nn.Sequential(
                            nn.Conv2d(128,64,kernel_size=3,padding=0),
                            nn.BatchNorm2d(64, momentum=1, affine=True),
                            nn.ReLU(),
                            nn.MaxPool2d(2))
            self.layer2 = nn.Sequential(
                            nn.Conv2d(64,64,kernel_size=3,padding=0),
                            nn.BatchNorm2d(64, momentum=1, affine=True),
                            nn.ReLU(),
                            nn.MaxPool2d(2))
            self.fc1 = nn.Linear(input_size*3*3,hidden_size)
            self.fc2 = nn.Linear(hidden_size,1)
    
        def forward(self,x):
            out = self.layer1(x)
            out = self.layer2(out)
            out = out.view(out.size(0),-1)
            out = F.relu(self.fc1(out))
            out = F.sigmoid(self.fc2(out))
            return out
    

    初始化模型

    创建模型类实例,会自动调用init方法,进行模型初始化

    relation_network = RelationNetwork(FEATURE_DIM,RELATION_DIM)
    

    打印模型

    print(relation_network)
    

    权值初始化(可选)

    自定义初始化

    feature_encoder.apply(weights_init)
    

    加载预训练

        if os.path.exists(str("./models/miniimagenet_relation_network_"+ str(CLASS_NUM) +"way_" + str(SAMPLE_NUM_PER_CLASS) +"shot.pkl")):
            relation_network.load_state_dict(torch.load(str("./models/miniimagenet_relation_network_"+ str(CLASS_NUM) +"way_" + str(SAMPLE_NUM_PER_CLASS) +"shot.pkl")))
            print("load relation network success")
    

    部署到cuda

    relation_network.cuda(GPU)
    

    执行模型–前向传播

    relations = relation_network(relation_pairs)
    

    模型设置为训练模式

    feature_encoder.zero_grad()
    

    模型设置为测试模式

    存储模型

    torch.save(relation_network.state_dict(),str("./models/miniimagenet_relation_att_network_"+ str(CLASS_NUM) +"way_" + str(SAMPLE_NUM_PER_CLASS) +"shot_"+str(episode)+".pkl"))
    

    3 优化

    定义优化器

    relation_network_optim = torch.optim.Adam(relation_network.parameters(),lr=LEARNING_RATE)
    

    学习率时刻表

    relation_network_scheduler = StepLR(relation_network_optim,step_size=100000,gamma=0.5)
    

    执行优化器(时刻表)

    feature_encoder_scheduler.step(episode)

    计算损失

    mse = nn.MSELoss().cuda(GPU)
    
    loss = mse(relations,one_hot_labels)
    

    反向传播

    loss.backward()
    

    梯度截断

    torch.nn.utils.clip_grad_norm(relation_network.parameters(),0.5)
    

    执行优化

    relation_network_optim.step()
    

    4 损失

    5 日志

    ========

    通用代码积累

    常见数据预处理

    复杂模型

    优化器

    学习率调整

    自定义的参数优化设置

    权值加载与存储

    ========

    自己的框架

    数据流模块

    调用某个方法可得到可以输入模型的数据

    模型定义模块

    创建模型实例等于创建模型,调用forward方法等于执行模型

    模型初始化模块

    损失模块

    *run模块

    调用方法得到可以输入模型的数据–用数据流模块

    • 数据部署到cuda

    创建模型实例–用模型定义模块

    模型初始化–用模型初始化模块

    模型部署到cuda

    定义优化器

    定义优化器时刻表

    执行优化器(时刻表)

    执行模型–前向传播

    模型设置为训练模式

    计算损失

    反向传播

    执行优化

    设置模型为测试模式

    计算准确率

    输出日志

    存储模型

    2018-03-08 20:19:28 qq_33837704 阅读数 284
    • CTO讲堂:海量日志分析智能运维

      大数据分析正在被广泛应用,大数据里90%都是非结构化数据。日志是重要的非结构化数据,日志无处不在,所以能够从日志里面挖掘的价值非常高,可用于运维监控、安全审计、用户数据以及业务数据分析。那么,如何大限度发挥日志的价值成为业内人士研究思考多的问题之一。拥有19年IT经验的日志易创始人兼CEO陈军为大家分享当前海量日志分析的相关应用场景、技术难点以及趋势发展等。

      2527 人正在学习 去看看 CSDN讲师

    本文是基于Tensorflow的手写数字识别的项目最终篇,最终准确率为99.2%

    这样截止到3/8,终于算是入门了一个深度学习项目-《基于Tensorflow的手写数字识别》

    网络模型3层卷积,区别在于每次卷积后面加上了规范层:

    该层在每个batch上将前一层的激活值重新规范化,即使得其输出数据的均值接近0,其标准差接近1

    (1)加速收敛 (2)控制过拟合,可以少用或不用Dropout和正则 (3)降低网络对初始化权重不敏感 (4)允许使用较大的学习率

    首先记录一下我写代码遇到的坑:

    按照教程写代码报错:

    ValueError: Dimension (-1) must be in the range [0, 2), where 2 is the number of dimensions in the input. for 'metrics/categorical_accuracy/ArgMax' (op: 'ArgMax') with input shapes: [?,?], [].

    后来才知道是这里的问题:

    cnn_net.compile(loss='categorical_crossentropy',optimizer='adam',metrics=[metrics.categorical_accuracy])

    把后面的metrics参数去掉就可以了(至于原因目前我也不太清楚):

    cnn_net.compile(loss='categorical_crossentropy',optimizer='adam')

    运行如下:

    64/33600 [..............................] - ETA: 48:49 - loss: 2.6620
      128/33600 [..............................] - ETA: 30:09 - loss: 3.2769
      192/33600 [..............................] - ETA: 22:57 - loss: 3.5317
      256/33600 [..............................] - ETA: 18:53 - loss: 3.2478
      320/33600 [..............................] - ETA: 16:16 - loss: 2.9932
      384/33600 [..............................] - ETA: 14:24 - loss: 2.7520
      448/33600 [..............................] - ETA: 12:57 - loss: 2.5195
      512/33600 [..............................] - ETA: 11:55 - loss: 2.4143
      576/33600 [..............................] - ETA: 11:02 - loss: 2.2881

    完整代码如下:

    import numpy as np
    import tensorflow as tf
    import pandas as pd
    from keras.models import Sequential
    from keras.layers import Dense,Activation,Conv2D
    from keras.layers import MaxPool2D,Flatten,Dropout,ZeroPadding2D,BatchNormalization
    from keras.utils import np_utils
    from keras import metrics
    import keras
    from keras.models import save_model,load_model
    from keras.models import Model
    
    df=pd.read_csv("train.csv")
    #data由dataframe类型转换为矩阵类型
    data=df.as_matrix()
    df=None
    # shuffle() 方法将序列的所有元素随机排序
    np.random.shuffle(data)
    x_train=data[:,1:]
    x_train=x_train.reshape(data.shape[0],28,28,1).astype("float32")
    x_train=x_train/255.0
    
    #把训练的图片类型进行onehot编码
    #将类别向量(从0到nb_classes的整数向量)映射为二值类别矩阵, 用于应用到以categorical_crossentropy为目标函数的模型中.
    y_train=np_utils.to_categorical(data[:,0],10).astype("float32")
    
    x_train_test=np.random.random((10,28,28,1))
    y_train_test=keras.utils.to_categorical(np.random.randint(10,size=(10,1)),num_classes=10)
    print(x_train.shape)
    print(y_train.shape)
    #设置相关参数
    batch_size=64
    n_filters=32
    pool_size=(2,2)
    #d定义网络
    cnn_net=Sequential()
    cnn_net.add(Conv2D(32,kernel_size=(3,3),strides=(1,1),input_shape=(28,28,1)))
    cnn_net.add(Activation('relu'))
    #第0轴沿着行的垂直往下,第1轴沿着列的方向水平延伸。
    #该层在每个batch上将前一层的激活值重新规范化,即使得其输出数据的均值接近0,其标准差接近1
    cnn_net.add(BatchNormalization(epsilon=1e-6,axis=1))
    cnn_net.add(MaxPool2D(pool_size=pool_size))
    
    #对2D输入(如图片)的边界填充0,以控制卷积以后特征图的大小
    cnn_net.add(ZeroPadding2D((1,1)))
    cnn_net.add(Conv2D(48,kernel_size=(3,3)))
    cnn_net.add(Activation('relu'))
    #第0轴沿着行的垂直往下,第1轴沿着列的方向水平延伸。
    #该层在每个batch上将前一层的激活值重新规范化,即使得其输出数据的均值接近0,其标准差接近1
    cnn_net.add(BatchNormalization(epsilon=1e-6,axis=1))
    cnn_net.add(MaxPool2D(pool_size=pool_size))
    
    #对2D输入(如图片)的边界填充0,以控制卷积以后特征图的大小
    cnn_net.add(ZeroPadding2D((1,1)))
    cnn_net.add(Conv2D(64,kernel_size=(2,2)))
    cnn_net.add(Activation('relu'))
    #第0轴沿着行的垂直往下,第1轴沿着列的方向水平延伸。
    #该层在每个batch上将前一层的激活值重新规范化,即使得其输出数据的均值接近0,其标准差接近1
    cnn_net.add(BatchNormalization(epsilon=1e-6,axis=1))
    cnn_net.add(MaxPool2D(pool_size=pool_size))
    
    cnn_net.add(Dropout(0.25))
    #Flatten层用来将输入“压平”,即把多维的输入一维化,常用在从卷积层到全连接层的过渡。
    cnn_net.add(Flatten())
    
    cnn_net.add(Dense(3168))
    cnn_net.add(Activation('relu'))
    
    cnn_net.add(Dense(10))
    cnn_net.add(Activation('softmax'))
    #summary查看网络结构
    cnn_net.summary()
    cnn_net.compile(loss='categorical_crossentropy',optimizer='adam')
    #训练模型
    #validation_split:0~1之间的浮点数,用来指定训练集的一定比例数据作为验证集。验证集将不参与训练,并在每个epoch结束后测试的模型的指标,如损失函数、精确度等
    cnn_net.fit(x_train,y_train,batch_size=batch_size,epochs=50,verbose=1,validation_split=0.2)
    
    

    总之,通过keras框架,确实使得深度学习变得非常简单,比tensorflow要简单不少。

    学习日志

    阅读数 45

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