keras 猫狗大战自搭网络以及vgg16应用

导入模块

import os
import numpy as np
import tensorflow as tf
import random
import seaborn as sns
import matplotlib.pyplot as plt
import keras
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Activation, Flatten, Input,BatchNormalization
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.optimizers import RMSprop, Adam, SGD
from keras.preprocessing import image
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16, preprocess_input

from sklearn.model_selection import train_test_split

加载数据集

def read_and_process_image(data_dir,width=64, height=64, channels=3, preprocess=False):
    train_images= [data_dir + i for i in os.listdir(data_dir)]
    
    random.shuffle(train_images)
    
    def read_image(file_path, preprocess):
        img = image.load_img(file_path, target_size=(height, width))
        x = image.img_to_array(img)
        x = np.expand_dims(x, axis=0)
        # if preprocess:
            # x = preprocess_input(x)
        return x
    
    def prep_data(images, proprocess):
        count = len(images)
        data = np.ndarray((count, height, width, channels), dtype = np.float32)
        
        for i, image_file in enumerate(images):
            image = read_image(image_file, preprocess)
            data[i] = image
        
        return data
    
    def read_labels(file_path):
        labels = []
        for i in file_path:
            label = 1 if 'dog' in i else 0
            labels.append(label)
        
        return labels
    
    X = prep_data(train_images, preprocess)
    labels = read_labels(train_images)
    
    assert X.shape[0] == len(labels)
    
    print("Train shape: {}".format(X.shape))
    
    return X, labels

            

读取数据集

# 读取图片
WIDTH = 150
HEIGHT = 150
CHANNELS = 3
X, y = read_and_process_image('D:\\Python_Project\\train\\',width=WIDTH, height=HEIGHT, channels=CHANNELS)

查看数据集信息

# 统计y
sns.countplot(y)

# 显示图片
def show_cats_and_dogs(X, idx):
    plt.figure(figsize=(10,5), frameon=True)
    img = X[idx,:,:,::-1]
    img = img/255
    plt.imshow(img)
    plt.show()


for idx in range(0,3):
    show_cats_and_dogs(X, idx)

train_X = X[0:17500,:,:,:]
train_y = y[0:17500]
test_X = X[17500:25000,:,:,:]
test_y = y[17500:25000]
train_X.shape
test_X.shape

自定义神经网络层数

input_layer = Input((WIDTH, HEIGHT, CHANNELS))
# 第一层
z = input_layer
z = Conv2D(64, (3,3))(z)
z = BatchNormalization()(z)
z = Activation('relu')(z)
z = MaxPooling2D(pool_size = (2,2))(z)

z = Conv2D(64, (3,3))(z)
z = BatchNormalization()(z)
z = Activation('relu')(z)
z = MaxPooling2D(pool_size = (2,2))(z)

z = Conv2D(128, (3,3))(z)
z = BatchNormalization()(z)
z = Activation('relu')(z)
z = MaxPooling2D(pool_size = (2,2))(z)

z = Conv2D(128, (3,3))(z)
z = BatchNormalization()(z)
z = Activation('relu')(z)
z = MaxPooling2D(pool_size = (2,2))(z)

z = Flatten()(z)
z = Dense(64)(z)
z = BatchNormalization()(z)
z = Activation('relu')(z)
z = Dropout(0.5)(z)
z = Dense(1)(z)
z = Activation('sigmoid')(z)

model = Model(input_layer, z)

model.compile(
    optimizer = keras.optimizers.RMSprop(),
    loss = keras.losses.binary_crossentropy,
    metrics = [keras.metrics.binary_accuracy]
)

model.summary()

训练模型

history = model.fit(train_X,train_y, validation_data=(test_X, test_y),epochs=10,batch_size=128,verbose=True)
score = model.evaluate(test_X, test_y, verbose=0)
print("Large CNN Error: %.2f%%" %(100-score[1]*100))

复用vgg16模型

def vgg16_model(input_shape= (HEIGHT,WIDTH,CHANNELS)):
    vgg16 = VGG16(include_top=False, weights='imagenet',input_shape=input_shape)
    
    for layer in vgg16.layers:
        layer.trainable = False
    last = vgg16.output
    # 后面加入自己的模型
    x = Flatten()(last)
    x = Dense(256, activation='relu')(x)
    x = Dropout(0.5)(x)
    x = Dense(256, activation='relu')(x)
    x = Dropout(0.5)(x)
    x = Dense(1, activation='sigmoid')(x)
    
    model = Model(inputs=vgg16.input, outputs=x)
    
    return model

编译模型

model_vgg16 = vgg16_model()
model_vgg16.summary()
model_vgg16.compile(loss='binary_crossentropy',optimizer = Adam(0.0001), metrics = ['accuracy'])

训练模型

# 训练模型
history = model_vgg16.fit(train_X,train_y, validation_data=(test_X, test_y),epochs=5,batch_size=128,verbose=True)
score = model_vgg16.evaluate(test_X, test_y, verbose=0)
print("Large CNN Error: %.2f%%" %(100-score[1]*100))