Introducción al aprendizaje automatizado –Machine Learning–

Pasos para aplicar ML

• Recoger y almacenar datos

• Explorar y preparar los datos

• Entrenar al clasificador con nuestros datos

• Evaluar el desempeño del modelo

• Mejorarlo si fuese necesario

Una vez completados estos pasos, nuestro modelo puede ser implementado en la clasificación de nuevos datos.

Implementación de KNN en R

data( iris )

Preprocesar datos

El preporcesado de datos incluye normalizar si es necesario, o reducir el número de variables si fuese necesario mediante otras técnicas multivariantes.

P.e. \(\frac{x-\overline{x}}{\sigma^2}\), es lo que hace la función scale()

NormIris <- as.data.frame( scale( iris[, 1:4 ], scale = TRUE, center = TRUE ) )
summary( NormIris )

  Sepal.Length       Sepal.Width       Petal.Length    
 Min.   :-1.86378   Min.   :-2.4258   Min.   :-1.5623  
 1st Qu.:-0.89767   1st Qu.:-0.5904   1st Qu.:-1.2225  
 Median :-0.05233   Median :-0.1315   Median : 0.3354  
 Mean   : 0.00000   Mean   : 0.0000   Mean   : 0.0000  
 3rd Qu.: 0.67225   3rd Qu.: 0.5567   3rd Qu.: 0.7602  
 Max.   : 2.48370   Max.   : 3.0805   Max.   : 1.7799  
  Petal.Width     
 Min.   :-1.4422  
 1st Qu.:-1.1799  
 Median : 0.1321  
 Mean   : 0.0000  
 3rd Qu.: 0.7880  
 Max.   : 1.7064  

Previsualizar datos

plot( iris[ ,1:4 ], col = iris$Species )

Generar las muestras

En una clasificación supervisada, normalmente se selecciona del total de datos, un subconjunto de aproximadamente 2/3 - 3/4 del total para entrenar al clasificador y el resto de datos se reserva para testar el desempeño del clasificador, o dicho de otra forma, para comprobar cómo de bien o mal clasifica nuestra máquina·

#generar subconjunto de 100 datos para entrenar
iris.train <- iris[ sample( c( 1:150 ), 100 ), 1:5 ]
#generar subconjunto de 50 datos para testar
iris.test <- iris[ sample( c( 1:150 ), 50 ), 1:5 ]

Entrenar/testar clasificador

La función knn del paquete class entrena y clasifica en un único paso. Como parámetros le pasamos en conjunto de datos de entrenamiento, el conjunto de datos para el test, las clases a las que pertenece cada elemento, y el número de vecinos.

# Genera modelo y hace predicción a la vez
iris.pred <- knn( train = iris.train[ , 1:4 ], test = iris.test[ , 1:4 ], 
                cl = iris.train[ ,5 ], k = 2 )

# predicción
print(iris.pred)

 [1] virginica  virginica  versicolor setosa     setosa    
 [6] virginica  virginica  setosa     versicolor setosa    
[11] virginica  versicolor setosa     setosa     setosa    
[16] virginica  setosa     setosa     virginica  versicolor
[21] setosa     setosa     setosa     setosa     setosa    
[26] versicolor virginica  versicolor setosa     virginica 
[31] setosa     versicolor versicolor setosa     versicolor
[36] versicolor setosa     virginica  virginica  virginica 
[41] virginica  setosa     setosa     setosa     versicolor
[46] virginica  virginica  versicolor setosa     setosa    
Levels: setosa versicolor virginica

# realidad 
print(iris.test[ ,5 ])

 [1] virginica  virginica  versicolor setosa     setosa    
 [6] virginica  virginica  setosa     versicolor setosa    
[11] virginica  versicolor setosa     setosa     setosa    
[16] virginica  setosa     setosa     virginica  versicolor
[21] setosa     setosa     setosa     setosa     setosa    
[26] versicolor virginica  versicolor setosa     virginica 
[31] setosa     versicolor versicolor setosa     versicolor
[36] versicolor setosa     versicolor virginica  virginica 
[41] virginica  setosa     setosa     setosa     versicolor
[46] virginica  virginica  versicolor setosa     setosa    
Levels: setosa versicolor virginica

Validar resultados

Podemos ver la diferencia entre lo clasificado y la realidad con table

table( Predic = iris.pred, Realidad = iris.test[,5])

            Realidad
Predic       setosa versicolor virginica
  setosa         23          0         0
  versicolor      0         12         0
  virginica       0          1        14

Una vez creado un clasificador y comprobado que clasifica bien, podemos probarlo con un dato nuevo. Si encuentro un iris en el campo y mido pétalo y sépalo, puedo utilizar mi clasificador para determinar a que variedad pertenece.

miIris <- c( 5.0, 3.5, 1.3, 0.1 )

mi_predict <- knn( train = iris.train[ ,1:4 ], test = miIris, 
                cl = iris.train[ ,5 ], k = 2, prob = TRUE ) 
mi_predict

[1] setosa
attr(,"prob")
[1] 1
Levels: setosa versicolor virginica

Implementación de SVM en R

data( iris )

Preprocesar datos

Incluye normalizar si es necesario, reducir el número de variables si fuese necesario…

Generar las muestras

#generar muestras
iris.train <- iris[ sample( c( 1:150 ), 100 ), 1:5 ]

iris.test <- iris[ sample( c( 1:150 ), 30 ), 1:5 ]

Aplicar SVM

Con la función svm del paquete e1071 se puede generar generar un modelo mediante algoritmo de soporte de vectores. Como parámetros hay que proporcionar los datos en forma de fórmula de R, donde la variable respuesta son las clases frente al resto de variables predictoras Species ~ ., hay que definir sobre que datos se está refiriendo la fórmula, si queremos normalizar los datos y el tipo de función kernel que queremos utilizar.

# Esta función sólo genera el modelo
svm_model <- svm( Species ~ . , data = iris.train, scale = TRUE,
                  kernel = "linear", probability = TRUE)
summary( svm_model )

Call:
svm(formula = Species ~ ., data = iris.train, kernel = "linear", 
    probability = TRUE, scale = TRUE)


Parameters:
   SVM-Type:  C-classification 
 SVM-Kernel:  linear 
       cost:  1 
      gamma:  0.25 

Number of Support Vectors:  25

 ( 10 2 13 )


Number of Classes:  3 

Levels: 
 setosa versicolor virginica

Una vez entrenado el modelo, podemos hacer predicción con el conjunto de datos de iris.test.

SVM_predict <- predict( svm_model, iris.test[,1:4], 
                        probability = TRUE, decision.values = TRUE )
summary(SVM_predict)

    setosa versicolor  virginica 
        12          9          9 

Contrastar la predicción con la realidad

# Versión simple
table( SVM_predict, Realidad = as.factor( iris.test[ ,5 ] ) )

            Realidad
SVM_predict  setosa versicolor virginica
  setosa         12          0         0
  versicolor      0          9         0
  virginica       0          0         9

Igual que en el caso de KNN, podemos hacer una predicción sobre nuestro modelo con una muestra recogida en el campo, y obtendremos a qué clase ha sido asignada y con que probabilidad.

miIris <- matrix( c( 5.0, 3.5, 1.3, 0.1 ), nrow = 1, ncol = 4 )
colnames( miIris ) <- colnames( iris[ , 1:4 ] )
# predict requiere un matrix o data.frame no un vector
predict( svm_model, miIris, probability = TRUE )

     1 
setosa 
attr(,"probabilities")
    virginica    setosa versicolor
1 0.009415069 0.9764111  0.0141738
Levels: setosa versicolor virginica

Refrescando la memoria bayesiana

Probabilidad de un evento

\[ P(X) = \frac{Casos\ \ favorables}{Casos\ \ posibles} \]

Probabilidad de que al tirar un dado salga un 3:

\[ P(X=3) = \frac{1}{6} \]

Probabilidad condicionada

Probabilidad de que suceda un evento cuando ya ha sucedido otro:

\[ P (Y \mid X) \]

Probabilidad de que Y tome un valor determinado cuando X ya ha tomado uno.

Ejemplo: probabilidad de obtener un 10 entre dos dados cuando el primero ha salido 4

\[ P (Y=10 \mid X=4) \]

Teorema de Bayes

Basado en el Teorema de Bayes:

\[ P(Y \mid X) = \frac{P(X \mid Y) \, P(Y)}{P(X)} \]

En castellano

\[ P(posteriori) = \frac{P(probabilidad\ condicional) \, P(a\ priori)}{P(total)} \]

Veamos como funciona Naïve Bayes como predictor con un ejemplo:

Tenemos datos históricos sobre si se ha jugado o no al tenis con una serie de parámetros meteorológicos muy simples.
En base a esto, y empleando la lógica bayesiana determinaremos qué probabilidad tenemos de que haya partido un día nublado, frío, con alta humedad y sin viento.

La siguiente tabla, son nuestros datos históricos.

Probabilidades

¿Jugaremos al tenis (\(Y\)) un día nublado, frío, con humedad alta y sin viento (\(X\))?

\[ P(Y=Si \mid X_{v1,v2,v3,v4}) = \frac{P(X \mid Y)_{vi} \cdot P(Y)}{P(total)} \]

Probabilidades

Las probabilidades “observadas” se obtienen de las frecuencias de la tabla anterior.

\[ P(SI_{jugar}) = 4/7 \ \ P(NO_{jugar}) = 3/7 \] \[ P(nublado \mid SI_{jugar}) = 2/4 \ \ P(nublado \mid NO_{jugar}) = 1/3 \] \[ P(frio \mid SI_{jugar}) = 1/4 \ \ P(frio \mid NO_{jugar}) = 1/3 \] \[ P(Alta_{humedad} \mid SI_{jugar}) = 1/4 \ \ P(Alta_{humedad} \mid NO_{jugar}) = 3/3 \] \[ P(Si_{viento} \mid SI_{jugar}) = 1/4 \ \ P(Si_{Viento} \mid NO_{jugar}) = 2/3 \]

La hora de la verdad, ¿Jugaremos?

\[ P(Y=Si \mid X_{v1,v2,v3,v4}) = \frac{2/4 \cdot 1/4 \cdot 1/4 \cdot 1/4 \cdot 4/7 =0.024}{0.024+0.21}=0.103 \] \[ P(Y=No \mid X_{v1,v2,v3,v4}) = \frac{1/3 \cdot 1/3 \cdot 3/3 \cdot 2/3 \cdot 3/7 = 0.21}{0.024+0.21}=0.897 \]

Implementación de Naïve Bayes en R

iris.NB <- naiveBayes( Species ~ ., data = iris.train )
iris.NB

Naive Bayes Classifier for Discrete Predictors

Call:
naiveBayes.default(x = X, y = Y, laplace = laplace)

A-priori probabilities:
Y
    setosa versicolor  virginica 
      0.29       0.35       0.36 

Conditional probabilities:
            Sepal.Length
Y                [,1]      [,2]
  setosa     5.086207 0.3215189
  versicolor 5.917143 0.3776753
  virginica  6.616667 0.6855655

            Sepal.Width
Y                [,1]      [,2]
  setosa     3.455172 0.4230723
  versicolor 2.757143 0.2983146
  virginica  2.952778 0.3220347

            Petal.Length
Y                [,1]      [,2]
  setosa     1.520690 0.1372675
  versicolor 4.291429 0.3760252
  virginica  5.608333 0.5862106

            Petal.Width
Y                 [,1]      [,2]
  setosa     0.2827586 0.1197288
  versicolor 1.3171429 0.1790263
  virginica  1.9916667 0.2892107

predNB <- predict( iris.NB, iris.test[,1:4] )
predNB

 [1] setosa     versicolor setosa     setosa     virginica 
 [6] virginica  versicolor versicolor setosa     versicolor
[11] setosa     virginica  virginica  setosa     setosa    
[16] setosa     virginica  versicolor setosa     virginica 
[21] setosa     versicolor setosa     virginica  versicolor
[26] versicolor setosa     virginica  virginica  versicolor
Levels: setosa versicolor virginica

Contrastar la predicción

table( Predicción = predNB, Realidad = iris.test[,5] )

            Realidad
Predicción  setosa versicolor virginica
  setosa         12          0         0
  versicolor      0          9         0
  virginica       0          0         9

Y con mi muestra encontrada en el campo

miIris<-matrix(c(5.0, 3.5, 1.3, 0.1), nrow=1, ncol=4)

colnames(miIris)<-colnames(iris[,1:4])

# En este caso predict requiere un matrix o data.frame no un vector
pdr <- predict(iris.NB, miIris, probability = TRUE )
summary(pdr)

    setosa versicolor  virginica 
         1          0          0 

Lo que nos devuelve la predicción es la probabilidad de pertenencia a cada clase. En este caso es una probabilidad del 100% de pertenecer a la clase setosa, y por tanto 0% al resto de clases.

Implementación de redes neuronales en R

Preprocesar datos

Incluye normalizar si es necesario, reducir el número de variables si fuese necesario, …

Generar las muestras

Este paso es igual lo que hemos visto en los ejemplos anteriores

data(iris)
#generar muestras
iris.train <- iris[ sample( c( 1:150 ), 100 ), 1:5 ]

iris.test <- iris[ sample( c( 1:150 ), 50 ), 1:5 ]

Binarizar las categorias

En este caso hay que generar nuevas columnas de VERDADERO/FALSO para pertenencia de cada observación a cada clase —especie—.

iris.train <- cbind( iris.train, iris.train$Species == "setosa" )
iris.train <- cbind( iris.train, iris.train$Species == "versicolor" )
iris.train <- cbind( iris.train, iris.train$Species == "virginica" )

names(iris.train)[6]<-"setosa"
names(iris.train)[7]<-"versicolor"
names(iris.train)[8]<-"virginica"

head(iris.train)

    Sepal.Length Sepal.Width Petal.Length Petal.Width
94           5.0         2.3          3.3         1.0
107          4.9         2.5          4.5         1.7
28           5.2         3.5          1.5         0.2
127          6.2         2.8          4.8         1.8
29           5.2         3.4          1.4         0.2
56           5.7         2.8          4.5         1.3
       Species setosa versicolor virginica
94  versicolor  FALSE       TRUE     FALSE
107  virginica  FALSE      FALSE      TRUE
28      setosa   TRUE      FALSE     FALSE
127  virginica  FALSE      FALSE      TRUE
29      setosa   TRUE      FALSE     FALSE
56  versicolor  FALSE       TRUE     FALSE

Entrenar la red neuronal

La función neuralnet del paquete del mismo nombre, requiere la introducción de parámetros de forma similar a como se hizo en SVM, mediante una foŕmula, donde las variables dependientes –setosa, versicolor, virgínica– lo son en función de las predictoras. Podemos definir también la topología de la red, es decir cuántas capas y cuántos nodos por capa.

Una vez entrenada nuestra red, podemos visualizar su topología, los pesos ponderados asignados a cada nodo. Con la función print podemos obtener bastante información acerca del modelo.

iris.nnt <- neuralnet( setosa + versicolor + virginica ~ Sepal.Length +
            Sepal.Width +
            Petal.Length +
            Petal.Width, 
            data = iris.train, hidden = c( 3, 2 ) )
# print(iris.nnt) #Ejecutar para ver los resultados
plot( iris.nnt, col.intercept = "blue" , rep="best")

Predicción

Con los datos que nos reservamos para el test, vamos a hacer la predicción, en este caso en lugar de la función predict usada anteriormente, empleamos compute

pred.nn <- compute( iris.nnt, iris.test[ 1:4 ] )
# print(pred.nn) # ejecutar para ver los resultados

El resultado de la predicción no es tan “amigable” como en los otros algoritmos vistos, pero con un poco de código lo podemos extraer y dejar más claro.

resultado <- 0
for ( i in 1:dim( pred.nn$net.result )[1] ){
  resultado[i] <- which.max( pred.nn$net.result[ i, ] )
}
resultado[ resultado == 1 ] <- "setosa"
resultado[ resultado == 2 ] <- "versicolor"
resultado[ resultado == 3 ] <- "virginica"

table(Predicción = resultado, Realidad = iris.test[,5])

            Realidad
Predicción  setosa versicolor virginica
  setosa         13          0         0
  versicolor      0         18         1
  virginica       0          0        18

Evaluar el modelo con tablas

Lo más sencillo, una tabla de contingencia con table

table( Predicción = w_predict, Observación = w_test_label )

          Observación
Predicción  B  M
         B 80  8
         M  0 52

Una tabla de contingencia un poco más sofisticada con CrossTable

Calcula una tabla similar a la anterior pero más completa. Aporta proporciones de aciertos por filas, columnas y totales.

CrossTable(x = w_predict, y = w_test_label, dnn = c( "Predicción", "Observación" )
           , prop.chisq = FALSE )

 
   Cell Contents
|-------------------------|
|                       N |
|           N / Row Total |
|           N / Col Total |
|         N / Table Total |
|-------------------------|

 
Total Observations in Table:  140 

 
             | Observación 
  Predicción |         B |         M | Row Total | 
-------------|-----------|-----------|-----------|
           B |        80 |         8 |        88 | 
             |     0.909 |     0.091 |     0.629 | 
             |     1.000 |     0.133 |           | 
             |     0.571 |     0.057 |           | 
-------------|-----------|-----------|-----------|
           M |         0 |        52 |        52 | 
             |     0.000 |     1.000 |     0.371 | 
             |     0.000 |     0.867 |           | 
             |     0.000 |     0.371 |           | 
-------------|-----------|-----------|-----------|
Column Total |        80 |        60 |       140 | 
             |     0.571 |     0.429 |           | 
-------------|-----------|-----------|-----------|

 

Curvas ROC (_Receiver Operating Characteristic_) como evaluadores

Como vimos en el módulo anterior, es una representación gráfica de la \(sensibilidad\) frente a \(1 - especificidad\) para un clasificador binario, es decir sólo hay dos respuestas, positivo y negativo.

prob <- attr(w_predict, "prob")
labels <- factor(w_test_label, labels = c(1,0))
rocobj <- pROC::roc( labels, prob, auc = TRUE, ci = TRUE  )
print( rocobj )

Call:
roc.default(response = labels, predictor = prob, auc = TRUE,     ci = TRUE)

Data: prob in 80 controls (labels 1) > 60 cases (labels 0).
Area under the curve: 0.6527
95% CI: 0.5694-0.736 (DeLong)

pROC::plot.roc( rocobj, legacy.axes = TRUE, print.thres = "best",
                print.auc = TRUE, auc.polygon = FALSE, max.auc.polygon = FALSE,
                auc.polygon.col="gainsboro", col = 2, grid = TRUE )

Como se puede observar el la curva, el clasificador no parece ser muy bueno, ya que su AUC no es muy alta (0.6527083)

Vamos a repetir aumentando el número de vecinos a k=100.

w_predict<- knn( w_train[ , c( 1:( ncol(w_train) -1 ) )  ], 
                 w_test[ , c( 1:( ncol(w_test) -1 ) )  ], 
                 cl = w_train_label, k = 100, prob = TRUE )

prob <- attr(w_predict, "prob")
labels <- factor(w_test_label, labels = c(0,1))
rocobj <- pROC::roc( labels, prob, auc = TRUE, ci = TRUE  )
print( rocobj )

Call:
roc.default(response = labels, predictor = prob, auc = TRUE,     ci = TRUE)

Data: prob in 80 controls (labels 0) > 60 cases (labels 1).
Area under the curve: 0.7331
95% CI: 0.641-0.8252 (DeLong)

pROC::plot.roc( rocobj, legacy.axes = TRUE, print.thres = "best", print.auc = TRUE,
          auc.polygon = FALSE, max.auc.polygon = FALSE, auc.polygon.col="gainsboro",
          col = 2, grid = TRUE )

Ahora el AUC a aumentado a 0.733125 por lo que al aumentar el número de vecinos, ha mejorado –en este caso– la eficiencia del predictor.

Validación cruzada —cross-validation—

Como se ha comentado anteriormente, una vez que hemos generado el modelo, interesa conocer la precisión de este modelo en la predicción de los resultados. Dicho de otra manera, interesa estimar el error cometido en la predicción.

La validación cruzada aglutina una serie de técnicas, utilizadas para validar la precisión de un modelo predictivo. Para ello, comprueba la bondad predictiva del modelo sobre un conjunto de datos de prueba independientes de los datos empleados para generar el modelo.

Básicamente la secuencia sería:

1. Construir el modelo con los datos de entrenamiento
2. Aplicar el modelo con los datos de prueba, que serán independientes de los de entrenamiento
3. Estimar el error en la predicción.

Hay distintas técnicas de validación cruzada para la estimación del error, aqui vamos a ver alguna de ellas.

Para todas las técnicas que vamos a ver, utilizaremos el paquete caret, uno de los más completos paquetes de machine learning que hay en R.

En primer lugar cargaremos y prepararemos los datos, esto nos servirá para todos los métodos que vamos a ver. A continuación iremos haciendo las validaciones con las diferentes técnicas

La función CreateDataPartition nos permite crear un grupo de entrenamiento de forma similar a como lo hacíamos con sample.

set.seed(111)
train <- createDataPartition( iris$Species, p = 0.7, list = FALSE )
train.iris <- iris[ train, ]
test.iris <- iris[ -train, ]

El método del conjunto de validación

En este caso la cuantificación del error se hace mediante la diferencia cuadrática media entre los valores observados y los predichos.

#Crear el modelo
model <- naiveBayes(Species ~ . , data = train.iris )
predictions <- predict( model, test.iris )
predictions <- as.numeric( predictions )
test <- as.numeric( as.factor( test.iris$Species ) )

data.frame( R2 = R2( predictions, test ),
            RMSE = RMSE(predictions, test ),
            MAE = MAE(predictions, test ) )

         R2      RMSE        MAE
1 0.9363057 0.2108185 0.04444444

\(R^2\)

Es la correlación al cuadrado entre observaciones y predicciones. Cuanto más alto mejor será el modelo

RMSE —Root mean squared error—

Error cuadrático medio, mide el error medio cometido por el modelo al predecir la clasificación de una observación. Cuanto más bajo sea, mejor será el modelo

MAE —Mean absolute Error—

Error absoluto medio, es similar al RMSE, pero menos sensible a valores atípicos. Es la diferencia absoluta media entre observaciones y predicciones. Cuanto más bajo, mejor será el modelo

LOOCV —Leave one out cross validation—

La validación cruzada dejando una observación fuera, consiste en dejar fuera del modelo una observación y contruir el modelo con el resto, a continuación comprobar el modelo con esa observación y anotar el error. Este proceso se repetirá con todas las observaciones. Finalmente se obtiene el error total cometido calculado como la media de los errores obtenidos para cada observación que se ha testado.

set.seed(111)
train <- trainControl(method = "LOOCV")
model <- train(Species ~ ., data=iris, method = "naive_bayes", trControl = train )
print(model)

Naive Bayes 

150 samples
  4 predictor
  3 classes: 'setosa', 'versicolor', 'virginica' 

No pre-processing
Resampling: Leave-One-Out Cross-Validation 
Summary of sample sizes: 149, 149, 149, 149, 149, 149, ... 
Resampling results across tuning parameters:

  usekernel  Accuracy   Kappa
  FALSE      0.9533333  0.93 
   TRUE      0.9600000  0.94 

Tuning parameter 'laplace' was held constant at a value
 of 0
Tuning parameter 'adjust' was held constant at
 a value of 1
Accuracy was used to select the optimal model using
 the largest value.
The final values used for the model were laplace =
 0, usekernel = TRUE and adjust = 1.

La ventaja del método es que utiliza todos los datos para entrenar y para testar el modelo.

La desventaja es que precisamente por utilizar todos los datos, tiene un alto coste computacional, especialmente cuando tenemos un conjunto de datos muy grande.

K-fold cross-validation y repeat K-fold cross-validation

Es la validación cruzada de k-iteraciones o de k-iteraciones repetidas.

En el primer caso, el conjunto de datos se divide en \(K\) subjuntos, uno de ellos se utiliza como datos de prueba y el resto \(K-1\) los datos de entrenamiento. La validación cruzada se realizará durante \(K\) iteraciones. En cada iteración un subconjunto será el conjunto de prueba y el resto de entrenamiento.

La idea es similar al método LOOCV, pero en lugar de hacerlo a nivel de observación, se hace a nivel de conjunto de observaciones.

El método de k-fold repetido es idéntico al método k-fold, sólo que en este caso, una vez terminadas las k-iteraciones, se vuelve a particionar en subconjuntos y se repite el proceso anterior. Estos ciclos se repetirán el número de veces que se indique.

K-fold

set.seed(111)
train <- trainControl(method = "cv", number = 10 )
model <- train(Species ~ ., data=iris, method = "naive_bayes", trControl = train )
print(model)

Naive Bayes 

150 samples
  4 predictor
  3 classes: 'setosa', 'versicolor', 'virginica' 

No pre-processing
Resampling: Cross-Validated (10 fold) 
Summary of sample sizes: 135, 135, 135, 135, 135, 135, ... 
Resampling results across tuning parameters:

  usekernel  Accuracy   Kappa
  FALSE      0.9533333  0.93 
   TRUE      0.9533333  0.93 

Tuning parameter 'laplace' was held constant at a value
 of 0
Tuning parameter 'adjust' was held constant at
 a value of 1
Accuracy was used to select the optimal model using
 the largest value.
The final values used for the model were laplace =
 0, usekernel = FALSE and adjust = 1.

repeat K-fold

set.seed(111)
train <- trainControl(method = "repeatedcv", number = 10, repeats = 3 )
model <- train(Species ~ ., data=iris, method = "naive_bayes", trControl = train )
print(model)

Naive Bayes 

150 samples
  4 predictor
  3 classes: 'setosa', 'versicolor', 'virginica' 

No pre-processing
Resampling: Cross-Validated (10 fold, repeated 3 times) 
Summary of sample sizes: 135, 135, 135, 135, 135, 135, ... 
Resampling results across tuning parameters:

  usekernel  Accuracy   Kappa    
  FALSE      0.9533333  0.9300000
   TRUE      0.9555556  0.9333333

Tuning parameter 'laplace' was held constant at a value
 of 0
Tuning parameter 'adjust' was held constant at
 a value of 1
Accuracy was used to select the optimal model using
 the largest value.
The final values used for the model were laplace =
 0, usekernel = TRUE and adjust = 1.