Archivo de la etiqueta: SVM

Machine learnig. Análisis gráfico del funcionamiento de algunos algoritmos de clasificacion

Letra_O

De forma gráfica os voy a presentar algunas técnicas de clasificación supervisada de las más empleadas en Machine Learning y podremos ver cómo se comportan de forma gráfica en el plano. Como siempre prefiero ilustrarlo a entrar en temas teóricos y para esta tarea se me ha ocurrido pintar una letra O y comenzar a trabajar con Python, así de simple. Lo primero es tener los datos, evidentemente serán puntos aleatorios en el plano donde pintamos una variable dependiente con forma de O:

 
import numpy as np
import pandas as pd
from pylab import *

largo = 10000

df = pd.DataFrame(np.random.uniform(0,100,size=(largo, 2)), columns=list('XY'))

dependiente1 = np.where(((df.X-50)**2/20**2 + (df.Y-50)**2/40**2>1) ,1,0)
dependiente2 = np.where(((df.X-50)**2/30**2 + (df.Y-50)**2/50**2>1) ,1,0)
dependiente = dependiente1 - dependiente2

plt.scatter(df.X, df.Y,c=dependiente,marker=".")
show()

Se crea un data frame con 10.000 registros y dos variables aleatorias con valores entre 0 y 100 X e Y. Soy consciente de la forma en la que se obtiene la variable dependiente, no entiendo como funciona np.where con condiciones múltiples y por ello toman valor 1 aquellas observaciones del plano que están entre las dos eclipses que pinto dentro del plano. Con todo esto tenemos unos datos como ilustran el scatter plot con el que se inicia esta entrada. El siguiente paso será dividir los datos en validación y test mediante train_test_split:

 
#Dividimos en validacion y test
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(df,dependiente,stratify=dependiente,
test_size = 0.5, random_state=123)

Ahora vamos a estudiar gráficamente como se comportan algunos algoritmos de machine learning para clasificar la letra O en el espacio. Empezamos por los árboles de decisión Sigue leyendo Machine learnig. Análisis gráfico del funcionamiento de algunos algoritmos de clasificacion

El parámetro gamma, el coste, la complejidad de un SVM

letra_o_svm_r

Cuando clasificamos datos con SVM es necesario fijar un margen de separación entre observaciones, si no fijamos este margen nuestro modelo sería tan bueno tan bueno que sólo serviría para esos datos, estaría sobrestimando y eso es malo. El coste C y el gamma son los dos parámetros con los que contamos en los SVM. El parámetro C es el peso que le

damos a cada observación a la hora de clasificar un mayor coste implicaría un mayor peso de una observación y el SVM sería más estricto (este link aclara mejor las cosas). Si tuvieramos un modelo que clasificara observaciones en el plano como una letra O podemos ver como se modifica la estimación en esta secuencia en la que se ha modificado el parámetro C:

r_svm_2

Sigue leyendo El parámetro gamma, el coste, la complejidad de un SVM

Resolución del juego de modelos con R

Hace mucho planteé un juego de identificación de modelos con R y ya se me había olvidado daros la solución. Pensando en el Grupo de Usuarios de R y en hacer algo parecido en una presentación recordé que había que solucionar el ejercicio. Lo primero es la creación de los datos, se me ocurrió una función sencilla y una nube de puntos alrededor de ella:

#Variable independiente
indep = runif(500,100,500)
#Función para crear la variable dependiente
foo = function(x){ mean(x)*(1-sin(-0.006042*x))
}
dep = sapply(indep,foo)

dep=dep+(runif(length(dep),-100,100))
datos = data.frame(cbind(indep,dep))
plot(datos)

juego_modelos1

Seleccionamos los datos de entrenamiento y test:

#Datos de entrenamiento y test
indices = sample(1:length(dep),length(dep)/2) 
entrenamiento = datos[indices,]
test = datos[-indices,]

El más sencillo de todos era el caso de la regresión lineal y fue el que puse de ejemplo:

#REgresión lineal
modelo.1=lm(dep ~ indep,entrenamiento)
plot(test)
points(test$indep,predict(modelo.1,test),col="red")

juego_modelos2

Una línea que pasa por la media de la nube de puntos. Otro de los casos menos complicados es el árbol de regresión Sigue leyendo Resolución del juego de modelos con R

Juego de modelos de regresión con R

Rplot

Os propongo un juego con R. El juego parte de unos datos aleatorios que he generado con R (los que veis arriba) que dividimos en entrenamiento y test. Sobre el conjunto de datos de entrenamiento he realizado varios modelos y valoro las predicciones gráficamente sobre los datos de test. El juego consiste en asociar cada resultado gráfico de test a cada código de R correspondiente y justificar brevemente la respuesta.

Los gráficos de los datos de test son:

Figura A:
Rplot01

Figura B:
Rplot02

Figura C:
Rplot03

Figura D:
Rplot05

Figura E:
Rplot07

Figura F:
Rplot08

Figura G:
Rplot06

Los códigos R que tenéis que asociar a cada figura son:

Código 1: Red neuronal con una sólo capa y 2 nodos:
mejor.red {
mejor.rss for(i in 1:50){
modelo.rn linout=T, trace=F,decay=0.1)
if(modelo.rn$value < mejor.rss){
mejor.modelo mejor.rss

return(mejor.modelo)
}}
}

mejor.red(2)

Código 2: Regresión lineal
lm(dep ~ indep,entrenamiento)

Código 3: Máquina de vector de soporte con un margen muy alto
svm(dep ~ indep ,entrenamiento, method="C-classification",
kernel="radial",cost=100,gamma=100)

Código 4: Árbol de regresión
rpart(dep~indep,entrenamiento)

Código 5: Regresión LOESS
loess (dep ~ indep, data = entrenamiento)

Código 6: Máquina de vector de soporte con un margen bajo
svm(dep ~ indep ,entrenamiento, method="C-classification",
kernel="radial",cost=10,gamma=10)

Código 7: K vecinos más cercanos K-nn
train.kknn(dep ~ indep, data = entrenamiento,
k = 4, kernel = c("rectangular"))

Por ejemplo la figura A irá con el código 2 porque se trata de una estimación lineal. Y ahora os toca a vosotros asociar figuras a modelos de R.

Solventamos los peligros del análisis cluster con SVM

Retomamos un asunto tratado en días anteriores, los peligros de realizar un análisis de agrupamiento basado en las distancias entre observaciones. ¿Cómo podemos evitar este problema? Empleando máquinas de vectores de soporte, traducción de Support Vector Machines (SVM). Esta técnica de clasificación de la que ya hablamos en otra entrada nos permite separar observaciones en base la creación de hiperplanos que las separan. Una función kernel será la que nos permita crear estos hiperplanos, en el caso que nos ocupa tenemos sólo dos variables, necesitamos crear líneas de separación entre observaciones. En la red tenéis una gran cantidad de artículos sobre estas técnicas.

Para ilustrar como funciona retomamos el ejemplo anterior:


#GRUPO 1
x = runif(500,70,90)
y = runif(500,70,90)
grupo1 = data.frame(cbind(x,y))
grupo1$grupo = 1


#GRUPO 2
x = runif(1000,10,40)
y = runif(1000,10,40)
grupo2 = data.frame(cbind(x,y))
grupo2$grupo = 2


#GRUPO 3
x = runif(3000,0,100)
y = runif(3000,0,100)
grupo3.1 = data.frame(cbind(x,y))
grupo3.1$separacion=(x+y)
grupo3.1 = subset(grupo3.1,separacion>=80 & separacion <=140,select=-separacion)
grupo3.1 = subset(grupo3.1,y>0)
grupo3.1$grupo = 3


#UNIMOS TODOS LOS GRUPOS
total=rbind(grupo1,grupo2,grupo3.1)
plot(total$x,total$y,col=c(1,2,3)[total$grupo])

El paquete de R que vamos a emplear es kernlab, Sigue leyendo Solventamos los peligros del análisis cluster con SVM

Monográfico. Clasificación con SVM en R

Las máquinas de vectores de soporte, Support Vector Machines, SVM a partir de ahora, son un conjunto de técnicas estadísticas que nos permiten clasificar una población en función de la partición en subespacios de múltiples variables. Parte de la idea de dividir de forma lineal un conjunto de múltiples dimensiones. Creamos muchos hiperplanos que nos dividen las observaciones. Es una técnica que está ganando popularidad y que por supuesto podemos realizarla con R. Para ello tenemos algunos paquetes específicos como kvm, svmlight y el e1071. Este último es al que pretendo acercarme hoy.

El SVM es un algoritmo que, a partir del producto escalar de vos vectores multidimensionales, busca hiperplanos que separen los grupos. La función que define este producto escalar la denominaremos kernel y puede ser lineal, polinómica, radial o sigmoidal. Para clasificación el SVM se plantea como un problema de programación lineal en el que buscamos maximizar la distancia entre categorías sujeto a un coste y a un número óptimo de patrones de entrenamiento. Para entender mejor su funcionamiento trabajamos un ejemplo bidimensional:

#Simulación de un conjunto de datos bivariante
x=c(rnorm(500,1000,100),rnorm(500,2000,200),rnorm(500,3000,400))
y=c(abs(rnorm(500,50,25)),rnorm(500,200,50),rnorm(500,100,30))
grupo=as.factor(c(rep(1,500),rep(2,500),rep(3,500)))
datos=data.frame(x,y,grupo)

Tenemos un data frame con 3 variables, Sigue leyendo Monográfico. Clasificación con SVM en R