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.