Crear Red Neuronal con Tensorflow que sea capaz de reconocer dígitos escritos a mano.

por
Tiempo de lectura: 5 minutos

Paso 1: Instalar TensorFlow

Lo primero que debes hacer es instalar TensorFlow. Puedes hacerlo siguiendo las instrucciones en la página de TensorFlow: https://www.tensorflow.org/install/.

Si quieres instalarlo en docker:

 docker pull tensorflow/tensorflow:latest  # Download latest stable image
 docker run -it -p 8888:8888 tensorflow/tensorflow:latest-jupyter  # Start Jupyter server

Si quieres instalarlo en local:

# Requires the latest pip
pip install --upgrade pip

# Current stable release for CPU and GPU
pip install tensorflow

# Or try the preview build (unstable)
pip install tf-nightly

Paso 2: Obtener los datos

Para este tutorial, utilizaremos el conjunto de datos MNIST, que consiste en imágenes de dígitos escritos a mano. Puedes descargar el conjunto de datos desde el sitio web de TensorFlow utilizando el siguiente código:

from tensorflow import keras

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

Paso 3: Preprocesamiento de los datos

Antes de entrenar nuestra red neuronal, debemos preprocesar los datos. En primer lugar, normalizaremos los valores de píxeles para que estén en un rango de 0 a 1 en lugar de 0 a 255. Luego, aplanaremos las imágenes de 28×28 píxeles en un vector de 784 píxeles.

# Normalizar los valores de píxeles
x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255

# Aplanar las imágenes
x_train = x_train.reshape((len(x_train), 784))
x_test = x_test.reshape((len(x_test), 784))

También convertiremos las etiquetas en vectores one-hot.

from tensorflow.keras.utils import to_categorical

y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

Paso 4: Crear el modelo

Utilizaremos una red neuronal de tres capas: una capa de entrada, una capa oculta y una capa de salida. La capa de entrada tendrá 784 nodos, la capa oculta tendrá 64 nodos y la capa de salida tendrá 10 nodos (uno para cada posible dígito).

from tensorflow.keras import layers

model = keras.Sequential([
    layers.Dense(64, activation="relu", input_shape=(784,)),
    layers.Dense(10, activation="softmax")
])

Paso 5: Compilar el modelo

Antes de entrenar el modelo, debemos compilarlo. En este paso, debemos especificar la función de pérdida, el optimizador y las métricas que utilizaremos para evaluar el modelo.

model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])

Paso 6: Entrenar el modelo

Ahora que hemos preparado nuestros datos y modelo, podemos entrenar el modelo.

model.fit(x_train, y_train, epochs=10, batch_size=128, validation_data=(x_test, y_test))

En este ejemplo, entrenamos el modelo durante 10 épocas con un tamaño de lote de 128. También utilizamos los datos de prueba como conjunto de validación.

Paso 7: Evaluar el modelo

Una vez que el modelo se ha entrenado, podemos evaluar su rendimiento utilizando los datos de prueba.

test_loss, test_acc = model.evaluate(x_test, y_test)
print("Precisión de prueba:", test_acc)

Paso 8: Utilizar el modelo

Finalmente, podemos utilizar el modelo para hacer predicciones sobre nuevos datos

Para hacer predicciones utilizando el modelo entrenado, podemos utilizar el método predict del modelo. Por ejemplo, si tenemos una nueva imagen de un dígito, podemos utilizar el modelo para predecir qué dígito es:

import numpy as np

# Cargar una imagen de ejemplo
# Cargar una imagen de ejemplo
new_image = np.array([[
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
]])

Aquí está el código completo:

import tensorflow as tf
from tensorflow.keras.datasets import mnist

# Cargar los datos de entrenamiento y prueba
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Normalizar los datos de entrada
x_train = x_train / 255.0
x_test = x_test / 255.0

# Crear el modelo de red neuronal
model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

# Compilar el modelo
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Entrenar el modelo
model.fit(x_train, y_train, epochs=5)

# Evaluar el modelo
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print('Accuracy:', test_acc)

# Hacer predicciones con el modelo
import numpy as np

# Cargar una imagen de ejemplo
# Cargar una imagen de ejemplo
new_image = np.array([[
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
]])
# Hacer una predicción
prediction = model.predict(new_image)

# Imprimir la predicción
print('Prediction:', np.argmax(prediction))

En este código, cargamos una imagen de ejemplo que es simplemente una matriz de 28×28 con todos los valores establecidos en cero. Luego, hacemos una predicc

ón en el modelo entrenado y utilizamos np.argmax para obtener la clase de la predicción.

Ahora, si deseas probar el modelo con tus propias imágenes, puedes cargarlas y preprocesarlas de manera similar a como lo hicimos con los datos de MNIST en el tutorial. Aquí hay un ejemplo de cómo cargar y preprocesar una imagen:

from PIL import Image

# Cargar la imagen
img = Image.open('mi_imagen.png')

# Convertir la imagen a escala de grises y redimensionarla a 28x28 píxeles
img = img.convert('L').resize((28, 28))

# Convertir la imagen a un arreglo numpy
img_array = np.array(img)

# Invertir los colores de la imagen (ya que MNIST tiene números blancos sobre fondo negro)
img_array = 255 - img_array

# Normalizar la imagen (dividir cada valor de píxel por 255 para obtener valores en el rango [0, 1])
img_array = img_array.astype('float32') / 255.0

# Aplanar la imagen (convertir una matriz 2D en un vector 1D)
img_array = img_array.reshape((1, 28*28))

ón en el modelo entrenado y utilizamos np.argmax para obtener la clase de la predicción.

Ahora, si deseas probar el modelo con tus propias imágenes, puedes cargarlas y preprocesarlas de manera similar a como lo hicimos con los datos de MNIST en el tutorial. Aquí hay un ejemplo de cómo cargar y preprocesar una imagen:

python
from PIL import Image

# Cargar la imagen
img = Image.open('mi_imagen.png')

# Convertir la imagen a escala de grises y redimensionarla a 28x28 píxeles
img = img.convert('L').resize((28, 28))

# Convertir la imagen a un arreglo numpy
img_array = np.array(img)

# Invertir los colores de la imagen (ya que MNIST tiene números blancos sobre fondo negro)
img_array = 255 - img_array

# Normalizar la imagen (dividir cada valor de píxel por 255 para obtener valores en el rango [0, 1])
img_array = img_array.astype('float32') / 255.0

# Aplanar la imagen (convertir una matriz 2D en un vector 1D)
img_array = img_array.reshape((1, 28*28))

Una vez que hayas preprocesado tu imagen, puedes hacer una predicción en el modelo utilizando el código anterior. Espero que este tutorial te haya sido útil.

Post Views: 22

Deja un comentario