Split-Apply-Combine- Parte 3

A terminar el ejemplo!!!

En la entrada Split-Apply-Combine parte 2, mostré unos ejemplos sencillos de como usar librerías de R y de Python para manipular los datos y obtener otro tipo de relaciones tales que de manera directa explorando la información sin transformarla no pueden ser detectadas dichas relaciones.

La relevancia de transformar la información y encontrar nuevas relaciones es parte fundamental para un buen análisis, esto requiere un poco de ensayo y error, de jugar con los datos y el tipo de datos, de buscar conexiones para tratar de descubrir alguna relación. Pero lo descubierto no implica que las “relaciones”  determinan algo relevantes, lo que en teoría uno debe de hacer es validar estos supuesto descubrimientos por medio de alguna técnicas estadística  para probar que la hipótesis o descubrimiento son por lo menos estadísticamente ciertos.

Lo que he compartido en las dos entradas previas(Parte 1 y Parte 2) es en general se puede considerar solo como exploración y diagnóstico, la idea de Split-Apply-Combine( SAC) es dividir , aplicar y combinar los resultados y por medio de esto obtener información que relevante.

El ejemplo en la referencia [1] da una idea de la metodología de manera fácil, por lo cual replico uno de los ejemplo para incentivar a revisar la referencia y observar como se aplica la metodología. El código que uso no es el mismo que comparten en dicho artículo, pero se obtienen los mismo resultados.

Las etapas son las siguientes:

  1. Se cargan los datos y se analiza la muestra de datos para un solo jugador( Split).
  2. Se construye un modelo el cual se aplica a cada uno de los jugadores(Apply).
  3. Se eligen dos elementos obtenidos del modelo para analizar el comportamiento de los datos en general y se muestran algunas gráficas para expresar los resultados (Combine).

Los datos corresponden a la base de datos baseball que se puede obtener desde la librería plyr.

#Split
#Se cargan las librerías
library(dplyr)
library(reshape)
library(plyr)
library(ggplot2)

#Se cargan los datos y se revisan que no cuente con NA
data("baseball")
head("baseball")
sum(is.na("baseball"))

#Se elige solo los datos correspondiente a baberuth

baberuth=filter(baseball,id=="ruthba01")
head(baberuth)
dim(baberuth)
#str(baberuth) se puede usar este comando para explorar que tipo de variables se tienen en los datos.

#Se agregan un par de variables para analizar lso años jugando y el número de carreras por bateos y el número de ocasiones que pasó a batear.

L=mutate(baberuth,cyear=year-min(year)+1,indice=rbi/ab)

#Se analiza la relación entre las dos nuevas variables

ggplot(L,aes(x=cyear,y=indice))+geom_line(col="red")+ggtitle('Relación entre datos')+
 xlab('Índice')+ylab('Ciclo de años')+geom_smooth(method='lm')

SAC_baseball

El código anterior lo que hace es elegir una muestra de datos y analizar la relación entre un par de variables que se construyen de las variables existentes, para ver la información de la descripción de la base se puede consultar por medio del comando ?—nombre de la base—.

La gráfica muestra una relación  y se hace un ajuste lineal como modelo para estudiar dicha relación. Esto no necesariamente es buen buen modelo, pero como ejemplo resulta fácil de entender y de aplicar.

#Apply
#Se construye el modelo 

model<-function(df){lm(rbi/ab~cyear,data=df)}

#Seleccionan los datos que permitan aplicar el modelo
L2=filter(baseball,ab>25)
#Se agregan las variables para toda la base

L3=mutate(L2,cyear=year-min(year)+1,indice=rbi/ab)
#Se aplica el modelo 
bmodels<-dlply(L3,.(id),model)
#Se observan el data.frame obtenido después de aplicar el modelo
head(bmodels)

Lo que se hace en el código anterior es lo siguiente, ya que se definen las nuevas variables y se analiza su relación se procede agregar esas variables para toda la base y se define una función que es el modelo aplicar a todos los datos, posteriormente se elige de la base aquellos elementos que permiten que el modelo se aplique. Si se aplica el modelo a toda la base sin revisar los valores de la variable ab, se obtendrá un error, esto debido al cálculo del modelo sobre los datos.

Se aplica el modelo por medio de la función dlplyr, el “dl” del comando indica que manda un data.frame para obtener una lista.Por último observo como son los datos por medio de head().

La parte de combinar los resultados implica usar algún estadístico para analizar los modelos, en la primera gráfica se observa que no es un buen modelo, entonces haciendo los ajustes lineales se puede extraer la r cuadrada que indica que tan bueno es el modelo de manera descriptiva. Ya que si la r cuadrada es muy alta indicaría que la relación es muy lineal y que el modelo es hasta cierto punto bueno, pero si es baja indica que no lo es.

Por lo tanto lo que hago, siguiendo al artículo o referencia [1], es extraer tanto la  r cuadrada de cada modelo, como la intercepto de la recta. Sabiendo un poco de geometría, se debe de tener en cuanta que la pendiente de la recta está relacionada con la correlación de las dos variables analizadas y por lo tanto con el valor de la r cuadrada.

#Combine

# Se define la función para extraer la R cuadrada de los modelos

rsq<-function(x)summary(x)$r.squared
#Se aplica el modelo a la lista y se regresa un data.frame
bcoef<-ldply(bmodels,function(x)c(coef(x),rcuadrada=rsq(x)))
head(bcoef)
#Se cambian nombres a las columnas
names(bcoef)[2:3]<-c("intercept","slope")
head(bcoef)

#Se revisa el histograma de los datos
ggplot(bcoef,aes(rcuadrada))+geom_histogram(col="red")+ggtitle('Histograma de R cuadradas')+
 xlab('Valores de R cuadrada')+ylab('Conteo')

#Se asigna el valor de las variables a toda la base
baseballcoef<-merge(baseball,bcoef,by="id")
head(baseballcoef)
dim(baseballcoef)

#Grafica 1
d1=qplot(data=baseballcoef,x=slope,y=intercept)+xlim(-0.05,0.05)+ylim(-2,2)
d1+geom_point(alpha=0.05,aes(size=rcuadrada))+ggtitle('Cruce de pendiente vs interceptos')+
 xlab('Pendientes')+ylab('Interceptos')+geom_hline(yintercept=0,col="red")+geom_vline(xintercept=0,col="red")

#Gráfica 2
d2=qplot(data=baseballcoef,x=slope,y=intercept)+xlim(-0.010,0.010)+ylim(-.25,.25)
d2+geom_point(alpha=0.05,aes(size=rcuadrada))+ggtitle('Cruce de pendiente vs interceptos')+
 xlab('Pendientes')+ylab('Interceptos')+geom_hline(yintercept=0,col="red")+geom_vline(xintercept=0,col="red")

Lo que hace todo el código anterior es extraer un estadístico que permita saber si es bueno el modelo, analizar gráficamente los datos. Por último analizar la posible relación gráfica entre los estadístico extraídos. Las gráficas son las siguientes:

Hist_baseball

SAC3SAC3_2

Entonces en resumen lo que se hizo, aun que fue replicar los cálculos del artículo trato de agregar algún modo distinto de obtenerlo con el código. La técnica al final es clara con este ejemplo, cada paso puede requerir más detalle y exploración sobre la información, pero en resumen la primera de estas últimas gráficas muestra que el modelo es malo, lo cual reta a buscar un mejor modelo para analizar los datos y otros estadísticos.

Ejemplo 2

Retomando los ejemplos de los datos de vuelos desde tres aeropuertos cercanos a la ciudad de NY, tenemos que que la base de datos es considerablemente más grande que el ejemplo anterior. Lo que trato de evitar con el ejemplo es hacer confuso como aplicar la técncias de SAC, así que lo que hago en un primer momento es algo similar al ejemplo anterior.

Tomo los datos, reviso el indicador “tailnum” para elegir los aviones que tienen el mismo número en la cola del avión y después analizo un par de variables que no son tan relevantes pero que permiten hacer un modelo sobre los tiempos de retraso al despegar y al arribar. Lo único que cambia es que la regresión o el modelo lineal es múltiple y es un buen modelo, lo cual no es de sorprender ya que si un avión se retrasa al despegar se espera que también se retrase al arribar.

Las etapas son las siguientes:

  1. Se cargan los datos y se analiza la muestra de datos para un solo registro “tailnum”, de hecho elijo el que aparece más ocasiones en los datos (Split).
  2. Se construye un modelo el cual se aplica a cada uno de los registros (Apply).
  3. Se eligen dos elementos obtenidos del modelo para analizar el comportamiento de los datos en general y se muestran algunas gráficas para expresar los resultados (Combine).
#Split

library(nycflights13)
library(plyr)
library(dplyr)
library(reshape2)
library(ggplot2)

data("flights")
dim(flights)
#[1] 336776 16

#missing value
sum(is.na(flights))
#[1] 60593
flights2=na.omit(flights)

head(flights2,10)
str(flights2)
dim(flights2)
#[1] 327346 16

#Seleccionamos el que tiene mayor número de apariciones

sort(summary(factor(flights2$tailnum)),decreasing = TRUE)

N725MQ=filter(flights2,tailnum=="N725MQ")

head(N725MQ)
dim(N725MQ)

#Agrego dos variables
N725MQ_2=mutate(N725MQ,dep_d=dep_delay-min(dep_delay)+1,arr_d=arr_delay-min(arr_delay)+1)

#Gráfica de cruce entre variables por mes
ggplot(data=N725MQ_2,aes(y=dep_d, x=arr_d))+geom_point(aes(colour=factor(month)))+geom_smooth(method='lm')

La gráfica que se obtiene es la siguiente:

fligths3_cruce

La gráfica muestra que existe una relación linea entre las dos variables que se definieron, pero esto además agrego una revisión de como se comportan los datos con respecto a los meses de vuelo y si bien no es claro una relación muestra que el comportamiento no es del todo aleatorio, en ciertos meses se presenta un retraso mayor que en otros. Un modo de ver esto es correr la regresión lineal solo para los datos de este registro de tailnum y revisar si es significativa, en este caso R cuadrada marca un 0.8 lo cual es bastante bueno.

Entonces lo que ahora hago es aplicar este modelo a los datos de toda la tabla.

#Apply
#Definición del modelo
modelo<-function(df){lm(dep_d~arr_d+month,data=df)}

#Procesamiento de toda la base
flight3=mutate(flights2,dep_d=dep_delay-min(dep_delay)+1,arr_d=arr_delay-min(arr_delay)+1)

#Aplicación del modelo
fmodelo<-dlply(flight3,.(tailnum),modelo)
head(fmodelo)
str(fmodelo)

#Extracción del estadístico
rsq<-function(x){summary(x)$r.squared}

fcoef<-ldply(fmodelo,function(x)c(coef(x),rcuadrada=rsq(x)))

#Extracción de datos del modelo
fcoef=ldply(fmodelo,function(x)c(coef(x),rcuadrada=rsq(x)))
head(fcoef)
names(fcoef)[2]=c("Intercepto")

#Histograma del modelo
ggplot(fcoef,aes(rcuadrada))+geom_histogram(col="red")+ggtitle('Histograma de R cuadradas')+
 xlab('Valores de R cuadrada')+ylab('Conteo')

La gráfica que se obtiene es la siguiente:

flights_hist

El histograma muestra que la regresión es un buen modelo para analizar todos los datos, y que se comporta bien la r cuadrada, es decir que es próxima a 1, lo único extraño es el conjunto de valores que tienen un valor pequeño  o cercano a cero, esto indica que debe de revisarse el para algunos registros. Esto de puede hacer de modo fácil usando la función filter().

 Lo último es combinar la información con la tabla original y analizar las relaciones entre los valores estimados del modelo. Estos datos permiten hacer otra exploración de la información y de cierto modo los datos fueron enriquecidos.

#Combine
#Unión de las dos tablas
flightscoef<-merge(flights2,fcoef,by="tailnum")
head(flightscoef)
dim(flightscoef)
str(flightscoef)

#Gráficas de resultados por aeropuerto de origen
ggplot(flightscoef,aes(rcuadrada))+geom_histogram(color="black",aes(fill=origin))+ggtitle('Histograma de R cuadradas')+
 xlab('Valores de R cuadrada')+ylab('Conteo')

#Gráficas de coeficientes

d1=qplot(data=flightscoef,x=month.y,y=Intercepto)
d1+geom_point(alpha=0.05,aes(size=rcuadrada))+ggtitle('Cruce de pendiente vs interceptos')+
 xlab('Pendientes de Meses')+ylab('Interceptos')+geom_hline(yintercept=0,col="red")+geom_vline(xintercept=0,col="red")

d2=qplot(data=flightscoef,x=arr_d,y=Intercepto)
d2+geom_point(alpha=0.05,aes(size=rcuadrada))+ggtitle('Cruce de pendiente vs interceptos')+
 xlab('Pendientes de Meses')+ylab('Interceptos')+geom_hline(yintercept=0,col="red")+geom_vline(xintercept=0,col="red")

Las gráficas que se obtienen son las siguientes:

flights_hist_origin

flights1_082015Flights2_082015

Lo que se observa es que efectivamente el comportamiento del modelo por aeropuerto de origen es similar, lo cual se ve en el histograma con diferentes colores por origen. Las otras dos gráficas muestran la primera la relación entre los coeficientes de la regresión, entre los cuales se aprecia cuales tienen cierto comportamiento, para profundizar en el análisis de estos coeficientes se requiere un poco más de detalle, pero en general la idea de aplicar SAC es también reflejada en este ejemplo.

Ultimo ejemplo.

En la entrada Split-Apply-Combine Parte 2 mostré que los datos podían ser analizados como series de tiempo después de una serie de transformación sobre la información, lo que trato de hacer con el ejemplo es aplicar un modelo de series de tiempo a los datos por medio de la metodología SAC.

Lo primero que hago es procesar la información y explorar solo los datos como series de tiempo de un solo registro de “tailnum”, esto se muestra gráficamente que tienen cierto comportamiento, el registro elegido es el que cuenta con mayor cantidad de datos o líneas en la base, el cual es “N725MQ”.

El código para explorar la información y los datos es el siguiente:

#Ejemplo de Series de tiempo
#Cargo las librerías requeridas
library(nycflights13)
library(plyr)
library(dplyr)
library(reshape2)
library(ggplot2)

#Revisión de los datos

data("flights")
dim(flights)
#[1] 336776 16

#missing value
sum(is.na(flights))
#[1] 60593
flights2=na.omit(flights)

head(flights2,10)
str(flights2)
dim(flights2)
#[1] 327346 16

#Seleccionamos el que tiene mayor número de apariciones
sort(summary(factor(flights2$tailnum,labels=levels)),decreasing = TRUE)

#Elijo el registro con mayor cantidad de líneas es "N725MQ"

N725MQ=filter(flights2,tailnum=="N725MQ")
head(N725MQ)
dim(N725MQ)

N725MQ_1=mutate(N725MQ,fechas=as.Date(paste(month,day,year,sep="/"),"%m/%d/%Y"))

Dat_1<-N725MQ_1%>%
 group_by(fechas,tailnum)%>%
 summarise(dis_m=mean(distance))

head(Dat_1)
qplot(data=Dat_1,x=fechas,y=dis_m,geom=c("line","point"))+geom_point(colour="red")+scale_x_date()+ggtitle('Seríe de N725MQ')

La gráfica que se obtiene es la siguiente:

SAC_timeseries

Estos datos se pueden tratar como una serie de tiempo, burdamente elijo un modelo para esta seria, el método que elijo es  ets (exponential smoothing), la intención es aplicar el modelo y tomar el estadístico RMSE, el cual la raíz de la media de los errores cuadrados y a grandes rasgos representa la desviación estándar entre los valores predichos y los estimados.

El código para aplicar el modelo a esta serie y obtener el RMSE, es el siguiente:

#Código
#Modelo
TS=ts(Dat_1$dis_m)
S=ets(TS)
S1=summary(S)
#El valor de RMSE es el siguente
S1[2]
201.2376
plot(TS, main="Serie de N725MQ para el año 2013",col="blue", ylab="Valores de la serie", xlab="Tiempo")
lines(S$fitted,col="2")

SerieN725MQ_1

Ahora el trabajo es elegir un cierto grupo de valores de tailnum que permitan aplicar el modelo y explorar como se comporta el estadístico y ver el comportamiento de los parámetros alpha y beta del modelo para cada un de los registros elegidos. Entonces se requiere que se transformen los datos, que se seleccionen cierto grupo de datos, se aplica un modelo y se extrae un estadístico para revisar el comportamiento del modelo.

#Transformando los datos
Datos1<-Vuelos1%>%
 group_by(fechas,tailnum)%>%
 summarise(dis_m=mean(distance))

Dato2=melt(Datos1,id=c("fechas","tailnum"))

Datos3=dcast(Datos1,fechas~tailnum)

Datos3[is.na(Datos3)] <- 0

#Eligiendo los tailnum con mayor actividad
Lista<-flights2%>%
 group_by(tailnum)%>%
 summarise(cantidad=n())

Aviones=filter(Lista,cantidad>365)

Lista_av=Aviones$tailnum

Lista_av2=c('fechas',Lista_av)

#Selección
Datos4=subset(Datos3,select=Lista_av2)

#Gráficas del comportamiento de algunos registros
ggplot(Datos4,aes(x=fechas,y=N324JB))+geom_line()
ggplot(Datos4,aes(x=fechas,y=N713MQ))+geom_line()
ggplot(Datos4,aes(x=fechas,y=N722MQ))+geom_line()

Como ejemplo gráfico algunos de los registros para ver su comportamiento en el año.

N324JBN713MQN722MQSe aprecia en los gráficos que el comportamiento es diferente y que es de esperar que el modelo no sea el mejor para todos los registros.

#Todos los datos
Datos5=melt(Datos4,id="fechas")
head(Datos5)
ggplot(Datos5,aes(x=fechas,y=value,color=variable,group=variable))+geom_line()+
 ggtitle('Todos los datos')+
 ylab('Media de las distancia de vuelos')+xlab('Fechas')

El comportamiento de todos los registros es el siguiente:

Todos_tailnum

Se hace notar que el comportamiento de separa en dos bloques, por lo cual es posible que para los vuelos que muestran mayor actividad el modelo sea más adecuado.

#Más transformaciones

#Ultima transformación
Datos6=dcast(Datos5,variable~fechas) 
head(Datos6)
colnames(Datos6)[1]<-'tailnum'
str(Datos6)

#Modelo
modelo<-function(df){ets(as.numeric(df))}

#Aplicación del modelo
Amodels<-dlply(Datos6,.(tailnum),modelo)

#Estadistico
rmse<-function(x){sqrt(x$mse)}

#Extracción del estadistico
Acoef<-ldply(Amodels,function(x)rmse(x))



ggplot(Acoef,aes(x=tailnum,y=V1))+geom_boxplot(col="red")+
 ggtitle("RMSE")+theme(plot.title=element_text(lineheight = 1,face='bold'))+ylab("RMSE")+xlab("TailNum")

Estas última parte del código hace el cierre de la metodología SAC, ya teniendo los datos preparados para aplicar el modelo se define la función que se va aplicar, se extrae el estadístico y se revisan los resultados con algún gráfico para tener identificado como se comportó el modelo.

Considerando que RMSE indica la desviación estándar de los errores del modelo, lo que se desea es que no sea muy grande ya que indica que los errores no están tan centrados. Esto es burdo pero es un modo sencillo de interpretar el gráfico que analizar como se comporta el modelo, el gráfico es el siguiente:

RMSE_ejemploRevisando en los datos, se observa que por ejemplo el vuelo N335AA tiene un comportamiento no muy favorable para el modelo,  haciendo la gráfica del comportamiento en el año se observa lo siguiente:

N335AAPara el cual se ve complicado que el modelo funcione bien, ya que siendo de suavizado exponencial no se favorable su aplicación.

 Espero que la entrada ilustre de manera general como se hace uso de la metodología SAC, si bien fueron tres entradas para explicar su aplicación la intensión es tener varios ejemplos tanto de gráficas exploratorias , como de gráficas no triviales y la aplicación de algún modelo sencillo que permita visualizar la metodología de manera clara.

Referencias:

1.-http://www.jstatsoft.org/v40/i01/paper

 

 

Algo sobre Python, análisis de datos y machine learning.

Sobre Python

Python es un lenguaje de programación interpretado multiparadigma, es decir; soporta hacer programación orientada a objetos y programación imperativa. Su creador fue Guido Van Rossum y debido a que es de código libre la comunidad de desarrolladores han creado librerías o módulos para hacer casi cualquier cosa.

En general la gente que hace análisis de datos o estadística conoce bien R project, SAS o SPSS. Pero pocos se han acercado a Python y sus librerías para análisis de datos, las ventajas pueden ser cuestionables con respecto a software que específicamente fueron diseñados con una perspectiva estadística, pero sin duda la potencia y calidad de librerías es muy buena. Principalmente para hacer uso de algoritmos de Machine Learning las librerías en Python son mejores que las de R project, sobre todo las técnicas de Deep Learning.

Quizás el mejor candidato para comparar el uso de Python en el análisis de datos es R project, por ser software libre y ser actualmente de alta demanda y atracción en la ciencia de datos. Sin embargo, Python siendo realmente un lenguaje de programación, no como R project, no se limita a ser usado  solamente para analizar datos, sino bien puede ser parte de un sistema o para desarrollar un proyecto completo. 

En caso de que resulte complicado hacer implementación de alguna técnica estadística en Python, se puede enviar un Script a R o manipular los datos desde R y extraerlos a Python por medio de la librería rpy2.

Yo siempre recomiendo para aprender a programar Python, por cosas muy sencillas, es fácil de aprender, fácil de leer y cuenta con librerías para hacer de todo. La curva de aprendizaje es muy corta y en muy poco tiempo uno puede estar programando cosas no tan triviales.

En caso de que se use Windows como sistema operativo, que la mayoría lo usa; se debe de instalar y revisar como hacer instalación de módulos, es bastante fácil y en general se hace desde la consola del sistema con el módulo pip. Si se usa Linux, ya no se tienen ningún problema, está por default, solo basta abrir la terminal del sistema para probarlo.

La mejor referencias para revisar información sobre python, tanto para instalar y conocer el lenguaje, es su página oficial:

https://www.python.org/

Para aprender desde cero a programar en este lenguaje existen muchas páginas y libros, pero creo que solo con ejemplos y ejercicios se aprende, recomiendo seguir y revisar el siguiente libro online:

http://learnpythonthehardway.org/book/

Comentario: cada ocasión que pongo un [] con un número me refiero al número de la lista de referencias.

Sobre Machine Learning y data analysis en Python

Considerando que se tiene instalado Python, las librerías necesarias para hacer los ejemplos que comentaré en las entradas de esta categoría son:

  1. Numpy
  2. SciPy
  3. Matplotlib
  4. Pandas
  5. mlpy
  6. scikit-learn
  7. Pybrain
  8. IPython
  9. NLTK

Por supuesto que hay más librerías necesarias, pero las comento conforme se haga uso de ellas.

Algunas de las convenciones que se hace al programar con las anteriores librerías, sobre todo con Numpy, SciPy , Pandas y Matplotlib, son las siguientes:

#Convenciones en los programas para hacer uso de ciertas librerías
import numpy as np
import pandas as pd
import scipy as sp
import matplotlib.pyplot as plt

 Lo único que dice el código anterior es que se hace uso de nombres cortos y que ahora son estándar en los programas que requieren estas librerías.

Suponiendo que ya se tiene instalado python y las librerías, uno puede revisar en la documentación del lenguaje en la página para ver como se hace uso con: números, variables boolenas, cadenas, listas, diccionarios, loops, tuplas, conjuntos, funciones y clases.

Principalmente el manejo de listas y diccionarios es de uso frecuente al analizar datos, ya que en general se usan para implementar algoritmos sobre un conjunto de datos, y cada uno de estas estructuras de datos tienen sus operaciones o métodos.

Si haz leído hasta este punto y te desanima un poco el aprender a instalar cosas, revisar tanta documentación para solo hacer uso de un software. Bueno, una opción es instalar un paquete con todas la librerías más usadas. Pensando en que mucha gente usa Windows y que la gente que usa Mac o Linux tienen familiaridad con instalación de software, entonces explico cuales son las opciones que conozco.

Las opciones son variadas y depende de las preferencias:

1.-Anaconda.

2.-WinonPyth

3.-Conopy

Cada una de estas instalaciones contiene todas la librerías que uso en los ejemplos, con excepción de pybrain y mlpy. Basta con seguir las instrucciones de instalación que son cosa de dar “click”.

Yo recomiendo Anaconda, es la que he estado usando recientemente y creo que está bien en general. Estos paquetes contienen más herramientas de las que menciono en la entrada, se puede revisar dependiendo del interés de cada uno para qué sirve el resto de librerías.

Un poco de NumPy, SciPy y Matplotlib

En el resto de la entrada trataré de explicar algunas operaciones y usos de las librerías Numpy, Scipy y Matplotlib.

Prácticamente son la base para muchas librerías, Numpy permite manipular arreglos o matrices de datos, si se tiene un poco de conocimiento de álgebra lineal resultará natural conocer las operaciones y funciones de dicha librería. Si no se cuenta con conocimiento de álgebra lineal, recomiendo revisar cualquier texto que prefieran ya que el perfil del texto va desde muy abstracto hasta muy aplicado y depende de la formación e interes de cada persona.

Pero es altamente recomendable revisar conceptos de estos temas lo mejor posible, ya que las matrices son el centro de muchos algoritmos de Machine Learning a todos los niveles.

SciPy, concentra varios procesos, algoritmos o técnicas de manipulación numérica; esto va desde el cálculo de la transformada rápida de Fourier, optimización, procesamiento de señales e imágenes.

Si nunca haz escuchado cosas de estos temas, no te desesperes ni mucho menos tienes que saber todo sobre eso, se aprende con la práctica y la formación, hay gente con carreras completas en ingeniería que no entendió la relevancia del análisis de Fourier  u optimización en sus cursos. En buena medida depende del problema que se aborde para hacer uso de alguna herramienta de Scipy.

Por último Matplotlib, es un módulo para gráficar, existe otro módulo para realizar gráficas que es actualmente muy usado, ggplot2. Este último es muy popular en la comunidad de usuarios de R project pero existe también la versión del módulo en Python y depende la preferencia en cuanto al tipo de gráficos al elegir entre Matplotlib o ggplot2.

El nivel de gráficos es bastante bueno y en ocasiones es tan importante hacer una buena gráfica ya que esto clarifica lo que se hace en el análisis de datos o como se presentan los resultados.

En los últimos años de han desarrollado muchos proyectos de visualización de datos y es prácticamente un campo de investigación, ya que al analizar muchos datos es fundamental tener un modo agradable de visualizar lo resultados de los análisis o investigaciones, de modo tal que sea interactivo e informativo [1].

¿Cómo correr el código en sus computadoras?

Los ejemplos los corrí en una sistema Windows con una versión del sistema 8.1 y con la versión de Python 2.7.9, lamento no comentar respecto a como correrlos en Linux, pero es mucho más simple ya que solo se debe de agregar la ruta del directorio en un script y debe de correr el código sin problema alguno.

Entonces pensando en que hay más usuario de Windows que de Linux, los detalles para correr el código que comentaré requiere probar que está bien instalado Python , configurar la variable PATH para correr Python desde la consola cmd o desde powershell y en caso de que se haga uso de Notepad++, se puede configurar para enviar el código a la consola y correrlos en el IDLE.

Creo que la mejor recomendación es empezar a usar Ipython y cualquier editor de texto, puede ser simplemente el notepad, pero se pueden revisar las recomendaciones en el libro online que mencioné anteriormente para ver como correr un scrip de python y como interactuar con el intérprete. Si presionan en la palabra “interprete”, podrán ver una versión online en la página oficial de python.

El párrafo anterior desalienta un poco cuando uno usa R project, por que solo basta instalar R, instalar las librerías y listo. Pero usar Python da oportunidad de conocer mejor como funciona aspecto del sistema, de la creación de una aplicación y de una que otra cosa que termina sirviendo posteriormente.

Lo que suele pasar con los usuarios de R es que pocas ocasiones desarrollan Script de R y los corren en la consola del sistema, el cmd en Windows. Esto cuando uno está iniciando a programar es raro, pero es fundamental para poder ponerse hacer cosas más interesantes.

Algunas aclaraciones, Notepad++ es un editor de texto más amigable y con más detalles y herramientas que el notepad normal, es de libre descarga y entre los lenguajes que soporta está Python. El IDLE que vienen en la descarga usual de Python es sencillo y lo único que se debe de revisar es como crear un archivo para ejecutar el código, que es cosa simple. Por supuesto que existen otros editores de texto y otros IDLE, depende del gusto de cada persona, pero la idea es la misma, de hecho directamente los IDLE no requieren otro editor como  Notepad++, en mi caso es por que me gusta más usar este último que escribir código directamente en el IDLE. Por último, lo recomendable es usar Ipython y una editor de texto eso basta para tener un entorno de trabajo con todos los recursos para trabajar con Python.

Un poco de Numpy

Esta librería permite la manipulación de arreglos o matrices de datos, en consecuencia también el manejo de vectores que son matrices de un solo renglón. Permite hacer operaciones aritméticas sobre todos los elementos de la matriz o elegir entre ellos bajo condiciones pedidas.

Haciendo un poco de memoria sobre las operaciones con matrices en álgebra lineal, en general uno estudia la dimensión de la matriz, la forma, el tipo de entradas que tiene, la multiplicación de matrices por un escalar, la suma y resta de matrices, el cálculo de la inversa de una matriz, el producto de matrices, el producto de una matriz y un vector, el producto interno de dos vectores o de las columnas de una matriz.

Este tipo de operaciones algebráicas se realizan con Numpy; algo extra es la manipulación de las entradas cuando se cuentan con datos NaN o eligiendo aquellas entradas que son mayores o menores algún valor, los que han usado Ovecta o Matlab.

En el código doy algunos ejemplos sencillos.

#Numpy
import numpy as np
#Creamos una matriz
a=np.array([0,1,2,3,4,5])
print 'Presenta la matriz'
print a
print 'Dimension de la matriz'
print a.ndim
#Vemos sus dimesión
print 'Forma de la matriz'
print a.shape
#Vemos su forma, el número de renglones y columnas
print 'Multiplica cada entrada por 2'
print a*2 
#Multiplicamos cada entrada por 2
print 'Eleva a la potencia 2 cada entrada'
print a**2
#Elevamos a la segunda potencia cada entrada
print 'Cambiando la forma del la matriz'
print a.reshape((3,2))
print 'Se imprime cada uno de sus elementos'
print a[0],a[1],a[2]
a[0]=5
print 'Se cambia la primera entrada a[0]=5'
print a
#Creamos una nueva matriz para de más dimensiones
b=np.array([[0,1,2],[3,4,5]])
print 'Se presenta b'
print b
print 'La forma de b'
print b.shape
print 'Se multiplica cada entrada por 3'
print b*3
print 'Se eleva cada entrada al cuadrado'
print b**2
#Se eliminan el vector y la matriz
del(a,b)


#Creacion de matrices especiales

a=np.zeros((3,4))
print 'Se presenta la matriz nula de 3X4'
print a
b=np.ones((2,2))

print 'Se presenta la matriz de unos'
print b
#Se creo la matriz con un valor igual para todas las entradas
c=np.full((3,3),3.5)
print 'Se presenta la matriz con valores iguales en todas las entradas'
print c

#Matriz identidad

d=np.eye(5)

print 'Se presenta la matriz identida de dimension 5'
print d

#Matriz con valores aleatorios

e=np.random.random((7,7))
print 'Se preseta la matri con valores aleatorios en cada entrada'
print e
#Eliminamos las matrices
del(a,b,c,d,e)

#Algunos detalles con los valores de las matrices y asignaciones

a=np.array([[1,2,3],[4,5,6],[7,8,9]])
print 'Se presenta la nueva matriz a'
print a
print 'Se presenta el valor de sus colnas'
print a[:,2]
#Se presentan las dos primeras filas
print 'Se presentan las dos primeras filas'
print a[:2,:]
#Creamos una nueva matriz con las primeras 4 entradas de a

b=a[:2,:2]
print 'Sub matriz de a'
print b
print 'modificamos el valor de b y modifica el de a'
b[0][0]=65
print b
print 'Modifica a'
print a
#esto tiene que ver con la asignación de memoria y de valores por python
del(a,b)
#Operaciones matematicas
a=np.array([[1,2,3],[4,5,6],[7,8,9]], dtype=np.float64)
b=np.array([[1,0,1],[2,6,1],[1,1,1]], dtype=np.float64)
#Suma de matrices
print a+b
print np.add(a,b)
#Resta de matrices
print a-b
print np.subtract(a,b)

#Multiplicacion
print a*b
print np.multiply(a,b) 

#division
print b/a 
print np.divide(b,a)

#Raiz cuadrada

print np.sqrt(a) 

#Producto interno de vectores y de vectores con matrices

c=np.array([1,0,1])

print 'Produto interno por (1,0,1)'
print a.dot(c)
print 'Producto punto de matrices'
print a.dot(b)

print 'Valores de b'
print b
print 'elecci󮠤e valores mayores a 1'
print b[b>1]
print b>1
print 'Generamos otra matriz con un elemento NAN'
c=np.array([1,2,np.NAN,3,4])
print 'Presentamos su valor'
print c
print 'Identificamos los valores que son NAN'
print np.isnan(c)
print 'Elegimos los valores que no son NAN'
print c[~np.isnan(c)]

Puede haber evitado poner tanto comentario en pantalla o estar enviando “print” en cada orden y comentario, pero los dejo así sobre todo para gente que recién inicia a manejar Python y le pueda causar confusión solo ver números y no saber que cosa es lo que está haciendo.

Si se pone atención el objeto sobre el cual se trabaja siempre es np y de él se toman lo necesitado para crear el tipo de matrices que se desea.

Algunas cosas que no comenté son las operaciones como suma de valores en la columna o de valores en la fila, la transpuesta y el asignar a una matriz para que tengas valores enteros o flotantes. Esto es sencillo y se puede consultar en la documentación de NumPy.

Algo de SciPy y Matplotlib

Como antes mencioné SciPy es una caja de herramientas y Matplotlib es una librería para graficar. Dos ejemplo son los siguientes:

#Dos ejemplos de Scipy
#Cargamos los módulos necesarios
import numpy as np
from scipy import signal, misc
import matplotlib.pyplot as plt

#Se revisará una imagen como dato

image = misc.lena().astype(np.float32)
derfilt = np.array([1.0, -2, 1.0], dtype=np.float32)
ck = signal.cspline2d(image, 8.0)
deriv = (signal.sepfir2d(ck, derfilt, [1]) +
 signal.sepfir2d(ck, [1], derfilt))

#Se calcula el Lapaciano

laplacian = np.array([[0,1,0], [1,-4,1], [0,1,0]], dtype=np.float32)
deriv2 = signal.convolve2d(ck,laplacian,mode='same',boundary='symm')

#Se presenta la imagen
plt.figure()
plt.imshow(image)
plt.gray()
plt.title('Original image')
plt.show()

#Se presenta la imagen modificada por el filtro y la señal gaussiana

image = misc.lena()
w = signal.gaussian(50, 5.0)
image_new = signal.sepfir2d(image, w, w)
plt.figure()
plt.imshow(image_new)
plt.gray()
plt.title('Filtered image')
plt.show()

Las imágenes  que obtenemos es:

figura_1

 

Este es un ejemplo clásico de SciPy, la siguiente foto, generada por las últimas líneas del programa anterior no regresan la siguiente modificación a la imagen. Qué lo que se hace es extraer como señal gaussiana o filtrar la imagen original, esto lo pueden consultar en la página de SciPy o en textos de procesamiento de imágenes.

figure_2

 

Otro ejemplo estándar para usar SciPy es en el análisis de señales.

#Análisis de señales
from numpy import arange, sin, pi, random, array
x = arange(0, 6e-2, 6e-2 / 30)
A, k, theta = 10, 1.0 / 3e-2, pi / 6
y_true = A * sin(2 * pi * k * x + theta)
y_meas = y_true + 2*random.randn(len(x))

def residuals(p, y, x):
 A, k, theta = p
 err = y - A * sin(2 * pi * k * x + theta)
 return err

def peval(x, p):
 return p[0] * sin(2 * pi * p[1] * x + p[2])

p0 = [8, 1 / 2.3e-2, pi / 3]
print(array(p0))


from scipy.optimize import leastsq
plsq = leastsq(residuals, p0, args=(y_meas, x))
print(plsq[0])


print(array([A, k, theta]))


import matplotlib.pyplot as plt
plt.plot(x, peval(x, plsq[0]),x,y_meas,'o',x,y_true)
plt.title('Datos con Ruido')
plt.legend(['Estimacion', 'Ruido', 'True'])
plt.show()

figure_3

Observamos que todo el proceso anterior es el que se realiza para analizar una señal, se considera el ruido, se estima una curva y se analiza con respecto a los datos originales.

Los dos códigos anteriores son ejemplos de como se usa SciPy en dos contextos distintos, uno con números y otro con imágenes. Se puede consultar muchos ejemplos en la página oficial de SciPy y Matplotlib.

El último ejemplo es tomado del texto de “Building Machine Learning Systems with Python” y los datos se pueden descargar desde GitHub. La idea de lo siguiente es graficar el cruce entre datos de tráfico web y semanas, pero además agregar curvas ajustadas a los datos.

#Se simplifica el código presentado en el texto
import os
from utils import DATA_DIR
import scipy as sp
import matplotlib.pyplot as plt

 
sp.random.seed(3) 
data = sp.genfromtxt(os.path.join(DATA_DIR, "web_traffic.tsv"), delimiter="\t")
print(data[:10])
print(data.shape)

#Se separan los datos en x e y
x = data[:,0]
y = data[:,1]
print("Entradas no validas:", sp.sum(sp.isnan(y)))

#Se limpian los datos
x = x[~sp.isnan(y)]
y = y[~sp.isnan(y)]

#Modelo 1
fp1= sp.polyfit(x, y, 1)
f1 = sp.poly1d(fp1)
fx = sp.linspace(0,x[-1], 1000)
#Modelo 2
f2p = sp.polyfit(x, y, 2)
f2 = sp.poly1d(f2p)

#Gráfica de los modelos y los datos 
plt.scatter(x,y)
plt.title("Trafico Web en un Mes")
plt.xlabel("Tiempo")
plt.ylabel("Hits/hora")
plt.xticks([w*7*24 for w in range(10)],['Semana %i'%w for w in range(10)])
#Se agregan los ajustes
plt.plot(fx, f1(fx), linewidth=4)
plt.plot(fx, f2(fx), linewidth=4)
#Se agregan las leyendas de las curvas
plt.legend(["d=1","d=2"], loc="upper left")
plt.autoscale(tight=True)
plt.grid()
#Se muestra la gráfica en la pantalla
plt.show()

La gráfica que se obtienen es la siguiente:

figure_4

Si uno revisa el último código, se observa que se importan las librerías usuales, SciPy y Matplotlib, pero además la librería os (sistema operativo) y un módulo de nombre utils. Existe un módulo en Python con el nombre de utils, pero lo que realmente se está haciendo es usar un script escrito por Willi Richert y Luis Pedro Coelho, que son los autores de dicho libro, para extraer los datos de un archivo con el nombre de “web_traffic.tsv” desde algún directorio. Si solo se descargan los datos y se quiere correr el código en algún directorio  arbitrario donde no se encuentre ni los datos ni el archivo utils, Python no enviará un error.

Entonces para este último ejemplo es recomendable descargar el código en zip de GitHub del libro y revisar el código de los autores del libro.

Con estos ejemplos espero se de una idea de como se hace uso de Numpy, SciPy y Matplotlib. Sobre las otras librerías, en cada entrada comento lo necesario, pero cada uno tienen sus detalles al momento de usarlas. En algunos casos, como IPython, uno puede hacer uso de Python sin recurrir a su uso, pero no esta de más conocer el por qué es altamente usada y ya con la práctica terminaran convencidos de su utilidad.

Referencias:

1.-http://www.creativebloq.com/design-tools/data-visualization-712402

Libros:

1.-http://www.amazon.es/Building-Machine-Learning-Systems-Python/dp/1782161406

2.-http://www.amazon.es/Learning-Python-Mark-Lutz/dp/1449355730/ref=sr_1_1?s=foreign-books&ie=UTF8&qid=1431492984&sr=1-1&keywords=Python

3.-http://www.amazon.es/Python-Data-Analysis-Wrangling-IPython/dp/1449319793/ref=sr_1_6?s=foreign-books&ie=UTF8&qid=1431493009&sr=1-6&keywords=Python

4.-http://www.amazon.es/High-Performance-Python-Performant-Programming/dp/1449361595/ref=sr_1_11?s=foreign-books&ie=UTF8&qid=1431493009&sr=1-11&keywords=Python

5.-http://www.amazon.es/Natural-Language-Processing-Python-Steven/dp/0596516495/ref=sr_1_94?s=foreign-books&ie=UTF8&qid=1431493443&sr=1-94&keywords=Python

6.-http://www.amazon.es/Building-Machine-Learning-Systems-Python-ebook/dp/B00VAG2WU4/ref=sr_1_126?s=foreign-books&ie=UTF8&qid=1431493491&sr=1-126&keywords=Python

Algoritmos de Machine Learning en R project

“The best thing about R is  that it was developed by statisticians. The worst thing about R is that….it was developed by statisticians.”  Bo Cowgill, Google, Inc.

Todas las entradas de esta categoría muestran algoritmos y técnicas clasificadas como algoritmos de Machine Learning o Aprendizaje Estadístico. En cada entrada comparto el código  y algunos repositorios donde pueden bajar datos y notas sobre los temas.

Las ventajas de usar R project para dar estos ejemplos son las siguientes:

1.-R project es software libre u open source, por lo cual cualquier persona pude descargarlo.

2.-El código que comparto solo debe de ser copiado y pegado en un Script o en la consola  de R project para reproducir los resultados.

Otra ventaja de aprender estas técnicas con ejemplos en R, es que muchos de los algoritmos son acompañados de alguna técnica gráfica para visualizar el resultado. R project por default cuenta con una gran cantidad de herramientas gráficas o se puede hacer uso de librerías como ggplot2, lattice, ggvis para hacer gráficas aún más elaboradas y visualmente más agradables.

El entendimiento de la técnica después de realizar un ejemplo desde mi perspectiva genera interés por saber como aplicarla a otros datos y nos invita a conocer más sobre el algoritmo desde un punto de vista no solo práctico, sino también teórico.

Evité en la medida de lo posible hacer uso de ecuaciones y en cada ocasión que se menciona algún concepto de matemáticas trato de explicarlo de un modo sencillo. Si este concepto requiere a mi parecer una mejor lectura, agregue algunas ligas para consultar en la red.

La única meta que me propuse fue explicar las cosas de modo tal que cualquier persona con un poco de curiosidad pueda entender algo de cada entrada.

Teniendo en mente lo anterior, espero que  el objetivo de trasmitir el conocimiento desde un ejemplo concreto haya sido logrado. En caso de que no sea así, sería grato saber qué parte no es clara y como mejorar este material.

Resumen de las entradas.

El orden siguiente es el que considero apropiado para revisar cada entrada.

1.-¿Qué se necesita conocer de R project para aprender algunas técnicas de Machine Learning?

Es una breve explicación sobre R project y sobre algunas de las funciones con las que cuenta por default. También menciono las librería que se requieren para replicar los ejemplos, aunque en cada entrada menciono algo breve sobre la librerías requeridas.

2.-Análisis Confirmatorio vs Exploratorio

Explico la diferencia entre los dos tipos de análisis y cómo están relacionados. Clasifico el tipo de medidas que uno puede analizar en los datos y pongo algunos ejemplos del tipo de gráficas que pueden ayudarnos a visualizar las medidas al momento de explorar la información.

3.-Regresión Lineal, un ejemplo sencillo.

Esta técnica es muy sencilla de implementar y los datos que nos regresa el comando en R debe ser entendidos para poder evaluar la calidad del resultado obtenido. Omito detalles formales del tema y comparto algunos ejemplos de regresiones simples y múltiples. Es un tema con muchos detalles importantes, por ejemplo la revisión de las posibles fallas al construir un modelo lineal o multilineal. No toco mucho  esos temas, pero en las referencias pueden encontrar observaciones y técnicas para conocer más al respecto.

4.-Regresión no lineal, Cross-Validation y Regularization. 

Los tres temas pueden haber requerido una entrada para cada uno, pero funciona bien mostrar como se relacionan. El objetivo es mostrar la implementación de la regresión no lineal y validar que el modelo elegido es el adecuado, para evitar la sobre estimación de los datos. En esto último las cross-validation y la regularización ayudan a tener un método para hacer una elección del modelo. Se dan algunos ejemplos del uso de los tres conceptos y técnicas.

5.-Clasificación binaria….Naive Bayes. 

Es uno de los algoritmos más usados por sencillo y por que puede ser modificado para tener una clasificación rápida en varias categorías. Doy el ejemplo clásico sobre detección de Spam y trato de complementarlo con el uso de una librería en la cual se cuenta con una función para estimar el modelo. Agregué una pequeña explicación sobre la probabilidad condicional y sobre el uso de la librería tm para analizar textos en R project. Espero ser claro y que permita comprenderse el ejemplo.

6.-Análisis de Cluster, un ejemplo sencillo. 

Se explica de modo breve como funciona la detección de Clusters. Como el tema requiere hacer uso de la noción de distancia o métrica, trato de explicar el concepto. Omití mucho material, sobre todo en el uso de distintas métricas para distintos tipos de variables.

7.-Un ejemplo sencillo sobre Análisis de Componentes Principales (PCA, Principal Component Analysis).

La técnica es muy usada y conocida para hacer reducción de dimensiones, explico qué es reducir dimensiones y como interpretar los resultado de la técnica. Como ejemplo principal hago una reducción de 25 indicadores para formar uno que resuma la información del resto. Replico un ejemplo de análisis de la digitalización de los números escritos a mano, este es un ejemplo clásico y la base de datos fue objeto de estudio para comparar técnicas de clasificación.

8.-Sobre sistemas de recomendación, ejemplo sencillo. 

Hago un breve ejemplos de un sistema de recomendación usando la técnica de k-vecinos cercanos (K-nn), esta técnica es no-paramétrica. Para ejemplificar como funciona pongo un ejemplo inicial y trato de explicar qué realiza el algoritmo y aplicarlo a un caso concreto. Los sistemas de recomendación prácticamente dan la libertad de elegir la técnica de clasificación que uno considere adecuada para el tipo de datos o servicio, por lo cual existen libertad de replicar este ejemplo haciendo uso de otro técnicas de clasificación.

9.-Optimización.

Esta entrada creo que es extensa y puede ser un poco amplia,ya que traté de explicar desde aspectos básicos de mínimo y máximos hasta algoritmo estocásticos y genéticos. Puse un ejemplo de como usar el código y en los casos más sofisticados, la parte estocástica, comparto un ejemplo que permitiera comparar los resultado obtenidos con diversos tipos de algoritmos, no puse los tiempos que tardan en dar la solución pero en caso de replicarlos será notorio el costo del procesamiento.

10.-Máquina de soporte Vectorial (SVM-Sopport Vector Machine).

La técnica sumamente usada y funciona bien para datos no-lineales, se dan varios ejemplos de como usar dos librerías que permiten calcular SVM con distintos kernels. En uno de los ejemplos de hace la comparación de varios modelos para determinar por medio de MSE cual es el mejor. Son ejemplos muy sencillos y trato de agregar explicaciones a cada ejemplo.

Lo que no está aún en estas entradas, pero que estará en inicio de Marzo 2016.

Dejé fuera por el momento varios temas fuera de las entradas, ejemplo Redes neuronales , Arboles de decisión, Random Forests, AdaBoost. Espero posteriormente agregar entradas sobre esos algoritmos.

En general todos las entradas tratan de simplificar y resumir lo que se puede encontrar en el texto  “Machine Learning for Hackers“, libro escrito por Jhon M. White y Drew Conway. Si bien, el libro en si es sencillo y requiere un bajo nivel de matemáticas para estudiarse, traté de hacer más sencillas las explicaciones y de complementarlo con otros ejemplos.

La recomendación es complementar las explicaciones de las entradas con la lectura del texto.  Jhon M White compartió su código  y datos usados en los ejemplos en el repositorio Github y pueden descargar el código presionando estas letras en rojo.

Algunos de los códigos deben de revisarse ya que las librerías que usaron en el año de la edición del texto ya fueron actualizadas, por lo cual es generan algunos errores.

Dos temas que vienen en el texto y decidí omitir son generación de un rango y análisis de redes sociales o de grafos. En otro momento comparto ejemplos respecto al tema.

El segundo es sumamente interesante; análisis de redes sociales, pero el código con el que cuenta el texto ya no es funcional. Así que se requiere rehacer buena parte del código y diseñar nuevos ejemplos, para eso se necesita cierto tiempo. Más aún debido al boom de las redes sociales existen otro tipo de herramientas sobre las cuales se puede escribir.

Para tener una idea de lo nuevo e interesante se pueden consultar las siguientes ligas para echar un vistazo:

Deseo que el material que se encuentra en esta categoría les sea útil y sobre todo les deje con ganas de aprender más al respecto y no solo desde el lado aplicado, sino también desde el lado teórico.

En la siguiente cita aplique “instrumento= algoritmo”.

“Tienes que aprender a tocar tu instrumento. Después debes practicar, practicar y practicar. Y después, cuando finalmente estás en el escenario, olvídalo todo y ulula.” Charlie Parker

 Nota: Todas las críticas y comentarios respecto a las entradas son bienvenidos.

¿Qué se necesita conocer de R project para aprender algunas técnicas de Machine Learning?

Sobre R

El lenguaje R o R project, en recientes años se ha vuelto muy popular, sobre todo en el ámbito académico y poco a poco empieza a sonar en el sector de la industria de la Tecnologías de la Información (TI).

Tan es así, que Oracle una empresa líder en tecnología y conocida por su gestor de bases de datos con el mismo nombre, ahora ofrece una versión de R dentro de su gestor de bases de datos. No he probado la versión, por lo cual desconozco si tienen todas las funcionalidades iguales o si tienen ciertas restricciones al compararlo con la versión de R que uno descarga libremente.

Si uno busca en la red o en la página principal de R project, se encontrará con la abrumadora noticia de que existen aproximadamente más de 7 000 librerías. Las librerías son un bloque de código o funciones que alguien escribió y compartió libremente para hacer uso de ellas en el software.

Al ser libre R project uno tienen la posibilidad de compartir algunas funciones que considere que son buenas y que a otros les pueden servir, eso hace que una comunidad a nivel mundial esté actualizando librerías o compartiendo nuevos algoritmos.

Entre todas las librerías uno puede encontrar un poco de todo. Se encuentran librerías que permiten la manipulación de datos, realizar conexiones a la red, automatizar pronósticos, manipular y analizar textos, generar reportes, conectarse con gestores de bases de datos, manipular mapas, etc.

Si uno toma alguna técnica  estándar para hacer algo de estadística, es probable que exista más de una librería que nos permite hacer eso. Por lo tanto pretender conocer todas las librerías es una tarea casi imposible y lo que recomiendo es ir consultando en la red, en foros o blog para conocer las librerías que sugieren para realizar tal o cual técnica.  Al final las mejores librerías y las más usadas tenderán a persistir en las recomendaciones que haga la gente.

Existen muchos manuales básicos para aprender a usar R [1,2,3,4,5]. Lamentablemente el manual de introducción en español no ha sido actualizado desde hace años, pero se cuenta con muchas referencias que van desde blog, notas y textos  que cubren prácticamente todo lo que uno debe de saber a un nivel básico o intermedio, y posiblemente hasta un poco avanzado ( hay un libro hermoso de temas avanzados escrito por Hadley Wickham que deben de apurarse a leerlo).

Lo “malo” hasta cierto punto es que las mejores referencias se encuentran en Ingles, es importante aprender por lo menos a leer en dicho idioma pero hace falta en ocasiones manuales en español que clarifiquen los conceptos e ideas.

Al final lo recomendable para aprender cualquier software es practicar, tomar varias fuentes para aprender y replicar ejemplos. Estudiar el código que otros hacen y hacer las modificaciones que uno pueda ir pensando que mejoran dicho código, ya sea para optimizarlo o solo para probar si se puede usar para hacer otra cosa.

Lo que puedo decir es que R project es un software bastante sencillo de aprender,  lo complicado no radica en el software mismo, sino conocer lo que hacen comandos, técnicas, algoritmos y librerías. A gente que lleva toda su vida haciendo software le desconcierta y le parece muy “científico” como para aprenderlo, pero con algo de tiempo y algunas revisiones de como declarar variables, hacer funciones, manipular tipos de datos, etcétera; van perdiendo el miedo a usarlo.

R project y Machine Learning

La instalación en el sistema que sea, Windows, Mac Ox o Linux, son sencillas y el IDE (Entorno de Desarrollo Integrado) es prácticamente igual para todos los sistemas. Lo único que es importante y que cambia es al correr un script desde la consola del sistema. En general la consola de Windows es muy pobre comparada con las de los otros dos sistemas, pero se puede fortalecer usando otros software. Para ese caso en otro momento explico el tipo de cosas que hay que hacer para correr los script.

Un complemente para programar en R es usar el entorno R Studio, que prácticamente es tener un entorno de desarrollo amigable, de mejor vista y con herramientas que simplifican el trabajo al momento de programar en R. Existen  otros entornos, pero es cosa de cuál se adecua mejor a nuestro modo de trabajo y necesidades.

En el caso de los ejemplos de Machine Learning, lo necesario del software se puede clasificar en:

  1. Funciones estándar en R.
  2. Importación, exportación y manipulación de datos.
  3. Funciones particulares de ciertas librerías.

Del primer punto las funciones estándar son: lm, plot, hist, summary, head, apply, sapply, poly, tail, dim, str, names, c, paste, princomp, subset, cov, cor, ts, entre otras. Lo recomendable es revisar por medio de la función help la información de los parámetros y ver algún ejemplo del uso de dicha función, como siempre la recomendación es hacer pruebas para ir mejorando en el manejo de dichas funciones o comandos. Por supuesto que existen más funciones que no menciono, pero son en general las que de momento creo se usan más en las entras.

Sobre la importación y exportación de datos, lo principal en mi opinión es tener claro que el tipo de dato base en R son los vectores o en otras palabras R es un lenguaje “vectorizado” y en general la mayoría de funciones que se usan depende de asignarle data.frame o matrices, que son construidos con vectores.

La importación de los datos se hace por medio de las funciones read.csv, read.txt,scan entre otras. Para este tema se puede consultar un pequeño manual de aproximadamente 30 páginas en la página oficial de R. En general se requiere practicar con la importación de datos, ya que en ocasiones pedir que se importen datos con cierta restricción, como por ejemplo pedir que las cadenas no sean leídas como factores, que se separen las columnas por tabuladores,etc.

Respecto a la manipulación, se cuenta con algunas funciones subset, with, ifelse, cbind, rbind   las cuales son estándar del software. Pero se cuenta con varias librerías que permiten la manipulación de datos, entre ellas, reshape2,  gdata ,data.table, plyr, dplyr.

Del tercer punto, para aprender sobre algunas funciones de ciertas librerías mi recomendación es revisar los manuales de usuarios que son publicados cuando se libera la librería o paquete, es decir; cuando nos permiten usar su código otras personas que usan R project.

La mayoría  de las librerías suelen contar con algunos ejemplos, datos y  en Internet suele haber información casi suficiente para conocer como funcionan. Creo que lo mejor es tratar de replicar los ejemplos, cambiar las condiciones de parámetros y crear un ejemplo, también esto resulta más divertido para comprender lo que hacen las funciones.

Algunas librerías son más populares que otras y en buena medida es por la calidad y utilidad. Ejemplo, la librería ggplot2  es bastante buena para gráficos, se cuenta con libros y notas que explican su uso con buen detalle, además de que en recientes años se ha hecho muy popular y es considerada unas de las herramientas indispensables en análisis de datos.

Otra librería que ha tenido popularidad es tm, que se refiere a Text Mining ( Minería de Textos); se cuenta con bastante información en la red sobre como usar sus funciones con algunas ejemplos, pero además está relacionada con las investigaciones del Procesamiento de Lenguaje Natural (NLP, en ingles).

Por último las librerías que son populares para analizar redes es igraph y sna, con redes me refiero a redes sociales o redes complejas, esta librería cuenta con una gran cantidad de funciones. La gran ventaja es que se cuenta con suficiente explicación y ejemplos debido a la gran popularidad de las redes sociales en nuestro día a día, entonces basta con buscar un poco en la red para encontrar buen material al respecto [6,7].

Espero las explicaciones generen interés en explorar más sobre R project. La última observación que hago es entender que este software permite rápido aprender ciertas técnicas, pero existen otros software que ante proyectos grandes puede ser mejores( Python, C,Ruby, Java, scala), pero sin duda es una buena fuente para aprender practicando,  R lo permite con una curva de aprendizaje muy pequeña.

Comentario: Debido al desarrollo de R y  la creación de nuevas librerías, con el paso del tiempo algunos de los comentarios respecto a las librarías puede dejar de ser actualizado. Ejemplo, ggplot2 ha evolucionado no solo con mejoras y más funciones, sino también con la aparición de otro tipo de librerías que se abocan a la visualización de datos a nivel web. Otro ejemplo es en el procesamiento de datos, debido a la relevancia de plyr y dplyr es posible que aparezcan librerías más optimizadas o con otro tipo de características, ejemplo data.table es mejor para ciertas operaciones con datos. Así que siempre hay que tener en mente que los software evolucionan, pero ello es recomendable conocer de manera solida las estructuras base o herramientas base.

“The best thing about R is  that it was developed by statisticians. The worst thing about R is that….it was developed by statisticians.”  Bo Cowgill, Google, Inc.

Referencias:

1.-The R inferno.

2.-Using R for Numerical Analysis in Science and Engineering.

3.-A handbook of Statistical Analyses using R.

4.-Data Manipulation with R.

5.-R in Action.

6.-Igraph

7.-SNA

8.-R-bloggers

9.-Revolution Analytic

De lo concreto a lo abstracto.

“The best thing about R is that it was developed by statisticians. The worst thing about R is that…it was developed by statisticians. ”      -Bo Cowgill-

Lo que se puede encontrar en esta categoría son ejemplos tomados del libroMachine Learning for Hackers”, todos los ejemplos y casos de estudio están desarrollados en R project, la intensión no es solo replicar los ejemplos de dicho texto, es complementarlos e indicar algunos aspectos claves en cada técnica y ejemplo. Algunas de las cosas que tengo pensadas es agregar otros ejemplos donde de manera sencilla se pueda ver como es que se usan dichas técnicas, espero también poder mostrando como se desarrollarían los temas en Python.

Todos los datos y una versión del código que es empleados se encuentra en el repositorio: https://github.com/johnmyleswhite/ML_for_Hackers

El software se puede descargar e instalar desde: http://www.r-project.org/

Las librerías recomendadas para desarrollar los ejemplos son:

  • arm
  • ggplot2
  • glmnet
  • igraph
  • lme4
  • lubridate
  • RCurl
  • reshape
  • RJSONIO
  • tm
  • XML

Fui encontrando otras librerías nuevas y hasta cierto punto más completas, las cuales haré mención en cada ejemplo según sea necesario.

Mi perspectiva para aprender aspectos de Machine Learning o  análisis de datos es haciendo  algunos ejemplos sencillos y pasar posteriormente con cierta preparación abordar el tema desde un punto de vista teórico.

Espero el material pueda ser útil, en buena medida este proyecto nació de mi molestia al ver que se cuenta con poca información en español y si bien todos los desarrollos se hacen en ingles, creo que contar con alguna referencia en español ayuda.

Cualquier duda o comentario será bien recibido.

Hasta pronto.

D.L.