library(plotly) # construir graficas interactivas## Loading required package: ggplot2##
## Attaching package: 'plotly'## The following object is masked from 'package:ggplot2':
##
## last_plot## The following object is masked from 'package:stats':
##
## filter## The following object is masked from 'package:graphics':
##
## layoutlibrary(listviewer) # para visualizar listados o menus
library(ggforce) #
library(lubridate) #Ayudan a separar los componentes de la fecha y hora cuando no tienen una estructura definida. ##
## Attaching package: 'lubridate'## The following objects are masked from 'package:base':
##
## date, intersect, setdiff, unionlibrary(modelr) #
library(GGally) #hacer varis graficos juntos## Registered S3 method overwritten by 'GGally':
## method from
## +.gg ggplot2library(dplyr) #manipular datos##
## Attaching package: 'dplyr'## The following objects are masked from 'package:stats':
##
## filter, lag## The following objects are masked from 'package:base':
##
## intersect, setdiff, setequal, unionlibrary(naniar) #visualizar datos perdidos de un conjunto de datos
library(quantmod) #trazar datos financieros de distintas fuentes## Loading required package: xts## Loading required package: zoo##
## Attaching package: 'zoo'## The following objects are masked from 'package:base':
##
## as.Date, as.Date.numeric##
## ################################### WARNING ###################################
## # We noticed you have dplyr installed. The dplyr lag() function breaks how #
## # base R's lag() function is supposed to work, which breaks lag(my_xts). #
## # #
## # Calls to lag(my_xts) that you enter or source() into this session won't #
## # work correctly. #
## # #
## # All package code is unaffected because it is protected by the R namespace #
## # mechanism. #
## # #
## # Set `options(xts.warn_dplyr_breaks_lag = FALSE)` to suppress this warning. #
## # #
## # You can use stats::lag() to make sure you're not using dplyr::lag(), or you #
## # can add conflictRules('dplyr', exclude = 'lag') to your .Rprofile to stop #
## # dplyr from breaking base R's lag() function. #
## ################################### WARNING #####################################
## Attaching package: 'xts'## The following objects are masked from 'package:dplyr':
##
## first, last## Loading required package: TTR## Registered S3 method overwritten by 'quantmod':
## method from
## as.zoo.data.frame zoo`
data(economics, package = "ggplot2")
p <- economics %>%
arrange(psavert) %>%
plot_ly(x = ~date, y = ~psavert)
add_paths(p)add_lines(p)Figura 3.1
econ <- economics %>%
mutate(yr = year(date), mnth = month(date))
econ %>%
group_by(yr) %>%
plot_ly(x = ~mnth, y = ~uempmed) %>%
add_lines(text = ~yr)plot_ly(econ, x = ~mnth, y = ~uempmed) %>%
add_lines(color = ~ordered(yr))figura 3.2
set.seed(99)
plot_ly() %>%
add_trace(
type = "scatter",
mode = "markers+lines+text",
x = 4:6,
y = 4:6,
text = replicate(3, praise::praise("You are ${adjective}! 🙌")),
textposition = "right",
hoverinfo = "text",
textfont = list(family = "Roboto Condensed", size = 16)
) %>%
layout(xaxis = list(range = c(3, 8)))FIGURE 3.3: Aquí se usa la funcion generica add_trace() para representar marcadores, texto y lineas en una sola grafica de dispersión.Tanto esta como cualquier otra función add_() te permite especificar los atributos de plotly.js
si se es nuevo usando plotly.js es recomendado dedicarle un poco mas de tiempo a obervar los atributos disposibles para este tipo de trazas de dispersión. La mayoría de estos atributos también funcionan para otros tipos de trazas, por lo que aprender un atributo una vez para un gráfico específico puede ser útil en otros contextos también. La referencia de figuras de plotly.js en línea, https://plot.ly/r/reference/#scatter, es un lugar decente para buscar y aprender acerca de los atributos, se recumienda utilizar la función schema() por algunas razones:
+schema() proporciona un poco más de información que la documentación en línea (por ejemplo, tipos de valores, valores predeterminados, rangos aceptables, etc.). +La interfaz facilita un poco la exploración y el descubrimiento de nuevos atributos. +Puedes estar absolutamente seguro de que coincide con la versión utilizada en el paquete R (la documentación en línea puede utilizar una versión diferente, probablemente más antigua).
schema()Figure 3.4: se usa “schema()” para atravesar los atributos disponibles para estas graficas de dispersión
A continuacion veremos distintos tipos de vistas de datas usando “catter-based layers”. Para evitar la duplicacion de documentos se hace especial hincapié en las funciones que actualmente solo están disponibles en el paquete R.
Esta sección describe cómo trabajar con trazas de dispersión que utilizan el modo “marcadores” (es decir, add_markers()). Para simplificar los ejemplos, la mayoría de ellos utilizan add_markers() con un eje numérico x e y, lo que resulta en un diagrama de dispersión, una forma común de visualizar la relación entre dos variables cuantitativas. El contenido a continuación es relevante para variables cualitativas.
tal como lo mencionó Unwin (2015), los graficos de dispercion pueden ser usados para representar distintas caracteristicas importantes. la cosa es que el problema con los graficos de dispersión es la superposición de los datos (datos uno escima de otro o muy pegados). En la siguiente figura se ve una forma de contrarrestar la superposición con la ayuda de alpha blending. con muestras demasiado grandes se recomienda usar mejor “toWebGL()”.
subplot(
plot_ly(mpg, x = ~cty, y = ~hwy, name = "default"),
plot_ly(mpg, x = ~cty, y = ~hwy) %>%
add_markers(alpha = 0.2, name = "alpha")
)## No trace type specified:
## Based on info supplied, a 'scatter' trace seems appropriate.
## Read more about this trace type -> https://plotly.com/r/reference/#scatter## No scatter mode specifed:
## Setting the mode to markers
## Read more about this attribute -> https://plotly.com/r/reference/#scatter-modeFIGURE 3.5: luchando contra la superposición en el grafico de dispersion usando alpha blending.
tal como se discutio en la seccion 2.2, el mapear una variable discreta a “color” nos genera trazas por categorias, algo deseado para las propiedades de la leyenda y cursor. al mapear una variable numérica a “color” se produce una sola traza, junto a una guía de colorbar para decodificar visualmente los colores de vuelta a los valores de los datos. La función “colorbar()”es usada para perzonalizar la apariencia de la guia generada. La escala de colores predeterminada es viridis, una escala de colores perceptualmente uniforme (incluso cuando se convierte en blanco y negro) y perceptible incluso para aquellos con formas comunes de daltonismo (Berkeley Institute for Data Science 2016).
p <- plot_ly(mpg, x = ~cty, y = ~hwy, alpha = 0.5)
subplot(
add_markers(p, color = ~cyl, showlegend = FALSE) %>%
colorbar(title = "Viridis"),
add_markers(p, color = ~factor(cyl))
)FIGURE 3.6: variacion de color en un mapeo. Se puede alterar los colores usados usando el comando “color”, aunque tiene algunas exepciones: 1.una paleta de colores mezclados, 2.un vector de colores para interpolar, 3. una función de interpolación de colores como lo es “colorRamp()” o “scales::colour_ramp()”. pese a que esto otorga mucha flexibilidad, uno debe ser consciente de usar una escala de colores secuencial para variables numéricas (y factores ordenados) tal como se muestra en las siguiente figura:
col1 <- c("#132B43", "#56B1F7")
col2 <- viridisLite::inferno(10)
col3 <- colorRamp(c("red", "white", "blue"))
subplot(
add_markers(p, color = ~cyl, colors = col1) %>%
colorbar(title = "ggplot2 default"),
add_markers(p, color = ~cyl, colors = col2) %>%
colorbar(title = "Inferno"),
add_markers(p, color = ~cyl, colors = col3) %>%
colorbar(title = "colorRamp")
) %>% hide_legend()FIGURE 3.7: 3 variaciones en un mapa numerico
tambien se debe ser conciente al seleccionar una escala de colores cualitativa para variables discretas
col1 <- "Accent"
col2 <- colorRamp(c("red", "blue"))
col3 <- c(`4` = "red", `5` = "black", `6` = "blue", `8` = "green")
subplot(
add_markers(p, color = ~factor(cyl), colors = col1),
add_markers(p, color = ~factor(cyl), colors = col2),
add_markers(p, color = ~factor(cyl), colors = col3)
) %>% hide_legend()FIGURE 3.8: tres variaciones en un mapa de variables discretas.
tal como ya se mencionó en la seccion 2.3, los colores pueden ser seleccionados manualmente a travez del argumento “I()”. En la siguiente figura se ve un ejemplo de esto, ademas, usando la función “add_markers()”.Cualquier color entendido por la función col2rgb() del paquete grDevices puede usarse de esta manera.
add_markers(p, color = I("black"))FIGURE 3.9: Se modifico el color manualmente usando I().
El argumento “color” se utiliza para controlar el color de relleno de un objeto geométrico, mientras que “stroke” (sección 3.1.4) se utiliza para controlar el color del contorno de un objeto geométrico. En el caso de add_markers(), esto significa que el color se asigna al atributo de plotly.js marker.color y el stroke se asigna a marker.line.color. No todos los símbolos de marcador, pero muchos de ellos, tienen una noción de “stroke”
El argumento symbol se utiliza para asignar valores de datos al atributo marker.symbol de plotly.js. Usa la misma semántica que hemos visto para el color:
+Una asignación numérica genera una traza. +Una asignación discreta genera múltiples trazas (una traza por categoría). +El plural, symbols, se puede usar para especificar el rango visual para la asignación. +Las asignaciones se evitan por completo a través de I().
Cuando se trazan varias trazas y no se especifica el color, se aplica la secuencia de colores de plotly.js (es decir, cada traza se representará con un color diferente). Para establecer un color fijo, se puede establecer el color de cada traza generada de esta capa con color = I(“black”), o similar.
p <- plot_ly(mpg, x = ~cty, y = ~hwy, alpha = 0.3)
subplot(
add_markers(p, symbol = ~cyl, name = "A single trace"),
add_markers(p, symbol = ~factor(cyl), color = I("black"))
)FIGURE 3.10: Asignación de símbolo a una variable numérica (izquierda) y a un factor (derecha).
Hay 2 formas de especificar los rangos visuales de “symbol”: 1. codigos numericos (codigos “pch”), 2.una cadena de caracteres que especifica un marker.symbol valido. En la siguiente figura se puede ver el uso de ambas formas.
subplot(
add_markers(p, symbol = ~cyl, symbols = c(17, 18, 19)),
add_markers(
p, color = I("black"),
symbol = ~factor(cyl),
symbols = c("triangle-up", "diamond", "circle")
)
)FIGURE 3.11: Especificando el rango visual de los simbolos
Estos symbols ( rango visual) también se pueden ajustar al gusto a través de I(). Por ejemplo, la figura 3.12 fija el símbolo del marcador en forma de diamante.
plot_ly(mpg, x = ~cty, y = ~hwy) %>%
add_markers(symbol = I(18), alpha = 0.5)FIGURE 3.12: ajustando los simbolos con I().
El argumento Stroke sigue la misma via que el color y el symbol cuando se trata de asignaciones de variables y especificación de rangos visuales. Generalmente, no se desea asignar valores de datos a trazos, sino simplemente especificar un color de contorno fijo. Por ejemplo, la Figura 3.13 modifica la Figura 3.12 para agregar simplemente un contorno negro. Por defecto, el span del trazo es cero, por lo que es recomendable establecer un ancho alrededor de un píxel.
plot_ly(mpg, x = ~cty, y = ~hwy, alpha = 0.5) %>%
add_markers(symbol = I(18), stroke = I("black"), span = I(1))FIGURE 3.13: se usa stroke an span para controlar el contorneo de los puntos asi como en ancho de este borde.
Para graficos de dispersión, el argumento Size controla el tamaño de los marcadores, debe de ser una variable numerica. el argumento “size” controla el maximo y minimo del tamaño del circulo, por pixel:
p <- plot_ly(mpg, x = ~cty, y = ~hwy, alpha = 0.3)
subplot(
add_markers(p, size = ~cyl, name = "default"),
add_markers(p, size = ~cyl, sizes = c(1, 500), name = "custom"))## Warning: `line.width` does not currently support multiple values.
## Warning: `line.width` does not currently support multiple values.FIGURE 3.14: Controlando el rango del tamaño a traves de “size”
De manera similar a otros argumentos, I() se puede usar para especificar el tamaño directamente. En el caso de los marcadores, el tamaño controla el atributo marker.size plotly.js. Siempre estara la opcion de ajustar el atributo haciendo algo similar a la Figura 3.15.
plot_ly(mpg, x = ~cty, y = ~hwy, alpha = 0.3, size = I(30))## No trace type specified:
## Based on info supplied, a 'scatter' trace seems appropriate.
## Read more about this trace type -> https://plotly.com/r/reference/#scatter## No scatter mode specifed:
## Setting the mode to markers
## Read more about this attribute -> https://plotly.com/r/reference/#scatter-modeFIGURE 3.15: ajustando marcadores usando ¨marker.size¨.
El dotplot es similar a un scatterplot, pero en lugar de dos ejes numéricos, uno es categórico. El objetivo usual de un dotplot es comparar valor(es) en una escala numérica sobre numerosas categorías. En este contexto, los dotplots son preferibles a los gráficos de torta y a los gráficos de barras. Además, son particularmente útiles cuando se presentan estimaciones de puntos y la incertidumbre asociada con estas estimaciones. Una aplicación popular de los dotplots con barras de error es el “coeficiente de trazado” para visualizar las estimaciones de puntos de los coeficientes y su error estándar. La función coefplot() y ggcoef() producen coeficientes de trazado para muchos tipos de objetos de modelo en R utilizando ggplot2, que se pueden traducir a plotly mediante ggplotly(). Figure 3.16 utiliza la función tidy() para producir un coeficiente de trazado con barras de error a lo largo del eje x.
m <- lm(
Sepal.Length ~ Sepal.Width * Petal.Length * Petal.Width,
data = iris
)
broom::tidy(m) %>%
mutate(term = forcats::fct_reorder(term, estimate)) %>%
plot_ly(x = ~estimate, y = ~term) %>%
add_markers(
error_x = ~list(value = std.error),
color = I("black"),
hoverinfo = "x"
)FIGURE 3.16: Grafica de coeficientes
En relación a los marcadores, muchos de los mismos principios que aprendimos sobre las asignaciones estéticas también se aplican a las líneas. Además, al inicio del capítulo (específicamente en la Figura 3.2), aprendimos cómo usar group_by() de dplyr para asegurarnos de que haya al menos una geometría (en este caso, línea) por grupo. También aprendimos la diferencia entre add_paths() y add_lines() - el primero dibuja líneas según el orden de las filas, mientras que el segundo las dibuja según x. En este capítulo, aprenderemos sobre linetype/linetype, una estética que se aplica a las líneas y polígonos. También discutiremos otros tipos importantes de gráficos que se pueden implementar con add_paths(), add_lines() y add_segments().
En este caso, usamos el paquete dplyr para encontrar las 5 ciudades principales en términos de ventas mensuales promedio (top5), y filtramos eficazmente los datos originales para contener solo estas ciudades a través de “semi_join()”. Como demuestra la Figura 3.17, una vez que tenemos los datos filtrados, asignar color o tipo de línea a la ciudad es trivial. La paleta de colores se puede modificar a través del argumento “colors”, y sigue las mismas reglas que en los gráficos de dispersión. La paleta de tipos de línea se puede modificar a través del argumento “linetypes”, y acepta los valores lty de R o los valores de guiones de plotly.js.
top5 <- txhousing %>%
group_by(city) %>%
summarise(m = mean(sales, na.rm = TRUE)) %>%
arrange(desc(m)) %>%
top_n(5)## Selecting by mtx5 <- semi_join(txhousing, top5, by = "city")
plot_ly(tx5, x = ~date, y = ~median) %>%
add_lines(linetype = ~city)FIGURE 3.17: Usando “color” y “linetype” para diferenciar los grupos.
Si te gustaria colocar el tipo de lina que salga para determinado dato, puedes agregarle un vector de carácter nombrado.
ltys <- c(
Austin = "dashdot",
`Collin County` = "longdash",
Dallas = "dash",
Houston = "solid",
`San Antonio` = "dot"
)
plot_ly(tx5, x = ~date, y = ~median) %>%
add_lines(linetype = ~city, linetypes = ltys)FIGURE 3.18: preveyendo una caracteristica vectorial a cada conjunto de datos para ajustarlo al gusto
La función add_segments() esencialmente provee una manera de conectar dos puntos [(x, y) a (xend, yend)] con una línea. Los segmentos forman la base para numerosos tipos de gráficos útiles, incluyendo slopegraphs, dumbell charts, candlestick charts, y más. Los slopegraphs y dumbell charts son útiles para comparar valores numéricos en numerosas categorías. Los candlestick charts son típicamente usados para visualizar cambios en un activo financiero a lo largo del tiempo.
Tipicamente usado para comparar entre dos diferentes clases de valores numéricos a través de numerosos grupos. La Figura 3.20 utiliza el enfoque de dumbell para mostrar el promedio de millas por galón en ciudad y carretera para diferentes modelos de autos. Con un gráfico de dumbell, siempre es una buena idea ordenar las categorías por una métrica sensata - para la Figura 3.20, las categorías están ordenadas por las millas por galón en ciudad.
mpg %>%
group_by(model) %>%
summarise(c = mean(cty), h = mean(hwy)) %>%
mutate(model = forcats::fct_reorder(model, c)) %>%
plot_ly() %>%
add_segments(
x = ~c, y = ~model,
xend = ~h, yend = ~model,
color = I("gray"), showlegend = FALSE
) %>%
add_markers(
x = ~c, y = ~model,
color = I("blue"),
name = "mpg city"
) %>%
add_markers(
x = ~h, y = ~model,
color = I("red"),
name = "mpg highway"
) %>%
layout(xaxis = list(title = "Miles per gallon"))FIGURE 3.20: A dumbell chart de millas por galon y el hight way de los modelos de auto.
La Figura 3.21 utiliza el paquete quantmod (Ryan 2016) para obtener datos de precios de acciones de Microsoft y traza dos segmentos para cada día: uno para codificar los valores de apertura / cierre y otro para codificar el alto / bajo diario. Esta utiliza add_segments() para implementar candlestick, pero las versiones más recientes de plotly.js contienen candlestick y ohlc, ambas útiles para visualizar datos financieros.
msft <- getSymbols("MSFT", auto.assign = F)
dat <- as.data.frame(msft)
dat$date <- index(msft)
dat <- subset(dat, date >= "2016-01-01")
names(dat) <- sub("^MSFT\\.", "", names(dat))
plot_ly(dat, x = ~date, xend = ~date, color = ~Close > Open,
colors = c("red", "forestgreen"), hoverinfo = "none") %>%
add_segments(y = ~Low, yend = ~High, size = I(1)) %>%
add_segments(y = ~Open, yend = ~Close, size = I(3)) %>%
layout(showlegend = FALSE, yaxis = list(title = "Price")) %>%
rangeslider()FIGURE 3.21: gráfico de velas creado con “add_segments()”,mapeo de colores, que es un vector lógico (VERDADERO si el valor de cierre fue mayor que el de apertura), crea dos trazos: un trazo rojo que indica una caída en el precio y un trazo verde bosque que indica un aumento en el precio.
Podemos aprovechar la función de density() para calcular las estimaciones de densidad del kernel de una manera similar y enrutar los resultados a add_lines (), como se hace en la Figura 3.22.
kerns <- c("gaussian", "epanechnikov", "rectangular",
"triangular", "biweight", "cosine", "optcosine")
p <- plot_ly()
for (k in kerns) {
d <- density(economics$pce, kernel = k, na.rm = TRUE)
p <- add_lines(p, x = d$x, y = d$y, name = k)
}
pFIGURE 3.22: distintas estimaciones de densidad de Kernel.
Proporcionan una forma de comparar valores a lo largo de una escala posicional común (o no alineada) en más de 3 dimensiones. Cada línea representa cada medición para una fila (u observación) en un conjunto de datos. Plotly.js proporciona un tipo de traza, “parcoords”, específicamente para coordenadas paralelas que ofrece capacidades interactivas deseables. Sin embargo, también puede ser útil aprender a usar add_lines() para implementar coordenadas paralelas ya que puede ofrecer más flexibilidad y control sobre las escalas de los ejes. Cuando las mediciones están en escalas muy diferentes, se debe tener cuidado y las variables deben transformarse para ponerse en una escala común. Como muestra la Figura 3.23, incluso cuando las variables se miden en una escala similar, puede ser informativo transformar las variables de diferentes maneras.
iris$obs <- seq_len(nrow(iris))
iris_pcp <- function(transform = identity) {
iris[] <- purrr::map_if(iris, is.numeric, transform)
tidyr::gather(iris, variable, value, -Species, -obs) %>%
group_by(obs) %>%
plot_ly(x = ~variable, y = ~value, color = ~Species) %>%
add_lines(alpha = 0.3)
}
subplot(
iris_pcp(),
iris_pcp(scale),
iris_pcp(scales::rescale),
nrows = 3, shareX = TRUE
) %>% hide_legend()## Warning: attributes are not identical across measure variables; they will be
## droppedFIGURE 3.23: Gráficos de coordenadas paralelas del conjunto de datos Iris. El panel superior muestra todas las variables en una escala común. El panel central escala cada variable para tener una media de 0 y una desviación estándar de 1. En el panel inferior, cada variable se escala para tener un mínimo de 0 y un máximo de 1
El paquete GGally proporciona la función ggparcoord(), que crea gráficos de coordenadas paralelas a través de ggplot2, que se pueden convertir a plotly a través de ggplotly(). Gracias al marco de resaltado vinculado, las coordenadas paralelas creadas de esta manera podrían vincularse a gráficos de datos relacionados de menor dimensión (pero a veces de mayor resolución) para guiar la exploración de datos multivariados.
La función add_polygons() es esencialmente equivalente a add_paths() con el atributo de relleno establecido en “toself”. Los polígonos forman la base para otras capas de dispersión de nivel superior (por ejemplo, add_ribbons() y add_sf()) que no tienen un tipo de traza dedicado en plotly.js. Los polígonos pueden ser utilizados para dibujar muchas cosas, pero quizás la aplicación más familiar donde se puede utilizar add_polygons() es para dibujar objetos geo-espaciales. Si y cuando se usa add_polygons() para dibujar un mapa, asegúrese de fijar la relación de aspecto (por ejemplo, xaxis.scaleanchor) y también considere el uso de plotly_empty() sobre plot_ly() para ocultar las etiquetas de los ejes, los ticks y la rejilla de fondo.
base <- map_data("world", "canada") %>%
group_by(group) %>%
plotly_empty(x = ~long, y = ~lat, alpha = 0.2) %>%
layout(showlegend = FALSE, xaxis = list(scaleanchor = "y"))
base %>%
add_polygons(hoverinfo = "none", color = I("black")) %>%
add_markers(text = ~paste(name, "<br />", pop), hoverinfo = "text",
color = I("red"), data = maps::canada.cities)Figura 3.24: se usa add_poligon() para crear un mapa de canada indicando sus ciudades, todo esto gracias a el paquete de maps
La discusión en torno a la Figura 4.10 señala que, por defecto, las capas de polígonos basados en dispersión (es decir, add_polygons(), add_ribbons(), etc.) renderizan todos los polígonos utilizando una sola traza de plotly.js. Este enfoque es eficiente en términos computacionales, pero no siempre es deseable (por ejemplo, no se pueden tener múltiples rellenos por traza, la interactividad es relativamente limitada). Para trabajar en torno a estas limitaciones, se recomienda considerar el uso de split (o color con una variable discreta) para dividir los datos del polígono en múltiples trazas.
add_polygons(base, split = ~subregion, hoveron = "fills")Figura3.25: se usa split para hacer un mapa mas interactivo
La función add_ribbons() crea bandas de incertidumbre para mostrar límites de incertidumbre en función de x. Requiere los argumentos x, ymin e ymax. Además, la función augment() del paquete broom añade componentes de modelo a nivel de observación (por ejemplo, valores ajustados almacenados en una nueva columna .fitted), lo que resulta útil para extraer esos componentes de una forma conveniente para la visualización.
m <- lm(mpg ~ wt, data = mtcars)
broom::augment(m) %>%
plot_ly(x = ~wt, showlegend = FALSE) %>%
add_markers(y = ~mpg, color = I("black")) %>%
add_ribbons(ymin = ~.fitted - 1.96 ,
ymax = ~.fitted + 1.96 ,
color = I("gray80")) %>%
add_lines(y = ~.fitted, color = I("steelblue"))Figura 3.26: valores ajustados y límites de incertidumbre de un modelo lineal a través del paquete de escoba