Escribe tu primer proyecto de IA en 15 min

En este tutorial, codificaremos un proyecto de IA con TensorFlow y Keras que puede reconocer los dígitos escritos a mano. Si es tu primera vez con el aprendizaje automático y no tienes ni idea de lo que es TensorFlow, no te preocupes, haré todo lo posible para mantener las cosas simples. Y aún no tienes que entender todo con todo detalle, publicaré muchos tutoriales y proyectos sobre aprendizaje automático e inteligencia artificial que harán que las cosas sean comprensibles un tutorial a la vez.

Por ahora, debes saber que TensorFlow es una herramienta de aprendizaje automático muy popular. Al aprovechar TensorFlow, podemos ponernos en marcha con el aprendizaje automático en 15 minutos.

En este tutorial haremos todo en Google Colab, que viene preinstalado con todas las herramientas principales para crear modelos de aprendizaje automático. Lo que esto significa para ti es que puedes ir al sitio web de Google Colab y empezar a codificar tu primera red neuronal en cuestión de minutos, sin instalar nada en tu ordenador. Para empezar, puedes seguir el siguiente enlace y hacer clic en “nuevo cuaderno”:

Importar las bibliotecas necesarias

Lo primero es lo primero, vamos a importar las bibliotecas necesarias. Importaremos dos bibliotecas para este tutorial. La primera es TensorFlow, que es la principal biblioteca que utilizaremos. Importaremos tensorflow como tf, lo que significa que, para que podamos usar tensorflow en nuestro código, no tendremos que escribir “tensorflow” cada vez, sino que simplemente usaremos el alias de “tf”. Esta es la forma predeterminada de importar el flujo de tensor. También importaremos matplotlib, que es una biblioteca de visualización de datos muy popular.

# importar las bibliotecas necesariasimportar tensorflow como tfimportar matplotlib.pyplot como plt

Cargar y dividir los datos

El siguiente paso es obtener los datos con los que vamos a trabajar y dividirlos en conjuntos de datos de entrenamiento y pruebas. El conjunto de entrenamiento es la parte de los datos en la que entrenaremos nuestra red neuronal. Una vez completada la formación, probaremos su rendimiento en el conjunto de datos de la prueba. En ambos conjuntos de datos, tendremos dos cosas, las imágenes reales de los dígitos escritos a mano y las etiquetas correspondientes para ese dígito.

# cargar los datos y dividirlos en el conjunto de entrenamiento y el conjunto de pruebas(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()

El siguiente paso es reducir los valores de píxeles de las imágenes de 0 a 255 rango a rango 0-1. Las redes neuronales funcionan mucho mejor con números cercanos a cero. Uno de los rangos más comunes para convertir es de 0 a 1.

# reducir el valor de los píxeles de la imagen de 0-255 a 0-1train_images = train_images / 255.0test_images = test_images / 255.0

https://colab.research.google.com/

Visualizar los datos

Antes de seguir adelante y crear nuestra red neuronal, veamos cómo son nuestros datos. Mostremos también la primera imagen del conjunto de datos de entrenamiento.

# visualizar los datosprint(train_images.shape)print(test_images.shape)print(train_labels)
plt.imshow(train_images[0], cmap='gris')plt.show()

Ejecutar esta celda de código debería darte algo como esto:

(60000, 28, 28)
(10000, 28, 28)
[5 0 4 … 5 6 8]

Lo que nos dice esta salida es que tenemos 60 000 imágenes en el conjunto de entrenamiento que son en escala de grises y son de 28 x 28 píxeles. Si estuviéramos trabajando con imágenes en color, la forma de nuestras imágenes de entrenamiento se vería así: (60000, 28, 28, 3). Los 3 aquí habrían venido de 3 canales de color (muy probablemente: rojo, verde, azul) que habríamos necesitado para representar la imagen.

Definir el modelo de aprendizaje automático

La creación de un modelo de aprendizaje automático consta de dos pasos. Primero, definiremos el modelo y, a continuación, compilaremos el modelo. Así que empecemos por definir el modelo.

# definir el modelomy_model = tf.keras.models.Sequential()my_model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))my_model.add(tf.keras.layers.Dense(128, activation='relu'))my_model.add(tf.keras.layers.Dense(10, activation='softmax'))

Ahora examinemos lo que hicimos en el código anterior. Hay 3 formas de crear nuestro modelo y hoy estamos utilizando la más amigable para principiantes, que es el modelo “Secuencial”. Una vez que hayamos definido que utilizaremos el modelo secuencial, estamos creando nuestro modelo de red neuronal apilando las capas de red neuronal secuencialmente, como se puede ver anteriormente.

La primera capa es la capa “Flatten”, que obtendrá las imágenes cuadradas de 28 x 28 y las aplanará en 1×784 píxeles. Este paso es necesario, ya que la capa “Densa” que utilizaremos en la siguiente capa no puede funcionar con imágenes cuadradas, pero puede funcionar con la única línea de píxeles a la vez. En otros tutoriales, veremos otros tipos de capas de red neuronal que también pueden trabajar directamente con imágenes cuadradas.

En la siguiente capa, estamos creando una capa “Densa” con 128 neuronas. El nombre “Dense” proviene de su tipo de conexión, porque cada neurona está conectada a todas las demás neuronas de la siguiente capa. Esto hace que la red esté muy densamente conectada. Este es el tipo más sencillo de capa de red neuronal. También le daremos la función de activación de “relu”, que es un nombre abreviado para “unidad lineal ectificada”. Esta es una de las funciones de activación más populares debido a su eficiencia y eficacia.

Entonces estamos creando la última capa. Al crear la última capa, es muy crucial que el número de neuronas coincida con el número de clasificaciones que tienes. En este caso, estamos usando 10 neuronas porque tenemos clases entre 0 y 9. También le daremos una función de activación de “softmax” porque la función softmax convierte sus entradas en un rango probabilístico que podemos interpretar. Como resultado, si mostramos al modelo una imagen de un 8, si el modelo piensa que está un 91 por ciento seguro de que es un 8, simplemente obtendríamos 0,91 de la neurona que representa el número 8.

Compilar el modelo

El siguiente paso es compilar el modelo. Al compilar el modelo, utilizaremos uno de los optimizadores y funciones de pérdida más populares. La razón principal por la que son tan populares actualmente se debe a su eficiencia y eficacia computacional. Como optimizador, utilizaremos el “adam optimizer”, que se puede escribir como “adam”. También tenemos que definir una función de pérdida, porque estamos haciendo una clasificación multiclase, utilizaremos la función de “interestropía categórica dispersa”. Esta función es muy útil cuando clasificamos más de 2 clases. Luego, para hacer un seguimiento de la precisión del modelo, vamos a utilizar las métricas.

# compilar el modelomy_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

Entrenar al modelo

El siguiente paso es entrenar al modelo. Hasta ahora, nuestro modelo nunca había visto los datos antes. En el paso de formación, entrenaremos el modelo de red neuronal con las imágenes de los dígitos escritos a mano, así como las etiquetas correspondientes para esas imágenes. Tenemos 60 000 imágenes de entrenamiento y las mostraremos 3 veces a nuestra modelo. Para comunicar eso, introduciremos el valor de “epochs” como 3. A medida que entrenemos el modelo para más épocas, la precisión de nuestro modelo aumentará hasta cierto punto. Por lo tanto, queremos empezar con un pequeño número de épocas. Siempre podemos entrenar al modelo para más épocas.

# entrenar al modelomy_model.fit(train_images, train_labels, epochs=3)

Ejecutar este código debería dar un resultado como este:

Época 1/3 1875/1875 [==================================] — 4s 2ms/paso — pérdida: 0.4357 — precisión: 0.8756

Época 2/3 1875/1875 [==================================] — 3s 2ms/paso — pérdida: 0,178 — precisión: 0,9621

Época 3/3 1875/1875 [====================================] — 3s 2ms/paso — pérdida: 0.0823 — precisión: 0.9761

Esto significa que, al final de la primera iteración en el conjunto de datos, el modelo alcanza una precisión del 87,56 % en la determinación de la etiqueta correcta para una imagen determinada. A finales de la tercera época, la precisión del modelo aumenta al 97,61 %, lo que es bastante bueno, dado que utilizamos una red neuronal muy pequeña y la entrenamos solo durante 3 épocas. Pero esta es la precisión de la predicción en los datos que ya ha visto antes.

Comprueba la precisión del modelo en los datos de prueba

Para obtener una visión más realista del rendimiento del modelo, debemos medir su precisión en datos que no ha visto antes. Para lograrlo, utilizaremos el conjunto de datos de prueba. Para probar el modelo, escribiremos my_model.evaluate() y le daremos las imágenes de prueba, así como las etiquetas correspondientes para esas imágenes. También imprimiremos la precisión de la prueba en una línea separada.

# comprobar la precisión del modelo en los datos de pruebaval_loss, val_acc = my_model.evaluate(test_images, test_labels)print("Precisión de prueba: ", val_acc)

Ejecutar este código debería darnos algo como esto:

313/313 [====================================] — 0s 994us/paso — pérdida: 0.0817 — precisión: 0.9742

Precisión de la prueba: 0.9742000102996826

Lo que esto significa es que nuestro modelo clasifica los dígitos escritos a mano con una precisión del 97,42 %. En realidad, esto está bastante cerca de la precisión del entrenamiento, que fue del 97,61 %. Y esto es algo que queríamos lograr. Siempre queremos que la precisión de nuestro entrenamiento esté cerca de la precisión de nuestras pruebas. Ese es el objetivo de la formación, obtener mejores resultados en datos que no había visto antes. Es por eso que sus datos de entrenamiento deben ser representativos de los datos de las pruebas. Si la precisión de los modelos en el conjunto de datos de prueba fuera de alrededor del 85 % o el 75 %, probablemente significaría que estamos sobreadaptados con nuestro modelo. Esto podría requerir que volvamos a nuestro modelo y hagamos algunas modificaciones y entrenemos a nuestro modelo con menos épocas esta vez para evitar el sobreajuste. El sobreajuste se produce cuando el modelo comienza a memorizar los ejemplos del conjunto de datos en lugar de aprender información útil y generalizable.

Guardar el modelo

Ahora que tenemos un modelo que puede hacer algo útil, guardemos nuestro modelo, para que también podamos usarlo en otros lugares. Si no guardamos el modelo, tendremos que volver a crearlo cada vez que queramos usarlo. Para guardar nuestro modelo, escribiremos my_model.save() y también le daremos un directorio de archivos para guardar el archivo.

# guardar el modelo para su uso posteriormy_model.save('my_mnist_model')

Recuperar el modelo

Recuperemos también el modelo del sistema de archivos para asegurarnos de que funciona. Para cargar el modelo, tenemos que localizar el modelo en el sistema de archivos y pasarlo al método .load_model(). Como estamos en el mismo cuaderno, podemos copiar y pegar la dirección del archivo de la celda de código anterior, donde guardamos el modelo. En este ejemplo, lo nombraré como “my_nmist_model” y todo lo relacionado con nuestro modelo de aprendizaje automático se guardará en ese archivo. Por lo tanto, siempre y cuando tengamos acceso a esa carpeta, podemos recuperar exactamente el mismo modelo de aprendizaje automático del sistema de archivos.

# cargar el modelo desde el sistema de archivosmy_new_model = tf.keras.models.load_model('my_mnist_model')

Comprueba la precisión del nuevo modelo

También probemos nuestro nuevo modelo con los datos de prueba para asegurarnos de que también estamos obteniendo la misma precisión exacta con el nuevo modelo.

# comprobar la precisión del nuevo modelo en los datos de pruebanew_val_loss, new_val_acc = my_new_model.evaluate(test_images, test_labels)print("Nueva precisión de prueba: ", new_val_acc)

Ejecutar este código debería darte un resultado que se vea así:

313/313 [==================================] — 0s 1ms/paso — pérdida: 0.0817 — precisión: 0.9742

Nueva precisión de la prueba: 0.9742000102996826

Como podemos ver, tanto el modelo original como el nuevo modelo que recuperamos del sistema de archivos dan exactamente los mismos resultados, que es lo que esperábamos cuando guardamos el modelo.