Reconocimiento de escritura a mano basado en red neuronal convolucional (construir red neuronal desde cero)

1. Aprendiendo a usar la biblioteca de aprendizaje profundo - Keras

1.1 Introducción a Keras : es una biblioteca de red neuronal artificial de código abierto escrita en Python. Se puede usar como una interfaz de programa de aplicación de alto nivel para Tensorflow, Microsoft-CNTK y Theano para diseñar, depurar, evaluar, aplicar y visualizar el aprendizaje profundo. Modelos Es compatible con CPU y GPU.

1.2 Instalación de Keras:

1.2.1 Método de instalación

Método 1 : instalar en la terminal de su propio entorno

Antes de instalar Keras, debe instalar numpy, matplotlib, scipy, tensoflow

paso:

pip install numpy
pip install matplotlib
pip install scipy
pip install tensorflow
pip install keras

Método 2 : instalar en el aviso de anaconda

paso:

pip install --upgrade --ignore-installed tensorflow
pip install keras

1.2.2 Si la prueba es exitosa

Ingrese python en la línea de comando, ingrese al entorno de python e ingrese lo siguiente

import numpy
import matplotlib
import tensorflow as tf
import keras

Si no se informa ningún error, la instalación está completa

2. Capa de red de Keras

2.1 Las capas de Keras incluyen principalmente: capa común (Core), capa convolucional (Convolucional), capa de agrupación (Pooling), capa de conexión local , capa recurrente (Recurrent), capa de incrustación (Embedding), capa de activación avanzada , capa de especificación , Ruido capas , capas de envoltura y, por supuesto, escribir las suyas propias

2.2 Las principales operaciones de la capa

layer.get_weights() #获得每一层的权重
layer.set wetights(weights)#把这一层的权重加载到这一层
config = layer.get config()#保存该层的配置
layer.input#输入张量
layer.output#输出张量
layer.input shape#输入数据的形状
layer.output shape#输出数据的形状

2.3 Capas utilizadas en este proyecto

2.3.1 Capa de convolución bidimensional

2.3.2 Capa completamente conectada

2.3.3 Capa de activación

3. Construyendo ideas

3.1 El modelo Secuencial tiene principalmente dos métodos de construcción

3.1.1 construcción de listas:

from keras.mDenseodel import Sequential
from keras.layers import Dense, Activation
layer = [ Dense(64, input_shape = (784, ) ),
          Activation('relu'),
          Dense(10),
          Activation('softmax']
model = Sequential(layer)

Explicación detallada de los parámetros densos

Dense(
        inputs,#输入一个二维tensor
        units,#输入神经网络中的结点数
        activation = None,#输入激活函数
                          #主要的激活函数有relu，softmax，sigmoid linear等
        use_bias = True,#是否适用偏置向量
        kernel_initializer = None,#权重矩阵的初始化函数
        bias_constraint = None,#偏置项的初始化函数
        kernel_regualrizer = None,#权重矩阵的正则化函数
        bias_regularizer = None,#偏置项的正则化函数
        activity_regularizer = None,#输出的正则化函数
        trainable = None,#如果为Ture将变量添加到图集合GraphKeys.TRAINABLE_VARIABLES中。
        name = None,#层的名称
        reuse = None,#是否重复使用参数

)

Explicación detallada de los parámetros Cov2d:

Conv2D(
        filters,#输出空间的维度
        kernel_size,#卷积核的大小
        strides=(1, 1),#沿高度和宽度卷积的步长
        padding="valid",#卷积会导致输出图像越来越小，图像边界信息丢失，若想保持卷积后的图像大小不变，需要设置padding参数为same
        data_format=None,#输入维度的顺序，默认为channels——last
        dilation_rate=(1, 1),#用于扩展卷积的扩展率
        groups=1,#
        activation=None,#激活函数
        use_bias=True,#是否有bias单元
        kernel_initializer="glorot_uniform",#默认是GlorotUniform ，通过输入和输出单元个数来推演权重矩阵尺寸 
        bias_initializer="zeros",#kernel bias单元的初始化器，默认是0
        kernel_regularizer=None,
        bias_regularizer=None,
        activity_regularizer=None,
        kernel_constraint=None,
        bias_constraint=None
)

3.1.2 añadir ( ) construcción:

#向Sequential逐层加入layer
from keras.models import Sequential
from keras.layers import Dense, Activation
 
model = Sequential() # 定义模型
model.add(Dense(units=64, activation='relu', input_dim=100)) # 定义网络结构
model.add(Dense(units=10, activation='softmax')) # 定义网络结构
model.compile(loss='categorical_crossentropy', # 定义loss函数、优化方法、评估标准
              optimizer='sgd',
              metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5, batch_size=32) # 训练模型
loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128) # 评估模型

3.2 Construcción del modelo:

from keras.layers import Input, Dense
from keras.models import Model
 
# 输入层，确定输入维度
input = Input(shape = (784, ))
# 2个隐含层，每个都有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.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(data, labels)

4. Conjunto de datos MNIST

3.1 Dirección de descarga del conjunto de datos: http://yann.lecun.com/exdb/mnist/

3.2 Contenido del conjunto de datos

   

Muestra del conjunto de entrenamiento: train-images-idx3-ubyte.gz : imágenes del conjunto de entrenamiento (9912422 bytes)
Etiqueta del conjunto de entrenamiento: train-labels-idx1-ubyte.gz : etiquetas del conjunto de entrenamiento (28881 bytes)
Muestra del conjunto de prueba: t10k-images- idx3-ubyte.gz : imágenes del conjunto de prueba (1648877 bytes)
etiquetas del conjunto de prueba: t10k-labels-idx1-ubyte.gz : etiquetas del conjunto de prueba (4542 bytes)

4. Implementación del código

4.1 Lectura del conjunto de datos (se omite escribir en MNIST.py)

4.2 Importar bibliotecas requeridas

import numpy as np
import MNIST
from keras.models import Sequential
from keras.layers import Dense, Activation, Flatten
from keras.layers import Conv2D, AveragePooling2D

4.3 Definir los parámetros necesarios para las capas de entrenamiento y red

batch_size = 16 #批量处理的数据数量
nb_classes = 10 #分类的数目
epochs = 10 #迭代次数
img_rows, img_cols = 28, 28
nb_filters = 32 #卷积核的个数
pool_size = (2, 2) #池化层的大小
kernel_size = (5, 5) #卷积核的大小
input_shape = (img_cols, img_cols) #输入的图片维度

4.4 Conjunto de entrenamiento de carga

x_train, y_train = MNIST.get_training_data_set(6000, False)

4.5 Normalización de datos

x_train = np.array(x_train).astype(bool).astype(float)/255
y_train = np.array(y_train)

4.6 Agregar una dimensión

x_train = x_train[:, :, :, np.newaxis]#样本个数， 宽度， 高度， 通道数

4.7 Construcción del modelo

#模型建立
model = Sequential()
model.add(Conv2D(6, kernel_size, input_shape = input_shape, ))#卷积层
model.add(AveragePooling2D(pool_size = pool_size, strides = 2))#针对2D输入的平均池化层
#平均池化：前向传播卷积取平均，能够很好保留背景，但容易使图片模糊，反向传播取平均分配给每个位置
model.add(Conv2D(12, kernel_size, strides = 2))#卷积层
model.add(AveragePooling2D(pool_size = pool_size, strides = 2))#池化层
model.add(Flatten(0))#拉成一维的数据
model.add(Dense(nb_classes))
model.add(Activation("softmax"))

La selección de la capa de agrupación es la siguiente:

1. Agrupación media (mean-pooling)

2. Agrupación máxima (max-pooling)

3. Agrupación estocástica

4. Agrupación media global

4.8 Compilación del modelo

model.compile(loss = 'categorical crossentropy', optimizer = 'sgd', metrics = ['acccuracy'])

4.9 Preservación de la formación y evaluación del modelo

#模型的训练
model.fit(x_train, y_train, batch_size = batch_size, epochs = epochs)
#模型的评估
score = model.evaluate(x_train, y_train, verbose = 1)#返回loss value以及metrics value
print('Train score:', score[0])
print('Train accuracy:', score[1])
#模型的保存
model.save('cnn_model.h5')