Clase 10 - Clasificación
Andrés Acero
01/09/2021
Problemas de clasificación
¿Qué es clasificación?
Junto con la regresión, la clasificación es una técnica de modelado importante en el conjunto de herramientas de ciencia de datos. Ajustamos un modelo de clasificación para clasificar puntos de datos en múltiples categorías o clases en lugar de predecir un valor numérico como hicimos en la regresión. En este caso, también nos referimos a la variable de destino como etiqueta de clase. La clasificación binaria es un tipo especial de clasificación con la etiqueta de clase tomando dos valores (como vimos con la regresión logística). Los modelos de clasificación con variables objetivo que toman más de dos valores se denominan clasificación multiclase.
La clasificación también es uno de los problemas centrales del aprendizaje automático. Es muy utilizado en la práctica; La clasificación encuentra aplicación en problemas como el filtrado de spam, la publicidad computacional, el reconocimiento de voz y escritura a mano y la autenticación biométrica, por nombrar algunos.
La clasificación usa observaciones cuyo estado se sabe para derivar predictores y luego aplica esos predictores a nuevas observaciones. Cuando se trabaja con un solo conjunto de datos, normalmente se divide en un conjunto de entrenamiento que se usa para desarrollar el modelo de clasificación y un conjunto de prueba que se usa para determinar el rendimiento. Es fundamental no evaluar el rendimiento sobre las mismas observaciones que se utilizaron para desarrollar el modelo.
Un proyecto de clasificación generalmente incluye los siguientes pasos como mínimo:
Se recopila un conjunto de datos en el que se conoce o asigna la pertenencia al grupo para cada observación (por ejemplo, asignada por observación del comportamiento, calificación de expertos o procedimientos de agrupación).
El conjunto de datos se divide en un conjunto de entrenamiento y un conjunto de prueba. Un patrón común es seleccionar del 50 al 80% de las observaciones para el conjunto de entrenamiento (el 80% parece ser particularmente común) y asignar las observaciones restantes al conjunto de prueba.
Se crea un modelo de predicción para predecir la pertenencia a los datos de entrenamiento de la mejor manera posible.
A continuación, se evalúa el rendimiento del modelo resultante utilizando los datos de prueba. El desempeño se evalúa para ver que excede el azar (tasa base). Además, se podría evaluar si el método funciona mejor que un modelo alternativo razonable (y más simple o mejor conocido)
Hay muchos enfoques para la clasificación; En estas clases veremos algunos de los más utilizados. Cada modelo de clasificación tiene una intuición diferente detrás. Es importante conocer esta intuición a la hora de elegir el clasificador adecuado para nuestros datos. Veremos cómo funciona internamente cada modelo de clasificación para obtener esta comprensión. Pero antes de empezar con los modelos cargaremos el conjunto de datos:
data1 <- read.csv("Clase 10.csv")
data1$label <- as.factor(data1$label)Como podrán notar, usaremos una base de datos nueva. Esta base de datos es bastante sencilla de entender, ya que nos da una categoría ID que implica si debo o no otorgar una tarjeta de crédito a una persona dependiendo de 11 características anónimas (dados problemas con el banco de origen de los datos). Nuestro objetivo será realizar una predicción utilizando estos features. Para obtener los datos el link es el siguiente: https://www.dropbox.com/s/zpvzq4yapfc2g6j/Clase%2010.csv?dl=0.
Clasificadores Bayesianos
El aprendizaje probabilístico se define como el tipo de aprendizaje supervisado que calcula la probabilidad de una categoría dada un elemento, llamado a posteriori, utilizando la ley de Bayes. La probabilidad de un ejemplo individual dada una categoría, llamada probabilidad, se calcula directamente a partir de los ejemplos de entrenamiento. El a posteriori se calcula aplicando la ley de Bayes a la probabilidad en principio, pero en realidad estamos interesados no solo en su valor sino también en su comparación con los demás. Si se supone que las probabilidades de las categorías, llamadas a priori, son idénticas, la categoría se decide directamente a partir de las probabilidades.
Como se indicó anteriormente, los clasificadores bayesianos aplica el conocido teorema de Bayes para la probabilidad condicional. En la forma más simple para los eventos A y B, el teorema de Bayes relaciona dos probabilidades condicionales de la siguiente manera:
\[\begin{equation} P(A\cap B)=P(A, B)=P(A)P(B|A)=P(B)P(A|B) \implies P(B|A)=\frac{P(B)P(A|B)}{P(A)} \end{equation}\]
Utilizando esta fórmula y diferentes variaciones lograremos generar el primer grupo de modelos, los clasificadores Naive Bayes.
Naïve Bayes
Un método de clasificación simple pero poderoso es el clasificador Naive Bayes (NB). Naive Bayes usa datos de entrenamiento para conocer la probabilidad de pertenencia a una clase como una función de cada variable de predicción considerada de forma independiente (por lo tanto, “ingenua”). Cuando se aplica a nuevos datos, la pertenencia a la clase se asigna a la categoría que se considera más probable de acuerdo con las probabilidades conjuntas asignadas por la combinación de predictores.
El clasificador Naive Bayes es simple (tanto intuitivo como computacionalmente), rápido, funciona bien con pequeñas cantidades de datos de entrenamiento y escala bien a grandes conjuntos de datos. La mayor debilidad del clasificador ingenuo de Bayes es que se basa en una suposición a menudo errónea de características igualmente importantes e independientes que resulta en probabilidades posteriores sesgadas. Aunque esta suposición rara vez se cumple, en la práctica, este algoritmo funciona sorprendentemente bien. Esto se debe principalmente a que lo que generalmente se necesita no es una propensión (probabilidad posterior exacta) para cada registro que sea precisa en términos absolutos, sino simplemente un orden de rango razonablemente preciso de las propensiones.
Una de las primeras aplicaciones importantes de NB fue el filtrado de spam. En esta configuración, los documentos de texto, como los correos electrónicos, se tratan como un punto de datos x con una bolsa de palabras que forman las características x1,. . . , xd. Las etiquetas de clase vienen dadas por si un documento está marcado como spam o no. Identificar las probabilidades condicionales de la clase es simplemente identificar la distribución de documentos no deseados frente a correo no deseado para cada palabra.
Naive Bayes con e1071
Para este primer modelo usaremos el paquete 1071, desarrollado por la Universidad Tecnológico de Viena:
library(e1071)Ahora, el primer supuesto que nos interesa es asegurar que los datos son independientes entre ellos, para lo que haremos un estudio de correlación sobre las variables predictoras:
data1<- na.omit(data1)
cor(cbind(data1[,3:13]))## fea_1 fea_2 fea_3 fea_4 fea_5
## fea_1 1.00000000 -0.012045822 -0.01430317 -0.12307845 -0.030584142
## fea_2 -0.01204582 1.000000000 -0.24688339 0.28445464 0.003514876
## fea_3 -0.01430317 -0.246883394 1.00000000 -0.14457054 -0.019073890
## fea_4 -0.12307845 0.284454638 -0.14457054 1.00000000 0.041717630
## fea_5 -0.03058414 0.003514876 -0.01907389 0.04171763 1.000000000
## fea_6 0.33253451 0.001175765 0.15327653 -0.15325144 0.049818098
## fea_7 -0.03500292 0.003682197 0.29629752 -0.02552226 -0.019312859
## fea_8 0.06246076 -0.022590718 0.03265681 -0.07867048 0.011716120
## fea_9 -0.05802757 0.097180131 0.13233091 0.09976956 -0.016058577
## fea_10 0.08053404 -0.029273205 -0.14924445 0.06720694 0.105359354
## fea_11 0.10355536 0.059463549 0.07439651 0.05898096 -0.105898901
## fea_6 fea_7 fea_8 fea_9 fea_10
## fea_1 0.332534507 -0.035002921 0.06246076 -0.05802757 0.08053404
## fea_2 0.001175765 0.003682197 -0.02259072 0.09718013 -0.02927320
## fea_3 0.153276531 0.296297523 0.03265681 0.13233091 -0.14924445
## fea_4 -0.153251440 -0.025522261 -0.07867048 0.09976956 0.06720694
## fea_5 0.049818098 -0.019312859 0.01171612 -0.01605858 0.10535935
## fea_6 1.000000000 -0.003579518 0.02656020 0.06962333 0.18633712
## fea_7 -0.003579518 1.000000000 0.09112659 -0.04855519 -0.23555502
## fea_8 0.026560196 0.091126587 1.00000000 -0.09142829 0.09018108
## fea_9 0.069623334 -0.048555192 -0.09142829 1.00000000 -0.05166040
## fea_10 0.186337116 -0.235555023 0.09018108 -0.05166040 1.00000000
## fea_11 0.146345846 0.008728923 0.12863100 -0.04376033 0.28419641
## fea_11
## fea_1 0.103555358
## fea_2 0.059463549
## fea_3 0.074396505
## fea_4 0.058980957
## fea_5 -0.105898901
## fea_6 0.146345846
## fea_7 0.008728923
## fea_8 0.128631003
## fea_9 -0.043760328
## fea_10 0.284196408
## fea_11 1.000000000No parece que exista una correlación particularmente alta, lo que no viola este primer supuesto. Si existieran problemas podríamos usar el análisis de componentes principales para resolverlo. Ahora, debemos revisar si las variables son buenas predictoras. Para realizaremos algunas gráficas para revisar su comportamiento, así como el comportamiento de label:
library(ggplot2)
ggplot(data1, aes(x=label, y=fea_2)) + geom_boxplot() + theme_light()
ggplot(data1, aes(x=label, y=fea_4)) + geom_boxplot() + theme_light()
ggplot(data1, aes(x=label, y=fea_10)) + geom_boxplot() + theme_light()
table(data1$label)##
## 0 1
## 788 188Parece ser que las variables que mejor nos ayudan son las que se presentan (2, 4 y 10), aunque todas las variables entrarán al modelo. La muestra de la variable no es balanceada, pero este no parece ser un problema para Naïve Bayes. Al igual que como vimos en las clases anteriores, este modelo requiere que se haga una división de los datos. Para este modelo utilizaremos el comando sample():
set.seed(123)
proba <- 0.8
data2 <- data1[,c(1,3:13)]
trainIndex <- sample(nrow(data2), nrow(data2)*proba)
train1 <- data2[trainIndex,]
test1 <- data2[-trainIndex,]Una vez tenemos nuestras bases de datos vamos a correr nuestro modelo. El modelo corre con el comando naiveBayes() al cual le daremos como parámetro de entrada el modelo y el origen de los datos:
mod1 <- naiveBayes(label ~ ., data= train1)
mod1##
## Naive Bayes Classifier for Discrete Predictors
##
## Call:
## naiveBayes.default(x = X, y = Y, laplace = laplace)
##
## A-priori probabilities:
## Y
## 0 1
## 0.8089744 0.1910256
##
## Conditional probabilities:
## fea_1
## Y [,1] [,2]
## 0 5.445325 1.373134
## 1 5.758389 1.378655
##
## fea_2
## Y [,1] [,2]
## 0 1285.311 51.37484
## 1 1277.060 49.98439
##
## fea_3
## Y [,1] [,2]
## 0 2.320127 0.9472889
## 1 2.476510 0.8821342
##
## fea_4
## Y [,1] [,2]
## 0 131171.2 94573.19
## 1 101838.9 71338.18
##
## fea_5
## Y [,1] [,2]
## 0 1.930269 0.2548945
## 1 1.932886 0.2510634
##
## fea_6
## Y [,1] [,2]
## 0 10.81458 2.684259
## 1 11.18792 2.568965
##
## fea_7
## Y [,1] [,2]
## 0 5.006339 2.887294
## 1 4.805369 2.914729
##
## fea_8
## Y [,1] [,2]
## 0 100.47227 11.90660
## 1 99.21477 12.68621
##
## fea_9
## Y [,1] [,2]
## 0 4.209192 0.8714034
## 1 4.214765 0.8971709
##
## fea_10
## Y [,1] [,2]
## 0 160566.6 149788.4
## 1 176124.7 156946.3
##
## fea_11
## Y [,1] [,2]
## 0 129.6710 117.7216
## 1 129.3027 114.2239El modelo por si solo no nos dirá mucho más que las probabilidades de cada estado, ya que solo contiene información de las estadísticas a priori y sobre las variables de entrada. Para poder probarla es más útil tendremos que usar nuestros datos de test con el mismo comando de las clases anteriores, predict():
pred1 <- predict(mod1, test1)Una vez tenemos este resultado lo podemos comparar usando nuestra función table():
table(test1$label, pred1)## pred1
## 0 1
## 0 155 2
## 1 39 0Como podemos ver, este modelo no parece funcionar muy bien ya que no predice la variable label correctamente (especificidad de casi 0).
Naive Bayes con CARET
Al igual que como hemos hecho en clases anteriores, utilizaremos el paquete caret() para realizar nuestra predicción. Empezaremos, una vez más, haciendo una división en los datos (train y test):
library(caret)## Loading required package: latticeset.seed(20210901)
trainIndex2 <- createDataPartition(data2$label, p=0.8, list=F)
train2 <- data2[trainIndex2,]
test2 <- data2[-trainIndex2,]Una vez tengo mis bases de datos debo definir mis controles del modelo:
fitControl <- trainControl( method = "cv", number = 10, savePredictions = 'final', classProbs = FALSE)Ahora deberemos correr el modelo usando nuestras variables usando el método nb():
mod2 <- train(train2[,2:4], train2$label, method = "nb" ,trControl = fitControl)## Warning in FUN(X[[i]], ...): Numerical 0 probability for all classes with
## observation 2Una vez hemos corrido el modelo vamos a usar la función predict() para evaluar los resultados sobre el dataset test2:
pred2 <- predict(mod2, test2)
confusionMatrix(test2$label, pred2)## Confusion Matrix and Statistics
##
## Reference
## Prediction 0 1
## 0 157 0
## 1 37 0
##
## Accuracy : 0.8093
## 95% CI : (0.7468, 0.862)
## No Information Rate : 1
## P-Value [Acc > NIR] : 1
##
## Kappa : 0
##
## Mcnemar's Test P-Value : 3.252e-09
##
## Sensitivity : 0.8093
## Specificity : NA
## Pos Pred Value : NA
## Neg Pred Value : NA
## Prevalence : 1.0000
## Detection Rate : 0.8093
## Detection Prevalence : 0.8093
## Balanced Accuracy : NA
##
## 'Positive' Class : 0
## Este modelo tampoco parece ser un buen predictor del modelo, por lo que nos iremos por un nuevo modelo, los árboles de decisión.
Árboles de decisión
Los árboles de decisión son un método usado en distintas disciplinas como modelo de predicción. Estos son similares a diagramas de flujo, en los que llegamos a puntos en los que se toman decisiones de acuerdo a una regla. En el campo del aprendizaje automático, hay distintas maneras de obtener árboles de decisión, la que usaremos en esta ocasión es conocida como CART: Classification And Regression Trees. Esta es una técnica de aprendizaje supervisado. Tenemos una variable objetivo (dependiente) y nuestra meta es obtener una función que nos permita predecir, a partir de variables predictoras (independientes), el valor de la variable objetivo para casos desconocidos.
Como el nombre indica, CART es una técnica con la que se pueden obtener árboles de clasificación y de regresión. Usamos clasificación cuando nuestra variable objetivo es discreta, mientras que usamos regresión cuando es continua. Nosotros tendremos una variable discreta, así que haremos clasificación. La implementación particular de CART que usaremos es conocida como Recursive Partitioning and Regression Trees o RPART. De allí el nombre del paquete que utilizaremos en nuestro ejemplo.
De manera general, lo que hace este algoritmo es encontrar la variable independiente que mejor separa nuestros datos en grupos, que corresponden con las categorías de la variable objetivo. Esta mejor separación es expresada con una regla. A cada regla corresponde un nodo. Por ejemplo, supongamos que nuestra variable objetivo tiene dos niveles, deudor y no deudor. Encontramos que la variable que mejor separa nuestros datos es ingreso mensual, y la regla resultante es que ingreso mensual > X pesos. Esto quiere decir que los datos para los que esta regla es verdadera, tienen más probabilidad de pertenecer a un grupo, que al otro. En este ejemplo, digamos que si la regla es verdadera, un caso tiene más probabilidad de formar parte del grupo no deudor.
Una vez hecho esto, los datos son separados (particionados) en grupos a partir de la regla obtenida. Después, para cada uno de los grupos resultantes, se repite el mismo proceso. Se busca la variable que mejor separa los datos en grupos, se obtiene una regla, y se separan los datos. Hacemos esto de manera recursiva hasta que nos es imposible obtener una mejor separación. Cuando esto ocurre, el algoritmo se detiene. Cuando un grupo no puede ser partido mejor, se le llama nodo terminal u hoja. Una característica muy importante en este algoritmo es que una vez que alguna variable ha sido elegida para separar los datos, ya no es usada de nuevo en los grupos que ha creado. Se buscan variables distintas que mejoren la separación de los datos.
Además, supongamos después de una partición que hemos creado dos grupos, A y B. Es posible que para el grupo A, la variable que mejor separa estos datos sea diferente a la que mejor separa los datos en el grupo B. Una vez que los grupos se han separado, al algoritmo “no ve” lo que ocurre entre grupos, estos son independientes entre sí y las reglas que aplican para ellos no afectan en nada a los demás. El resultado de todo el proceso anterior es una serie de bifurcaciones que tiene la apariencia de un árbol que va creciendo ramas, de allí el nombre del procedimiento (aunque a mí en realidad me parece más parecido a la raíz del árbol que a las ramas).
Las principales ventajas de este método son su interpretabilidad, pues nos da un conjunto de reglas a partir de las cuales se pueden tomar decisiones. Este es un algoritmo que no es demandante en poder de cómputo comparado con procedimientos más sofisticados y, a pesar de ello, que tiende a dar buenos resultados de predicción para muchos tipos de datos.
Sus principales desventajas son que este en tipo de clasificación “débil”, pues sus resultados pueden variar mucho dependiendo de la muestra de datos usados para entrenar un modelo. Además es fácil sobreajustar los modelos, esto es, hacerlos excelentes para clasificar datos que conocemos, pero deficientes para datos conocidos. Así pues, empezamos con el ejercicio:
Árboles de decisión con rpart
Empezaremos por instalar nuestro paquete, el cual nos permitirá realizar los ejercicios de clase:
library(rpart)Al igual que en los métodos anteriores, tendremos que hacer una división de los datos y una selección de las variables. Por términos del trabajo nos ahorraremos estos pasos e iremos directamente a la realización del modelo. Para este caso el comando es rpart():
mod3 <- rpart(label ~ ., data=train1)
mod3## n= 780
##
## node), split, n, loss, yval, (yprob)
## * denotes terminal node
##
## 1) root 780 149 0 (0.8089744 0.1910256)
## 2) fea_4>=75500 594 82 0 (0.8619529 0.1380471) *
## 3) fea_4< 75500 186 67 0 (0.6397849 0.3602151)
## 6) fea_4>=50500 127 38 0 (0.7007874 0.2992126)
## 12) fea_2< 1240.25 72 15 0 (0.7916667 0.2083333) *
## 13) fea_2>=1240.25 55 23 0 (0.5818182 0.4181818)
## 26) fea_2>=1243.25 35 10 0 (0.7142857 0.2857143) *
## 27) fea_2< 1243.25 20 7 1 (0.3500000 0.6500000) *
## 7) fea_4< 50500 59 29 0 (0.5084746 0.4915254)
## 14) fea_11>=178.408 24 8 0 (0.6666667 0.3333333) *
## 15) fea_11< 178.408 35 14 1 (0.4000000 0.6000000)
## 30) fea_1< 4.5 15 6 0 (0.6000000 0.4000000) *
## 31) fea_1>=4.5 20 5 1 (0.2500000 0.7500000) *plot(mod3)
text(mod3,pretty=T,minlength=10, cex=0.5)
Al revisar los resultados vemos que las variables importantes son 2,4,10 y 11. Esto confirma nuestros resultados del modelo anterior. Ahora deberemos hacer uso de nuestro comando predict() para realizar nuestras pruebas del modelo:
pred3 <- predict(mod3, test1)
pred3_1 <- ifelse(pred3[,2]>0.75, yes=1, no=0)Finalmente evaluaremos el modelo de acuerdo con nuestra matriz de confusión:
table(test1$label, pred3_1)## pred3_1
## 0 1
## 0 155 2
## 1 38 1Con respecto al modelo anterior vemos que hay una mejoría en el nivel de predicción, lo que nos dice que este modelo funciona mejor para este propósito.
Árboles de decisión con caret
Una vez más, les mostraré la aplicación con el paquete caret(). No realizaremos nuevamente la división de los datos y el ajuste de los controles, así que pasaremos a la realización del modelo. En este caso el método será rpart():
mod4 <- train(train2[,2:12],train2$label, method="rpart", trControl=fitControl)Ahora iremos a revisar los resultados con nuestra base de datos de test:
pred4 <- predict(mod4, test2)
confusionMatrix(test2$label,pred4)## Confusion Matrix and Statistics
##
## Reference
## Prediction 0 1
## 0 151 6
## 1 36 1
##
## Accuracy : 0.7835
## 95% CI : (0.7188, 0.8393)
## No Information Rate : 0.9639
## P-Value [Acc > NIR] : 1
##
## Kappa : -0.0162
##
## Mcnemar's Test P-Value : 7.648e-06
##
## Sensitivity : 0.80749
## Specificity : 0.14286
## Pos Pred Value : 0.96178
## Neg Pred Value : 0.02703
## Prevalence : 0.96392
## Detection Rate : 0.77835
## Detection Prevalence : 0.80928
## Balanced Accuracy : 0.47517
##
## 'Positive' Class : 0
## El uso automático del modelo no nos ha generado mejores resultados (uno de los riesgos de este tipo de modelos). La pregunta es ¿cómo podemos hacerlo incluso mejor? La mejor forma es hacer muchos árboles. Sin embargo, esto es costoso en términos de programación y no sabremos si tenemos una buena combinación. Para solucionar este problema se diseñaron los bosques aleatorios.
Bosques aleatorios
Si aplicamos de manera iterativa el algoritmo que crea árboles de decisión con diferentes parámetros sobre los mismos datos, obtenemos lo que denominamos un bosque aleatorio de decisión (random forest). Este algoritmo es uno de los métodos más eficientes de predicción y más usados hoy día para big data, pues promedia muchos modelos con ruido e imparciales reduciendo la variabilidad final del conjunto.
En realidad lo que se hace es construir diferentes conjuntos de entrenamiento y de test sobre los mismos datos, lo que genera diferentes árboles de decisión sobre los mismos datos. La unión de estos árboles de diferentes complejidades y con datos de origen distinto aunque del mismo conjunto resulta un bosque aleatorio, cuya principal característica es que crea modelos más robustos de los que se obtendrían creando un solo árbol de decisión complejo sobre los mismos datos.
El ensamblado de modelos (arboles de decisión) distintos genera predicciones mas robustas. Los grupos de árboles de clasificación se combinan y se deduce una única predicción votada en democracia por la población de árboles.El paquete randomForest() nos permite crear este tipo de modelos de manera muy sencilla.
Bosques aleatorios con randomForest
Empezaremos por llamar al paquete randomForest:
library(randomForest)## Warning: package 'randomForest' was built under R version 4.1.1## randomForest 4.6-14## Type rfNews() to see new features/changes/bug fixes.##
## Attaching package: 'randomForest'## The following object is masked from 'package:ggplot2':
##
## marginAl igual que en los métodos anteriores, tendremos que hacer una división de los datos y una selección de las variables. Por términos del trabajo nos ahorraremos estos pasos e iremos directamente a la realización del modelo. Para este caso el comando es randomTree(). Es importante notar que debemos indicar la cantidad de árboles a generar. En este caso se recomiendo que se tengan 5 árboles por cada observación para bases pequeñas y 2 para bases grandes. En este caso decidimos usar 3000 árboles:
set.seed(1234)
mod5 <- randomForest(label ~ ., data=train1, ntree=3000)Tengan en cuenta que dada la cantidad de árboles el tiempo de procesamiento será grande. Ahora debemos realizar la predicción haciendo uso del comando predict():
pred5 <- predict(mod5, test1)Una vez hemos hecho nuestra predicción veremos que tan bueno es el resultado usando la matriz de confusión:
table(test1$label, pred5)## pred5
## 0 1
## 0 152 5
## 1 38 1Aunque no es un modelo excelente, mejora con respecto a los modelos anteriores. Finalmente veremos si este modelo funciona bien con el paquete caret
Bosques aleatorios con caret
Nuevamente, omitiremos los pasos de selección de variables, diseño de los controles y división de bases de datos e iremos directamente a la predicción con el método rf:
mod6 <- train(train2[,2:12], train2$label, method="rf", trControl = fitControl)Al igual que antes, tengan en cuenta que las operaciones pueden ser lentas. Una vez tenemos nuestro modelo iremos a la predicción:
pred6 <- predict(mod6, test2)Una vez tenemos nuestro modelo correremos la matriz de confusión de este modelo:
confusionMatrix(test2$label, pred6)## Confusion Matrix and Statistics
##
## Reference
## Prediction 0 1
## 0 154 3
## 1 36 1
##
## Accuracy : 0.799
## 95% CI : (0.7356, 0.853)
## No Information Rate : 0.9794
## P-Value [Acc > NIR] : 1
##
## Kappa : 0.012
##
## Mcnemar's Test P-Value : 2.99e-07
##
## Sensitivity : 0.81053
## Specificity : 0.25000
## Pos Pred Value : 0.98089
## Neg Pred Value : 0.02703
## Prevalence : 0.97938
## Detection Rate : 0.79381
## Detection Prevalence : 0.80928
## Balanced Accuracy : 0.53026
##
## 'Positive' Class : 0
## Auneu hemos mejorado a lo largo de estos modelos, parece que todavía no encontramos un modelo adecuado. La próxima sesión hablaremos de otros modelos adicionales que nos ayuden con esta tarea.