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

 

 

Anuncios

Split-Apply-Combine-Parte 1

Sobre Split-Apply-Combine

La idea de esta entrada es aplicar la visión de dividir-aplicar-combinar (Split-Apply-Combine), en las referencias [1,2] se explican más detalles sobre el modelo o metodología guía, la cual fue inspirada por Map-Reduce. Esta última es una metodología apropiada cuando se tienen un cluster de computadoras, en este caso la versión Split-Apply-Combina se centra en el caso del análisis de datos mediante una sola máquina para diseñar una buena estrategia de análisis.

En la entrada desarrollo el ejemplo mediante R project y Python. La intención es mostrar como los dos lenguajes cuentan con las herramientas para realizar el mismo tipo de análisis. Trato de hacer un ejemplo amplio, por lo cual elegí una base más o menos grande de R project, la cual si bien no tiene muchas variables ( solo 16) permite hacer varias cosas con ellas. Por supuesto que el análisis puede tener otro tipo de enfoque, lo único que hago es usar esa base para emplear varias herramientas de R y de Python, las cuales en general uno las consulta de mera independiente.

Divido esta entrada en 3 partes.

Parte 1.-Exploración directa de los datos.

Parte 2.-Procesando los datos y analizando otras posibles relaciones.

Parte 3.-Definiendo técnicas para aplicar y concentrar esto para realizar un proceso Split-Apply-Combine.

Decidí dividir en tres partes para compartir algunos ejemplos sencillos sobre como hacer algunos gráficos y también un poco de análisis. Todos los gráficos usados entran perfectamente en los temas de exploración de datos o análisis exploratorio, en ocasiones solo uso algunas funciones para mostrar como funcionan y el valor que agrega a la exploración puede ser pobre y sin relevancia mayor.

En la referencia [3] se pueden ver detalles sobre las gráficas en R y en la referencia [4] sobre las gráficas en Python.

Parte 1.-Exploración directa de los datos.

En el código considero instaladas las librerías requeridas, en caso de contar con ellas  en caso de usar RStudio se puede hacer uso de Tools para instalar paquetes, lo cual es rápido y fácil.

Los datos corresponden a los tiempos de vuelo del año 2013, contienen información de los vuelos de 3 aeropuertos JFK, LGA y EWR.

#Código para cargar las librerías y datos
library(nycflights13)
library(ggplot2)
library(grid)
library(GGally)
library(gridExtra)#Funciones para la librería Grid

Los datos en general primero son explorados para conocer cuantos datos se tienen como missing values y las dimensiones de estos datos, es decir; cuantas columnas y cuantas filas tiene el archivo.

#Código para revisar las propiedades básicas de los datos
data(flights)
#Para conocer información de los datos 
#?flights

dim(flights)
#[1] 336776     16

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

#tipo de datos
str(flights2)
#Aspectos básicos de los datos
head(flights2)
#También se puede ver la parte final de la tabla de datos
#tail(flights2)

#Para revisar el resumen estadístico de los datos
#Se usa el siguiente comando

summary(flights2)

Debido a que se tienen varias variables que son categóricas, se puede revisar su comportamiento considerándolas como “factores”. Un modo de revisar como se comportan ese tipo de datos se puede hacer con el siguiente comando.

#Explorando unas variables categóricas

sort(summary(factor(flights2$dest)),decreasing = TRUE)
sort(summary(factor(flights2$origin)),decreasing = TRUE)
#EWR    JFK     LGA
#117127 109079  101140

Cuando se revisan los datos de manera numérica uno no aprecia mucho la relevancia del comportamiento de los datos. Entonces siempre se buscan algunas gráficas sencillas que representen la información de manera clara y fácil.

Todas las gráficas siguientes pueden ser mejoradas, al final depende del interés de cada persona para definir el tipo de gráfica que se hace.

#Primeras Gráficas

p1=ggplot(data=flights2,aes(x=factor(origin),y=month))+geom_boxplot(col="black",alpha=0.7,aes(fill=factor(origin)))+
xlab('Origen de los Vuelos')+ylab('Mes de vuelo')+ggtitle('Comportamiento de los lugares de salida por mes')+theme(plot.title=element_text(lineheight = 2,face='bold'))

p2=ggplot(data=flights2,aes(x=factor(month)))+geom_bar(col="black",aes(fill=factor(origin)),position="dodge")+
  xlab('Mes de Vuelos')+ylab('Número de vuelos')+ggtitle('Comportamiento de vuelos por mes con respecto al aeropuerto de salida')+theme(plot.title=element_text(lineheight = 2,face='bold'))

grid.arrange(p1,p2,ncol=2,main="Gráficas del comportamiento de vuelos por mes")

La gráfica que se obtiene es la siguiente:Gráficas_vuelos_por_mesLa intensión es revisar la relación que existe entre la cantidad de vuelos por mes respecto al aeropuerto de salida u origen. La primera gráfica muestra como los 3 aeropuertos tienen un mes en el cual es la media de vuelos y por otro lado el JFK muestra que cubre un mayor número de meses con actividad. En las barras se observa que en EWR se realiza un mayor número de vuelos, además muestra las altas en vuelos en primavera y verano.

##Comportamiento de los tiempos de retraso de despegue y de arrive

q1=ggplot(data=flights2,aes(x=dep_time))+geom_histogram(color="black",aes(fill=factor(origin)))+
  xlab('Hora de despegue')+ylab('Número de Vuelos')+ggtitle('Hora de Despegue por aeropuerto de salida')+theme(plot.title=element_text(lineheight = 2,face='bold'))

q2=ggplot(data=flights2,aes(x=arr_time))+geom_histogram(colour="black",aes(fill=factor(origin)))+
  xlab('Hora de arrivo')+ylab('Número de vuelos')+ggtitle('Hora de Arrivo por aeropuerto de salida')+theme(plot.title=element_text(lineheight = 2,face='bold'))

grid.arrange(q1,q2,nrow=1,ncol=2,main="Gráficas del comportamiento de vuelos por mes")

El gráfico que se obtiene es:

Despegue_y_arrivo_por_aeropuertoSe muestran los histogramas de la cantidad de vuelos por hora de despegue y arribo divididos por el aeropuerto de origen. Se aprecian las horas en las cuales se realizan el mayor número de vuelos , los cuales son sumamente notorios. Por otro lado se aprecia la hora de llegada, las cuales muestran cuatro horas pico o el horario con mayor número de arribos.

En la base de datos se tienen registrados los minutos de retraso en despegues y en arribos a su destino, una idea sencilla es graficar el cruce de ambos datos y explorarlos.

#Gráfica de retrasos en despeque y arrivo
ggplot(data=flights2,aes(x=dep_delay,y=arr_delay))+geom_point(aes(colour=factor(origin)))+
  geom_smooth(method='lm',colour='black')+
  xlab('Retraso en Despegar')+ylab('Retraso en arrivo')+ggtitle('Relación entre retraso de despegue y arrivo por aeropuerto')+theme(plot.title=element_text(lineheight = 2,face='bold'))

La gráfica que se genera es la siguiente:

Relación_despegue_vs_arrivoAgregué la línea de tendencias entre los datos calculada con la regresión lineal entre los datos. Esta recta muestra una buena descripción gráficamente o eso aparenta, pero con un poco de cuidado se ve que los mejores datos descritos son aquellos que tienen mayor tiempo de retraso, mientras que la mayoría de datos se muestran como una mancha en los primeros 500 minutos.

Lo que se me ocurrió revisar el comportamiento de la distribución de los datos, haciendo uso de un histograma, después de observar que solo se apreciaba unas cuantas barras estimadas probé transformar los dato y calcular su logaritmo y luego volver a revisar su histograma. Lo que se observa de los datos transformados es la siguiente gráfica:

Hist_Dist_despegue_y_arrivosLa cual se puede obtener con el siguiente código:

#Tranformación de los datos e Histograma
l1=ggplot(data=flights2,aes(x=log(87+arr_delay)))+geom_histogram(color="black",aes(fill=factor(origin)))+
xlab('Log(87+arr_delay)')+ylab('Conteo')+ggtitle('Histograma de los retrasos en tiempo de arrivo')+theme(plot.title=element_text(lineheight = 2,face='bold'))

l2=ggplot(data=flights2,aes(x=log(43+dep_delay)))+geom_histogram(color="black",aes(fill=factor(origin)))+
  xlab('Log(43+dep_delay)')+ylab('Conteo')+ggtitle('Histograma de los retrasos de tiempo de despegues')+theme(plot.title=element_text(lineheight = 2,face='bold'))

grid.arrange(l1,l2,nrow=1,ncol=2,main="Gráficas del comportamiento de vuelos por mes")

Se observa entonces que los datos muestran comportamientos de distribuciones de cols pesadas, lo cual requiere una revisión más meticulosa. Haciendo el gráfico de cruce entre los dos tiempos de retrasos, pero considerando sus valores transformados se obtienen el siguiente gráfico log-log.

Log_vs_log_distancia-arrivosEl otro par de variables que sugiere que tienen alguna relación son la distancia del vuelo y el tiempo de vuelo. La gráfica se puede realizar con el siguiente código:

ggplot(data=flights2,aes(x=air_time,y=distance))+geom_point(aes(colour=factor(origin)))+
  xlab('Tiempo de vuelo')+ylab('Distancia recorrida')+ggtitle('Cruce entre la distancia y el tiempo de vuelo')+theme(plot.title=element_text(lineheight = 2,face='bold'))

La gráfica que se obtiene es la siguiente:

Cruce_Dis_vs_Tiempo_vueloLa gráfica a primera vista sugiere una relación lineal, pero también se puede explorar si no resulta favorable considerar el log-log de los datos, esto por aquellos datos que muestran desconexión en la parte superior de la gráfica.

ggplot(data=flights2,aes(x=log(distance),y=log(air_time)))+geom_point(aes(colour=factor(origin)))+
  xlab('Logaritmo del Tiempo de vuelo')+ylab('Logaritmo de la Distancia recorrida')+ggtitle('Cruce entre la distancia y el tiempo de vuelo')+theme(plot.title=element_text(lineheight = 2,face='bold'))

La gráfica que se obtiene es la siguiente:

Cruce_Log_de_Dist_vs_Timepo_VueloTambién muestra una relación lineal pero es posible que revisando un ajuste lineal entre los datos sea favorable considerar el log-log para cubrir una mayor  población de los datos.

Los siguientes gráficos solo son ejemplos para explorar la información en busca de alguna posible relación entre los datos.

JitterHoras_de_despegueEl código de los dos gráficos es el siguiente:

ggplot(data=flights2,aes(x=factor(carrier),y=factor(origin)))+geom_jitter()
#ggplot(data=flights2,aes(x=hour))+geom_bar(aes(colour=origin,fill=origin),position = "dodge")+coord_flip()

ggplot(data=flights2,aes(x=hour))+geom_bar(color="black",aes(fill=origin))+
  xlab('hora del día')+ylab('Conteo')+ggtitle('Histograma de las horas de despegue o salida')

Estos dos gráficos, sobre todo el primero; son informativos por ejemplo las barras negras muestran por aeropuerto qué aerolíneas tienen actividad. Es inmediatamente es claro cuales aerolíneas tienen presencia y la diferencia entre la actividad por aeropuerto.

La segunda gráfica muestra 3 momentos donde no se registran vuelos, lo cual resulta raro pero los datos de muestran esto, lo cual implica a ser explorado con mayor detalle.

Un gráfico que suele hacerse entre varias variables o entre una matriz de datos es el scatter plot, para explorar la posible relación entre cada par de variables. Para realizarlo en R con ggplot, se ejecuta el siguiente código:

#Scatter Plot
ggpairs(data=flights2[,c("dep_delay","arr_delay","air_time","distance")],columns=1:4,title="Datos")

La gráfica que se obtiene es la siguiente:

Scatterplot-flighLa gráfica de arriba solo muestra la relación entre varias variables de los datos no de todas. La información de la gráfica incluye la correlación, la cual muestra que es casi nula entre algunas de las variables y muy próxima a 1 en dos pares de variables. La otra opción es hacer una revisión entre las variables pero no solo usando la correlación, sino la el índice de información Mutua. Este último no solo considera la posible relación lineal, sino también una posible relación no lineal. Para realizar el cálculo en R project se puede usar la librería “entropy”.

Ejemplo en R la información mutua entre arr_delay y distance, es de 0.0406. Lo cual indica que no existe alguna relación que analizar.

Con la breve exploración anterior se puede ir pensando en el tipo de cosas que pueden resultar interesantes o que podían ser modeladas, ejemplo pronosticar conociendo el lugar de despegue la hora y la aerolínea el lugar de arribo, o construir un modelo para clasificar los datos de vuelos por el aeropuerto de origen. Pronosticar la cantidad de vuelos por aeropuerto para el siguiente año, o pronosticar los tiempo de atraso en arribar un vuelo conociendo el origen, el horario, el mes de vuelo y el lugar al cual arribará.

Por su puesto que el tipo de preguntar a responder depende de la persona que está explorando los datos o el negocio que requiere este análisis. Por lo cual en esta entrada solo deseaba mostrar algunos gráficos que se pueden ayudar a explorar los datos, al final la primera parte de realizar algún análisis es explorar aspectos estadísticos básicos y apoyarse de alguna gráfica ayuda a tener alguna visualización de la información.

Análisis similar con Python

 El procesamiento de datos en Python en general es realizado siempre en el módulo pandas, las estructuras de datos para procesar información es similar a R project. Se cuenta con estructuras de datos como Data.Frame y Series, como su nombre lo indica funcionan equivalentemente a las de R.

Se pueden usar en Python algunos de los datos de R project haciendo uso de algún módulo, ejemplo el módulo Stats Models tienen un api para conectarse con los datos de R project, lo cuales se encuentran su lista en Rdatasets.

En el ejemplo lo que hice fue exportar los datos de la librería nycflights13 a un archivo csv y cargarlo en una sección en Pandas de Python.

El código es el siguiente:

#Carga de datos
import pandas as pd
#Cargar datos
flights=pd.read_csv('flights.csv')

Para procesar o explorar la descripción básica de los datos se hacer con los siguientes código.

#Revisión de los datos
#Se ve un resumen de lso datos
flights.head()
flights.shape()

Unas de las cosas estándar al hacer análisis es procesar los missing data, lo cual se puede hacer en python con el siguiente código.

#Revisión
#Un modo burdo de ver que tienen missin values
flights[flights.isnull()!=True].count()
#Nuevo data.frame para los datos sin missin value
flights2=flights.dropna()
flights2[flights2.isnull()!=True].count()

Otro aspecto básico es revisar la descripción de la información de manera general, es decir; revisar aquella variables que son categóricas como origin o dest y también revisar la descripción estadística de variables que pueden ser consideradas continuas, como dep_delay o distance.

#Revisión de algunas variables
#Para conocer la información en general de los datos
flights2.info()
flights2.describe()
#Se exploran algunas de las variables que no son númericas y otras númericas
#Variables continua
flights2['dep_delay'].describe()
flights2['distance'].describe()

#Variables categoricas
flights2['origin'].astype('category').value_counts()
flights2['origin'].astype('category').describe()
flights2['dest'].astype('category').value_counts()
flights2['dest'].astype('category').describe()

Ahora para visar algunas gráficas básicas sobre las variables se usa en general matplotlib, pese a que pandas cuanta con algunas gráficas básicas como histogramas,gráficas de barras y boxplot.

Otra opción de reciente desarrollo es ggplot en python, la cual no cuenta con la misma flexibilidad que en R, pero está en desarrollo. La diferencia entre matplot y ggplot es en esencia que este último fue desarrollado con la perspectiva de “Grammar of Graphics”, mientras que matplot fue pensado en el marco de desarrollo de gráficos  que se usan en matlab. El concepto de ggplot, en recientes años a tomado relevancia ya que se pueden construir gráficos de manera rápida que involucran de fondo una transformación de los datos.

Un ejemplo es el siguiente, el cual se hace con los gráficos de base de pandas.

#Boxplot
df=flights2[['month','origin']]
df.boxplot(by='origin')

Boxplot_por_Mes

El gráfico es similar al que se obtienen en ggplot con R, pero en su defecto en R no se requiere seleccionar los datos y directamente indicar que se agrupen para hacer el gráfico.

Entonces para hacer un análisis gráfico rápido me resulta más fácil pensarlo en R que en Python, pero se obtienen ciertas ventajas en Python que no se obtienen en R.

Otra opción que existe es usar los gráficos de R desde pandas con el módulo rpy2, por medio del cual de cierto modo se usa todo lo que se quiera de R y se utiliza en python.

Un ejemplo de ggplot en Python, usando el módulo para python y no desde R, es el siguiente:

#Gráfica de barras
from ggplot import *


print ggplot(flights2,aes(x='month',fill='factor(origin)'))+\
 geom_bar(color="black")+\
 ggtitle('Barras por cada Mes')+\
 theme(plot_title=element_text(lineheight=2))+\
 ylab('Cantidad de Vuelos por Mes')+\
 xlab('Meses')

Barras_por_mes

El gráfico es parecido al primero que mostré en R. El boxplot de los vuelos en matplotlib se puede obtener del siguiente modo:

#Boxplot Maplotlib
import numpy as np
import matplotlib.pyplot as plt

plt.style.use('ggplot')

fig,ax1=plt.subplots()
ax1.boxplot(Mes,showmeans=True)
ax1.set_title('Boxplot de vuelos por mes')
ax1.set_xlabel('Valores')
ax1.set_ylabel('Meses')
plt.show()

Boxplot de los meses

Los histogramas para explorar el comportamiento de los tiempo de retraso y de despegue se obtienen en ggplot para python se obtienen con el siguiente código.

#Histogramas
from ggplot import *
print ggplot(flights2,aes(x='dep_time',fill='origin'))+\
 geom_histogram(color="black")+\
 ggtitle('Histograma de la hora despegue')+\
 theme(plot_title=element_text(lineheight=2))+\
 ylab('Cantidad de vuelos')+\
 xlab('Horario')

print ggplot(flights2,aes(x='arr_time',fill='origin'))+\
 geom_histogram(color="black")+\
 ggtitle('Histograma de la hora de arribo')+\
 theme(plot_title=element_text(lineheight=2))+\
 ylab('Cantidad de vuelos')+\
 xlab('Horario')

Histograma_despegues

Histograma_arribos

La gráfica del cruce entre los retrasos de arribo y despegue se obtienen de manera similar a la que se realiza en ggplot para R, lo único que se hace notar, es que la librería ggplot para python es más lenta al crear una gráfica con muchos datos.

#Scatter plot
from ggplot import *
print ggplot(flights2,aes(x='dep_delay',y='arr_delay'))+\
 geom_point()+\
 geom_smooth(color="red")+\
 ggtitle('Cruce de retrasos')+\
 theme(plot_title=element_text(lineheight=2))+\
 ylab('Retrasos en arribos')+\
 xlab('Retrasos en despegue')

Cruce_de_retrasos

Para hacer una gráfica similar en matplotlib se observa que el código es más elaborado, se obtiene una gráfica similar pero con mayor cantidad de líneas de programación.

#Ejemplo en Matplotlib
import matplotlib.pyplot as plt

for aero in ['LGA', 'JFK', 'EWR']:
 x =flights2.loc[flights2.loc[:,'origin']==aero,'dep_delay']
 y = flights2.loc[flights2.loc[:,'origin']==aero,'arr_delay'] 
 
 if aero=='EWR':
 color='red'
 plt.scatter(np.asarray(x.values)[:len(x)-1],np.asarray(y.values)[:len(y)-1],
 c=color, label=aero)
 
 if aero =='JFK':
 color='blue'
 plt.scatter(np.asarray(x.values)[:len(x)-1],np.asarray(y.values)[:len(y)-1],
 c=color, label=aero)

 if aero=='LGA':
 color='green'
 plt.scatter(np.asarray(x.values)[:len(x)-1],np.asarray(y.values)[:len(y)-1],
 c=color, label=aero) 
 

plt.legend(loc=4)
plt.grid(True)
plt.title('Scatter plot de los retrasos')
plt.ylabel('Retrasos en despegues')
plt.xlabel('Retrasos en arribos')
plt.show()

La gráfica es la siguiente:

Scatter_plot_retrasos

Otra gráfica fácil de hacer es la del comportamiento de los histogramas de los retrasos, tanto de despegues como de arribos.

El código es el siguiente:

#Histogramas
import matplotlib.pyplot as plt

plt.style.use('bmh')

x =flights2['dep_delay']
y = flights2['arr_delay'] 

x1=np.asarray(x.values)[:len(x)-1]
y1=np.asarray(y.values)[:len(y)-1]
plt.hist(x1, histtype="stepfilled",
 bins=20, alpha=0.8, normed=True)
plt.hist(y1, histtype="stepfilled",
 bins=20, alpha=0.8, normed=True)
plt.title('Histogramas de los retrasos de despeque y de llegada')
plt.xlabel('Valores de los retrasos')
plt.ylab('Cantidad de retrasos')
plt.show()

La gráfica es la siguiente:

Histogramas_de_los_retrasos

Para hacer un panel de gráficos como el de la exploración en R, se tiene que diseñar el panel con el número de gráficos que se desea. Esto en el fondo también sucede con R, solo que en matplotlib uno tiene que hacer el código con mayor detalle.

Espero que estas cuantas gráficas hechas en python de una imagen de lo versátil que es, se requiere en general procesar más los datos pero se puede tener mayor control sobre el tipo de gráficos que se pueden hacer.En la referencia [4] se pueden consultar muchas gráficas de muestra.

Referencias

1.-http://static.googleusercontent.com/media/research.google.com/es//archive/mapreduce-osdi04.pdf

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

3.-http://ggplot2.org/

4.-http://matplotlib.org/

5.-http://pandas.pydata.org/pandas-docs/stable/groupby.html

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