DEV Community: galp76

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.

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.