Cuadrícula visual

La representación visual de los datos proporciona una información valiosa al analista. A veces los puntos en el gráfico no reflejan de forma clara donde se concentra la mayor cantidad de información. Vamos a utilizar una librería que provee la funcionalidad y además vamos a programar nosotros mismos una forma de producir un gráfico similar.”

Gráficos con el paquete fMultivar

Primero vamos a cargar los datos utilizando read.csv especificando la dirección donde se encuentran los datos y luego los convertirlos en una serie de tiempo con la rutina as.timeSeries. Luego calculamos los retornos utilizando timeSeries::returns mediante el método continuous, para utilizar el método de cálculo del retorno con composición del capital a tiempo contínuo (instantáneo).

Finalmente creamos dos vectores con los retornos con el nombre de cada acción, es decir, FB y AAPL.

#install.packages("fMultivar")
library(fMultivar)
#Carga de datos desde el csv
data<-read.csv("http://synergy.vision/assets/corpus/rmd/data/4tech.csv")
prices<-as.timeSeries(data)
#Cálculo de retornos
returns<-timeSeries::returns(prices, method="continuous")

#Creación del vector de retornos de FB
FB<-as.vector(returns[,"FB"])
#Creación del vector de retornos de AAPL
AAPL<-as.vector(returns[,"AAPL"])

Como ejercicio intelectual se puede estudiar las fuentes de las rutinas que construyen los gráficos con cuadrículas o inclusive hexágonos.

Ahora vamos a generar los gráficos utilizando los métodos hexBinning y squareBinning comparando los retornos de los dos activos.

par(mfrow=c(1,2))

hexHist<-hexBinning(returns[,c("FB","AAPL")], bin=30)
plot(hexHist, xlab="FB", ylab="AAPL", addPoints=FALSE, col=rev(greyPalette(30)))

sqrHist<-squareBinning(returns[,c("FB","AAPL")], bin=30)
plot(sqrHist, xlab="FB", ylab="AAPL", addPoints=FALSE , col=rev(greyPalette(30)))

par(mfrow=c(1,1))

El gráfico permite comparar los retornos de los instrumentos financieros y entender su nivel de relación lineal. Permite identificar donde se concentran los datos y los valores atípicos o extremos de los retornos de cada instrumento.

fMultivar gráficos

Gráfico de datos - FB vs. AAPL

A continuación vamos a graficar el retorno de las dos series de tiempo y entender un poco dónde se concentran los datos. Esto se hará con el comando plot(), el cual realiza una nube de puntos entre los datos de Facebook y Apple, y con el comando rug(), este último coloca sobre los ejes líneas que corresponden a los valores que se tiene de cada variable(FB y AAPL).

plot(FB, AAPL,type="p", pch=19, cex=0.01, col="black")
rug(FB, ticksize = 0.01, side = 3)
rug(AAPL, ticksize = 0.01, side = 4)

Con este gráfico se tiene puede visualizar la dispersión en un gráfico de puntos y la dispersión de cada variable sobre el eje correspondiente, observando así donde se concentran los mismos, esto nos podría ayudar a identificar datos que no se comportan como la mayoria, es decir, datos atípicos o valores extremos.

Nuestra cuadrícula

Hemos hecho un gráfico similar al que se produce en la librería fMultivar para entender el proceso de cómo se puede construir y programar un gráfico similar. Partimos de una cuadrícula y la escala de colores.

Para construir la cuadrícula primero seleccionamos en cuantas partes queremos dividir el espacio del gráfico, la cual llamaremos $bin$, es decir, partiremos el plano en $bin\times bin$ partes de igual tamaño. Luego calculamos los valores máximos y mínimos (usaremos los comandos min() y max()) que toman ambas variables, y con estos calculamos el tamaño del ancho (xbinsize) y el alto (ybinsize) de cada cuadrícula utilizando la fórmula siguiente:

#Número de cuadrículas
bin<-30

#Cálculo del mínimo y máximo de FB
FB.min<-min(FB)
FB.max<-max(FB)

#Partición del invervalo en bin partes
xbinsize<-(FB.max-FB.min)/(bin-1)

#Cálculo de mínimo y máximo de AAPL
AAPL.min<-min(AAPL)
AAPL.max<-max(AAPL)

#Partición del invervalo en bin partes
ybinsize<-(AAPL.max-AAPL.min)/(bin-1)

Ahora crearemos una matriz de tamaño $bin\times bin$, que llamaremos matriz de frecuencias, para guardar en cada posición $(i,j)$ la cantidad de datos que caen en cada celda.

Primero inicializaremos la matriz frecuencias con ceros, es decir, crearemos una matriz nula de tamaño $bin \times bin$.

freqmatrix<-matrix(rep(0, len=bin*bin), nrow=bin, ncol=bin)

Para calcular la frecuencia en cada celda, necesitamos calcular en qué cuadrícula cae cada par de datos, es decir, si consideramos el punto $(x,y)$, donde $x\in FB$ y $y\in AAPL$, utilizamos las fórmulas $(x-\min(FB)\ MOD\ \text{ancho de la cuadrícula(xbinsize)})+1$ y $(y-\min( APPL)\ MOD\ \text{alto de la cuadrícula(ybinsize)})+1$ para conseguir la posición $(i,j)$ de la cuadrícula a la cual pertenece cada punto. A dicha posición le sumamos uno, esto se repetirá para cada uno de los pares de datos. $MOD$ es la división entera entre dos números.

for (xdata in 1:length(FB)) {
  xbin<-(FB[xdata]-FB.min)%/%xbinsize + 1
  ybin<-(AAPL[xdata]-AAPL.min)%/%ybinsize + 1
  freqmatrix[xbin, ybin]<-freqmatrix[xbin, ybin] + 1  
}

Ahora a cada celda le asignamos un color, el cual dependerá de la cantidad de puntos que pertenecen a la celda, es decir, a mayor frecuencia mayor intensidad de color, cada celda estará representada por una posición de la matriz.

Para generar la paleta de colores que usaremos necesitamos calcular el valor máximo que toma la matriz de frecuencia, colocando este valor dentro del comando greyPalette() generaremos los colores que utilizaremos, genera colores en escala de grises y la intensidad del color comienza con el valor máximo calculado y va disminuyendo, luego con el comando rev() revertimos los colores, es decir, de menor intensidad a mayor intensidad.

#Cálculo del máximo en la matriz de frecuencia
fmmax<-max(freqmatrix)

#Generación de la paleta de colores
bincolors<-rev(greyPalette(fmmax))

Ahora se creará la matriz de colores, para ello iniciaremos la matriz con todas las celdas en blanco, luego con dos ciclos for recorremos la matriz de frecuencias y dependiendo del número de puntos que pertenece en cada celda se asigna un color de la paleta.

Primero crearemos una matriz que en todas las posiciones tendrá el color blanco de tamaño $bin \times bin$.

colormatrix<-matrix(rep("#ffffff", len=bin*bin), nrow=bin, ncol=bin)

Realizaremos ahora el recorrido de la matriz de frecuencias para asignar los colores, si la frecuencia es cero se deja el color blanco en la posición.

for (j in 1:bin) {
  for (i in 1:bin) {
    if (freqmatrix[i,j] != 0)
      colormatrix[i,j]<-bincolors[freqmatrix[i,j]]
  }
}

A continuación graficaremos polígonos de cuatro lados con los colores asignados a cada posición $(i,j)$ de la matriz de colores.

Crearemos un gráfico con la función plot() utilizando los pares de puntos correspondientes a FB y AAPL, pero no los mostraremos, esto es colocando type=n dentro del comando plot(), de esta forma obtenemos el marco del gráfico.

plot(FB,AAPL, type="n")

El gráfico anterior se hace con la intención de graficar los polígonos sobre el.

Para graficar los poligonos de cuatro lados, ya que queremos dividir la hoja en una grilla, se necesitan las coordenadas de los extremos de dicho polígono, entonces los extremos del polígono $i$-ésimo serán:

ancho y alto corresponden al ancho de las celdas y al alto de las celdas, es decir, xbinsize y ybinsize.

A cada uno de estos extremos se les suma el mínimo valor encontrado en cada eje ya que pudieran no comenzar en el cero y de esa manera se ajusta la escala, luego que se tenga los extremos del polígono usamos el comando polygon() con el color correspondiente de la matriz de colores para dibujarlo sobre el marco del gráfico.

for (y in 0:(bin-1)) {
  for (x in 0:(bin-1)) {
    xs<-c(x*xbinsize, (x+1)*xbinsize, (x+1)*xbinsize, x*xbinsize)+FB.min
    ys<-c(y*ybinsize, y*ybinsize, (y+1)*ybinsize, (y+1)*ybinsize)+AAPL.min
    polygon(xs, ys, xpd = NA, col = colormatrix[x+1,y+1], border = "white")
  }
}

Otra opción que podemos agregarle al gráfico son los puntos que caen en cada cuadrícula, esto lo hacemos con el comando points().

points(FB,AAPL,type="p", pch=19, cex=0.01, col="black")

Finalmente podemos agregarle líneas a los ejes que correspondan a los valores que conseguimos en cada variable con el comando rug

rug(FB, ticksize = 0.01, side = 3)
rug(AAPL, ticksize = 0.01, side = 4)

Finalmente vamos a dibujar el gráfico sin los puntos para apreciar los colores y la escala.

plot(FB,AAPL,type="n")
for (y in 0:(bin-1)) {
  for (x in 0:(bin-1)) {
    xs<-c(x*xbinsize, (x+1)*xbinsize, (x+1)*xbinsize, x*xbinsize)+FB.min
    ys<-c(y*ybinsize, y*ybinsize, (y+1)*ybinsize, (y+1)*ybinsize)+AAPL.min
    polygon(xs, ys, xpd = NA, col = colormatrix[x+1,y+1], border = NA)
  }
}
rug(FB, ticksize = 0.01, side = 3)
rug(AAPL, ticksize = 0.01, side = 4)

Es interesante cómo se pueden construir representaciones de los datos para apreciar mejor la información que pueden ofrecer y reconocer patrones o sencillamente dónde se concentran y la relación que hay entre dos variables.

Les dejamos los comandos en R en un archivo para que puedan experimentar.

Copyright © 2014-2018 Synergy Vision. Los artículos del Corpus se comparten bajo los términos de la licencia Creative Commons con Reconocimiento, Propósito no comercial, Compartir contenido similar, 4.0 Internacional (CC BY-NC-SA 4.0).

Citar el artículo.