Visualizações herdadas

Este artigo descreve as visualizações herdadas do Databricks. Consulte Visualizações no Databricks Notebook para suporte de visualização atual.

O Databricks também oferece suporte nativo a bibliotecas de visualização em Python e R e permite que você instale e use bibliotecas de terceiros.

Criar uma visualização herdada

Para criar uma visualização herdada a partir de uma célula de resultados, clique em + e selecione Visualização herdada.

As visualizações herdadas suportam um rico conjunto de tipos de gráficos:

Tipos de gráficos

Escolha e configure um tipo de gráfico herdado

Para escolher um gráfico de barras, clique no ícone do gráfico de barras Botão Gráfico:

Ícone do gráfico de barras

Para escolher outro tipo de gráfico, clique em Botão para baixo à direita do gráfico de barras Botão Gráfico e escolha o tipo de gráfico.

Barra de ferramentas do gráfico herdado

Os gráficos de linhas e de barras possuem uma barra de ferramentas integrada que oferece suporte a um rico conjunto de interações do lado do cliente.

Barra de ferramentas do gráfico

Para configurar um gráfico, clique em Gráfico Opções….

opções gráficas

O gráfico de linha tem algumas opções de gráfico personalizado: definir um intervalo do eixo Y, mostrar e ocultar pontos e exibir o eixo Y com uma escala logs .

Para obter informações sobre tipos de gráfico herdados, consulte:

Consistência de cores em gráficos

Databricks dá suporte a dois tipos de consistência de cores em gráficos herdados: conjunto de série e global.

A consistência de cores do conjunto de séries atribui a mesma cor ao mesmo valor se você tiver séries com os mesmos valores, mas em ordens diferentes (por exemplo, A = ["Apple", "Orange", "Banana"] e B = ["Orange", "Banana", "Apple"]). Os valores são classificados antes do gráfico, portanto, ambas as legendas são classificadas da mesma maneira (["Apple", "Banana", "Orange"]) e os mesmos valores recebem as mesmas cores. No entanto, se você tiver uma série C = ["Orange", "Banana"], não seria uma cor consistente com o conjunto A porque o conjunto não é o mesmo. O algoritmo de classificação atribuiria a primeira cor a “Banana” no conjunto C, mas a segunda cor a “Banana” no conjunto A. Se você deseja que essas séries sejam consistentes em cores, pode especificar que os gráficos devem ter consistência global de cores.

Na consistência de cor global , cada valor é sempre mapeado para a mesma cor, independentemente dos valores da série. Para habilitar isso para cada gráfico, marque a caixa de seleção Consistência de cor global .

Consistência de cor global

Observação

Para atingir essa consistência, o Databricks faz o hash diretamente dos valores para as cores. Para evitar colisões (onde dois valores vão exatamente para a mesma cor), o hash é para um grande conjunto de cores, o que tem o efeito colateral de que cores bonitas ou facilmente distinguíveis não podem ser garantidas; com muitas cores, é provável que haja algumas com aparência muito semelhante.

Visualizações de aprendizado de máquina

Além dos tipos de gráfico padrão, as visualizações herdadas oferecem suporte aos seguintes parâmetros e resultados de treinamento machine learning :

resíduos

Para regressões lineares e logísticas, você pode renderizar um gráfico ajustado versus residual . Para obter este gráfico, forneça o modelo e o DataFrame.

O exemplo a seguir executa uma regressão linear na população da cidade para dados de preço de venda de casas e, em seguida, exibe os resíduos em relação aos dados ajustados.

# 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)
Resíduos de exibição

curvas ROC

Para regressões logísticas, você pode renderizar uma curva ROC . Para obter esse gráfico, forneça o modelo, os dados preparados que são inseridos no método fit e o parâmetro "ROC".

O exemplo a seguir desenvolve um classificador que prevê se um indivíduo ganha <= 50 mil ou > 50 mil por ano a partir de vários atributos do indivíduo. O dataset Adulto deriva de dados do censo e consiste em informações sobre 48.842 indivíduos e sua renda anual.

O código de exemplo nesta seção usa codificação 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")
Exibir ROC

Para exibir os resíduos, omita o parâmetro "ROC" :

display(lrModel, preppedDataDF)
Exibir resíduos de regressão logística

Árvores de decisão

As visualizações herdadas oferecem suporte à renderização de uma árvore de decisão.

Para obter esta visualização, forneça o modelo de árvore de decisão.

Os exemplos a seguir ensinam uma árvore a reconhecer dígitos (0 - 9) do dataset MNIST de imagens de dígitos manuscritos e, em seguida, exibe a árvore.

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])
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)
Exibir árvore de decisão

DataFrames estruturados transmitidos

Para visualizar o resultado de uma query transmitida em tempo real você pode display transmitir um DataFrame estruturado em Scala e Python.

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

display suporta os seguintes parâmetros opcionais:

  • streamName: o nome query transmitida.

  • trigger (Scala) e processingTime (Python): define com que frequência a query de transmissão é executada. Se não for especificado, o sistema verifica a disponibilidade de novos dados assim que o processamento anterior é concluído. Para reduzir o custo de produção, o Databricks recomenda que você sempre defina um intervalo de gatilho. Com o Databricks Runtime 8.0e acima, o intervalo de gatilho default é de 500 ms.

  • checkpointLocation: o local onde o sistema grava todas as informações do ponto de verificação. Se não for especificado, o sistema gera automaticamente um local de ponto de verificação temporário no DBFS. Para que sua transmissão continue processando os dados de onde parou, você deve fornecer um local de checkpoint. Databricks recomenda que na produção você sempre especifique a opção checkpointLocation .

streaming_df = spark.readStream.format("rate").load()
display(streaming_df.groupBy().count(), processingTime = "5 seconds", checkpointLocation = "dbfs:/<checkpoint-path>")
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 obter mais informações sobre esses parâmetros, consulte Iniciando querypor transmissão.

displayHTML função

Linguagem de programação Databricks Notebook (Python, R e Scala) oferece suporte a gráficos HTML usando a função displayHTML; você pode passar para a função qualquer código HTML, CSS ou JavaScript. Esta função oferece suporte a gráficos interativos usando bibliotecas JavaScript, como D3.

Para exemplos de uso displayHTML, consulte:

Observação

O iframe displayHTML é servido do domínio databricksusercontent.com e a sandbox do iframe inclui o atributo allow-same-origin. databricksusercontent.com deve estar acessível em seu navegador. Se estiver atualmente bloqueado por sua rede corporativa, ele deve ser adicionado a uma lista de permissões.

Imagens

As colunas que contêm tipos de dados de imagem são renderizadas como HTML avançado. Databricks tenta renderizar miniaturas de imagem para colunas DataFrame correspondentes ao Spark ImageSchema. A renderização de miniatura funciona para qualquer imagem lida com sucesso por meio da função spark.read.format('image') . Para valores de imagem gerados por outros meios, o Databricks dá suporte à renderização de imagens de 1, 3 ou 4 canais (onde cada canal consiste em um único byte), com as seguintes restrições:

  • Imagens de um canal: o campo mode deve ser igual a 0. Os campos height, width e nChannels devem descrever com precisão os dados da imagem binária no campo data .

  • Imagens de três canais: o campo mode deve ser igual a 16. Os campos height, width e nChannels devem descrever com precisão os dados da imagem binária no campo data . O campo data deve conter dados de pixel em blocos de três bytes, com o canal ordenando (blue, green, red) para cada pixel.

  • Imagens de quatro canais: o campo mode deve ser igual a 24. Os campos height, width e nChannels devem descrever com precisão os dados da imagem binária no campo data . O campo data deve conter dados de pixel em blocos de quatro bytes, com o canal ordenando (blue, green, red, alpha) para cada pixel.

Exemplo

Suponha que você tenha uma pasta contendo algumas imagens:

Pasta de dados da imagem

Se você ler as imagens em um DataFrame e exibir o DataFrame, o Databricks renderizará as miniaturas das imagens:

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

Visualizações em Python

Seaborn

Você também pode usar outras bibliotecas Python para gerar gráficos. O Databricks Runtime inclui a biblioteca de visualização seaborn . Para criar um gráfico marítimo, importe a biblioteca, crie um gráfico e passe o gráfico para a função 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)
gráfico Seaborn

Visualizações em R

Para graficar dados no R, utilize a função display da seguinte forma:

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"))

Você pode usar a função gráfica R default .

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

Você também pode usar qualquer pacote de visualização do R. O R Notebook captura o gráfico resultante como um .png e o exibe embutido.

treliça

O pacote Lattice oferece suporte a grafos de treliça—gráficos que exibem uma variável ou a relação entre variáveis, condicionadas a uma ou mais outras variáveis.

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

DandEFA

O pacote DandEFA oferece suporte ao gráfico de dente-de-leão.

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)
R DandEFA graficar

Plotly

O pacote Plotly R depende de htmlwidgets para R. Para obter instruções de instalação e um Notebook, consulte htmlwidgets.

Visualizações em Scala

Para graficar dados no Scala, use a função display da seguinte forma:

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"))

Notebooks detalhados para Python e Scala

Para um mergulho profundo nas visualizações do Python, consulte o Notebook:

Para um mergulho profundo nas visualizações Scala, consulte o Notebook: