Sebastian Carvalho
Si al igual que yo, ustedes están desarrollando este curso en windows y presentan inconvenientes con la función mclapply, como alternativa pueden usar la función lapply y remover de los parámetros de entrada mc.cores.
¿Cómo configurar una validación cruzada para una red neuronal?
La validación cruzada es una técnica potente y esencial para la evaluación de modelos, especialmente en el aprendizaje automático. Al implementar este método, no solo se facilita la evaluación de modelos en conjuntos de datos no vistos, sino que se mejora su capacidad de generalización. Aquí te mostraremos cómo llevar a cabo una validación cruzada en un modelo de red neuronal utilizando herramientas específicas en el lenguaje de programación R.
¿Qué librerías utilizar?
Para realizar este procedimiento, se emplearán las siguientes librerías en R:
Caret: Fundamental para la validación cruzada, permitiendo la creación del sistema de pliegues.Nnet: Para el desarrollo y entrenamiento de la red neuronal.¿Cómo se define la función de pliegue?
El primer paso es construir una función que permita evaluar un pliegue, dividiendo el conjunto de datos en un conjunto de prueba y uno de entrenamiento. Este método asegura que cada parte del conjunto de datos se use una vez como datos de prueba y las restantes veces como datos de entrenamiento.
# Creación del pliegue lógico logic <- vector("logical", length(data)) logic[fold] <- TRUE # Dividir datos training <- data[!logic, ] testing <- data[logic, ] # Construir modelo model <- nnet(fórmula, data = training, size = neuron_count, linout = TRUE, trace = FALSE)
¿Cómo obtener el error estándar (RMSE)?
El RMSE (Root Mean Square Error) es la métrica que se utilizará para evaluar el rendimiento de la red neuronal en los datos de prueba.
# Pronóstico y cálculo de RMSE predicted <- predict(model, testing) rmse <- RMSE(predicted, testing$response)
¿Cómo implementar la validación cruzada?
La validación cruzada puede llevarse a cabo dividiendo el conjunto de datos en varios pliegues. Cada pliegue se evalúa de forma independiente, calculando un promedio de los errores para determinar la eficacia global del modelo.
# Crear pliegues folds <- createFolds(data$response, k = number_of_folds) # Ejecutar con MCLapply para computación paralela results <- mclapply(folds, function(fold) { rms_fold(fold, formula = y ~ x, data = data, neurons = neuron_count) }, mc.cores = number_of_cores)
¿Cómo interpretar los resultados?
Una vez obtenidos los resultados de cada pliegue, el promedio del RMSE nos dará una idea de la capacidad del modelo para generalizar a nuevos datos. Además, la variación entre los pliegues puede indicar la estabilidad y robustez del modelo.
# Conversión a vector y plot rmse_values <- unlist(results) average_rmse <- mean(rmse_values) plot(rmse_values, type = "b", ylim = c(0, 1)) abline(h = average_rmse, col = "red", lwd = 2)
Si los pliegues presentan alta disparidad, puede ser necesario ajustar el tamaño de muestra, el número de neuronas, o el número de pliegues para mejorar la consistencia.
Recomendaciones finales para optimizar la validación cruzada
No olvides que en el mundo del aprendizaje automático, la iteración y experimentación son clave. ¡Sigue explorando y aprendiendo!
Estimado platzinauta, en el minuto 13 debemos esta función. Si utilizas windows 10 este no permite la paralelizacion de procesos de forma sencilla y utilizando R lo hace en los sistemas Unix, hay formas de crear procesos paralelos utilizando clusters, aqui un articulo
https://www.juliancabezas.com/post/paralelizando-r-en-windows-usando-el-paquete-parallel/
La otra opcion si no te quieres complicar es instalar R en wsl
sudo apt-get install r-base
Llamamos al interprete
sudo -i R
Y copiamos y pegamos paso a paso el script que realizamos en R Studio, fue la forma "Rápida" que se me ocurrió.
Sebastian Carvalho
Si al igual que yo, ustedes están desarrollando este curso en windows y presentan inconvenientes con la función mclapply, como alternativa pueden usar la función lapply y remover de los parámetros de entrada mc.cores.
Martin DAVILA
Cesar Augusto Morales Godoy
Buenas en esta clase me tocó repasar el video número 16 del curso. No se si alguien tubo problemas con con el código acá, en el notebook de Colab todo fue muy fluido, dejo mi cuaderno: https://colab.research.google.com/drive/1kDuwwRDgM12fHLfsrOBtDt_qrraPv-pI?usp=sharing
Byron José López Mayorga
Le doy createfolds(muestra$y, k = n_pliegues) -> n_pliegues pero aparece:
Error in createFolds(muestra$y, k = n_pliegues) : could not find function "createFolds"
Entiendo que viene en la libreria caret, pero ya la instale y ya la habilite.
Jhon Freddy Tavera Blandon
Métricas promedio:
Se obtiene el error cuadrático medio (RMSE) y otras métricas como el coeficiente de determinación (R2R2) promediadas a lo largo de los 5 folds.
Estabilidad:
La validación cruzada proporciona una idea de qué tan bien generaliza el modelo en nuevos datos.
Jordi Reig Carruana
# Instalación de paquetes
if (!require(caret)) install.packages("caret")
if (!require(nnet)) install.packages("nnet")
if (!require(parallel)) install.packages("parallel")
library(caret) # Para validación cruzada
library(nnet) # Para crear redes neuronales
library(parallel) # Para computación paralela
# Crear función para calcular RMSE en un pliegue
rmse_fold <- function(pliegue, form, datos, nn_size) {
pliegue_logic <- seq_len(nrow(datos)) %in% pliegue
prueba <- subset(datos, pliegue_logic)
entrena <- subset(datos, !pliegue_logic)
modelo <- nnet(form, data=entrena, size=nn_size, linout=TRUE, trace=FALSE)
response_name <- setdiff(names(datos), modelo$coefnames)
Y_pronosticado <- predict(modelo, newdata=prueba)
rmse <- RMSE(Y_pronosticado, prueba[[response_name]])
return(rmse)
}
# Generar datos
n_pliegues <- 5
tamano_muestral <- 30
neuronas <- 10
genera_y <- function(x) {
cos(x) + rnorm(length(x), 0, 0.5)
}
X <- seq(0, 3 * pi, length.out = tamano_muestral)
Y <- genera_y(X)
# Crear datos como data.frame
muestra <- data.frame(X, Y)
# Crear pliegues para validación cruzada
pliegues <- createFolds(muestra$Y, k = n_pliegues)
# Crear un clúster para paralelismo
cluster <- makeCluster(6) # Ajusta según el número de núcleos disponibles
# Cargar paquetes y exportar funciones y variables necesarias al clúster
clusterEvalQ(cluster, library(nnet))
clusterEvalQ(cluster, library(caret))
clusterExport(cluster, c("rmse_fold", "muestra", "pliegues", "neuronas"))
# Realizar validación cruzada usando parLapply
rmse_pliegues <- parLapply(cluster, pliegues, rmse_fold, Y ~ X, muestra, nn_size = neuronas)
# Detener el clúster después de procesar
stopCluster(cluster)
# Resultados de RMSE para cada pliegue
print(rmse_pliegues)
# Hacemos la validación cruzada de nuestra red neuronal. ------------------ # Paquetes ---------------------------------------------------------------- library("caret") library("nnet") library("parallel") # función de pliegue ------------------------------------------------------ rmse_fold <- function(pliegue, form, datos, nn_size){ pliegue_logic <- seq_len(nrow(datos)) %in% pliegue entrena <- subset(datos, !pliegue_logic) prueba <- subset(datos, pliegue_logic) modelo <- nnet(form, data = datos, size = nn_size, linout = TRUE, trace = FALSE) response_name <- setdiff(names(datos), modelo$coefnames) Y_pronosticado <- predict(modelo, newdata = prueba) rmse <- RMSE(Y_pronosticado, prueba[[response_name]]) rmse } # Red neuronal ------------------------------------------------------------ n_pliegues <- 5 tamano_muestral <- 30 neuronas <- 10 genera_y <- function(x){ cos(x) + rnorm(length(x), 0, 0.5) } X <- seq(0, 3*pi, length.out = tamano_muestral) Y <- genera_y(X) data.frame(X, Y) -> muestra createFolds(muestra$Y, k = n_pliegues) -> pliegues mclapply( pliegues, rmse_fold, Y ~ X, muestra, nn_size = neuronas, mc.cores = floor(detectCores()*0.8) ) -> rmse_pliegues rmse_pliegues <- unlist(rmse_pliegues) mean(rmse_pliegues) plot(rmse_pliegues, ylim = c(0, 1)) abline(h = mean(rmse_pliegues), col = 2, lwd = 2) # Tidy approach ----------------------------------------------------------- library("dplyr") library("magrittr") n_pliegues <- 5 tamano_muestral <- 30 neuronas <- 10 tibble( pliegues = createFolds(muestra$Y, k = n_pliegues), rmse_pliegues = mclapply( pliegues, rmse_fold, Y ~ X, muestra, nn_size = neuronas, mc.cores = floor(detectCores()*0.8) ) %>% unlist, nombres = names(pliegues) ) -> validacion validacion %$% mean(rmse_pliegues) ggplot(validacion) + geom_vline(aes(xintercept = 0), size = 1.5) + geom_segment(aes(x = 0, y = nombres, xend = rmse_pliegues, yend = nombres), colour = "grey75") + geom_point(aes(x = rmse_pliegues, y = nombres), size = 4) + theme_minimal()```