Visualizaciones heredadas

En este artículo se describen las visualizaciones heredadas de Azure Databricks. Consulte Visualizaciones en cuadernos de Databricks para obtener compatibilidad con la visualización actual.

Azure Databricks también admite de forma nativa bibliotecas de visualización en Python y R, y permite instalar y usar bibliotecas de terceros.

Creación de una visualización heredada

Para crear una visualización heredada a partir de una celda de resultados, haga clic en + y seleccione Legacy Visualization.

Las visualizaciones heredadas admiten un amplio conjunto de tipos de trazado:

Elección y configuración de un tipo de gráfico

Para elegir un gráfico de barras, haga clic en el icono del gráfico de barras :

Para elegir otro tipo de trazado, haga clic en a la derecha del gráfico de barras y elija el tipo de trazado.

Barra de herramientas del gráfico heredado

Tanto los gráficos de líneas como los de barras tienen una barra de herramientas integrada que admite un amplio conjunto de interacciones del lado cliente.

Para configurar un gráfico, haga clic en Opciones de trazado...

El gráfico de líneas tiene varias opciones personalizadas: establecer un rango del eje Y, mostrar y ocultar puntos, y mostrar el eje Y con una escala de registro.

Para obtener información sobre los tipos de gráfico heredados, consulte:

• Migración de gráficos de líneas heredados

Coherencia de colores entre gráficos

Azure Databricks es compatible con dos tipos de consistencia de color entre los gráficos heredados: conjunto de una serie y global.

La consistencia de color de tipo conjunto de una serie asigna el mismo color al mismo valor si existen series con los mismos valores pero ordenados de forma distinta (por ejemplo, A = ["Apple", "Orange", "Banana"] y B = ["Orange", "Banana", "Apple"]). Los valores se ordenan antes de trazarse, de modo que ambas leyendas se ordenan de la misma manera (["Apple", "Banana", "Orange"]) y los mismos valores reciben los mismos colores. Sin embargo, si tiene una serie C = ["Orange", "Banana"], los colores no serían uniformes con los del conjunto A porque no es el mismo conjunto. El algoritmo de ordenación asignaría el primer color a "Banana" en el conjunto C, pero en el conjunto A le asignaría el segundo color. Si quiere que estas series tengan colores uniformes, puede especificar que los gráficos tengan una uniformidad de color global.

En la coherencia de color global, todos los valores siempre se asignan al mismo color, independientemente de los valores que tenga la serie. Para habilitar esta opción en todos los gráficos, active la casilla Global color consistency (Coherencia de color global).

Nota:

Para lograr esta coherencia, Azure Databricks aplica un algoritmo hash directamente de los valores a los colores. Para evitar colisiones (donde dos valores se asignan al mismo color exacto), el hash se aplica a un conjunto grande de colores. Como efecto secundario, no es posible garantizar colores con una apariencia agradable o fáciles de distinguir. Cuando hay muchos colores, existe la posibilidad de que algunos tengan una apariencia muy similar.

Visualizaciones de Machine Learning

Además de los tipos de gráfico estándar, las visualizaciones heredadas admiten los siguientes parámetros y resultados del entrenamiento del aprendizaje automático:

• Valores residuales
• Curvas ROC
• Árboles de decisión

Valores residuales

En el caso de las regresiones lineales y logísticas, puede representar gráficamente valores residuales frente a predichos. Para obtener este trazado, proporcione el modelo y el dataframe.

En el ejemplo siguiente se ejecuta una regresión lineal en la población de la ciudad en relación con los datos del precio de venta de las casas y, a continuación, se muestran los valores residuales frente a los datos predichos.

# Load data
pop_df = spark.read.csv("/databricks-datasets/samples/population-vs-price/data_geo.csv", header="true", inferSchema="true")

# Drop rows with missing values and rename the feature and label columns, replacing spaces with _
from pyspark.sql.functions import col
pop_df = pop_df.dropna() # drop rows with missing values
exprs = [col(column).alias(column.replace(' ', '_')) for column in pop_df.columns]

# Register a UDF to convert the feature (2014_Population_estimate) column vector to a VectorUDT type and apply it to the column.
from pyspark.ml.linalg import Vectors, VectorUDT

spark.udf.register("oneElementVec", lambda d: Vectors.dense([d]), returnType=VectorUDT())
tdata = pop_df.select(*exprs).selectExpr("oneElementVec(2014_Population_estimate) as features", "2015_median_sales_price as label")

# Run a linear regression
from pyspark.ml.regression import LinearRegression

lr = LinearRegression()
modelA = lr.fit(tdata, {lr.regParam:0.0})

# Plot residuals versus fitted data
display(modelA, tdata)

Curvas ROC

En el caso de las regresiones logísticas, puede representar una curva ROC. Para obtener este trazado, se suministra el modelo; es decir, los datos preparados previamente que se introducen en el método fit y el parámetro "ROC".

En el siguiente ejemplo se desarrolla un clasificador que predice si un individuo percibe menos de 50 000 o más de 50 000 al año a partir de varios atributos del individuo. El conjunto de datos Adult se deriva de datos de un censo y consta de información sobre 48 842 personas y sus ingresos anuales.

El código de ejemplo de esta sección usa codificación "one-hot".

# This code uses one-hot encoding to convert all categorical variables into binary vectors.

schema = """`age` DOUBLE,
`workclass` STRING,
`fnlwgt` DOUBLE,
`education` STRING,
`education_num` DOUBLE,
`marital_status` STRING,
`occupation` STRING,
`relationship` STRING,
`race` STRING,
`sex` STRING,
`capital_gain` DOUBLE,
`capital_loss` DOUBLE,
`hours_per_week` DOUBLE,
`native_country` STRING,
`income` STRING"""

dataset = spark.read.csv("/databricks-datasets/adult/adult.data", schema=schema)

from pyspark.ml import Pipeline
from pyspark.ml.feature import OneHotEncoder, StringIndexer, VectorAssembler

categoricalColumns = ["workclass", "education", "marital_status", "occupation", "relationship", "race", "sex", "native_country"]

stages = [] # stages in the Pipeline
for categoricalCol in categoricalColumns:
    # Category indexing with StringIndexer
    stringIndexer = StringIndexer(inputCol=categoricalCol, outputCol=categoricalCol + "Index")
    # Use OneHotEncoder to convert categorical variables into binary SparseVectors
    encoder = OneHotEncoder(inputCols=[stringIndexer.getOutputCol()], outputCols=[categoricalCol + "classVec"])
    # Add stages.  These are not run here, but will run all at once later on.
    stages += [stringIndexer, encoder]

# Convert label into label indices using the StringIndexer
label_stringIdx = StringIndexer(inputCol="income", outputCol="label")
stages += [label_stringIdx]

# Transform all features into a vector using VectorAssembler
numericCols = ["age", "fnlwgt", "education_num", "capital_gain", "capital_loss", "hours_per_week"]
assemblerInputs = [c + "classVec" for c in categoricalColumns] + numericCols
assembler = VectorAssembler(inputCols=assemblerInputs, outputCol="features")
stages += [assembler]

# Run the stages as a Pipeline. This puts the data through all of the feature transformations in a single call.

partialPipeline = Pipeline().setStages(stages)
pipelineModel = partialPipeline.fit(dataset)
preppedDataDF = pipelineModel.transform(dataset)

# Fit logistic regression model

from pyspark.ml.classification import LogisticRegression
lrModel = LogisticRegression().fit(preppedDataDF)

# ROC for data
display(lrModel, preppedDataDF, "ROC")

Para mostrar los valores residuales, omita el parámetro "ROC":

display(lrModel, preppedDataDF)

Árboles de decisión

Las visualizaciones heredadas admiten la representación de un árbol de decisión.

Para obtener esta visualización, debe proporcionar el modelo de árbol de decisión.

En los siguientes ejemplos se entrena un árbol para reconocer dígitos (0 a 9) del conjunto de datos de MNIST a partir de imágenes de dígitos escritos a mano y, a continuación, se muestra el árbol.

Python

trainingDF = spark.read.format("libsvm").load("/databricks-datasets/mnist-digits/data-001/mnist-digits-train.txt").cache()
testDF = spark.read.format("libsvm").load("/databricks-datasets/mnist-digits/data-001/mnist-digits-test.txt").cache()

from pyspark.ml.classification import DecisionTreeClassifier
from pyspark.ml.feature import StringIndexer
from pyspark.ml import Pipeline

indexer = StringIndexer().setInputCol("label").setOutputCol("indexedLabel")

dtc = DecisionTreeClassifier().setLabelCol("indexedLabel")

# Chain indexer + dtc together into a single ML Pipeline.
pipeline = Pipeline().setStages([indexer, dtc])

model = pipeline.fit(trainingDF)
display(model.stages[-1])

Scala

val trainingDF = spark.read.format("libsvm").load("/databricks-datasets/mnist-digits/data-001/mnist-digits-train.txt").cache
val testDF = spark.read.format("libsvm").load("/databricks-datasets/mnist-digits/data-001/mnist-digits-test.txt").cache

import org.apache.spark.ml.classification.{DecisionTreeClassifier, DecisionTreeClassificationModel}
import org.apache.spark.ml.feature.StringIndexer
import org.apache.spark.ml.Pipeline

val indexer = new StringIndexer().setInputCol("label").setOutputCol("indexedLabel")
val dtc = new DecisionTreeClassifier().setLabelCol("indexedLabel")
val pipeline = new Pipeline().setStages(Array(indexer, dtc))

val model = pipeline.fit(trainingDF)
val tree = model.stages.last.asInstanceOf[DecisionTreeClassificationModel]

display(tree)

DataFrames de Streaming estructurado

Para visualizar el resultado de una consulta de streaming en tiempo real, puede usar display para mostrar un dataframe de Structured Streaming en Scala y Python.

Python

streaming_df = spark.readStream.format("rate").load()
display(streaming_df.groupBy().count())

Scala

val streaming_df = spark.readStream.format("rate").load()
display(streaming_df.groupBy().count())

display admite los siguientes parámetros opcionales:

• streamName: el nombre de la consulta de streaming.
• trigger (Scala) y processingTime (Python): define la frecuencia con que se ejecuta la consulta de streaming. Si no se especifica, el sistema comprueba la disponibilidad de los datos nuevos en cuanto se haya completado el procesamiento anterior. Para reducir el costo de producción, Databricks recomienda establecer siempre un intervalo de desencadenador. El intervalo de desencadenador predeterminado es 500 ms.
• checkpointLocation: la ubicación en la que el sistema escribe toda la información del punto de comprobación. Si no se especifica, el sistema genera automáticamente una ubicación temporal para el punto de comprobación en DBFS. Para que la transmisión continúe con el procesamiento de datos en el lugar en que lo dejó, es preciso proporcionar una ubicación del punto de control. Databricks recomienda que en producción siempre se especifique la opción checkpointLocation.

Python

streaming_df = spark.readStream.format("rate").load()
display(streaming_df.groupBy().count(), processingTime = "5 seconds", checkpointLocation = "dbfs:/<checkpoint-path>")

Scala

import org.apache.spark.sql.streaming.Trigger

val streaming_df = spark.readStream.format("rate").load()
display(streaming_df.groupBy().count(), trigger = Trigger.ProcessingTime("5 seconds"), checkpointLocation = "dbfs:/<checkpoint-path>")

Para más información sobre estos parámetros, consulte el apartado en el que se indica cómo iniciar consultas de streaming.

Función displayHTML

Los cuadernos de los lenguajes de programación de Azure Databricks (Python, Scala y R) admiten gráficos HTML mediante la función displayHTML; esta función se puede usar en cualquier código HTML, CSS o JavaScript. Esta función admite gráficos interactivos mediante bibliotecas de JavaScript como D3.

Para ver ejemplos de uso de displayHTML, consulte:

• HTML, D3 y SVG en cuadernos

• Inserción de imágenes estáticas en cuadernos

Nota:

El iframe displayHTML se muestra desde el dominio databricksusercontent.com y el espacio aislado de iframe incluye el atributo allow-same-origin. Debe ser capaz de acceder a la dirección databricksusercontent.com desde el explorador. Si actualmente está bloqueada por la red corporativa, se debe agregar a la lista de permitidos.

Imágenes de

Las columnas que contienen tipos de datos de imagen se representan como HTML enriquecido. Azure Databricks intenta representar las miniaturas de imagen de las columnas de DataFrame que coinciden con ImageSchema de Spark. La representación de miniaturas funciona para las imágenes que se leen correctamente a través de la función spark.read.format('image'). En el caso de los valores de imagen generados a través de otros medios, Azure Databricks es compatible con la representación de imágenes de uno, tres o cuatro canales (donde cada canal consta de un solo byte), con las siguientes restricciones:

• Imágenes de un canal: el campo mode debe ser igual a 0. Los campos height, width y nChannels deben describir con precisión los datos de la imagen binaria en el campo data.
• Imágenes de tres canales: el campo mode debe ser igual a 16. Los campos height, width y nChannels deben describir con precisión los datos de la imagen binaria en el campo data. El campo data debe contener datos de píxeles en fragmentos de tres bytes, y el canal debe ordenarlos como (blue, green, red) en cada píxel.
• Imágenes de cuatro canales: el campo mode debe ser igual a 24. Los campos height, width y nChannels deben describir con precisión los datos de la imagen binaria en el campo data. El campo data debe contener datos de píxeles en fragmentos de cuatro bytes, y el canal debe ordenarlos como (blue, green, red, alpha) en cada píxel.

Ejemplo

Supongamos que tiene una carpeta que contiene algunas imágenes:

Si lee las imágenes en un dataframe y, a continuación, muestra dicho dataframe, Azure Databricks representa las miniaturas de las imágenes:

image_df = spark.read.format("image").load(sample_img_dir)
display(image_df)

Visualizaciones en Python

En esta sección:

• Seaborn
• Otras bibliotecas de Python

Seaborn

También puede usar otras bibliotecas de Python para generar trazados. Databricks Runtime incluye la biblioteca de visualización Seaborn. Para crear un trazado de Seaborn, importe la biblioteca, cree un trazado y use el trazado en la función display.

import seaborn as sns
sns.set(style="white")

df = sns.load_dataset("iris")
g = sns.PairGrid(df, diag_sharey=False)
g.map_lower(sns.kdeplot)
g.map_diag(sns.kdeplot, lw=3)

g.map_upper(sns.regplot)

display(g.fig)

Otras bibliotecas de Python

• Bokeh
• Matplotlib
• Plotly

Visualizaciones en R

Para trazar datos en R, use la función display como se indica a continuación:

library(SparkR)
diamonds_df <- read.df("/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv", source = "csv", header="true", inferSchema = "true")

display(arrange(agg(groupBy(diamonds_df, "color"), "price" = "avg"), "color"))

Puede usar la función plot predeterminada de R.

fit <- lm(Petal.Length ~., data = iris)
layout(matrix(c(1,2,3,4),2,2)) # optional 4 graphs/page
plot(fit)

También puede usar cualquier paquete de visualización de R. El cuaderno de R captura el trazado resultante en forma de archivo .png y lo muestra en línea.

En esta sección:

• Lattice
• DandEFA
• Plotly
• Otras bibliotecas de R

Lattice

El paquete Lattice admite gráficos de Trellis (gráficos que muestran una variable o la relación entre variables, con condiciones en una o varias variables).

library(lattice)
xyplot(price ~ carat | cut, diamonds, scales = list(log = TRUE), type = c("p", "g", "smooth"), ylab = "Log price")

DandEFA

El paquete DandEFA admite trazados de "diente de león".

install.packages("DandEFA", repos = "https://cran.us.r-project.org")
library(DandEFA)
data(timss2011)
timss2011 <- na.omit(timss2011)
dandpal <- rev(rainbow(100, start = 0, end = 0.2))
facl <- factload(timss2011,nfac=5,method="prax",cormeth="spearman")
dandelion(facl,bound=0,mcex=c(1,1.2),palet=dandpal)
facl <- factload(timss2011,nfac=8,method="mle",cormeth="pearson")
dandelion(facl,bound=0,mcex=c(1,1.2),palet=dandpal)

Plotly

El paquete de R Plotly usa htmlwidgets para R. Para ver instrucciones de instalación y un cuaderno, consulte htmlwidgets.

Otras bibliotecas de R

• ggplot2
• htmlwidgets

Visualizaciones en Scala

Para trazar datos en Scala, use la función display como se indica a continuación:

val diamonds_df = spark.read.format("csv").option("header","true").option("inferSchema","true").load("/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv")

display(diamonds_df.groupBy("color").avg("price").orderBy("color"))

Análisis detallado de los cuadernos para Python y Scala

Para profundizar en las visualizaciones de Python, consulte el cuaderno:

• Profundización en la visualización en Python

Para profundizar en las visualizaciones de Scala, consulte el cuaderno:

• Profundización en la visualización en Scala