Blox - Donde la lógica se vuelve natural

Nombre

entrenar_mse - Entrena una red simple usando error cuadratico medio y activacion sigmoide.

Sinopsis

red = neural.entrenar_mse(red, X, Y, tasa, epocas)

Descripcion

Recibe una red, una matriz de entradas X, una matriz objetivo Y, una tasa de aprendizaje y la cantidad de epocas.

Objetivo:

$\min_W \frac{1}{n}\sum_i(\hat{y}_i-y_i)^2$

La red se actualiza durante el entrenamiento y tambien se retorna como TABLA.

Esta rutina de entrenamiento esta pensada para la arquitectura fija de la biblioteca: capa de entrada, una unica capa oculta y capa de salida. No entrena redes con multiples capas ocultas.

Validaciones y casos borde

Valida que la TABLA red contenga W1, b1, W2 y b2 con dimensiones coherentes.
Valida que X y Y tengan al menos una fila.
Valida que X e Y tengan la misma cantidad de filas.
Valida que X.col coincida con red.W1.fil.
Valida que Y.col coincida con red.W2.col.
Valida que epocas sea entero y mayor que cero.
Si alguna condicion falla, emite ERROR().

Comportamiento

Valida dimensiones de X, Y, W1, b1, W2 y b2.
Rechaza entrenamiento con epocas <= 0.
Actualiza pesos y bias en sitio durante el proceso.

Funciones API relacionadas

neural.forward_pass()
neural.back_propagation()
neural.mse()

Parámetros

Parámetro	Tipo	Descripción
red	TABLA	Tabla que representa la red neuronal y sus parametros.
X	MATRIZ	Matriz de entradas de entrenamiento.
Y	MATRIZ	Matriz de valores esperados.
tasa	NUMERICO	Tasa de aprendizaje.
epocas	NUMERICO	Cantidad de epocas de entrenamiento.

Valor de retorno

TABLA - TABLA de red con pesos y bias actualizados despues del entrenamiento.

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.

entrenar_mse(red,X,Y,tasa,epocas)\texttt{entrenar\_mse}(red, X, Y, tasa, epocas)entrenar_mse(red,X,Y,tasa,epocas)

Parámetros

Valor de retorno

Ejemplo

$\texttt{entrenar\_mse}(red, X, Y, tasa, epocas)$