Visualizzazioni legacy
Questo articolo descrive le visualizzazioni legacy di Azure Databricks. Per informazioni sul supporto della visualizzazione corrente, vedere Visualizzazioni nei notebook di Databricks.
Azure Databricks supporta inoltre in modalità nativa le librerie di visualizzazione in Python e R e consente di installare e usare librerie di terze parti.
Creare una visualizzazione legacy
Per creare una visualizzazione legacy da una cella dei risultati, fare clic + su e selezionare Visualizzazione legacy.
Le visualizzazioni legacy supportano un set completo di tipi di tracciato:
Scegliere e configurare un tipo di grafico legacy
Per scegliere un grafico a barre, fare clic sull'icona 
del grafico a barre :
Per scegliere un altro tipo di tracciato, fare clic 
a destra del grafico a barre e scegliere il tipo di tracciato.
Barra degli strumenti del grafico legacy
Sia i grafici a linee che i grafici a barre includono una barra degli strumenti incorporata che supporta un set completo di interazioni lato client.
Per configurare un grafico, fare clic su Opzioni tracciato.
Il grafico a linee include alcune opzioni personalizzate per impostare un intervallo dell'asse Y, visualizzare e nascondere punti e visualizzare l'asse Y con una scala logaritmica.
Per informazioni sui tipi di grafico legacy, vedere:
Coerenza dei colori tra grafici
Azure Databricks supporta due tipi di coerenza dei colori tra grafici legacy: set di serie e globali.
La coerenza dei colori a livello di set di serie assegna lo stesso colore allo stesso valore se si dispone di serie con valori uguali, ma in ordini diversi (ad esempio, A = ["Apple", "Orange", "Banana"] e B = ["Orange", "Banana", "Apple"]). I valori vengono ordinati prima dell'esecuzione del tracciato, pertanto entrambe le legende sono ordinate nello stesso modo (["Apple", "Banana", "Orange"]) e agli stessi valori vengono assegnati i medesimi colori. Se però si dispone di una serie C = ["Orange", "Banana"], non sarà coerente con il set A dal punto di vista dei colori perché il set è diverso. L'algoritmo di ordinamento assegnerà il primo colore a "Banana" nel set C, ma il secondo colore a "Banana" nel set A. Se si desidera che i colori di queste serie siano coerenti, è possibile specificare che i grafici abbiamo una coerenza dei colori a livello globale.
Con la coerenza dei colori a livello globale, ogni valore viene sempre mappato allo stesso colore, indipendentemente dai valori delle serie. Per abilitare tale impostazione per ogni grafico, selezionare la casella di controllo Global color consistency (Coerenza colori globale).
Nota
Per ottenere questa coerenza, gli hash di Azure Databricks vengono vuoti direttamente dai valori ai colori. Per evitare conflitti (nei casi in cui due valori vengano assegnati esattamente allo stesso colore), l'hash si riferisce a un ampio set di colori. Come effetto collaterale, non è possibile garantire che si ottengano colori gradevoli o facilmente distinguibili; in presenza di molti colori, è probabile che alcuni risultino molto simili.
Visualizzazioni di Machine Learning
Oltre ai tipi di grafico standard, le visualizzazioni legacy supportano i parametri e i risultati di training di Machine Learning seguenti:
Residui
Per le regressioni lineari e logistiche, è possibile eseguire il rendering di un tracciato adattato rispetto ai residui. Per ottenere questo tracciato, specificare il modello e il dataframe.
Nell'esempio seguente viene eseguita una regressione lineare sulla popolazione della città in relazione al prezzo di vendita delle case e quindi vengono visualizzati i residui rispetto ai dati adattati.
# 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)
Curve ROC
Per le regressioni logistiche, è possibile eseguire il rendering di una curva ROC . Per ottenere questo tracciato, specificare il modello, i dati prepped immessi per il fit metodo e il parametro "ROC".
L'esempio seguente sviluppa un classificatore che stima se un individuo guadagna <=50.000 o >50.000 all'anno da vari attributi dell'individuo. Il set di dati Adult deriva dai dati del censimento ed è costituito dalle informazioni relative a 48842 individui e al loro reddito annuale.
Il codice di esempio di questa sezione usa la codifica 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")
Per visualizzare i residui, omettere il parametro "ROC":
display(lrModel, preppedDataDF)
Alberi delle decisioni
Le visualizzazioni legacy supportano il rendering di un albero delle decisioni.
Per ottenere questa visualizzazione, fornire il modello di albero delle decisioni.
Negli esempi seguenti viene eseguito il training di un albero per riconoscere le cifre (0-9) del set di dati MNIST di immagini di cifre scritte a mano e quindi viene visualizzato l'albero.
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)
DataFrame di streaming strutturato
Per visualizzare il risultato di una query di streaming in tempo reale, è possibile usare display per visualizzare un dataframe Structured Streaming in Scala e 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 supporta i parametri facoltativi seguenti:
streamName: il nome della query di streaming.trigger(Scala) eprocessingTime(Python): definisce la frequenza con cui viene eseguita la query di streaming. Se non specificato, il sistema controlla la disponibilità dei nuovi dati non appena viene completata l'elaborazione precedente. Per ridurre i costi di produzione, Databricks consiglia di impostare sempre un intervallo di trigger. L'intervallo di trigger predefinito è 500 ms.checkpointLocation: la posizione in cui il sistema scrive tutte le informazioni di checkpoint. Se non specificato, il sistema genera automaticamente una posizione di checkpoint temporanea in DBFS. Affinché il flusso continui a elaborare i dati dal punto in cui è stato interrotto, è necessario specificare una posizione di checkpoint. Databricks consiglia di specificare sempre l'opzione nell'ambientecheckpointLocationdi produzione.
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>")
Per altre informazioni su questi parametri, vedere Avvio delle query di streaming.
Funzione displayHTML
I notebook nei linguaggi di programmazione di Azure Databricks (Python, R e Scala) supportano la grafica HTML tramite la funzione displayHTML, pertanto è possibile passare qualsiasi codice HTML, CSS o JavaScript alla funzione. Questa funzione supporta la grafica interattiva tramite librerie JavaScript come D3.
Per esempi dell'uso di displayHTML, vedere:
Nota
L'iframe displayHTML viene servito dal dominio databricksusercontent.com e la sandbox dell'iframe include l'attributo allow-same-origin. databricksusercontent.com deve essere accessibile dal browser. Se è attualmente bloccato dalla rete aziendale, deve essere aggiunto a un elenco di elementi consentiti.
Immagini
Il rendering delle colonne contenenti tipi di dati immagine viene eseguito come HTML avanzato. Azure Databricks tenta di eseguire il rendering delle anteprime delle immagini per DataFrame le colonne corrispondenti a Spark ImageSchema.
Il rendering delle anteprime funziona per tutte le immagini lette correttamente tramite la spark.read.format('image') funzione . Per i valori di immagine generati in altri modi, Azure Databricks supporta il rendering delle immagini a uno, tre o quattro canali (dove ogni canale è costituito da un singolo byte), con i vincoli seguenti:
- Immagini a un canale: il campo
modedeve essere uguale a 0. I campiheight,widthenChannelsdevono descrivere in modo accurato i dati di immagine binari nel campodata. - Immagini a tre canali: il campo
modedeve essere uguale a 16. I campiheight,widthenChannelsdevono descrivere in modo accurato i dati di immagine binari nel campodata. Il campodatadeve contenere i dati di pixel in blocchi da tre byte, con l'ordinamento dei canali(blue, green, red)per ogni pixel. - Immagini a quattro canali: il campo
modedeve essere uguale a 24. I campiheight,widthenChannelsdevono descrivere in modo accurato i dati di immagine binari nel campodata. Il campodatadeve contenere i dati di pixel in blocchi da quattro byte, con l'ordinamento dei canali(blue, green, red, alpha)per ogni pixel.
Esempio
Si supponga di disporre di una cartella contenente alcune immagini:
Se si leggono le immagini in un dataframe e quindi si visualizza il dataframe, Azure Databricks esegue il rendering delle anteprime delle immagini:
image_df = spark.read.format("image").load(sample_img_dir)
display(image_df)
Visualizzazioni in Python
Contenuto della sezione:
Seaborn
È anche possibile usare altre librerie Python per generare tracciati. Databricks Runtime include la libreria per visualizzazioni seaborn. Per creare un tracciato seaborn, importare la libreria, creare un tracciato e passarlo alla funzione 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)
Altre librerie Python
Visualizzazioni in R
Per tracciare i dati in R, usare la funzione display come segue:
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"))
È possibile usare la funzione predefinita plot di R.
fit <- lm(Petal.Length ~., data = iris)
layout(matrix(c(1,2,3,4),2,2)) # optional 4 graphs/page
plot(fit)
È anche possibile usare qualsiasi pacchetto di visualizzazione R. Il notebook R acquisisce il tracciato risultante come .png e lo visualizza inline.
Contenuto della sezione:
Lattice
Il pacchetto Lattice supporta i grafici a traliccio, ovvero grafici che visualizzano una variabile o la relazione tra variabili, subordinata a una o più altre variabili.
library(lattice)
xyplot(price ~ carat | cut, diamonds, scales = list(log = TRUE), type = c("p", "g", "smooth"), ylab = "Log price")
DandEFA
Il pacchetto DandEFA supporta i tracciati dandelion.
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
Il pacchetto Plotly R si basa su htmlwidgets per R. Per istruzioni di installazione e un notebook, vedere htmlwidgets.
Altre librerie R
Visualizzazioni in Scala
Per tracciare i dati in Scala, usare la funzione display come segue:
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"))
Notebook di approfondimento per Python e Scala
Per un approfondimento sulle visualizzazioni Python, vedere il notebook:
Per un approfondimento sulle visualizzazioni Scala, vedere il notebook: