深度学习-卷积神经网络-keras的用法-48

• 1.
• 2.
• 3.
• 4.

1.

# 模型各层之间是线性关系 k层 k+1层可以加上各种元素来构造神经网络
# 这些元素可以通过一个列表来制定 然后作为参数传递给Sequential来生成模型

from keras.models import Sequential
from keras.models import Model
from keras.layers import Dense
from keras.layers import Activation


layers = [
    Dense(32, input_shape=(784, )),
    Activation('relu'),
    Dense(10),
    Activation('softmax')
]

model = Sequential(layers)
model.summary()

2.

# 通用模型可以用来涉及非常复杂的 任意topology结构的神经网络  例如有向无环图

from keras.layers import Input
from keras.layers import Dense
from keras.models import Model

# 输入层
input = Input(shape=(784,))

# 定义各层之间的连接 假设 输入层之后 两个隐藏层 且都有64个神经元 并使用relu激活函数激活
x = Dense(64, activation='relu')(input)
x = Dense(64, activation='relu')(x)

# 输出层 使用最近的隐藏层作为输入
y = Dense(10, activation='softmax')(x)

# 定义模型对象
model = Model(inputs=input, outputs=y)
model.summary()

# 编译模型
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['acc'])

# 拟合模型
# model.fit(train_x, train_y)
# model.evaluate(test_x, test_y)

# model.predict(x_new)

3.

import numpy as np
from keras.datasets import fashion_mnist
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import Flatten

from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.initializers import he_normal


(X_train, y_train), (X_test, y_test) = mnist.load_data('./MNIST_data_bak')

print('X_train shape:', X_train.shape)
print('X_train[0] shape:', X_train[0].shape)
print('y_train[0]:', y_train[0])

# 训练 以及测试的X 为单通道的灰度图像 装换成标准的4维张量形式 [m, h, w, c]即[样本数，高，宽，通道数]
# 并将像素值转化成浮点格式
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1).astype('float32')
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1).astype('float32')

# 每个像素点都是0-255 归一化 像素值控制在0-1之间
X_train /= 255
X_test /= 255


def tran_y(y):
    y_ohe = np.zeros(10)
    y_ohe[y] = 1
    return y_ohe


# y重新用one hot编码转化一下
y_train_ohe = np.array([tran_y(y_train[i]) for i in range(len(y_train))])
y_test_ohe = np.array([tran_y(y_test[i]) for i in range(len(y_test))])

# 搭建卷积神经网络
model = Sequential()

# 添加一层卷积层 64个filters(卷积核) 每个filter是 3*3*1
# 卷积的步长为1 并用relu进行非线性变换激活
model.add(Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1),
                 padding='same', input_shape=(28, 28, 1), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))  # 添加一层 池化层 给输出降采样
# Dropout层 drop率0.5
model.add(Dropout(0.5))

# 重复的搭建 卷积层 128个filters
model.add(Conv2D(128, kernel_size=(3, 3), strides=(1, 1), padding='same',
                 activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.5))

# 重复的搭建 卷积层 256个filters
model.add(Conv2D(256, kernel_size=(3, 3), strides=(1, 1), padding='same',
                 activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.5))

# 把当前层的节点摊平
model.add(Flatten())

# 增加全连接层 softmax输出
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dense(10, activation='softmax'))

# 损失函数为多分类交叉熵
model.compile(loss='categorical_crossentropy', optimizer='adagrad', metrics=['accuracy'])

# 放入数据 进行训练 注意这里y一定要放入one hot转化之后的
model.fit(X_train, y_train_ohe, validation_data=(X_test, y_test_ohe))

# 验证集 验证
# model.predict(X_val)

4.

# 使用迁移学习的思想，以VGG16作为模板 搭建模型 训练自己的手写数字识别模型
# 引入vgg16模型

from keras.applications.vgg16 import VGG16

from keras.layers import Input
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Dropout
from keras.models import Model
from keras.optimizers import SGD

# 加载mnist手写数字识别数据集
from keras.datasets import mnist

# 引入 opencv (安装命令行 pip install opencv-python) 用于对图像进行处理
# 主要是尺寸的变化 以及 通道数的变化 为了是输入数据满足 VGG16的输入格式
import cv2
import h5py as h5py
import numpy as np


# 将VGG16的顶层去掉 只保留其余的网络 VGG16是ImageNet比赛的 分类数目是1000
# 我们的实验模型输出是10个数字 所以需要把top层拿掉
# VGG模型对于输入图像数据的要求 宽高至少为48个像素点 由于硬件配置的限制我们选用48的像素点
# 即使是这样 依然需要24G的内存 所以需要使用 generator 一点点的feed数据进行训练

model_vgg = VGG16(include_top=False, pooling='avg', weights='imagenet',
                  input_shape=(48, 48, 3))
for layer in model_vgg.layers:
    layer.trainable = False

model = Dense(4096, activation='relu', name='fc1')(model_vgg.output)
model = Dense(4096, activation='relu', name='fc2')(model)

model = Dropout(0.5)(model)
model = Dense(10, activation='softmax')(model)

model_vgg_mnist = Model(inputs=model_vgg.input, outputs=model, name='vgg16')

model_vgg_mnist.summary()
sgd = SGD(lr=0.05, decay=1e-5)
model_vgg_mnist.compile(loss='categorical_crossentropy', optimizer=sgd,
                        metrics=['accuracy'])
# 每一张图片转化成48*48 并把单通道的灰度图像转化成RGB的三通道彩色图片
(X_train, y_train), (X_test, y_test) = mnist.load_data('/MNIST_data_bak')
X_train = [cv2.cvtColor(cv2.resize(i, (48, 48)), cv2.COLOR_GRAY2BGR) for i in
           X_train]
# 并把数据转化成tensor 才能输入keras
X_train = np.concatenate([arr[np.newaxis] for arr in X_train]).astype('float32')

# test童颜的处理
X_test = [cv2.cvtColor(cv2.resize(i, (48, 48)), cv2.COLOR_GRAY2BGR) for i in
          X_test]
X_test = np.concatenate([arr[np.newaxis] for arr in X_test]).astype('float32')


# 数据归一化
X_train /= 256
X_test /= 256


def tran_y(y):
    y_ohe = np.zeros(10)
    y_ohe[y] = 1
    return y_ohe


# y 需要做one hot编码转化
y_train_ohe = np.array([tran_y(y_train[i]) for i in range(len(y_train))])
y_test_ohe = np.array([tran_y(y_test[i]) for i in range(len(y_test))])

# 训练模型
model_vgg_mnist.fit(X_train, y_train_ohe, validation_data=(X_test, y_test_ohe), epochs=100, batch_size=100)