Forem: galp76

De Keras a Bare-Metal C++: Construyendo un motor de inferencia dentro de un Arduino Uno (Parte 3)

galp76 — Sun, 03 May 2026 10:00:10 +0000

En la Parte 2 de esta serie, logramos entrenar exitosamente una red neuronal recurrente (LSTM) en Python, capaz de predecir la falla de una turbina aeroespacial con un error de apenas 10 vuelos.

El modelo era un éxito en la nube. Pero en el mundo del mantenimiento industrial y el Edge Computing, no siempre tenemos servidores disponibles. Quería llevar a MAJN (mi red neuronal) al mundo físico. Así que tomé una decisión de hardware deliberadamente extrema para forzar mis habilidades en C++: desplegaría el modelo dentro de un humilde Arduino Uno.

Aquí chocamos de frente con la física del hardware: nuestro modelo en Keras tenía 14,665 parámetros en formato de punto flotante de 32 bits (float32), eso equivale a unos 60 Kilobytes. El cerebro del Arduino Uno (el microcontrolador ATmega328P) tiene 32 KB de memoria Flash (disco duro) y apenas 2 KB de memoria RAM.

En este artículo, documentaré paso a paso cómo logré meter esta red neuronal en el microcontrolador desarrollando un motor de inferencia LSTM en C++ puro desde cero.

La "Dieta" Matemática: Cuantización Lineal a 8-bits (Quantization)

En Python, nuestro modelo operaba con números decimales de 32 bits (float32), pero el microcontrolador del Arduino Uno carece de una Unidad de Punto Flotante (FPU) por hardware. Obligarlo a procesar decimales mediante emulación por software destruiría su rendimiento y saturaría sus 2KB de RAM al instante. La solución técnica fue aplicar Cuantización (Quantization): una transformación matemática donde escalamos los más de 14,000 pesos decimales para convertirlos en números enteros de un solo byte (int8_t). Esto reduciría el peso de la red a 14.6 KB, perfecto para la Flash de 32 KB.

Aquí está el script en Python que extrae los pesos de Keras, busca el valor absoluto máximo de toda la red, y calcula un Factor de Escala:

# Extracción y Cuantización en Python
pesos_keras = modelo.get_weights()
todos_los_pesos = np.concatenate([p.flatten() for p in pesos_keras])
max_abs = np.max(np.abs(todos_los_pesos))

# Buscamos encajar el peso más grande en el límite de un int8_t (127)
factor_escala = 126.0 / max_abs

# Multiplicamos la matriz, redondeamos y convertimos a entero de 1 byte
matriz_cuantizada = np.round(matriz_peso * factor_escala).astype(np.int8)

Con esto ya tenemos las proporciones matemáticas exactas, pero comprimidas en números enteros minúsculos.

Siguiente reto: el muro de la Arquitectura Harvard (PROGMEM)

Las computadoras modernas usan la arquitectura Von Neumann (datos y programas comparten la RAM). El ATmega328P usa Arquitectura Harvard (la Flash y la RAM están separadas físicamente).

Si en C++ estándar declaras un arreglo global enorme (int8_t pesos[14665]), el compilador lo guarda en la Flash, pero al encender la placa, intenta copiarlo todo a la RAM para trabajar. Con 2 KB de RAM, esto provoca un Stack Overflow instantáneo y el Arduino muere.

La solución en Bare-Metal AVR C++ es usar la directiva PROGMEM. Esto "ancla" el arreglo a la Flash de forma permanente.
Pero esto genera un nuevo problema: en C++, un puntero normal no puede leer la memoria Flash. Para extraer nuestros pesos en tiempo de ejecución, tuvimos que usar aritmética de punteros y llamadas a bajo nivel con pgm_read_byte_near():

// El arreglo vive exclusivamente en los 32KB de Flash
const int8_t matriz_pesos_0[2800] PROGMEM = {12, -45, 89, ...};

// Para leerlo usando un índice (offset)
int8_t peso = (int8_t)pgm_read_byte_near(matriz_pesos_0 + indice);

Álgebra lineal sin decimales: evitando el desbordamiento

Nuestro Arduino no tiene Unidad de Punto Flotante (FPU) ni librerías como NumPy. Tuvimos que escribir el producto punto (multiplicación de matrices) usando bucles for anidados.

Aquí el peligro era matemático: Si multiplicas un sensor cuantizado (ej. 100) por un peso cuantizado (ej. 50), el resultado es 5000. ¡Eso no cabe en los 8 bits de un int8_t! La memoria "daría la vuelta" arrojando basura negativa.
Para evitarlo, la acumulación en el código de C++ forzosamente se hizo usando un tipo de dato más grande (int32_t):

int32_t acumulador = 0;
// Multiplicación en 32 bits para evitar overflow de memoria
acumulador += (int32_t)sensor * (int32_t)peso;

Aproximando las funciones de activación (Hard Tanh & Hard Sigmoid)

Una celda LSTM requiere funciones trigonométricas continuas (Sigmoide y Tangente Hiperbólica). Ejecutar la función exp() en un microcontrolador de 8 bits destruye el rendimiento por los ciclos de reloj que requiere.

La solución en el mundo del TinyML es usar "Hard Activations" (Aproximaciones lineales). Reemplazamos la compleja curva sigmoide por funciones de clipping (topes) usando solo sumas y divisiones sobre nuestra variable ESCALA constante:

int32_t hard_sigmoid_8bit(int32_t x) {
  // Aproximación de la Sigmoide adaptada a números enteros escalados
  int32_t sig = (x / 2) + (ESCALA / 2);
  if (sig > ESCALA) return ESCALA;
  if (sig < 0) return 0;
  return sig;
}

El Motor LSTM en C++ y la Integración Final

Con todas las piezas listas, programamos el bucle del LSTM. Creé dos arreglos en la memoria RAM (h_estado y c_estado) para conservar el contexto temporal entre ciclos, y programé las cuatro compuertas (Forget, Input, Cell, Output).

Para que no quede ninguna duda de cómo se ve una Red Neuronal Recurrente escrita "a bajo nivel", aquí está el código completo que corrió dentro del Arduino Uno.

En este bloque pueden observar las aproximaciones a las funciones de activación (hard_tanh y hard_sigmoid), los arreglos globales para mantener la memoria temporal de los ciclos de la turbina (h_estado y c_estado), y el cálculo algebraico de las cuatro compuertas matemáticas del LSTM leyendo los pesos directamente desde la memoria Flash con PROGMEM:

#include "majn_weights.h"

const int PIN_ALARMA = 13;
const int32_t ESCALA = (int32_t)FACTOR_ESCALA;

// --- MEMORIA DEL LSTM (El "Estado" que viaja en el tiempo) ---
int32_t h_estado[50]; // Hidden State (Estado Oculto)
int32_t c_estado[50]; // Cell State (Memoria a largo plazo)

// --- FUNCIONES DE ACTIVACIÓN CUANTIZADAS ---
int32_t hard_tanh_8bit(int32_t x) {
  if (x > ESCALA) return ESCALA;
  if (x < -ESCALA) return -ESCALA;
  return x;
}

int32_t hard_sigmoid_8bit(int32_t x) {
  int32_t sig = (x / 2) + (ESCALA / 2);
  if (sig > ESCALA) return ESCALA;
  if (sig < 0) return 0;
  return sig;
}

// Función que limpia la "mente" de la red para un motor nuevo
void resetear_memoria_turbina() {
  for(int i = 0; i < 50; i++) {
    h_estado[i] = 0;
    c_estado[i] = 0;
  }
}

void setup() {
  Serial.begin(9600);
  pinMode(PIN_ALARMA, OUTPUT);
  digitalWrite(PIN_ALARMA, LOW);

  resetear_memoria_turbina();
  while(Serial.available()) Serial.read(); 
}

void loop() {
  if (Serial.available() > 0) {
    // Protocolo de comunicación con el "Gemelo Digital" en Python
    char comando = Serial.read();

    if (comando == 'R') {
      // Python pide resetear porque empezó un motor nuevo
      resetear_memoria_turbina();
      digitalWrite(PIN_ALARMA, LOW);
      Serial.println("RESET_OK");
    } 
    else if (comando == 'D') {
      // Python envía datos: 14 sensores cuantizados a 8-bits
      while(Serial.available() < 14) { /* Esperamos recepción */ }

      int8_t sensores[14];
      Serial.readBytes((char*)sensores, 14);

      // =======================================================
      // EL CORAZÓN DEL LSTM (Matemática Bare-Metal)
      // =======================================================
      int32_t h_nuevo[50]; 
      int32_t c_nuevo[50];

      for(int u = 0; u < 50; u++) { 
        // 1. Extraemos los Bias (Sesgos) de la Flash
        int32_t comp_i = (int8_t)pgm_read_byte_near(matriz_pesos_2 + u);       
        int32_t comp_f = (int8_t)pgm_read_byte_near(matriz_pesos_2 + 50 + u);  
        int32_t comp_c = (int8_t)pgm_read_byte_near(matriz_pesos_2 + 100 + u); 
        int32_t comp_o = (int8_t)pgm_read_byte_near(matriz_pesos_2 + 150 + u); 

        // 2. Multiplicamos Entradas x Pesos (W * x)
        int32_t sum_in_i = 0, sum_in_f = 0, sum_in_c = 0, sum_in_o = 0;
        for(int x = 0; x < 14; x++) {
          int32_t entrada = sensores[x];
          sum_in_i += entrada * (int8_t)pgm_read_byte_near(matriz_pesos_0 + (x * 200) + u);
          sum_in_f += entrada * (int8_t)pgm_read_byte_near(matriz_pesos_0 + (x * 200) + 50 + u);
          sum_in_c += entrada * (int8_t)pgm_read_byte_near(matriz_pesos_0 + (x * 200) + 100 + u);
          sum_in_o += entrada * (int8_t)pgm_read_byte_near(matriz_pesos_0 + (x * 200) + 150 + u);
        }
        comp_i += sum_in_i / 64;
        comp_f += sum_in_f / 64;
        comp_c += sum_in_c / 64;
        comp_o += sum_in_o / 64;

        // 3. Multiplicamos Estado Anterior x Pesos Recurrentes (U * h)
        int32_t sum_h_i = 0, sum_h_f = 0, sum_h_c = 0, sum_h_o = 0;
        for(int hu = 0; hu < 50; hu++) {
          int32_t h_pasado = h_estado[hu];
          sum_h_i += h_pasado * (int8_t)pgm_read_byte_near(matriz_pesos_1 + (hu * 200) + u);
          sum_h_f += h_pasado * (int8_t)pgm_read_byte_near(matriz_pesos_1 + (hu * 200) + 50 + u);
          sum_h_c += h_pasado * (int8_t)pgm_read_byte_near(matriz_pesos_1 + (hu * 200) + 100 + u);
          sum_h_o += h_pasado * (int8_t)pgm_read_byte_near(matriz_pesos_1 + (hu * 200) + 150 + u);
        }
        comp_i += sum_h_i / ESCALA;
        comp_f += sum_h_f / ESCALA;
        comp_c += sum_h_c / ESCALA;
        comp_o += sum_h_o / ESCALA;

        // 4. Pasamos por las Funciones de Activación
        int32_t act_i = hard_sigmoid_8bit(comp_i);
        int32_t act_f = hard_sigmoid_8bit(comp_f);
        int32_t act_c = hard_tanh_8bit(comp_c);
        int32_t act_o = hard_sigmoid_8bit(comp_o);

        // 5. Ecuaciones finales de actualización de la celda LSTM
        c_nuevo[u] = (act_f * c_estado[u]) / ESCALA + (act_i * act_c) / ESCALA;
        h_nuevo[u] = (act_o * hard_tanh_8bit(c_nuevo[u])) / ESCALA;
      }

      // Guardamos la memoria para el siguiente ciclo
      for(int i = 0; i < 50; i++) {
        h_estado[i] = h_nuevo[i];
        c_estado[i] = c_nuevo[i];
      }

      // =======================================================
      // CAPAS DENSAS Y RUL PREDICTIVO
      // =======================================================
      int32_t capa_densa[32];
      for(int d = 0; d < 32; d++) {
        capa_densa[d] = (int8_t)pgm_read_byte_near(matriz_pesos_4 + d);
        int32_t sum_densa = 0;
        for(int u = 0; u < 50; u++) {
          sum_densa += h_estado[u] * (int8_t)pgm_read_byte_near(matriz_pesos_3 + (u * 32) + d);
        }
        capa_densa[d] += sum_densa / ESCALA;
        if (capa_densa[d] < 0) capa_densa[d] = 0; // Activación ReLU
      }

      int32_t salida_final = (int8_t)pgm_read_byte_near(matriz_pesos_6 + 0);
      int32_t sum_salida = 0;
      for(int d = 0; d < 32; d++) {
        sum_salida += capa_densa[d] * (int8_t)pgm_read_byte_near(matriz_pesos_5 + d);
      }
      salida_final += sum_salida / ESCALA;

      // Descuantización para obtener ciclos reales
      float rul_predicho = (float)salida_final / FACTOR_ESCALA;
      rul_predicho = abs(rul_predicho); 
      if (rul_predicho > 125) rul_predicho = 125; 

      // Lógica de Alarma Física Industrial
      if (rul_predicho < 15.0) {
         digitalWrite(PIN_ALARMA, HIGH); // Peligro Inminente
         Serial.print("CRITICO,");
      } else {
         digitalWrite(PIN_ALARMA, LOW);
         Serial.print("OK,");
      }
      Serial.println(rul_predicho);
    }
  }
}

Para que este motor de inferencia en el Arduino pudiera "ver" los datos de la turbina, necesitaba un programa en la computadora que actuara como un Gemelo Digital.

Escribí este script en Python que utiliza la librería pyserial. Su trabajo es cargar los datos históricos de la NASA, normalizarlos usando nuestro escalador guardado en la Parte 1, cuantizarlos a números enteros multiplicándolos por 64, y enviarlos byte a byte a través del cable USB.

El código inyecta vuelo tras vuelo, y se queda esperando a que el Arduino procese la matemática y devuelva el diagnóstico:

import serial
import pandas as pd
import joblib
import time

# --- CONFIGURACIÓN ---
PUERTO = '/dev/ttyACM0'  # Reemplazar por COM3 en Windows
BAUDIOS = 9600

print("1. Cargando datos de la NASA y el Escalador...")
# (Aquí omitimos el código de carga de Pandas para mantenerlo conciso)
df = cargar_y_limpiar_datos('train_FD001.txt')
scaler = joblib.load('escalador_sensores_turbina.pkl')
df[columnas_sensores] = scaler.transform(df[columnas_sensores])

# Seleccionamos el Motor 1 para la prueba
motor_1 = df[df['id_motor'] == 1]

print("2. Iniciando enlace Serial con MAJN (Arduino)...")
conexion = serial.Serial(PUERTO, BAUDIOS, timeout=2)
time.sleep(2) # Pausa obligatoria para que el Arduino despierte

# Le indicamos al Arduino que limpie su memoria RAM (Nuevo Motor)
conexion.write(b'R')
conexion.readline() # Esperamos el "RESET_OK"

print("3. Inyectando datos de vuelo en tiempo real...")

for index, row in motor_1.iterrows():
    ciclo = int(row['ciclo'])
    sensores_float = row[columnas_sensores].values

    # --- LA CUANTIZACIÓN (El puente entre Python y C++) ---
    # Multiplicamos los floats (0.0 a 1.0) por 64 para enviarlos como enteros
    sensores_int = [int(val * 64) for val in sensores_float]

    # Empaquetamos: La letra 'D' (Data) seguida de los 14 bytes de los sensores
    trama_bytes = b'D' + bytes([max(min(s, 127), -128) & 0xFF for s in sensores_int])

    # Inyectamos los datos por el cable USB
    conexion.write(trama_bytes)

    # Leemos la predicción que calculó el Arduino
    respuesta = conexion.readline().decode('utf-8').strip()

    if respuesta:
        estado, rul = respuesta.split(',')

        if estado == "OK":
            print(f"✈️ Vuelo {ciclo:03d} | Estado: OK | Vida útil: {float(rul):05.2f} ciclos")
        else:
            print(f"🔥 Vuelo {ciclo:03d} | Estado: CRÍTICO | Vida útil: {float(rul):05.2f} ciclos")
            print(">>> ALERTA ROJA: EL LED DEL ARDUINO SE ENCENDIÓ. PARADA DE PLANTA <<<")
            break # Detenemos la simulación para salvar el motor

    time.sleep(0.1) # Simulamos el tiempo entre un vuelo y otro

conexion.close()

La prueba de estrés industrial (100 motores):

Hice pasar los 20,631 vuelos de los 100 motores del Test Set por el cable USB a máxima velocidad. Aquí los resultados del Arduino:
0% de Falsos Negativos: El sistema detectó la falla inminente en los 100 motores sin que se le escapara uno solo.
36.3 vuelos de anticipación: En promedio, el Arduino encendió la alarma 36 vuelos antes de la muerte real del motor. El margen logístico perfecto para programar una parada de planta y solicitar repuestos sin caer en urgencias.

Conclusión

Este proyecto, que comenzó como una curiosidad con Google Gemini, me llevó desde la limpieza de datos en Pandas hasta el Bare-Metal en C++. Me demostró que para hacer Mantenimiento Predictivo; con ingeniería, matemáticas y entendiendo los límites del hardware, podemos llevar la Inteligencia Artificial a la base misma de la industria.

Aprendiendo Recurrent Neural Networks (Parte 2): Dándole "memoria" a nuestra red y logrando un MAE de 10.05

galp76 — Tue, 28 Apr 2026 08:46:51 +0000

En la Parte 1 de esta serie, comenzamos nuestro viaje para predecir la falla de turbinas aeroespaciales de la NASA. Logramos limpiar nuestros datos, eliminar los sensores "muertos", normalizar las lecturas y, lo más importante, aplicar el Piecewise Linear RUL topando la vida útil a 125 ciclos.

Teníamos una tabla de datos impecable, pero nos enfrentábamos a un problema grave: las redes neuronales clásicas no tienen memoria.

Si a una red normal le mostramos una foto de un manómetro marcando 50 PSI, no sabe si la presión está subiendo, bajando o estable. Pero si le muestro un "video" de los últimos 30 segundos donde la aguja pasa de 20 a 50 PSI, cualquier una red diseñada correctamente detectará una tendencia.

En esta Parte 2, vamos a convertir nuestros datos estáticos en "videos", construiremos nuestro cerebro con una red LSTM y veremos los asombrosos resultados.

El concepto de las "Sliding Windows" (Ventanas Deslizantes)

Para darle contexto histórico a nuestra IA, necesitamos transformar nuestra tabla plana (2D) en un cubo de datos (3D). Para esto usamos una técnica llamada Ventanas Deslizantes.

Definimos una ventana de 30 ciclos.

La IA mirará los vuelos del 1 al 30 de un motor, y tratará de predecir cuánto le queda en el ciclo 30.

Luego, la ventana se "desliza": mirará del 2 al 31, e intentará predecir el ciclo 31. Y así sucesivamente.

Aquí está la función en Python (usando NumPy) que hace esta magia:

import numpy as np

def crear_secuencias(df, longitud_secuencia, columnas_sensores):
    X, Y = [],[]

    # Iteramos motor por motor para no mezclar vuelos de turbinas distintas
    for id_motor in df['id_motor'].unique():
        df_motor = df[df['id_motor'] == id_motor]

        datos_sensores = df_motor[columnas_sensores].values
        datos_rul = df_motor['RUL'].values

        for i in range(len(df_motor) - longitud_secuencia + 1):
            ventana_X = datos_sensores[i : i + longitud_secuencia]
            X.append(ventana_X)

            # El objetivo a predecir es el RUL del ÚLTIMO ciclo de la ventana
            etiqueta_Y = datos_rul[i + longitud_secuencia - 1]
            Y.append(etiqueta_Y)

    return np.array(X), np.array(Y)

# Aplicamos la función pidiendo 30 ciclos de memoria hacia atrás
longitud_ventana = 30
X_train, Y_train = crear_secuencias(df_train, longitud_ventana, columnas_sensores)

print(f"Forma de X_train: {X_train.shape}")

Al ejecutar esto, la consola nos devolvió (17731, 30, 14).
¿Qué significa esto? Que hemos creado 17,731 "mini-videos", donde cada uno dura 30 ciclos temporales y monitorea 14 sensores simultáneamente.

Construyendo el Cerebro: La arquitectura LSTM

Con nuestros datos listos, era hora de usar TensorFlow/Keras para diseñar nuestra red neuronal.

Elegí una LSTM (Long Short-Term Memory). Estas redes tienen "compuertas" lógicas (olvido, entrada y salida) que deciden matemáticamente qué tendencias históricas son importantes para el desgaste y cuáles son solo ruido pasajero.

La arquitectura fue sencilla:


from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

model = Sequential()

# La Capa Mágica: 50 "neuronas" evaluando nuestras ventanas 3D
model.add(LSTM(units=50, return_sequences=False, input_shape=(30, 14)))

# Dropout del 20%: Apagamos aleatoriamente neuronas para evitar que 
# la red se "memorice" los datos (Overfitting) y la obligamos a generalizar.
model.add(Dropout(0.2))

# Capa de análisis matemático
model.add(Dense(units=32, activation='relu'))

# Salida: 1 sola neurona (Regresión). Nos dará un solo número: El RUL pronosticado.
model.add(Dense(units=1, activation='linear'))

# Optimizador Adam y Error Cuadrático Medio
model.compile(optimizer='adam', loss='mse', metrics=['mae'])

Total de parámetros entrenables: 14,665. (Este número será un dolor de cabeza en la Parte 3).

El Entrenamiento: Encendiendo los motores

Le pedí a la red que estudiara el dataset dando 40 pasadas completas (epochs=40), procesando en lotes de 64 "videos" a la vez, y escondiéndole un 10% de los datos para que se examinara a sí misma sin hacer trampa (validation_split=0.1).

print("¡Iniciando el entrenamiento de la Red Neuronal LSTM...")

historial = model.fit(
    X_train,
    Y_train,
    epochs=40,          # Dará 40 pasadas completas a los datos
    batch_size=64,      # Procesará los videos en bloques de 64
    validation_split=0.1, # Guarda un 10% de datos para examinarse a sí misma
    verbose=1           # Muestra una barra de progreso bonita
)

print("¡Entrenamiento finalizado!")

Al graficar el Error Absoluto Medio (MAE), vi lo siguiente: a partir de la época 10, la línea de error dejaba de caer bruscamente y empezaba a zigzaguear en el fondo. La red neuronal ya había entendido la termodinámica y el desgaste de los motores de la NASA casi a la perfección.

import matplotlib.pyplot as plt

# Configuramos el tamaño del gráfico
plt.figure(figsize=(10, 5))

# Graficamos el MAE de entrenamiento y el de validación
plt.plot(historial.history['mae'], label='Error de Entrenamiento (MAE)', color='blue')
plt.plot(historial.history['val_mae'], label='Error de Validación (val_MAE)', color='red', linestyle='--')

# Le ponemos títulos y etiquetas para que se vea profesional
plt.title('Curva de Aprendizaje del Modelo LSTM (Predicción de RUL)')
plt.xlabel('Épocas (Iteraciones de aprendizaje)')
plt.ylabel('Margen de Error Promedio (Ciclos)')
plt.legend()
plt.grid(True)

# Mostramos el gráfico
plt.show()

El "Jefe Final": El Test Set

En Machine Learning, sacar buenas notas en el entrenamiento no sirve de nada si el modelo falla en el mundo real.

Tomamos el archivo test_FD001.txt. A diferencia de los datos de entrenamiento, a estos motores se les cortó el registro antes de fallar. Tuvimos que pasarle a nuestra red los últimos 30 ciclos de estos motores "ciegos" y preguntarle: "¿Cuántos vuelos le quedan?". Luego, comparamos sus respuestas con el archivo secreto de respuestas reales.

import pandas as pd
import numpy as np
from sklearn.metrics import mean_absolute_error

print("1. Cargando datos de prueba...")
# Cargamos el test set
df_test = pd.read_csv('test_FD001.txt', sep=r'\s+')

# Eliminamos las mismas columnas inútiles
df_test.drop(columns=columnas_a_eliminar, inplace=True)

# NORMALIZACIÓN (¡ATENCIÓN AQUÍ!)
# Usamos transform() y NO fit_transform(). Queremos usar la misma escala
# que aprendimos con los datos de entrenamiento para no confundir a la red.
df_test[columnas_sensores] = scaler.transform(df_test[columnas_sensores])

print("2. Extrayendo la última ventana (30 ciclos) de cada motor...")
X_test =[]
# Agrupamos por motor
for engine in df_test['engine'].unique():
    df_motor = df_test[df_test['engine'] == engine]

    # Solo nos interesan los ÚLTIMOS 30 ciclos de este motor para predecir su futuro
    # Si el motor tiene menos de 30 ciclos, esto fallaría, pero en FD001 todos tienen más de 30.
    datos_sensores = df_motor[columnas_sensores].values[-longitud_ventana:]
    X_test.append(datos_sensores)

X_test = np.array(X_test)
print(f"Forma de X_test lista para la red: {X_test.shape}")

print("3. Cargando las respuestas correctas (True RUL)...")
# Cargamos el archivo con los RUL reales
Y_test = pd.read_csv('RUL_FD001.txt', sep=r'\s+', header=None, names=['RUL_real'])

# Aplicamos el mismo tope de 125 (Piecewise RUL) a las respuestas correctas
Y_test['RUL_real'] = Y_test['RUL_real'].clip(upper=125)
Y_test_real = Y_test['RUL_real'].values

print("4. ¡Haciendo las predicciones con la Red Neuronal!")
# Le pedimos a la red que prediga
predicciones = model.predict(X_test)

# Calculamos el error final
error_final_mae = mean_absolute_error(Y_test_real, predicciones)

print("\n==================================================")
print(f"ERROR ABSOLUTO MEDIO EN EL TEST SET (FINAL BOSS): {error_final_mae:.2f} ciclos")

print("==================================================")

El resultado arrojado en la consola fue:
ERROR ABSOLUTO MEDIO EN EL TEST SET: 10.05 ciclos.

¡Un resultado fenomenal! Pasamos de un intento exploratorio inicial con un perceptrón multicapa y un modesto 60% de precisión, a un modelo recurrente capaz de predecir la falla inminente de un motor con un margen de error promedio de solo 10 vuelos. En la industria, tener esta ventana de certeza es oro puro para pedir repuestos, evitar correctivos catastróficos y programar paradas de planta.

¿Qué sigue ahora?

Teníamos un modelo exitoso, entrenado en la nube con Python y punto flotante de 32 bits. El proyecto podría haber terminado aquí.

Pero quise llevarlo al mundo físico: ¿Y si metemos este "cerebro" dentro de un microcontrolador?

Me compré un Arduino Uno, pensando ingenuamente que "todas las placas son iguales", lo cual complicó (para bien) las siguientes partes del experimento.

El problema: El modelo pesa casi 60 KB, pero un Arduino Uno tiene apenas 2 KB de memoria RAM.

En la Parte 3 de esta serie (más técnica que las anteriores), veremos como (con mucha ayuda de Google Gemini) agarramos esta red neuronal, la comprimimos a 8 bits aplicando una técnica llamada cuantización y escribimos un motor de álgebra lineal en C++ para hacerla correr dentro del Arduino.

¡Nos vemos en la siguiente entrega!

Aprendiendo Recurrent Neural Networks: prediciendo fallas usando el dataset C-MAPSS de la NASA, Python y C++

galp76 — Tue, 07 Apr 2026 23:13:01 +0000

Bienvenidos a esta serie de posts. Lo que están por leer comenzó como un simple ejercicio de fin de semana para aprender a usar el ecosistema de Deep Learning en Python. Mi objetivo era trabajar en redes neuronales aplicadas al mantenimiento predictivo. Pero las cosas se fueron complicando y el proyecto ya incluye un microcontrolador Arduino Uno y C++. Para no hacer de esto un texto interminable, he decidido dividir la historia. En esta Parte 1, arrancaremos desde el principio: el análisis, limpieza y preparación de los datos de la NASA usando Python.

El contexto

Soy Ingeniero Industrial desde el año 2002 y, desde el 2020, también soy un apasionado autodidacta de la programación. Hace algunas semanas le pregunté a Google Gemini si podía ayudarme a encontrar un proyecto donde pudiera aplicar ambas áreas. ¿Su respuesta? Una genialidad: usar el famoso Turbofan Engine Degradation Simulation Dataset de la NASA para entrenar redes neuronales y hacer mantenimiento predictivo. Así nació MAJN (el nombre lo escogió mi hijo), y así comenzó el proyecto que quiero documentar a través de esta serie.

Buckle your seatbelt, Dorothy, 'cause Kansas is going bye-bye.

Hasta ahora había jugado con redes neuronales simples y un clasificador que alcanzaba fácilmente el 99,9 % de precisión.

Pero este dataset de la NASA es otro nivel.

Aquí ya no basta con un perceptrón multicapa tradicional. Vamos a tener que trabajar con series temporales, memoria a largo plazo y redes LSTM de verdad.

Primer intento

Hace algunos meses usé el código del excelente libro Neural Networks and Deep Learning de Michael Nielsen para entrenar un clasificador sencillo de tan solo 3 clases, el cual obtuvo 99,9% de precisión en los tests, así que decidí hacer pruebas con este nuevo Dataset.
Comenzamos a trabajar con el archivo train0001.txt del dataset. La primera prueba dió apenas un 50% de precisión en los tests, y después de nuevas iteraciones (más capas, más neuronas por capa, mas épocas) solo pude obtener un 59% en los tests, así que tocó hacerle caso a Gemini y aprovechar el dataset preparado para el Perceptrón en el entrenamiento de una Red Neuronal Recurrente, una red LSTM para ser más exactos. Estas están diseñadas específicamente para trabajar con series temporales, donde es vital tomar en consideración cómo evolucionan las variables independientes (en nuestro caso, los datos de los sensores) en función del tiempo.

Preparando los datos

Aquí está el código que usamos para preparar el dataset. Como ya se sabe, los datos de train_FD001.txt fueron simulados usando una sola condición de vuelo, así que lo primero que tuvimos que hacer fue buscar sensores que no cambiaran sus valores a lo largo de la vida de los motores, ya que los mismos representan ruido en el dataset a la hora de entrenar la red neuronal. Para ello, convertimos train_FD001.txt en un Dataframe de Pandas y usamos la función describe() para ubicar desviaciones estándar iguales o cercanas a cero.

import pandas as pd

# Definimos los nombres de las 26 columnas
nombres_columnas =[
    'id_motor', 'ciclo', 
    'config_1', 'config_2', 'config_3', 
    'sensor_1', 'sensor_2', 'sensor_3', 'sensor_4', 'sensor_5', 
    'sensor_6', 'sensor_7', 'sensor_8', 'sensor_9', 'sensor_10', 
    'sensor_11', 'sensor_12', 'sensor_13', 'sensor_14', 'sensor_15', 
    'sensor_16', 'sensor_17', 'sensor_18', 'sensor_19', 'sensor_20', 
    'sensor_21'
]

# TIP: Usamos sep=r'\s+' porque los datos están separados por uno o más espacios, no por comas.
df_train = pd.read_csv('train_FD001.txt', sep=r'\s+', header=None, names=nombres_columnas)

# Ver las primeras 5 filas para comprobar que cargó bien
print(df_train.head())
# Buscamos valores de std iguales o cercanos a cero
df_train.describe()

Despues del análisis se decidió eliminar los sensores 1, 5, 6, 10, 16, 18 y 19, junto con las 3 configuraciones operativas, ya que no aportan ninguna información útil. Estas eliminaciones son la regla estándar para el estudio del dataset FD001.

# Lista de columnas inútiles para FD001
columnas_a_eliminar =['config_1', 'config_2', 'config_3', 
                       'sensor_1', 'sensor_5', 'sensor_6', 'sensor_10', 
                       'sensor_16', 'sensor_18', 'sensor_19']

# Eliminamos esas columnas de nuestro DataFrame de entrenamiento
df_train.drop(columns=columnas_a_eliminar, inplace=True)

El siguiente paso es crear la columna de Vida Útil Restante (RUL), que será la meta (Y) que nuestra red neuronal aprenderá a predecir.

# Creamos una columna temporal con la vida máxima de CADA motor
df_train['ciclo_max'] = df_train.groupby('id_motor')['ciclo'].transform('max')

# Calculamos el RUL restando el ciclo máximo menos el ciclo actual
df_train['RUL'] = df_train['ciclo_max'] - df_train['ciclo']

# Ya no necesitamos la columna temporal, la borramos
df_train.drop(columns=['ciclo_max'], inplace=True)

El siguiente paso es aplicar el tope al RUL: añadimos esta línea al código para topar el RUL máximo a 125 (el estándar en la NASA para este problema):

# Todo RUL mayor a 125, se convierte en 125.
df_train['RUL'] = df_train['RUL'].clip(upper=125)

Normalización de datos de sensores

¿Qué hace la Normalización?
Toma todas las columnas, sin importar si son RPM, grados Celsius o PSI, y las exprime para meterlas en una misma escala estándar (usualmente entre 0 y 1 o entre -1 y 1).
Así, el valor máximo de RPM (15,000) se convierte en "1.0", y el valor máximo de vibración (0.05) también se convierte en "1.0". Ahora, la red neuronal los trata con el mismo nivel de respeto y puede descubrir cuál importa realmente para predecir la falla basándose en su comportamiento, no en su tamaño. OJO AQUÍ: No podemos normalizar a lo loco. El id_motor, el ciclo y nuestra meta RUL NO se normalizan. Esos son nuestros identificadores y nuestra respuesta en ciclos reales. Solo vamos a normalizar las columnas de los sensores (nuestra "X").

from sklearn.preprocessing import MinMaxScaler

# 1. Identificamos cuáles son las columnas de los sensores que nos quedaron
# (Es decir, todas menos id_motor, ciclo y RUL)
columnas_sensores = df_train.columns.drop(['id_motor', 'ciclo', 'RUL'])

# 2. Inicializamos el escalador
scaler = MinMaxScaler()

# 3. Entrenamos el escalador y transformamos los datos (solo los sensores)
df_train[columnas_sensores] = scaler.fit_transform(df_train[columnas_sensores])

En este primer post nos enfocamos en entender el dataset y preparar los datos. En la próxima entrega entraremos de lleno en ventanas deslizantes (sliding windows), secuencias temporales y el corazón del modelo: las redes LSTM.

🚀 ¡ACTUALIZACIÓN! La historia continúa...
Ya está publicada la segunda entrega de esta serie. En ella damos el salto al Deep Learning: transformamos nuestros datos estáticos en secuencias temporales (sliding windows), diseñamos el "cerebro" usando una red LSTM y ponemos a prueba el modelo logrando un margen de error de apenas 10 vuelos.

👉 Lee la Parte 2: Dándole "memoria" a nuestra red y logrando un MAE de 10.05 haciendo clic aquí

Día Cero en Venezuela: Creando un Monitor Económico 24/7 con Python y Termux

galp76 — Sun, 11 Jan 2026 17:37:18 +0000

El contexto
Nací y he vivido toda mi vida en Venezuela. El pasado 3 de enero de 2026 ocurrió un hecho histórico: Estados Unidos llevó a cabo una operación de extracción de Nicolás Maduro. Más allá del impacto político, como ingeniero entiendo que estamos ante un "Quiebre Estructural" (Structural Break) en la historia del país.

Hoy comienzo esta serie de artículos con tres propósitos claros:

Documentar la historia: Registrar con datos duros el comportamiento de algunos indicadores económicos clave en lo que, espero, será la recuperación de la economía del país.
Aprendizaje Técnico: Explorar y dominar el ecosistema de Análisis de Datos con Python (Pandas, Openpyxl, Matplotlib, Seaborn, Visidata) aplicado a un problema del mundo real.
Comprensión Macroeconómica: Más allá del código, con este proyecto busco entender los conceptos que mueven la economía del país, aprendiendo sobre conceptos como la Liquidez Monetaria (M2), las Reservas Operativas y el Tipo de Cambio Implícito. Mi meta es aprender la teoría económica de la forma más efectiva posible: programando su lógica y validándola con datos reales.

La Construcción del Dataset (2024-2025)
Para entender hacia dónde vamos, primero tuve que reconstruir de dónde venimos, con este fin, utilicé las siguientes estrategias de Ingeniería de Datos:

Minería de Fuentes Oficiales (BCV): Descargué reportes del Banco Central de Venezuela, luego, utilizando la librería Openpyxl, extraje la información de liquidez monetaria, reservas internacionales y tipo de cambio oficial, transformando hojas de cálculo en un formato CSV unificado y limpio.
Reconstrucción de Series de Tiempo: Ante la falta de datos diarios del mercado paralelo, utilicé herramientas de IA (Perplexity y Grok) para obtener los cierres mensuales de 2024 y 2025. Posteriormente, utilicé Pandas para aplicar técnicas de interpolación lineal (upsampling), convirtiendo 24 puntos de datos mensuales en una serie continua de 730 días.
Monitoreo en Tiempo Real: Para la data actual (2026 en adelante), implementé bots de web scraping modulares. Con el objetivo de garantizar una recolección de datos continua (24/7) sin comprometer recursos ni mantener una laptop encendida permanentemente, desplegué estos scripts directamente en mi smartphone (utilizando el entorno Linux de la aplicación Termux). Mediante la configuración de Cron Jobs, automaticé la ejecución exacta de los procesos cada hora, creando un servidor de recolección de datos portátil, eficiente y de bajo consumo energético que monitorea el dólar paralelo y el petróleo Brent.

En los próximos posts, compartiré el código fuente, las gráficas resultantes y el análisis de estos primeros días de operación.

Intentando implementar guardrails en mi red neuronal: enseñando a Prize a no dar consejos médicos

galp76 — Tue, 23 Dec 2025 17:21:36 +0000

Nota: Este es el 4to post de la serie "Entrenando mi red neuronal sin frameworks".
Si te perdiste el inicio:
Parte 1: La Idea y la Arquitectura
Parte 2: Ingeniería de datos
Parte 3: 99.9% de precisión en Test Data tras 4 horas de Vibe Coding

Introducción
La semana pasada conseguí y celebré una gran victoria personal: logré que Prize, mi red neuronal casera, clasificara intenciones de búsqueda entre 2 clases (farmacia y laboratorio dental) con una precisión de 99.9%.

Para este post tenía pensado hacer un benchmarking entre Prize y mi API usando OpenRouter, pero decidí primero intentar entrenar a Prize para que identifique cuando un usuario está pidiendo consejo médico, con el objeto de poder indicarle de manera respetuosa que busque ayuda médica especializada para su problema.

Para este propósito vamos a proceder al igual que en el post # 2 de esta serie, usando el mismo script y reemplazando la lista de strings semillas_laboratorio por una nueva lista con frases relevantes para nuestro propósito. Por lo demás el archivo es exactamente el mismo.

Un viejo amigo escrito en Go
Luego de tener listas nuestras 5500 frases pidiendo consejo médico, procedemos a convertirlas en embeddings usando la API de OpenRouter y un script escrito en Go que me traje de otro proyecto, aquí les dejo el script:

package main

import (
    "bufio"
    "bytes"
    "encoding/csv"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "strconv"
    "strings"
)

// Configuración
const (
    ApiKey     = "XXXXXXX"
    BaseURL    = "https://openrouter.ai/api/v1/embeddings"
    ModelID    = "qwen/qwen3-embedding-8b"
    InputFile  = "dataset_consejo_medico_sintetico.txt"
    OutputFile = "embeddings_consejo_medico.txt"
    BatchSize  = 20
)

// Estructuras para enviar la petición JSON
type EmbeddingRequest struct {
    Model          string   `json:"model"`
    Input          []string `json:"input"`
    EncodingFormat string   `json:"encoding_format"`
    Dimensions     int      `json:"dimensions,omitempty"`
}

// Estructuras para recibir la respuesta JSON
type EmbeddingResponse struct {
    Data []struct {
        Embedding []float64 `json:"embedding"`
        Index     int       `json:"index"`
    } `json:"data"`
    Error *struct {
        Message string `json:"message"`
    } `json:"error,omitempty"`
}

func main() {
    // 1. Carga el archivo con los strings
    medicinas, err := leerMedicinas(InputFile)
    if err != nil {
        log.Fatalf("Error leyendo el archivo: %v", err)
    }

    fmt.Printf("Total de medicinas a procesar: %d\n", len(medicinas))

    // 2. Preparar archivo CSV de salida
    file, err := os.Create(OutputFile)
    if err != nil {
        log.Fatalf("No se pudo crear el archivo CSV: %v", err)
    }
    defer file.Close()

    writer := csv.NewWriter(file)
    defer writer.Flush()

    // 3. Procesar por lotes
    for i := 0; i < len(medicinas); i += BatchSize {
        fin := i + BatchSize
        if fin > len(medicinas) {
            fin = len(medicinas)
        }

        batch := medicinas[i:fin]
        fmt.Printf("Procesando lote %d (%d items)...\n", (i/BatchSize)+1, len(batch))

        // Llamada a la API
        embeddings, err := obtenerEmbeddings(batch)
        if err != nil {
            fmt.Printf("Error procesando el lote: %v\n", err)
            break // Paramos si hay error grave, igual que en el script Python
        }

        // Guardar en CSV
        for _, embedding := range embeddings {
            // Creamos una fila: [Texto Original, float1, float2, ...]
            row := make([]string, len(embedding)+1)

            // Primera columna: Texto original
            //row[0] = batch[j]

            // Resto columnas: Valores del vector convertidos a string
            for k, val := range embedding {
                // 'f' para float, -1 precisión automática, 64 bits
                row[k] = strconv.FormatFloat(val, 'f', 5, 64)
            }

            if err := writer.Write(row); err != nil {
                log.Printf("Error escribiendo fila en CSV: %v", err)
            }
        }
        // Forzamos escritura al disco tras cada lote por seguridad
        writer.Flush()
    }

    // Iteramos sobre OutputFile para eliminar la coma ',' al final de cada línea
    input, err := os.ReadFile(OutputFile)
    if err != nil {
        log.Fatalf("Error leyendo el archivo para limpieza: %v", err)
    }

    lines := strings.Split(string(input), "\n")
    for i, line := range lines {
        lines[i] = strings.TrimRight(line, ",")
    }
    output := strings.Join(lines, "\n")

    err = os.WriteFile(OutputFile, []byte(output), 0644)
    if err != nil {
        log.Fatalf("Error escribiendo el archivo limpio: %v", err)
    }

    // Notificamos al usuario el fin del proceso
    fmt.Printf("Proceso finalizado. Embeddings guardados en %s\n", OutputFile)
}

// Función para leer el archivo de texto
func leerMedicinas(ruta string) ([]string, error) {
    if _, err := os.Stat(ruta); os.IsNotExist(err) {
        return nil, fmt.Errorf("no se encuentra el archivo %s", ruta)
    }

    file, err := os.Open(ruta)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    var lineas []string
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        texto := strings.TrimSpace(scanner.Text())
        if texto != "" {
            lineas = append(lineas, texto)
        }
    }
    return lineas, scanner.Err()
}

// Función para hacer la petición HTTP a OpenRouter
func obtenerEmbeddings(inputs []string) ([][]float64, error) {
    reqBody := EmbeddingRequest{
        Model:          ModelID,
        Input:          inputs,
        EncodingFormat: "float",
        Dimensions:     1024,
    }

    jsonData, err := json.Marshal(reqBody)
    if err != nil {
        return nil, err
    }

    req, err := http.NewRequest("POST", BaseURL, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer "+ApiKey)
    // Opcional: HTTP-Referer y X-Title son requeridos a veces por OpenRouter para rankings
    req.Header.Set("HTTP-Referer", "http://localhost")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    bodyBytes, _ := io.ReadAll(resp.Body)

    if resp.StatusCode != 200 {
        return nil, fmt.Errorf("status code %d: %s", resp.StatusCode, string(bodyBytes))
    }

    var apiResponse EmbeddingResponse
    if err := json.Unmarshal(bodyBytes, &apiResponse); err != nil {
        return nil, fmt.Errorf("error decodificando JSON: %v", err)
    }

    if apiResponse.Error != nil {
        return nil, fmt.Errorf("api error: %s", apiResponse.Error.Message)
    }

    // Extraemos solo los vectores
    resultado := make([][]float64, len(apiResponse.Data))
    for i, item := range apiResponse.Data {
        vec := item.Embedding

        // --- VERIFICACIÓN DE SEGURIDAD ---
        // Si el proveedor ignoró el parámetro 'dimensions' y mandó 4096,
        // cortamos el vector aquí mismo.
        if len(vec) > 1024 {
            vec = vec[:1024]
        }

        resultado[i] = vec
    }

    return resultado, nil
}

func obtenerEmbedding(input string) ([]float64, error) {
    // Envolvemos el string único en un slice porque el struct EmbeddingRequest
    // probablemente define Input como []string.
    reqBody := EmbeddingRequest{
        Model:          ModelID,
        Input:          []string{input},
        EncodingFormat: "float",
        Dimensions:     1024,
    }

    jsonData, err := json.Marshal(reqBody)
    if err != nil {
        return nil, err
    }

    req, err := http.NewRequest("POST", BaseURL, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer "+ApiKey)
    req.Header.Set("HTTP-Referer", "http://localhost")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    bodyBytes, _ := io.ReadAll(resp.Body)

    if resp.StatusCode != 200 {
        return nil, fmt.Errorf("status code %d: %s", resp.StatusCode, string(bodyBytes))
    }

    var apiResponse EmbeddingResponse
    if err := json.Unmarshal(bodyBytes, &apiResponse); err != nil {
        return nil, fmt.Errorf("error decodificando JSON: %v", err)
    }

    if apiResponse.Error != nil {
        return nil, fmt.Errorf("api error: %s", apiResponse.Error.Message)
    }

    // Verificamos que la API haya devuelto al menos un elemento
    if len(apiResponse.Data) == 0 {
        return nil, fmt.Errorf("la API no devolvió ningún embedding")
    }

    // Verificación de seguridad (opcional):
    // A veces OpenRouter puede ignorar el parámetro 'dimensions' dependiendo del proveedor.
    // Si te devuelve 4096, este código de respaldo lo corta.
    vector := apiResponse.Data[0].Embedding
    if len(vector) > 1024 {
        return vector[:1024], nil
    }

    return vector, nil
}

Ya con nuestros embeddings listos, procedimos al entrenamiento usando los mismos scripts del post anterior, actualizándolos con cambios menores para trabajar con 3 neuronas de salida en vez de 2.

El entrenamiento
Al igual que en el primer entrenamiento, procedimos a fijar 30 épocas y ver como se comportaba Prize, aquí están los números:

En este punto, más que suerte de principiante, esto confirma la potencia de usar embeddings de calidad: al facilitar el trabajo semántico, la red aprende volando.

Volvemos a ver como Prize alcanza una precisión mayor al 99%, y ya a partir de la época 4 predice correctamente 3194 de los 3196 casos de prueba (99,94%). Sin embargo, me llamó la atención los valores altos del costo en el entrenamiento. Investigando sobre esto, entendí que estos valores altos en el costo no son un error, sino una consecuencia de la regularización L2 del script network2.py haciendo su trabajo: penalizar pesos altos para evitar que la red memorice datos, aunque la precisión sea casi perfecta. Con el objetivo de evaluar esta hipótesis sobre los valores del costo y la regularización, hice una nueva ronda de entrenamiento fijando en 0.0 el valor de lambda para "apagar" la regularización, aquí están los resultados:

Podemos observar como efectivamente, esta vez obtenemos los mismos resultados de precisión, pero esta vez con unos valores para el costo muy inferiores a la primera ronda.

Conclusión: Una IA más responsable
Con este ajuste, Prize ha evolucionado. Ya no es solo una máquina rápida; ahora tiene una capa de seguridad ética. Ahora, cuando un usuario pregunte "qué puedo tomar para el dolor", mi aplicación no le lanzará una lista de medicinas y precios. Gracias a esta nueva clase, detectaremos la intención y podremos responder: "Lo sentimos, no podemos dar consejo médico. Te sugerimos visitar a un especialista."

Para la próxima semana haremos el benchmarking entre Prize y mi API usando OpenRouter, para poder evaluar con datos la pertinencia del trabajo hecho en estas semanas.

Prize Pt. 3: 99.9% de precisión en Test Data tras 4 horas de Vibe Coding con Gemini Pro

galp76 — Mon, 08 Dec 2025 17:34:01 +0000

Nota: Este es el 3er post de la serie "Entrenando mi red neuronal sin frameworks".
Si te perdiste el inicio:
Parte 1: La Idea y la Arquitectura
Parte 2: Ingeniería de datos
Ya está publicado el 4to post de la serie:
Parte 4: Enseñando a Prize a no dar consejos médicos

Introducción: Cuando "un rato" se convierte en magia

Ayer domingo me desperté con una intención modesta: dedicarle "un par de horas" a avanzar con Prize, mi proyecto de red neuronal casera. Mi plan era simplemente configurar algunos archivos y quizás dejar todo listo para trabajar con los hiperparámetros y el entrenamiento durante la semana.

Pero esta intención se convirtió en 4 horas de "vibe coding".

Lo primero fue convertir los ~11.000 items del data set en embeddings, usando la API de OpenRouter y el excelente modelo qwen/qwen3-embedding-8b.

Luego, con la ayuda de Google Gemini Pro, empezó la sesión de "vibe coding": Lo que iba a ser una sesión de configuración se convirtió en una maratón donde resolvimos problemas de formatos, ajustamos dimensiones vectoriales y depuramos matrices de Numpy.

El resultado no fue solo "un avance". Fue el nacimiento oficial de Prize.

El Entrenamiento: 99% en la primera vuelta

Corrí el script de entrenamiento main.py esperando ver una curva de aprendizaje lenta. Aquí les dejo el código:

prize_loader.py

import numpy as np
import random
import argparse
import sys
import os

INPUT_SIZE = 1024   
OUTPUT_SIZE = 2     # Clase 0: Farmacia, Clase 1: Laboratorio

def vectorizar_entrada(lista_floats):
    """Convierte lista a matriz columna (1024, 1) para Numpy"""
    return np.reshape(lista_floats, (INPUT_SIZE, 1))

def vectorizar_salida(indice_clase):
    """One-Hot Encoding: Clase 0 -> [[1], [0]], Clase 1 -> [[0], [1]]"""
    y = np.zeros((OUTPUT_SIZE, 1))
    y[indice_clase] = 1.0
    return y

def cargar_csv_embeddings(ruta):
    """
    Lee un archivo de texto donde cada línea son 1024 floats separados por coma.
    Ej: 0.029,0.022,...
    """
    if not os.path.exists(ruta):
        print(f"Error: No se encuentra el archivo '{ruta}'")
        sys.exit(1)

    dataset = []
    print(f"  -> Leyendo CSV: {ruta}...")

    with open(ruta, 'r', encoding='utf-8') as f:
        for i, linea in enumerate(f):
            linea = linea.strip()
            if not linea: continue # Saltar líneas vacías

            try:
                # Convertir "0.1, 0.2" -> [0.1, 0.2]
                vector = [float(x) for x in linea.split(',')]

                # Validación rápida de dimensiones
                if len(vector) == INPUT_SIZE:
                    dataset.append(vector)
                else:
                    # Opcional: Avisar si una línea tiene tamaño incorrecto
                    if i < 5: print(f"    ⚠️ Línea {i+1} ignorada: tiene {len(vector)} dimensiones (se esperan {INPUT_SIZE})")
            except ValueError:
                print(f"    ⚠️ Error de formato en línea {i+1}")
                continue

    return dataset

def create_prize_datasets(ruta_farmacia, ruta_lab):
    print(f"--- Cargando Datos (Formato CSV) ---")

    # 1. Cargar vectores crudos
    raw_farmacia = cargar_csv_embeddings(ruta_farmacia)
    raw_lab = cargar_csv_embeddings(ruta_lab)

    print(f"✅ Leídos: {len(raw_farmacia)} Farmacia | {len(raw_lab)} Laboratorio")

    dataset_completo = []

    # 2. Etiquetar FARMACIA (Clase 0)
    label_farmacia = vectorizar_salida(0) 
    for vector in raw_farmacia:
        x = vectorizar_entrada(vector)
        dataset_completo.append((x, label_farmacia, 0))

    # 3. Etiquetar LABORATORIO (Clase 1)
    label_lab = vectorizar_salida(1)
    for vector in raw_lab:
        x = vectorizar_entrada(vector)
        dataset_completo.append((x, label_lab, 1))

    # 4. Barajar y Dividir
    random.shuffle(dataset_completo)

    split_index = int(len(dataset_completo) * 0.8)
    train_slice = dataset_completo[:split_index]
    test_slice = dataset_completo[split_index:]

    # Formatear para Nielsen
    training_data = [(x, y) for x, y, _ in train_slice]
    test_data = [(x, idx) for x, _, idx in test_slice]

    print(f"📊 Dataset Final: {len(training_data)} Train / {len(test_data)} Test")

    return training_data, test_data

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("-f", "--farmacia", required=True)
    parser.add_argument("-l", "--laboratorio", required=True)
    args = parser.parse_args()

    create_prize_datasets(args.farmacia, args.laboratorio)

main.py

import argparse
import network2      
import prize_loader  
import sys

def main():
    parser = argparse.ArgumentParser(description="Entrenar Red Neuronal Prize (Network2)")
    parser.add_argument("-f", "--farmacia", required=True, help="JSON Farmacia")
    parser.add_argument("-l", "--laboratorio", required=True, help="JSON Laboratorio")
    parser.add_argument("-e", "--epochs", type=int, default=30, help="Épocas")
    parser.add_argument("-r", "--rate", type=float, default=0.5, help="Learning Rate")
    parser.add_argument("-x", "--lmbda", type=float, default=5.0, help="Regularización Lambda")
    parser.add_argument("-b", "--batch", type=int, default=10, help="Mini-batch size")

    # Nuevo argumento para el nombre del archivo de salida
    parser.add_argument("-o", "--output", default="prize_model.json", help="Archivo donde guardar el cerebro (JSON)")

    args = parser.parse_args()

    # Cargar datos
    training_data, test_data = prize_loader.create_prize_datasets(
        args.farmacia, 
        args.laboratorio
    )

    print(f"\n🧠 Inicializando Prize Network2 [1024 -> 50 -> 2]")
    net = network2.Network([1024, 50, 2], cost=network2.CrossEntropyCost)

    print(f"🚀 Iniciando entrenamiento. Pulsa Ctrl+C para detener y guardar anticipadamente.")

    # --- BLOQUE DE SEGURIDAD ---
    try:
        net.SGD(training_data, 
                args.epochs, 
                args.batch, 
                args.rate, 
                lmbda=args.lmbda,
                evaluation_data=test_data,
                monitor_evaluation_accuracy=True, 
                monitor_evaluation_cost=True)

        print("\n✅ Entrenamiento finalizado correctamente.")

    except KeyboardInterrupt:
        print("\n\n⚠️ Interrupción detectada (Ctrl+C).")
        print("🛑 Deteniendo entrenamiento...")

    finally:
        # Esto se ejecuta SIEMPRE: si termina bien O si das Ctrl+C
        print(f"💾 Guardando el cerebro de Prize en '{args.output}'...")
        net.save(args.output)
        print("¡Guardado! Tu red está segura.")

if __name__ == "__main__":
    main()

Me preparé para esperar 30 épocas para ver resultados decentes. Pero Prize tenía otros planes. Miren el log de la terminal apenas segundos después de iniciar:

¿Lo ven? En la Época 0, la red ya tenía una precisión del 99.47%. Para la Época 4, alcanzó el 99.9%.

Suerte de principiante supongo.

¿Por qué tan rápido?
Según Gemini, la clave fue usar Embeddings como entrada, ya que de esta manera la red no tuvo que aprender a leer español desde cero. Ya "sabía" que la palabra "amoxicilina" y "prótesis" viven en planetas diferentes dentro del universo semántico. Prize solo tuvo que aprender a trazar la frontera entre esos dos mundos.

La Prueba de Fuego: Prize en la Terminal

Con los pesos guardados en prize_model.json, escribimos un último script: prize_inference.py. Quería ver a la red funcionando en la terminal.

import sys
import os
import argparse
import json
import numpy as np
import requests
import network2  # El archivo del libro que contiene la clase Network

# --- CONFIGURACIÓN CRÍTICA ---
# 1. API KEY de OpenRouter
API_KEY = "XXXXXXX" 

# 2. El nombre EXACTO del modelo de embeddings
MODEL_ID = "qwen/qwen3-embedding-8b" # <--- AJUSTA ESTO AL MODELO DE EMBEDDINGS CORRECTO

# URL de OpenRouter para embeddings
API_URL = "https://openrouter.ai/api/v1/embeddings"

# Definición de Clases
CLASES = {
    0: "💊 FARMACIA",
    1: "🦷 LABORATORIO DENTAL"
}

def get_embedding_from_api(text):
    """
    Envía el texto a la API y devuelve el vector de 1024 floats.
    """
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
        "HTTP-Referer": "https://prize.local",
    }

    payload = {
        "model": MODEL_ID,
        "input": text,
        "dimensions": 1024
    }

    try:
        response = requests.post(API_URL, headers=headers, json=payload, timeout=10)

        if response.status_code != 200:
            print(f"❌ Error API ({response.status_code}): {response.text}")
            sys.exit(1)

        result = response.json()

        # OpenRouter/OpenAI devuelven data en: data[0]['embedding']
        if 'data' in result and len(result['data']) > 0:
            vector = result['data'][0]['embedding']
            return vector
        else:
            print(f"❌ Respuesta API inesperada: {result}")
            sys.exit(1)

    except Exception as e:
        print(f"❌ Error de conexión: {e}")
        sys.exit(1)

def main():
    parser = argparse.ArgumentParser(description="Prize: Clasificador IA Todo-en-Uno")
    parser.add_argument("query", type=str, help="El texto que quieres clasificar (entre comillas)")
    parser.add_argument("-m", "--model", default="prize_model.json", help="Ruta al archivo del cerebro entrenado")

    args = parser.parse_args()

    # 1. Validaciones Iniciales
    if not os.path.exists(args.model):
        print(f"❌ Error: No encuentro el archivo '{args.model}'. ¿Ya entrenaste a Prize?")
        sys.exit(1)

    if API_KEY.startswith("sk-or-v1-..."):
        print("⚠️ ADVERTENCIA: No has configurado tu API_KEY en el script.")

    print(f"\n🤖 Prize System v1.0")
    print(f"Query: '{args.query}'")

    # 2. Generar Embedding (Reemplaza al script de Go)
    print("📡 Conectando con OpenRouter para vectorizar...")
    vector_lista = get_embedding_from_api(args.query)

    # Verificar dimensiones
    dim = len(vector_lista)
    if dim != 1024:
        print(f"❌ ERROR CRÍTICO: El modelo devolvió {dim} dimensiones, pero Prize espera 1024.")
        print("Solución: Verifica que MODEL_ID en el script sea el mismo que usaste para entrenar.")
        sys.exit(1)

    # Convertir a formato Numpy para Nielsen (Columna 1024x1)
    vector_numpy = np.reshape(vector_lista, (1024, 1))

    # 3. Cargar el Cerebro
    print("🧠 Cargando red neuronal...")
    net = network2.load(args.model)

    # 4. Inferencia
    print("🔮 Clasificando...")
    output = net.feedforward(vector_numpy)

    # Extraer probabilidades
    prob_farmacia = output[0][0]
    prob_lab = output[1][0]

    # 5. Visualización de Resultados
    print("\n" + "="*40)
    print(f" RESULTADOS PARA: '{args.query}'")
    print("="*40)

    # Barra Farmacia
    len_bar = 30
    fill_f = int(len_bar * prob_farmacia)
    bar_f = "█" * fill_f + "░" * (len_bar - fill_f)
    print(f"{CLASES[0]}: {bar_f} {prob_farmacia*100:.1f}%")

    # Barra Laboratorio
    fill_l = int(len_bar * prob_lab)
    bar_l = "█" * fill_l + "░" * (len_bar - fill_l)
    print(f"{CLASES[1]}: {bar_l} {prob_lab*100:.1f}%")
    print("-" * 40)

    # Decisión Final
    ganador = np.argmax(output)
    print(f"🏆 VEREDICTO: {CLASES[ganador]}")
    print("="*40 + "\n")

if __name__ == "__main__":
    main()

Aquí está el resultado de una prueba real:

Conclusión: Misión Cumplida

Lo que empezó hace una semana como una frustración por la latencia de 5 segundos de una API externa, hoy es la base para una solución propia.

Este fin de semana me enseñó que no siempre necesitamos una IA grande (GPT-5) para resolver nuestros problemas. A veces, un poco de Numpy, unos buenos datos y unas sesiones de vibe coding también generan buenos resultados.

Durante las siguientes semanas seguiré aumentando la complejidad de Prize para buscar reemplazar la API externa que uso actualmente en mi aplicación.

Entrenando a Prize (Parte 2): Creando un Dataset de 5,500 líneas por $0.08 USD

galp76 — Sun, 07 Dec 2025 00:32:36 +0000

Introducción: El ritmo de un "Weekend Project"

Bienvenidos a la segunda entrega de mi viaje construyendo Prize, mi propia red neuronal para clasificación de texto.

Antes de entrar en materia, tengo que aclarar que Prize es oficialmente un "proyecto de fin de semana". Como muchos de ustedes, tengo un trabajo diario y responsabilidades, así que solo puedo ponerme la gorra de "Ingeniero de Machine Learning" los sábados y domingos. El progreso será constante, pero a su propio ritmo.

En el post anterior definí la arquitectura. Hoy, les contaré cómo resolví el problema más grande de cualquier proyecto de IA: conseguir los datos.

Fase 1: La limpieza manual

Mi primera fuente de datos es el inventario de una cadena de farmacias con 6,000 ítems. Suena genial, hasta que abres el archivo.

Una red neuronal aprende lo que le enseñas. Si le enseño que una "Coca-Cola" es una medicina, la red fallará. Me di cuenta de que mi inventario estaba "contaminado" con productos que no tienen nada que ver con salud.

Así que me tocó hacer el trabajo sucio. En varias sesiones a lo largo del fin de semana, filtré la lista manualmente. Borré cientos de filas que contenían refrescos, chocolates, detergentes, escobas y araganes.

El resultado final es un archivo limpio: inventarioSoloMedicinas.txt. Es un trabajo tedioso, pero vital. Sin esta limpieza, Prize no tendría oportunidad.

Fase 2: La Fábrica de Datos Sintéticos ($0.08 de inversión)

Aquí vino el reto real. Mientras que de Farmacia tenía miles de ítems, del "Laboratorio Dental" apenas tenía unos 50 ejemplos. Un desbalance total.

Necesitaba convertir esas 50 líneas en 5,500 para igualar a la farmacia. ¿La solución? Usar IA para entrenar IA.

Con la ayuda de Google Gemini, escribí un script en Python que se conecta a la API de OpenRouter (usando modelos Llama 3). La lógica fue sencilla:

Tomar 5 ejemplos reales de mis servicios dentales.
Pedirle a la IA que genere 20 variaciones de cómo un usuario pediría esos servicios (con jerga, errores de dedo, diferentes tonos).
Repetir hasta llegar a la meta.

Aquí está el script:

import requests
import json
import random
import time
import os

# --- CONFIGURACIÓN ---
API_KEY = "XXXXXXXXXX"
OUTPUT_FILE = "dataset_laboratorio_sintetico.txt"
TARGET_COUNT = 5500
BATCH_SIZE = 20  # Cuántas frases pedimos por llamada (no pidas muchas de golpe para no confundir al modelo)

MODEL_ID = "meta-llama/llama-3.1-70b-instruct" 

semillas_laboratorio = [
    "protesis total superior acrilico",
    "reparacion de puente fijo",
    "ferula de descarga rigida",
    "corona de zirconio sobre implante",
    # ... Aquí va el resto de los 50 items ...
]

def generate_variations(seeds):
    # Envía un prompt a OpenRouter para generar variaciones basadas en las semillas.

    seeds_text = "\n".join([f"- {s}" for s in seeds])

    prompt = f"""
    Actúa como un generador de datos para entrenar una IA.
    Tu tarea es generar {BATCH_SIZE} frases de búsqueda DISTINTAS basadas en los servicios de un laboratorio dental.

    Aquí tienes algunos ejemplos reales (semillas):
    {seeds_text}

    INSTRUCCIONES:
    1. Genera {BATCH_SIZE} variaciones nuevas. NO copies las semillas exactamente.
    2. Contexto: Usuarios en Venezuela/Latinoamérica buscando estos servicios.
    3. Variedad:
       - Usa sinónimos (ej: "plancha" en vez de "prótesis", "férula" en vez de "placa").
       - Mezcla tonos: Formal ("necesito una cotización..."), Informal ("cuanto cuesta la plancha..."), Directo ("precio corona").
       - Incluye ocasionalmente errores leves de ortografía o falta de tildes (como escribe la gente en WhatsApp).
    4. FORMATO DE SALIDA: Únicamente una lista JSON pura de strings. Sin texto extra antes ni después.
    Ejemplo: ["frase 1", "frase 2", "frase 3"]
    """

    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }

    data = {
        "model": MODEL_ID,
        "messages": [
            {"role": "system", "content": "Eres un asistente útil que responde SOLO en formato JSON válido."},
            {"role": "user", "content": prompt}
        ],
        "temperature": 0.8  # Creatividad alta para tener variedad
    }

    try:
        response = requests.post("https://openrouter.ai/api/v1/chat/completions", headers=headers, json=data)
        response.raise_for_status() # Lanza error si falla la petición

        result = response.json()
        content = result['choices'][0]['message']['content']

        return json.loads(content)

    except Exception as e:
        print(f"Error en la llamada a la API: {e}")
        return []

def main():
    print(f"--- Iniciando Generación para Proyecto Prize ---")
    print(f"Meta: {TARGET_COUNT} frases.")

    # Contar cuántas llevamos si el archivo ya existe
    current_count = 0
    if os.path.exists(OUTPUT_FILE):
        with open(OUTPUT_FILE, 'r', encoding='utf-8') as f:
            current_count = len(f.readlines())

    print(f"Progreso actual: {current_count} frases encontradas en {OUTPUT_FILE}")

    while current_count < TARGET_COUNT:
        # 1. Seleccionar semillas al azar
        mis_semillas = random.sample(semillas_laboratorio, k=min(5, len(semillas_laboratorio)))

        # 2. Llamar a la API
        print(f"Generando lote... (Total actual: {current_count})")
        nuevas_frases = generate_variations(mis_semillas)

        if not nuevas_frases:
            print("Fallo en este lote, reintentando en 5 segundos...")
            time.sleep(5)
            continue

        # 3. Guardar en disco (Append mode 'a')
        with open(OUTPUT_FILE, 'a', encoding='utf-8') as f:
            for frase in nuevas_frases:
                f.write(frase + "\n")

        current_count += len(nuevas_frases)

        # 4. Pequeña pausa para no saturar la API (Rate Limits)
        time.sleep(1)

    print(f"\n¡ÉXITO! Generación completada.")
    print(f"Archivo guardado en: {OUTPUT_FILE}")

if __name__ == "__main__":
    main()

Los Resultados: Datos duros

Dejé el script corriendo en mi laptop mientras hacía otras cosas. Aquí están las estadísticas finales de esta operación de "Ingeniería de Datos":

Tiempo de ejecución: 2 horas.
Volumen generado: 5,500 líneas de texto único y variado.
Costo total de la API: $0.08 USD.

Sí, por menos de 10 centavos de dólar, generé un dataset robusto y equilibrado que me hubiera tomado semanas escribir a mano.

Misión cumplida. El dataset sintético está listo.

Conclusión

Ahora tengo dos archivos en mi disco duro que valen su peso en oro:

inventarioSoloMedicinas.txt (Datos reales, limpios).
dataset_laboratorio_sintetico.txt (Datos generados, variados).

La balanza está equilibrada. Tengo ~11,000 ejemplos de alta calidad listos para ser procesados.

En el próximo fin de semana, haremos la magia matemática: usaremos nuevamente la API de OpenRouter y convertiremos todo este texto a números (embeddings), luego convertiremos los vectores fila en vectores columna (es lo que espera el script network2.py) y finalmente... encenderemos a Prize para su primer entrenamiento.

¡El momento de la verdad!

Ya tenemos los datos. Ahora mira cómo Prize alcanzó el 99.9% de precisión en el post 3.

De OpenRouter a Numpy: mi viaje entrenando mi primera red neuronal (sin Frameworks)

galp76 — Sat, 29 Nov 2025 18:46:30 +0000

Actualización 06-12-25: ¡Ya está disponible el 2do post de la serie!
Puedes leer la Parte 2 aqui: Entrenando a Prize: creando el dataset
Actualización 08-12-25: ¡Disponible el 3er post de la serie!
Saltar al post 3: De 0 a 99.9% de precisión
Actualización 23-12-25: ¡Disponible el 4to post!
Post 4: Enseñando a Prize a no dar consejos médicos

Introducción

Actualmente estoy trabajando en el desarrollo de una aplicación web que utiliza la geolocalización del usuario para ofrecer bienes y servicios en su cercanía. Hasta ahora, la lógica de "inteligencia" era delegada: utilizo la API de OpenRouter (accediendo a modelos como GPT5 y Gemini) para clasificar lo que el usuario escribe en el buscador y así decidir qué lógica de código ejecutar.

El Problema

Sobre el papel, usar un LLM (Large Language Model) sonaba genial. Pero en la práctica, me topé con un gran problema: la latencia.

Cada consulta tarda hasta 5 segundos en procesarse. En el entorno web actual, donde todo debe ser instantáneo, hacer esperar al usuario 5 segundos solo para entender qué quiere es inaceptable. Además, depender de una API externa añade costos y una capa de complejidad que no controlo.

La Meta

Necesito una solución que cumpla tres requisitos:

Local: Que corra en mi propio servidor.
Baja Latencia: Que responda en milisegundos.
Control Total: Entender exactamente qué pasa bajo el capó.

El Nombre del Proyecto: "Prize"

Como anécdota personal, quería involucrar a mi hijo en este proyecto para tratar de despertar su curiosidad por la tecnología. Le pedí que bautizara a la red neuronal que estamos construyendo y, tras pensarlo, decidió llamarla "Prize".

Así que, oficialmente, el objetivo no es solo crear un clasificador, sino dar vida a Prize. Si logramos que funcione, el nombre le vendrá como anillo al dedo, porque será una verdadera recompensa después de pelear con tantos hiperparámetros y código.

La Idea: "Hardcore Mode"

Podría haber descargado TensorFlow o PyTorch y tener un modelo corriendo en una tarde. Pero mi objetivo no es solo solucionar el problema, sino aprender.

Por eso, he decidido construir mi propio clasificador de texto desde cero, utilizando únicamente Python y Numpy, basándome en el código del libro "Neural Networks and Deep Learning" de Michael Nielsen. Nada de frameworks modernos que esconden la matemática.

La Arquitectura: Reciclando Inteligencia

Para no empezar de cero absoluto, decidí aprovechar algo que ya tenía implementado. Mi aplicación cuenta con un sistema de recomendación que utiliza Embeddings (vectores numéricos que representan el significado semántico del texto).

Como ya tengo el inventario vectorizado, decidí usar estos embeddings como la entrada de mi red. El diseño inicial de la arquitectura es el siguiente:

Capa de Entrada (1024 neuronas): Corresponde al tamaño exacto de los vectores de embedding que ya utilizo.
Capa Oculta (100 neuronas): Decidí usar 100 neuronas para no hacer una reducción de dimensiones tan drástica y permitir que la red capture mejor los patrones.
Capa de Salida (2 neuronas): Aunque mi meta final es clasificar en 5 categorías de servicios, para esta primera etapa de entrenamiento voy a simplificar el problema. Empezaré con una clasificación binaria (2 clases). Si logro que funcione bien aquí, escalaré a las 5 categorías.

El Desafío de los Datos:

Aquí es donde la teoría chocó con la realidad de mi base de datos. Al revisar mi inventario para crear el dataset de entrenamiento, encontré un desbalance masivo:

Farmacia: Tengo un inventario robusto de 6,000 ítems.
Laboratorio Odontológico: Apenas tengo 20 ítems de referencia.

Si entreno la red con estos datos tal cual, aprenderá rápidamente a decir siempre "Farmacia" para maximizar su acierto, ignorando por completo al laboratorio.

La Estrategia: Data Sintética

Para solucionar esto, tengo un plan de ataque:

Filtrado: Voy a limpiar la data de farmacia para quedarme estrictamente con los medicamentos, eliminando ruido.
IA Generativa: Usaré la misma API de OpenRouter para generar data sintética. Tomaré los 20 ítems del laboratorio y le pediré a la IA que genere cientos de variaciones de cómo un usuario pediría esos servicios. Así equilibraré la balanza antes de entrenar.

¿En qué punto estoy?

Actualmente estoy procesando la materia prima: estoy filtrando el inventario de 6,000 ítems de farmacia para preparar el dataset de entrenamiento.

Mi meta es tener la data limpia y lista para la próxima semana y correr las primeras pruebas de concepto. Documentaré los primeros resultados (sean buenos o malos) en la segunda parte de esta serie.