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:
Escolher e configurar um tipo de gráfico herdado
Para escolher um gráfico de barras, clique no ícone do gráfico de barras 
:
Para escolher outro tipo de gráfico, clique em 
à direita do gráfico de barras 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.
Para configurar um gráfico, clique em 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.
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)
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")
Para exibir os resíduos, omita o parâmetro "ROC":
display(lrModel, preppedDataDF)
Á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)
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) eprocessingTime(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çãocheckpointLocation.
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:
modecampo deve ser igual a 0. Os camposheight,widthenChannelsdevem descrever com precisão os dados da imagem binária no campodata. - Imagens de três canais: o campo
modedeve ser igual a 16. Os camposheight,widthenChannelsdevem descrever com precisão os dados da imagem binária no campodata. O campo dedatadeve 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
modedeve ser igual a 24. Os camposheight,widthenChannelsdevem descrever com precisão os dados da imagem binária no campodata. O campo dedatadeve 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:
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)
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)
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)
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")
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)
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:
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de