Al realizar la clasificación de imágenes digitales escritas a mano, se puede suponer que el aprendizaje se ha completado y utilizamos los parámetros aprendidos para realizar el "procesamiento de razonamiento" de la red neuronal. Este proceso también se conoce como el paso hacia adelante de la red neuronal .
Al igual que los pasos para resolver problemas de aprendizaje automático (divididos en dos etapas de aprendizaje y razonamiento)
, al usar redes neuronales para resolver problemas, también es necesario usar primero datos de entrenamiento (datos de aprendizaje) para aprender parámetros de peso ; parámetros para clasificar el datos de entrada
Conjunto de datos MNIST
MNIST es uno de los conjuntos de datos más famosos en el aprendizaje automático. Se utiliza en varias ocasiones, desde experimentos simples hasta trabajos de investigación publicados. Al leer artículos sobre reconocimiento de imágenes o aprendizaje automático, el conjunto de datos MNIST se utiliza a menudo como un experimento aparecen los datos.
El conjunto de datos MINIST se compone de imágenes digitales del 0 al 9. El método para usar el conjunto de datos MNIST es usar primero la imagen de entrenamiento para el aprendizaje y luego usar el modelo aprendido para medir hasta qué punto la imagen de prueba puede ser correctamente clasificado _
Los datos de imagen de MNIST son una imagen en escala de grises (1 canal) de 28 píxeles x 28 píxeles, y el valor de cada píxel está entre 0 y 255. Cada dato de imagen se etiqueta en consecuencia con "7", "2", "1", etc.
Aquí, a través de la secuencia de comandos de Python mnist.py, desde la descarga del conjunto de datos MNIST hasta la conversión de estos datos en matrices NumPy, etc., utilizando la función load_mnist() en mnistpy, puede leer fácilmente los datos MNIST de la siguiente manera.
Tenga en cuenta que el mnist.py aquí no es universal y solo se puede usar en proyectos de aprendizaje para aprender y comprender (para obtener detalles, consulte el conocimiento en línea, que no se detallará aquí)
Python tiene la función de pickle , que puede guardar los objetos en el programa en ejecución como archivos.Si agrega el archivo pickle guardado, puede restaurar inmediatamente los objetos en el programa en ejecución. Usando la función pickle, la preparación de datos MINIST se puede completar de manera eficiente.pickle.load(f)
Ejemplo de reconocimiento de dígitos escritos a mano
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 为了导入父目录的文件而进行的设定
import numpy as np
from dataset.mnist import load_mnist
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)
# 输出各个数据的形状
print(x_train.shape) # (60000，784)
print(t_train.shape) # (60000,)
print(x test.shape) #(10000，784)
print(t_test.shape) # (10000,)
En el código anterior, el líder es la función load_mnist en dataset/mnist.py. La función load mnist devuelve los datos leídos de MNIST en forma de " (imagen de entrenamiento, etiqueta de entrenamiento), (imagen de prueba, etiqueta de prueba) ".
Entonces piensa load_mnist(normalize=True,flatten=True，one_hot_label=False)así , establece 3 parámetros.
normalize establece si normalizar la imagen de entrada a un valor de 0.0~1.0.
Flatten establece si expandir la imagen de entrada ( en una matriz unidimensional ). Si se establece en True, la imagen de entrada se guardará como una matriz unidimensional de 784 elementos.
one_hot_label establece si guardar la etiqueta como una representación one-hot. One-hot significa que solo la etiqueta de solución correcta es 1, y el resto son todos 0 arreglos, como [0,0,1,0,0,0,0,0,0,0]. Cuando one_hot_label es True, la etiqueta se guarda como una representación one-hot.
La imagen MINIST se muestra más tarde y los datos también se confirman. Las imágenes se crean utilizando el módulo PIL (Biblioteca de imágenes de Python). Después de ejecutar el siguiente código, se mostrará la primera imagen de entrenamiento
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 为了导入父目录的文件而进行的设定
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image
def img_show(img):
pil_img = Image.fromarray(np.uint8(img))
pil_img.show()
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)
img = x_train[0]
label = t_train[0]
print(label) # 5
print(img.shape) # (784,)
img = img.reshape(28, 28) # 把图像的形状变为原来的尺寸
print(img.shape) # (28, 28)
img_show(img)
Cabe señalar que cuando flatten=True, la imagen del lector se guarda en forma de columna (unidimensional) NumPy array. Por lo tanto, al mostrar la imagen, debe cambiarse a su forma original de 28 px x 28 px. La forma deseada se puede especificar a través del parámetro del método remodelar (). . Además, también es necesario convertir los datos de imagen guardados como una matriz NumPy en un objeto de datos para PIL, y este proceso de conversión Image.fromarray()se completa.
Procesamiento de inferencias de redes neuronales
Implemente el procesamiento de inferencias de redes neuronales en el conjunto de datos MNIST.
La capa de entrada de la red neuronal tiene 784 neuronas y la capa de salida tiene 10 neuronas.
El número 784 en la capa de entrada proviene del tamaño de imagen de 28x28=784, y
el número 10 en la capa de salida proviene de 10 categorías (números del 0 al 9, un total de 10 categorías).
Además, esta red neuronal tiene 2 capas ocultas , la primera capa oculta tiene 50 neuronas y la segunda capa oculta tiene 100 neuronas .
Primero defina las tres funciones get_data() , init_network() y predict()
def get data():
(x_train,t_train),(x_test,t_test) = load_mnist(normalize=True,flatten=True，one_hot_label=False)
return x_test, t_test
def init_network():
with open("sample_weight.pkl",'rb') as f:
network = pickle.load(f)
return netwrok
def predict(network, x):
W1，W2，w3 = network['W1'], network['W2'], network['w3']
bl，b2, b3 = network['b1']，network['b2']， network['b3']
a1 = np.dot(x,W1)+b1
z1 = sigmoid(a1)
a2 = np.dot(a1,W2) +b2
z2 = sigmoid(a2)
a3=np.dot(a2,W3)+b3
y = sigmoid(a3)
reutrn y
init_network() leerá los parámetros de peso aprendidos guardados en el archivo pickle sample_weight.pkl
Ahora, use estas tres funciones para implementar el procesamiento de inferencia de la red neuronal. Luego, evalúa su precisión de reconocimiento , es decir, hasta qué punto se puede clasificar correctamente.
# 获取数据
x, t = get_data()
# 初始化network
network =init_network()
accuracy_cnt =0
for i in range(len(x)):
y = predict(network，x[i]) # predict()函数以NumPy数组的形式输出各个标签对应的概率
p=np.argmax(y) # 获取概率最高的元素的索引
if p == t[i]:
accuracy_cnt += 1
print("Accuracy:" + str(float(accuracy_cnt) / len(x))) # 比较神经网络所测的答案和正确解标签，将回答正确的概率作为识别精度。
En la actualidad, la precisión de este código no es muy alta, y la estructura y el método de aprendizaje de la red neuronal se optimizarán en el futuro para mejorar esta precisión.
Establezca el parámetro normalize de la función load_mnist en True. Después de establecer normalizar en Verdadero, la función realizará la conversión interna y dividirá cada valor de píxel de la imagen por 255, de modo que el valor de los datos esté en el rango de 0.0~1.0. El proceso de limitar los datos a un cierto rango como este se llama normalización . Este tipo de transformación predeterminada de los datos de entrada de la red neuronal se denomina preprocesamiento .
El preprocesamiento es muy práctico en las redes neuronales (aprendizaje profundo). De hecho, una gran cantidad de preprocesamiento tendrá en cuenta la distribución general de los datos, por ejemplo, utilizando la media general o la desviación estándar de los datos para mover los datos de modo que la distribución general los datos se distribuyen alrededor de 0.