Nothing Special   »   [go: up one dir, main page]
Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 2 vistas

    Lab0nn

    Cargado por

    wilson.lombardo42

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd

    Lab0nn

    Cargado por

    wilson.lombardo42
    2 vistas4 páginas

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    2 vistas4 páginas

    Lab0nn

    Cargado por

    wilson.lombardo42

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    Está en la página 1de 4

    Laboratorio 0

    Capítulo 10

    Índice
    Instalación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
    Datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
    Regresión lineal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
    Modelo Lasso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
    Red Neuronal (una sola capa) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
    En este Laboratorio aprenderemos a ajustar una red neuronal de una sola capa R. Para ello, utilizaremos la
    interfaz en R de la librería de python keras. A su vez este paquete contiene a la librería tensorflow la cual
    contiene un código muy eficiente para implementar redes neuronales.
    La instalación de estos paquetes puede ser problemática. Por lo tanto, la primera parte de este laboratorio
    consistirá en la instalación de la librería keras.

    Instalación
    Evidentemente, necesitamos tener instalado Python en nuestro ordenador. Esto se puede hacer a través de
    R de la siguiente manera.

    #reticulate::install_python()

    Luego, instalamos keras.

    #install.packages("keras")

    Una vez instalados, podremos implementar una red neuronal.


    Como bien hemos mencionado, ajustaremos una red neuronal de una sola capa. La idea es comparar los
    resultados de tal red con modelos que hemos visto anteriormente, e.g., un modelo de regresión lineal o un
    modelo Lasso. Esto lo haremos utilizando los datos de la ya conocida base de datos Hitters dentro del
    paquete ISLR2

    Datos

    library(ISLR2)
    Gitters <- na.omit(Hitters)
    n <- nrow(Gitters)
    set.seed(13)
    ntest <- trunc(n / 3)
    testid <- sample(1:n, ntest)

    1
    Nuestro objetivo será predecir el Salario de los jugadores de béisbol.

    Regresión lineal

    Ajustamos la regresión lineal y realizamos la predicción

    # Entrenamos el modelo con datos de entrenamiento


    lfit <- lm(Salary ~ . , data = Gitters[-testid, ])
    # Realizamos las predicciones
    lpred <- predict(lfit, Gitters[testid, ])
    # Calculamos el Mean Absolute Error (con el comando with() - una forma alternativa de hacerlo-)
    with(Gitters[testid, ], mean(abs(lpred - Salary)))

    ## [1] 254.6687

    Modelo Lasso

    Ajustamos ahora el modelo Lasso con el paquete glmnet. Recordemos que este paquete no utiliza fórmulas.
    Entonces, debemos especificar nuestra matriz de predictoraas y el vector de variables dependientes.

    # Estandariza las variables


    x <- scale(model.matrix(Salary ~ . - 1, data = Gitters))
    # model.matrix() crea un modelo igual al modelo lineal anterior (sin el intercepto) y convierte los fact
    y <- Gitters$Salary

    Ajustamos el modelo y calculamos el Mean Absolute Error

    library(glmnet)

    ## Loading required package: Matrix

    ## Loaded glmnet 4.1-8

    # Seleccionamos el parámetro de penalización mediante validación cruzada (10 folds por default) y ajusta
    cvfit <- cv.glmnet(x[-testid, ], y[-testid], type.measure = "mae")
    # Realizamos las predicciones sobre los datos de testeo
    cpred <- predict(cvfit, x[testid, ], s = "lambda.min")
    # Calculamos el MAE
    mean(abs(y[testid] - cpred))

    ## [1] 252.2994

    Obtenemos un error ligeramente menor.

    Red Neuronal (una sola capa)

    Primero llamamos a la librería de keras y creamos un entorno virtual con el nombre "r-tensorflow".

    2
    library(keras)
    install_keras(envname = "r-tensorflow-lab")

    ## Using virtual environment "r-tensorflow-lab" ...

    ## + "C:/Users/girel/OneDrive/Documentos/.virtualenvs/r-tensorflow-lab/Scripts/python.exe" -m pip instal

    ##
    ## Installation complete.

    Vamos a establecer la arquitectura de la red. Nuestro modelo se denomina modnn que es un modelo de
    capas secuenciales (keras_model_sequential()). El operador %> % pasa el término anterior a la siguiente
    función. Se agrega una capa con el comando layer_dense() donde es necesario especificar el tamaño del
    input (ncol(x)) que es el tamaño de nuestros datos.
    Nuestra red tiene una sola capa de 50 neuronas con una función de activación "relu"y una capa de dropout
    donde el 40 % de las 50 neuronas aleatoriamente se desactivan (seteadas en cero). Finalmente, al tratarse de
    un problema de regresión, la última capa tiene una sola neurona sin función de activación alguna.

    reticulate::use_virtualenv(virtualenv = "r-tensorflow-lab")
    modnn <- keras_model_sequential() %> %
    layer_dense(units = 50, activation = "relu", input_shape = ncol(x)) %> %
    layer_dropout(rate = 0.4) %> % layer_dense(units = 1)

    Para entrenar nuestra red, debemos antes establecer detalles para el algoritmo de entrenamiento con la
    función compile(). En este caso, minimizamos el error cuadrático medio como nuestra función de pérdida.
    A su vez, el algoritmo nos arroja el MAE a medida que va entrenando el modelo y nuestro método de
    optimización, en este caso: RMSPROP.

    modnn %> % compile(loss = "mse", optimizer = optimizer_rmsprop(),


    metrics = list("mean_absolute_error")
    )

    Ahora ajustamos el modelo con la función fit() donde especificamos nuestros datos de entrenamiento y
    testeo, el número de épocas y el tamaño del batch. Los datos de validación no se utilizan para ajustar el
    modelo pero los utilizamos para monitorear el error a lo largo de las épocas. A su vez, podemos graficar el
    ajuste del modelo para cada época como herramienta visual de monitoreo con la función plot().

    history <- modnn %> % fit(


    x[-testid, ], y[-testid], epochs = 1500, batch_size = 32,
    validation_data = list(x[testid, ], y[testid])
    )

    Obtendremos un gráfico de este estilo.

    plot(history)

    3
    5e+05

    4e+05
    loss

    3e+05

    2e+05

    1e+05
    data
    training
    validation
    mean_absolute_error

    500

    400

    300

    200
    0 500 1000 1500
    epoch

    Notemos que tanto el MSE como MAE disminuyen abruptamente en las primeras 200 épocas (en el error
    de entrenamiento como de testeo). Entre la época 500 y 600 vemos que el error de testeo luego de lograr
    un mínimo crece levemente para luego mantenerse constante mientras que al mismo tiempo, el error de
    entrenamiento sigue disminuyendo. Por lo que podemos detectar un ligero sobreajuste de los datos por parte
    del modelo. Podemos mejorar este aspecto del modelo disminuyendo el número de épocas, el tamaño del
    batch, el tamaño de nuestra capa, etc.
    Por último, vemos el error del modelo en predicción.

    npred <- predict(modnn, x[testid, ])

    ## 3/3 - 0s - 60ms/epoch - 20ms/step

    mean(abs(y[testid] - npred))

    ## [1] 250.5534

    También podría gustarte