【表情识别】模型训练(简单的卷积网络)

用了简单的四层卷积网络，效果不是很好，训练了800多伦之后，准确率早已不再增加，约在0.62413，还没有达到其他人的0.65

# -*- coding: utf-8 -*-
import numpy as np
from APL import APLUnit
from keras.layers import Activation,BatchNormalization
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Flatten, InputLayer
from keras.layers.convolutional import Conv2D
from keras import backend as K
from keras.preprocessing.image import ImageDataGenerator
from batch_fscore import fbeta_score
import pandas as pd
import cv2
from keras.utils import multi_gpu_model
from keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
input_shape = (48, 48, 1)
validation_split = .2
seed = 7
np.random.seed(seed)
training_size = 28273
validation_size = 3533 # size of either test set

# data generator
data_generator = ImageDataGenerator(
                        featurewise_center=False,
                        featurewise_std_normalization=False,
                        rotation_range=30,              #整数。随机旋转的度数范围。
                        width_shift_range=0.2,          #浮点数、一维数组或整数
                        height_shift_range=0.2,
                        zoom_range=0.2,                  # 浮点数 或 [lower, upper]。随机缩放范围。如果是浮点数，[lower, upper] = [1-zoom_range, 1+zoom_range]。
                        horizontal_flip=True)           #布尔值。随机水平翻转


#def frac_max_pool(x):
#    return tf.nn.fractional_max_pool(x,p_ratio)[0]
def load_fer2013():
    data = pd.read_csv("../fer2013/fer2013.csv")
    pixels = data['pixels'].tolist()
    width, height = 48, 48
    faces = []
    for pixel_sequence in pixels:
        face = [int(pixel) for pixel in pixel_sequence.split(' ')]
        # 将数组转换为64*64的二维矩阵
        face = np.asarray(face).reshape(width, height)
        # 根据需要缩放
        #face = cv2.resize(face.astype('uint8'), self.image_size)
        faces.append(face.astype('float32'))
    faces = np.asarray(faces)
    faces = np.expand_dims(faces, -1)
    # 返回nunpy二元数组
    emotions = pd.get_dummies(data['emotion']).as_matrix()
    return faces, emotions
def preprocess_input(x, v2=True):
    x = x.astype('float32')
    x = x / 255.0
    if v2:
        x = x - 0.5
        x = x * 2.0
    return x
def split_data(x, y, validation_split=.2):
    num_samples = len(x)
    num_train_samples = int((1 - validation_split)*num_samples)
    train_x = x[:num_train_samples]
    train_y = y[:num_train_samples]
    val_x = x[num_train_samples:]
    val_y = y[num_train_samples:]
    train_data = (train_x, train_y)
    val_data = (val_x, val_y)
    return train_data, val_data
def model(weights = None, S = 5, p_ratio = [1.0, 2.6, 2.6, 1.0]):

    model = Sequential()
    #第一层
    model.add(Conv2D(filters=16, kernel_size=(5, 5), padding='same',
                            name='image_array', input_shape=input_shape))
    model.add(BatchNormalization())
    model.add(Conv2D(filters=16, kernel_size=(5, 5),
                            strides=(2, 2), padding='same'))
    model.add(BatchNormalization())
    model.add(Activation('relu'))
    model.add(Dropout(.25))

    #第二层
    model.add(Conv2D(filters=32, kernel_size=(5, 5), padding='same'))
    model.add(BatchNormalization())
    model.add(Conv2D(filters=32, kernel_size=(5, 5),
                            strides=(2, 2), padding='same'))
    model.add(BatchNormalization())
    model.add(Activation('relu'))
    model.add(Dropout(.25))

    #第三层
    model.add(Conv2D(filters=64, kernel_size=(3, 3), padding='same'))
    model.add(BatchNormalization())
    model.add(Conv2D(filters=64, kernel_size=(3, 3),
                            strides=(2, 2), padding='same'))
    model.add(BatchNormalization())
    model.add(Activation('relu'))
    model.add(Dropout(.25))

    #第四层
    model.add(Conv2D(filters=64, kernel_size=(1, 1), padding='same'))
    model.add(BatchNormalization())
    model.add(Conv2D(filters=128, kernel_size=(3, 3),
                            strides=(2, 2), padding='same'))
    model.add(BatchNormalization())
    model.add(Activation('relu'))
    model.add(Dropout(.25))

    model.add(Conv2D(filters=256, kernel_size=(1, 1), padding='same'))
    model.add(BatchNormalization())
    model.add(Conv2D(filters=128, kernel_size=(3, 3),
                            strides=(2, 2), padding='same'))

    model.add(Conv2D(filters=256, kernel_size=(1, 1), padding='same'))
    model.add(BatchNormalization())
    model.add(Conv2D(filters=7, kernel_size=(3, 3),
                            strides=(2, 2), padding='same'))

    model.add(Flatten())
    model.add(Activation('softmax',name='predictions'))
    #使用多GPU
    model = multi_gpu_model(model, 3)

    model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy', fbeta_score])

    if weights:
        model.load_weights(weights)

    return model


#可以加载已经存在的模型
model = model(weights="weights.h5")
model = model()

batch_size = 256

# Preprocess inputted data
train_datagen = ImageDataGenerator(
        rescale=1./255,
        rotation_range = 30,
        shear_range=0.2,
        width_shift_range=0.2,
        height_shift_range=0.2,
        zoom_range=0.2,
        fill_mode='nearest',
        horizontal_flip=True)

test_datagen = ImageDataGenerator(rescale = 1./255)



# ~~~~~~~~~~~~~~~~~~~~~~ Train model ~~~~~~~~~~~~~~~~~~~~~~
# callback functions
save_best = ModelCheckpoint('weights.h5', monitor='val_acc', verbose=2, save_best_only=True, mode='max')
reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2,
              patience=5, min_lr=0.001, verbose=1)



faces, emotions = load_fer2013()
#faces = preprocess_input(faces)
num_samples, num_classes = emotions.shape


#分割训练集和验证集
train_data, val_data = split_data(faces, emotions, validation_split)

#得到训练集
train_faces, train_emotions = train_data


model.fit_generator(data_generator.flow(train_faces, train_emotions,
                        batch_size),
        steps_per_epoch=len(train_faces) / batch_size,
        epochs=3000,
        callbacks = [save_best, reduce_lr],
        validation_data=val_data)
#model.save_weights('VGG16_regular_second_try.h5')  # always save your weights after training or during training