keras 修仙笔记一

对于牛逼的程序员，人家都喜欢叫他大神；因为大神很牛逼，人家需要一个小时完成的技术问题，他就20分钟就搞定。Keras框架是一个高度集成的框架，学好它，就犹如掌握一个法宝，可以呼风唤雨。所以学keras 犹如在修仙，呵呵。请原谅我无厘头的逻辑。

Kera是一个高度集成化的框架，面向高层的抽象，他是python语言写的，同时也可以运行在tensorflow或者cntk之上（即后台运行可以是tensorflow或者cntk），他可以快速的构建你的机器学习模型，但也因为高度封装的原因，也会失去一些改写的灵活性。

首先来看看导入的类，可以有哪些：

import numpy as np
#import tensorflow as tf
from keras import layers
from keras.layers import Input, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D
from keras.layers import AveragePooling2D, MaxPooling2D, Dropout, GlobalMaxPooling2D, GlobalAveragePooling2D
from keras.models import Model
from keras.preprocessing import image
from keras.utils import layer_utils
from keras.utils.data_utils import get_file
from keras.applications.imagenet_utils import preprocess_input
import pydot
from IPython.display import SVG
from keras.utils.vis_utils import model_to_dot
from keras.utils import plot_model
from kt_utils import *

import keras.backend as K
K.set_image_data_format('channels_last')
import matplotlib.pyplot as plt
from matplotlib.pyplot import imshow

%matplotlib inline

尤其是

from keras.layers import Input, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D

from keras.layers import AveragePooling2D, MaxPooling2D, Dropout, GlobalMaxPooling2D, GlobalAveragePooling2D

这样的函数，顺手捏来就可以使用了。就像一些积木似的，可以用来快速成型。

现在有一个例子：

就是有人组织一场party，到场参加的必须是带着笑容了，因为门口有摄像头，通过摄像头会识别来的人是否是带着笑容的，如果是，则自动开门放行，如果不是则不会开门。

第一步：参数的初始化（模拟数据）

def mean_pred(y_true, y_pred):
    return K.mean(y_pred)

def load_dataset():
    train_dataset = h5py.File('datasets/train_happy.h5', "r")  # h5py 是一种数据存储格式
    train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set features
    train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels

    test_dataset = h5py.File('datasets/test_happy.h5', "r")
    test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
    test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels

    classes = np.array(test_dataset["list_classes"][:]) # the list of classes

    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))

return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes

小测：

X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()

# Normalize image vectors
X_train = X_train_orig/255.
X_test = X_test_orig/255.

# Reshape
Y_train = Y_train_orig.T
Y_test = Y_test_orig.T

print ("number of training examples = " + str(X_train.shape[0]))
print ("number of test examples = " + str(X_test.shape[0]))
print ("X_train shape: " + str(X_train.shape))
print ("Y_train shape: " + str(Y_train.shape))
print ("X_test shape: " + str(X_test.shape))
print ("Y_test shape: " + str(Y_test.shape))

图片是（64，64,3）

训练集 600张

测试集 150张

第二步：用keras建立模型

根据keras的快速原型：这些方法都是在导入keras时候导入的
def model(input_shape):
   X_input = Input(input_shape) # 底层是tensorflow ，其实是创建placeholder存放变量
   X=ZeroPadding2D((3,3))(X_input) # 建立padding画布，主要适配不同图片尺寸或者避免边缘特征磨损的情况
   X=Conv2D(32，(7,7)),strides=(1,1),name=’conv0’)(x)  ##32 是过滤核的数量；（7,7）是过滤核的宽度和高度，strides是卷积的部长，name是对其进行命名
   X = BatchNormalization(axis = 3, name = 'bn0')(X) #规范化，控制过拟合
   X=Activation(‘relu’)(x) #激活函数
   X=MaxPooling2D((2,2),name=’max_pool’)(x) #池化

   X = Flatten()(X) #全连接，多维转为一维
   X=Dense(1,activation=’sigmoid’,name=’fc’)(x) #激活函数，和全连接
   model=Model(input=X_input,outputs=X,name=’HappyModel’)

   return model

在上面给出的模型中，我们可以看到都一直都用X作为变量，其实这个无所谓了，因为底层已经根据给出的别名X，Z1，A1，Z2，A2等已经赋值并缓存起来了。而这些方法都是前面导入的函数：

from keras.layers import Input, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D

接下来，我们组装一个模型：

def HappyModel(input_shape):
  X_input = Input(shape=input_shape)
  X = ZeroPadding2D(padding=(1,1))(X_input)
  X=Conv2D(8,kernel_size=(3,3),strides=(1,1))(x)
  X=BatchNormalization(axis=3)(x)
  X=Activation(‘relu’)(X)
  X=MaxPooling2D(pool_size=(2,2),strides=(2,2),padding=’valid’)(x)

 #FC
  X=Flatten()(X)
  Y=Dense(1,activation=’sigmoid’)(x)
  Model = Model(inputs=X_input,outputs=Y,name=’HappyModel’)

  Return model

第三步：训练模型

在下面训练模型的过程可分为

1）  创建模型 （如上代码）

2）  编译模型，使用到函数 model.compile(optimizer=”..”,loss=”..’’,metrics=[“accuracy”])

3）  训练模型，通过调用model.fit(x=…,y=…,epochs=…,batch_size=…)

Batch_size:批次数，就是每次有多少个样例参与训练，每次训练迭代epochs次

Batch_Size 太小，算法在 200 epoches 内不收敛。

•随着 Batch_Size 增大，处理相同数据量的速度越快。

•随着 Batch_Size 增大，达到相同精度所需要的 epoch 数量越来越多。

•由于上述两种因素的矛盾， Batch_Size 增大到某个时候，达到时间上的最优。

由于最终收敛精度会陷入不同的局部极值，因此 Batch_Size 增大到某些时候，达到最终收敛精度上的最优。如果内存不足，需要把batch_size 设置小一点

4）  测试模型的数据通过调用 model.evaluate(x=…,y=…)

具体的使用可以参考中文keras手册：

http://keras-cn.readthedocs.io/en/latest/layers/core_layer/

1）  创建模型：

happyModel = HappyModel((64, 64, 3))

2）  编译模型：

import keras

happyModel.compile(optimizer=keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0), loss='binary_crossentropy', metrics=['accuracy'])

# 优化器中Adam

# lr：大或等于0的浮点数，学习率

#beta_1/beta_2：浮点数， 0<beta<1，通常很接近1

# epsilon：大或等于0的小浮点数，防止除0错误

3）  训练模型：

happyModel.fit(x=X_train, y=Y_train, batch_size=16, epochs=20)

4）  测试模型：

preds = happyModel.evaluate(x=X_test, y=Y_test)
### END CODE HERE ###
print()
print ("Loss = " + str(preds[0]))
print ("Test Accuracy = " + str(preds[1]))

happyModel.summary() :会详细打印出训练的过程

第四步：实际运用

预测结果：model.predict(x) 就会打印出匹配的结果 是true 还是flase

mg_path = 'images/my_image.jpg'
### END CODE HERE ###
img = image.load_img(img_path, target_size=(64, 64))
imshow(img)

x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
result = happyModel.predict(x) ###预测结果
print(result)

总结：keras训练主要有4大步骤
Create->Compile->Fit/Train->Evaluate/Test.
创建-编译-训练-测试
具体的keras函数可以查看：http://keras-cn.readthedocs.io/en/latest/other

参考：基础原理http://www.jianshu.com/p/64172378a178