Código Python: perceptrón desde cero para decidir si reponer un producto

Código Python: perceptrón desde cero para decidir si reponer un producto

En una ferretería, en una distribuidora de repuestos o en el depósito de una panadería, la misma pregunta vuelve cada semana: ¿este producto lo pido otra vez o espero? Casi siempre la responde una persona con la memoria del mes pasado y una hoja de cálculo abierta. El problema no son los datos: las ventas del mes, las existencias y la demora del proveedor ya están registradas en alguna parte. El problema es que nadie tiene tiempo de mirar los tres números a la vez, artículo por artículo, justo antes de armar el pedido.

Este artículo es para el dueño del negocio, para el contador que revisa compras y para el almacenista que arma la lista. Aquí puedes descargar un programa de Python que se lee completo, sin librerías de inteligencia artificial, que toma tres columnas de tu inventario y aprende por su cuenta cuándo conviene reponer. La idea de fondo cabe en una frase: una neurona es una regla que se ajusta sola. Empieza adivinando, se equivoca, se corrige y termina acertando. No hay magia: hay una fórmula pequeña que se repite treinta veces sobre tus datos, y el resultado se puede comprobar línea por línea.

El paquete es un ZIP con cuatro archivos y nada más. No trae instaladores ni depende de internet: cuando lo descomprimas, todo funciona en tu propio computador.

Qué hace el programa

El programa hace un trabajo acotado y lo hace completo. De principio a fin:

1. Lee datos/productos.csv: doce productos de ferretería con las ventas del mes, las existencias, el plazo del proveedor y una columna llamada reponer, que vale uno cuando el comprador sí repuso ese producto y cero cuando no lo repuso. Esa columna es la respuesta correcta que la neurona debe aprender a copiar; no la inventa el programa.
2. Normaliza las tres entradas al rango de cero a uno. Es el paso que casi todos se saltan y el que decide si el experimento sirve o no.
3. Arranca los pesos con valores al azar, pero con la semilla fija siete: por eso todos vemos exactamente los mismos números al ejecutarlo, hoy y dentro de un mes.
4. Entrena la neurona: recorre el archivo treinta veces, barajando el orden en cada vuelta, y cada vez que la predicción no coincide con la respuesta correcta corrige los pesos en la dirección que reduce el error.
5. Imprime los pesos finales con su lectura en palabras, para que los entiendas aunque no sepas programar.
6. Predice producto por producto y compara la predicción con la respuesta correcta.
7. Guarda salida/predicciones.csv, comprueba que la misma semilla devuelve el mismo resultado y te avisa si algo no cuadra.

Cómo ejecutarlo

Necesitas Python 3.11 o superior y absolutamente nada más. Ni numpy, ni pandas, ni ninguna biblioteca de inteligencia artificial: el programa usa solo la biblioteca estándar que viene con Python. Si todavía no lo tienes, descárgalo del sitio oficial y acepta las opciones por defecto.

1. Descomprime el ZIP en una carpeta (por ejemplo, Documentos/Perceptron).
2. Abre la terminal en esa carpeta.
3. Escribe el comando y pulsa Enter:

   python perceptron_reponer.py

En Windows el intérprete a veces se llama py: si el comando anterior no responde, prueba py perceptron_reponer.py. En Mac y Linux suele ser python3 perceptron_reponer.py. La única condición es estar dentro de la carpeta descomprimida, porque el programa busca el archivo de datos en datos/productos.csv y el resultado lo escribe en salida/predicciones.csv.

El código, explicado

El programa completo pasa un poco de las doscientas líneas y está comentado línea por línea. Con mirar seis pedazos ya se entiende toda la idea.

Las tres perillas del aprendizaje. Al principio se declaran tres números que gobiernan el entrenamiento completo. La semilla fija el azar para que el resultado se repita; la tasa dice cuánto se corrige cada peso en cada error; las épocas dicen cuántas vueltas completas se le dan al archivo. Cambiar la tasa o las épocas cambia la corrida, y por eso el programa imprime sus valores en pantalla: así sabes con qué se obtuvo el resultado.

SEMILLA = 7          # # Semilla fija: con el mismo dato el resultado es siempre el mismo
TASA = 0.1           # # Tasa de aprendizaje: cuanto se corrige el peso en cada error
EPOCAS = 30          # # Epocas: cuantas vueltas completas se le dan al archivo

Por qué se normaliza. Esta función lleva cada columna al rango de cero a uno. Si la neurona viera el stock en unidades, que llega a cientos, junto al plazo en días, que no pasa de treinta, la suma quedaría dominada por la columna más grande y el plazo casi no contaría. Con todo en la misma escala, cada entrada empuja de verdad y los pesos se pueden comparar entre sí.

def normalizar(productos: list[dict], campo: str) -> list[float]:
    """Lleva una columna al rango 0..1 (min-max): así el stock en unidades no aplasta al plazo en días."""
    valores = [producto[campo] for producto in productos]
    minimo, maximo = min(valores), max(valores)
    rango = maximo - minimo

La neurona propiamente dicha. Aquí está el corazón y cabe en dos funciones. Se multiplica cada entrada por su peso, se suman los tres resultados y se les agrega el sesgo. Ese total se compara contra cero: si pasa de cero, la respuesta es reponer; si no, no reponer. Nada más que eso; geométricamente, una recta que parte los productos en dos grupos.

def suma_pesada(pesos: list[float], sesgo: float, entrada: list[float]) -> float:
    """Suma ponderada w*x + b: el valor que la neurona compara contra cero."""
    total = sesgo
    for indice in range(len(ENTRADAS)):
        total += pesos[indice] * entrada[indice]
    return total

def predecir(pesos: list[float], sesgo: float, entrada: list[float]) -> int:
    """Predice 1 (reponer) cuando la suma ponderada pasa de cero, y 0 cuando no."""
    return 1 if suma_pesada(pesos, sesgo, entrada) > 0 else 0

El entrenamiento. Los pesos no nacen acertados: nacen al azar. Lo que los vuelve útiles es la regla de corrección, que se aplica fila por fila dentro de cada época.

def entrenar(entradas: list[list[float]], etiquetas: list[int]) -> tuple:
    """Entrena la neurona con la regla del perceptrón y devuelve pesos, sesgo y errores por vuelta."""
    azar = random.Random(SEMILLA)
    pesos = [azar.uniform(-1.0, 1.0) for _ in ENTRADAS]   # # Cada peso dice cuánto empuja su entrada hacia el reponer
    sesgo = azar.uniform(-1.0, 1.0)

La corrección. Cuando la predicción coincide con la respuesta correcta, el error vale cero y no se toca nada: lo que ya está bien no se mueve. Cuando no coincide, el error empuja cada peso en proporción a la entrada y al tamaño de la tasa de aprendizaje. El sesgo se corrige igual que un peso, con la diferencia de que no multiplica ninguna entrada.

                for j in range(len(ENTRADAS)):
                    pesos[j] += TASA * error * entradas[indice][j]
                sesgo += TASA * error    # # El sesgo se corrige igual que un peso, pero no multiplica ninguna entrada

Qué vas a ver en pantalla

Primero la tabla de datos tal como vienen en el archivo y, debajo, la misma tabla normalizada: los mismos productos vistos con la escala de cero a uno que usa la neurona. Fíjate en que la columna de existencias es la única que cambia de aspecto de forma drástica; ese es justamente el efecto que buscamos.

DATOS NORMALIZADOS (0 a 1: lo que ve la neurona)
-------------------------------------------------------------------------------------
Producto                        Reponer        Ventas 0-1     Stock 0-1     Plazo 0-1
-------------------------------------------------------------------------------------
Cemento gris 50 kg              SI                   0,26          0,10          0,76
Tornillo autoperforante 1 pulg  SI                   1,00          0,26          0,19
Martillo de bola                SI                   0,00          0,00          1,00
Arena gruesa (bulto)            NO                   0,47          1,00          0,00

Después viene el entrenamiento. El programa imprime solo las vueltas en las que mejora, que son las que enseñan: en la primera época se equivoca siete veces, en la segunda cinco, en la tercera cuatro, en la cuarta dos y en la sexta ya no se equivoca. Ahí está el aprendizaje a la vista, sin cajas negras.

ENTRENAMIENTO: 30 épocas, tasa 0,10, semilla 7
  Época 1/30 · errores 7
  Época 2/30 · errores 5
  Época 3/30 · errores 4
  Época 4/30 · errores 2
  Época 6/30 · errores 0

Y al final, los pesos con su lectura en palabras, el resultado producto por producto y la comprobación de que la corrida se repite.

PESOS FINALES Y SESGO (leídos en palabras)
  peso de ventas_mes = 0,25: cuanto más vende el producto, más ganas de reponer
  peso de stock = -0,74: cuanto más stock hay guardado, menos ganas de reponer
  peso de plazo_proveedor = 0,28: cuanto más tarda el proveedor, más ganas de reponer
  sesgo = -0,06: con las tres entradas en cero, la neurona se inclina a no reponer

Estos cuatro números son el resultado de la corrida y merecen una lectura de negocio:

Lo importante no es el valor exacto de cada peso, sino su tamaño relativo. Las existencias pesan más que las otras dos entradas juntas; el sesgo es tan pequeño que casi no influye. Y como los datos están normalizados, esos tres números se pueden comparar entre sí: si las existencias se midieran en unidades y el plazo en días, un peso de menos cero coma setenta y cuatro no diría nada. Ojo con un detalle que vale oro: estos pesos son la huella de estos doce productos de ejemplo, no una receta universal. Con tu propio archivo van a salir otros números, y eso es lo correcto.

Aciertos: 12 de 12
Comprobación (misma semilla, mismo resultado): CUADRA

La corrida de ejemplo acierta las doce predicciones, es decir, el cien por ciento de los casos. Y el programa deja además salida/predicciones.csv con cuatro columnas, producto, esperado, predicho y acierto, listo para abrir en Excel o en cualquier hoja de cálculo. Eso es lo que se revisa con el contador: no la promesa del modelo, sino la lista de casos en los que acertó y en los que se equivocó.

Errores comunes y consejos

• No encuentra el archivo. Casi siempre es que estás ejecutando el comando desde otra carpeta. Entra a la carpeta descomprimida o escribe la ruta completa hasta el archivo.
• No muevas el CSV. El programa busca los datos con el nombre exacto datos/productos.csv. Si lo renombras o lo sacas de la subcarpeta, deja de funcionar.
• Guarda el CSV en formato CSV. Si lo editas en Excel, mantén las mismas cabeceras, producto, ventas_mes, stock, plazo_proveedor y reponer, y separador por comas. La configuración regional que cambia el separador de listas rompe la lectura.
• Nada de símbolos ni puntos de miles. Los números van limpios, sin signo de pesos y sin separador de miles.
• La etiqueta es uno o cero. En la columna reponer no escribas palabras como sí o no: el programa espera números.
• Un dato raro arruina la tabla. Una celda vacía o un texto metido entre los números desalinea los cálculos; revisa el archivo antes de correr.
• Doce filas no son una prueba. El ejemplo es corto a propósito para que se entienda. Con tu inventario real, usa varios meses y unos cuantos cientos de filas antes de confiar en la regla.
• Anota la semilla. Si más adelante cambias la semilla verás otros pesos; la lógica es la misma, pero el punto de partida no. Deja constancia de con qué valores se obtuvo cada resultado.

Cuándo esto no alcanza

Con esto ya puedes reponer con un criterio y no con la corazonada del mes pasado. Pero conviene ser honesto sobre los límites. El primero es técnico: una sola neurona solo aprende reglas con frontera recta, del tipo existencias bajas frente a ventas o plazo largo. Si tu regla real tiene excepciones, por ejemplo no reponer los productos que ya están pedidos, hace falta más de una neurona. El segundo límite es de operación: este programa es didáctico, lo corre una persona, sobre un archivo CSV que alguien tiene que mantener al día.

Cuando el negocio crece y la hoja de cálculo con los scripts ya no dan abasto, el paso natural es un software de inventarios. Ahí entra Kardex Tauro, la herramienta para la que escribimos este taller: permite llevar el stock y el costo de ventas en serio, con varios usuarios y con respaldo, sin depender de que alguien se acuerde de actualizar el archivo. El programa de este artículo es gratis y sirve para entender la mecánica y para ordenar el inventario; el software es para cuando el inventario ya no cabe en un archivo.

Descarga el ZIP, ejecútalo tal como viene y mira la tabla de aciertos. Después reemplaza una fila de datos/productos.csv por un producto tuyo real y vuelve a correr: verás cómo la regla se reajusta sola, sin que toques una línea de código. Ese es todo el truco, y también la mejor forma de entender por qué un inventario ordenado vale más que un pedido hecho a la carrera.