深度学习：keras 学习笔记
我的图书馆
深度学习：keras 学习笔记
python向量：
import numpy as np
a = np.array([[1,2],[3,4],[5,6]])
sum0 = np.sum(a, axis=0)
sum1 = np.sum(a, axis=1)
print sum0
print sum11234567812345678
指在网络的训练过程中，对于神经网络单元，按照一定的概率将其暂时从网络中丢弃。
dropout是CNN中防止过拟合提高效果的一个大杀器
输出结果是10个类别，所以维度是10
model.add(Dense(500, 10, init=’glorot_uniform’))
Batch gradient descent，批梯度下降
随机梯度下降，stochastic gradient descent
mini-batch gradient decent，小批的梯度下降
batch_size
初始化方法
init是关键字，’uniform’表示用均匀分布去初始化
model.add(Dense(64, init=’uniform’))
每个神经元都有激活函数： linear，sigmoid，tanh，softmax，LeakyReLU和PReLU
model.add(Dense(64))
model.add(Activation(‘tanh’))
model.add(Dense(64, activation=’tanh’)) #此处’tanh’是一个字符串
compile(optimizer, loss, class_model=”categorical”):
optimizer：指定模型训练的优化器；
loss：目标函数；
class_mode: ”categorical”和”binary”中的一个，只是用来计算分类的精确度或using the predict_classes method
theano_mode: pile.mode.Mode instance controllingspecifying compilation options
fit(X, y, batch_size=128, nb_epoch=100, verbose=1, validation_split=0,validation_data=None,shuffle=True,show_accuracy=False,callbacks=[],class_weight=Noe, sample_weight=None)
用于训练一个固定迭代次数的模型
返回：记录字典，包括每一次迭代的训练误差率和验证误差率；
X：训练数据
batch_size : 每次训练和梯度更新块的大小。
nb_epoch: 迭代次数。
verbose : 进度表示方式。0表示不显示数据，1表示显示进度条，2表示用只显示一个数据。
callbacks : 回调函数列表。就是函数执行完后自动调用的函数列表。
validation_split : 验证数据的使用比例。
validation_data : 被用来作为验证数据的(X, y)元组。会代替validation_split所划分的验证数据。
shuffle : 类型为boolean或 str(‘batch’)。是否对每一次迭代的样本进行shuffle操作（可以参见博文Theano学习笔记01--Dimshuffle()函数）。’batch’是一个用于处理HDF5（keras用于存储权值的数据格式）数据的特殊选项。
show_accuracy:每次迭代是否显示分类准确度。
class_weigh : 分类权值键值对。原文：dictionary mapping classes to a weight value, used for scaling the lossfunction (during training only)。键为类别，值为该类别对应的权重。只在训练过程中衡量损失函数用。
sample_weight : list or numpy array with1:1 mapping to the training samples, used for scaling the loss function (duringtraining only). For time-distributed data, there is one weight per sample pertimestep, i.e. if your output data is shaped(nb_samples, timesteps, output_dim), your mask should be of shape (nb_samples, timesteps, 1). This allows you to maskout or reweight individual output timesteps, which is useful in sequence tosequence learning.
evalute(X, y, batch_size=128, show_accuracy=False,verbose=1, sample_weight=None)
展示模型在验证数据上的效果
返回：误差率或者是(误差率，准确率)元组（if show_accuracy=True）
参数：和fit函数中的参数基本一致，其中verbose取1或0，表示有进度条或没有
predict(X, batch_size=128, verbose=1)
用于对数据的预测
返回：对于测试数据的预测数组
参数：和fit函数中的参数一样。
predict_classes(X, batch_size=128, verbose=1)
用于对测试数据的分类预测
返回：对于测试数据的预测分类结果数组
参数：和evaluate函数中的参数一样。
train_on_batch(X, y, accuracy=False, class_weight=None, sample_weight=None)
对数据块进行计算并梯度更新
返回：数据块在现有模型中的误差率或者元组(if show_accuracy=True）
参数：和evaluate函数中的参数一样。
test_on_batch(X, y, accuracy=False, sample_weight=None)
用数据块进行性能验证
返回：数据块在现有模型中的误差率或者元组（误差率，准确率）（if show_accuracy=True）
参数：和evaluate函数中的参数一样。
save_weights (fname, overwrite=False)
将所有层的权值保存为HDF5文件
返回：如果overwrite=False并且fname已经存在，则会抛出异常。
fname: 文件名
overwrite : 如果已经存在，是否覆盖原文件。
load_weights(fname):
加载已经存在的权值数据到程序中的模型里面。文件中的模型和程序中的模型结构必须一致。在compile之前或之后都可以调用load_ weights函数。
参数： fname文件名
Sequential（线性叠加模型）举例说明
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.optimizers import SGD
model = Sequential()
model.add(Dense(2, init='uniform', input_dim=64))
model.add(Activation('softmax'))
pile(loss='mse', optimizer='sgd')
Verbose=1或2的结果演示
model.fit(X_train, y_train, nb_epoch=3, batch_size=16, verbose=1)
# 输出信息
Train on 37800 samples, validate on 4200 samples
[==============================] - 7s - loss: 0.0385
[==============================] - 8s - loss: 0.0140
[=======&......................] - ETA: 4s - loss: 0.0109
model.fit(X_train, y_train, nb_epoch=3, batch_size=16, verbose=2)
# 输出信息
Train on 37800 samples, validate on 4200 samples
loss: 0.0190
loss: 0.0146
loss: 0.0049
show_accuracy=True的演示，会输出误差率-正确率
model.fit(X_train, y_train, nb_epoch=3, batch_size=16, verbose=2, show_accuracy=True)
# 输出信息
Train on 37800 samples, validate on 4200 samples
loss: 0.0190 - acc.: 0.8750
loss: 0.0146 - acc.: 0.8750
loss: 0.0049 - acc.: 1.0000
validation_split=0.1表示总样本的10%用来进行验证。比如下方实例，样本总数42000，则验证数据占10%，即4200，剩余的37800为训练数据。
model.fit(X_train, y_train, nb_epoch=3, batch_size=16, validation_split=0.1, show_accuracy=True, verbose=1)
Train on 37800 samples, validate on 4200 samples
[==============================] - 7s - loss: 0.0385 - acc.:0.7258 - val. loss: 0.0160 - val. acc.: 0.9136
[==============================] - 8s - loss: 0.0140 - acc.:0.9265 - val. loss: 0.0109 - val. acc.: 0.9383
[=======&......................] - ETA: 4s - loss: 0.0109 -acc.: 0.9420
''' 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
Graph（任意连接图模型）方法及属性介绍
任意连接图可以有任意数量的输入和输出，每一个输出都由专门的代价函数进行训练。图模型的最优化取决于所有代价函数的总和。看过代码就会感觉很清晰，完全就是一张节点连接图。可以很清晰的画出该有向图。适用于部分连接的模型。
model = keras.models.Graph()
下面看一下对象model都有哪些方法。
add_input (name, input_shape, dtype=’float’)
往model里边增加一输入层
name: 输入层的唯一字符串标识
input_shape: 整数元组，表示新增层的shape。例如(10,)表示10维向量；(None, 128)表示一个可变长度的128维向量；(3, 32, 32) 表示一张3通道(RGB)的32*32的图片。
dtype:float或者int；输入数据的类型。
add_output (name, input=None, inputs=[], merge_mode=’concat’)
增加一个连接到input或inputs的输出层
name: 输出层的唯一字符串标识
input: 输出层要连接到的隐层的名字。只能是input或inputs中的一个。
inputs:新增层要连接到的多个隐层的名字列表。
merge_mode: “sum”或”concat”。在指定inputs时有效，将不同的输入合并起来。
add_node (layer, name, input=None,inputs=[], merge_mode=’concat’)
增加一个连接到input或inputs的输出层（就是除去输入输出之外的隐层）
layer: Layer实例(Layer后边会介绍到)
name:隐层的唯一字符串标识
input: 新增隐层要连接到的某隐层或输入层的名字。只能是input或inputs中的一个。
inputs:新增隐层要连接到的多个隐层的名字列表。
merge_mode: “sum”或”concat”。在指定inputs时有效，将不同的输入合并起来。
compile (optimizer, loss)
往input或inputs里边增加一输出层
optimizer: 优化器名或者优化器对象
loss: 字典键值对。键为输出层的name，值为该层对应的目标函数名或目标函数对象。
fit(data, batch_size=128, nb_epoch=100, verbose=1, validation_split=0,validation_data=None, shuffle=True, callbacks=[])
用于训练一个固定迭代次数的模型
返回：记录字典，包括每一次迭代的训练误差率和验证误差率；
data：字典。键为输入层或输出层的名，值为具体的输入数据或输出数据。可见下方的示例。
batch_size : 每次训练和梯度更新的数据块大小
nb_epoch: 迭代次数
verbose : 进度表示方式。0表示不显示数据，1表示显示进度条，2表示用只显示一个数据。
callbacks : 回调函数列表
validation_split : 验证数据的使用比例。
validation_data : 被用来作为验证数据的(X, y)元组。Will override validation_split.
shuffle : 类型为boolean或 str(‘batch’)。是否对每一次迭代的样本进行shuffle操作（可以参见博文Theano学习笔记01--Dimshuffle()函数）。’batch’是一个用于处理HDF5（keras用于存储权值的数据格式）数据的特殊选项。
evalute(data, batch_size=128, verbose=1): 展示模型在验证数据上的效果
返回：误差率
参数：和fit函数中的参数基本一致，其中verbose取1或0，表示有进度条或没有
predict(data, batch_size=128, verbose=1): 用于对测试数据的预测
返回：键值对。键为输出层名，值为对应层的预测数组
参数：和fit函数中的参数一样。输入层需要在data中声明。
train_on_batch(data): 对数据块进行计算并梯度更新
返回：数据块在现有模型中的误差率
参数：和evaluate函数中的参数一样。
test_on_batch(data): 用数据块对模型进行性能验证
返回：据块在现有模型中的误差率
参数：和evaluate函数中的参数一样。
save_weights (fname, overwrite=False): 将所有层的权值保存为HDF5文件
返回：如果overwrite=False并且fname已经存在，则会抛出异常。
fname: 文件名
overwrite : 如果已经存在，是否覆盖原文件。
load_weights (fname): 加载已经存在的权值数据到程序中的模型里面。文件中的模型和程序中的模型结构必须一致。在compile之前或之后都可以调用load_ weights函数。
Graph（任意连接图模型）举例说明
# 含一输入，两输出的graph model
graph = Graph()
graph.add_input(name='input', input_shape=(32,))
graph.add_node(Dense(16), name='dense1', input='input')
graph.add_node(Dense(4), name='dense2', input='input')
graph.add_node(Dense(4), name='dense3', input='dense1')
graph.add_output(name='output1', input='dense2')
graph.add_output(name='output2', input='dense3')
pile('rmsprop', {'output1':'mse', 'output2':'mse'})
history = graph.fit({'input':X_train, 'output1':y_train, 'output2':y2_train}, nb_epoch=10)
# 含两输入，两输出的graph model
graph = Graph()
graph.add_input(name='input1', input_shape=(32,))
graph.add_input(name='input2', input_shape=(32,))
graph.add_node(Dense(16), name='dense1', input='input1')
graph.add_node(Dense(4), name='dense2', input='input2')
graph.add_node(Dense(4), name='dense3', input='dense1')
graph.add_output(name='output', inputs=['dense2', 'dense3'], merge_mode='sum')
pile('rmsprop', {'output':'mse'})
history = graph.fit({'input1':X_train, 'input2':X2_train, 'output':y_train}, nb_epoch=10)
predictions = graph.predict({'input1':X_test, 'input2':X2_test}) # {'output':...}
12345678910111213141516171819202122232425261234567891011121314151617181920212223242526
如何使用规则化项
规则化项是一个对于权值参数的惩罚项。它包含在代价函数中。
在Keras的Dense Layer、TimeDistributedDense Layer、MaxoutDense Layer、Convolution1D Layer和Convolution2D Layer中有一个统一的API用来应用规则化项。
上面这些层有3个关键的参数：
W_regularizer：实例化于 keras.regularizers.WeightRegularizer（对权值规则化）
b_regularizer：实例化于keras.regularizers.WeightRegularizer （对偏置规则化）
activity_regularizer：实例化于keras.regularizers.ActivityRegularizer
(对激活值规则化，也就是权值与矩阵点乘以后的输出规则化）
这里对W和b的规则化用的同一个类，因为他们的实现方式基本差不多。然而日常使用的时候，很少对b进行规则化。即使对b规则化了，结果只有一点点的改善。因此经常使用的是对W的规则化。
使用示例代码如下：
from keras.regularizers import l2, activity_l2
model.add(Dense(64, input_dim=64, W_regularizer=l2(0.01), activity_regularizer=activity_l2(0.01)))1212
在Keras的Dense Layer、TimeDistributedDense Layer、MaxoutDense Layer、Convolution1D Layer和Convolution2D Layer中有一个统一的API用来使用约束。
2个关键的参数：
W_constraint：约束主要的权值矩阵
b_constraint：约束偏置值
from keras.constraintsimport maxnorm
model.add(Dense(64, W_constraint =maxnorm(2))) #限制权值的各个参数不能大于21212
可用的约束限制
maxnorm(m=2): 最大值约束
nonneg(): 不允许负值
unitnorm(): 归一化
TA的最新馆藏
喜欢该文的人也喜欢易用的深度学习框架Keras简介及使用
我的图书馆
易用的深度学习框架Keras简介及使用
& & & & & 之前我一直在使用Theano，前面五篇Deeplearning相关的文章也是学习Theano的一些笔记，当时已经觉得Theano用起来略显麻烦，有时想实现一个新的结构，就要花很多时间去编程，所以想过将代码模块化，方便重复使用，但因为实在太忙没有时间去做。最近发现了一个叫做Keras的框架，跟我的想法不谋而合，用起来特别简单，适合快速开发。（其实还有很多其他的深度学习框架都是比较容易用的。）1. Keras简介Keras是基于Theano的一个深度学习框架，它的设计参考了Torch，用Python语言编写，是一个高度模块化的神经网络库，支持GPU和CPU。使用文档在这：，这个框架貌似是刚刚火起来的，使用上的问题可以到github提issue:下面简单介绍一下怎么使用Keras，以Mnist数据库为例,编写一个CNN网络结构，你将会发现特别简单。2. Keras里的模块介绍Optimizers顾名思义，Optimizers包含了一些优化的方法，比如最基本的随机梯度下降SGD,另外还有Adagrad、Adadelta、RMSprop、Adam，一些新的方法以后也会被不断添加进来。[code]keras.optimizers.SGD(lr=0.01, momentum=0.9, decay=0.9, nesterov=False)1上面的代码是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也就是loglossActivations这是激活函数模块，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这几种。layerslayers模块包含了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数据在其官网上有提供，但是不是图像格式的，因为我们通常都是直接处理图像，为了以后程序能复用，我把它弄成图像格式的，这里可以下载：，共有42000张图片。读取图片数据keras要求输入的数据格式是numpy.array类型（numpy是一个python的数值计算的库），所以需要写一个脚本来读入mnist图像，保存为一个四维的data，还有一个一维的label，代码：[code]#coding:utf-8
Author:wepon
Source:/wepe
file:data.py
from PIL import Image
import numpy as np
#读取文件夹mnist下的42000张图片，图片为灰度图，所以为1通道，
#如果是将彩色图作为输入,则将1替换为3,图像大小28*28
def load_data():
data = np.empty((,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，直接读下面的代码吧，有注释，很容易读懂：[code]#导入各种用到的模块组件
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
#pile里的参数loss就是损失函数(目标函数)
sgd = SGD(l2=0.0,lr=0.05, decay=1e-6, momentum=0.9, nesterov=True)
pile(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)
#fit方法在达到设定的nb_epoch时结束，并且自动地保存了效果最好的model,之后你可以调用model.evaluate()方法对测试数据进行测试，
#还有model.predict_classes,model.predict_proba等方法,具体请看文档。代码使用与结果代码放在我github的机器学习仓库里：,非github用户直接点右下的DownloadZip。在/DeepLearning Tutorials/keras_usage目录下包括data.py,cnn.py两份代码，下载Mnist数据后解压到该目录下，运行cnn.py这份文件即可。结果如下所示，在Epoch 9达到了0.98的训练集识别率和0.97的验证集识别率：总结了Keras的基本使用方法，相信用过的同学都会觉得不可思议，太简洁了。十多天前，我在github上发现这个框架的时候，关注Keras的人还比较少，这两天无论是github还是微薄，都看到越来越多的人关注和使用Keras。所以这篇文章就简单地再介绍一下Keras的使用,方便各位入门。主要包括以下三个内容：训练CNN并保存训练好的模型。将CNN用于特征提取，用提取出来的特征训练SVM。可视化CNN卷积层后的特征图。仍然以Mnist为例，代码中用的Mnist数据到这里下载,本文的代码在我的github上:dive_into _keras1. 加载数据数据是图片格式，利用pyhton的PIL模块读取，并转为numpy.array类型。这部分的代码在data.py里：2. 训练CNN并保存训练好的CNN模型将上一步加载进来的数据分为训练数据（X_train，30000个样本）和验证数据（X_val，12000个样本），构建CNN模型并训练。训练过程中，每一个epoch得到的val-accuracy都不一样，我们保存达到最好的val-accuracy时的模型，利用Python的cPickle模块保持。（Keras的开发者最近在添加用hdf5保持模型的功能，我试了一下，没用成功，去github发了issue也没人回，估计还没完善，hdf5压缩率会更高，保存下来的文件会更小。）这部分的代码在cnn.py里，运行:[code]python cnn.py1在第Epoch 4得到96.45%的validation accuracy,运行完后会得到model.pkl这份文件，保存的就是96.45%对应的模型：3.将CNN用于特征提取，用提取出来的特征训练SVM上一步得到了一个val-accuracy为96.45%的CNN模型，在一些论文中经常会看到用CNN的全连接层的输出作为特征，然后去训练其他分类器。这里我也试了一下，用全连接层的输出作为样本的特征向量，训练SVM。SVM用的是scikit learn里的算法。这部分代码在cnn-svm.py,运行：[code]python cnn-svm.py1得到下图的输出，可以看到，cnn-svm的准确率提高到97.89%：4.可视化CNN卷积层后的特征图将卷积层和全连接层后的特征图、特征向量以图片形式展示出来，用到matplotlib这个库。这部分代码在get_feature_map.py里。运行：[code]python get_feature_map.py1得到全连接层的输出，以及第一个卷积层输出的4个特征图：作者：文章出处：
TA的最新馆藏
喜欢该文的人也喜欢