Blox - Donde la lógica se vuelve natural

Nombre

crear_red_simple - Crea una red neuronal simple con una capa oculta.

Sinopsis

red = neural.crear_red_simple(n_entrada, n_oculta, n_salida)

Descripcion

Construye una TABLA con los parametros principales de una red feed-forward simple.

La estructura generada contiene W1, b1, W2 y b2, lista para inferencia, entrenamiento o persistencia.

La biblioteca esta pensada para redes con tres capas logicas: entrada, una unica capa oculta y salida. Solo permite elegir la cantidad de neuronas en esas tres capas; no admite multiples capas ocultas ni una arquitectura profunda.

Validaciones y casos borde

Valida que n_entrada, n_oculta y n_salida sean enteros.
Valida que las tres cantidades sean mayores que cero.
Si alguna condicion falla, emite ERROR().

Comportamiento

Crea pesos W1 y W2 junto con bias b1 y b2.
La capa oculta queda representada por W1 y b1.
La capa de salida queda representada por W2 y b2.

Funciones API relacionadas

neural.forward_sigmoide()
neural.forward_relu_sigmoide()
neural.entrenar_mse()

Parámetros

Parámetro	Tipo	Descripción
n_entrada	NUMERICO	Cantidad de neuronas de entrada.
n_oculta	NUMERICO	Cantidad de neuronas de la capa oculta.
n_salida	NUMERICO	Cantidad de neuronas de salida.

Valor de retorno

TABLA - TABLA con los campos W1, b1, W2 y b2.

Ejemplo

ejemplo.blox

Solo lectura

INCLUIR "matrices.api"
INCLUIR "neural.api"


FUNCION PRINCIPAL
INICIO "AND con red neuronal en BLOX"

    NUMERICO n_in, n_hid, n_out
    NUMERICO m
    NUMERICO tasa, epocas
    NUMERICO i

    TABLA red, red1

    MATRIZ W1[][], W2[][]
    MATRIZ b1[][], b2[][]

    MATRIZ X[][], Y[][]
    VECTOR x_test[], y_pred[]

    NUMERICO salida_red
    NUMERICO salida_binaria

    // ---------------------------------------
    // 1. Definir dimensiones de la red
    // ---------------------------------------
    n_in  = 2         // 2 entradas (X1, X2)
    n_hid = 2         // 3 neuronas ocultas (podés probar 4 o más)
    n_out = 1         // 1 salida (OR binario)
    m     = 4         // 4 ejemplos en la tabla verdad

    IMPRIMIR ("\n DIMENSIONES DE LA RED")
    IMPRIMIR ("\n ----------------------\n")
    IMPRIMIR ("\n Entradas = ", n_in)
    IMPRIMIR ("\n Ocutas   = ", n_hid)
    IMPRIMIR ("\n Salidas  = ", n_out)
    IMPRIMIR ("\n")


    // ---------------------------------------
    // 2. Crear matrices de datos X (entrada) y Y (objetivo)
    // ---------------------------------------
    X = matrices.carga_cero(m, n_in)
    Y = matrices.carga_cero(m, n_out)

    // OR - Tabla verdad
    // Ejemplo 0: 0 AND 0 = 0
    X[0][0] = 0
    X[0][1] = 0
    Y[0][0] = 0

    // Ejemplo 1: 0 AND 1 = 1
    X[1][0] = 0
    X[1][1] = 1
    Y[1][0] = 01

    // Ejemplo 2: 1 AND 0 = 1
    X[2][0] = 1
    X[2][1] = 0
    Y[2][0] = 1

    // Ejemplo 3: 1 AND 1 = 1
    X[3][0] = 1
    X[3][1] = 1
    Y[3][0] = 1

    IMPRIMIR ("\n EJEMPLO: OR - Tabla verdad")
    IMPRIMIR ("\n ----------------------------\n")
    IMPRIMIR ("\n X = \n")
    matrices.imprimir(X)    
    IMPRIMIR ("\n Y = \n")
    matrices.imprimir(Y)

    IMPRIMIR ("\n")


    // ---------------------------------------
    // 3. Crear red y parámetros de entrenamiento
    // ---------------------------------------
    red = neural.crear_red_simple(n_in, n_hid, n_out)
        W1 = red.W1
        W2 = red.W2
        b1 = red.b1
        b2 = red.b2

        // Borra el 1er elemento de la tabla. Ya se copiaron los datos.
        // Evita tener varias instancias de la red.
        ELIMINAR(red[1])    

    // No reutilizo 'red' porque los datos se pierden de alguna manera (bug).
    // Por eso he montado nuevamente la red en otra variable.

    red1 = { W1 = W1, b1 = b1, W2 = W2, b2 = b2 }

    tasa   = 1      
    epocas = 600    

    IMPRIMIR ("\nEntrenando red OR...")
    red = neural.entrenar_mse(red1, X, Y, tasa, epocas)
        W1 = red.W1
        W2 = red.W2
        b1 = red.b1
        b2 = red.b2

        ELIMINAR(red1[1])  // Borra el 1er elemento de la tabla. Ya se usaron esos datos.

    // La red esta aca...
    red1 = { W1 = W1, b1 = b1, W2 = W2, b2 = b2 }

    IMPRIMIR ("\nEntrenamiento finalizado.")
    IMPRIMIR ("\n-------------------------------------\n\n")




    // ---------------------------------------
    // 4. Probar la red sobre cada fila de X
    // ---------------------------------------
    NUMERICO f
    f = X.fil

    PARA i = 0 HASTA f-1 HACER

        x_test = matrices.extraer_fila(X, i)

        y_pred = neural.forward_sigmoide(red1, x_test)
        DEPURAR(y_pred)

        salida_red = y_pred[0]

        // Umbral en 0.5 para decidir 0 o 1
        salida_binaria = SI (salida_red >= 0.5) VALOR 1 SINO 0

        IMPRIMIR ("\nEntrada                : ", x_test)
        IMPRIMIR ("\nSalida esperada        : ", Y[i][0])
        IMPRIMIR ("\nSalida red (cruda)     : ", salida_red)
        IMPRIMIR ("\nSalida red (binaria)   : ", salida_binaria)

        IMPRIMIR ("\n-----------------------------\n")

    FIN_PARA

    MATRIZ NEW[][]

    NEW = matrices.multiplicar(X, red1.W1)
    NEW = neural.sumar_bias(NEW, red1.b1)   // Matriz N = XW1 + b1
    NEW = neural.sigmoide_matriz(NEW)       // Matriz H1 = sigmoide(N)

    IMPRIMIR("\nPuntos en el espacio original X   = \n")
    matrices.imprimir(X)

    IMPRIMIR("\nPesos de la RED entrenada")
    IMPRIMIR("\nW1  = \n")
    matrices.imprimir(red1.W1)     
    IMPRIMIR("\nW2  = \n")
    matrices.imprimir(red1.W2)    

    IMPRIMIR("\nPuntos en el hiperespacio H1 = \n")
    matrices.imprimir(NEW)


    NEW = matrices.multiplicar(NEW, W2)
    NEW = neural.sumar_bias(NEW, b2)
    NEW = neural.sigmoide_matriz(NEW)

    IMPRIMIR("\nPredicciones para Activacion Y_hat= \n")
    matrices.imprimir(NEW)

    DEPURAR("TODAS")

FINAL













    // 5. Grafico de la frontera
    TABLA frontera
    NUMERICO xmin, xmax, ymin, ymax, pasosX, pasosY, umbral, cuad_x, cuad_y

    xmin = -0.5     xmax = 1.5 
    ymin = -0.5     ymax = 1.5 
    pasosX = 50     pasosY = 100 
    umbral = 0.5

    cuad_x = 1
    cuad_y = ymax / 10

    frontera = neural.frontera_xy(red1, xmin, xmax, ymin, ymax, pasosX, pasosY, umbral)

    VECTOR x_graf[], y_graf[]
    VECTOR x_graf1[1], y_graf1[1]
    TABLA G, datos, serie1, serie2, eje_x, eje_y

    x_graf = frontera.X
    y_graf = frontera.Y

    // Serie 1: frontera
    serie1 = {
        tipo      = "xy",
        x         = x_graf,
        y         = y_graf,
        color     = "#124ae3",  // AZUL
        grosor    = 1
    }

    // CLASE 0
    x_graf1[0] = 0
    //x_graf1[1] = 1

    y_graf1[0] = 0
    //y_graf1[1] = 1

    serie2 = {
        tipo      = "xy",
        x         = x_graf1,
        y         = y_graf1,
        color     = "#4ba32a", // VERDE
        grosor    = 10
    }    

    datos[1]["Serie1"] = serie1[1]
    datos[1]["Serie2"] = serie2[1]

    eje_x = {
        nombre     = "x",
        min        = xmin,
        max        = xmax,
        cuadricula = cuad_x
    }

    eje_y = {
        nombre      = "y",
        min         = ymin,
        max         = ymax,
        cuadricula  = cuad_y
    }

    G = {
      tipo      = "xy",
      titulo    = "Frontera neuronal" + epocas,
      etiquetas = FALSO,
      //leyenda   = { mostrar = 1, posicion = "e" },
      ejex      = VERDADERO,
      ejey      = VERDADERO,
      abscisas  = eje_x,
      ordenadas = eje_y,
      datos     = datos,
      ancho     = 960,
      alto      = 540,
      margen    = 100,
      archivo   = "frontera_neural_XOR" + " - " + UNIR(epocas) + "(" + UNIR(n_hid) + ")" + ".png"
    }

    GRAFICAR(G[1])```

Restringido: este ejemplo no puede ejecutarse en el Playground web porque la API requerida no está disponible en el sandbox.

crear_red_simple(nentrada,noculta,nsalida)\texttt{crear\_red\_simple}(n_{entrada}, n_{oculta}, n_{salida})crear_red_simple(nentrada​,noculta​,nsalida​)

Parámetros

Valor de retorno

Ejemplo

$\texttt{crear\_red\_simple}(n_{entrada}, n_{oculta}, n_{salida})$