[ALEXNET] [keras] Reconocimiento de números escritos a mano

Configuración del entorno

Python 3.6
tensorflow 1.13.1
hard 2.2.4

pip install tensorflow==1.13.1
pip install keras==2.2.4

Progreso del programa

Leer en conjunto de datos escritos a mano

import keras
from keras.datasets import mnist

(X_train, Y_train), (X_test, Y_test) = mnist.load_data()

El conjunto de datos escritos a mano se encuentra en el paquete keras . En este momento, el programa descarga automáticamente los datos del sitio web oficial; el
conjunto de datos escritos a mano:

ver X, Y en el siguiente formato:

X_train contiene una imagen: la

etiqueta correspondiente Y_train es un número entero, que representa la imagen ¿Cuál es el número?

Organizar los datos de entrada en un formato aceptable para el modelo.

X_train = X_train.reshape(60000, 28, 28, 1)
X_test = X_test.reshape(10000, 28, 28, 1)

Los primeros datos de imagen del conjunto de entrenamiento parecen ser 5. (tenga en cuenta que el último parámetro debe escribirse como 0, intentado ":" no funciona)

Los datos del conjunto de prueba son similares, la primera imagen de prueba:

ver el convertido formato:

es solo una dimensión adicional

Verifique el rango de los datos de la imagen de entrada: el

valor está entre 0 y 255, lo siguiente se convierte entre 0 y 1, para la normalización:

X_train = X_train / 255
X_test = X_test / 255

Un código en caliente de los datos de salida

En pocas palabras, se utiliza una matriz dispersa para representar los resultados de la predicción. Hay n tipos de resultados de clasificación y la matriz tiene n columnas. La j-ésima columna es 1, lo que significa que el j-ésimo tipo de resultado de predicción es el más probable.

Y_train = keras.utils.to_categorical(Y_train, 10)
Y_test = keras.utils.to_categorical(Y_test, 10)

Comprueba el formato: de

hecho es más ancho.
Verifique la etiqueta 101 y observe los datos de la imagen:

hay 10 categorías, 0, 1, 2,…, 9, donde la séptima columna es 1, lo que significa que el resultado es 6, que realmente parece 6.

Construir un modelo

model = Sequential() # 空模型

model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1))) 
model.add(Activation("relu"))
model.add(Conv2D(32, (3, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Conv2D(64, (3, 3)))
model.add(Activation("relu"))
model.add(Conv2D(64, (3, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Flatten()) # 展开成一维
model.add(Dense(200))
model.add(Activation("relu"))

model.add(Dense(200))
model.add(Activation("relu"))

model.add(Dense(10, activation="softmax"))

Breve explicacion:

model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1))) 

El primer parámetro de Conv2D 32 significa que el resultado final es 32 capas ( $metro\ast norte\ast 3$ ->${metro}^{\prime }\ast {norte}^{\prime }\ast 32$ ) El
segundo parámetro (3, 3) representa el tamaño del operador de convolución;
input_shape es el formato de los datos de entrada

model.add(Dense(200))

Superposición de 200 capas de red neuronal (parece ser el tipo más común, o capa oculta ... no lo entiendo mucho)

Ver información del modelo: (ignore el número entre paréntesis que representa el proceso en ejecución)

Definir el optimizador del modelo.

adam = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
model.compile(loss="categorical_crossentropy", optimizer=adam, metrics=["accuracy"])

Elija el optimizador de Adam e introduzca el parámetro $B_1$, $B_2$, $\epsilon$ , tome un valor de uso común, lr es la tasa de aprendizaje, establecido en 0.001, la
función de pérdida usa entropía cruzada y la fórmula de cálculo para medir la precisión del rendimiento del modelo es precisión

Modelo de entrenamiento

model.fit(X_train, Y_train, batch_size=100, epochs=1, verbose=1, validation_data=[X_test, Y_test])

En el entrenamiento por lotes, los datos se dividen en 100 partes y solo se entrenan una vez (las épocas es el número de iteraciones). No está claro qué es detallado. . .

¡Rugido, ventilador eléctrico!

Ingrese una imagen para hacer una predicción

Primero mire la tercera imagen del conjunto de prueba: (esta imagen es la que ha visto antes)

impresión, el resultado predicho es el número 1, que es consistente con la etiqueta de datos. La

salida es una lista que registra la posibilidad de cada resultado de clasificación, necesitamos extraer manualmente el resultado más grande posible como nuestro resultado de predicción final.
Aquí la función np.round () es mantener varios lugares decimales, el primer parámetro son los datos de entrada, el segundo parámetro es mantener varios lugares decimales, el valor predeterminado es 1 dígito

El .reshape anterior (1, 28, 28, 1) es necesario, porque otros métodos están reportando errores. . .
(1)


(2) A


mi entender, como el último parámetro, si es 0, es decir, si solo hay una capa, entonces se considera que no existe tal dimensión (ver (1)), solo para tomar todas , use el símbolo ":", Se considera que tienen esta dimensión, pero parecen ser los mismos en mi opinión.
Por tanto, el primer parámetro solo utiliza un número, y se considera que no existe tal dimensión para reportar un error.
Esto también debería demostrar por qué cuando la información de la imagen se mostró antes, el último parámetro con el símbolo ":" para tomarlo todo reportará un error, porque esto se considerará como una dimensión más que la imagen.

Almacenamiento de modelos

Accede principalmente a una serie de parámetros obtenidos del entrenamiento:

model.save("model/My_Alexnet_mnist.h5")
# 这里我之前手动创建了文件夹 model, 如果没有的话，应该会报文件不存在的错

Guarde en el archivo .h5 en la carpeta del modelo en el directorio principal del archivo de programa

Carga del modelo

from keras.models import load_model
model = load_model("model/My_Alexnet_mnist.h5")

¡Vuelve el modelo original!

¡No hay necesidad de preocuparse por volver a ejecutar después de apagar la computadora!

Código fuente completo

Sin salida innecesaria;

# 完整版
import numpy as np
import matplotlib.pyplot as plt
import keras

from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Activation
from keras.layers import Conv2D, MaxPooling2D
#from keras import backend as K

# 手写数据集读入
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()

# 把输入数据整理成模型可以接受的格式
X_train = X_train.reshape(60000, 28, 28, 1)
X_test = X_test.reshape(10000, 28, 28, 1)

# 进行归一化处理
X_train = X_train / 255
X_test = X_test / 255

# 对于输出进行 one-hot-codeing
Y_train = keras.utils.to_categorical(Y_train, 10)
Y_test = keras.utils.to_categorical(Y_test, 10)

# 搭建模型
model = Sequential()

model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1)))
model.add(Activation("relu"))
model.add(Conv2D(32, (3, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Conv2D(64, (3, 3)))
model.add(Activation("relu"))
model.add(Conv2D(64, (3, 3)))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2,2)))

model.add(Flatten()) # 展开成一维
model.add(Dense(200))
model.add(Activation("relu"))

model.add(Dense(200))
model.add(Activation("relu"))

model.add(Dense(10, activation="softmax"))

# 定义模型的优化器
adam = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
model.compile(loss="categorical_crossentropy", optimizer=adam, metrics=["accuracy"])

# 训练模型
model.fit(X_train, Y_train, batch_size=100, epochs=1, verbose=1, validation_data=[X_test, Y_test])

# 模型预测
test_index = 2
plt.imshow(X_test[test_index, :, :, 0])
output = model.predict(X_test[test_index, :, :, :].reshape(1, 28, 28, 1))

print("predicted output: ", np.round(output))
print("the label is: ", Y_test[test_index])

# 模型的存储
model.save("model/My_Alexnet_mnist.h5")

# 载入训练完成的模型
# from keras.models import load_model
# model = load_model("model/My_Alexnet_mnist.h5")
model.summary()