keras 深度学习_keras深度学习库 - CSDN
精华内容
参与话题
  • 针对计算机视觉、图像处理的深度学习Keras框架,希望对有兴趣的同行有帮助!
  • 深度学习(十)keras学习笔记

    万次阅读 2016-03-26 12:25:04
    keras与torch7的使用非常相似,是最近才火起来的深度学习开源库,底层是用了theano。keras可以说是python版的torch7,对于快速构建CNN模型非常方便。同时也包含了一些最新文献的算法,比如Batch Noramlize,文档教程...

    keras学习笔记

    原文地址http://blog.csdn.net/hjimce/article/details/49095199

    作者:hjimce

    keras与torch7的使用非常相似,是最近才火起来的深度学习开源库,底层是用了theano。keras可以说是python版的torch7,对于快速构建CNN模型非常方便。同时也包含了一些最新文献的算法,比如Batch Noramlize,文档教程也很全,在官网上作者都是直接给例子浅显易懂,个人感觉非常容易上手。keras也支持保存训练好的参数,然后加载已经训练好的参数,进行继续训练。

    一、安装教程。

    因为keras是在theano的基础上进行封装的,所以我们需要先安装好theano后,再继续安装keras。theano的安装可以参考我的另外一篇博文,因为我在另外一篇博文中,是在windows环境下搭建theano的,所以这里所讲的keras的安装也是在windows下。

    其实如果在ubuntu中,theano没有安装也没关系,只要使用命令:pip install keras。如果顺利的话,系统会帮你把keras所有所需的库都给安装了,包括theano。

    windows安装步骤:

    1、参考我的另外一篇博文,安装theano,并测试没有问题。

    2、使用Anaconda,然后在命令anaconda的命令窗口中输入:pip install keras

    这个时候有可能出现h5py安装失败:


    那么请到网站:http://www.lfd.uci.edu/~gohlke/pythonlibs/  下载h5py。

    打开上面的网站,找到h5py:


    根据根据自己的电脑选择相应的版本,我的电脑是64为系统,python为2.7,所以选择了:h5py-2.5.0-cp27-none-win_amd64.whl。
    然后把下载到的h5py文件,放到Anaconda所在的安装目录下:

    最后我们在anaconda的命令窗口中输入命令:pip install  h5py-2.5.0-cp27-none-win_amd64.whl 。等h5py安装完后。在重新安装keras输入命令:pip install keras。



    上面如果还是安装失败,那么试试升级pip版本,输入:python-m pip install --upgrade pip,把pip的版本升级一下。
    二、keras 使用教程
    下面贴个简单的例子、更多的例子可以自己到官网的文档教程上看,官网给了很详细的教程,不像caffe的文档那么少。看一下下面例子,松松构建CNN模型。keras为我们提供了两种网络模型.
    1、一种是CNN比较常用到的sequential网络结构,调用方法如下:

    # coding=utf-8
    
    import numpy as np
    
    #np.random.seed(100)
    
    from keras.optimizers import SGD
    
    import os
    import  matplotlib.pyplot as plt
    
    import h5py
    from keras.models import Sequential
    from keras.layers.convolutional import Convolution2D, MaxPooling2D, ZeroPadding2D
    from keras.layers.core import Dense,Dropout,Activation,Flatten
    from keras.layers.normalization import  BatchNormalization
    from keras.optimizers import SGD, Adadelta, Adagrad,RMSprop
    from keras.layers.advanced_activations import PReLU
    
    from  keras.callbacks import ModelCheckpoint,Callback
    
    
    class LossHistory(Callback):
        def on_train_begin(self, logs={}):
            self.losses = []
    
        def on_batch_end(self, batch, logs={}):
            self.losses.append(logs.get('loss'))
    
    def Net_Mouth():
    	keras_model=Sequential()#单支线性网络模型
    	#卷积层输出的特征图为20个,卷积核大小为5*5
    	keras_model.add(Convolution2D(20, 5, 5,input_shape=(3, 60, 60)))#网络输入每张图片大小为3通道,60*60的图片。
    	#激活函数层
    	keras_model.add(Activation('relu'))
    	#最大池化层
    	keras_model.add(MaxPooling2D(pool_size=(2, 2)))
    
    	#卷积层,特征图个数为40,卷积核大小为5*5
    	keras_model.add(Convolution2D(40, 5, 5))
    	keras_model.add(Activation('relu'))
    
    	keras_model.add(MaxPooling2D(pool_size=(2, 2)))
    
    
    	keras_model.add(Convolution2D(60, 3, 3))
    	keras_model.add(Activation('relu'))
    
    	keras_model.add(MaxPooling2D(pool_size=(2, 2)))
    
    
    	keras_model.add(Convolution2D(80, 3, 3))
    	keras_model.add(Activation('relu'))
    
    	#全连接展平
    	keras_model.add(Flatten())
    	#全连接层,神经元个数为1000
    	keras_model.add(Dense(1000))
    	keras_model.add(Activation('relu'))
    
    	keras_model.add(Dense(500))
    	keras_model.add(Activation('relu'))
    
    
    	keras_model.add(Dense(38))
    	keras_model.add(Activation('tanh'))
    
    	#采用adam算法进行迭代优化,损失函数采用均方误差计算公式
    	keras_model.compile(loss='mean_squared_error', optimizer='adam')
    	return keras_model
    
    keras_model=Net_Mouth()
    #用于保存验证集误差最小的参数,当验证集误差减少时,立马保存下来
    checkpointer =ModelCheckpoint(filepath="mouth.hdf5", verbose=1, save_best_only=True)
    history = LossHistory()
    #训练函数,对于cnn来说,网络的输入x是(nsamples,nchanels,height,width)
    #y的输入是(nsamples,output_dimension)
    keras_model.fit(x, y, batch_size=128, nb_epoch=100,shuffle=True,verbose=2,show_accuracy=True,validation_split=0.1,callbacks=[checkpointer,history])
    
    2、图模型,根据节点进行命名连接的一种网络结构

    # coding=utf-8
    import  numpy as np
    from  keras.models import Graph
    import numpy as np
    
    np.random.seed(100)
    import os
    import  matplotlib.pyplot as plt
    
    import h5py
    from keras.models import Graph
    from keras.layers.convolutional import Convolution2D, MaxPooling2D
    from keras.layers.core import Dense,Activation,Flatten, Dropout
    import  keras.optimizers
    
    from  keras.callbacks import ModelCheckpoint,Callback
    
    class LossHistory(Callback):
        def on_train_begin(self, logs={}):
            self.losses = []
    
        def on_batch_end(self, batch, logs={}):
            self.losses.append(logs.get('loss'))
    
    #graph 模型,下面的例子是CNN的局部unshared weight 例子
    #用于人脸五官特征点的定位预测,采用五官局部unshared weight
    def Second_Net_Graph():
    	keras_model=Graph()
    	#网络输入,一张图片3通道,60*60的图片。name表示图模型的节点名称,我们把第一层输入命名为input
    	keras_model.add_input(name='input',input_shape=(3,60,60))
    	#第一个卷积层节点,我们把它命名为conv1,这一层连接到input节点上,input节点作为输入
    	keras_model.add_node(layer=Convolution2D(20, 5, 5),name='conv1',input='input')
    	#激活函数节点,我们把它命名为relul,这一节点连接到conv1节点上
    	keras_model.add_node(layer=Activation('relu'),name='relul',input='conv1')
    	keras_model.add_node(layer=MaxPooling2D(pool_size=(2, 2)),name='pool1',input='relul')
    
    
    	keras_model.add_node(layer=Convolution2D(40, 5, 5),name='conv2',input='pool1')
    	keras_model.add_node(layer=Activation('relu'),name='relu2',input='conv2')
    	keras_model.add_node(layer=MaxPooling2D(pool_size=(2, 2)),name='pool2',input='relu2')
    
    
    	keras_model.add_node(layer=Convolution2D(60, 3, 3),name='conv3',input='pool2')
    	keras_model.add_node(layer=Activation('relu'),name='relu3',input='conv3')
    	keras_model.add_node(layer=MaxPooling2D(pool_size=(2, 2)),name='pool3',input='relu3')
    
    	#分支,前面是权重共享,单支情况,接着到这里,我们把它分支成几个支路,每个分支用于预测各个五官的特征点位置
    
    	#分支1、这个节点名字为brow_input,连接到pool3上,pool3为输入节点
    	keras_model.add_node(layer=Convolution2D(80, 3, 3,activation='relu'),name='brow_input',input='pool3')
    	#分支2,节点名称为eye_input,输入节点为pool3
    	keras_model.add_node(layer=Convolution2D(80, 3, 3,activation='relu'),name='eye_input',input='pool3')
    	#分支3
    	keras_model.add_node(layer=Convolution2D(80, 3, 3,activation='relu'),name='nose_input',input='pool3')
    	#分支4
    	keras_model.add_node(layer=Convolution2D(80, 3, 3,activation='relu'),name='mouth_input',input='pool3')
    
    	#各个分支展平
    	keras_model.add_node(layer=Flatten(),name='brow_flatten',input='brow_input')
    	keras_model.add_node(layer=Flatten(),name='eye_flatten',input='eye_input')
    	keras_model.add_node(layer=Flatten(),name='nose_flatten',input='nose_input')
    	keras_model.add_node(layer=Flatten(),name='mouth_flatten',input='mouth_input')
    
    
    	#各个分支全连接
    	keras_model.add_node(layer=Dense(500,activation='relu'),name='brow_dense1',input='brow_flatten')
    	keras_model.add_node(layer=Dense(500,activation='relu'),name='eye_dense1',input='eye_flatten')
    	keras_model.add_node(layer=Dense(500,activation='relu'),name='nose_dense1',input='nose_flatten')
    	keras_model.add_node(layer=Dense(500,activation='relu'),name='mouth_dense1',input='mouth_flatten')
    
    
    
    	#各个分支的输出
    	keras_model.add_node(layer=Dense(20,activation='tanh'),name='brow_dense2',input='brow_dense1')
    	keras_model.add_node(layer=Dense(24,activation='tanh'),name='eye_dense2',input='eye_dense1')
    	keras_model.add_node(layer=Dense(18,activation='tanh'),name='nose_dense2',input='nose_dense1')
    	keras_model.add_node(layer=Dense(38,activation='tanh'),name='mouth_dense2',input='mouth_dense1')
    
    	#inputs把各个分支得到的向量,按节点的名字,进行排放,然后作为输出
    	keras_model.add_output(name='output',inputs=['brow_dense2','nose_dense2','eye_dense2',
    													  'mouth_dense2'])
    
    	#优化方法选择adam,损失函数选择均方差
    	keras_model.compile(optimizer='adam',loss={'output':'mse'})
    	return  keras_model
    #读取模型,并进行训练
    def train(data_file='../../h5py/train.h5'):
    	print 'readdata'
    	f=h5py.File(data_file,'r')
    	x=f['data'][:]
    	x=np.asarray(x,dtype='float32')
    	y=f['label'][:]
    	y=np.asarray(y,dtype='float32')
    	print x.shape
    	print y.shape
    	print 'train'
    	keras_model=Second_Net_Graph()
    
    	checkpointer =ModelCheckpoint(filepath="graph51point.hdf5", verbose=1, save_best_only=True)
    	history = LossHistory()
    	history = keras_model.fit({'input':x, 'output':y}, shuffle=True,verbose=2,validation_split=0.1,callbacks=[checkpointer,history])
    train()
    

    个人心得:感觉keras使用很方便,同时底层的源码很很容易读懂,我们要修改算法,可以去读一读底层的源码,学习起来不会像caffe的底层那么麻烦,个人感觉caffe的唯一好处就是有很多公开的model、源码,用起来相当麻烦,keras就不一样了,用python,搞深度学习,轻松许多,可惜cvpr上的一些文献的源码都是用caffe写的。期待keras像torch一样,支持caffe模型导入功能。

    **********************作者:hjimce   时间:2015.10.1  联系QQ:1393852684   原创文章,转载请保留原文地址、作者等信息***************

    展开全文
  • 一、这个IMDB数据集包含了50000条电影评论,其中25000条用于训练,另外25000条用于测试...from keras.datasets import imdb (train_data,train_labels),(test_data,test_labels) = imdb.load_data(num_words=8000) ...

    一、这个IMDB数据集包含了50000条电影评论,其中25000条用于训练,另外25000条用于测试。其label只包含0或1,其中0表示负面评价,1表示正面评价

    from keras.datasets import imdb
    (train_data,train_labels),(test_data,test_labels) = imdb.load_data(num_words=8000) #前8000个单词(每局评论至多包含8000个单词)

    二、数据集的相关信息

    print('shape of train data is ',train_data.shape)
    print('shape of train labels is ',train_labels.shape)
    print('an example of train data is ',train_data[5])
    shape of train data is  (25000,)
    shape of train labels is  (25000,)
    an example of train data is  [1, 778, 128, 74, 12, 630, 163, 15, 4, 1766, 7982, 1051, 2, 32, 85, 156, 45, 40, 148, 139, 121, 664, 665, 10, 10, 1361, 173, 4, 749, 2, 16, 3804, 8, 4, 226, 65, 12, 43, 127, 24, 2, 10, 10]
    

    三、处理数据集

    import numpy as np
    # 神经网络的输入必须是tensor而不是list,所以需要将数据集处理为25000*8000
    def vectorize_sequences(sequences,dimension=8000):
        # 生成25000*8000的二维Numpy数组
        results = np.zeros((len(sequences),dimension))
        # one-hot编码
        for i,sequence in enumerate(sequences):
            results[i,sequence] = 1.
        return results
    x_train = vectorize_sequences(train_data)
    x_test = vectorize_sequences(test_data)
    y_train = np.asarray(train_labels).astype('float32')
    y_test = np.asarray(test_labels).astype('float32')

    四、设计网络结构

    • 对于一个输入为向量的二分类问题,使用relu做为激活函数的全连接网络可以很好的解决这个问题
    • 输出层使用sigmoid的目的是使网络输出的是介于0到1的一个概率值
    • 对于二分类问题,通常使用binary_crossentropy
    from keras import models
    from keras import layers
    def build_model():
        model = models.Sequential()
        model.add(layers.Dense(16,activation='relu',input_shape=(8000,)))
        model.add(layers.Dense(16,activation='relu'))
        model.add(layers.Dense(1,activation='sigmoid'))
        model.compile(optimizer='rmsprop',# 还可以通过optimizer = optimizers.RMSprop(lr=0.001)来为优化器指定参数
                      loss='binary_crossentropy', # 等价于loss = losses.binary_crossentropy
                      metrics=['accuracy']) # 等价于metrics = [metircs.binary_accuracy]
        return model
    model = build_model()

    五、划分验证集用于选择超参数epochs

    x_val = x_train[:10000]
    partial_x_train = x_train[10000:]
    y_val = y_train[:10000]
    partial_y_train = y_train[10000:]

    六、训练模型

    history = model.fit(partial_x_train,
                        partial_y_train,
                        epochs=20, # 在全数据集上迭代20次
                        batch_size=512, # 每个batch的大小为512
                        validation_data=(x_val,y_val))
    Train on 15000 samples, validate on 10000 samples
    Epoch 1/20
    15000/15000 [==============================] - 2s 100us/step - loss: 0.5112 - acc: 0.7813 - val_loss: 0.3790 - val_acc: 0.8654
    Epoch 2/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.3057 - acc: 0.9003 - val_loss: 0.3029 - val_acc: 0.8884
    Epoch 3/20
    15000/15000 [==============================] - 1s 77us/step - loss: 0.2272 - acc: 0.9245 - val_loss: 0.3130 - val_acc: 0.8718
    Epoch 4/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.1874 - acc: 0.9365 - val_loss: 0.2842 - val_acc: 0.8859
    Epoch 5/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.1571 - acc: 0.9467 - val_loss: 0.2845 - val_acc: 0.8868
    Epoch 6/20
    15000/15000 [==============================] - 1s 77us/step - loss: 0.1316 - acc: 0.9587 - val_loss: 0.3343 - val_acc: 0.8692
    Epoch 7/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.1159 - acc: 0.9625 - val_loss: 0.3089 - val_acc: 0.8851
    Epoch 8/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.0993 - acc: 0.9685 - val_loss: 0.3608 - val_acc: 0.8703
    Epoch 9/20
    15000/15000 [==============================] - 1s 80us/step - loss: 0.0850 - acc: 0.9750 - val_loss: 0.3473 - val_acc: 0.8788
    Epoch 10/20
    15000/15000 [==============================] - 1s 80us/step - loss: 0.0745 - acc: 0.9781 - val_loss: 0.3719 - val_acc: 0.8757
    Epoch 11/20
    15000/15000 [==============================] - 1s 81us/step - loss: 0.0658 - acc: 0.9811 - val_loss: 0.4018 - val_acc: 0.8736
    Epoch 12/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.0566 - acc: 0.9837 - val_loss: 0.4373 - val_acc: 0.8679
    Epoch 13/20
    15000/15000 [==============================] - 1s 77us/step - loss: 0.0483 - acc: 0.9861 - val_loss: 0.4484 - val_acc: 0.8703
    Epoch 14/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.0406 - acc: 0.9897 - val_loss: 0.4728 - val_acc: 0.8677
    Epoch 15/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.0355 - acc: 0.9913 - val_loss: 0.4968 - val_acc: 0.8693
    Epoch 16/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.0301 - acc: 0.9934 - val_loss: 0.5280 - val_acc: 0.8676
    Epoch 17/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.0277 - acc: 0.9933 - val_loss: 0.5561 - val_acc: 0.8654
    Epoch 18/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.0222 - acc: 0.9949 - val_loss: 0.5822 - val_acc: 0.8654
    Epoch 19/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.0175 - acc: 0.9971 - val_loss: 0.6369 - val_acc: 0.8581
    Epoch 20/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.0152 - acc: 0.9977 - val_loss: 0.6359 - val_acc: 0.8636
    

    history对象保存了在模型训练过程的相关信息

    history_dict = history.history
    history_dict.keys()
    dict_keys(['val_loss', 'val_acc', 'loss', 'acc'])
    

    七、绘制loss和accuracy

    x轴为epochs,y轴为loss

    import matplotlib.pyplot as plt
    %matplotlib inline
    loss_values = history_dict['loss']
    val_loss_values = history_dict['val_loss']
    epochs = range(1,len(loss_values)+1)
    plt.plot(epochs,loss_values,'bo',label='Training loss')
    plt.plot(epochs,val_loss_values,'b',label='Validation loss')
    plt.title('Training and validation loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()

    这里写图片描述

    x轴为epochs,y轴为accuracy

    plt.clf()
    acc_values = history_dict['acc']
    val_acc_values = history_dict['val_acc']
    
    plt.plot(epochs,acc_values,'bo',label='Training acc')
    plt.plot(epochs,val_acc_values,'b',label='Validation acc')
    plt.title('Training and validation accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Acc')
    plt.legend()

    这里写图片描述

    八、选择合适的超参数,然后在所有训练集上重新训练模型

    model.fit(x_train,
             y_train,
             epochs=4, # 由loss图发现在epochs=4的位置上validation loss最低
             batch_size=512)
    Epoch 1/4
    25000/25000 [==============================] - 1s 55us/step - loss: 0.2172 - acc: 0.9436
    Epoch 2/4
    25000/25000 [==============================] - 1s 56us/step - loss: 0.1509 - acc: 0.9552
    Epoch 3/4
    25000/25000 [==============================] - 1s 54us/step - loss: 0.1221 - acc: 0.9632
    Epoch 4/4
    25000/25000 [==============================] - 1s 54us/step - loss: 0.1012 - acc: 0.9678
    <keras.callbacks.History at 0x7f68945847b8>
    

    评估模型在测试集上的loss和accuracy

    results = model.evaluate(x_test,y_test)
    results
    [0.49199876737356185, 0.8586]
    
    展开全文
  • 使用Keras进行深度学习:RNN

    万次阅读 2018-04-27 20:41:55
    RNN---循环神经网络,在这里主要将它用在处理与预测序列数据方面.1.RNN网络结构与原理详解: 该图的左边是未展开的RNN模型,展开后的RNN模型在右边详细的进行了展示.RNN网络的最为重要的一点就是其具有时序性,该...

    RNN---循环神经网络,在这里主要将它用在处理与预测序列数据方面.

    1.RNN网络结构与原理详解:

      

    该图的左边是未展开的RNN模型,展开后的RNN模型在右边详细的进行了展示.RNN网络的最为重要的一点就是其具有时序性,该时序性在网络的具体的体现就是hi的一系列参数的设置,这些参数的含义就是在i时刻(对应时刻的记忆)的记忆.

    输入层到隐含层:

    用公式表示RNN当前时刻的记忆为:


    你会通过这个公式发现,其hi就是在i时刻的记忆,他的计算具体是由两个部分组成的,其中前面的部分是输入的值与权值的乘积,后面一个部分是权值与前一个时刻记忆的乘积。构成了当前时刻的输出值.

    隐含层到输出层:

    在隐含层到输出层,我们使用softmax函数作为激活函数,这个函数的作用就是预测每一个词出现的概率,然后选择其中最大的那一个值(有时候还常常与交叉熵结合使用).


    通过上面的处理过程,RNN就可以有效的处理时序数据,对每一个输入保留重要的信息,理论上就能够得到所有重要的信息,进而综合考虑所有的输入去预测输出.

    2.双向RNN网络结构及原理详解:

    实际上,为什么会产生双向的RNN,这里可以形象的说一下,如果我们把RNN的过程比作一部电视剧,那么如果我们突然的从中间挑出一集来看,肯定会看的一头雾水,因为我们并不知道其前面的背景,所以会很不理解,这就可以比作RNN神经网络,我们从头开始看电视剧,把其中的重要的信息保存下来,这样随着剧请的发展,我们就可以看懂了所有的剧情,并且有时候还可以根据剧情来进行预测.

    但是吧,单向的RNN只能够往一个方向流动,恰好此时你又挑了一集电视剧,但是这个人是啥性格,下场咋样,单从前面的消息是不能够进行预测的,但是如果你知道后面的剧情,那么就非常容易了,这就是为啥引出双向RNN。。


    在上图中,黄色的实线是从前向后流动的重要信息,而黄色的虚线就是从后向前的重要信息。

    3.深层RNN网络结构:

     深层的RNN结构,就是多了几个隐藏层,当重要的信息一次无法体现的时候,我们就可以采用增加隐藏层的方式,试图使其变得更加复杂,那么其就有了更加良好的表示信息的能力.

    4.Keras对RNN的支持:

    Keras对RNN模型进行了封装,调用起来是十分的方便。

    Keras在layers包的recurrent模块中实现了RNN相关层模型的支持,并在wrapper模型上实现双向的RNN包装器.

    recurrent模块中的RNN模型包含RNN,LSTM,GRU等模型。

    RNN:全连接RNN模型

    SimpleRNN(units,activation='tanh',dropout=0.0,recurrent_dropout=0.0,return_sequences=False)

    wrapper模块实现双向RNN模型:

    Bidirectional(layer,merge_mode='concat',weights=None)



    展开全文
  • 基于Keras深度学习实战总结

    千次阅读 2018-06-05 14:34:36
    Keras是一个基于Python语言编写的高度抽象与模块化的深度学习库,其最主要的优势在于对初学者友好,用户直接调用封装好的模块即可快速完成原型设计与验证。Keras的底层可以基于Tensorflow或Theano,用户可以自由选择...

    1.  Keras是什么?

    Keras是一个基于Python语言编写的高度抽象与模块化的深度学习库,其最主要的优势在于对初学者友好,用户直接调用封装好的模块即可快速完成原型设计与验证。Keras的底层可以基于Tensorflow或Theano,用户可以自由选择。另外,Keras支持在CPU和GPU之间进行无缝切换,总体而言,个人感觉这是一个相当强大的工具,并且极大地降低了AI学习与开发的门槛。

    2.  如何在Ubuntu16. 0464Bit环境下安装与配置Keras?

    这部分基本是参照官方手册,主要步骤如下:

    1)      首先,进行Ubuntu系统更新与升级。

    $sudo apt-get update

    $sudo apt-get upgrade

    2)      安装Python,Pip,Git,vim等基础开发包

    $sudo apt-get install –y python-devpython-pip python-nose git gfortran vim

    3)      安装CUDA开发环境(选配,进行GPU加速时需要,使用CPU加速可跳过这一步)

    4)      安装相关安装包

    $sudo pip install –U –pre pip setuptoolswheel

    $sudo pip install –U numpy scipymatplotlib sciket-learn scikit-image

    5)      安装theano

    sudo pip install –U –pre theano

    6)      安装keras

    sudo pip install –U –pre keras

    3.  如何用Keras快速创建深度学习网络模型并进行训练验证?

    基本步骤:

    a)       导入各种用到的模块组件,如Sequential,Dense,Dropout,Activation等模块。

    from keras.models import Sequential

    from keras.layers.core import Dense,Dropout, Activation, Flatten

    b)      创建模型

    例如创建一个简单的Sequential模型,该模型是多个网络层的线性堆叠,用户可以根据自己应用需要灵活地配置Sequential模型的内部具体结构。

    创建Sequential模型:

    model = Sequential()

    c)       配置模型

    两种方法对模型进行配置。

    第一种方法:通过向Sequential 模型传递一个各层(layer)的列表list来构造该模型。

    如:

    model= Sequential([

    Dense(32,input_dim=784),

    Activation('relu'),

    Dense(10),

    Activation('softmax'),

    ])

    可知,该模型依次由Dense层,relu非线性激活层,Dense层,SoftMax分类层构成。

    第二种方法:使用.add()方法一次添加一层到模型中。

    如:

    model.add(Dense(32,input_dim=784))

    model.add(Activation('relu')

    d)      编译模型

    在模型进行训练之前,通常使用model.compile()方法对学习过程进行配置。这里主要是设置三个参数:优化器optimizer,损失函数loss和指标列表metrics。可以使用系统预定义好的优化器和损失函数,当然也可以自己进行自定义。在解决分类问题时,指标列表metrics通常设置为metrics=['accuracy']

    #for a multi-class classification problem

    如:model.compile(optimizer='rmsprop',

    loss='categorical_crossentropy',

    metrics=['accuracy'])

    e)       训练模型

    通常使用model.fit方法,通常需要指定训练的输入数据,数据标签,训练轮数(epochs)和batchsize。

    如:

    #train the model, iterating on the data in batches

    #of 32 samples

    model.fit(data, labels, nb_epoch=10,batch_size=32)

    f)   在测试集上进行验证

    调用model.evaluate()方法,使用测试数据和标签对模型进行验证。

    model.evaluate(X_test, Y_test, batch_size=16)

    4.  一个完整的例子(使用Mnist数据集进行手写数字识别)

    '''Train a simple convnet on the MNIST dataset.
    
    Run on GPU: THEANO_FLAGS=mode=FAST_RUN,device=gpu,floatX=float32 python mnist_cnn.py
    
    Get to 99.25% test accuracy after 12 epochs (there is still a lot of margin for parameter tuning).
    16 seconds per epoch on a GRID K520 GPU.
    '''
    
    from __future__ import print_function
    import numpy as np
    np.random.seed(1337)  # for reproducibility
    
    from keras.datasets import mnist
    from keras.models import Sequential
    from keras.layers.core import Dense, Dropout, Activation, Flatten
    from keras.layers.convolutional import Convolution2D, MaxPooling2D
    from keras.utils import np_utils
    
    batch_size = 128
    nb_classes = 10
    nb_epoch = 12
    
    # input image dimensions
    img_rows, img_cols = 28, 28
    # number of convolutional filters to use
    nb_filters = 32
    # size of pooling area for max pooling
    nb_pool = 2
    # convolution kernel size
    nb_conv = 3
    
    # the data, shuffled and split between tran and test sets
    (X_train, y_train), (X_test, y_test) = mnist.load_data()
    
    X_train = X_train.reshape(X_train.shape[0], 1, img_rows, img_cols)
    X_test = X_test.reshape(X_test.shape[0], 1, img_rows, img_cols)
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')
    X_train /= 255
    X_test /= 255
    print('X_train shape:', X_train.shape)
    print(X_train.shape[0], 'train samples')
    print(X_test.shape[0], 'test samples')
    
    # convert class vectors to binary class matrices
    Y_train = np_utils.to_categorical(y_train, nb_classes)
    Y_test = np_utils.to_categorical(y_test, nb_classes)
    
    model = Sequential()
    
    model.add(Convolution2D(nb_filters, nb_conv, nb_conv,
                            border_mode='valid',
                            input_shape=(1, img_rows, img_cols)))
    model.add(Activation('relu'))
    model.add(Convolution2D(nb_filters, nb_conv, nb_conv))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool)))
    model.add(Dropout(0.25))
    
    model.add(Flatten())
    model.add(Dense(128))
    model.add(Activation('relu'))
    model.add(Dropout(0.5))
    model.add(Dense(nb_classes))
    model.add(Activation('softmax'))
    
    model.compile(loss='categorical_crossentropy', optimizer='adadelta')
    
    model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch,
              show_accuracy=True, verbose=1, validation_data=(X_test, Y_test))
    score = model.evaluate(X_test, Y_test, show_accuracy=True, verbose=0)
    print('Test score:', score[0])
    print('Test accuracy:', score[1])

    5.  如何切换Keras后端backend?

    创建或打开如下Keras配置文件:

    ~/.keras/keras.json

     

    默认配置如下:

    {

    “image_dim_ordering”:”tf”,

    “Epsilon”:1e-07,

    “floatx”:”float32”,

    “backend”:tensorflow”

    }

     

    将backend字段的值改为theano或者tensorflow,即可切换到相应的后端。

    6.  如何使Keras调用GPU?

    如果采用TensorFlow作为后端,当机器上有可用的GPU时,代码会自动调用GPU进行并行计算。如果使用Theano作为后端,可以通过以下方法设置:

    方法1:使用Theano标记,在执行python脚本时使用下面的命令:

    THEANO_FLAGS=device=gpu,floatX=float32python my_keras_script.py

    方法2:在代码的开头处手动设置theano.config.device 和 theano.config.floatX

    import theano

    theano.config.device= 'gpu'

    theano.config.floatX= 'float32'

     

    参考资料:《Keras中文手册》

    点击打开链接

    展开全文
  • 深度学习Keras入门(一)之基础篇

    千次阅读 2018-09-10 15:42:07
    1.关于Keras &nbsp; &nbsp; &nbsp; &nbsp; 1)简介 &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;Keras是由纯python编写的基于...
  • Keras 深度学习框架

    2019-03-28 12:18:13
    https://keras.io/zh/why-use-keras/为什么选择Keras?...主流深度学习框架对比(TensorFlow、Keras、MXNet、PyTorch) 近几年来,深度学习的研究和应用的热潮持续高涨,各种开源深度学习框架层出不穷...
  • Keras是Python中以CNTK、Tensorflow或者Theano为计算后台的一个深度学习建模环境。相对于其他深度学习的计算软件,如:Tensorflow、Theano、Caffe等,Keras在实际应用中有一些显著的优点,其中最主要的优点就是Keras...
  • Keras入门(2)——麻雀虽小,五脏俱全

    万次阅读 多人点赞 2017-08-15 20:31:40
    1. 什么是Keras不知什么时候,突然对于Keras是什么产生了困惑。Keras中文为克拉斯,相传也是铜管乐器。其实,Keras的名字源于希腊古典史诗...但事实上,Keras只是深度学习建模的一个上层建筑,其后端可以灵活使用CNT
  • ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~前言今天去图书馆想找一本Tensorflow方面的教程,结果找到了这本《Tensorflow+Keras 深度学习人工智能实践应用学习 》清华大学出版社,林大贵著。目前小白一枚,打算照着这本书...
  • 分享一套视频教程,名字叫——Keras深度学习入门与实战视频教程,课程很不错,完整版,附源码和课件,有需要的同学可以下载看看
  • Keras深度学习环境配置(WIN10/GPU加速版) 本人目前在用深度学习方法做命名实体识别。起初学习阶段因为数据量不大,所以直接用CPU来训练模型;不过真正落实到研究则需要大量数据才能训练出泛化能力强的模型,这时...
  • [Keras深度学习浅尝]实战二·CNN实现Fashion MNIST 数据集分类 与我们上篇博文[Keras深度学习浅尝]实战一结构相同,修改的地方有,定义网络与模型训练两部分,可以对比着来看。通过使用CNN结构,预测准确率略有提升...
  • 使用Java部署训练好的Keras深度学习模型!!!!: http://www.atyun.com/26414.html java web应用调用python深度学习训练的模型: https://blog.csdn.net/weixin_30377461/article/details/96496250 ...
  • 最近在学习深度学习,想搭建一个...现在把windows下的Anaconda+tensorflow+keras深度学习框架搭建过程记录如下 1.下载安装Anaconda记住支持版本一定是python3以上的版本 链接如下:https://www.continuum.io/downl...
  • Python中Keras深度学习库的回归教程

    千次阅读 2018-02-23 11:31:16
    Keras 是一个深度学习库,它封装了高效的数学运算库 Theano 和 TensorFlow。在这篇文章中,你将会了解到如何使用 Keras 开发和评估神经网络模型来解决回归问题。在完成这个循序渐进的教程后,你将知道:如何加载 CSV...
  • 使用keras深度学习实现回归问题示例

    万次阅读 2016-10-31 16:21:49
    通常情况下,我们都是用深度学习做分类,但有时候也会用来做回归。 原文出处:Regression Tutorial with the Keras Deep Learning Library in Python 1. 这里作者使用Keras 和python的scikit-learn机器学习库来...
  • [Keras深度学习浅尝]实战一·DNN实现Fashion MNIST 数据集分类 此实战来源于TensorFlow Keras官方教程 导入相关包 # TensorFlow and tf.keras import os os.environ[&quot;KMP_DUPLICATE_LIB_OK&quot;]=&...
  • 波士顿房价 keras 深度学习 回归程序
  • Keras提供了一个简单和模块化的API来创建和训练神经网络,隐藏了大部分复杂的细节。How to install keras?Keras 安装的话需要安装Theano和TensorFlow作为Keras的背景库这里安装流程如下:pip install Theano #If ...
1 2 3 4 5 ... 20
收藏数 30,019
精华内容 12,007
关键字:

keras 深度学习