keras 机器学习初探

Keras 介绍

Keras是一个高层神经网络库,Keras由纯Python编写而成并基Tensorflow或Theano。Keras 为支持快速实验而生,能够把你的idea迅速转换为结果,如果你有如下需求,请选择Keras:

  • 简易和快速的原型设计(keras具有高度模块化,极简,和可扩充特性)
  • 支持CNN和RNN,或二者的结合
  • 支持任意的链接方案(包括多输入和多输出训练)
  • 无缝CPU和GPU切换

Keras适用的Python版本是:Python 2.7-3.5

ubuntu 安装

安装 keras

在 ubuntu 下安装比较容易:

sudo pip install keras

注意: 我这里安装的版本为 keras 1.2 后续keras 更新可能导致以下代码不能跑通

本文代码基于theano

编辑~/.keras/keras.json

{
		"image_dim_ordering": "th",
		"epsilon": 1e-07,
		"floatx": "float32",
		"backend": "theano"
}

安装PIL

PIL: Python Imaging Library 是一个python比较常用的图像库

#wget "http://effbot.org/downloads/Imaging-1.1.7.tar.gz"
#sudo python setup.py install
sudo pip install pillow

## 如果需要解析jpeg 需要安装jpeg 库
sudo apt-get install libjpeg-dev
# reinstall pillow
sudo pip install --no-cache-dir -I pillow

安装h5py

安装h5py 是为了保存训练结果 保存格式为 hdf5 类型

sudo pip install h5py

编写模型

下载数据

jpeg 格式 Mnist 数据: http://pan.baidu.com/s/1pLLJ3Of

来源

加载数据模块

# -*- coding:utf-8 -*-
import os
from PIL import Image
import numpy as np

#读取mnist文件夹下的42000张图片,图片为灰度图,所以通道为1,图像大小28*28
#如果是将彩色图作为输入,则将1替换为3,并且data[i,:,:,:] = arr改为data[i,:,:,:] = [arr[:,:,0],arr[:,:,1],arr[:,:,2]]
def load_data(input_shape):
    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):
        print "%d\r"%i,
        img = Image.open("./mnist/"+imgs[i])
        arr = np.asarray(img,dtype="float32")
        data[i,:,:,:] = arr
        label[i] = int(imgs[i].split('.')[0])
    data = data.reshape(data.shape[0],input_shape[0],input_shape[1],input_shape[2])
    return data,label

CNN分类Mnist 网络构造以及训练模块

# -*- coding:utf-8 -*-
#导入各种用到的模块组件
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
from keras import backend as K


###############
#开始建立CNN模型
###############


#生成一个model
model = Sequential()

img_rows=28
img_cols=28
if K.image_dim_ordering() == 'th':
    input_shape = (1, img_rows, img_cols)
else:
    input_shape = (img_rows,img_cols,1)

#第一个卷积层,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, 5, 5, border_mode='valid',input_shape=input_shape))
model.add(Activation('tanh'))

#第二个卷积层,8个卷积核,每个卷积核大小3*3。4表示输入的特征图个数,等于上一层的卷积核个数
#激活函数用tanh
#采用maxpooling,poolsize为(2,2)
model.add(Convolution2D(8, 3, 3, border_mode='valid',input_shape=(4,3,3)))
model.add(Activation('tanh'))
model.add(MaxPooling2D((2, 2)))

#第三个卷积层,16个卷积核,每个卷积核大小3*3
#激活函数用tanh
model.add(Convolution2D(16, 3, 3, border_mode='valid',input_shape=(8,3,3)))
model.add(Activation('tanh'))
#采用MaxPooling,poolsize为(2,2)
model.add(MaxPooling2D((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, input_shape=(16,3,3),init='normal'))
model.add(Activation('tanh'))

#Softmax分类,输出是10类别
model.add(Dense(10, init='normal'))
model.add(Activation('softmax'))



#加载数据
data, label = load_data(input_shape)
print(data.shape[0], ' samples')

#label为0~9共10个类别,keras要求格式为binary class matrices,转化一下,直接调用keras提供的这个函数
label = np_utils.to_categorical(label, 10)

#data = data.reshape(data.shape[0],  img_rows, img_cols,1)

#############
#开始训练模型
##############

#使用SGD + momentum
sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
#model.compile里的参数loss就是损失函数(目标函数)
model.compile(loss='categorical_crossentropy', optimizer=sgd,class_mode="categorical")


#fit方法,就是一个训练过程. 训练的epoch数设为10,batch_size为100.
#数据经过随机打乱shuffle=True。
#verbose=1,训练过程中输出的信息
#show_accuracy=True,训练时每一个epoch都输出accuracy。
#validation_split=0.2,将20%的数据作为验证集。
#fit方法在达到设定的nb_epoch时结束,并且自动地保存了效果最好的model
#还有model.predict_classes,model.predict_proba等方法,具体请看文档。
model.fit(data, label, batch_size=100,nb_epoch=10,shuffle=True,verbose=1,show_accuracy=True,validation_split=0.2)

open('model_architecture.json','w').write(model.to_json())
model.save_weights('model_weights.h5')

#之后你可以调用model.evaluate()方法对测试数据进行测试,

注解:

Dropout是指在模型训练时随机让网络某些隐含层节点的权重不工作,不工作的那些节点可以暂时认为不是网络结构的一部分,但是它的权重得保留下来

输出:

Train on 33600 samples, validate on 8400 samples
Epoch 1/10
33600/33600 [==============================] - 43s - loss: 0.3049 - val_loss: 0.2332
Epoch 2/10
33600/33600 [==============================] - 46s - loss: 0.1859 - val_loss: 0.1760
Epoch 3/10
33600/33600 [==============================] - 48s - loss: 0.1965 - val_loss: 0.1552
Epoch 4/10
33600/33600 [==============================] - 45s - loss: 0.1249 - val_loss: 0.1346
Epoch 5/10
33600/33600 [==============================] - 44s - loss: 0.1044 - val_loss: 0.1029
Epoch 6/10
33600/33600 [==============================] - 46s - loss: 0.1069 - val_loss: 0.1413
Epoch 7/10
33600/33600 [==============================] - 45s - loss: 0.1288 - val_loss: 0.1718
Epoch 8/10
33600/33600 [==============================] - 44s - loss: 0.1105 - val_loss: 0.1162
Epoch 9/10
33600/33600 [==============================] - 44s - loss: 0.1609 - val_loss: 0.2333
Epoch 10/10
33600/33600 [==============================] - 44s - loss: 0.1886 - val_loss: 0.2084

模型加载以及测试模块

# -*- coding:utf-8 -*-

from keras.models import Sequential,model_from_json
from keras.utils import np_utils, generic_utils
from keras.optimizers import SGD, Adadelta, Adagrad

from data import load_data
from keras import backend as K

# 加载网络
model = model_from_json(open('model_architecture.json').read())

sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd,class_mode="categorical")

# 加载权值
model.load_weights('model_weights.h5')

img_rows=28
img_cols=28
if K.image_dim_ordering() == 'th':
    input_shape = (1, img_rows, img_cols)
else:
    input_shape = (img_rows,img_cols,1)
#加载数据
data, label = load_data(input_shape)
print(data.shape[0], ' samples')

#label为0~9共10个类别,keras要求格式为binary class matrices,转化一下,直接调用keras提供的这个函数
label = np_utils.to_categorical(label, 10)

print(model.predict(data[0:1]))
score=model.evaluate(data,label,batch_size=1000,verbose=1)

print(score)

输出为:

[[  1.20462562e-09   9.99981880e-01   5.61546926e-07   2.91456748e-09
    1.17034360e-05   2.22247802e-08   3.18724517e-07   1.95865914e-06
    1.74572790e-06   1.83476288e-06]]
42000/42000 [==============================] - 14s
0.190522604045

参考

Keras-cn

humboldt Written by:

humboldt 的趣味程序园