Archivo de la etiqueta: knn

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

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

KNN con SAS. Mejorando K-Means

Imagen de previsualización de YouTube

La clasificación por k vecinos más cercanos es EL MÉTODO supervisado no paramétrico. El KNN, si empleamos las siglas en inglés, clasifica las observaciones en función de su probabilidad de pertenecer a uno u otro grupo, en el video que encabeza la entrada queda muy bien explicado. El caso es que tenemos la posibilidad de realizar esta clasificación con SAS STAT y el PROC DISCRIM y me parece interesante dedicarle unas líneas. Hace años ya hablamos de segmentación con SAS  y vamos a emplear los mismos datos para ilustrar esta entrada. Primero generamos un conjunto de datos con datos simulados de 3 esferas que clasificamos en 3 grupos:

data pelota;
do i = 1 to 1000;
a=0; b=5; x = a+(b-a)*ranuni(34);
a=0; b=5; y = a+(b-a)*ranuni(14);
grupo=1;
distancia = sqrt(((x-2.5)**2)+((y-2.5)**2));
if distancia < 2.5 then output;
end;
run;

data pelota1;
set pelota;
grupo=1;
run;

data pelota2;
set pelota;
x = x+4.5;
grupo=2;
run;

data pelota3;
set pelota;
x = x+2.5;
y = y+3.5;
grupo=3;
run;

data datos;
set pelota1 pelota2 pelota3;
run;

proc gplot data=datos;
	plot y * x = grupo; 
run;quit;

KNN_SAS1

Si realizamos un análisis mediante k-means sin asignar centroides obtenemos esta clasificación Sigue leyendo KNN con SAS. Mejorando K-Means

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.