keras实现多种分类网络的方式

迷南。 2023-02-18 15:29 4阅读 0赞

keras实现多种分类网络的方式

更多python视频教程请到菜鸟教程https://www.piaodoo.com/

Keras应该是最简单的一种深度学习框架了，入门非常的简单.

简单记录一下keras实现多种分类网络：如AlexNet、Vgg、ResNet

采用kaggle猫狗大战的数据作为数据集.

由于AlexNet采用的是LRN标准化,Keras没有内置函数实现,这里用batchNormalization代替

收件建立一个model.py的文件,里面存放着alexnet,vgg两种模型,直接导入就可以了

#coding=utf-8
    from keras.models import Sequential
    from keras.layers import Dense, Dropout, Activation, Flatten
    from keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D, BatchNormalization
    from keras.layers import *
    from keras.layers.advanced_activations import LeakyReLU,PReLU
    from keras.models import Model

def keras\_batchnormalization\_relu(layer):  
BN = BatchNormalization()(layer)  
ac = PReLU()(BN)  
return ac

def AlexNet(resize=227, classes=2):  
model = Sequential()

# 第一段 #

model.add(Conv2D(filters=96, kernel\_size=(11, 11),  
strides=(4, 4), padding=‘valid’,  
input\_shape=(resize, resize, 3),  
activation=‘relu’))  
model.add(BatchNormalization())  
model.add(MaxPooling2D(pool\_size=(3, 3),  
strides=(2, 2),  
padding=‘valid’))

# 第二段 #

model.add(Conv2D(filters=256, kernel\_size=(5, 5),  
strides=(1, 1), padding=‘same’,  
activation=‘relu’))  
model.add(BatchNormalization())  
model.add(MaxPooling2D(pool\_size=(3, 3),  
strides=(2, 2),  
padding=‘valid’))

# 第三段 #

model.add(Conv2D(filters=384, kernel\_size=(3, 3),  
strides=(1, 1), padding=‘same’,  
activation=‘relu’))  
model.add(Conv2D(filters=384, kernel\_size=(3, 3),  
strides=(1, 1), padding=‘same’,  
activation=‘relu’))  
model.add(Conv2D(filters=256, kernel\_size=(3, 3),  
strides=(1, 1), padding=‘same’,  
activation=‘relu’))  
model.add(MaxPooling2D(pool\_size=(3, 3),  
strides=(2, 2), padding=‘valid’))

# 第四段 #

model.add(Flatten())  
model.add(Dense(4096, activation=‘relu’))  
model.add(Dropout(0.5))

model.add(Dense(4096, activation=‘relu’))  
model.add(Dropout(0.5))

model.add(Dense(1000, activation=‘relu’))  
model.add(Dropout(0.5))

# Output Layer #

model.add(Dense(classes,activation=‘softmax’))

# model.add(Activation(‘softmax’)) #

return model

def AlexNet2(inputs, classes=2, prob=0.5):  
‘’’  
自己写的函数,尝试keras另外一种写法  
:param inputs: 输入  
:param classes: 类别的个数  
:param prob: dropout的概率  
:return: 模型  
‘’’

# Conv2D(32, (3, 3), dilation\_rate=(2, 2), padding=‘same’)(inputs) #

print “input shape:”, inputs.shape

conv1 = Conv2D(filters=96, kernel\_size=(11, 11), strides=(4, 4), padding=‘valid’)(inputs)  
conv1 = keras\_batchnormalization\_relu(conv1)  
print “conv1 shape:”, conv1.shape  
pool1 = MaxPool2D(pool\_size=(3, 3), strides=(2, 2))(conv1)  
print “pool1 shape:”, pool1.shape

conv2 = Conv2D(filters=256, kernel\_size=(5, 5), padding=‘same’)(pool1)  
conv2 = keras\_batchnormalization\_relu(conv2)  
print “conv2 shape:”, conv2.shape  
pool2 = MaxPool2D(pool\_size=(3, 3), strides=(2, 2))(conv2)  
print “pool2 shape:”, pool2.shape

conv3 = Conv2D(filters=384, kernel\_size=(3, 3), padding=‘same’)(pool2)  
conv3 = PReLU()(conv3)  
print “conv3 shape:”, conv3.shape

conv4 = Conv2D(filters=384, kernel\_size=(3, 3), padding=‘same’)(conv3)  
conv4 = PReLU()(conv4)  
print “conv4 shape:”, conv4

conv5 = Conv2D(filters=256, kernel\_size=(3, 3), padding=‘same’)(conv4)  
conv5 = PReLU()(conv5)  
print “conv5 shape:”, conv5

pool3 = MaxPool2D(pool\_size=(3, 3), strides=(2, 2))(conv5)  
print “pool3 shape:”, pool3.shape

dense1 = Flatten()(pool3)  
dense1 = Dense(4096, activation=‘relu’)(dense1)  
print “dense2 shape:”, dense1  
dense1 = Dropout(prob)(dense1)

# print “dense1 shape:”, dense1 #

dense2 = Dense(4096, activation=‘relu’)(dense1)  
print “dense2 shape:”, dense2  
dense2 = Dropout(prob)(dense2)

# print “dense2 shape:”, dense2 #

predict= Dense(classes, activation=‘softmax’)(dense2)

model = Model(inputs=inputs, outputs=predict)  
return model

def vgg13(resize=224, classes=2, prob=0.5):  
model = Sequential()  
model.add(Conv2D(64, (3, 3), strides=(1, 1), input\_shape=(resize, resize, 3), padding=‘same’, activation=‘relu’,  
kernel\_initializer=‘uniform’))  
model.add(Conv2D(64, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(MaxPooling2D(pool\_size=(2, 2)))  
model.add(Conv2D(128, (3, 2), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(Conv2D(128, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(MaxPooling2D(pool\_size=(2, 2)))  
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(MaxPooling2D(pool\_size=(2, 2)))  
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(MaxPooling2D(pool\_size=(2, 2)))  
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(MaxPooling2D(pool\_size=(2, 2)))  
model.add(Flatten())  
model.add(Dense(4096, activation=‘relu’))  
model.add(Dropout(prob))  
model.add(Dense(4096, activation=‘relu’))  
model.add(Dropout(prob))  
model.add(Dense(classes, activation=‘softmax’))  
return model

def vgg16(resize=224, classes=2, prob=0.5):  
model = Sequential()  
model.add(Conv2D(64, (3, 3), strides=(1, 1), input\_shape=(resize, resize, 3), padding=‘same’, activation=‘relu’,  
kernel\_initializer=‘uniform’))  
model.add(Conv2D(64, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(MaxPooling2D(pool\_size=(2, 2)))  
model.add(Conv2D(128, (3, 2), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(Conv2D(128, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(MaxPooling2D(pool\_size=(2, 2)))  
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(Conv2D(256, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(MaxPooling2D(pool\_size=(2, 2)))  
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(MaxPooling2D(pool\_size=(2, 2)))  
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(Conv2D(512, (3, 3), strides=(1, 1), padding=‘same’, activation=‘relu’, kernel\_initializer=‘uniform’))  
model.add(MaxPooling2D(pool\_size=(2, 2)))  
model.add(Flatten())  
model.add(Dense(4096, activation=‘relu’))  
model.add(Dropout(prob))  
model.add(Dense(4096, activation=‘relu’))  
model.add(Dropout(prob))  
model.add(Dense(classes, activation=‘softmax’))  
return model

然后建立一个train.py文件，用于读取数据和训练数据的.

#coding=utf-8
    import keras
    import cv2
    import os
    import numpy as np
    import model
    import modelResNet
    import tensorflow as tf
    from keras.layers import Input, Dense
    from keras.preprocessing.image import ImageDataGenerator

resize = 224  
batch\_size = 128  
path = “/home/hjxu/PycharmProjects/01\_cats\_vs\_dogs/data”

trainDirectory = ‘/home/hjxu/PycharmProjects/01\_cats\_vs\_dogs/data/train/’  
def load\_data():  
imgs = os.listdir(path + “/train/”)  
num = len(imgs)  
train\_data = np.empty((5000, resize, resize, 3), dtype=“int32”)  
train\_label = np.empty((5000, ), dtype=“int32”)  
test\_data = np.empty((5000, resize, resize, 3), dtype=“int32”)  
test\_label = np.empty((5000, ), dtype=“int32”)  
for i in range(5000):  
if i % 2:  
train\_data\[i\] = cv2.resize(cv2.imread(path + ‘/train/’ + ‘dog.’ + str(i) + ‘.jpg’), (resize, resize))  
train\_label\[i\] = 1  
else:  
train\_data\[i\] = cv2.resize(cv2.imread(path + ‘/train/’ + ‘cat.’ + str(i) + ‘.jpg’), (resize, resize))  
train\_label\[i\] = 0  
for i in range(5000, 10000):  
if i % 2:  
test\_data\[i-5000\] = cv2.resize(cv2.imread(path + ‘/train/’ + ‘dog.’ + str(i) + ‘.jpg’), (resize, resize))  
test\_label\[i-5000\] = 1  
else:  
test\_data\[i-5000\] = cv2.resize(cv2.imread(path + ‘/train/’ + ‘cat.’ + str(i) + ‘.jpg’), (resize, resize))  
test\_label\[i-5000\] = 0  
return train\_data, train\_label, test\_data, test\_label

def main():

train\_data, train\_label, test\_data, test\_label = load\_data()  
train\_data, test\_data = train\_data.astype(‘float32’), test\_data.astype(‘float32’)  
train\_data, test\_data = train\_data/255, test\_data/255

train\_label = keras.utils.to\_categorical(train\_label, 2)  
‘’’  
\#one\_hot转码,如果使用 categorical\_crossentropy,就需要用到to\_categorical函数完成转码  
‘’’  
test\_label = keras.utils.to\_categorical(test\_label, 2)

inputs = Input(shape=(224, 224, 3))

modelAlex = model.AlexNet2(inputs, classes=2)  
‘’’  
导入模型  
‘’’  
modelAlex.compile(loss=‘categorical\_crossentropy’,  
optimizer=‘sgd’,  
metrics=\[‘accuracy’\])  
‘’’  
def compile(self, optimizer, loss, metrics=None, loss\_weights=None,  
sample\_weight\_mode=None, \*\*kwargs):  
optimizer:优化器,为预定义优化器名或优化器对象,参考优化器  
loss: 损失函数,为预定义损失函数名或者一个目标函数  
metrics:列表,包含评估模型在训练和测试时的性能指标,典型用法是 metrics=\[‘accuracy’\]  
sample\_weight\_mode:如果需要按时间步为样本赋值,需要将改制设置为"temoral"  
如果想用自定义的性能评估函数:如下  
def mean\_pred(y\_true, y\_pred):  
return k.mean(y\_pred)  
model.compile(loss = ‘binary\_crossentropy’, metrics=\[‘accuracy’, mean\_pred\],…)  
损失函数同理,再看 keras内置支持的损失函数有  
mean\_squared\_error  
mean\_absolute\_error  
mean\_absolute\_percentage\_error  
mean\_squared\_logarithmic\_error  
squared\_hinge  
hinge  
categorical\_hinge  
logcosh  
categorical\_crossentropy  
sparse\_categorical\_crossentropy  
binary\_crossentropy  
kullback\_leibler\_divergence  
poisson  
cosine\_proximity  
‘’’  
modelAlex.summary()  
‘’’

# 打印模型信息 #

‘’’  
modelAlex.fit(train\_data, train\_label,  
batch\_size=batch\_size,  
epochs=50,  
validation\_split=0.2,  
shuffle=True)  
‘’’  
def fit(self, x=None, \# x:输入数据  
y=None, \# y:标签 Numpy array  
batch\_size=32, \# batch\_size:训练时,一个batch的样本会被计算一次梯度下降  
epochs=1, \# epochs: 训练的轮数,每个epoch会把训练集循环一遍  
verbose=1, \# 日志显示:0表示不在标准输入输出流输出,1表示输出进度条,2表示每个epoch输出  
callbacks=None, \# 回调函数  
validation\_split=0., \# 0-1的浮点数,用来指定训练集一定比例作为验证集,验证集不参与训练  
validation\_data=None, \# (x,y)的tuple,是指定的验证集  
shuffle=True, \# 如果是"batch",则是用来处理HDF5数据的特殊情况,将在batch内部将数据打乱  
class\_weight=None, \# 字典,将不同的类别映射为不同的权值,用来在训练过程中调整损失函数的  
sample\_weight=None, \# 权值的numpy array,用于训练的时候调整损失函数  
initial\_epoch=0, \# 该参数用于从指定的epoch开始训练,继续之前的训练  
\*\*kwargs):  
返回:返回一个History的对象,其中History.history损失函数和其他指标的数值随epoch变化的情况  
‘’’  
scores = modelAlex.evaluate(train\_data, train\_label, verbose=1)  
print(scores)

scores = modelAlex.evaluate(test\_data, test\_label, verbose=1)  
print(scores)  
modelAlex.save(‘my\_model\_weights2.h5’)

def main2():  
train\_datagen = ImageDataGenerator(rescale=1. / 255,  
shear\_range=0.2,  
zoom\_range=0.2,  
horizontal\_flip=True)  
test\_datagen = ImageDataGenerator(rescale=1. / 255)  
train\_generator = train\_datagen.flow\_from\_directory(trainDirectory,  
target\_size=(224, 224),  
batch\_size=32,  
class\_mode=‘binary’)

validation\_generator = test\_datagen.flow\_from\_directory(trainDirectory,  
target\_size=(224, 224),  
batch\_size=32,  
class\_mode=‘binary’)

inputs = Input(shape=(224, 224, 3))

# modelAlex = model.AlexNet2(inputs, classes=2) #

modelAlex = model.vgg13(resize=224, classes=2, prob=0.5)

# modelAlex = modelResNet.ResNet50(shape=224, classes=2) #

modelAlex.compile(loss=‘sparse\_categorical\_crossentropy’,  
optimizer=‘sgd’,  
metrics=\[‘accuracy’\])  
modelAlex.summary()

modelAlex.fit\_generator(train\_generator,  
steps\_per\_epoch=1000,  
epochs=60,  
validation\_data=validation\_generator,  
validation\_steps=200)

modelAlex.save(‘model32.hdf5’)

#  #

if **name** == “**main**”:  
‘’’  
如果数据是按照猫狗大战的数据,都在同一个文件夹下,使用main()函数  
如果数据按照猫和狗分成两类,则使用main2()函数  
‘’’  
main2()

得到模型后该怎么测试一张图像呢？

建立一个testOneImg.py脚本，代码如下

#coding=utf-8
    from keras.preprocessing.image import load_img#load_image作用是载入图片
    from keras.preprocessing.image import img_to_array
    from keras.applications.vgg16 import preprocess_input
    from keras.applications.vgg16 import decode_predictions
    import numpy as np
    import cv2
    import model
    from keras.models import Sequential

pats = ‘/home/hjxu/tf\_study/catVsDogsWithKeras/my\_model\_weights.h5’  
modelAlex = model.AlexNet(resize=224, classes=2)

# AlexModel = model.AlexNet(weightPath=’/home/hjxu/tf\_study/catVsDogsWithKeras/my\_model\_weights.h5’) #

modelAlex.load\_weights(pats)

#  #

img = cv2.imread(’/home/hjxu/tf\_study/catVsDogsWithKeras/111.jpg’)  
img = cv2.resize(img, (224, 224))  
x = img\_to\_array(img/255) \# 三维（224，224，3）

x = np.expand\_dims(x, axis=0) \# 四维（1，224，224，3）\#因为keras要求的维度是这样的，所以要增加一个维度

# x = preprocess\_input(x) \# 预处理 #

print(x.shape)  
y\_pred = modelAlex.predict(x) \# 预测概率 t1 = time.time() print(“测试图：”, decode\_predictions(y\_pred)) \# 输出五个最高概率(类名, 语义概念, 预测概率)  
print y\_pred

不得不说，Keras真心简单方便。

**补充知识：****keras中的函数式API——残差连接+权重共享的理解**

**1、残差连接**

# coding: utf-8
    """残差连接 residual connection：
      是一种常见的类图网络结构，解决了所有大规模深度学习的两个共性问题：
       1、梯度消失
       2、表示瓶颈
      （甚至，向任何>10层的神经网络添加残差连接，都可能会有帮助）

残差连接：让前面某层的输出作为后面某层的输入，从而在序列网络中有效地创造一条捷径。  
“”"  
from keras import layers

x = …  
y = layers.Conv2D(128, 3, activation=‘relu’, padding=‘same’)(x)  
y = layers.Conv2D(128, 3, activation=‘relu’, padding=‘same’)(y)  
y = layers.Conv2D(128, 3, activation=‘relu’, padding=‘same’)(y)

y = layers.add(\[y, x\]) \# 将原始x与输出特征相加

# \---------------------如果特征图尺寸不同，采用线性残差连接------------------- #

x = …  
y = layers.Conv2D(128, 3, activation=‘relu’, padding=‘same’)(x)  
y = layers.Conv2D(128, 3, activation=‘relu’, padding=‘same’)(y)  
y = layers.MaxPooling2D(2, strides=2)(y)

residual = layers.Conv2D(128, 1, strides=2, padding=‘same’)(x) \# 使用1\*1的卷积，将原始张量线性下采样为y具有相同的形状

y = layers.add(\[y, residual\]) \# 将原始x与输出特征相加

**2、权重共享**

即多次调用同一个实例

# coding: utf-8
    """函数式子API：权重共享
      能够重复的使用同一个实例，这样相当于重复使用一个层的权重，不需要重新编写"""
    from keras import layers
    from keras import Input
    from keras.models import Model

lstm = layers.LSTM(32) \# 实例化一个LSTM层,后面被调用很多次

# \------------------------左边分支-------------------------------- #

left\_input = Input(shape=(None, 128))  
left\_output = lstm(left\_input) \# 调用lstm实例

# \------------------------右分支--------------------------------- #

right\_input = Input(shape=(None, 128))  
right\_output = lstm(right\_input) \# 调用lstm实例

# \------------------------将层进行连接合并------------------------ #

merged = layers.concatenate(\[left\_output, right\_output\], axis=-1)

# \-----------------------在上面构建一个分类器--------------------- #

predictions = layers.Dense(1, activation=‘sigmoid’)(merged)

# \-------------------------构建模型，并拟合训练----------------------------------- #

model = Model(\[left\_input, right\_input\], predictions)  
model.fit(\[left\_data, right\_data\], targets)

以上这篇keras实现多种分类网络的方式就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多