Aprendizaje de maquinas -- R -- Máquinas de Soporte Vectorial.

Notas de clase sobre aprendizaje de maquinas usando R

Juan David Velásquez Henao
jdvelasq@unal.edu.co
Universidad Nacional de Colombia, Sede Medellín
Facultad de Minas
Medellín, Colombia

[Licencia]

[Readme]

Software utilizado.

Este es un documento interactivo escrito como un notebook de Jupyter, en el cual se presenta un tutorial sobre regresión logistica usando R en el contexto de aprendizaje de maquinas. Los notebooks de Jupyter permiten incoporar simultáneamente código, texto, gráficos y ecuaciones. El código presentado en este notebook puede ejecutarse en los sistemas operativos Linux y OS X.

Haga click aquí para obtener instrucciones detalladas sobre como instalar Jupyter en Windows y Mac OS X.

Haga clic [aquí] para ver la última versión de este documento en nbviewer.

Descargue la última versión de este documento a su disco duro; luego, carguelo y ejecutelo en línea en Try Jupyter!

Haga clic aquí para ver el tutorial de visualización y gráficas.

Contenido

Bibliografía.

Material complementario.

Webinar RStudio Getting your data into R


Introducción

Contenido

Las máquinas de soporte vectorial (SVM) son algoritmos no-lineales de aprendizaje supervisado utilizados para el problema de clasificación, no obstante se pueden utilizar para aproximar funciones o regresiones a partir de ciertos métodos. En esta sección se en clasificación.

Básicamente, el algoritmo crea una frontera llamada hiperplano, la cual divide el espacio en particiones de las clases a predecir. En este sentido se puede considerar que las SVM combinan aspectos de los métodos de regresión y de vecinos más cercanos (k-NN).

Clasificación marginal máxima

Contenido

Uno de los conceptos más importantes en SVM, es el de Maximal Margin Classification, donde se asumirá que se tiene una variable respuesta binaria para ilustar. Dentro de los árboles de regresión y clasificación, usualmente la partición (hiperplanos de separación) del espacio de las variables es lineal. A diferencia de SVM donde dependiendo de la estructura, los supuestos y el criterio de optimización se puede terminar con uno de los infinitos hiperplanos (incluyendo no lineales) que pueden particionar los datos.

Cuando se tiene dos o más variables predictoras, se expresar el hiperplano como una combinación lineal de dichas variables, por lo tanto:

$$ \beta_{0} + \sum_{k=1}^{p} \beta_{k} x_{i,k} > 0 \hspace{0.25cm} si \hspace{0.25cm} y_{i}=1 $$$$ \beta_{0} + \sum_{k=1}^{p} \beta_{k} x_{i,k} < 0 \hspace{0.25cm} si \hspace{0.25cm} y_{i}=-1 $$

Estas ecuaciones indican que cualquier punto que pertenezca a la clase 1, se encuentran por encima de la ecuación (mayor que 0). Análogmente, cualquier punto que pertenzca a la clase -1, se ubicará por debajo de ella (menor que 0).

Ahora bien, para determinar cuál de todas las rectas utilizar para la separacion de datos, se define una cantidad denominada margen, la cual representa la mínima distancia perpendicular de cualquier punto de los datos al hiperplano. Para este ejemplo, siempre se tienen al menos dos (ya que son dos variables predictoras) que tengan la menor distancia al hiperplano. A veces, pueden existir puntos con iguales distancias mínimas.

Lo anterior gráficamente es:

Por lo tanto, el hiperplano de maximo margen como aquel cuyo margen sea el mayor posible de todos los hiperplanos posibles. Lo anterior definición busca el hiperplano que separará las clases de predicción mientras al mismo tiempo busca que este sea lo más alejado posible de las observaciones evitando así cualquier sesgo. En la imagen anterior, se observa que la linea es aquella con menor margen igual a 2, donde los tres vectores perpendiculares al hiperplano se llaman vectores de soporte.

Para entender esto matemáticamente se define lo siguiente:

$$ Seleccionar \hspace{0.25cm} \beta_{0},\beta_{1},\beta_{2},... \hspace{0.25cm} que \hspace{0.1cm} maximicen \hspace{0.25cm} M $$$$ Tal \hspace{0.1cm} que: \hspace{0.25cm} \sum_{k=1}^{p} \beta_{k}^{2}=1 $$$$ además \hspace{0.25cm} \forall_{i}:y_{i} (\beta_{0} + \sum_{k=1}^{p} \beta_{k} x_{i,k}) > M $$

Las restricciones del problema establecen que deben ser correctamente clasificados los datos del problema así como que deben estar al menos de M unidades alejados del hiperplano, para esto se modifican los parámetros $ \beta $ hasta encontrar el mayor M que cumpla las restricciones.

Clasificación con Vectores de Soporte

Contenido

Cuando los datos de entranamiento no son lineamente clasificables se puede utilizar la definición de vectores de soporte para definir el margen, no obstante se permite que algunas observaciones estén mal clasificadas por el algoritmo, por lo tanto se estima un margen debil. Estas observaciones se permitiran estar dentro de un rango establecido y no afectaran la elección del hiperplano.

Hay que tener en cuenta que entre más largo el margen es más confiable el hiperplano de clasificar las observaciones, es por esto que cuando los datos no son linealmente clasificables "relajar" el margen puede ser beneficioso para el algortimo ya que evita que datos alejados modifiquen el hiperplano como se evidencia en la siguiente imagen donde se introdujo una observación de clase 1 cerca a los datos de clase -1 y el margen disminuyó de 2 a 0.29:

Para esto, matematicamente, se ingresa un parametro de "suavizamiento" $ \xi $ tal que:

$$ Seleccionar \hspace{0.25cm} \beta_{0},\beta_{1},\beta_{2},... \hspace{0.25cm} que \hspace{0.1cm} maximicen \hspace{0.25cm} M $$$$ Tal \hspace{0.1cm} que: \hspace{0.25cm} \sum_{k=1}^{p} \beta_{k}^{2}=1 $$$$ además \hspace{0.25cm} \forall_{i}:y_{i} (\beta_{0} + \sum_{k=1}^{p} \beta_{k} x_{i,k}) > M(1-\xi_{i}) $$$$ además \hspace{0.25cm} \forall_{i}:\xi_{i} > 0, \sum_{i=1}^{n} \xi_{i} <= C $$

A las variables $ \xi $ se les conocen como variables flojas, donde hay una para cada observacion y se cumple que:

$$ \xi_{i} = 0, \hspace{1cm} x_{i} \hspace{0.1cm} está \hspace{0.1cm} correctamente \hspace{0.1cm} clasificada \hspace{0.1cm} y \hspace{0.1cm} fuera \hspace{0.1cm} del \hspace{0.1cm}margen $$$$ 0 < \xi_{i} <= 1, \hspace{0.6cm} x_{i} \hspace{0.1cm} está \hspace{0.1cm} correctamente \hspace{0.1cm} clasificada \hspace{0.1cm} pero \hspace{0.1cm} dentro \hspace{0.1cm} del \hspace{0.1cm}margen $$$$ \xi_{i} > 1, \hspace{4cm} x_{i} \hspace{0.1cm} está \hspace{0.1cm} incorrectamente \hspace{0.1cm} clasificada \hspace{0.1cm} $$

Donde la magnitud de la variable suelta es proporcional a la distancia entre la observación y el hiperplano.

El hecho de que dichas variables no sobrepasen una cantidad C significa un límite superior de error en clasificación que estamos dispuestos a asumir. Si dicha constante C es baja (menor que 1) siginfica que el modelo tolerará pocas observaciones dentro del margen pero no permitirá errores de clasificación. Si por el contrario el valor de C es alto (mayor a 1) el modelo permitirá muchas observaciones dentro del margen o mal clasificadas, resultando en varios vectores de soporte. El primer escenario nos otorgará un modelo con mayor varianza pero menos sesgo, donde el último escenatio resultará en un modelo con menor varianza pero mayor sesgo. A esto se le conoce como el intercambio sesgo-varianza (Bias-Variance trade off)

Kernels y Máquinas de Soporte Vectorial

Contenido

Una forma de introducir la no-linealidad a las SVM es utilizar representaciones que involucren el concepto de producto interno de álgebra lineal para aplicar transformaciones no-lineales a su resultado. Para esto definimos una funcion general $ K $ que llamara la función núcleo (kernel) que opera en dos vectores y produce un resultado escalar. Esto se representa como:

$$ y(x)=\beta_{0}+\sum_{s \in S} \alpha_{s} K \langle x, x_{s} \rangle $$

El modelo de SVM tiene tantas características como vectores de soporte tenga y se definen estas características como un kernel aplicado a la observaciones con uno de los vectores de soporte. Para el ejemplo que anterior donde se evaluó un modelo lineal, se tiene que:

$$ K_{lineal}(x_{i},x_{j}) = \sum_{k=1}^{p} x_{i,k} x_{j,k} $$

También estas funciones kernel puede medir la similaridad aplicando funciones que lo representen. Para introducir la no-linealidad simplemente se introducen los kernels no lineales y se crea las máquinas de soporte vectorial. Entre los kernels más usados están el polinómico y el de base radial.

Kernel Polinomico

Contenido

Esta función utiliza una expasión a la potencia del producto interno de dos vectores. Esencialmente este kernel transforma el espacio de las variables predictoras en uno de mayor grado, lo cual lo hace más eficiente comparado con transformar todas las características primero e intentar ajustar un modelo lineal en ese espacio.

$$ K_{polinomico}(x_{i},x_{j}) = (1+\sum_{k=1}^{p} x_{i,k} x_{j,k})^{d} $$

Kernel Radial

Contenido

En este kernel el numero de dimensiones a la que se transforma el espacio de las variables predictoras es infinito dado al número infinito en la expansión. Si $ d \approx \infty $ entonces $ (1+\frac{1}{d})^{d}=e $. Es por esto que este kernel no usa el producto interno, en su lugar usa la suma de la distnacia entre los dos vectores. Este kernel permite que solo los vectores de soporte cerca a la observación de interes interfieran significativamente en los cálculos.

$$ K_{radial}(x_{i},x_{j}) = e^{-\frac{1}{2\sigma^{2}}\sum_{k=1}^{p}(x_{i,k}- x_{j,k})^{2}} $$

Kernel Sigmoideo

Contenido

A diferencia de los anteriores, este kernel se asemeja a una red neuronal y utiliza la función de activación sigmoidea representada por la función tangente hiperbolica.

$$ K_{sigmoideo}(x_{i},x_{j}) = tanh(\kappa x_{i,k}\cdot x_{j,k}-\delta)$$

Aplicación : En este ejemplo se utiliza la base de datos de creditos en Alemania la cual contiene las solicitudes de créditos que han realizado personas en un banco. La tarea del algoritmo es determinar si una solicitud contiene un alto riesgo de crédito para la entidad.


In [ ]:
## Instale y cargue las siguientes librerias
library(caret)                                              
library(e1071)

In [1]:
## Lectura de datos
link              <-"https://archive.ics.uci.edu/ml/machine-learning-databases/statlog/german/german.data"  

german_raw        <- read.table(link,                                                     # Variable link
                         quote = "\"")                                                    # Separador del encabezado

names(german_raw) <- c( "checking", "duration", "creditHistory",                          # Titulos de las variables
                        "purpose", "credit", "savings", "employment", "installmentRate",
                        "personal", "debtors", "presentResidence", "property", "age",
                        "otherPlans", "housing", "existingBankCredits", "job",
                        "dependents", "telephone", "foreign", "risk")                        

head(german_raw)                                                                          # Primeros datos


checkingdurationcreditHistorypurposecreditsavingsemploymentinstallmentRatepersonaldebtors...propertyageotherPlanshousingexistingBankCreditsjobdependentstelephoneforeignrisk
A11 6 A34 A43 1169A65 A75 4 A93 A101... A12167 A143A1522 A1731 A192A2011
A12 48 A32 A43 5951A61 A73 2 A92 A101... A12122 A143A1521 A1731 A191A2012
A14 12 A34 A46 2096A61 A74 2 A93 A101... A12149 A143A1521 A1722 A191A2011
A11 42 A32 A42 7882A61 A74 2 A93 A103... A12245 A143A1531 A1732 A191A2011
A11 24 A33 A40 4870A61 A73 3 A93 A101... A12453 A143A1532 A1732 A191A2012
A14 36 A32 A46 9055A65 A73 2 A93 A101... A12435 A143A1531 A1722 A192A2011

Se puede observar que existen varias variables categoricas dentro de la base de datos, por lo cual se calculará y estimará variables dummys además de forzar la variable respuesta como 0 para buen crédito y 1 para mal crédito.


In [2]:
## Preparacion de los datos
dummies <- dummyVars(risk ~ .,                               # Generar modelo para arrojar las variables dummy con risk de variable respuesta
                     data = german_raw)                      # Base de datos

german <- data.frame(predict(dummies, newdata = german_raw), # Generar la matriz con los dummy
                     risk = factor((german_raw$risk - 1)))   # Generar la respuesta con el dummy 0 o 1

dim(german)                                                  # Dimensiones de la matriz
head(german)                                                 # Primeras filas


Loading required package: lattice
Loading required package: ggplot2
  1. 1000
  2. 62
checking.A11checking.A12checking.A13checking.A14durationcreditHistory.A30creditHistory.A31creditHistory.A32creditHistory.A33creditHistory.A34...job.A171job.A172job.A173job.A174dependentstelephone.A191telephone.A192foreign.A201foreign.A202risk
1 0 0 0 6 0 0 0 0 1 ...0 0 1 0 1 0 1 1 0 0
0 1 0 0 48 0 0 1 0 0 ...0 0 1 0 1 1 0 1 0 1
0 0 0 1 12 0 0 0 0 1 ...0 1 0 0 2 1 0 1 0 0
1 0 0 0 42 0 0 1 0 0 ...0 0 1 0 2 1 0 1 0 0
1 0 0 0 24 0 0 0 1 0 ...0 0 1 0 2 1 0 1 0 1
0 0 0 1 36 0 0 1 0 0 ...0 1 0 0 2 0 1 1 0 0

Conjunto de datos de entrenamiento y el de validación.


In [2]:
## Partición de la data
set.seed(977)                                               # Semilla aleatoria

german_sampling_vector <- createDataPartition(german$risk,  # Generar vector de posiciones de la partición
                                              p = 0.80,     # Porcentaje de partición
                                              list = FALSE) # Devuelve lista es falso

german_train <- german[german_sampling_vector,]             # Datos de entrenamiento
german_test <- german[-german_sampling_vector,]             # Datos de validacion


Error in eval(expr, envir, enclos): no se pudo encontrar la función "createDataPartition"
Traceback:

Dado que en este ejemplo el hecho que una empresa clasifique favorablemente a un cliente cuando esté se no cuenta con buen perfil credictio es cinco veces más costoso para la entidad ya que está dejando de colocar óptimamente. Para esto se define un vector de costo donde castigue más el error tipo II, es decir, clasificar como 1 al cliente, cuando en realidad es 1.


In [4]:
## Crear el vector de costos
class_weights        <- c(1, 5)          # Vector de costos
names(class_weights) <- c("0", "1")      # Se les asigna nombre de la clase
class_weights                            # Se observa el data.frame


0
1
1
5

Una vez creado el vector de costos, usando la función tune() para entrenar varios modelos svm() y encontrar el que tenga mejor desempeño con ciertos parámetros de búsqueda. Esta optimización arroja que los parámetros óptimos son costo igual a 10 y gamma igual a 0.05.


In [5]:
# Entrenar la SVM
set.seed(2423)                                                                  # Semilla aleatoria

german_radial_tune <- tune(svm,                                                 # Maquinas de soporte vectorial
                           risk ~ .,                                            # Riesgo como variable dependiente
                           data = german_train,                                 # Data de entrenamiento
                           kernel = "radial",                                   # Tipo de Kernel = Radial
                           ranges = list(cost = c(0.01, 0.1, 1, 10, 100),       # Valores de busqueda para el parámetro cost
                                         gamma = c(0.01, 0.05, 0.1, 0.5, 1)),   # Valores de busqueda para el parámetro gamma
                           class.weights = class_weights)                       # Vector de costos para los errores

german_radial_tune$best.parameters                                              # Mejores parámetros del SVM

german_radial_tune$best.performance                                             # Mejor métrica de desempeño


costgamma
910 0.05
0.2675

Se extrae modelo final de la lista que devuelve la función tune(), se realizan las predicciones para comparar desempeño y hace la tabla cruzada de aciertos y errores.


In [6]:
## Modelo final
german_model     <- german_radial_tune$best.model                  # Extraer el mejor modelo

test_predictions <- predict(german_model,                          # Modelo SVM
                            german_test[,1:61])                    # Data de validación

mean(test_predictions == german_test[,62])                         # Ma media del acierto en las predicciones


0.735

In [7]:
## Tabla cruzada
table(predicted = test_predictions,   # Predicciones
      actual = german_test[,62])      # Verdaderos


         actual
predicted   0   1
        0 134  47
        1   6  13

Ejercicio.-- Utilice la base de datos de biodegradación QSAR para predecir si un elemento en particular será biodegradable dadas sus características por ejemplo, cantidad de oxigeno, carbono, nitrogeno así como el numero de atomos pesados en la molecula.

Utilice la librería e1070 en R.

## Libreria library(e1071)

In [ ]:



In [ ]:
## Instale y cargue las siguientes librerias
library(kernlab)

En la siguiente aplicación se tienen las 26 letras en mayuscula del alfabeto en inglés donde se incluyen letras script, cursivas, góticas y letras tipo tipografía (Serif). Se tiene una muestra de 20000 letras y la tarea de la SVM es determinar para cada una de ellas cuál es la letra correspondiente utilizando 16 características con atributos numéricos.

Para clasificar se utilizó un espacio de 45x45 pixeles en los que se identificó los pixeles blancos (fondo de la imagen) y los negros (pixeles utilizados para crear el caracter) y los valores encontrados para cada característica se normalizaron en un rango de 0 a 15.

Características utilizadas:

  1. x.box: Posición horizontal, contando los pixeles desde el borde izquierdo de la imagen
  2. y.box: Posición vertical, contando los pixeles desde el borde inferior de la imagen
  3. Width: El ancho de los pixeles
  4. High: El alto de los pixeles
  5. onpix: El número total de pixeles negros
  6. x.bar: La posición media horizontal de todos los pixeles negros con respecto al centro y dividido por el ancho del espacio
  7. y.bar: La posición media vertical de todos los pixeles negros con respecto al centro y dividido por el alto del espacio
  8. x2bar: El valor medio cuadrado de las distancias horizontales x.bar
  9. y2bar: El valor medio cuadrado de las distancias verticales y.bar
  10. xybar: El producto medio de las distancias verticales y horizontales y.bar - x.bar
  11. x2ybr: Medida de correlación de la varianza de la distancia horizontal con respecto a la vertical (pixeles negros)
  12. xy2br: Medida de correlación de la varianza de la distancia vertical con respecto a la horizontal (pixeles negros)
  13. X.ege: El número promedio de bordes (pixeles negros junto a pixeles blancos) de izquierda a derecha para cada posición vertical del espacio
  14. xegvy: Suma de las posiciones verticales de los bordes encontrados en X.ege
  15. Y.ege: El número promedio de bordes encontrados de abajo a arriba para cada posición horizontal del espacio
  16. yegvx: Suma de las posiciones horizontales de los bordes encontrados en Y.ege

Para objeto de estudio se dividió la muestra en entrenamiento y validación equivalente al 80% de los datos que se tomó para entrenar el algoritmo y el 20% restante utilizado para hacer las validaciones.


In [8]:
## Lectura datos 

letters <- read.csv("data.csv")         # Lectura de la data

str(letters)                            # Estructura de la data


Attaching package: 'kernlab'

The following object is masked from 'package:ggplot2':

    alpha

'data.frame':	20000 obs. of  17 variables:
 $ letter: Factor w/ 26 levels "A","B","C","D",..: 20 9 4 14 7 19 2 1 10 13 ...
 $ x.box : int  2 5 4 7 2 4 4 1 2 11 ...
 $ y.box : int  8 12 11 11 1 11 2 1 2 15 ...
 $ width : int  3 3 6 6 3 5 5 3 4 13 ...
 $ high  : int  5 7 8 6 1 8 4 2 4 9 ...
 $ onpix : int  1 2 6 3 1 3 4 1 2 7 ...
 $ x.bar : int  8 10 10 5 8 8 8 8 10 13 ...
 $ y.bar : int  13 5 6 9 6 8 7 2 6 2 ...
 $ x2bar : int  0 5 2 4 6 6 6 2 2 6 ...
 $ y2bar : int  6 4 6 6 6 9 6 2 6 2 ...
 $ xybar : int  6 13 10 4 6 5 7 8 12 12 ...
 $ x2ybr : int  10 3 3 4 5 6 6 2 4 1 ...
 $ xy2br : int  8 9 7 10 9 6 6 8 8 9 ...
 $ X.ege : int  0 2 3 6 1 0 2 1 1 8 ...
 $ xegvy : int  8 8 7 10 7 8 8 6 6 1 ...
 $ Y.ege : int  0 4 3 2 5 9 7 2 1 1 ...
 $ yegvx : int  8 10 9 8 10 7 10 7 7 8 ...

In [9]:
## Partición de los datos
set.seed(1)                                                 # Semilla aleatoria

trainIndex    <- createDataPartition(letters$letter,        # Generar vector de posiciones de la partición
                                              p = 0.80,     # Porcentaje de partición
                                              list = FALSE) # Devuelve lista es falso

letters_train <- letters[trainIndex,]                       # Datos de entrenamiento
letters_test  <- letters[-trainIndex,]                      # Datos de validacion

In [10]:
# Entrenamiento del modelo SVM 

letter_classifier <- ksvm(letter ~ .,              # Variable respuesta es la letra
                          data = letters_train,    # Datos de entrenamiento
                          kernel = "vanilladot")   # Tipo de kernel lineal

letter_classifier                                  # Visualizamos el svm


 Setting default kernel parameters  
Support Vector Machine object of class "ksvm" 

SV type: C-svc  (classification) 
 parameter : cost C = 1 

Linear (vanilla) kernel function. 

Number of Support Vectors : 7100 

Objective Function Value : -15.6296 -24.1035 -32.6139 -6.9407 -11.2391 -33.8314 -61.6819 -19.9247 -66.8142 -34.664 -17.0182 -34.0862 -38.6445 -54.4292 -14.4757 -37.9456 -35.478 -16.676 -15.1289 -36.4191 -31.5295 -8.4011 -12.8527 -36.4246 -15.1811 -9.6631 -166.3312 -46.5484 -71.3353 -118.3936 -157.8402 -57.19 -43.1118 -76.2999 -26.5399 -20.3503 -22.4319 -36.8507 -44.8683 -122.0564 -198.2916 -203.692 -22.4506 -11.0084 -50.5033 -10.5674 -48.8043 -8.2428 -18.5451 -12.3587 -119.7663 -25.9019 -252.9595 -79.7413 -9.8543 -4.5354 -147.6783 -81.7189 -17.5327 -14.3599 -79.3617 -14.1883 -30.1773 -19.4426 -24.3816 -28.3644 -57.4585 -10.6397 -5.156 -14.0018 -4.6683 -4.5734 -7.8094 -39.5242 -52.733 -191.0638 -48.8511 -49.8955 -48.38 -17.3329 -17.9257 -87.0149 -113.984 -41.9839 -37.4487 -128.0483 -31.6999 -30.5003 -40.2004 -17.6703 -5.4254 -40.5818 -10.127 -19.5897 -61.457 -164.7185 -53.9735 -45.1218 -32.7226 -78.4436 -128.7579 -7.7926 -4.4973 -13.0046 -28.0001 -144.3059 -52.6895 -185.1087 -101.1071 -10.2861 -15.4408 -3.0366 -70.9248 -8.4659 -96.7448 -51.9271 -97.0994 -72.4081 -66.078 -25.2059 -13.516 -7.7437 -27.2402 -14.3216 -231.8682 -32.0182 -22.9489 -117.0789 -127.9985 -10.6071 -36.2559 -6.661 -55.0129 -61.5703 -32.367 -222.5596 -33.9807 -17.1567 -135.9669 -162.8287 -37.1961 -23.0355 -136.2965 -79.2474 -358.5877 -139.8925 -158.2267 -36.7762 -31.6717 -54.6171 -23.7241 -47.2747 -6.5682 -9.6633 -31.2075 -59.5595 -200.2849 -53.1097 -76.7927 -149.1051 -608.9825 -120.1413 -139.2066 -322.6822 -33.3301 -68.2861 -168.2828 -109.8055 -36.4133 -65.0367 -48.9212 -8.2925 -211.6559 -13.3675 -40.3996 -1.6783 -6.4708 -15.7039 -24.2792 -63.3143 -20.6278 -181.5077 -21.7433 -4.8287 -4.4453 -0.8414 -121.2993 -9.2322 -72.8311 -19.4974 -12.4608 -4.1944 -15.6757 -26.735 -20.5946 -75.2172 -24.842 -95.7836 -14.3627 -10.3159 -6.1829 -1.8683 -82.2801 -7.4171 -107.8906 -111.06 -36.6146 -23.5303 -60.0458 -21.498 -56.0182 -268.3554 -44.4758 -49.8371 -34.6814 -20.3505 -9.3535 -119.9536 -6.3201 -5.918 -9.3876 -12.1083 -22.369 -20.5086 -147.5779 -36.481 -95.2062 -30.2022 -15.2242 -10.528 -3.6662 -101.3321 -7.4074 -14.2149 -66.5613 -90.5667 -12.1291 -11.1699 -46.3752 -2.1586 -6.5785 -72.8206 -32.0065 -118.0653 -3.5576 -7.1291 -1.0498 -93.0395 -20.0544 -9.466 -46.5849 -3.183 -17.4104 -69.1557 -43.2736 -56.1116 -5.2805 -20.35 -2.2441 -72.1423 -114.873 -105.8891 -22.6937 -18.9277 -59.5579 -38.4504 -65.6126 -19.5407 -5.8265 -3.8988 -59.7491 -33.3004 -52.2709 -30.6458 -9.654 -46.3303 -10.3099 -19.1255 -64.0671 -4.8174 -65.0977 -230.4235 -16.5851 -12.409 -17.5244 -7.3137 -67.7321 -14.6215 -40.225 -50.1392 -28.3776 -16.4511 -42.4395 -15.3091 -56.8525 -4.7905 -6.1346 -75.1794 -3.3871 -6.694 -1.1129 -134.6156 -26.0153 -372.5829 -30.8361 -29.3164 -4.5656 -77.3432 -132.6668 -77.2841 -26.5899 -39.3386 -10.9058 -24.4309 -1.9996 -60.0088 -7.7833 -158.8157 -1.8546 -1.8262 -10.7389 -0.5096 -29.2206 -32.8548 -6.1986 
Training error : 0.131776 

In [11]:
##Predicción y evaluacion con el modelo

letter_predictions <- predict(letter_classifier,      # Clasificador SVM
                              letters_test)           # Datos de validación

mean(letter_predictions == letters_test$letter)       # Media de los aciertos del modelo.


0.859327983951856

In [12]:
# Tabla cruzada

table(letter_predictions,    # Predicciones
      letters_test$letter)   # Reales


                  
letter_predictions   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
                 A 149   2   0   1   0   0   0   0   0   2   0   0   1   2   5
                 B   0 139   0   3   0   1   0   2   1   0   0   1   4   0   0
                 C   0   0 133   0   1   1   6   1   0   0   1   0   0   0   2
                 D   0   0   0 150   0   1   5  11   3   1   1   2   0   4   4
                 E   0   2   3   0 138   2   0   0   0   0   2   6   0   0   0
                 F   0   0   0   1   0 135   0   2   3   1   0   0   0   1   0
                 G   0   1   3   0   5   0 122   1   0   0   4   4   0   0   1
                 H   0   3   0   1   1   0   1  98   0   1   1   1   0   3  13
                 I   0   0   0   0   0   0   0   0 131   8   0   0   0   0   0
                 J   2   0   0   0   0   0   0   4   1 130   0   0   0   0   0
                 K   1   0   5   0   1   1   2   8   0   0 126   0   0   1   0
                 L   1   0   0   0   0   0   1   1   0   0   0 131   0   0   0
                 M   1   0   0   0   0   0   3   0   0   0   0   0 142   1   0
                 N   0   0   0   2   0   0   0   1   0   1   0   0   0 139   0
                 O   0   0   2   2   0   0   0   5   0   0   0   0   2   2 115
                 P   0   1   0   0   0   4   0   0   0   0   0   0   0   1   1
                 Q   0   0   0   0   2   0   2   1   0   0   0   4   0   0   1
                 R   0   4   0   1   1   0   3   8   0   0   6   0   4   1   2
                 S   1   0   0   0   1   5   5   0   8   5   1   2   0   0   0
                 T   0   0   1   0   0   5   0   0   0   0   0   0   0   0   1
                 U   0   0   0   0   0   0   1   2   0   0   0   0   2   0   1
                 V   0   1   0   0   0   0   2   1   0   0   0   0   0   0   0
                 W   0   0   0   0   0   0   1   0   0   0   1   0   3   1   4
                 X   0   0   0   0   2   0   0   0   2   0   4   1   0   0   0
                 Y   2   0   0   0   0   0   0   0   0   0   0   0   0   0   0
                 Z   0   0   0   0   1   0   0   0   2   0   0   0   0   0   0
                  
letter_predictions   P   Q   R   S   T   U   V   W   X   Y   Z
                 A   0   6   4   2   0   1   1   1   0   0   0
                 B   0   2   2   9   0   0   4   0   1   0   0
                 C   0   0   0   0   0   1   0   0   0   0   0
                 D   0   1   1   0   1   0   0   0   0   0   1
                 E   2   1   0   5   2   0   0   0   3   0   0
                 F  12   0   0  10   1   0   0   0   1   3   1
                 G   2   3   1   3   1   0   0   0   1   0   0
                 H   1   0   2   0   2   2   2   1   1   1   0
                 I   0   0   0   6   0   0   0   0   5   0   0
                 J   1   1   0   0   0   0   0   0   0   0   4
                 K   3   0   7   0   0   0   0   0   6   0   0
                 L   0   0   1   3   0   0   0   0   3   0   1
                 M   0   0   0   0   0   5   0   1   0   0   0
                 N   0   0   4   0   0   0   0   1   0   0   0
                 O   4   2   3   0   0   1   0   0   1   0   0
                 P 134   0   0   1   2   0   1   0   0   1   0
                 Q   0 127   0   3   0   0   0   0   0   3   2
                 R   0   0 124   2   0   0   0   0   2   0   0
                 S   0  11   0  98   4   0   0   0   0   0  13
                 T   0   0   1   1 139   0   0   0   1   4   0
                 U   0   0   0   0   1 150   0   0   2   0   0
                 V   1   1   0   0   0   0 135   1   0   2   0
                 W   0   1   1   0   0   2   5 145   0   0   0
                 X   0   0   0   0   0   0   0   0 130   0   0
                 Y   0   0   0   1   3   0   4   0   0 143   0
                 Z   0   0   0   5   3   0   0   0   0   0 124

In [13]:
# Calculo de aciertos y  errores

aciertos <- letter_predictions == letters_test$letter    # Vector de comparacion lógica

table(aciertos)                                          # Mostrar tabla de aciertos

prop.table(table(aciertos))                              # Mostrar tabla de aciertos en porcentaje


aciertos
FALSE  TRUE 
  561  3427 
aciertos
   FALSE     TRUE 
0.140672 0.859328 

In [15]:
# Realización del mismo modelo pero con base radial y comparación de resultados

letter_classifierEV  <- ksvm(letter ~ ., data = letters_train,kernel = "rbfdot")
letter_predictionsEV <- predict(letter_classifierEV, letters_test)
aciertosEV           <- letter_predictionsEV == letters_test$letter

table(aciertosEV)
prop.table(table(aciertosEV))


aciertosEV
FALSE  TRUE 
  253  3735 
aciertosEV
     FALSE       TRUE 
0.06344032 0.93655968 

In [20]:
# Realización del mismo modelo pero con base sigmoidea y comparacion resultados

letter_classifierEV2  <- ksvm(letter ~ ., data = letters_train,kernel = "tanhdot")
letter_predictionsEV2 <- predict(letter_classifierEV2, letters_test)
aciertosEV2           <- letter_predictionsEV2 == letters_test$letter

table(aciertosEV2)
prop.table(table(aciertosEV2))


 Setting default kernel parameters  
aciertosEV2
FALSE  TRUE 
 3634   354 
aciertosEV2
    FALSE      TRUE 
0.9112337 0.0887663 

Ejercicio.-- Se busca identificar si la voz transmitida por una persona es de hombre o mujer, el conjunto de datos tiene analisis y caracteristicas de onda que tiene la voz transmitida. Utilice las caracteristicas deel siguiente conjunto de datos para realizar la predicción si es hombre o mujer

Datos


In [ ]: