Mes: febrero 2025

La inteligencia artificial (IA) es una disciplina que permite a las computadoras aprender y tomar decisiones basadas en datos. Utilizando modelos de aprendizaje automático, es posible entrenar algoritmos para reconocer patrones y hacer predicciones. En esta breve entrada, se muestra cómo desarrollar una aplicación en Python que permita el reconocimiento de patrones, para este caso, reconocer los números del 0 – 9 utilizando una red neuronal entrenada con TensorFlow. y para la interfaz gráfica, Tkinter, en python.

Librerias

• Tkinter: Para la interfaz gráfica.
• NumPy: Para manejar la matriz de datos.
• TensorFlow/Keras: Para cargar y utilizar un modelo de reconocimiento de patrones.

Carga del Modelo de Reconocimiento

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

# Ejemplos simples para 0 al 9
digits = {
    0: [
        [0,1,1,0],
        [1,0,0,1],
        [1,0,0,1],
        [1,0,0,1],
        [1,0,0,1],
        [0,1,1,0]
    ],
    1: [
        [0,0,1,0],
        [0,1,1,0],
        [0,0,1,0],
        [0,0,1,0],
        [0,0,1,0],
        [0,1,1,1]
    ],
    2: [
        [0,1,1,0],
        [1,0,0,1],
        [0,0,1,0],
        [0,1,0,0],
        [1,0,0,0],
        [1,1,1,1]
    ],
    3: [
        [1,1,1,0],
        [0,0,0,1],
        [0,1,1,0],
        [0,0,0,1],
        [0,0,0,1],
        [1,1,1,0]
    ],
    4: [
        [0,0,1,0],
        [0,1,1,0],
        [1,0,1,0],
        [1,1,1,1],
        [0,0,1,0],
        [0,0,1,0]
    ],
    5: [
        [1,1,1,1],
        [1,0,0,0],
        [1,1,1,0],
        [0,0,0,1],
        [1,0,0,1],
        [0,1,1,0]
    ],
    6: [
        [0,1,1,0],
        [1,0,0,0],
        [1,1,1,0],
        [1,0,0,1],
        [1,0,0,1],
        [0,1,1,0]
    ],
    7: [
        [1,1,1,1],
        [0,0,0,1],
        [0,0,1,0],
        [0,1,0,0],
        [1,0,0,0],
        [1,0,0,0]
    ],
    8: [
        [0,1,1,0],
        [1,0,0,1],
        [0,1,1,0],
        [1,0,0,1],
        [1,0,0,1],
        [0,1,1,0]
    ],
    9: [
        [0,1,1,0],
        [1,0,0,1],
        [1,0,0,1],
        [0,1,1,1],
        [0,0,0,1],
        [0,1,1,0]
    ]
}

# Preparación de los datos
X = np.array([np.array(digits[d]).flatten() for d in digits])  # Convertir a vectores de 24 elementos
y = np.array(list(digits.keys()))

# Codificación one-hot para las etiquetas
y_categorical = to_categorical(y, num_classes=10)

# Definir el modelo de red neuronal
model = Sequential([
    Dense(32, activation='relu', input_shape=(24,)),
    Dense(16, activation='relu'),
    Dense(10, activation='softmax')  # 10 clases (0 al 9)
])

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

# Entrenar el modelo
model.fit(X, y_categorical, epochs=1000, verbose=1)

# Guardar el modelo entrenado
model.save("modeloReconocimiento0-9.keras")

print("Modelo guardado exitosamente como 'modelo_numeros.keras")

El primer paso es cargar el modelo previamente entrenado. En este caso, el modelo debe haber sido guardado en un archivo modelo0-9.keras.

import tensorflow as tf
import numpy as np
import tkinter as tk

# Cargar el modelo
try:
    model = tf.keras.models.load_model('modelo0-9.keras')  
except:
    print(" No se encontró el archivo 'modelo0-9.keras'. Asegúrate de entrenar y guardar el modelo.")
    exit()

Creación de la Interfaz Gráfica con Tkinter

La interfaz se basa en un lienzo donde el usuario puede dibujar un patrón de 6×4 celdas. Cada celda puede activarse o desactivarse haciendo clic en ella.

# Dimensiones de la matriz
ROWS = 6
COLS = 4
CELL_SIZE = 50  

matrix = np.zeros((ROWS, COLS), dtype=int)

root = tk.Tk()
root.title("Reconocimiento de Patrones (Canvas)")
root.configure(bg="white")

canvas = tk.Canvas(root, width=COLS * CELL_SIZE, height=ROWS * CELL_SIZE, bg="white")
canvas.grid(row=0, column=0, columnspan=4, padx=10, pady=10)

Funcionalidad de Dibujo

Cada clic del usuario alterna el estado de la celda, cambiando su color de blanco a negro y viceversa.

rectangles = {}

def toggle_cell(event):
    col = event.x // CELL_SIZE
    row = event.y // CELL_SIZE  
    if 0 <= row < ROWS and 0 <= col < COLS:
        matrix[row, col] = 1 if matrix[row, col] == 0 else 0
        color = "black" if matrix[row, col] == 1 else "white"
        canvas.itemconfig(rectangles[(row, col)], fill=color)

Creación de la Cuadrícula

for r in range(ROWS):
    for c in range(COLS):
        x1, y1 = c * CELL_SIZE, r * CELL_SIZE
        x2, y2 = x1 + CELL_SIZE, y1 + CELL_SIZE
        rect = canvas.create_rectangle(x1, y1, x2, y2, fill="white", outline="gray")
        rectangles[(r, c)] = rect

canvas.bind("<Button-1>", toggle_cell)

Reconocimiento del Patrón

Al presionar el botón «Reconocer», la matriz se procesa y se pasa al modelo para obtener una predicción.

def recognize_number():
    flattened_matrix = matrix.flatten().reshape(1, -1)
    prediction = model.predict(flattened_matrix)
    result_label.config(text=f"Número reconocido: {np.argmax(prediction)}")

Reinicio del Dibujo

def reset_matrix():
    global matrix
    matrix = np.zeros((ROWS, COLS), dtype=int)
    for (r, c), rect in rectangles.items():
        canvas.itemconfig(rect, fill="white")  

Botones de Interacción

recognize_btn = tk.Button(root, text="Reconocer", command=recognize_number, font=("Arial", 12), bg="lightblue")
recognize_btn.grid(row=1, column=0, columnspan=2, pady=10)

reset_btn = tk.Button(root, text="Reiniciar", command=reset_matrix, font=("Arial", 12), bg="lightblue", fg="black")
reset_btn.grid(row=1, column=2, columnspan=2, pady=10)

result_label = tk.Label(root, text="Dibuja un número y presiona 'Reconocer'", font=("Arial", 12), bg="white")
result_label.grid(row=2, column=0, columnspan=4)

Finalmente, iniciamos el bucle de Tkinter:

root.mainloop()

Esta aplicación es un ejemplo práctico de cómo integrar modelos de inteligencia artificial en interfaces gráficas de usuario. Puedes mejorarla entrenando modelos más precisos o ampliando la resolución de la cuadrícula para mejorar la precisión en el reconocimiento.