Reconocimiento de Números

Link del proyecto

La aplicación fue creada usando HTML, CSS y JavaScript. Principalmente, JavaScript se utilizó para implementar el modelo generado en Google Colab con Python. Esto permitió la creación del modelo con librerías como Tensorflow, Matplotlib, Math y NumPy.

Modelo:

Link del modelo en Google Colab

Pasos que se llevo acabo.

Los pasos para generar esta red neuronal fueron sencillos gracias a distintos datasets libres disponibles en TensorFlow, particularmente el conjunto de datos MNIST, el cual contiene 70,000 datos divididos en 60,000 para entrenamiento y 10,000 para pruebas.

#Descargar set de datos de MNIST (Numeros escritos a mano, etiquetados)
datos, metadatos = tfds.load('mnist', as_supervised=True, with_info=True)

Luego, se dividieron los datos para entrenamiento y pruebas:

#guardamos los datos para entrenamiento y para pruebas en distintas variables
datos_entrenamiento = datos['train']
datos_prueba = datos['test']

También se extrajeron los nombres de las clases utilizando los meta_datos:

nombres_clases = meta_datos.features["label"].names

Normalización

Para mejorar el rendimiento de los algoritmos, se normalizaron los datos de entrada. Se redujo el rango de colores de 0 a 255 (RGB) a 0 a 1 para facilitar el procesamiento y se aplicó codificación "one-hot".

#Normalizacion
#0 - 255 1 byte
#Transformar de 0-255 a 0-1 (0-0, 255 = 1, 127 = 0.5)

#Normalizar datos de entrenamiento y pruebas
def normalizar(imagenes, etiquetas):
  imagenes = tf.cast(imagenes, tf.float32)
  imagenes = imagenes/255
  return imagenes, etiquetas

datos_entrenamiento = datos_entrenamiento.map(normalizar)
datos_prueba = datos_prueba.map(normalizar)

#Agregar en Cache
datos_entrenamiento = datos_entrenamiento.cache()
datos_prueba = datos_prueba.cache()

Clasificación de imagenes

Se empleó Matplotlib para visualizar imágenes del conjunto de entrenamiento y analizar sus píxeles en una tabla de 5x5.

plt.figure(figsize=(20,20),)
for i, (imagen,etiqueta) in enumerate(datos_entrenamiento.take(25)):
  #mostrar en pantalla
  plt.subplot(5,5, i+1 )
  plt.imshow(imagen, cmap=plt.cm.binary)
  plt.colorbar()

plt.show()

Creación del modelo.

La red neuronal cuenta con una capa de entrada de 28x28 píxeles, dos capas ocultas con 50 neuronas cada una usando la función de activación ReLU, y una capa de salida con 10 neuronas utilizando la función SoftMax para clasificar los números del 0 al 9.

Breve explicación.

esta red funciona por matrices de 1's y 0's, por medio de como este formada la matriz la red analizara la forma en la que esten posicionados los 1's principalmente y dara un resultado. Ejmplo: este es se puede leer como numero 4

¿Porque?

unamos los 1's para observar que forma nos puede dar esta matriz:

este es un ejemplo mas visual de como funcionara nuestra red neuronal

Predicciones.

Para realizar predicciones, se utilizó el modelo entrenado con los datos de prueba de MNIST y se graficó la precisión de las predicciones con colores azules para coincidencias y rojos para desviaciones.

codigo de la predicción

import numpy as np
import matplotlib.pyplot as plt

# Iterando a través del conjunto de datos de prueba
for imagenes_prueba, etiquetas_prueba in datos_prueba.take(1):
    imagenes_prueba = imagenes_prueba.numpy()
    etiquetas_prueba = etiquetas_prueba.numpy()
    predicciones = modelo.predict(imagenes_prueba)

# Función para graficar una imagen con etiqueta real y predicción
def graficar_imagen(i, arr_predicciones, etiquetas_reales, imagenes):
    # Obteniendo los datos necesarios para graficar
    arr_predicciones, etiqueta_real, img = arr_predicciones[i], etiquetas_reales[i], imagenes[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])

    plt.imshow(img[...,0], cmap=plt.cm.binary) # Mostrando la imagen en el gráfico

    etiqueta_prediccion = np.argmax(arr_predicciones)
    # Verificando si la predicción fue correcta o incorrecta y asignando un color
    if etiqueta_prediccion == etiqueta_real:
        color = 'blue'  # Etiqueta azul para predicción correcta
    else:
        color = 'red'   # Etiqueta roja para predicción incorrecta

    # Mostrando la etiqueta de la predicción con el porcentaje de confianza
    plt.xlabel("{} {:2.0f}% ({})".format(nombres_clases[etiqueta_prediccion],
                                          100*np.max(arr_predicciones),
                                          nombres_clases[etiqueta_real]),
                                          color=color)

# Función para graficar los valores de predicción y resaltar etiquetas reales y predicciones
def graficar_valor_arreglo(i, arr_predicciones, etiqueta_real):
    arr_predicciones, etiqueta_real = arr_predicciones[i], etiqueta_real[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])
    grafica = plt.bar(range(10), arr_predicciones, color="#777777")
    plt.ylim([0, 1])
    etiqueta_prediccion = np.argmax(arr_predicciones)

    grafica[etiqueta_prediccion].set_color('red')   # Predicción en rojo
    grafica[etiqueta_real].set_color('blue')       # Etiqueta real en azul

# Configurando la cuadrícula para mostrar varias imágenes y sus predicciones
filas = 5
columnas = 5
num_imagenes = filas * columnas
plt.figure(figsize=(2*2*columnas, 2*filas))
for i in range(num_imagenes):
    plt.subplot(filas, 2*columnas, 2*i+1)
    graficar_imagen(i, predicciones, etiquetas_prueba, imagenes_prueba)
    plt.subplot(filas, 2*columnas, 2*i+2)
    graficar_valor_arreglo(i, predicciones, etiquetas_prueba)

# Mostrando la cuadrícula con las imágenes y sus predicciones resaltadas
plt.show()