Las redes neuronales son un concepto importante en los campos de la inteligencia artificial y el aprendizaje automático. Consisten en nodos interconectados, organizados en capas e imitan cómo funciona el cerebro humano. Los nodos representan las neuronas del cerebro humano.
Puede crear su propia red neuronal de clasificación multiclase de avance simple. Entrénelo para clasificar dígitos escritos a mano utilizando el conjunto de datos MNIST. Luego puede usar la visión por computadora para clasificar sus propios dígitos escritos a mano.
¿Qué es la clasificación multiclase?
La clasificación multiclase es un tipo de aprendizaje automático que puede clasificar datos en más de dos categorías. Las redes neuronales utilizan el clasificador softmax para distribuir la probabilidad entre las clases posibles.
Puede utilizar la clasificación multiclase para clasificar imágenes manuscritas del conjunto de datos MNIST en 10 categorías. Estas categorías corresponderán a los dígitos del 0 al 9.
Comprender el conjunto de datos MNIST
El conjunto de datos MNIST es un conjunto de datos de referencia popular para el aprendizaje automático y los algoritmos de visión por computadora. Contiene 70.000 imágenes escritas a mano en escala de grises que tienen un tamaño de 28 por 28 píxeles. Los dígitos escritos a mano están en el rango de 0 a 9.
Antes de construir cualquier modelo de aprendizaje automático, es importante comprender qué contiene su conjunto de datos. Comprender el conjunto de datos le permitirá realizar un mejor preprocesamiento de datos.
Preparación de su entorno
Para seguir este tutorial, debe estar familiarizado con el fundamentos de python. También debe tener un conocimientos básicos de aprendizaje automático. Finalmente, debe sentirse cómodo usando Jupyter Notebook o Google Colab.
El código fuente completo está disponible en un repositorio GitHub.
Cree un nuevo Jupyter Notebook o inicie sesión en Colaboración de Google. Ejecute este comando para instalar los paquetes necesarios:
pip instalar numpy matplotlib tensorflow opencv-python
Usarás:
- Matplotlib para visualización de datos.
- NumPy para manipular matrices.
- TensorFlow para crear y entrenar tu modelo.
- OpenCV para alimentar el modelo con sus propios dígitos escritos a mano.
Importación de los módulos necesarios
Importe los paquetes que instaló en su entorno. Esto le permitirá llamar más tarde y usar sus funciones y módulos en su código.
importar tensorflow como t.f.
de tensorflow importar queras
importar matplotlib.pyplot como por favor
% matplotlib en línea
importar entumecido como notario público
importar cv2La segunda línea de código importa el módulo Keras desde el Biblioteca Google TensorFlow. Utilizará Keras para entrenar su red neuronal profunda con TensorFlow como backend.
Cargar y ver el conjunto de datos
El conjunto de datos MNIST está integrado en Keras. Cargue el conjunto de datos MNIST y divídalo en conjuntos de entrenamiento y prueba. Utilizará el conjunto de entrenamiento para entrenar su modelo y el conjunto de prueba para evaluar la precisión de su modelo en la clasificación de nuevas imágenes no vistas.
(X_tren, y_tren), (X_prueba, y_prueba) = keras.datasets.mnist.load_data()
Compruebe la duración de los conjuntos de entrenamiento y prueba. El conjunto de datos MNIST tiene 60 000 imágenes para entrenamiento y 10 000 imágenes para prueba.
len (X_tren)
len (X_prueba)Verifique la forma de la primera imagen en el conjunto de datos MNIST, que debe tener 28 por 28 píxeles. Luego imprima sus valores de píxel y visualícelo usando Matplotlib.
X_tren[0].forma
X_tren[0]
plt.matshow (X_tren[0])
y_tren[0]El resultado de la visualización es el siguiente:
La imagen visualizada muestra que la primera imagen del conjunto de datos contiene el número cinco.
Preprocesamiento de datos
Antes de usar los datos del conjunto de datos para entrenar y probar su modelo, debe preprocesarlo. El preprocesamiento mejora la precisión de un modelo al estandarizar los datos.
Normalización de los valores de píxeles
Normalice los valores de píxeles de las imágenes en el conjunto de datos dividiendo cada valor por 255. Los valores de píxel del conjunto de datos no normalizados oscilan entre 0 y 255, siendo cero negro y 255 blanco. Dividir cada valor de píxel por 255 asegura que cada píxel esté en el rango entre 0 y 1. Esto facilita que el modelo aprenda las características y patrones relevantes en los datos.
Tren_X = Tren_X / 255
X_prueba = X_prueba / 255Luego imprima los valores de píxeles de la primera imagen.
X_tren[0]Observe que ahora están en el rango entre 0 y 1.
Convertir las matrices de imagen en una matriz 1D
La capa de entrada de la red neuronal generalmente espera entradas 1D, así que cree una matriz 1D de los valores de píxeles de la imagen. Para hacerlo, use la función reformar() con el número de imágenes sin procesar establecido en el número de imágenes en el conjunto de datos.
X_tren_aplanado = X_tren.reformar (len (X_tren), 28 * 28)
X_test_flattened = X_test.reshape (len (X_test), 28 * 28)
X_train_flattened.shape
Tren_X_aplanado[0]
Sus imágenes ahora están listas para entrenar y probar el modelo.
Creación del modelo de red neuronal profunda
Cree un modelo secuencial con el módulo Keras de Tensorflow usando una capa de entrada, dos capas ocultas y una capa de salida. Establezca la forma de entrada en 28 por 28, ya que esta es la forma de las imágenes originales en el conjunto de datos. Utilice 128 nodos para las capas ocultas. La capa de salida debe tener solo 10 neuronas, ya que solo está clasificando los dígitos del 0 al 9.
modelo = keras. Secuencial([
keras.layers. Aplanar (input_shape=(28, 28)),keras.layers. Denso(128, activación='relú'),
keras.layers. Denso(128, activación='relú'),
keras.layers. Denso(10, activación='softmax')
])
Compilar el modelo usando el Adán optimizador, sparse_categorical_crossentropy como la función de pérdida, y la métrica para evaluar el desempeño del modelo como exactitud. Luego ajuste los datos de entrenamiento en el modelo y establezca el número de épocas en cinco.
model.compile (optimizador='Adán',
pérdida ='esparse_categorical_crossentropy',
métricas=['exactitud'])
modelo.ajuste (tren_X, tren_y, épocas=5)
El modelo tardará unos minutos en entrenar. Una vez finalizado el entrenamiento del modelo, evalúe su rendimiento en el conjunto de prueba.
modelo.evaluar (X_test, y_test)
La función de evaluación devolverá la pérdida y la precisión del modelo. El modelo produce una precisión del 98%.
Uso del modelo para clasificar sus propios dígitos escritos a mano
Para clasificar sus propios dígitos escritos a mano, debe preparar sus imágenes para que coincidan con las del conjunto de datos MNIST. Si no lo hace, su modelo tendrá un rendimiento deficiente.
Para preprocesar las imágenes:
- Cargue la imagen que contiene el dígito usando OpenCV.
- Conviértalo a escala de grises y cambie su tamaño a 28 por 28 píxeles.
- Voltear y normalizar los valores de píxel.
- Finalmente, aplane la imagen en una matriz 1D.
Pase la imagen preprocesada al modelo para la predicción e imprima el valor predicho en la pantalla.
img = cv2.imread('dígitos/dígito1.png', cv2.IMREAD_ESCALA DE GRISES)
img_resize = cv2.resize (img, (28, 28))
img_flip = cv2.bitwise_not (img_resize)
img_normalizado = img_flip.astype('flotador32') / 255.0# Aplana la imagen en una matriz 1D
input_data = img_normalized.flatten().reshape( 1,28,28)
# Haz una predicción usando el modelo
predicción = modelo.predecir (input_data)
imprimir (f'Predicción: {np.argmax (predicción)}')
Pasar una imagen preprocesada que contiene un número al modelo.
La salida del modelo es la siguiente:
El modelo fue capaz de clasificar correctamente el dígito siete.
Redes neuronales en chatbots
El uso de las redes neuronales se ha disparado en los últimos años. Se han utilizado predominantemente en el procesamiento del lenguaje natural para la traducción de idiomas y la IA generativa.
Más recientemente, ha habido un aumento en la cantidad de chatbots que pueden comunicarse de manera similar a los humanos. Utilizan un tipo de red neuronal conocida como red neuronal transformadora. Interactúa con algunos de ellos y experimenta el poder de las redes neuronales.