Machine Learning: Aprendizaje Supervisado

Modelos de Clasificación: detección de cáncer de seno

Datos

• Fuente - UCI Machine Learning Repository: Datos de cáncer de seno.
• Problema: entrenar modelos de aprendizaje automático - aprendizaje supervisado, para detectar cáncer de seno. Las variables son constituidas como predictores que pueden ser parametrizadas y servir como biomarcadores de cáncer.
• Variable respuesta:
  • 0: pacientes saludables.
  • 1: pacientes enfermos.

Metodología

1. Lectura de datos.
   
2. Exploración de datos.
   2.1. Proporción de enfermos y sanos.
   2.2. Distribuciones de probabilidad.
   2.3. Correlaciones de variables predictoras.
   2.4. Tendencias por edad del paciente.
   
3. Preprocesamiento de datos.
   3.1. Partición en Training y Testing.
   3.2. Normalización de variables.
   3.3. Recodificación de variable respuesta Classification (“0”: paciente sano y “1”: paciente enfermo).
   3.4. Preprocesamiento específico para implementación de redes neuronales profundas (deep learning) con bibliotecas keras y lime.
   
4. Ajuste de modelos de Machine Learning - Supervised Learning:
   4.1. K-Nearest Neighbor.
   4.2. Naive Bayes.
   4.3. Regresión Logística.
   4.4. Árbol de decisión (clasificación).
   4.5. Random Forest.
   4.6. Support Vector Machine.
   4.7. Gradient Boosting.
   4.8. Deep Learning (Multilayer Perceptron).
   
5. Desempeño de los modelos: comparación de Accuracy en Training y Testing.
   
6. Referencias

Resultados

1. Lectura de datos

2. Análisis exploratorio

Proporción de enfermos y sanos

       0        1 
44.82759 55.17241 

Distribuciones

Correlaciones

Tendencias por edad

3. Preprocesamiento

Train y Test

• Primero se convierte en factor la variable respuesta que está codificada como numeric. Este paso es importante para garantizar que las proporciones de cada clase (enfermo o sano) se mantengan en las bases de datos train y test.
• Se usa la biblioteca caret con la función CreateDataPartition().
• La partición se realizó 70-30%, para train y test, respectivamente.
• Nota: la función implementada tiene en cuenta la proporción de la variable respuesta para el train y test, no obstante, no hace énfasis en la variabilidad de predictores (problemas de varianza igual a cero).

set.seed(1000)
library(caret)
df_seno$Classification <- as.factor(df_seno$Classification)
ind <- createDataPartition(y = df_seno$Classification, times = 1,
                           p = 0.7, list = FALSE)
df_train <- df_seno[ind, ]
df_testi <- df_seno[-ind, ]

Preprocesamiento para keras

• Para ajustar el modelo secuencial con keras es necesario coercionar las bases de datos (data.frame) train y test a la clase matrix, de la misma manera que quedó coercionada la variable respuesta en el paso anterior.
• En keras y muchas otras bibliotecas para Machine Learning los modelos se expresan en términos matriciales; esto debido a la eficiencia algebráica para procesamiento de información. Este requisito no es obligatorio en todos los modelos, puesto que algunos aceptan las variables declaradas como fórmula (formula = y ~ x + w + z).

# Coerción a matriz
x_train <- as.matrix(df_train[, 1:9])
x_testi <- as.matrix(df_testi[, 1:9])
# Eliminando dimensiones
dimnames(x_train) <- NULL
dimnames(x_testi) <- NULL

Normalización

• La normalización o estandarización de variables puede ser efecutada de maneras diferentes:
  • Escalado Min-Max: \(z_i = x-mínimo_x/(máximo_x-mínimo_x)\). La variable queda acotada entre [0, 1].
  • Estandarización: \(x - \mu_x/\sigma_x\). La variable queda acotada entre [-1, 1], con \(\mu = 0\) y \(\sigma = 1\).
• La normalización o estandarización de variables es necesaria para la ejecución de algunos algoritmos como las redes neuronales, las máquinas de soporte vectorial o la regresión logística. Este proceso es necesario cuando las unidades de las variables son diferentes, tratando de evitar el sobrepeso (mayor importancia para el modelo) en variables que posean mayor variabilidad (varianza).
• En R se pueden implementar las funciones scale() para escalar o estandarizar las variables y la función normalize() del paquete keras permite aplicar la normalización min-max.
• Para este ejemplo las variables serán normalizadas con la función normalize() de la biblioteca keras.

library(keras)
df_train[, 1:9] <- normalize(x_train[, 1:9])
df_testi[, 1:9] <- normalize(x_testi[, 1:9])

• A manera de ejemplo se muestra el rango de las variables df_train. Corroborando que ninguna de las variables posee valores inferiores a cero o mayores a 1.

apply(df_train, 2, range)

     Age          BMI          Glucose      Insulin       HOMA           Leptin        Adiponectin   Resistin     
[1,] "0.02820357" "0.01555693" "0.05288169" "0.001492439" "0.0003313214" "0.005518683" "0.003125271" "0.005109257"
[2,] "0.39514376" "0.17217330" "0.73820809" "0.062640891" "0.0175414790" "0.264769237" "0.172404469" "0.260385811"
     MCP.1       Classification
[1,] "0.4829921" "0"           
[2,] "0.9979598" "1"           

Recodificación de Classification

• Para el modelo de red neuronal profunda implementado a través de keras, es necesario convertir la variable respuesta en Dummy, en regresión se suele hablar de variables indicadoras, aunque también es conocido como one-hot encoding (codificación activa) en Machine Learning.
• La función to_categorical() del paquete keras permite esta conversión.

y_train <- to_categorical(df_train$Classification)
y_testi <- to_categorical(df_testi$Classification)

4. Modelos

• Se usan las bibliotecas caret, y keras para entrenar los modelos de Machine Learning.
• A través de validación cruzada (k = 10 y repeticiones = 10) se evalúa el desempeño de los modelos.
• La métrica a tener en cuenta para comparar los modelos es la Accuracy o precisión del modelo.
• Todos los procedimientos con caret son paralelizados con la biblioteca doMC.

K-Nearest Neighbor

• Características generales:
  • Uno de los algoritmos de Machine Learning más simples.
  • Fundamentado en identificar observaciones que se asemejen a las observaciones vecinas para realizar predicciones.
  • Una nueva observación se predice en función de su “similitud” con otras observaciones (“vecinos más cercanos”).
  • La “similitud” con otras observaciones es cuantificada con métricas de distancia, por ejemplo, distancia Euclidiana.
  • Pueden ser computacionalmente ineficientes y son conocidos como lazy learners (Cunningham & Delany, 2007).
  • Hiperparámetro k: número de observaciones vecinas empleadas para realizar la predicción.
  • Algunos casos de uso:
    • Categorización de texto (Jiang et al., 2012).
    • Detección de Spam en Twitter (McCord & Chuah, 2011).
    • Clasificación de tumores cerebrales con imágenes hiper-espectrales (Florimbi et al., 2018).
    • Selección de características - Feature Engineering (Shenggiao et al., 2011).

# Paralelización del proceso
library(doMC)
library(parallel)
registerDoMC(cores = detectCores())
# Submuestras y repeticiones
particiones  <- 10
repeticiones <- 10
# Definiendo hiperparámetro k
hiperparametros <- expand.grid(k = seq(1, 30, 2))
# Semillas
set.seed(123)
seeds <- vector(mode = "list", length = (particiones * repeticiones) + 1)
for (i in 1:(particiones * repeticiones)) {
  seeds[[i]] <- sample.int(1000, nrow(hiperparametros)) 
}
seeds[[(particiones * repeticiones) + 1]] <- sample.int(1000, 1)
# Control de entrenamiento
cross_val <- trainControl(
  method = "repeatedcv",
  number = particiones,
  repeats = repeticiones,
  returnResamp = "final",
  verboseIter = FALSE,
  allowParallel = TRUE,
  seeds = seeds
)
# Ajuste del modelo (entrenamiento)
set.seed(1000)
mod_knn <- train(
  Classification ~ .,
  data = df_train,
  method = "knn",
  tuneGrid = hiperparametros,
  metric = "Accuracy",
  trControl = cross_val
)

• Evaluando el \(k\) óptimo:

• Resultados del modelo (de mayor a menor accuracy):

• Accuracy en testing (matriz de confusión):

Confusion Matrix and Statistics

    Predicho
Real  0  1
   0  5 10
   1  5 14
                                          
               Accuracy : 0.5588          
                 95% CI : (0.3789, 0.7281)
    No Information Rate : 0.7059          
    P-Value [Acc > NIR] : 0.9777          
                                          
                  Kappa : 0.0727          
                                          
 Mcnemar's Test P-Value : 0.3017          
                                          
            Sensitivity : 0.5833          
            Specificity : 0.5000          
         Pos Pred Value : 0.7368          
         Neg Pred Value : 0.3333          
             Prevalence : 0.7059          
         Detection Rate : 0.4118          
   Detection Prevalence : 0.5588          
      Balanced Accuracy : 0.5417          
                                          
       'Positive' Class : 1               
                                          

Naive Bayes

• Características:
  • Se fundamenta en el cálculo de probabilidades condicionales basado en el Teorema de Bayes.
  • El algoritmo asume que existe independencia entre las variables predictoras, de ahí que su nombre sea naive (ingenuo en inglés). En la vida real esta suposición de independencia rara vez se cumple, no obstante, proporciona resultados favorables en variedad de aplicaciones.
  • Posee tres hiperparámetros:
    • usekernel: TRUE para utilizar un kernel que estime la densidad o FALSE para asumir una función de densidad gaussiana.
    • fL: fL = 1 para aplicar el factor de corrección de Laplace. De utilidad cuando se tienen eventos o conjuntos vacios, es decir, ausencia de información que impide el cálculo de probabilidades de manera correcta.
    • adjust: parámetro que hace parte de la función density() en caso de usekernel = TRUE.
  • Algunos usos:
    • Clasificación de secuencias de RNA en taxonomía bacteriana (Wang et al., 2007).
    • Selección de características para entrenamiento de Support Vector Machine (Cinelli et al., 2017).
    • Eventos adversos de fármacos con base en citas de PubMed (Wang et al., 2011).
    • Extracción de características para clasificación de texto (Sarkar et al., 2014).
    • Estimación de ubicación (geoposicionamiento) probabilística (Shauer, 2019).

# Paralelización del proceso
library(doMC)
library(parallel)
registerDoMC(cores = detectCores())
# Submuestras y repeticiones
particiones  <- 10
repeticiones <- 10
# Definiendo hiperparámetro k
hiperparametros <- data.frame(usekernel = FALSE, fL = 0 , adjust = 0)
# Semillas
set.seed(123)
seeds <- vector(mode = "list", length = (particiones * repeticiones) + 1)
for (i in 1:(particiones * repeticiones)) {
  seeds[[i]] <- sample.int(1000, nrow(hiperparametros)) 
}
seeds[[(particiones * repeticiones) + 1]] <- sample.int(1000, 1)
# Control de entrenamiento
cross_val <- trainControl(
  method = "repeatedcv",
  number = particiones,
  repeats = repeticiones,
  returnResamp = "final",
  verboseIter = FALSE,
  allowParallel = TRUE,
  seeds = seeds
)
# Ajuste del modelo (entrenamiento)
set.seed(1000)
mod_bayes <- train(
  Classification ~ .,
  data = df_train,
  method = "nb",
  tuneGrid = hiperparametros,
  metric = "Accuracy",
  trControl = cross_val
)

• Resultados del modelo:

• Accuracy en testing (matriz de confusión):

Confusion Matrix and Statistics

    Predicho
Real  0  1
   0  1 14
   1  4 15
                                          
               Accuracy : 0.4706          
                 95% CI : (0.2978, 0.6487)
    No Information Rate : 0.8529          
    P-Value [Acc > NIR] : 1.00000         
                                          
                  Kappa : -0.1547         
                                          
 Mcnemar's Test P-Value : 0.03389         
                                          
            Sensitivity : 0.51724         
            Specificity : 0.20000         
         Pos Pred Value : 0.78947         
         Neg Pred Value : 0.06667         
             Prevalence : 0.85294         
         Detection Rate : 0.44118         
   Detection Prevalence : 0.55882         
      Balanced Accuracy : 0.35862         
                                          
       'Positive' Class : 1               
                                          

Regresión Logística

• Características:
  • Algoritmos de amplio uso en estadística e incorporados hoy en día como parte de la caja de herramientas para Machine Learning.
  • Hace parte de los Modelos Lineales Generalizados (GLM).
  • Permite modelar variables con distribución de errores no gaussianas o normales.
  • Aplica transformaciones sobre la variable respuesta original, tratando de linealizar la relación con las predictoras a través de una función de enlace (linkage).
  • Es aplicable a problemas binomiales y multinomiales.
  • Algunos casos de uso:
    • Estudio comparativo de técnicas de predicción en pacientes con VIH (Bisaso et al., 2018).
    • Análisis del riesgo cardiovascular con datos clínicos (Weng et al., 2017).
    • Detección de anomalías en el crecimiento fetal (Kuhle et al., 2018).
    • Clasificación de enfermedades a través de aprendizaje semisupervisado (Chai et al., 2018).
    • Artículo guía: entendiendo el análisis de regresión logística (Sperandei, 2014).

# Paralelización del proceso
library(doMC)
library(parallel)
registerDoMC(cores = detectCores())
# Submuestras y repeticiones
particiones  <- 10
repeticiones <- 10
# Definiendo hiperparámetro k
hiperparametros <- data.frame(parameter = "none")
# Semillas
set.seed(123)
seeds <- vector(mode = "list", length = (particiones * repeticiones) + 1)
for (i in 1:(particiones * repeticiones)) {
  seeds[[i]] <- sample.int(1000, nrow(hiperparametros)) 
}
seeds[[(particiones * repeticiones) + 1]] <- sample.int(1000, 1)
# Control de entrenamiento
cross_val <- trainControl(
  method = "repeatedcv",
  number = particiones,
  repeats = repeticiones,
  returnResamp = "final",
  verboseIter = FALSE,
  allowParallel = TRUE,
  seeds = seeds
)
# Ajuste del modelo (entrenamiento)
set.seed(1000)
mod_regl <- train(
  Classification ~ .,
  data = df_train,
  method = "glm",
  tuneGrid = hiperparametros,
  metric = "Accuracy",
  trControl = cross_val
)

• Resultados del modelo:

• Accuracy en testing (matriz de confusión):

Confusion Matrix and Statistics

    Predicho
Real  0  1
   0  8  7
   1  2 17
                                          
               Accuracy : 0.7353          
                 95% CI : (0.5564, 0.8712)
    No Information Rate : 0.7059          
    P-Value [Acc > NIR] : 0.4355          
                                          
                  Kappa : 0.4436          
                                          
 Mcnemar's Test P-Value : 0.1824          
                                          
            Sensitivity : 0.7083          
            Specificity : 0.8000          
         Pos Pred Value : 0.8947          
         Neg Pred Value : 0.5333          
             Prevalence : 0.7059          
         Detection Rate : 0.5000          
   Detection Prevalence : 0.5588          
      Balanced Accuracy : 0.7542          
                                          
       'Positive' Class : 1               
                                          

Árbol de decisión

• Características:
  • Se fundamenta en la segmentación del espacio de predictores a través de reglas lógicas (booleanas) simples.
  • Hacen parte de los algoritmos no paramétricos.
  • Modelos de árbol pequeños son de fácil interpretación, además, son fáciles de visualizar.
  • Permiten modelar relaciones no lineales de manera sencilla.
  • Ignora facilmente las variables menos importantes.
  • A menudo presentan alta varianza en las predicciones.
  • Dentro de los algoritmos de árboles de decisión se destacan los siguientes:
    • CART: algoritmo original de Leo Breiman.
    • ID3, C4.5 y C5.0. Todos desarrollados por Ross Quinlan.
  • La métrica de impureza utilizada por CART es Gini.
  • La métrica de impureza utilizada por ID3, C4.5 y C5.0 es la entropía o ganancia de información.
  • Algunos casos de uso:
    • Predicción de gripe en pacientes de atención primaria (Zimmerman et al., 2016).
    • Árboles de decisión aplicados en servicios psiquiátricos (Song & Lu, 2015).
    • Predicción de accidentes laborales en fábrica de acero de Irán (Shirali et al., 2018).
    • Cambio en el uso del suelo basado en algoritmo CART (Sang et al., 2019).
    • Detección temprana de mastitis en vacas productoras de leche (Zhang et al., 2015).

# Paralelización del proceso
library(doMC)
library(parallel)
registerDoMC(cores = detectCores())

# Submuestras y repeticiones
particiones  <- 10
repeticiones <- 10

# Definiendo hiperparámetro k
hiperparametros <- data.frame(parameter = "none")

# Semillas
set.seed(123)
seeds <- vector(mode = "list", length = (particiones * repeticiones) + 1)
for (i in 1:(particiones * repeticiones)) {
  seeds[[i]] <- sample.int(1000, nrow(hiperparametros)) 
}
seeds[[(particiones * repeticiones) + 1]] <- sample.int(1000, 1)

# Control de entrenamiento
cross_val <- trainControl(
  method = "repeatedcv",
  number = particiones,
  repeats = repeticiones,
  returnResamp = "final",
  verboseIter = FALSE,
  allowParallel = TRUE,
  seeds = seeds
)

# Ajuste del modelo (entrenamiento)
set.seed(1000)
mod_c5tree <- train(
  Classification ~ .,
  data = df_train,
  method = "C5.0Tree",
  tuneGrid = hiperparametros,
  metric = "Accuracy",
  trControl = cross_val
)

• Resultados del modelo:

• Accuracy en testing (matriz de confusión):

Confusion Matrix and Statistics

    Predicho
Real  0  1
   0  5 10
   1  3 16
                                          
               Accuracy : 0.6176          
                 95% CI : (0.4356, 0.7783)
    No Information Rate : 0.7647          
    P-Value [Acc > NIR] : 0.98311         
                                          
                  Kappa : 0.1845          
                                          
 Mcnemar's Test P-Value : 0.09609         
                                          
            Sensitivity : 0.6154          
            Specificity : 0.6250          
         Pos Pred Value : 0.8421          
         Neg Pred Value : 0.3333          
             Prevalence : 0.7647          
         Detection Rate : 0.4706          
   Detection Prevalence : 0.5588          
      Balanced Accuracy : 0.6202          
                                          
       'Positive' Class : 1               
                                          

Random Forest

• Características:
  • Considerado como parte de los métodos de Bagging (bootstrap aggregation) propuestos por Leo Breiman.
  • El Bagging surge como estrategía para el desequilibrio bias-varianza.
  • El término Bagging hace referencia al empleo del muestreo repetido (bootstrapping).
  • El algoritmo en lugar de ajustar un sólo arbol de decisión permite la incorporación de muchos de estos, conformando lo que se denomina como “bosque”. Se denomina “bosque aleatorio” porque selecciona aleatoriamente \(m\) predictores para la construcción de los árboles.
  • Permite obtener métricas de importancia de variables, resultando en un método viable para seleccionar predictores.
  • En R puede ser implementado a través de la biblioteca randomForest o ranger. El método ranger posee tres hiperparámetros controlables:
    • mtry: número de predictores seleccionados aleatoriamente en cada árbol.
    • min.node.size: tamaño mínimo que debe tener un nodo para ser dividido.
    • splitrule: criterio de división (por defecto gini).
  • Algunos casos de uso:
    • Bosques aleatorios para clasificación de neuroimágenes en pacientes con Alzheimer (Sarica et al., 2017).
    • Identificación de fuentes de contaminación del agua a través de Bosques Aleatorios (Roguet et al., 2018).
    • Modelado de variables espaciales y espacio-temporales con Bosques Aleatorios (Hengl et al., 2018).
    • Extracción de características con Bosques Aleatorios para análisis de expresión génica con Deep Learning (Kong & Yu, 2018).
    • Predicción de cáncer de próstata con Bosques Aleatorios (Xiao et al., 2017).
    • Bosques Aleatorios para análisis de datos genómicos (Chen & Ishwaran, 2013).

# Paralelización del proceso
library(doMC)
library(parallel)
registerDoMC(cores = detectCores())
# Submuestras y repeticiones
particiones  <- 10
repeticiones <- 10
# Definiendo hiperparámetro k
hiperparametros <- expand.grid(mtry = seq(1, 9, 1),
                               min.node.size = seq(1, 30, 2),
                               splitrule = "gini")
# Semillas
set.seed(123)
seeds <- vector(mode = "list", length = (particiones * repeticiones) + 1)
for (i in 1:(particiones * repeticiones)) {
  seeds[[i]] <- sample.int(1000, nrow(hiperparametros)) 
}
seeds[[(particiones * repeticiones) + 1]] <- sample.int(1000, 1)
# Control de entrenamiento
cross_val <- trainControl(
  method = "repeatedcv",
  number = particiones,
  repeats = repeticiones,
  returnResamp = "final",
  verboseIter = FALSE,
  allowParallel = TRUE,
  seeds = seeds
)
# Ajuste del modelo (entrenamiento)
set.seed(1000)
mod_rf <- train(
  Classification ~ .,
  data = df_train,
  method = "ranger",
  tuneGrid = hiperparametros,
  metric = "Accuracy",
  trControl = cross_val,
  num.trees = 500
)

• El mejor modelo:

• Resultados del modelo:

• Accuracy en testing (matriz de confusión):

Confusion Matrix and Statistics

    Predicho
Real  0  1
   0  8  7
   1  4 15
                                          
               Accuracy : 0.6765          
                 95% CI : (0.4947, 0.8261)
    No Information Rate : 0.6471          
    P-Value [Acc > NIR] : 0.4358          
                                          
                  Kappa : 0.3297          
                                          
 Mcnemar's Test P-Value : 0.5465          
                                          
            Sensitivity : 0.6818          
            Specificity : 0.6667          
         Pos Pred Value : 0.7895          
         Neg Pred Value : 0.5333          
             Prevalence : 0.6471          
         Detection Rate : 0.4412          
   Detection Prevalence : 0.5588          
      Balanced Accuracy : 0.6742          
                                          
       'Positive' Class : 1               
                                          

Support Vector Machine (SVM)

• Características:
  • Algoritmo propiamente de la escuela de inteligencia artificial.
  • El algoritmo se fundamenta en la búsqueda de un hiperplano en algún espacio o dimensión de características que separe “mejor” las clases.
  • El Maximal Margin Classifier está basado en el concepto de hiperplano.
  • El espacio de entrada es mapeado a una dimensión superior a través de una función kernel y es en el espacio de características trasnformadas que encuentra el hiperplano que dará como resultado la separación máxima de las clases.
  • La escalabilidad computacional suele ser compleja en grandes volúmenes de información.
  • Resultados satisfactorios se consiguen con tamaños muestrales pequeños.
  • Los hiperparámetros de la función ksvm()del paquete kernlab que implementa caret son los siguientes:
    • sigma: coeficiente del kernel radial.
    • C: penalización para margen de hiperplano.
  • Algunos casos de uso:
    • Aplicación de SVM en análisis genómico de cáncer (Huang et al., 2018).
    • Predicción de metástatis en cáncer de colon a través de SVM (Zhi et al., 2018).
    • Metaanálisis con SVM para datos ómicos (Kim et al., 2017).
    • Predicción de mastitis subclínica con SVM (Mammadova & Keskin, 2013).
    • Casos de uso de SVM en biología computacional (Ben-Hur et al., 2008).

# Paralelización del proceso
library(doMC)
library(parallel)
registerDoMC(cores = detectCores())
# Submuestras y repeticiones
particiones  <- 10
repeticiones <- 10
# Definiendo hiperparámetro k
hiperparametros <- expand.grid(sigma = c(0.001, 0.01, seq(0.1, 1, 0.1)),
                               C = seq(1, 1000, 20))
# Semillas
set.seed(123)
seeds <- vector(mode = "list", length = (particiones * repeticiones) + 1)
for (i in 1:(particiones * repeticiones)) {
  seeds[[i]] <- sample.int(1000, nrow(hiperparametros)) 
}
seeds[[(particiones * repeticiones) + 1]] <- sample.int(1000, 1)
# Control de entrenamiento
cross_val <- trainControl(
  method = "repeatedcv",
  number = particiones,
  repeats = repeticiones,
  returnResamp = "final",
  verboseIter = FALSE,
  allowParallel = TRUE,
  seeds = seeds
)
# Ajuste del modelo (entrenamiento)
set.seed(1000)
mod_svm <- train(
  Classification ~ .,
  data = df_train,
  method = "svmRadial",
  tuneGrid = hiperparametros,
  metric = "Accuracy",
  trControl = cross_val
)

• El mejor modelo:

• Resultados del modelo:

• Accuracy en testing (matriz de confusión):

Confusion Matrix and Statistics

    Predicho
Real  0  1
   0 10  5
   1  5 14
                                         
               Accuracy : 0.7059         
                 95% CI : (0.5252, 0.849)
    No Information Rate : 0.5588         
    P-Value [Acc > NIR] : 0.0582         
                                         
                  Kappa : 0.4035         
                                         
 Mcnemar's Test P-Value : 1.0000         
                                         
            Sensitivity : 0.7368         
            Specificity : 0.6667         
         Pos Pred Value : 0.7368         
         Neg Pred Value : 0.6667         
             Prevalence : 0.5588         
         Detection Rate : 0.4118         
   Detection Prevalence : 0.5588         
      Balanced Accuracy : 0.7018         
                                         
       'Positive' Class : 1              
                                         

Gradient Boosting

• Características:
  • Hacen parte de los algoritmos de ensemble.
  • Se fundamenta en la implementación de un conjunto de modelos sencillos (weak learners) con tasas de aprendizaje condicional por el modelo anterior, es decir, que emplea la información previa para aprender de sus errores.
  • La construcción del modelo se da de forma iterativa como lo hacen otros métodos de Boosting.
  • A diferencia de Bagging el método Gradient Boosting no usa bootstrapping.
  • Tres de los algoritmos de Boosting con mayor aceptación son AdaBoost, Gradient Boosting y Stochastic Gradient Boosting.
  • En R puede ser implementado a través de la función gbm() del paquete gmb. El algoritmo tiene 6 hiperparámetros a tener en cuenta:
    • n.trees: número de iteraciones del algoritmo. Es el número de modelos que conforma el ensemble.
    • iteration.depth: complejidad de los árboles empleados como weak learner.
    • shrinkage: tasa de aprendizaje (learning rate) que controla la influencia que tiene cada modelo individual sobre el conjunto de modelos (ensemble).
    • n.minobsinnode: número mínimo de observaciones que debe tener un nodo para poder ser dividido.
    • distribution: determina la función de coste (loss function).
      • Gaussian –> para regresión.
      • Bernoulli –> para respuestas binarias.
      • Multinomial –> para respuestas multiclase.
    • bag.fraction: submuestra del conjunto de entrenamiento utilizado para ajustar los weak learner. Si el valor es igual a \(1\) se emplea el algoritmo Gradient Boosting. Por defecto la función está con valor de 0.5, implementando el algoritmo Stochastic Gradient Boosting.
    • En general, la jerarquía en modelos basados en árboles se da de la siguiente manera: \(Boosting\ > Random\ Forest\ > Bagging\ > Árboles\ simples\).
    • Son uno de los algoritmos más potentes en cuanto a capacidad predicitiva.
  • Algunos casos de uso:
    • Analítica predicitiva en medicina con Gradient Boosting (Zhang et al., 2019).
    • Predicción de efectos secundarios en tratamiento para osteoartritis a través de modelos de Boosting (Liu et al., 2018).
    • Identificación de predictores moleculares de alta eficiencia alimenticia en cerdos en crecimiento (Messad et al., 2019).
    • Modelos de Boosting en análisis de streaming data para internet de las cosas (IoT) (Kenda et al., 2019).
    • Artículo guía de Gradient Boosting (Natekin & Knoll, 2013).

# Paralelización del proceso
library(doMC)
library(parallel)
registerDoMC(cores = detectCores())
# Submuestras y repeticiones
particiones  <- 10
repeticiones <- 10
# Definiendo hiperparámetro k
hiperparametros <- expand.grid(interaction.depth = c(1, 3, 5),
                               n.trees = seq(50, 1000, 100),
                               shrinkage = c(0.0001, 0.001, 0.01, 0.1, 1),
                               n.minobsinnode = c(2, 5, 10, 15))
# Semillas
set.seed(123)
seeds <- vector(mode = "list", length = (particiones * repeticiones) + 1)
for (i in 1:(particiones * repeticiones)) {
  seeds[[i]] <- sample.int(1000, nrow(hiperparametros)) 
}
seeds[[(particiones * repeticiones) + 1]] <- sample.int(1000, 1)
# Control de entrenamiento
cross_val <- trainControl(
  method = "repeatedcv",
  number = particiones,
  repeats = repeticiones,
  returnResamp = "final",
  verboseIter = FALSE,
  allowParallel = TRUE,
  seeds = seeds
)
# Ajuste del modelo (entrenamiento)
set.seed(1000)
mod_gbm <- train(
  Classification ~ .,
  data = df_train,
  method = "gbm",
  tuneGrid = hiperparametros,
  metric = "Accuracy",
  trControl = cross_val,
  distribution = "bernoulli",
  verbose = FALSE
)

• El mejor modelo:

• Resultados del modelo:

• Accuracy en testing (matriz de confusión):

Confusion Matrix and Statistics

    Predicho
Real  0  1
   0  5 10
   1  5 14
                                          
               Accuracy : 0.5588          
                 95% CI : (0.3789, 0.7281)
    No Information Rate : 0.7059          
    P-Value [Acc > NIR] : 0.9777          
                                          
                  Kappa : 0.0727          
                                          
 Mcnemar's Test P-Value : 0.3017          
                                          
            Sensitivity : 0.5833          
            Specificity : 0.5000          
         Pos Pred Value : 0.7368          
         Neg Pred Value : 0.3333          
             Prevalence : 0.7059          
         Detection Rate : 0.4118          
   Detection Prevalence : 0.5588          
      Balanced Accuracy : 0.5417          
                                          
       'Positive' Class : 1               
                                          

Deep Learning con keras

• Características:
  • Las redes neuronales existen hace mucho tiempo como un concepto de inteligencia artificial e incluso como un algoritmo de Machine Learning.
  • Hasta cierto punto pueden ser consideradas como métodos de regresión no lineal.
  • La arquitectura de red neuronal profunda (deep learning) hace parte de las redes neuronales artificiales.
    
  • Visualmente se observa como un conjunto de capas de entrada (inputs) y salida (outputs).
  • Se fundamenta en la asignación de un peso o ponderación a las entradas y con una función de activación (por ejemplo sigmoidea) se produce la siguiente capa de entradas. Este proceso se repite y el conjunto de entradas conforman lo que se conoce como capas ocultas (hidden layers).
  • El método común para entrenar redes neuronales es el de propagación hacia atrás (Backpropagation). El método de Backpropagation es iterativo, recursivo y eficiente para recalcular los pesos de las entradas de la red. La actualización de los pesos es obtenida al seguir un algoritmo de optimización basado en gradientes, como el descenso de gradiente.
  • Algunas de las arquitecturas de redes neuronales más conocidas en la actualidad se mencionan a continuación:
    • Perceptrón multicapa - MLP. Consta de múltiples capas, con cada capa conectada completamente a la siguiente. Puede distinguir datos que no son linealmente separables.
    • Redes Neuronales Recurrentes - RNN. Permite conexiones entre unidades que exhiben comportamientos temporales dinámicos. De amplio uso en processamiento de lenguaje (NLP - Natural Language Processing). Aquí un ejemplo cómico de uso de RNN.
    • Redes Neuronales Convolucionales - CNN. Las redes convolucionales son variaciones de perceptrones multicapa diseñados para usar cantidades mínimas de preprocesamiento. De amplio uso en análisis de imagen, video, NLP y sistemas de recomendación.
    • Funciones de activación:
      • Sigmoide.
      • Hiperbólicas.
      • Rectificador - ReLU. Es la más popular desde el año 2011 cuando se demostró que permite el mejor entrenamiento de redes neuronales.
      • Más funciones de activación.
    • Además de la función de activación para el entrenamiento de redes, es necesario declarar una función matemática para la capa de salida (outputs), para problemas binarios se usa la función Sigmoide, para tareas multinomiales se utiliza la función Softmax y para problemas de regresión se usa la función lineal (identidad).
    • Una red neuronal profunda posee los siguientes componentes fundamentales:
      • Nodos y capas: determinan la complejidad de la red. Las capas se consideran densas cuando están completamente conectados todos los nodos con capas sucesivas. Más capas y nodos agregados a la red, brindarán mayor oportunidad de extraer nueva información (características). La capa de entrada está constituida por las variables predictoras originales, además de esta capa también se encuentran capas ocultas y capa de salida. Las capas ocultas (hidden layers) pueden ser consideradas como hiperparámetros sobre los cuales no hay una dirección unificada de procesamiento; la cantidad de nodos que se incorporen en estas capas estará determinado por el número de atributos. Apelando al principio de parsimonia, lo ideal es encontrar un modelo de red simple y computacionalmente óptimo. La capa de salida está determinada por el tipo de variable respuesta, para problemas de regresión se predicen valores numéricos y para clasificación se predicen probabilidades para una etiqueta o clase específica.
      • Activación: elección de la función de activación para asignación de pesos o ponderaciones a los inputs.
    • Software para deep learning con R o Python:
      • mxnet
      • h2o
        • Página web h2o
      • tensorFlow en RStudio
      • keras
        • keras
        • keras en R
      • deepnet
      • PyTorch
      • Proyecto TensorFlow
    • Algunos casos de uso:
      • Redes neuronales convolucionales en identificación de objetivos en sistemas de defensa (d’Acremont et al., 2019).
      • Reconocimiento facial con CNN (Yang et al., 2018).
      • Detección de pupila rugosa con CNN a través de imágenes infrarojo (Won et al., 2019).
      • Método mejorado a través de deep learning para condición corporal en vacas lecheras (Huang et al., 2019).
      • CNN para identificación automática de patologías en plantas (Boulent et al., 2019).
      • Modelación de características del suelo a través de redes neuronales para irrigación automática (Adeyemi et al., 2018).
      • Predicción del rendimiento de cultivos con deep learning (Khaki & Wang, 2019).
      • Monitoreo de cultivos de pequeños productores a través de redes neuronales artificiales usando imágenes satelitales de alta resolución espacial (Xie et al., 2019).

Idea Intuitiva de Red Neuronal Profunda

Ajuste del modelo

# Modelo secuencial: load
mod_keras <- keras_model_sequential()
# Añadiendo capas: configuración del modelo
mod_keras %>% 
  layer_dense(units = 9, activation = "relu", input_shape = c(9)) %>% 
  layer_batch_normalization() %>% 
  layer_dropout(rate = 0.2) %>%
  layer_dense(units = 9, activation = "relu") %>% 
  layer_batch_normalization() %>% 
  layer_dense(units = 9, activation = "relu") %>% 
  layer_batch_normalization() %>% 
  layer_dense(units = 2, activation = "sigmoid")
# Compilando el modelo
mod_keras %>% 
  compile(loss = "binary_crossentropy",
          optimizer = optimizer_rmsprop(),
          metrics = "accuracy")
# Ajuste del modelo
mod_nnet <- mod_keras %>% 
  fit(x_train,
      y_train,
      epochs = 200,
      batch_size = 8,
      validation_split = 0.2,
      verbose = FALSE)

• Desempeño de la red neuronal:

• Accuracy en testing (matriz de confusión):

Confusion Matrix and Statistics

    Predicho
Real  0  1
   0 14  1
   1  8 11
                                          
               Accuracy : 0.7353          
                 95% CI : (0.5564, 0.8712)
    No Information Rate : 0.6471          
    P-Value [Acc > NIR] : 0.1859          
                                          
                  Kappa : 0.4883          
                                          
 Mcnemar's Test P-Value : 0.0455          
                                          
            Sensitivity : 0.9167          
            Specificity : 0.6364          
         Pos Pred Value : 0.5789          
         Neg Pred Value : 0.9333          
             Prevalence : 0.3529          
         Detection Rate : 0.3235          
   Detection Prevalence : 0.5588          
      Balanced Accuracy : 0.7765          
                                          
       'Positive' Class : 1               
                                          

5. Desempeño de modelos

• Tabla comparativa de modelos: resultados ordenanos de mayor a menor Accuracy en datos de prueba (test).

• Comparación de accuracy de modelos (gráfico):

• Comparación de de modelos (gráfico):

6. Referencias

1. Libro: Machine Learning - Michael Clark
2. Libro: useR! Machine Learning Tutorial
3. Libro: Hands-On Machine Learning with R
4. Libro: An Introduction to Statistical Learning
5. Libro: The Elements of Statistical Learning
6. Recurso web: R Markdown Notebooks for “Deep Learning with R”
7. Recurso web: A visual introduction to machine learning.
8. Curso Youtube: Robert Tibshirani & Trevor Hastie - Statistical Learning