Introducción a la inteligencia artificial: experimento de reconocimiento de patrones basado en redes neuronales

Experimento 3 Experimento de reconocimiento de patrones basado en redes neuronales

1. Propósito del experimento:

Comprenda la estructura y el principio de la red neuronal BP y la red neuronal convolucional, domine el proceso de entrenamiento del algoritmo de aprendizaje de retropropagación para neuronas y comprenda la fórmula de retropropagación. Mediante la creación de ejemplos de reconocimiento de patrones de redes neuronales BP y redes neuronales convolucionales, familiarícese con el principio, la estructura y el proceso de trabajo de las redes neuronales feedforward.

2. Principio experimental

El algoritmo de aprendizaje de BP minimiza el error a través del proceso de aprendizaje inverso. El proceso del algoritmo comienza desde el nodo de salida y propaga inversamente la corrección de peso causada por el error total a la primera capa oculta (es decir, la capa oculta más cercana a la capa de entrada) . . La red BP no solo contiene nodos de entrada y nodos de salida, sino que también contiene una o más capas de nodos ocultos (capa). La señal de entrada se transmite primero al nodo oculto, y luego la información de salida del nodo oculto se transmite al nodo de salida después de que se actúe sobre ella, y finalmente se proporciona el resultado de salida.

Las neuronas artificiales de la red neuronal convolucional pueden responder a las unidades circundantes dentro de una parte de la cobertura. La red neuronal convolucional consta de tres partes: la primera parte es la capa de entrada, la segunda parte consiste en una combinación de n capas convolucionales y capas de agrupación, y la tercera parte consiste en un clasificador de perceptrón multicapa completamente conectado. Esta estructura permite que las redes neuronales convolucionales aprovechen la estructura bidimensional de los datos de entrada. La red neuronal convolucional aprenderá automáticamente el mejor kernel de convolución y la combinación de estos kernels de convolución para una imagen, y luego emitirá un juicio.

3. Condiciones experimentales:

Instale de forma independiente Python 3.6 de 64 bits o superior, y bibliotecas de terceros como TensorFlow2.0 o superior, numpy, matplotlib, pylab, etc., cree una nueva carpeta de conjuntos de datos (C:\Users\A\.keras\datasets) , coloque mnist.npz en la carpeta de conjuntos de datos.

4. Contenido experimental:

1. Analice el conjunto de datos de Mnist, seleccione 55 000 muestras de entrenamiento, 5000 muestras de validación y 10 000 muestras de prueba, y establezca el tamaño del lote en 100.

2. Diseñe un modelo de estructura de red BP con 2 capas ocultas. La capa de salida adopta la función de pérdida de entropía cruzada después de la regresión sofmax. Establezca los parámetros como la tasa de aprendizaje, la cantidad de pasos de capacitación y la cantidad de lotes, y proporcione la capacitación y resultados de la prueba, respectivamente, complete la Tabla 1 a continuación. ( Nota: en la Tabla 1 a continuación , tanto el? como los espacios en blanco deben completarse )

Tabla 1 Parámetros y entrenamiento y resultados de prueba de la red BP

parámetro	número de capas ocultas	Función de activación de capa oculta	Número de neuronas en la capa oculta	algoritmo de aprendizaje	Resultados de entrenamiento (valor de pérdida de entrenamiento, tasa de precisión de verificación)	precisión de la prueba
Tamaño del lote: 100 Tasa de aprendizaje: 0.01 Tiempos de entrenamiento: 10 Número de neuronas de entrada: 512 Número de neuronas de salida: 10 Función de activación de salida: entropía cruzada después de la regresión sofmax	2	reanudar	La primera capa oculta: El número de neuronas es: 512 La cantidad del parámetro es: 401920 La segunda capa oculta: El número de neuronas es: 512 El número de parámetros es: 261656	Descenso de gradiente estocástico + método de momento: optimizadores.SGD(lr=0.01)	pérdida: 0.4541553258895874 Cuenta: 0.9074	Cuenta de prueba: 0.8866
				Algoritmo de Adagrad: optimizadores.Adagrad(lr=0.01)	pérdida: 0.0027855050284415483 Cuenta: 0.984	Cuenta de prueba: 0.9819
				Algoritmo Adam: optimizador=optimizadores.Adam(lr=0.01)	Pérdida: 0.17099925875663757 CAC=0.972	PRUEBA ACC=0.9636

3. Para un modelo de estructura de red BP con 4 capas ocultas (incluidas 512 neuronas), la función de activación de la capa oculta usa relu y el algoritmo de aprendizaje usa el algoritmo Adam. Diseñe y compare la precisión de diferentes modelos, y complete el entrenamiento y resultados de la prueba en la Tabla 2 a continuación. ( Nota: en la Tabla 2 a continuación , tanto el? como los espacios en blanco deben completarse )

Tabla 2 Entrenamiento de red BP y resultados de prueba con 4 capas ocultas

diferentes modelos

Resultados de entrenamiento (valor de pérdida de entrenamiento, tasa de precisión de verificación)

precisión de la prueba

Use una tasa de aprendizaje exponencialmente decreciente:

Tasa de aprendizaje inicial = 0,01

Coeficiente de atenuación = 0,96

Pasos de atenuación = 1000

pérdida: 0.0005220939638093114

Cuenta: 0.9766

Cuenta de prueba: 0.9776

Usando solo regularización, con una tasa de aprendizaje fija:

tasa de aprendizaje = 0.01

Factor de regularización = 0,001

pérdida: 0.17735381424427032

Cuenta: 0.971

Cuenta de prueba: 0.9676

Use la tasa de aprendizaje y la regularización exponencialmente decrecientes:

Factor de regularización = 0,001

Tasa de aprendizaje inicial = 0,01

Coeficiente de atenuación = 0,96

Pasos de atenuación = 1000

pérdida: 0.02895130217075348

Cuenta: 0.9806

Cuenta de prueba: 0.9793

Solo usando Dropout con una tasa de aprendizaje fija:

tasa de aprendizaje = 0.01

Tasa de desconexión de abandono = 0,5

pérdida: 0.1732

Cuenta: 0.967

Cuenta de prueba: 0.958

4. Para el conjunto de datos Mnist, seleccione 55 000 muestras de entrenamiento, 5000 muestras de validación y 10 000 muestras de prueba, y establezca el tamaño del lote en 100. Luego construya un modelo de red neuronal convolucional, complete los parámetros del modelo estructural de la red neuronal convolucional en la Tabla 3, use relu como la función de activación de capa oculta, seleccione el algoritmo de aprendizaje, establezca los parámetros y complete los resultados de entrenamiento y prueba de diferentes modelos en la siguiente tabla 4 . ( Nota: en la Tabla 3, complete los nombres de la capa de entrada, la capa convolucional, la capa de agrupación, la capa completamente conectada y la capa de salida; la red neuronal BP en la Tabla 4 usa 4 capas ocultas (cada capa contiene 512 neuronas, activación La función adopta el modelo de estructura de red de relu )

Tabla 3 Parámetros del modelo estructural de la red neuronal convolucional

	nombre	Número de neuronas	tamaño del filtro	Número de núcleos de convolución	Numero de pie	función de activación	Número de rellenos	tamaño del mapa de características de salida
Tier 1	Capa de convolución 1	62626	3*3	6	1	reanudar	0	26*26
capa 2	capa de agrupación 1	-	2*2	6	2	reanudar	0	13*13
capa 3	Capa de convolución 2	161111	3*3	dieciséis	1	reanudar	0	11*11
capa 4	capa de agrupación 2	-	2*2	dieciséis	2	reanudar	0	5*5
capa 5	Capa 1 completamente conectada	120	-	-	-	reanudar	0	-
Capa 6	Capa 2 completamente conectada	84	-	-	-	reanudar	0	-
Capa 7	Capa 3 completamente conectada	10	-	-	-	reanudar	0	-

Tabla 4 Resultados de entrenamiento y prueba de la red neuronal convolucional y la red neuronal BP

Algoritmo de aprendizaje y configuración de parámetros.

diferentes modelos

Resultados de entrenamiento (valor de pérdida de entrenamiento, tasa de precisión de verificación)

precisión de la prueba

La tasa de aprendizaje es 0.01

El algoritmo de aprendizaje es Adam.

Redes neuronales convolucionales usando regularización

(factor de regularización=0,001)

pérdida: 0.10340672731399536

Cuenta: 0.9824

Cuenta de prueba: 0.9799

Uso de la red neuronal BP regularizada

(factor de regularización=0,001)

pérdida: 0.17735381424427032

Cuenta: 0.971

Cuenta de prueba: 0.9676

五、实验报告要求：

1． 按照实验内容，给出相应结果。

2．分析比较不同学习算法对BP网络的训练结果、测试结果等的影响。

①随机梯度下降的算法是训练速度最快的，同时也是准确率最低的，训练结果和测试结果的准确率都不是很高。代价函数也最大，为0.4541553258895874，比其他两种算法都高很多，说明其模型拟合的不好。因为它是盲目搜索，是随机抽取的一个样本，信息少，容易跑偏。

②Adagrad算法性能是三种里面最好的，无论是训练效果还是测试效果都是准确率最高的，代价函数的值也是远远小于其他两种算法，可以从结果看Adagrad算法并没有发生严重的过拟合现象。

③Adam算法优化，也可以提高训练结果和测试结果的准确度，但没有Adagrad算法准确度高。

3. 分析比较使用指数衰减学习率、正则化和Drop层等不同模型对于训练结果、测试结果等的影响。

①使用指数衰减学习率提高了训练结果和测试结果的准确度，但提升的程度不明显，但是代价函数小了很多。

②使用正则化后，可以比较好的解决过拟合的问题，这边的loss值比不使用时大了一点，但是从准确度上来说模型拟合的性能并没有提高多少。

③使用droout层，也是和使用正则化一样的效果，它对于神经网络单元按照一定的概率将其暂时从网络中丢弃，从而提升训练效果，但是在本实验中不太明显，本实验是只在第3层加dropout层，如下：

network = Sequential([layers.Dense(512, activation='relu'),

layers.Dense(512, activation='relu'),

layers.Dropout(0.5),

layers.Dense(512, activation='relu'),

layers.Dense(10, activation='softmax')])

④使用指数衰减学习率和正则化结合的方法比只使用指数衰减学习率的loss值高，说明一定程度上减小了过拟合的效应，但是loss比值使用正则化的loss值高，提升了模型性能，训练结果和测试结果的准确度都提升了。

4. 总结BP网络和卷积神经网络在模式识别方面的异同点。

不同点：

①BP网络和卷积神经网络的计算方法不同：

BP神经网络是一种按照误差逆向传播算法训练的多层前馈神经网络

卷积神经网络则包含卷积计算且具有深度结构的前馈神经网络。

②卷积网络使用共享权值来减少网络各层之间的连接

③BP的网络结构：包括输入层，隐层和输出层。

卷积网络结构：输入层，卷积层，池化层，全连接层，输出层。

④BP采用全连接，卷积网络采用局部感知

相同点：

①BP神经网络和卷积神经网络都属于前馈神经网络，

②输入层都是输入图像，输出层都是多分类的结果。

③网络的中间层数、各层的神经元个数都可以根据具体情况任意设定，并且随着结构的差异其性能也有所不同。

④都采用了前向传播计算输出值，反向传播调整权重和偏置。

5. 实验心得。

①掌握了卷积层中输入大小和输出大小之间的计算关系：

输入：rxc，卷积核：axb，步长stride：s=1 输出：长=(r-a)/s+1 ，宽 =(c-b) )/s +1

②掌握了训练参数的计算

③掌握了BP和卷积网络的搭建和和优化算法的使用及训练和预测

代码（例：4层指数衰减）：

import  tensorflow as tf
from    tensorflow.keras import datasets, layers, optimizers, Sequential
import matplotlib.pyplot as plt
import numpy as np
import pylab

def preprocess(x, y):
    x = tf.cast(x, dtype=tf.float32) / 255.
    y = tf.cast(y, dtype=tf.int32)
    return x,y


(x, y), (x_test, y_test) = datasets.mnist.load_data()#下载或读取数据集
print('datasets:', x.shape, y.shape, x.min(), x.max())#打印

训练：

imgs = x_test[0:5]#选取第0到5的图片
labs = y_test[0:5]
#print(labs)
plot_imgs = np.hstack(imgs)#将五张图片拼接成一行
plt.imshow(plot_imgs, cmap='gray')#选择gray灰度图
#pylab.show()#显示测试图片


x_train,x_val=tf.split(x,num_or_size_splits=[55000,5000])
y_train,y_val=tf.split(y,num_or_size_splits=[55000,5000])

batchsz = 100#设置批量大小

db = tf.data.Dataset.from_tensor_slices((x_train,y_train))
db = db.map(preprocess).shuffle(55000).batch(batchsz).repeat(10)
db_test = tf.data.Dataset.from_tensor_slices((x_test,y_test))
db_test = db_test.map(preprocess).batch(batchsz)
ds_val = tf.data.Dataset.from_tensor_slices((x_val, y_val))
ds_val = ds_val.map(preprocess).batch(batchsz)

#构建网络模型
network = Sequential([layers.Dense(512, activation='relu'),
                      layers.Dense(512, activation='relu'),
                      layers.Dense(512, activation='relu'),
                      layers.Dense(512, activation='relu'),
                      layers.Dense(10,  activation='softmax')])
network.build(input_shape=(batchsz, 28*28))#批量大小
network.summary()                       #打印网络参数
# 设置优化器
exponential_decay=tf.keras.optimizers.schedules.ExponentialDecay(
          initial_learning_rate=0.01,decay_steps=1000,decay_rate=0.96)

optimizer=tf.keras.optimizers.Adam(exponential_decay)

#optimizer = optimizers.Adam(lr=0.01)    # 固定学习率的Adam学习算法，大块=快，会振荡
#optimizer = = optimizers.SGD(0.01, decay=1e-2)# 固定学习率的SGD学习算法

#分批进行训练
for echo in range(10):
    for step, (x,y) in enumerate(db):#从训练集读取一批样本数据
        with tf.GradientTape() as tape:#构建梯度训练环境
            # [b, 28, 28] => [b, 784]
            x = tf.reshape(x, (-1, 28*28))
            # [b, 784] => [b, 10]
            out = network(x,training=True)
            # [b] => [b, 10]
            y_onehot = tf.one_hot(y, depth=10)
            # [b]
            #计算交叉熵损失函数
            loss = tf.reduce_mean(tf.losses.categorical_crossentropy(y_onehot, out, from_logits=False))

        grads = tape.gradient(loss, network.trainable_variables)#计算梯度
        optimizer.apply_gradients(zip(grads, network.trainable_variables))#更新训练参数
        if step % 100 == 0:
            print('echo=',echo,' step=',step, 'loss:', float(loss))#打印训练的损失函数

        # 模型评价
        if step % 500 == 0:
            total, total_correct = 0., 0
            for i, (x, y) in enumerate(ds_val):
                # [b, 28, 28] => [b, 784]
                x = tf.reshape(x, (-1, 28*28))
                # [b, 784] => [b, 10]
                out = network(x)#神经网络模型输出
                # [b, 10] => [b]
                pred = tf.argmax(out, axis=1)
                pred = tf.cast(pred, dtype=tf.int32)
                # bool type
                correct = tf.equal(pred, y)
                # bool tensor => int tensor => numpy
                total_correct += tf.reduce_sum(tf.cast(correct, dtype=tf.int32)).numpy()
                total += x.shape[0]
            print(' step=',step, 'Evaluate Acc:', total_correct/total)#打印模型验证正确率

print("train is over")

#测试模型
total, total_correct = 0., 0
for i, (x, y) in enumerate(db_test):#读取一批测试数据
    # [b, 28, 28] => [b, 784]
    x = tf.reshape(x, (-1, 28*28))
    # [b, 784] => [b, 10]
    out = network(x)#神经网络模型输出
    # [b, 10] => [b]
    pred = tf.argmax(out, axis=1)
    pred = tf.cast(pred, dtype=tf.int32)
    # bool type
    correct = tf.equal(pred, y)
    # bool tensor => int tensor => numpy
    btestacc=tf.reduce_sum(tf.cast(correct, dtype=tf.int32)).numpy()
    total_correct += btestacc
    total += x.shape[0]
    #print('第',i,'批','test acc=',btestacc/x.shape[0])
    #print(y)
    #print(pred)
print('Test Acc:', total_correct/total)

训练结果：

Introducción a la inteligencia artificial: experimento de reconocimiento de patrones basado en redes neuronales

Supongo que te gusta