Análisis de comportamiento en redes sociales usando Procesamiento del Lenguaje Natural

Capítulo 6: Aprendizaje supervisado, problemas de clasificación con NLP

PARTE 2

1. Framework MLR3

1.1. Introducción

Acorde a Becker y otros (2021), el paquete mlr3 provee un marco de trabajo genérico para varias tareas de aprendizaje automático, inluyendo problemas de clasificación, regresión, análisis de supervivencia y otro tipo de modelos para el lenguaje R. Contrario a librerías de python como scikit-learn, lo que hace este paquete es proveer una interfaz unificada para el entrenamiento, selección de variables, optimización de hiperparámetros y evaluación de modelos de aprendizaje automático que podemos encontrar en varias librerías de R. Para muchos de estos casos, la paralelización de procesos viene nativamente soportada.

Si bien mlr3 provee la funcionalidad base del framework, existen librerías que extienden los procesos disponibles, mejorando la creación de flujos de trabajo (pipelines), preprocesamiento, visualización, etc. Estos se pueden observar a continuación:

Finalmente, los creadores de esta librería mencionan que se siguen varios principios de diseño enlistados a continuación, con la finalidad de mantener uniformidad en el análisis de aprendizaje automático realizado con esta librería.

• Se prioriza el backend sobre el frontend. Es decir que la gran mayoría de paquetes del ecosistema mlr3 se enfocan en el procesamiento y transformación de datos, estimación de modelos y comparación de resultados, por lo que su objetivo no es ofrecer una interfaz de usuario gráfica, apoyándose para ello de otras librerías como ggplot2.

• Se utilizan objetos del tipo R6 con la finalidad de lograr un diseño limpio, orientado a objetos, cambiado su estado con cada ejecución que se realice. Los objetos R6 son internamente tratados como ambientes o environments.

• Dado que librería se enfoca en el aprendizaje automático sobre datos coleccionados en memoria (y no en entornos distribuidos), utiliza la librería data.table para realizar la manipulación de datos de manera rápida y eficiente.

• Unifica los objetos que se objetan como resultado en objetos data.tables, permitiendo operaciones rápidas de selección y agregación.

• Utiliza programación defensiva y segura ante errores de tipeo, evitando simplificaciones dentro del código.

• Es ligero en dependencias.

Una vez que hemos interiorizado estas definiciones, podemos comenzar el análisis de clasificación de noticias falsas en la siguiente subsección.

1.2. Proceso de modelamiento en MLR3

Con el uso de la librería mlr3, a continuación se indica el proceso general de modelamiento utilizado.

En esencia, la librería mlr3 encapsula a los datos de análisis en tasks o tareas. En cada tarea, divide a los datos en conjuntos de datos de entrenamiento y prueba. Dado que el objetivo del aprendizaje automático es construir un modelo que pueda ser extrapolado a nuevos conjuntos de datos, se utilizan los datos de entrenamiento para la estimación de algoritmos, mientras que los datos de prueba se utilizan para evaluar el desempeño de los modelos.

Una vez divididos los datos dentro de la tarea, se entregan los datos de entrenamiento a un learner, el cual es un algoritmo de aprendizaje automático. Este learner construye el modelo y puede ser usado para predecir o para evaluarse a través de distintas métricas.

Adicionalmente podemos aumentar etapas de preprocesamiento entre la etapa de división de los datos y entrenamiento del modelo, o aplicar técnicas de remuestreo para que nuestros modelos sean más robustos.

Sin más preámbulo, manos a la obra, y para ello, cargaremos la librería y los datos que hemos procesado anteriormente.

# Carga de librerías
library(mlr3)
library(mlr3viz)
library(mlr3pipelines)
library(mlr3verse)
library(mlr3tuning)
library(tidyverse)
library(ggpubr)
library(rpart.plot)

# Carga de datos
fake_news_model_df = readRDS("Caso3_NoticiasFalsas/fake_news_model_df.RDS")

2. Modelo de clasificación de noticias falsas

2.1. Definición de una tarea

Para comenzar el análisis, definamos una tarea que pueda ser ejecutada por el framework *mlr3*, eliminando las variables identificadores y de texto que no usaremos para predecir.

# Conversión de variable dependiente a factor y remoción de variables
fake_news_task_df = fake_news_model_df %>% 
  mutate(target_falsa = factor(target_falsa,levels=c(0,1),
                               labels=c("Verídica","Falsa"))) %>% 
  select(-status_id, -screen_name, -text)

# Creación de la tarea
task_fake_news = TaskClassif$new(id = "fake_news", 
                                 backend = fake_news_task_df, 
                                 target = "target_falsa")
print(task_fake_news)

<TaskClassif:fake_news> (13892 x 33)
* Target: target_falsa
* Properties: twoclass
* Features (32):
  - int (21): n_hashtags, n_palabras, n_palabras_ADJ, n_palabras_ADV, n_palabras_DET,
    n_palabras_NOUN, n_palabras_PRON, n_palabras_PROPN, n_palabras_PUNCT,
    n_palabras_VERB, n_palabras_unicas, n_palabras_unicas_ADJ, n_palabras_unicas_ADV,
    n_palabras_unicas_DET, n_palabras_unicas_NOUN, n_palabras_unicas_PRON,
    n_palabras_unicas_PROPN, n_palabras_unicas_PUNCT, n_palabras_unicas_VERB,
    n_signos_admiracion, n_signos_interrogacion
  - dbl (10): anger, anticipation, disgust, fear, joy, negative, positive, sadness,
    surprise, trust
  - fct (1): hora_publicacion

Una vez creada la tarea, podremos llamar a los datos que se incluyen en esta, y otros atributos, como se muestra a continuación.

# Datos
task_fake_news$data()

# Clases en la variable objetivo
task_fake_news$class_names

[1] "Verídica" "Falsa"   

# Variables explicativas
task_fake_news$feature_names

 [1] "anger"                   "anticipation"            "disgust"                
 [4] "fear"                    "hora_publicacion"        "joy"                    
 [7] "n_hashtags"              "n_palabras"              "n_palabras_ADJ"         
[10] "n_palabras_ADV"          "n_palabras_DET"          "n_palabras_NOUN"        
[13] "n_palabras_PRON"         "n_palabras_PROPN"        "n_palabras_PUNCT"       
[16] "n_palabras_VERB"         "n_palabras_unicas"       "n_palabras_unicas_ADJ"  
[19] "n_palabras_unicas_ADV"   "n_palabras_unicas_DET"   "n_palabras_unicas_NOUN" 
[22] "n_palabras_unicas_PRON"  "n_palabras_unicas_PROPN" "n_palabras_unicas_PUNCT"
[25] "n_palabras_unicas_VERB"  "n_signos_admiracion"     "n_signos_interrogacion" 
[28] "negative"                "positive"                "sadness"                
[31] "surprise"                "trust"                  

Así también, gracias a la extensión mlr3viz podemos realizar varios tipos de visualizaciones para la tarea definida.

# Gráfico de la variable target
autoplot(task_fake_news)

2.2. Learners

Una vez que la tarea ha sido definida, deberemos definir el algoritmo que vamos a usar. Para ello, existe en la página ml3learners una lista de los algoritmos que podemos utilizar, entre los cuales podemos encontrar (para llevar a cabo tareas de clasificación):

ID	Algoritmo	Librería
classif.cv_glmnet	Regresión logística penalizada	glmnet
classif.glmnet	Regresión logística penalizada	glmnet
classif.kknn	k-vecinos más cercanos	kknn
classif.lda	Análisis discriminante lineal	MASS
classif.log_reg	Regresión logística	stats
classif.multinom	Modelo multinomial lineal logarítimico	nnet
classif.naive_bayes	Naive Bayes	e1071
classif.nnet	Redes neuronales de una sola neurona	nnet
classif.qda	Análisis discrimante cuadrático	MASS
classif.ranger	Bosques aleatorios	ranger
classif.svm	Máquinas de soporte vectorial	e1071
classif.xgboost	Gradient Boosting	xgboost

Cualquier de estos algoritmos será estimado en los datos de entrenamiento, es decir sobre un subconjunto de los datos analizados, para ser evaluado en los datos de prueba (o datos fuera de la muestra de entrenamiento), como se muestra en la siguiente imagen.

A través de las siguientes líneas de código también podemos observar los algoritmos existentes y sus hiperparámetros. Cabe notar que los hiperparámetros de un modelo son los valores de las configuraciones utilizadas por el algoritmo durante el proceso de entrenamiento, permitiendo su afinación. Específicamente, estos son valores que generalmente no se obtienen de los datos, por lo que tienen que ser especificados, y su valor óptimo tendrá que ser encontrado a través de métodos de pruba y error, uso de reglas o métodos de optimización de hiperparámetros, los cuales visitaremos más adelante.

# Lista de algoritmos de clasificación
classif_learners = mlr_learners$keys()[startsWith(mlr_learners$keys(),"classif")]
classif_learners

 [1] "classif.cv_glmnet"   "classif.debug"       "classif.featureless" "classif.glmnet"     
 [5] "classif.kknn"        "classif.lda"         "classif.log_reg"     "classif.multinom"   
 [9] "classif.naive_bayes" "classif.nnet"        "classif.qda"         "classif.ranger"     
[13] "classif.rpart"       "classif.svm"         "classif.xgboost"    

# Hiperparámetros
lrn("classif.rpart")$param_set$ids()

 [1] "minsplit"       "minbucket"      "cp"             "maxcompete"     "maxsurrogate"  
 [6] "maxdepth"       "usesurrogate"   "surrogatestyle" "xval"           "keep_model"    

2.3. Entrenamiento de un modelo

Ahora que conocemos cómo definir una tarea y un algoritmo, vamos a entrenar un modelo. Para ello, dividimos primero el conjunto de datos original en dos subconjuntos: entrenamiento y validación. Por lo general se suele tomar el 70% de los datos como muestra de entrenamiento, aunque este criterio dependerá de la situación y el analista.

# Definición de entrenamiento y validación
train_set = sample(task_fake_news$nrow, 0.7 * task_fake_news$nrow)
test_set = setdiff(seq_len(task_fake_news$nrow), train_set)
cat("Dimensión en entrenamiento:",length(train_set),"\n")

Dimensión en entrenamiento: 9724 

cat("Dimensión en testing:",length(test_set),"\n")

Dimensión en testing: 4168 

Una vez divididos los datos, inicializamos y entrenamos el modelo (en este caso, un árbol de decisión) con los parámetros por defecto del algoritmo utilizado.

# Inicialización de learner
example_learner = lrn("classif.rpart")
example_learner$predict_type = "prob"

# Entrenamiento 
example_learner$train(task_fake_news, row_ids = train_set)

# Resultados del modelo
rpart.plot(example_learner$model)

Cannot retrieve the data used to build the model (so cannot determine roundint and is.binary for the variables).
To silence this warning:
    Call rpart.plot with roundint=FALSE,
    or rebuild the rpart model with model=TRUE.

Luego de haber estimado el modelo en los datos de entrenamiento, podemos pasar a realizar las predicciones en el conjunto de datos de test y evaluar allí su rendimiento.

2.4. Predicción

Para realizar la predicción no hace falta nada más que una línea de código.

# Predicción
prediction_lr = example_learner$predict(task_fake_news, row_ids = test_set)
print(prediction_lr)

<PredictionClassif> for 4168 observations:

Una vez que estas predicciones han sido hechas, revisemos su distribución con respecto al valor real de la variable objetivo.

# Gráfico de la predicción
autoplot(prediction_lr)

En este caso, el modelo parece tener un buen desempeño, dado que tiene predicciones bastante similares a la de los datos reales.

2.5. Evaluación del desempeño

Para evaluar el desempeño de la clasificación binaria existen varias medidas, de las cuales, la gran mayoría se obtiene de la matriz de confusión. La lógica de esta matriz se puede visualizar a continuación.

Básicamente, en la matriz de confusión se comparan los valores verdaderos de la variable objetivo contra los valores predichos por el modelo en una tabla de doble entrada. A partir de esta matriz se pueden obtener todas las medidas especificadas anteriormente.

La matriz de confusión, así como sus indicadores, se pueden obtener a través del siguiente código.

# Matriz de confusión
prediction_lr$confusion

          truth
response   Verídica Falsa
  Verídica     2705   677
  Falsa         129   657

# Medidas de desempeño
example_measure = list(msr("classif.acc", id = "accuracy"),
                  msr("classif.auc", id = "auc"),
                  msr("classif.precision", id = "precision"),
                  msr("classif.recall", id = "recall"),
                  msr("classif.sensitivity", id = "sensitivity"),
                  msr("classif.specificity", id = "specificity"),
                  msr("classif.tn", id="true negative"),
                  msr("classif.tp", id="true positive"),
                  msr("classif.fn", id="false negative"),
                  msr("classif.fp", id="false positive"))
sapply(example_measure, function(x)prediction_lr$score(x))

      accuracy            auc      precision         recall    sensitivity    specificity 
     0.8066219      0.7885180      0.7998226      0.9544813      0.9544813      0.4925037 
 true negative  true positive false negative false positive 
   657.0000000   2705.0000000    129.0000000    677.0000000 

Adicional a estos indicadores, es posible graficar la curva ROC (Receiver Operating Characteristics) y calcular el área bajo ella (AUC). La ROC es la representación de la razón o proporción de verdaderos positivos frente a la razón o proporción de falsos positivos, según se varía el umbral de discriminación (valor a partir del cual decidimos que un caso es un positivo, es decir, que una noticia es falsa o no). Por su parte, el AUC puede resumir cómo funciona un modelo clasificador en una sola medida. Conforme más se acerque a 1, mejor será su poder de clasificación, mientras que, conforme se acerca a 0.5, su poder de clasificación será más similar al de un clasificador aleatorio.

# Curvas
autoplot(prediction_lr, type = "roc")

En este caso nuestro modelo alcanza un nivel razonable de ROC, pero podría hacerlo mejor y para ello veremos cómo nos ayuda la optimización de hiperparámetros.

2.6. Optimización de hiperparámetros

Pese a que los hiperparámetros de un modelo no son observados a primera vista durante la inicialización del modelo (en el ejercicio que acabamos de hacer no editamos ningún hiperparámetro), estos juega un rol crucial en el desempeño del algoritmo. Normalmente estos se suelen fijar al iniciar el entrenamiento, pero es posible seleccionar sus valores a través del entrenamiento de varios modelos que nos permitan comprobar el efecto que estos tienen sobre el desempeño del modelo. Para ello se ejecuta un procedimiento conocido como optimización o afinación de hiperparámetros. Este proceso se puede ver de manera gráfica a continuación.

Básicamente lo que hacemos es entrenar varios modelos para un conjunto de hiperparámetros definidos con anterioridad, para luego compararlos y escoger así sus valores ‘’óptimos’’. A continuación resolveremos el problema entre manos a través del uso de un algoritmo de árboles de clasificación, optimizando dos de sus hiperparámetros: el parámetro de complejidad (cp) y el número de observaciones mínimas exigidas en cada nodo (minsplit). Esto lo logramos a través del siguiente código.

# Inicialización del learner
optimizing_learner = lrn("classif.rpart")

# Definición del espacio de búsqueda
search_space = ps(cp = p_dbl(lower = 0.001, upper = 0.1),
                  minsplit = p_int(lower = 20, upper = 100))
search_space

<ParamSet>

Para ejecutar la afinación deberemos definir previamente tres parámetros:

• El método de remuestro, es decir, ¿seguiremos usando una sola división de entrenamiento y validación o lo haremos sobre varias muestras distintas tomadas aleatoriamente de los datos (validación cruzada)?
• Una medida de evaluación de desempeño, la cual definirá el mejor modelo.
• Un criterio de finalización, es decir, ¿detendremos la optimización después de un periodo de tiempo (dado que algunos algoritmos podrían tomar mucho en ejecutarse)? o ¿la detendremos cuando el modelo ya no se pueda mejorar?

Estos criterios se definen como se muestra a continuación.

# Método de evaluación
resamp_method = rsmp("holdout", ratio = 0.7)
measure_method = msr("classif.acc")

# Criterio de finalización
ending_method = trm("stagnation")

Una vez que tenemos estos parámetros definidos, crearemos la instancia de afinación con el siguiente código.

# Instancia de optimización
instance = TuningInstanceSingleCrit$new(task = task_fake_news,
                                        learner = optimizing_learner,
                                        resampling = resamp_method,
                                        measure = measure_method,
                                        search_space = search_space,
                                        terminator = ending_method)
instance

<TuningInstanceSingleCrit>
* State:  Not optimized
* Objective: <ObjectiveTuning:classif.rpart_on_fake_news>
* Search Space:
<ParamSet>

* Terminator: <TerminatorStagnation>
* Terminated: FALSE
* Archive:
<ArchiveTuning>

Finalmente realizaremos el entrenamiento a través de uno de los siguientes métodos existentes dentro de la librería mlr3:

• Búsqueda cartesiana (se estima un modelo para cada combinación posible de los hiperparámetros especificados)
• Búsqueda aleatoria (se estima un modelo para cada combinación posible de los hiperparámetros tomados de una distribución de probabilidad especificada)
• Optimización no lineal (se optimizan los parámetros a través de la búsqueda de un óptimo global o local)

En este caso, lo haremos a través de búsqueda aleatoria.

# Método de búsqueda
tuner = tnr("random_search")

# Optimización
tuner$optimize(instance)

INFO  [14:56:18.276] [bbotk] Starting to optimize 2 parameter(s) with '<OptimizerRandomSearch>' and '<TerminatorStagnation> [iters=10, threshold=0]' 
INFO  [14:56:18.305] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:18.339] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:18.358] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:18.499] [mlr3]  Finished benchmark 
INFO  [14:56:18.602] [bbotk] Result of batch 1: 

INFO  [14:56:18.636] [bbotk]  
INFO  [14:56:18.661] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:18.700] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:18.726] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:18.856] [mlr3]  Finished benchmark 
INFO  [14:56:18.952] [bbotk] Result of batch 2: 

INFO  [14:56:18.986] [bbotk]  
INFO  [14:56:19.012] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:19.058] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:19.087] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:19.228] [mlr3]  Finished benchmark 
INFO  [14:56:19.341] [bbotk] Result of batch 3: 

INFO  [14:56:19.373] [bbotk]  
INFO  [14:56:19.397] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:19.443] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:19.469] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:19.640] [mlr3]  Finished benchmark 
INFO  [14:56:19.738] [bbotk] Result of batch 4: 

INFO  [14:56:19.772] [bbotk]  
INFO  [14:56:19.810] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:19.871] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:19.909] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:20.292] [mlr3]  Finished benchmark 
INFO  [14:56:20.385] [bbotk] Result of batch 5: 

INFO  [14:56:20.456] [bbotk]  
INFO  [14:56:20.486] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:20.553] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:20.577] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:20.769] [mlr3]  Finished benchmark 
INFO  [14:56:20.962] [bbotk] Result of batch 6: 

INFO  [14:56:20.996] [bbotk]  
INFO  [14:56:21.021] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:21.073] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:21.099] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:21.244] [mlr3]  Finished benchmark 
INFO  [14:56:21.355] [bbotk] Result of batch 7: 

INFO  [14:56:21.389] [bbotk]  
INFO  [14:56:21.409] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:21.467] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:21.491] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:21.681] [mlr3]  Finished benchmark 
INFO  [14:56:21.800] [bbotk] Result of batch 8: 

INFO  [14:56:21.834] [bbotk]  
INFO  [14:56:21.863] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:21.909] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:21.938] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:22.096] [mlr3]  Finished benchmark 
INFO  [14:56:22.188] [bbotk] Result of batch 9: 

INFO  [14:56:22.224] [bbotk]  
INFO  [14:56:22.248] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:22.307] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:22.336] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:22.506] [mlr3]  Finished benchmark 
INFO  [14:56:22.618] [bbotk] Result of batch 10: 

INFO  [14:56:22.653] [bbotk]  
INFO  [14:56:22.674] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:22.721] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:22.749] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:22.893] [mlr3]  Finished benchmark 
INFO  [14:56:22.987] [bbotk] Result of batch 11: 

INFO  [14:56:23.018] [bbotk]  
INFO  [14:56:23.038] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:23.089] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:23.117] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:23.250] [mlr3]  Finished benchmark 
INFO  [14:56:23.340] [bbotk] Result of batch 12: 

INFO  [14:56:23.377] [bbotk]  
INFO  [14:56:23.399] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:23.467] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:23.504] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:23.692] [mlr3]  Finished benchmark 
INFO  [14:56:23.802] [bbotk] Result of batch 13: 

INFO  [14:56:23.842] [bbotk]  
INFO  [14:56:23.865] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:23.912] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:23.942] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:24.075] [mlr3]  Finished benchmark 
INFO  [14:56:24.183] [bbotk] Result of batch 14: 

INFO  [14:56:24.217] [bbotk]  
INFO  [14:56:24.242] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:24.293] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:24.319] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:24.483] [mlr3]  Finished benchmark 
INFO  [14:56:24.573] [bbotk] Result of batch 15: 

INFO  [14:56:24.612] [bbotk]  
INFO  [14:56:24.634] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:24.682] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:24.716] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:24.919] [mlr3]  Finished benchmark 
INFO  [14:56:25.018] [bbotk] Result of batch 16: 

INFO  [14:56:25.055] [bbotk]  
INFO  [14:56:25.078] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:25.123] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:25.149] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:25.286] [mlr3]  Finished benchmark 
INFO  [14:56:25.400] [bbotk] Result of batch 17: 

INFO  [14:56:25.433] [bbotk]  
INFO  [14:56:25.459] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:25.506] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:25.535] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:25.670] [mlr3]  Finished benchmark 
INFO  [14:56:25.767] [bbotk] Result of batch 18: 

INFO  [14:56:25.808] [bbotk]  
INFO  [14:56:25.833] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:25.882] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:25.914] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:26.063] [mlr3]  Finished benchmark 
INFO  [14:56:26.168] [bbotk] Result of batch 19: 

INFO  [14:56:26.202] [bbotk]  
INFO  [14:56:26.223] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:26.284] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:26.310] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:26.459] [mlr3]  Finished benchmark 
INFO  [14:56:26.581] [bbotk] Result of batch 20: 

INFO  [14:56:26.617] [bbotk]  
INFO  [14:56:26.645] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:26.697] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:26.725] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:26.914] [mlr3]  Finished benchmark 
INFO  [14:56:27.037] [bbotk] Result of batch 21: 

INFO  [14:56:27.089] [bbotk]  
INFO  [14:56:27.107] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:27.146] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:27.170] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:27.350] [mlr3]  Finished benchmark 
INFO  [14:56:27.451] [bbotk] Result of batch 22: 

INFO  [14:56:27.483] [bbotk]  
INFO  [14:56:27.507] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:27.556] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:27.583] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:27.730] [mlr3]  Finished benchmark 
INFO  [14:56:27.846] [bbotk] Result of batch 23: 

INFO  [14:56:27.879] [bbotk]  
INFO  [14:56:27.902] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:27.957] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:27.990] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:28.141] [mlr3]  Finished benchmark 
INFO  [14:56:28.239] [bbotk] Result of batch 24: 

INFO  [14:56:28.273] [bbotk]  
INFO  [14:56:28.299] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:28.350] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:28.376] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:28.533] [mlr3]  Finished benchmark 
INFO  [14:56:28.631] [bbotk] Result of batch 25: 

INFO  [14:56:28.668] [bbotk]  
INFO  [14:56:28.694] [bbotk] Evaluating 1 configuration(s) 
INFO  [14:56:28.741] [mlr3]  Running benchmark with 1 resampling iterations 
INFO  [14:56:28.769] [mlr3]  Applying learner 'classif.rpart' on task 'fake_news' (iter 1/1) 
INFO  [14:56:28.899] [mlr3]  Finished benchmark 
INFO  [14:56:29.008] [bbotk] Result of batch 26: 

INFO  [14:56:29.047] [bbotk]  
INFO  [14:56:29.085] [bbotk] Finished optimizing after 26 evaluation(s) 
INFO  [14:56:29.099] [bbotk] Result: 

INFO  [14:56:29.130] [bbotk]  

Una vez estimado la afinación, podremos ver sus resultados óptimos con el código que sigue.

# Resultado de la optimización
instance$result

Con tales resultados, realizamos la reestimación del modelo y observamos sus resultados.

# Inicialización de learner
final_learner = lrn("classif.rpart", cp = instance$result$cp, minsplit = instance$result$minsplit)
final_learner$predict_type = "prob"

# Entrenamiento 
final_learner$train(task_fake_news, row_ids = train_set)

# Resultados del modelo
rpart.plot(final_learner$model)

Cannot retrieve the data used to build the model (so cannot determine roundint and is.binary for the variables).
To silence this warning:
    Call rpart.plot with roundint=FALSE,
    or rebuild the rpart model with model=TRUE.

A la par, evaluamos su desempeño:

# Predicción
prediction_fn = final_learner$predict(task_fake_news, row_ids = test_set)
final_measure = list(msr("classif.acc", id = "accuracy"),
                  msr("classif.auc", id = "auc"),
                  msr("classif.precision", id = "precision"),
                  msr("classif.recall", id = "recall"),
                  msr("classif.sensitivity", id = "sensitivity"),
                  msr("classif.specificity", id = "specificity"),
                  msr("classif.tn", id="true negative"),
                  msr("classif.tp", id="true positive"),
                  msr("classif.fn", id="false negative"),
                  msr("classif.fp", id="false positive"))
sapply(final_measure, function(x)prediction_fn$score(x))

      accuracy            auc      precision         recall    sensitivity    specificity 
     0.8277351      0.8608496      0.8412903      0.9202541      0.9202541      0.6311844 
 true negative  true positive false negative false positive 
   842.0000000   2608.0000000    226.0000000    492.0000000 

Con esta optimización hemos mejorado nuestro modelo. Y en este punto quizás sea prudente comparar una gama más extensa de opciones, pero tal tarea quedará para otro capítulo.

3. Bibliografía

Becker, M. y otros (2021), mlr3 book.