Google
Cloud Platform
Amazon Web Services
Microsoft AzureVisualizaçõ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:
Escolha e configure 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 possuem uma barra de ferramentas integrada que oferece suporte a um rico conjunto de interações do lado do cliente.
Para configurar um gráfico, clique em Gráfico Opções….
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 .
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)
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")
Para exibir os resíduos, omita o parâmetro "ROC" :
display(lrModel, preppedDataDF)
Á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)
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.triggerScala) eprocessingTime(Python): define a frequência com que a consulta de transmissão é executada. Se não for especificado, o sistema verifica a disponibilidade de novos dados assim que o processamento anterior for concluído. Para reduzir o custo de produção, a Databricks recomenda que o senhor sempre defina um intervalo de acionamento. O intervalo de acionamento do 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çãocheckpointLocation.
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
modedeve 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 campodatadeve 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
modedeve ser igual a 24. Os camposheight,widthenChannelsdevem descrever com precisão os dados da imagem binária no campodata. O campodatadeve conter dados de pixel em blocos de quatro bytes, com o canal ordenando(blue, green, red, alpha)para cada pixel.
Visualizações em Python
Nesta secção:
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)
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)
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.
Nesta secção:
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")
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)
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"))