keras 订阅
Keras是一个由Python编写的开源人工神经网络库,可以作为Tensorflow、Microsoft-CNTK和Theano的高阶应用程序接口,进行深度学习模型的设计、调试、评估、应用和可视化 [1]  。Keras在代码结构上由面向对象方法编写,完全模块化并具有可扩展性,其运行机制和说明文档有将用户体验和使用难度纳入考虑,并试图简化复杂算法的实现难度 [1]  。Keras支持现代人工智能领域的主流算法,包括前馈结构和递归结构的神经网络,也可以通过封装参与构建统计学习模型 [2]  。在硬件和开发环境方面,Keras支持多操作系统下的多GPU并行计算,可以根据后台设置转化为Tensorflow、Microsoft-CNTK等系统下的组件 [3]  。Keras的主要开发者是谷歌工程师François Chollet,此外其GitHub项目页面包含6名主要维护者和超过800名直接贡献者 [4]  。Keras在其正式版本公开后,除部分预编译模型外,按MIT许可证开放源代码 [1]  。 展开全文
Keras是一个由Python编写的开源人工神经网络库,可以作为Tensorflow、Microsoft-CNTK和Theano的高阶应用程序接口,进行深度学习模型的设计、调试、评估、应用和可视化 [1]  。Keras在代码结构上由面向对象方法编写,完全模块化并具有可扩展性,其运行机制和说明文档有将用户体验和使用难度纳入考虑,并试图简化复杂算法的实现难度 [1]  。Keras支持现代人工智能领域的主流算法,包括前馈结构和递归结构的神经网络,也可以通过封装参与构建统计学习模型 [2]  。在硬件和开发环境方面,Keras支持多操作系统下的多GPU并行计算,可以根据后台设置转化为Tensorflow、Microsoft-CNTK等系统下的组件 [3]  。Keras的主要开发者是谷歌工程师François Chollet,此外其GitHub项目页面包含6名主要维护者和超过800名直接贡献者 [4]  。Keras在其正式版本公开后,除部分预编译模型外,按MIT许可证开放源代码 [1]  。
信息
开发者
François Chollet 等 [4]
类    型
神经网络库,应用程序接口
平    台
Linux,macOS,Windows
许可协议
MIT License(不包含预编译模型)
初始版本
0.1.0/2015年6月13日 [5]
外文名
Keras
编程语言
Python
稳定版本
2.3.0/2019年09月17日 [5]
Keras历史与命名
Keras的前身是François Chollet为ONEIROS(Open-ended Neuro-Electronic Intelligent Robot Operating System)项目所的编写的代码,在2015年分离成为开源的人工神经网络工具。Keras的最初版本以Theano为后台,设计理念参考了Torch但完全由Python编写 [5]  。2015年11月的Keras测试版本0.3.0,Tensorflow被加入了后台选项。2016年4月,Keras在PIPy上发布了第一个稳定版本1.0.0 [5]  。2017年5月,Keras版本2.0.0发布 [5]  。同年6月,Keras版本2.0.5测试性地将Microsoft-CNTK加入后台选项 [5]  。自2017年起,Keras得到了Tensorflow团队的支持,其大部分组件被整合至Tensorflow的Python API中。在2018年Tensorflow 2.0.0公开后,Keras被正式确立为Tensorflow高阶API,即tf.keras [6]  。此外自2017年7月开始,Keras也得到了CNTK 2.0的后台支持 [7]  。在2019年9月17日Keras稳定版本2.3.0的更新文档中,Keras团队宣布了计划调整:在该版本之后,Keras将集中于Tensoflow后台的有关内容,多后台Keras的开发优先度被降低,且更新将仅包含补丁(bug fix),不会有新的功能性内容移植/加入 [5]  。Keras的命名来自古希腊语“κέρας (牛角)”或 “κραίνω(实现)”,意为将梦境化为现实的“牛角之门” [1]  。由荷马史诗《奥德赛》第19卷佩涅罗佩与奥德修斯的对话,无法挽留的梦幻拥有两座门,一座门由牛角制成,一座门由象牙制成,象牙之门内光彩夺目,却仅是无法实现的梦境;唯有走进牛角之门,才能由梦境看见真实 [8]  。
收起全文
精华内容
下载资源
问答
  • Keras

    千次阅读 2018-07-23 08:45:03
    Keras是由纯python编写的基于theano/tensorflow的深度学习框架。Keras是一个高层神经网络API,支持快速实验,能够把你的idea迅速转换为结果,如果有如下需求,可以优先选择Keras: a)简易和快速的原型设计(keras...

    Keras是由纯python编写的基于theano/tensorflow的深度学习框架。Keras是一个高层神经网络API,支持快速实验,能够把你的idea迅速转换为结果,如果有如下需求,可以优先选择Keras:

    a)简易和快速的原型设计(keras具有高度模块化,极简,和可扩充特性)

    b)支持CNN和RNN,或二者的结合

    c)无缝CPU和GPU切换

    Keras模块结构:

    使用Keras搭建一个神经网络:

    【【【一些概念:

              (1)目前主要有两种方式来表示张量: a) th模式或channels_first模式,Theano和caffe使用此模式。b)tf模式或channels_last模式,TensorFlow使用此模式。

                例:对于100张RGB3通道的16×32(高为16宽为32)彩色图,th表示方式:(100,3,16,32);tf表示方式:(100,16,32,3)。唯一的区别就是表示通道个数3的位置不一样。

              (2)Keras有两种类型的模型,序贯模型(Sequential)和函数式模型(Model),函数式模型应用更为广泛,序贯模型是函数式模型的一种特殊情况。 a)序贯模型(Sequential):单输入单输出,一条路通到底,层与层之间只有相邻关系,没有跨层连接。这种模型编译速度快,操作也比较简单  b)函数式模型(Model):多输入多输出,层与层之间任意连接。这种模型编译速度慢。

            (3)neural layers(神经层), cost functions(损失函数), optimizers(优化器), initialization schemes(初始化方案), activation functions(激活函数), regularization(正则化项)在keras中都是独立的模块,可以自由组合。】】】

                

    以上内容来自:https://blog.csdn.net/zdy0_2004/article/details/74736656

    模型快速教程,可以看:http://keras-cn.readthedocs.io/en/latest/getting_started/sequential_model/

    一个keras model的例子(函数式模型):

    def model(input_shape):
        # Define the input placeholder as a tensor with shape input_shape. Think of this as your input image!
        X_input = Input(input_shape)
    
        # Zero-Padding: pads the border of X_input with zeroes
        X = ZeroPadding2D((3, 3))(X_input)
    
        # CONV -> BN -> RELU Block applied to X
        X = Conv2D(32, (7, 7), strides=(1, 1), name='conv0')(X)
        X = BatchNormalization(axis=3, name='bn0')(X)
        X = Activation('relu')(X)
    
        # MAXPOOL
        X = MaxPooling2D((2, 2), name='max_pool')(X)
    
        # FLATTEN X (means convert it to a vector) + FULLYCONNECTED
        X = Flatten()(X)
        X = Dense(1, activation='sigmoid', name='fc')(X)
    
        # Create model. This creates your Keras model instance, you'll use this instance to train/test the model.
        model = Model(inputs=X_input, outputs=X, name='HappyModel')
    
        return model
    

    一个keras model的实例:

    # number of training examples = 600
    # number of test examples = 150
    # X_train shape: (600, 64, 64, 3)
    # Y_train shape: (600, 1)
    # X_test shape: (150, 64, 64, 3)
    # Y_test shape: (150, 1)
    X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()
    
    # Normalize image vectors,像素值为最大255
    X_train = X_train_orig / 255.
    X_test = X_test_orig / 255.
    
    # Reshape, transfer row to column
    Y_train = Y_train_orig.T
    Y_test = Y_test_orig.T
    
    def HappyModel(input_shape):
        """
        Implementation of the HappyModel.
    
        Arguments:
        input_shape -- shape of the images of the dataset
    
        Returns:
        model -- a Model() instance in Keras
        """
    
        ### START CODE HERE ###
        # Feel free to use the suggested outline in the text above to get started, and run through the whole
        # exercise (including the later portions of this notebook) once. The come back also try out other
        # network architectures as well.
    
        # Define the input placeholder as a tensor with shape input_shape. Think of this as your input image!
        X_input = Input(input_shape)
    
        # Zero-Padding: pads the border of X_input with zeroes
        # 一种函数嵌套的形式
        X = ZeroPadding2D((3, 3))(X_input)
    
        # CONV -> BN -> RELU Block applied to X
        # 第一个参数为filters个数
        X = Conv2D(32, (7, 7), strides=(1, 1), name='conv0')(X)
    
        # axis: 整数,指定要规范化的轴,通常为特征轴。例如在进行data_format="channels_first的2D卷积后,一般会设axis=1
    
        X = BatchNormalization(axis=3, name='bn0')(X)
        X = Activation('relu')(X)
    
        # MAXPOOL
        X = MaxPooling2D((2, 2), name='max_pool')(X)
    
        # FLATTEN X (means convert it to a vector) + FULLYCONNECTED
        X = Flatten()(X)
        # Dense为全连接层
        X = Dense(1, activation='sigmoid', name='fc')(X)
    
        # Create model. This creates your Keras model instance, you'll use this instance to train/test the model.
        model = Model(inputs=X_input, outputs=X, name='HappyModel')
    
        ### END CODE HERE ###
    
        return model
    
    
    # mini-batch
    happyModel = HappyModel(X_train.shape[1:])
    happyModel.compile(optimizer="Adam", loss="binary_crossentropy", metrics=['accuracy'])
    happyModel.fit(x=X_train, y=Y_train, epochs=10, batch_size=32)
    
    preds = happyModel.evaluate(X_test, Y_test)
    print()
    print("Loss = " + str(preds[0]))
    print("Test Accuracy = " + str(preds[1]))

    1、类Dense,

     

    Keras.layers.core.Dense(output_dim, init='glorot_uniform', activation='linear', weights=None, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, input_dim=None)

    ouput_dim:int > 0,输出结果的维度

    init:初始化权值的函数名称或Theano function。可以使用Keras内置的,也可以传递自己编写的Theano function。如果不给weights传递参数时,则该参数必须指明。

    activation:激活函数名称或者Theano function。可以使用Keras内置的,也可以是传递自己编写的Theano function。如果不明确指定,那么将没有激活函数会被应用。

    weights:用于初始化权值的numpy arrays组成的list。这个List至少有1个元素,其shape为(input_dim, output_dim)。(如果指定init了,那么weights可以赋值None)
    2、

    3、为什么有的Keras函数后两个()??

    Dense等类都是基于Layer类的,参考class Dense(Layer),因此我们可以看看Layer这个类怎么写的。在Layer这个类里面,有这样一个函数:def __call__(self, inputs, **kwargs);这个函数可以在python的文档中查到,通过定义这个函数,我们可以让一个对象当作函数使用。因此我们可以把下面代码拆分成这样:

    X = Dense(64, activation='relu')(X)
    # 拆分
    fc = Dense(64, activation='relu')
    X = fc(X)

    或者说:Dense(64, avtivation='relu')执行__init__函数用于初始化得到一个类,然后调用对执行类的__call__函数,X=Dense(64, activation='relu')(inputs),然后得到输出。
    4、BatchNormalization():https://keras-cn.readthedocs.io/en/latest/layers/normalization_layer/

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

    (1)、在什么地方来进行BN:BN可以应用于网络中任意的activation set。特别指出在CNN中,BN应作用在非线性映射前,即对x=Wu+b做规范化。

    2)、为什么用BN?克服深度神经网络难以训练的弊病,为了防止“梯度弥散”。关于梯度弥散,大家都知道一个简单的栗子:0.9^{30}\approx 0.04在BN中,是通过将activation规范为均值和方差一致的手段使得原本会减小的activation的scale变大。总结起来就是BN解决了反向传播过程中的梯度问题(梯度消失和爆炸),同时使得不同scale的 w 整体更新步调更一致

    (4)、什么时候使用BN?OK,说完BN的优势,自然可以知道什么时候用BN比较好。例如,在神经网络训练时遇到收敛速度很慢,或梯度爆炸等无法训练的状况时可以尝试BN来解决。另外,在一般使用情况下也可以加入BN来加快训练速度,提高模型精度。

     

     

     

     

     

     

    展开全文
  • keras

    万次阅读 多人点赞 2016-07-31 00:15:36
    Keras简介 Keras是基于Theano的一个深度学习框架,它的设计参考了Torch,用Python语言编写,是一个高度模块化的神经网络库,支持GPU和CPU。使用文档在这:http://keras.io/,这个框架貌似是刚刚火起来的,使用上的...

    大神笔记,转载自http://blog.csdn.net/u012162613/article/details/45397033

    1. Keras简介

    Keras是基于Theano的一个深度学习框架,它的设计参考了Torch,用Python语言编写,是一个高度模块化的神经网络库,支持GPU和CPU。使用文档在这:http://keras.io/,这个框架貌似是刚刚火起来的,使用上的问题可以到github提issue:https://github.com/fchollet/keras 

    下面简单介绍一下怎么使用Keras,以Mnist数据库为例,编写一个CNN网络结构,你将会发现特别简单。

    1. Keras里的模块介绍

    Optimizers

    顾名思义,Optimizers包含了一些优化的方法,比如最基本的随机梯度下降SGD,另外还有Adagrad、Adadelta、RMSprop、Adam,一些新的方法以后也会被不断添加进来

    上面的代码是SGD的使用方法,lr表示学习速率,momentum表示动量项,decay是学习速率的衰减系数(每个epoch衰减一次),Nesterov的值是False或者True,表示使不使用Nesterov momentum。其他的请参考文档。

    Objectives

    这是目标函数模块,keras提供了mean_squared_error,mean_absolute_error
    ,squared_hinge,hinge,binary_crossentropy,categorical_crossentropy这几种目标函数。

    这里binary_crossentropy 和 categorical_crossentropy也就是常说的logloss.

    Activations

    这是激活函数模块,keras提供了linear、sigmoid、hard_sigmoid、tanh、softplus、relu、softplus,另外softmax也放在Activations模块里(我觉得放在layers模块里更合理些)。此外,像LeakyReLU和PReLU这种比较新的激活函数,keras在keras.layers.advanced_activations模块里提供。

    Initializations

    这是参数初始化模块,在添加layer的时候调用init进行初始化。keras提供了uniform、lecun_uniform、normal、orthogonal、zero、glorot_normal、he_normal这几种。

    layers

    layers模块包含了core、convolutional、recurrent、advanced_activations、normalization、embeddings这几种layer。

    其中core里面包含了flatten(CNN的全连接层之前需要把二维特征图flatten成为一维的)、reshape(CNN输入时将一维的向量弄成二维的)、dense(就是隐藏层,dense是稠密的意思),还有其他的就不介绍了。convolutional层基本就是Theano的Convolution2D的封装。

    Preprocessing

    这是预处理模块,包括序列数据的处理,文本数据的处理,图像数据的处理。重点看一下图像数据的处理,keras提供了ImageDataGenerator函数,实现data augmentation,数据集扩增,对图像做一些弹性变换,比如水平翻转,垂直翻转,旋转等。

    Models

    这是最主要的模块,模型。上面定义了各种基本组件,model是将它们组合起来,下面通过一个实例来说明。

    3.一个实例:用CNN分类Mnist

    数据下载

    Mnist数据在其官网上有提供,但是不是图像格式的,因为我们通常都是直接处理图像,为了以后程序能复用,我把它弄成图像格式的,这里可以下载:http://pan.baidu.com/s/1qCdS6,共有42000张图片。

    读取图片数据

    keras要求输入的数据格式是numpy.array类型(numpy是一个python的数值计算的库),所以需要写一个脚本来读入mnist图像,保存为一个四维的data,还有一个一维的label,代码:

    #coding:utf-8
    
    import os
    from PIL import Image
    import numpy as np
    
    #读取文件夹mnist下的42000张图片,图片为灰度图,所以为1通道,
    #如果是将彩色图作为输入,则将1替换为3,并且data[i,:,:,:] = arr改为data[i,:,:,:] = [arr[:,:,0],arr[:,:,1],arr[:,:,2]]
    def load_data():
        data = np.empty((42000,1,28,28),dtype="float32")
        label = np.empty((42000,),dtype="uint8")
    
        imgs = os.listdir("./mnist")
        num = len(imgs)
        for i in range(num):
            img = Image.open("./mnist/"+imgs[i])
            arr = np.asarray(img,dtype="float32")
            data[i,:,:,:] = arr
            label[i] = int(imgs[i].split('.')[0])
        return data,label

    构建CNN,训练

    短短二十多行代码,构建一个三个卷积层的CNN,直接读下面的代码吧,有注释,很容易读懂:

    #导入各种用到的模块组件
    from __future__ import absolute_import
    from __future__ import print_function
    from keras.preprocessing.image import ImageDataGenerator
    from keras.models import Sequential
    from keras.layers.core import Dense, Dropout, Activation, Flatten
    from keras.layers.advanced_activations import PReLU
    from keras.layers.convolutional import Convolution2D, MaxPooling2D
    from keras.optimizers import SGD, Adadelta, Adagrad
    from keras.utils import np_utils, generic_utils
    from six.moves import range
    from data import load_data
    
    #加载数据
    data, label = load_data()
    print(data.shape[0], ' samples')
    
    #label为0~9共10个类别,keras要求格式为binary class matrices,转化一下,直接调用keras提供的这个函数
    label = np_utils.to_categorical(label, 10)
    
    ###############
    #开始建立CNN模型
    ###############
    
    #生成一个model
    model = Sequential()
    
    #第一个卷积层,4个卷积核,每个卷积核大小5*5。1表示输入的图片的通道,灰度图为1通道。
    #border_mode可以是valid或者full,具体看这里说明:http://deeplearning.net/software/theano/library/tensor/nnet/conv.html#theano.tensor.nnet.conv.conv2d
    #激活函数用tanh
    #你还可以在model.add(Activation('tanh'))后加上dropout的技巧: model.add(Dropout(0.5))
    model.add(Convolution2D(4, 1, 5, 5, border_mode='valid')) 
    model.add(Activation('tanh'))
    
    #第二个卷积层,8个卷积核,每个卷积核大小3*3。4表示输入的特征图个数,等于上一层的卷积核个数
    #激活函数用tanh
    #采用maxpooling,poolsize为(2,2)
    model.add(Convolution2D(8,4, 3, 3, border_mode='valid'))
    model.add(Activation('tanh'))
    model.add(MaxPooling2D(poolsize=(2, 2)))
    
    #第三个卷积层,16个卷积核,每个卷积核大小3*3
    #激活函数用tanh
    #采用maxpooling,poolsize为(2,2)
    model.add(Convolution2D(16, 8, 3, 3, border_mode='valid')) 
    model.add(Activation('tanh'))
    model.add(MaxPooling2D(poolsize=(2, 2)))
    
    #全连接层,先将前一层输出的二维特征图flatten为一维的。
    #Dense就是隐藏层。16就是上一层输出的特征图个数。4是根据每个卷积层计算出来的:(28-5+1)得到24,(24-3+1)/2得到11,(11-3+1)/2得到4
    #全连接有128个神经元节点,初始化方式为normal
    model.add(Flatten())
    model.add(Dense(16*4*4, 128, init='normal'))
    model.add(Activation('tanh'))
    
    #Softmax分类,输出是10类别
    model.add(Dense(128, 10, init='normal'))
    model.add(Activation('softmax'))
    
    #############
    #开始训练模型
    ##############
    #使用SGD + momentum
    #model.compile里的参数loss就是损失函数(目标函数)
    sgd = SGD(l2=0.0,lr=0.05, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(loss='categorical_crossentropy', optimizer=sgd,class_mode="categorical")
    
    #调用fit方法,就是一个训练过程. 训练的epoch数设为10,batch_size为100.
    #数据经过随机打乱shuffle=True。verbose=1,训练过程中输出的信息,0、1、2三种方式都可以,无关紧要。show_accuracy=True,训练时每一个epoch都输出accuracy。
    #validation_split=0.2,将20%的数据作为验证集。
    model.fit(data, label, batch_size=100,nb_epoch=10,shuffle=True,verbose=1,show_accuracy=True,validation_split=0.2)
    

    代码使用与结果

    结果如下所示,在Epoch 9达到了0.98的训练集识别率和0.97的验证集识别率:

    这里写图片描述

    展开全文
  • keras:3)Embedding层详解

    万次阅读 多人点赞 2017-08-26 08:54:04
    详解Keras的Embedding层

    Embedding层

    keras.layers.embeddings.Embedding(input_dim, output_dim, embeddings_initializer='uniform', embeddings_regularizer=None, activity_regularizer=None, embeddings_constraint=None, mask_zero=False, input_length=None)
    

    嵌入层将正整数(下标)转换为具有固定大小的向量,如[[4],[20]]->[[0.25,0.1],[0.6,-0.2]]

    Embedding层只能作为模型的第一层

    参数

    input_dim:大或等于0的整数,字典长度,即输入数据最大下标+1
    output_dim:大于0的整数,代表全连接嵌入的维度
    embeddings_initializer: 嵌入矩阵的初始化方法,为预定义初始化方法名的字符串,或用于初始化权重的初始化器。参考initializers
    embeddings_regularizer: 嵌入矩阵的正则项,为Regularizer对象
    embeddings_constraint: 嵌入矩阵的约束项,为Constraints对象
    mask_zero:布尔值,确定是否将输入中的‘0’看作是应该被忽略的‘填充’(padding)值,该参数在使用递归层处理变长输入时有用。设置为True的话,模型中后续的层必须都支持masking,否则会抛出异常。如果该值为True,则下标0在字典中不可用,input_dim应设置为|vocabulary| + 2。
    input_length:当输入序列的长度固定时,该值为其长度。如果要在该层后接Flatten层,然后接Dense层,则必须指定该参数,否则Dense层的输出维度无法自动推断。
    输入shape
    形如(samples,sequence_length)的2D张量
    输出shape
    形如(samples, sequence_length, output_dim)的3D张量

    较为费劲的就是第一句话:
    嵌入层将正整数(下标)转换为具有固定大小的向量,如[[4],[20]]->[[0.25,0.1],[0.6,-0.2]]

    哪到底咋转换啊 ?
    这涉及到词向量,具体看可以参考这篇文章:Word2vec 之 Skip-Gram 模型,下面只进行简单描述
    这里写图片描述

    上图的流程是把文章的单词使用词向量来表示。
    (1)提取文章所有的单词,按其出现的次数降序(这里只取前50000个),比如单词‘network’出现次数最多,编号ID为0,依次类推。

    (2)每个编号ID都可以使用50000维的二进制(one-hot)表示

    (3)最后会生产一个矩阵M,行大小为词的数目50,000,列大小为词向量的维度(通常取128或300),比如矩阵的第一行就是编号ID=0,即单词‘network’对应的词向量。

    那这个矩阵M怎么获得呢?在Skip-Gram 模型中,通常会随机初始化它,然后使用神经网络来训练这个权重矩阵
    在这里插入图片描述

    那我们的输入数据和标签是什么?如下图所示,输入数据为中间的哪个蓝色的词对应的one-hot编码,标签就是它附近词的one-hot编码 (此处windown_size=2,左右各取2个)
    这里写图片描述

    就上述Word2Vec的例子而言,它的单词表大小为50,000,词向量的维度为300,所以Embedding的参数 input_dim=50,000,output_dim=300

    回到最初的问题:嵌入层将正整数(下标)转换为具有固定大小的向量,如[[4],[20]]->[[0.25,0.1],[0.6,-0.2]]

    举个栗子:假如单词表的大小为50,000,词向量维度为2,经单词频数统计后,tom对应的id=4,而jerry对应的id=20,经上述的转换后,我们会得到一个 M 50 , 000 × 2 M_{50,000\times2} M50,000×2的矩阵,而tom对应的是该矩阵的第4行,取出该行的数据就是[0.25,0.1]

    如果输入数据不需要词的语义特征语义,简单使用Embedding层就可以得到一个对应的词向量矩阵,但如果需要语义特征,我们大可把训练好的词向量权重直接扔到Embedding层中即可,具体看参考keras提供的栗子:在Keras模型中使用预训练的词向量

    展开全文
  • DL框架之Keras:深度学习框架Keras框架的简介、安装(Python库)、相关概念、Keras模型使用、使用方法之详细攻略 目录 Keras的简介 1、Keras的特点 2、Keras四大特性 3、Keras的用户体验 4、如果你有...

    DL框架之Keras:深度学习框架Keras框架的简介、安装(Python库)、相关概念、Keras模型使用、使用方法之详细攻略

     

     

     

     

    目录

    Keras的简介

    1、Keras的特点

    2、Keras四大特性

    3、Keras的用户体验

    4、如果你有如下需求,请选择Keras

    5、Keras支持多后端和多平台

    Keras的安装

    Keras的使用方法

    1、The Sequential Model 序列模型

    2、The functional API 函数式API

    3、Model subclassing 模型子类化

    其他概念

    1、shape

    2、回调

    3、保存和恢复

    4、动态图机制:Eager Execution

    Keras的中的模型使用

    1、查找使用方法

    2、Keras的 6 种预训练模型 

    3、Keras深度学习框架的注意事项(自动下载存放路径等)、使用方法之详细攻略


     

     

     

    相关文章
    DL框架之Keras:Python库之Keras库的简介、安装、使用方法详细攻略
    keras-yolo3:python库之keras-yolo3的简介、安装、使用方法详细攻略

    Keras的简介

         Keras是TensorFlow官方的高层API。Keras是一个高层神经网络API,并对TensorFlow等有较好的优化。,Keras由纯Python编写而成并基Tensorflow、Theano以及CNTK后端,也就是Keras基于什么东西来做运算。Keras 为支持快速实验而生,能够把你的idea迅速转换为结果。

    1、Keras的特点

    • tensorflow.keras(tf.keras) module
    • Part of core TensorFlow since v1.4
    • Full Keras API
    • 针对TF更好的优化
    • 与TF特别功能更好的整合,Estimator API、Eager execution

    2、Keras四大特性

    • 1、用户友好:Keras是为人类而非机器设计的API。用户的使用体验始终是我们考虑的首要和中心内容。Keras遵循减少认知困难的最佳实践:Keras提供一致而简洁的API, 能够极大减少一般应用下用户的工作量,同时,Keras提供清晰和具有实践意义的bug反馈。 
    • 2、模块性:模型可理解为一个层的序列或数据的运算图,完全可配置的模块可以用最少的代价自由组合在一起。具体而言,网络层、损失函数、优化器、初始化策略、激活函数、正则化方法都是独立的模块,你可以使用它们来构建自己的模型。 
    • 3、易扩展性:添加新模块超级容易,只需要仿照现有的模块编写新的类或函数即可。创建新模块的便利性使得Keras更适合于先进的研究工作。 
    • 4、与Python协作:Keras没有单独的模型配置文件类型(作为对比,caffe有),模型由python代码描述,使其更紧凑和更易debug,并提供了扩展的便利性。

     

    3、Keras的用户体验

    (1)、Keras是专为人而非机器设计的API

    • 它把用户体验放在首要和中心位置。
    • Keras遵循减少认知困难的最佳实践:它提供一致且简单的API,将常见用例所需的用户操作数量降至最低,并且在用户错误时提供清晰和可操作的反馈。

    (2)、Keras易于学习且易于使用

    • 作为Keras用户,可以更高效地工作,让你比竞争对手更快地尝试更多创意和帮助你赢得机器学习竞赛。

    (3)、这种易用性不是以降低灵活性为代价

    • Keras与低级深度学习语言(特别是TensorFlow)集成,能够实现可以用基本语言构建的任何东西。特别是,作为tf.keras,Keras API与TensorFlow工作流程无缝集成。

     

    4、如果你有如下需求,请选择Keras

    • 简易和快速的原型设计(keras具有高度模块化,极简,和可扩充特性)
    • 支持CNN和RNN,或二者的结合
    • 无缝CPU和GPU切换。

     

    5、Keras支持多后端和多平台

    (1)、支持多种语言:Develop in Python, R   On Unix, Windows, OSX
    (2)、支持多个后端:Keras与TensorFlow&Theano

         TensorFlow和theano以及Keras都是深度学习框架,TensorFlow和theano比较灵活,也比较难学,它们其实就是一个微分器  Keras其实就是TensorFlow和Keras的接口(Keras作为前端,TensorFlow或theano作为后端),它也很灵活,且比较容易学。可以把keras看作为tensorflow封装后的一个API。Keras 是一个用于快速构建深度学习原型的高级库。我们在实践中发现,它是数据科学家应用深度学习的好帮手。Keras 目前支持两种后端框架:TensorFlow 与 Theano,而且 Keras 再过不久就会成为 TensorFlow 的默认 API。

    Run the same code with…

    • -TensorFlow
    • -CNTK
    • -Theano
    • -MXNet
    • -PlaidML

    (3)、支持多运算平台:CPU, NVIDIA GPU, AMD GPU, TPU

     

    Keras: 基于 Python 的深度学习库
    Keras中文文档
    tensorflow.org/guide/keras

     

     

     

    Keras的安装

    pip install Keras
    python -m pip install keras

    哈哈,大功告成!继续学习去啦!
    pip install --upgrade Kera

    190827更新到2.2.5

    190827再次还原到2.2.4

    相关文章
    Py之keras-resnet:keras-resnet的简介、安装、使用方法之详细攻略

     

     

    Keras的使用方法

    0、三种API方式:The Sequential Model (序列模型)、The functional API (函数式API)、Model subclassing(模型子类化)

    from keras.models import Model
    from keras.callbacks import ModelCheckpoint
    from keras.layers import Conv2D, MaxPool2D, Flatten, Dropout, Dense, Input
    from keras.optimizers import Adam
    from keras.backend.tensorflow_backend import set_session
    from keras.utils.vis_utils import model_to_dot
    
    
    import tensorflow as tf
    from keras.backend.tensorflow_backend import set_session
     
    np.random.seed(5)
    config = tf.ConfigProto()
    config.gpu_options.allow_growth=True
    set_session(tf.Session(config=config))

     

    1、The Sequential Model 序列模型

    -非常简单
    -仅适用于单输入,单输出,顺序的层堆叠
    -适用于70%以上的用例

    Sequential 序列模型如所示
    可以简单地使用.add() 来堆叠模型
    在完成了模型的构建后, 可以使用.compile() 来配置学习过程:
    如果需要,还可以进一步地配置优化器:
    批量地在训练数据上进行迭代:# x_train 和y_train 是Numpy 数组--就像在Scikit-Learn API 中一样

    或者,可以手动地将批次的数据提供给模型:
    一行代码就能评估模型性能:
    对新的数据生成预测

    1、快速开始序贯(Sequential)模型  
    序贯模型是多个网络层的线性堆叠,也就是“一条路走到黑”。  
    (1)、可以通过向Sequential模型传递一个layer的list来构造该模型:  
    from keras.models import Sequential 
    from keras.layers import Dense, Activation  
    model = Sequential([ Dense(32, units=784), Activation('relu'), Dense(10), Activation('softmax'), ]) 
    (2)、也可以通过.add()方法一个个的将layer加入模型中:  
    model = Sequential() model.add(Dense(32, input_shape=(784,))) 
    model.add(Activation('relu')) 

    #引入Sequential,Dense,Activation
    from keras.models import Sequential
    from keras.layers import Dense, Activation
    #向layer添加list方式
    model = Sequential([Dense(32, input_dim=784),Activation('relu'),Dense(10),Activation('softmax'),])
    
    #通过.add()方式
    model = Sequential()
    model.add(Dense(32, input_dim=784))
    model.add(Activation('relu'))

     

     

     

    2、The functional API 函数式API

    -象玩乐高积木
    -多输入,多输出,任意静态图拓扑
    -适用于95%的用例

    Keras 函数式API 是定义复杂模型(如多输出模型、有向无环图,或具有共享层的模型)的方法。

    例一:全连接网络

     

    3、Model subclassing 模型子类化

    -最大的灵活性
    -更大的可能错误面

    (1)、通过对tf.keras.Model 进行子类化并定义你自己的前向传播来构建完全可自定义的模型。在__init__ 方法中创建层并将它们设置为类实例的属性。在call 方法中定义前向传播。
    (2)、在启用Eager Execution 时,模型子类化特别有用,因为可以命令式地编写前向传播。
    (3)、以下示例展示了使用自定义前向传播进行子类化的tf.keras.Model

    class MyModel(tf.keras.Model):
        def __init__(self, num_classes=10):
            super(MyModel, self).__init__(name='my_model')
            self.num_classes = num_classes  
            # Define your layers here.
            self.dense_1 = layers.Dense(32, activation='relu')
            self.dense_2 = layers.Dense(num_classes, activation='sigmoid')
            
        def call(self, inputs): 
            # Define your forward pass here,
            # using layers you previously defined (in `__init__`).
            x = self.dense_1(inputs)
            return self.dense_2(x)
        def compute_output_shape(self, input_shape):
            # You need to override this function if you want to use the subclassed model
            # as part of a functional-style model.# Otherwise, this method is optional.
            shape = tf.TensorShape(input_shape).as_list()
            shape[-1] = self.num_classes
            return tf.TensorShape(shape)
    
    实例化新模型类
    model = MyModel(num_classes=10) # The compile step specifies the training configuration.
    model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])
    # Trains for 5 epochs.
    model.fit(data, labels, batch_size=32, epochs=5)
    
    

     

    其他概念

    1、shape

    (1)、指定输入数据的shape  

    模型需要知道输入数据的shape,因此,Sequential的第一层需要接受一个关于输入数据shape的参数,后面的各个层则可以自动的推导出中间数据的shape,因此不需要为每个层都指定这个参数。

    (2)、关于张量shape  更多详细内容参考这个博客https://blog.csdn.net/u013378306/article/details/56281549
       在Keras和Tensorflow中,数据是以张量的形式表示的,张量的形状就是shape。TensorFlow用张量这种数据结构来表示所有的数据.你可以把一个张量想象成一个n维的数组或列表.一个张量有一个静态类型和动态类型的维数.张量可以在图中的节点之间流通即Flow。

       你可以认为一个二阶张量就是我们平常所说的矩阵,一阶张量可以认为是一个向量.对于一个二阶张量你可以用语句t[i, j]来访问其中的任何元素.而对于三阶张量你可以用't[i, j, k]'来访问其中的任何元素.

    (1)input_shape就是指输入张量的shape。例如 input_dim=784,说明输入是一个784维的向量,这相当于一个一阶的张量,它的shape就是(784,)

    2、回调

    1、回调是传递给模型的对象,用于在训练期间自定义该模型并扩展其行为。你可以编写自定义回调,也可以使用包含以下方法的内置tf.keras.callbacks:

    tf.keras.callbacks.ModelCheckpoint        '定期保存模型的检查点。'
    tf.keras.callbacks.LearningRateScheduler  '动态更改学习速率。'
    tf.keras.callbacks.EarlyStopping          '在验证效果不再改进时中断训练。'
    tf.keras.callbacks.TensorBoard            '使用TensorBoard 监控模型的行为。'

    2、要使用tf.keras.callbacks.Callback,请将其传递给模型的fit 方法:

    callbacks = [
        # Interrupt training if `val_loss` stops improving for over 2 epochs
        tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'),
        # Write TensorBoard logs to `./logs` directory
        tf.keras.callbacks.TensorBoard(log_dir='./logs')
        ]
    model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks,
              validation_data=(val_data, val_labels))

    3、保存和恢复

    (1)仅限权重:使用tf.keras.Model.save_weights 保存并加载模型的权重

    model = tf.keras.Sequential([layers.Dense(64, activation='relu'),
                                 layers.Dense(10, activation='softmax')])
    model.compile(optimizer=tf.train.AdamOptimizer(0.001),
                  loss='categorical_crossentropy',metrics=['accuracy'])
    
    '默认情况下,会以TensorFlow 检查点文件格式保存模型的权重'
    # Save weights to a TensorFlow Checkpoint file
    model.save_weights('./weights/my_model')
    # Restore the model's state,# this requires a model with the same architecture.
    model.load_weights('./weights/my_model')
    
    '权重也可以另存为KerasHDF5 格式(Keras多后端实现的默认格式)'
    # Save weights to a HDF5 
    filemodel.save_weights('my_model.h5', save_format='h5')
    # Restore the model's statemodel.
    load_weights('my_model.h5')

    (2)、仅限配置:可以保存模型的配置,此操作会对模型架构(不含任何权重)进行序列化。即使没有定义原始模型的代码,保存的配置也可以重新创建并初始化相同的模型。Keras 支持JSON 和YAML 序列化格式:

    # Serialize a model to JSON format
    json_string = model.to_json()
    json_string
    import json 
    import pprint
    pprint.pprint(json.loads(json_string))
    
    '从json重新创建模型'
    fresh_model = tf.keras.models.model_from_json(json_string)

    (3)整个模型:整个模型可以保存到一个文件中,其中包含权重值、模型配置乃至优化器配置。这样,您就可以对模型设置检查点并稍后从完全相同的状态继续训练,而无需访问原始代码。

    # Create a trivial model
    model = tf.keras.Sequential([layers.Dense(10, activation='softmax', input_shape=(32,)),
                                 layers.Dense(10, activation='softmax')])
    model.compile(optimizer='rmsprop',loss='categorical_crossentropy',
                  metrics=['accuracy'])
    model.fit(data, labels, batch_size=32, epochs=5)
    # Save entire model to a HDF5 file
    model.save('my_model.h5')
    
    # Recreate the exact same model, including weights and optimizer.
    model = tf.keras.models.load_model('my_model.h5')

     

    4、动态图机制:Eager Execution

          不同于TensorFlow的静态机制。

    • Eager Execution 是一种命令式编程环境,可立即评估操作。此环境对于Keras 并不是必需的,但是受tf.keras 的支持,并且可用于检查程序和调试。
    • 所有tf.keras 模型构建API 都与Eager Execution 兼容。虽然可以使用Sequential 和函数式API,但Eager Execution 对模型子类化和构建自定义层特别有用。
    • 与通过组合现有层来创建模型的API 不同,函数式API 要求你编写前向传播代码。

     

     

     

     

    Keras的中的模型使用

    1、查找使用方法

    from keras.models import Sequential
    model = Sequential()
    help(model.compile)

    (1)、model.compile()函数,用来配置训练模型参数,可以指定你设想的随机梯度下降中的网络的损失函数、优化方式等参数(2)、model.summary()函数,Prints a string summary of the network.
    (3)、model.fit_generator()函数,Fits the model on data generated batch-by-batch by a Python generator.The generator is run in parallel to the model, for efficiency.For instance, this allows you to do real-time data augmentation on images on CPU in parallel to training your model on GPU.
    (4)、K.placeholder()    #用于得到传递进来的真实的训练样本

     

    2、Keras的 6 种预训练模型 

          目前可知,Keras 已经将这 6 种预训练模型集成到了库中: VGG16、VGG19、ResNet50、Inception v3、Xception、MobileNet。VGG 网络以及从 2012 年以来的 AlexNet 都遵循现在的基本卷积网络的原型布局:一系列卷积层、最大池化层和激活层,最后还有一些全连接的分类层。MobileNet 本质上是为移动应用优化后的 Xception 架构的流线型(streamline)版本。

     

    3、Keras深度学习框架的注意事项(自动下载存放路径等)、使用方法之详细攻略

    DL之Keras: Keras深度学习框架的注意事项(自动下载存放路径等)、使用方法之详细攻略

     

     

     

    展开全文
  • 睿智的目标检测29——Keras搭建YoloV4目标检测平台

    万次阅读 多人点赞 2020-05-12 11:34:25
    睿智的目标检测29——Keras搭建YoloV4目标检测平台学习前言什么是YOLOV4YOLOV4改进的部分(不完全)改进点解析1、主干特征提取网络Backbone2、主干特征提取网络Backbone 学习前言 哈哈哈我最喜欢的YOLO更新了! ...
  • keras代码_keras_源码

    2021-09-30 15:07:41
    KERAS学习用的例子的代码,帮助学习KERAS的代码
  • picture-Keras_人工智能_Keras分类_keras_Keras图像分类_imageneural.zip
  • tensorflow下用Keras构建卷积神经网络用于图像分类
  • picture-Keras_人工智能_Keras分类_keras_Keras图像分类_imageneural_源码.rar
  • Keras安装+Pycharm配置Keras

    万次阅读 多人点赞 2019-08-13 19:43:33
    Keras安装Keras是什么安装前提安装步骤安装openGV3Pycharm配置Keras Keras是什么 Keras是一个由Python编写的开源人工神经网络库,可以作为Tensorflow、Microsoft-CNTK和Theano的高阶应用程序接口,进行深度学习...
  • Keras自定义Loss函数

    万次阅读 多人点赞 2018-01-13 12:00:09
    Keras本身提供了很多常用的loss函数(即目标函数),但这些损失函数都是比较基本的、通用的。有时候我们需要根据自己所做的任务来自定义损失函数,虽然Keras是一个很高级的封装,自定义loss还是比较简单的。这里记录...
  • Keras是一个由Python编写的开源人工神经网络库,可以作为Tensorflow、Microsoft-CNTK和Theano的高阶应用程序接口,进行深度学习模型的设计、调试、评估、应用和可视化。
  • 文章目录1.Keras简介2.Keras的安装3.backend3.1.查看当前使用的backend3.2.修改backend 1.Keras简介 如果说 Tensorflow 或者 Theano 神经网络方面的巨人. 那 Keras 就是站在巨人肩膀上的人. Keras 是一个兼容 Theano...
  • tensorflow和keras版本对应关系

    万次阅读 多人点赞 2020-06-13 11:50:11
    Keras版本 Tensorflow 2.1 Tensorflow 2.0 Tensorflow 1.15 Keras 2.3.1 Tensorflow 1.14 Keras 2.2.5 Tensorflow 1.13 Tensorflow 1.12 Tensorflow 1.11 Keras 2.2.4 Tensorflow 1.10 Tensorflow 1.9 ...
  • yolov4-keras框架下的实现,所需环境tensorflow-gpu==1.13.1 keras==2.1.5
  • keras-contrib:Keras社区贡献 Keras-contrib已过时。 使用 Keras-contrib的未来: 我们正在迁移到 。 请在查看公告。 该库是python深度学习库的官方扩展库。 它包含其他层,激活,损失函数,优化器等,这些在...
  • 最详细的Python语法,关于深度学习框架Keras以及神经网络
  • 1.什么是Keras? 如果说 Tensorflow 或者 Theano 神经网络方面的巨人. 那 Keras 就是站在巨人肩膀上的人. Keras 是一个兼容 Theano 和 Tensorflow 的神经网络高级包, 用他来组件一个神经网络更加快速, 几条语句就搞定...
  • Keras TCN 与所有主要/最新的Tensorflow版本(从1.14到2.4.0+)兼容。 pip install keras-tcn Keras时间卷积网络。 [] 为什么选择时间卷积网络? 与具有相同容量的循环体系结构相比,TCN具有更长的内存。 在各种...
  • 人脸识别mtcnn代码,简单易用,keras版本
  • Tensorflow Keras实战教程

    2021-03-08 22:37:03
    1. 结合程序实例全面详细介绍Tensorflow Keras编程的结构、模型流程、要素及重要的模型进阶技术点,由浅入深教会学员用Keras进行深度学习编程 2. 结合程序实例讲解大多数深度学习实用模型的用法及要点,包括CNN...
  • KerasKeras入门指南

    千次阅读 多人点赞 2019-03-25 10:55:57
    keras中文文档(官方) keras中文文档(非官方) 莫烦keras教程代码 莫烦keras视频教程 一些keras的例子 Keras开发者的github keras在imagenet以及VGG19上的应用 一个不负责任的Keras介绍(上) 一个不负...
  • from keras.layers import merge merge6 = merge([layer1,layer2], mode = ‘concat’, concat_axis = 3) 新版本中: from keras.layers.merge import concatenate merge = concatenate([layer1, layer2], axis=3)...
  • keras-resnet:用于深度残差网络的Keras软件包
  • BCNN_keras:使用keras的双线性CNN实现
  • 凯拉斯·拉丹(Keras RAdam) [| ] 在和TensorFlow中非官方实施 。 安装 pip install keras-rectified-adam 外部链接 用法 import keras import numpy as np from keras_radam import RAdam # Build toy model ...
  • keras中文手册

    2018-11-24 21:19:34
    keras中文手册,可供了解 keras的朋友下载学习。 keras中文手册,可供了解 keras的朋友下载学习。Keras是一个高层神经网络库,Keras由纯Python编写而成并基Tensorflow或Theano。Keras 为支持快速实验而生,能够把你...
  • keras-squeezenet 使用Keras Functional Framework 2.0的SqueezeNet v1.1实现 该具有AlexNet精度,且占用空间小(5.1 MB)。 # Most Recent One pip install git+...Keras
  • Supplemental_labels_keras 使用Keras进行弱监督学习
  • Python Keras库 安装包

    2019-12-14 21:47:06
    Python Keras库 安装包 Python Keras库 安装包 Python Keras库 安装包 Python Keras库 安装包 Python Keras库 安装包

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 126,860
精华内容 50,744
关键字:

keras