Modelo B

# Importación de paquetes
library(readxl)       # Para leer archivos de Excel
library(dplyr)        # Para manipulación de datos
library(scales)       # Para formatear números
library(tidyverse)    # Para manipulación de datos
library(Hmisc)        # Para algunas funciones adicionales
library(lubridate)
library(hms)
library(randomForest)
library(pROC)
library(knitr)

# Establecer directorio de trabajo. 
# Reemplaza "" con la ruta de tu directorio.
setwd("C:/Users/bianc/OneDrive/Escritorio/Maestria/TFM/TFMVersiónFinal/Data") 

# Nombres de archivos Excel que contienen la base de datos
file_name_control <- "anon_control_musics.xlsx"
file_name_disorder <- "anon_disorder_musics.xlsx"
song_scrapping <- "song_dataframe_scrapping.xlsx"
equivalencia_genres <- "equivalencia.xlsx"

# Leer los archivos Excel en DataFrames
data_control <- read_excel(file_name_control)
data_disorder <- read_excel(file_name_disorder)
gender_left_song <- read_excel(song_scrapping)
genres_equivalence <- read_excel(equivalencia_genres)

# Combinar los datos control y disorder, limpiar y preparar los datos
data_disorder<-data_disorder%>%
  mutate(created_at = as.POSIXct(strptime(created_at, format = "%m/%d/%y %I:%M %p")),
         TOD = strftime(created_at, format = "%H:%M:%S"))

data <- data_control %>%
  mutate(subgeneros = Subgenres,
         TOD = strftime(as_hms(created_at),format= "%H:%M:%S")) %>%
  select(!Subgenres) %>%
  union(data_disorder)

# Seleccionar y limpiar los datos, eliminando columnas no deseadas y filas con NA en user_id
data_new <- data %>%
  select(!c(lyric, subgeneros, count, type)) %>%
  filter(!is.na(user_id))

# Limpiar y preparar los datos aún más
new_data_work <- data_new %>%
  mutate(Genres = replace_na(Genres, "Otros"),
         part_of_day = ifelse(TOD >= "05:00:00" & TOD < "12:00:00", "Mañana",
                              ifelse(TOD >= "12:00:00" & TOD < "18:00:00", "Tarde",
                                     ifelse(TOD >= "18:00:00" & TOD < "24:00:00","Noche","Medianoche"))))

# Realizar equivalencia de géneros de música
new_data_work <- new_data_work %>%
  mutate(AT = paste(artist, title, sep = "-")) %>%
  left_join(gender_left_song %>%
              mutate(AT = paste(song_artist_data, song_name_data, sep = "-")) %>%
              select(AT, genres), by = "AT") %>%
  mutate(Genres = ifelse(is.na(Genres), genres, Genres)) %>%
  select(!c(AT, genres)) %>%
  mutate(Genres = tolower(Genres)) %>%
  left_join(genres_equivalence %>%
              select(Genres, equivalencia) %>%
              mutate(Genres = tolower(Genres)), by = "Genres")

# Tabla de Frecuencia por equivalencia de géneros
gender_artist<-new_data_work%>%
  select(artist,equivalencia)%>%
  group_by(artist,equivalencia)%>%
  summarise(Abs.Frec = n())%>%
  ungroup()%>%
  arrange(desc(Abs.Frec))

gender_artist<-gender_artist[!duplicated(gender_artist[,c("artist")]),]

new_data_work_enserio<-new_data_work%>%
  left_join(gender_artist%>%
              mutate(artist_genres = equivalencia)%>%
              select(artist,artist_genres),by = "artist")%>%
  mutate(equivalencia = capitalize(ifelse(is.na(equivalencia),artist_genres,equivalencia)))%>%
  mutate(equivalencia = replace_na(equivalencia,"Nulos")) %>%
  select(!artist_genres)

# Genres
others_gender<-new_data_work_enserio %>%
  group_by(equivalencia)%>%
  summarise(Abs.Frec = n(),
            'Usuarios Distintos' = comma(n_distinct(user_id))) %>%
  arrange(desc(Abs.Frec)) %>%                 # Ordenar de forma descendente por frecuencia absoluta
  mutate(Rel.Frec = Abs.Frec/sum(Abs.Frec),  # Calcular frecuencia relativa
         Abs.Frec = comma(Abs.Frec))%>%
  filter(Rel.Frec<0.04 & equivalencia!="Nulos")%>%
  select(equivalencia)

others_gender<-list(equivalencia = others_gender$equivalencia)

order<-c("Pop", "Hip hop", "Rock", "Edm", "R&b", "Indie", "K-pop", "Rap","Metal","Otros","Nulos")

tb_fr_Genres<-new_data_work_enserio %>%
  mutate(equivalencia= ifelse(equivalencia %in% others_gender$equivalencia,"Otros",equivalencia))%>%
  group_by(equivalencia) %>%
  summarise(Abs.Frec = n(),
            'Usuarios Distintos' = n_distinct(user_id))%>%
  mutate(equivalencia = factor(equivalencia, levels = order))

abv<-c("PO","HI","RO","ED","RB","IN","KP","RA","ME","OT","NU")
abreviatura<-data.frame(equivalencia=order,
                        abreviatura=abv)

rm(data,data_control,data_disorder,data_new,
   gender_artist,gender_left_song,genres_equivalence,
   new_data_work)

library(data.table)
library(mltools)

# One-Hot Encoding
factor_data<-new_data_work_enserio%>%
  mutate(equivalencia= ifelse(equivalencia %in% others_gender$equivalencia,"Otros",equivalencia))%>%
  mutate(#disorder = factor(disorder),
         src = factor(src),
         Genres = factor(equivalencia),
         part_of_day = factor(part_of_day))%>%
  select(user_id,disorder,src,Genres,part_of_day)

# unique user_id
train <- one_hot(as.data.table(factor_data))

train<-
train%>%
  group_by(user_id,
           disorder)%>%
  summarise(
            APPLE=max(src_APPLE),
            SOUNDCLOUD=max(src_SOUNDCLOUD),
            SPOTIFY=max(src_SPOTIFY),
            Edm=max(Genres_Edm),
            `Hip_hop`=max(`Genres_Hip hop`),
            Indie=max(Genres_Indie),
            `K_pop`=max(`Genres_K-pop`),
            Otros=max(Genres_Otros),
            Pop=max(Genres_Pop),
            `R_b`=max(`Genres_R&b`),
            Rock=max(Genres_Rock),
            Tarde=max(part_of_day_Tarde),
            Medianoche=max(part_of_day_Medianoche),
            Mañana=max(part_of_day_Mañana),
            Noche=max(part_of_day_Noche))

train<-train%>%
  ungroup()%>%
  select(!user_id)%>%
  mutate(control = factor(ifelse(disorder=="control","control","no_control")),disorder  = factor(disorder))

library(smotefamily)
library(caret)
seeds<-c(1234,456,789,512,1090)
# Número de pliegues para validación cruzada
num_folds <- 5
# Número de repeticiones para validación cruzada
num_repeats <- 3
override.linetype <- c(1, 2, 3,4,5)

Modelo B.1: Random Forest solo con Validación Cruzada

Random Forest ntree = 40

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Definir los parámetros de control para repeated k-fold cross-validation
  repeat_cv <- trainControl(method = 'repeatedcv', number = 10, repeats = 3)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = repeat_cv, 
                    method = "rf", metric = 'Accuracy', 
                    ntree = 40)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio 
print(average_conf_matrix)

##            anxiety depression otros ptsd class.error
## anxiety        4.0      893.0   0.4  1.2  0.99559379
## depression    14.6     1822.0   0.6  2.4  0.00958776
## otros          4.2      454.4   0.0  0.6  1.00000000
## ptsd           5.4      649.6   0.0  1.0  0.99847509

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.2      291.2   0.0   0.0
##   depression     0.8      594.6   0.0   0.0
##   otros          0.0      158.6   0.0   0.2
##   ptsd           0.6      220.4   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables

library(RColorBrewer)
# Crear una paleta de colores pastel extendida
pastel_colors <- colorRampPalette(brewer.pal(9, "Pastel1"))(length(unique(averages_var_importances$Variables)))

ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos con el argumento `size`
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Eliminar la leyenda
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest con Validación Cruzada") +
  scale_color_manual(values = pastel_colors)  # Asignar colores pastel generados

Random Forest ntree = 40 maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Definir los parámetros de control para repeated k-fold cross-validation
  repeat_cv <- trainControl(method = 'repeatedcv', number = 10, repeats = 3)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = repeat_cv, 
                    method = "rf", metric = 'Accuracy', 
                    ntree = 40,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd class.error
## anxiety        0.4      898.2     0    0 0.999561884
## depression     0.8     1838.8     0    0 0.000443459
## otros          0.4      458.8     0    0 1.000000000
## ptsd           0.0      656.0     0    0 1.000000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.0      158.8   0.0   0.0
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
library(RColorBrewer)
# Crear una paleta de colores pastel extendida
pastel_colors <- colorRampPalette(brewer.pal(9, "Pastel1"))(length(unique(averages_var_importances$Variables)))

# Suponiendo que `averages_var_importances` es tu dataframe y `Variables` y `Overall` son columnas de ese dataframe
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos con el argumento `size`
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Eliminar la leyenda
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest ntree = 40  maxnodes = 30") +
  scale_color_manual(values = pastel_colors)  # Asignar colores pastel generados

Random Forest ntree = 50

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Definir los parámetros de control para repeated k-fold cross-validation
  repeat_cv <- trainControl(method = 'repeatedcv', number = 10, repeats = 3)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = repeat_cv, 
                    method = "rf", metric = 'Accuracy', 
                    ntree = 50)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd class.error
## anxiety        3.0      894.2   0.4  1.0 0.996677287
## depression    12.2     1824.2   0.6  2.6 0.008380301
## otros          2.6      456.2   0.0  0.4 1.000000000
## ptsd           3.4      651.8   0.2  0.6 0.999089068

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.2      291.2   0.0   0.0
##   depression     0.4      595.0   0.0   0.0
##   otros          0.0      158.6   0.0   0.2
##   ptsd           0.2      220.8   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables

# Crear una paleta de colores pastel extendida
pastel_colors <- colorRampPalette(brewer.pal(9, "Pastel1"))(length(unique(averages_var_importances$Variables)))

# Suponiendo que `averages_var_importances` es tu dataframe y `Variables` y `Overall` son columnas de ese dataframe
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos con el argumento `size`
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Eliminar la leyenda
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest ntree = 50 ") +
  scale_color_manual(values = pastel_colors)  # Asignar colores pastel generados

Random Forest ntree = 50,maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Definir los parámetros de control para repeated k-fold cross-validation
  repeat_cv <- trainControl(method = 'repeatedcv', number = 10, repeats = 3)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = repeat_cv, 
                    method = "rf", metric = 'Accuracy', 
                    ntree = 50,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd  class.error
## anxiety        0.0      898.6     0  0.0 1.0000000000
## depression     0.2     1839.2     0  0.2 0.0002217295
## otros          0.0      459.2     0  0.0 1.0000000000
## ptsd           0.0      656.0     0  0.0 1.0000000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.0      158.8   0.0   0.0
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables

ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos con el argumento `size`
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Eliminar la leyenda
  ) +
  xlab("Variables") +
  ylab("") +
  ggtitle("Random Forest ntree = 50, maxnodes = 30") +
  scale_color_manual(values = pastel_colors)  # Asignar colores pastel desde tu entorno de R

Random Forest ntree = 50,maxnodes = 40

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Definir los parámetros de control para repeated k-fold cross-validation
  repeat_cv <- trainControl(method = 'repeatedcv', number = 10, repeats = 3)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = repeat_cv, 
                    method = "rf", metric = 'Accuracy', 
                    ntree = 50,maxnodes = 40)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd  class.error
## anxiety        0.4      898.0     0  0.2 0.9995614035
## depression     1.4     1838.0     0  0.2 0.0008682812
## otros          0.4      458.8     0  0.0 1.0000000000
## ptsd           0.2      655.8     0  0.0 1.0000000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.0      158.8   0.0   0.0
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables

ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos con el argumento `size`
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Eliminar la leyenda
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest ntree = 50,maxnodes = 40") +
  scale_color_manual(values = pastel_colors)  # Asignar colores pastel desde tu entorno de R

Random Forest ntree = 100

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Definir los parámetros de control para repeated k-fold cross-validation
  repeat_cv <- trainControl(method = 'repeatedcv', number = 10, repeats = 3)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = repeat_cv, 
                    method = "rf", metric = 'Accuracy', 
                    ntree = 100)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd class.error
## anxiety        1.0      897.6   0.0  0.0 0.998897432
## depression     3.6     1834.8   0.2  1.0 0.002629172
## otros          1.0      458.0   0.0  0.2 1.000000000
## ptsd           0.4      655.4   0.0  0.2 0.999696510

# Calcular la matriz de confusión promedio
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.6      594.8   0.0   0.0
##   otros          0.0      158.6   0.0   0.2
##   ptsd           0.2      220.8   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables

ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos con el argumento `size`
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Eliminar la leyenda
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest ntree = 100") +
  scale_color_manual(values = pastel_colors)  # Asignar colores pastel desde tu entorno de R

Random Forest ntree = 100,maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Definir los parámetros de control para repeated k-fold cross-validation
  repeat_cv <- trainControl(method = 'repeatedcv', number = 10, repeats = 3)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = repeat_cv, 
                    method = "rf", metric = 'Accuracy', 
                    ntree = 100,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(average_conf_matrix)

##            anxiety depression otros ptsd class.error
## anxiety          0      898.6     0    0           1
## depression       0     1839.6     0    0           0
## otros            0      459.2     0    0           1
## ptsd             0      656.0     0    0           1

# Calcular la matriz de confusión promedio
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.0      158.8   0.0   0.0
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos con el argumento `size`
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Eliminar la leyenda
  ) +
  ggtitle("Random Forest ntree = 100, maxnodes = 30") +
  scale_color_manual(values = pastel_colors)  # Asignar colores pastel desde tu entorno de R

Random Forest ntree = 100,maxnodes = 50

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Definir los parámetros de control para repeated k-fold cross-validation
  repeat_cv <- trainControl(method = 'repeatedcv', number = 10, repeats = 3)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = repeat_cv, 
                    method = "rf", metric = 'Accuracy', 
                    ntree = 100,maxnodes = 50)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd class.error
## anxiety          0      898.6     0    0           1
## depression       0     1839.6     0    0           0
## otros            0      459.2     0    0           1
## ptsd             0      656.0     0    0           1

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.0      158.8   0.0   0.0
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos con el argumento `size`
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Eliminar la leyenda
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest ntree = 100, maxnodes = 50") +
  scale_color_manual(values = pastel_colors)  # Asignar colores pastel desde tu entorno de R

Random Forest ntree = 100,maxnodes = 90

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Definir los parámetros de control para repeated k-fold cross-validation
  repeat_cv <- trainControl(method = 'repeatedcv', number = 10, repeats = 3)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = repeat_cv, 
                    method = "rf", metric = 'Accuracy', 
                    ntree = 100,maxnodes = 90)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd  class.error
## anxiety        0.2      898.4     0  0.0 0.9997785161
## depression     1.0     1838.6     0  0.0 0.0005515734
## otros          0.4      458.6     0  0.2 1.0000000000
## ptsd           0.0      656.0     0  0.0 1.0000000000

# Calcular la matriz de confusión promedio
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.2      158.6   0.0   0.0
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos a 5
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Elimina la leyenda
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest ntree = 100, maxnodes = 90") +
  scale_color_manual(values = pastel_colors)  # Asigna colores pastel desde tu entorno de R

Modelo B.2: Random Forest + Stratified KFold

Random Forest ntree = 40

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Crear pliegues de validación cruzada estratificados
  folds <- createMultiFolds(train_B$disorder, k = num_folds, times = num_repeats)
  
  # Crear train control con los índices estratificados
  stratified_cv <- trainControl(method = 'cv', index = folds, 
                                classProbs = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = stratified_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights),  
                    ntree = 40)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd class.error
## anxiety        6.4      890.0   0.2  2.0  0.99287892
## depression    14.8     1821.0   1.2  2.6  0.01011873
## otros          4.4      452.6   0.6  1.6  0.99870223
## ptsd           4.0      650.2   0.2  1.6  0.99755928

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.4      594.8   0.2   0.0
##   otros          0.4      158.2   0.0   0.2
##   ptsd           0.2      220.6   0.2   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos a 5
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Elimina la leyenda
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Stratified ntree=40") +
  scale_color_manual(values = pastel_colors)  # Asigna colores pastel desde tu entorno de R

Random Forest ntree = 40 maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Crear pliegues de validación cruzada estratificados
  folds <- createMultiFolds(train_B$disorder, k = num_folds, times = num_repeats)
  
  # Crear train control con los índices estratificados
  stratified_cv <- trainControl(method = 'cv', index = folds, 
                                classProbs = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = stratified_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 40,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd  class.error
## anxiety        0.2      898.4     0  0.0 0.9997809419
## depression     0.8     1838.4     0  0.4 0.0006623151
## otros          0.2      459.0     0  0.0 1.0000000000
## ptsd           0.2      655.6     0  0.2 0.9996965099

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.0      158.8   0.0   0.0
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos a 5
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Elimina la leyenda
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Stratified ntree=40 maxnodes = 30") +
  scale_color_manual(values = pastel_colors)  # Asigna colores pastel desde tu entorno de R

Random Forest ntree = 50

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Crear pliegues de validación cruzada estratificados
  folds <- createMultiFolds(train_B$disorder, k = num_folds, times = num_repeats)
  
  # Crear train control con los índices estratificados
  stratified_cv <- trainControl(method = 'cv', index = folds, 
                                classProbs = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = stratified_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 50)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd class.error
## anxiety        4.0      892.4   0.2  2.0 0.995550106
## depression    13.4     1823.2   0.8  2.2 0.008921352
## otros          2.4      455.4   0.4  1.0 0.999134195
## ptsd           3.8      650.8   0.2  1.2 0.998166948

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.4      594.8   0.2   0.0
##   otros          0.0      158.6   0.0   0.2
##   ptsd           0.0      220.8   0.2   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos a 5
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Elimina la leyenda
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Stratified ntree=50") +
  scale_color_manual(values = pastel_colors)  # Asigna colores pastel desde tu entorno de R

Random Forest ntree = 50,maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Crear pliegues de validación cruzada estratificados
  folds <- createMultiFolds(train_B$disorder, k = num_folds, times = num_repeats)
  
  # Crear train control con los índices estratificados
  stratified_cv <- trainControl(method = 'cv', index = folds, 
                                classProbs = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = stratified_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 50,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd  class.error
## anxiety        0.2      898.4   0.0    0 0.9997711670
## depression     0.2     1839.4   0.0    0 0.0001061571
## otros          0.0      459.2   0.0    0 1.0000000000
## ptsd           0.0      655.8   0.2    0 1.0000000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.0      158.6   0.0   0.2
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +  # Ajusta el tamaño de los puntos a 5
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"  # Elimina la leyenda
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Stratified ntree=50 maxnodes = 30") +
  scale_color_manual(values = pastel_colors)  # Asigna colores pastel desde tu entorno de R

Random Forest ntree = 50,maxnodes = 40

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Crear pliegues de validación cruzada estratificados
  folds <- createMultiFolds(train_B$disorder, k = num_folds, times = num_repeats)
  
  # Crear train control con los índices estratificados
  stratified_cv <- trainControl(method = 'cv', index = folds, 
                                classProbs = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = stratified_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 50,maxnodes = 40)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd  class.error
## anxiety        0.4      897.8   0.0  0.4 0.9995594580
## depression     0.8     1837.8   0.2  0.8 0.0009749187
## otros          0.2      458.4   0.0  0.6 1.0000000000
## ptsd           0.0      655.4   0.0  0.6 0.9990783410

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.0      158.6   0.0   0.2
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Stratified ntree=50 maxnodes = 40") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Crear pliegues de validación cruzada estratificados
  folds <- createMultiFolds(train_B$disorder, k = num_folds, times = num_repeats)
  
  # Crear train control con los índices estratificados
  stratified_cv <- trainControl(method = 'cv', index = folds, 
                                classProbs = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = stratified_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd class.error
## anxiety        1.6      896.8   0.0  0.2 0.998227746
## depression     4.8     1833.6   0.0  1.2 0.003273096
## otros          0.6      458.0   0.0  0.6 1.000000000
## ptsd           0.2      655.2   0.2  0.4 0.999385561

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.2   0.2   0.0
##   otros          0.0      158.8   0.0   0.0
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Stratified ntree=100") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100,maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Crear pliegues de validación cruzada estratificados
  folds <- createMultiFolds(train_B$disorder, k = num_folds, times = num_repeats)
  
  # Crear train control con los índices estratificados
  stratified_cv <- trainControl(method = 'cv', index = folds, 
                                classProbs = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = stratified_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd  class.error
## anxiety          0      898.6     0  0.0 1.0000000000
## depression       0     1839.4     0  0.2 0.0001109878
## otros            0      459.2     0  0.0 1.0000000000
## ptsd             0      656.0     0  0.0 1.0000000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.0      158.8   0.0   0.0
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Stratified ntree=100 maxnodes = 30") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100,maxnodes = 50

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Crear pliegues de validación cruzada estratificados
  folds <- createMultiFolds(train_B$disorder, k = num_folds, times = num_repeats)
  
  # Crear train control con los índices estratificados
  stratified_cv <- trainControl(method = 'cv', index = folds, 
                                classProbs = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = stratified_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100,maxnodes = 50)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd  class.error
## anxiety        0.0      898.4   0.2    0 1.0000000000
## depression     0.2     1839.4   0.0    0 0.0001079914
## otros          0.0      459.2   0.0    0 1.0000000000
## ptsd           0.0      656.0   0.0    0 1.0000000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.0      158.8   0.0   0.0
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Stratified ntree=100 maxnodes = 50") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100,maxnodes = 90

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Crear pliegues de validación cruzada estratificados
  folds <- createMultiFolds(train_B$disorder, k = num_folds, times = num_repeats)
  
  # Crear train control con los índices estratificados
  stratified_cv <- trainControl(method = 'cv', index = folds, 
                                classProbs = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = stratified_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100,maxnodes = 90)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros ptsd  class.error
## anxiety        0.2      898.4     0  0.0 0.9997809419
## depression     0.8     1838.6     0  0.2 0.0005483442
## otros          0.2      458.8     0  0.2 1.0000000000
## ptsd           0.0      656.0     0  0.0 1.0000000000

# Calcular la matriz de confusión promedio
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0      291.4   0.0   0.0
##   depression     0.0      595.4   0.0   0.0
##   otros          0.0      158.8   0.0   0.0
##   ptsd           0.0      221.0   0.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Stratified ntree=100 maxnodes = 90") +
  scale_color_manual(values = pastel_colors)

Modelo B.3: Random Forest + Entrenamiento Balanceado por árbol

Random Forest ntree = 40

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF + Entrenamiento Balanceado por árbol
  balanced_cv <- trainControl(method = 'cv', number = num_folds, 
                              classProbs = TRUE, summaryFunction = defaultSummary, 
                              sampling = "down", allowParallel = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = balanced_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 40)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros  ptsd class.error
## anxiety      121.8      118.6 101.0 117.8   0.7352038
## depression   122.6      128.8  97.6 110.2   0.7189506
## otros        123.8      108.6 104.6 122.2   0.7722268
## ptsd         113.8      110.2 107.6 127.6   0.7219413

# Calcular la matriz de confusión promedio
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       82.4       70.8  67.0  71.2
##   depression   167.6      152.6 127.8 147.4
##   otros         43.4       32.2  40.2  43.0
##   ptsd          51.8       52.8  55.2  61.2

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Balanceado ntree=40") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 40 maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF + Entrenamiento Balanceado por árbol
  balanced_cv <- trainControl(method = 'cv', number = num_folds, 
                              classProbs = TRUE, summaryFunction = defaultSummary, 
                              sampling = "down", allowParallel = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = balanced_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 40,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio 
print(average_conf_matrix)

##            anxiety depression otros  ptsd class.error
## anxiety      103.8      129.4 103.4 122.6   0.7738376
## depression   112.0      132.0  94.0 121.2   0.7122076
## otros        103.6      116.6 114.2 124.8   0.7517728
## ptsd         106.8      110.6 104.6 137.2   0.7010815

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       65.4       79.4  68.4  78.2
##   depression   149.6      160.2 126.8 158.8
##   otros         33.8       36.8  39.6  48.6
##   ptsd          41.2       61.6  52.0  66.2

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Balanceado ntree=40 maxnodes = 30") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 50

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF + Entrenamiento Balanceado por árbol
  balanced_cv <- trainControl(method = 'cv', number = num_folds, 
                              classProbs = TRUE, summaryFunction = defaultSummary, 
                              sampling = "down", allowParallel = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = balanced_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 50)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros  ptsd class.error
## anxiety      111.0      123.8 102.0 122.4   0.7586631
## depression   114.8      131.2  94.2 119.0   0.7137873
## otros        115.0      110.0 105.2 129.0   0.7708631
## ptsd         108.0      114.6 102.6 134.0   0.7081664

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       77.0       73.4  63.8  77.2
##   depression   158.4      159.0 118.2 159.8
##   otros         41.0       33.0  33.2  51.6
##   ptsd          48.2       59.0  49.6  64.2

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Balanceado ntree=50") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 50,maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF + Entrenamiento Balanceado por árbol
  balanced_cv <- trainControl(method = 'cv', number = num_folds, 
                              classProbs = TRUE, summaryFunction = defaultSummary, 
                              sampling = "down", allowParallel = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = balanced_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 50,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros  ptsd class.error
## anxiety      102.6      127.0 105.6 124.0   0.7764803
## depression   110.0      135.8  92.6 120.8   0.7041482
## otros        100.4      117.0 111.2 130.6   0.7580209
## ptsd          99.6      114.6 105.4 139.6   0.6960708

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       61.8       77.8  74.2  77.6
##   depression   143.0      154.2 136.6 161.6
##   otros         29.6       36.0  45.2  48.0
##   ptsd          37.8       59.8  58.4  65.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Balanceado ntree=50 maxnodes = 30") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 50,maxnodes = 40

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF + Entrenamiento Balanceado por árbol
  balanced_cv <- trainControl(method = 'cv', number = num_folds, 
                              classProbs = TRUE, summaryFunction = defaultSummary, 
                              sampling = "down", allowParallel = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = balanced_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 50,maxnodes = 40)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros  ptsd class.error
## anxiety      101.6      127.8 109.4 120.4   0.7788604
## depression    99.8      139.8  96.8 122.8   0.6952674
## otros         99.2      108.8 119.6 131.6   0.7396617
## ptsd          98.4      111.8 115.0 134.0   0.7081433

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       64.8       72.4  75.2  79.0
##   depression   133.4      154.2 140.0 167.8
##   otros         28.4       37.4  42.6  50.4
##   ptsd          38.4       59.8  53.8  69.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Balanceado ntree=50 maxnodes = 40") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF + Entrenamiento Balanceado por árbol
  balanced_cv <- trainControl(method = 'cv', number = num_folds, 
                              classProbs = TRUE, summaryFunction = defaultSummary, 
                              sampling = "down", allowParallel = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = balanced_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros  ptsd class.error
## anxiety      112.6      127.0 102.0 117.6   0.7549429
## depression   112.4      132.6  93.8 120.4   0.7106784
## otros        116.2      105.4 105.8 131.8   0.7698770
## ptsd         103.4      115.0 102.2 138.6   0.6978921

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       76.4       75.8  63.8  75.4
##   depression   160.0      156.4 122.6 156.4
##   otros         40.6       34.0  33.6  50.6
##   ptsd          46.8       58.6  48.8  66.8

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Balanceado ntree=100") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100,maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF + Entrenamiento Balanceado por árbol
  balanced_cv <- trainControl(method = 'cv', number = num_folds, 
                              classProbs = TRUE, summaryFunction = defaultSummary, 
                              sampling = "down", allowParallel = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = balanced_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros  ptsd class.error
## anxiety      106.6      124.0 113.2 115.4   0.7678366
## depression   113.8      125.4 101.6 118.4   0.7265094
## otros        100.6      108.8 121.0 128.8   0.7368242
## ptsd         101.4      112.2 121.0 124.6   0.7282707

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       69.0       76.0  75.6  70.8
##   depression   149.4      153.0 133.2 159.8
##   otros         35.4       32.8  44.8  45.8
##   ptsd          43.6       54.8  58.4  64.2

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Balanceado ntree=100 maxnodes = 30") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100,maxnodes = 50

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF + Entrenamiento Balanceado por árbol
  balanced_cv <- trainControl(method = 'cv', number = num_folds, 
                              classProbs = TRUE, summaryFunction = defaultSummary, 
                              sampling = "down", allowParallel = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = balanced_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100,maxnodes = 50)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros  ptsd class.error
## anxiety      100.2      124.8 111.6 122.6   0.7822177
## depression   109.4      130.2  92.2 127.4   0.7161774
## otros        104.4      104.2 111.8 138.8   0.7563256
## ptsd          95.0      107.8 108.0 148.4   0.6765194

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       67.2       74.4  68.8  81.0
##   depression   137.4      152.6 130.4 175.0
##   otros         34.2       33.2  38.8  52.6
##   ptsd          40.8       56.2  52.4  71.6

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Balanceado ntree=100 maxnodes = 50") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100,maxnodes = 90

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF + Entrenamiento Balanceado por árbol
  balanced_cv <- trainControl(method = 'cv', number = num_folds, 
                              classProbs = TRUE, summaryFunction = defaultSummary, 
                              sampling = "down", allowParallel = TRUE)
  # Ajustar el modelo Random Forest
  model_RF <- train(disorder ~ ., 
                    data = train_B, trControl = balanced_cv,
                    method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100,maxnodes = 90)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression otros  ptsd class.error
## anxiety      104.6      117.2 114.4 123.0   0.7728980
## depression   114.6      121.6 100.8 122.2   0.7348182
## otros        108.4      101.4 116.0 133.4   0.7473434
## ptsd          95.0      103.6 115.6 145.0   0.6840599

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       70.4       72.4  73.8  74.8
##   depression   147.2      150.0 140.4 157.8
##   otros         34.4       35.0  42.0  47.4
##   ptsd          45.2       51.6  59.4  64.8

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + Balanceado ntree=100 maxnodes = 90") +
  scale_color_manual(values = pastel_colors)

Modelo B.4: Random Forest + SMOTE

Random Forest ntree = 40

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF añadiendo SMOTE
  # Ahora, crear un nuevo trainControl 
  smote_cv <- trainControl(method = 'cv', number = num_folds, classProbs = TRUE, allowParallel = TRUE)
  
  # Aplicar SMOTE a los datos de `train_B`
  data_balanced <- SMOTE(train_B %>% 
                            select(-c(disorder)),  # Selecciona solo las características
                         train_B$disorder, K = 5)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(control ~ ., 
                       data = data_balanced$data %>% rename(control = class), trControl = smote_cv, 
                       method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 40)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression  otros  ptsd class.error
## anxiety      109.6      496.0  242.0  51.0   0.8784137
## depression   249.4      988.0  486.8 115.4   0.4632228
## otros         59.0      323.6 2813.0  18.8   0.1249801
## ptsd          73.4      347.6  195.6  39.4   0.9399075

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       32.0      162.8  81.8  14.8
##   depression    76.0      330.4 155.2  33.8
##   otros         21.6       82.6  45.2   9.4
##   ptsd          24.8      122.8  60.4  13.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + SMOTE ntree=40") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 40 maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF añadiendo SMOTE
  # Ahora, crear un nuevo trainControl 
  smote_cv <- trainControl(method = 'cv', number = num_folds, classProbs = TRUE, allowParallel = TRUE)
  
  # Aplicar SMOTE a los datos de `train_B`
  data_balanced <- SMOTE(train_B %>% 
                            select(-c(disorder)),  # Selecciona solo las características
                         train_B$disorder, K = 5)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(control ~ ., 
                       data = data_balanced$data %>% rename(control = class), trControl = smote_cv, 
                       method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 40,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression  otros ptsd class.error
## anxiety        0.2      289.6  608.8    0  0.99977553
## depression     1.8      600.8 1237.0    0  0.67392153
## otros          0.0      235.6 2978.8    0  0.07321514
## ptsd           0.4      175.8  479.8    0  1.00000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0       86.4 205.0   0.0
##   depression     0.0      197.8 397.6   0.0
##   otros          0.0       44.2 114.6   0.0
##   ptsd           0.0       60.0 161.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + SMOTE ntree=40 maxnodes = 30") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 50

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF añadiendo SMOTE
  # Ahora, crear un nuevo trainControl 
  smote_cv <- trainControl(method = 'cv', number = num_folds, classProbs = TRUE, allowParallel = TRUE)
  
  # Aplicar SMOTE a los datos de `train_B`
  data_balanced <- SMOTE(train_B %>% 
                            select(-c(disorder)),  # Selecciona solo las características
                         train_B$disorder, K = 5)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(control ~ ., 
                       data = data_balanced$data %>% rename(control = class), trControl = smote_cv, 
                       method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 50)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression  otros ptsd class.error
## anxiety       68.6      479.8  316.8 33.4   0.9239872
## depression   158.0      975.8  635.2 70.6   0.4696088
## otros         37.6      291.2 2873.4 12.2   0.1063756
## ptsd          46.8      331.4  250.6 27.2   0.9587903

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       19.2      156.0 106.0  10.2
##   depression    47.0      324.0 201.8  22.6
##   otros         13.2       77.8  61.0   6.8
##   ptsd          12.6      118.6  83.0   6.8

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + SMOTE ntree=50") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 50,maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF añadiendo SMOTE
  # Ahora, crear un nuevo trainControl 
  smote_cv <- trainControl(method = 'cv', number = num_folds, classProbs = TRUE, allowParallel = TRUE)
  
  # Aplicar SMOTE a los datos de `train_B`
  data_balanced <- SMOTE(train_B %>% 
                            select(-c(disorder)),  # Selecciona solo las características
                         train_B$disorder, K = 5)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(control ~ ., 
                       data = data_balanced$data %>% rename(control = class), trControl = smote_cv, 
                       method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 50,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression  otros ptsd class.error
## anxiety        0.4      284.0  614.2    0  0.99955107
## depression     1.4      589.0 1249.2    0  0.68049619
## otros          0.6      215.0 2998.8    0  0.06686851
## ptsd           0.2      169.8  486.0    0  1.00000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0       83.0 208.4   0.0
##   depression     0.0      189.8 405.6   0.0
##   otros          0.0       39.2 119.6   0.0
##   ptsd           0.0       56.6 164.4   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + SMOTE ntree=50 maxnodes = 30") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 50,maxnodes = 40

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF añadiendo SMOTE
  # Ahora, crear un nuevo trainControl 
  smote_cv <- trainControl(method = 'cv', number = num_folds, classProbs = TRUE, allowParallel = TRUE)
  
  # Aplicar SMOTE a los datos de `train_B`
  data_balanced <- SMOTE(train_B %>% 
                            select(-c(disorder)),  # Selecciona solo las características
                         train_B$disorder, K = 5)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(control ~ ., 
                       data = data_balanced$data %>% rename(control = class), trControl = smote_cv, 
                       method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 50,maxnodes = 40)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression  otros ptsd class.error
## anxiety        1.0      299.2  598.4    0  0.99888904
## depression     2.0      639.0 1198.6    0  0.65320195
## otros          0.4      214.4 2999.6    0  0.06677422
## ptsd           0.2      186.6  469.2    0  1.00000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0       89.8 201.6   0.0
##   depression     0.4      204.8 390.2   0.0
##   otros          0.0       41.4 117.4   0.0
##   ptsd           0.2       61.8 159.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + SMOTE ntree=50 maxnodes = 40") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF añadiendo SMOTE
  # Ahora, crear un nuevo trainControl 
  smote_cv <- trainControl(method = 'cv', number = num_folds, classProbs = TRUE, allowParallel = TRUE)
  
  # Aplicar SMOTE a los datos de `train_B`
  data_balanced <- SMOTE(train_B %>% 
                            select(-c(disorder)),  # Selecciona solo las características
                         train_B$disorder, K = 5)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(control ~ ., 
                       data = data_balanced$data %>% rename(control = class), trControl = smote_cv, 
                       method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression  otros ptsd class.error
## anxiety       46.6      478.4  349.8 23.8  0.94865791
## depression   108.4      984.2  699.0 48.0  0.46501859
## otros         24.0      256.8 2924.4  9.2  0.09063424
## ptsd          33.8      319.4  284.0 18.8  0.97173344

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety       14.2      149.4 119.8   8.0
##   depression    34.2      317.0 224.6  19.6
##   otros         10.4       74.0  69.0   5.4
##   ptsd           8.2      114.0  93.2   5.6

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + SMOTE ntree=100") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100,maxnodes = 30

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF añadiendo SMOTE
  # Ahora, crear un nuevo trainControl 
  smote_cv <- trainControl(method = 'cv', number = num_folds, classProbs = TRUE, allowParallel = TRUE)
  
  # Aplicar SMOTE a los datos de `train_B`
  data_balanced <- SMOTE(train_B %>% 
                            select(-c(disorder)),  # Selecciona solo las características
                         train_B$disorder, K = 5)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(control ~ ., 
                       data = data_balanced$data %>% rename(control = class), trControl = smote_cv, 
                       method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100,maxnodes = 30)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio 
print(average_conf_matrix)

##            anxiety depression  otros ptsd class.error
## anxiety        0.0      277.8  620.8    0  1.00000000
## depression     1.0      585.8 1252.8    0  0.68207838
## otros          0.2      205.8 3008.4    0  0.06404731
## ptsd           0.2      166.2  489.6    0  1.00000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.0       83.2 208.2   0.0
##   depression     0.0      191.8 403.6   0.0
##   otros          0.0       41.6 117.2   0.0
##   ptsd           0.0       59.0 162.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + SMOTE ntree=100 maxnodes = 30") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100,maxnodes = 50

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF añadiendo SMOTE
  # Ahora, crear un nuevo trainControl 
  smote_cv <- trainControl(method = 'cv', number = num_folds, classProbs = TRUE, allowParallel = TRUE)
  
  # Aplicar SMOTE a los datos de `train_B`
  data_balanced <- SMOTE(train_B %>% 
                            select(-c(disorder)),  # Selecciona solo las características
                         train_B$disorder, K = 5)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(control ~ ., 
                       data = data_balanced$data %>% rename(control = class), trControl = smote_cv, 
                       method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100,maxnodes = 50)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression  otros ptsd class.error
## anxiety        1.0      311.6  585.8  0.2  0.99888363
## depression     2.0      670.4 1167.2  0.0  0.63624147
## otros          0.2      190.4 3023.8  0.0  0.05917164
## ptsd           0.4      190.0  465.6  0.0  1.00000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        0.6       92.4 198.4   0.0
##   depression     1.0      211.0 383.4   0.0
##   otros          0.2       45.4 113.2   0.0
##   ptsd           0.2       64.2 156.6   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + SMOTE ntree=100 maxnodes = 50") +
  scale_color_manual(values = pastel_colors)

Random Forest ntree = 100,maxnodes = 90

# Función para ajuste del modelo y obtención de matriz de confusión
fit_model <- function(seed) {
  set.seed(seed)
  
  # Train-test split
  top <- floor(dim(train)[1] * 0.75)
  ind <- sample(1:dim(train)[1], top)
  
  train.set <- train[ind, ]
  test.set <- train[-ind, ]
  
  # Dividir los datos en dos conjuntos: para Clasificación B
  train_B <- train.set %>%
    filter(disorder != "control") %>% # Filtrar la variable Control
    select(-control) %>% # Excluir la columna control
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  test_B <- test.set %>%
    filter(disorder != "control") %>%
    select(-control) %>%
    mutate(disorder = factor(if_else(disorder %in% c("bipolar", "borderline", "panic"), "otros", disorder)))
  
  # Hacer el Entrenamiento del Modelo_B por la clasificación de la variable `disorder` con class weights
  class_freq <- table(train_B$disorder)
  class_weights <- 1 / class_freq
  
  # Modelo RF añadiendo SMOTE
  # Ahora, crear un nuevo trainControl 
  smote_cv <- trainControl(method = 'cv', number = num_folds, classProbs = TRUE, allowParallel = TRUE)
  
  # Aplicar SMOTE a los datos de `train_B`
  data_balanced <- SMOTE(train_B %>% 
                            select(-c(disorder)),  # Selecciona solo las características
                         train_B$disorder, K = 5)
  
  # Ajustar el modelo Random Forest
  model_RF <- train(control ~ ., 
                       data = data_balanced$data %>% rename(control = class), trControl = smote_cv, 
                       method = "rf", metric = 'Accuracy', class.weights = list(control = class_weights), 
                    ntree = 100,maxnodes = 90)
  
  confusion_matrix <- model_RF$finalModel$confusion
  
  # Obtener los errores de validación cruzada
  errors <- data.frame(model_RF[["finalModel"]][["err.rate"]])
  errors$ntree <- 1:nrow(errors)
  errors$seed <- seed

  # Obtener la importancia de las variables
  var_importance <- varImp(model_RF$finalModel)
  var_importance$seed <- seed
  var_importance <- cbind(Variables = rownames(var_importance), var_importance)
  rownames(var_importance) <- 1:nrow(var_importance)  
  
  # test
  conf_matrix_test <- confusionMatrix(predict(model_RF, test_B), test_B$disorder)$table
  
  return(list(confusion_matrix = confusion_matrix,errors = errors, var_importance = var_importance,
              conf_matrix_test = conf_matrix_test))
}

# Lista para almacenar los resultados
results_list <- lapply(seeds, fit_model)

# Extraer las matrices de confusión, errores y importancias
conf_matrices <- lapply(results_list, function(x) x$confusion_matrix)
errors_list <- lapply(results_list, function(x) x$errors)
var_importances <- lapply(results_list, function(x) x$var_importance)
conf_matrix_test <- lapply(results_list, function(x) x$conf_matrix_test)

# Calcular la matriz de confusión promedio
average_conf_matrix <- Reduce("+", conf_matrices) / length(seeds)

# Mostrar la matriz de confusión promedio
print(average_conf_matrix)

##            anxiety depression  otros ptsd class.error
## anxiety        1.4      358.6  538.4  0.2  0.99842160
## depression     9.0      763.4 1066.8  0.4  0.58558519
## otros          1.4      210.6 3002.2  0.2  0.06590344
## ptsd           1.6      232.4  422.0  0.0  1.00000000

# Calcular la matriz de confusión promedio test
average_conf_matrix_test <- Reduce("+", conf_matrix_test) / length(seeds)

# Mostrar la matriz de confusión promedio test
print(t(average_conf_matrix_test))

##             Prediction
## Reference    anxiety depression otros  ptsd
##   anxiety        1.2      106.2 183.8   0.2
##   depression     2.4      245.4 347.6   0.0
##   otros          0.4       53.8 104.6   0.0
##   ptsd           0.2       79.8 141.0   0.0

# Combinar todos los errores en un solo data frame
all_errors <- bind_rows(errors_list)

# Calcular el promedio de los errores de validación cruzada
average_errors <- all_errors %>%
  group_by(ntree) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar el promedio de los errores de validación cruzada
ggplot(average_errors) +
  geom_line(aes(x = ntree, y = OOB, color = "OOB", linetype = "OOB"), size = 1) +
  geom_line(aes(x = ntree, y = anxiety, color = "anxiety", linetype = "anxiety"), size = 1) +
  geom_line(aes(x = ntree, y = otros, color = "otros", linetype = "otros"), size = 1) +
  geom_line(aes(x = ntree, y = depression, color = "depression", linetype = "depression"), size = 1) +
  geom_line(aes(x = ntree, y = ptsd, color = "ptsd", linetype = "ptsd"), size = 1) +
  theme_minimal() +
  ylab("Error de Validación Cruzada Promedio") +
  guides(colour = guide_legend(override.aes = list(linetype = c(1, 2, 3, 4, 5)))) +
  scale_linetype(guide = FALSE) +
  theme(panel.grid = element_blank(),
        legend.title = element_blank(),
        legend.position = "bottom")

# Combinar todos los var_importances en un solo data frame
all_var_importances <- bind_rows(var_importances)

# Calcular la importancia promedio de las variables
averages_var_importances <- all_var_importances %>%
  group_by(Variables) %>%
  summarise(across(everything(), mean, na.rm = TRUE))

# Graficar la importancia promedio de las variables
ggplot(averages_var_importances, aes(x = reorder(Variables, Overall), y = Overall, color = Variables)) +
  geom_point(stat = "identity", size = 5) +
  coord_flip() +
  theme_minimal() +
  theme(
    legend.position = "none"
  ) +
  xlab("") +
  ylab("") +
  ggtitle("Random Forest + SMOTE ntree=100 maxnodes = 90") +
  scale_color_manual(values = pastel_colors)