Compartilhar via


Visualizações herdadas

Este artigo descreve as visualizações herdadas do Azure Databricks. Veja Visualizações em notebooks Databricks para suporte de visualização atual.

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

Criar uma visualização herdada

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

As visualizações herdadas dão suporte a um conjunto avançado de tipos de plotagem:

Tipos de gráfico

Escolher e configurar um tipo de gráfico herdado

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

Ícone de 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 de gráfico e escolha o tipo de gráfico.

Barra de ferramentas do gráfico herdado

Os gráficos de linhas e de barras têm uma barra de ferramentas interna compatível com um conjunto avançado de interações do lado do cliente.

Barra de ferramentas do gráfico

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

Opções de gráfico

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

Para obter informações sobre tipos de gráfico herdado, confira:

Consistência de cores entre gráficos

O Azure Databricks dá suporte a dois tipos de consistência de cor entre gráficos herdados: conjunto de séries e global.

A consistência de cor de 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 da plotagem, 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"], ela não seria consistente com 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 desejar que essas séries sejam consistentes com a cor, você poderá especificar que os gráficos devem ter consistência de cores global.

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

Consistência de cores global

Observação

Para atingir essa consistência, o Azure Databricks faz hash diretamente de valores para cores. Para evitar colisões (em que dois valores vão para a mesma cor exata), o hash é para um grande conjunto de cores, que tem o efeito colateral de que as cores atraentes ou facilmente distinguíveis não podem ser garantidas; com muitas cores, há um limite de aparência muito semelhante.

Visualizações de machine learning

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

Resíduos

Para regressões lineares e logísticas, dá suporte à renderização de uma plotagem de ajustados versus residuais. Para obter esse gráfico, forneça o modelo e o DataFrame.

O exemplo a seguir executa uma regressão linear de população de cidade para armazenar dados de preço de venda e, em seguida, exibe os dados residuais versus os 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)

Exibir resíduos

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 no parâmetro "ROC".

O exemplo a seguir desenvolve um classificador que prevê se um indivíduo ganha <= 50 mil ou > 50 mil por ano com base em vários atributos da pessoa. O conjunto de dados adulto deriva de dados de censo e consiste em informações sobre 48842 indivíduos e seus rendimentos anuais.

O código de exemplo desta seção usa a 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 dão suporte à renderização de uma árvore de decisão.

Para obter essa visualização, você fornece o modelo de árvore de decisão.

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

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)

Exibir árvore de decisão

DataFrames de streaming estruturado

Para visualizar o resultado de uma consulta de streaming em tempo real, você pode display um DataFrame do Streaming Estruturado no Scala e no 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())

O display é compatível com os seguintes parâmetros opcionais:

  • streamName: o nome da consulta de streaming.
  • trigger (Scala) e processingTime (Python): define a frequência com que a consulta de streaming é executada. Se não for especificado, o sistema verificará a disponibilidade de novos dados assim que o processamento anterior tiver sido concluído. Para reduzir o custo em produção, o Databricks recomenda que você sempre defina um intervalo de gatilho. O intervalo de disparo padrão é 500 ms.
  • checkpointLocation: o local em que o sistema grava todas as informações de ponto de verificação. Se não for especificado, o sistema vai gerar automaticamente um local de ponto de verificação temporário no DBFS. Para que seu fluxo continue a processar dados do local no qual parou, você deve fornecer um local de ponto de verificação. O Databricks recomenda que, na produção, você sempre especifique a opção 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 obter mais informações sobre esses parâmetros, consulte Como iniciar consultas de streaming.

Função displayHTML

Os notebooks da linguagem de programação do Azure Databricks (Python, R, Scala) dão suporte a gráficos HTML usando a função displayHTML; você pode passar a função para qualquer código HTML, CSS ou JavaScript. Essa função dá suporte a gráficos interativos usando bibliotecas JavaScript, como D3.

Para obter exemplos de como usar displayHTML, confira:

Observação

O iframe displayHTML é servido do domínio databricksusercontent.com e a área restrita do iframe inclui o atributo allow-same-origin. databricksusercontent.com deve ser acessível em seu navegador. Se estiver bloqueado pela sua rede corporativa, ele precisará ser adicionado em uma lista de permitidos.

Imagens

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

  • Imagens de um canal: mode campo 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 de data deve conter dados de pixel em partes de três bytes, com a ordenação de canal (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 de data deve conter dados de pixel em partes de quatro bytes, com a ordenação de canal (blue, green, red, alpha) para cada pixel.

Exemplo

Suponha que você tenha uma pasta contendo algumas imagens:

Pasta de dados de imagem

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

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

Exibir DataFrame de imagem

Visualizações no Python

Nesta seção:

Seaborn

Também é possível usar outras bibliotecas Python para gerar gráficos. O Databricks Runtime inclui a biblioteca de visualização seaborn. Para criar um gráfico seaborn, importe a biblioteca, crie um gráfico e passe-a 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

Outras bibliotecas Python

Visualizações no R

Para plotar dados em R, use a função display da seguinte maneira:

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

É possível usar a função de gráfico do R.

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

Gráfico padrão do R

Também é possível usar qualquer pacote de visualizações no R. O notebook do R captura o gráfico resultante como um .png e o exibe de maneira embutida.

Nesta seção:

Malha

O pacote Lattice dá suporte a grafos de treliça, grafos que exibem uma variável ou a relação entre variáveis, condicionadas em 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 Lattice do R

DandEFA

O pacote DandEFA dá suporte a gráficos “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)

Gráfico DandEFA do R

Plotly

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

Outras bibliotecas do R

Visualizações no Scala

Para plotar dados em Scala, use a função display da seguinte maneira:

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 de aprofundamento para Python e Scala

Para obter um aprofundamento nas visualizações Python, confira o notebook:

Para obter um aprofundamento nas visualizações Scala, confira o notebook: