Wizualizacje

Usługa Azure Databricks obsługuje różne typy gotowych do pracy wizualizacji przy użyciu funkcji display i displayHTML.

Usługa Azure Databricks również natywnie obsługuje biblioteki wizualizacji w języku Python i języku R oraz umożliwia instalowanie bibliotek innych firm i korzystanie z nich.

display Funkcja

Funkcja display obsługuje kilka typów danych i wizualizacji.

W tej sekcji:

Typy danych

Ramki danych

Najprostszym sposobem tworzenia wizualizacji ramek danych w usłudze Azure Databricks jest wywołanie funkcji display(<dataframe-name>). Jeśli na przykład masz ramkę diamonds_df danych Spark z zestawem danych diamentów pogrupowanych według koloru rombu, obliczenie średniej ceny i wywołanie:

from pyspark.sql.functions import avg
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.select("color","price").groupBy("color").agg(avg("price")))

Zostanie wyświetlona tabela koloru rombu w porównaniu ze średnią ceną.

Diamond color versus average price

Porada

Jeśli zobaczysz element OK bez renderowania po wywołaniu funkcji display, najprawdopodobniej przekazana ramka danych lub kolekcja jest pusta.

Element display() obsługuje ramki danych biblioteki Pandas. Jeśli odwołujesz się do ramki danych w bibliotece pandas lub interfejsie API biblioteki Pandas na platformie Spark bez display, tabela jest renderowana tak, jak w notesie Jupyter.

ramki danych display

Uwaga

Dostępne w środowisku Databricks Runtime w wersji 7.1 lub nowszej.

Ramki danych w interfejsie API PySpark, pandas i Pandas na platformie Spark mają metodę display , która wywołuje funkcję usługi Azure Databricks display . Możesz wywołać ją po prostej operacji ramki danych, na przykład:

diamonds_df = (spark.read
  .format("csv")
  .option("header", "true")
  .option("inferSchema", "true")
  .load("/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv")
)
diamonds_df.select("color","price").display()

lub pod koniec łańcucha operacji ramki danych, na przykład:

from pyspark.sql.functions import avg
diamonds_df = (spark.read
  .format("csv")
  .option("header", "true")
  .option("inferSchema", "true")
  .load("/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv")
)

diamonds_df.select("color","price").groupBy("color").agg(avg("price")).display()
Profile danych

Ważne

Ta funkcja jest dostępna w publicznej wersji zapoznawczej.

Uwaga

Dostępne w środowisku Databricks Runtime 9.1 lub nowszym.

Począwszy od środowiska Databricks Runtime 9.1, gdy używasz metody DataFrame display , w okienku wyników są wyświetlane dwie karty: Table i Data Profile. Table Wyświetla wyniki w formacie tabelarycznym i zapewnia dostęp do wbudowanych typów wykresów. Data Profile Wyświetla podsumowanie statystyk ramki danych Apache Spark lub pandas w formacie tabelarycznym i graficznym.

Data Profile

  • Cechy liczbowe i podzielone na kategorie są wyświetlane w oddzielnych tabelach.
  • W górnej części karty można sortować lub wyszukiwać funkcje.
  • W górnej części kolumny wykresu możesz wyświetlić histogram (standardowy) lub kwantyle.
  • Zaznacz rozszerzenie, aby powiększyć wykresy.
  • Sprawdź dziennik , aby wyświetlić wykresy w skali dziennika.
  • Możesz umieścić kursor na wykresach, aby uzyskać bardziej szczegółowe informacje, takie jak granice kolumny histogramu i liczba wierszy w nim lub wartość kwantylu.

Uwaga

Aby wyświetlić profile danych, należy użyć składni display(df). Składnia df.display() nie jest obsługiwana.

Profile danych można również generować programowo; Zobacz polecenie summarize (dbutils.data.summarize).

Obrazy

Funkcja display renderuje kolumny zawierające typy danych obrazu jako zaawansowany kod HTML. Funkcja display próbuje renderować miniatury obrazów dla kolumn elementu DataFrame zgodnych z elementem ImageSchema platformy Spark. Renderowanie miniatur działa dla wszystkich obrazów, które zostały pomyślnie odczytane za pośrednictwem spark.read.format('image') funkcji. W przypadku wartości obrazu generowanych za pomocą innych metod usługa Azure Databricks obsługuje renderowanie obrazów z 1, 3 lub 4 kanałami (gdzie każdy kanał składa się z jednego bajtu) z następującymi ograniczeniami:

  • Obrazy z jednym kanałem: pole mode musi być równe 0. Pola height, width i nChannels muszą precyzyjnie opisywać dane obrazu binarnego w polu data.
  • Obrazy z trzema kanałami: pole mode musi być równe 16. Pola height, width i nChannels muszą precyzyjnie opisywać dane obrazu binarnego w polu data. Pole data musi zawierać dane pikseli we fragmentach z trzema bajtami, dzięki czemu kanał porządkuje element (blue, green, red) dla każdego piksela.
  • Obrazy z czterema kanałami: pole mode musi być równe 24. Pola height, width i nChannels muszą precyzyjnie opisywać dane obrazu binarnego w polu data. Pole data musi zawierać dane pikseli we fragmentach z czterema bajtami, dzięki czemu kanał porządkuje element (blue, green, red, alpha) dla każdego piksela.
Przykład

Załóżmy, że masz folder zawierający obrazy:

Folder of image data

Jeśli odczytasz obrazy do ramki danych za pomocą funkcji ImageSchema.readImages, a następnie wyświetlisz ramkę danych, funkcja display renderuje miniatury obrazów:

from pyspark.ml.image import ImageSchema
image_df = ImageSchema.readImages(sample_img_dir)
display(image_df)

Display image DataFrame

Ramki danych przesyłania strumieniowego ze strukturą

Aby zwizualizować wynik zapytania przesyłania strumieniowego w czasie rzeczywistym, można użyć funkcji display względem ramki danych przesyłania strumieniowego ze strukturą w językach Scala i 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())

Funkcja display obsługuje następujące parametry opcjonalne:

  • streamName: nazwa zapytania przesyłania strumieniowego.
  • trigger (Scala) i processingTime (Python): określa częstotliwość uruchamiania zapytania przesyłania strumieniowego. Jeśli nie zostanie to określone, system sprawdzi dostępność nowych danych zaraz po zakończeniu poprzedniego przetwarzania. Aby zmniejszyć koszty w środowisku produkcyjnym, usługa Databricks zaleca , aby zawsze ustawiać interwał wyzwalacza. W przypadku środowiska Databricks Runtime 8.0 i nowszych domyślny interwał wyzwalacza wynosi 500 ms.
  • checkpointLocation: lokalizacja, w której system zapisuje wszystkie informacje o punkcie kontrolnym. Jeśli nie zostanie to określone, system automatycznie generuje tymczasową lokalizację punktów kontrolnych w systemie DBFS. Aby strumień kontynuował przetwarzanie danych z miejsca, w którym został pozostawiony, należy podać lokalizację punktu kontrolnego. W usłudze Databricks zalecane jest, aby w środowisku produkcyjnym zawsze określić opcję 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>")

Aby uzyskać więcej informacji na temat tych parametrów, zobacz Starting Streaming Queries (Uruchamianie zapytań przesyłania strumieniowego).

Typy wykresów

Funkcja display obsługuje szeroki zestaw typów wykresów:

Chart types

Wybieranie i konfigurowanie typu wykresu

Aby wybrać wykres słupkowy, kliknij ikonę Chart Buttonwykresu słupkowego:

Bar chart icon

Aby wybrać inny typ wykresu, kliknij Button Down po prawej stronie wykresu Chart Button słupkowego i wybierz typ wykresu.

Pasek narzędzi wykresu

Wykresy liniowe i słupkowe mają wbudowany pasek narzędzi obsługujący szeroki zestaw interakcji po stronie klienta.

Chart toolbar

Aby skonfigurować wykres, kliknij przycisk Opcje wykresu... .

Plot options

Wykres liniowy ma kilka niestandardowych opcji wykresu: ustawienie zakresu osi Y, pokazywanie i ukrywanie punktów oraz wyświetlanie osi Y przy użyciu skali logarytmicznej.

Aby uzyskać informacje o starszych typach wykresów, zobacz:

Spójność kolorów między wykresami

Usługa Azure Databricks obsługuje dwa rodzaje spójności kolorów między wykresami: zestaw serii i spójność globalna.

Spójność koloru według zestawu serii przypisuje ten sam kolor do tej samej wartości, jeśli istnieje seria z tymi samymi wartościami, ale w różnej kolejności (na przykład A = ["Apple", "Orange", "Banana"] i B = ["Orange", "Banana", "Apple"]). Wartości są sortowane przed utworzeniem wykresu, więc obie legendy są sortowane w taki sam sposób (["Apple", "Banana", "Orange"]), a te same wartości mają takie same kolory. Jeśli jednak istnieje seria C = ["Orange", "Banana"], nie będzie ona spójna kolorystycznie z zestawem A, ponieważ zestaw nie jest taki sam. Algorytm sortowania przypisuje pierwszy kolor do elementu „Banana” w zestawie C, ale inny kolor do elementu „Banana” w zestawie A. Jeśli chcesz, aby te serie były spójne kolorystycznie, możesz określić, że wykresy mają mieć globalną spójność koloru.

W przypadku globalnej spójności koloru każda wartość jest zawsze oznaczana tym samym kolorem niezależnie od tego, jakie wartości mają serie. Aby włączyć tę opcję dla każdego wykresu, zaznacz pole wyboru Globalna spójność koloru.

Global color consistency

Uwaga

Aby osiągnąć globalną spójność, usługa Azure Databricks tworzy skróty bezpośrednio z wartości do kolorów. Aby uniknąć kolizji (gdzie dwie wartości przechodzą do tego samego koloru), skrót prowadzi do dużego zestawu kolorów, co wywołuje taki efekt uboczny, że ładne lub łatwo rozróżnialne kolory nie mogą być zagwarantowane. Istnieje wiele kolorów, które są do siebie bardzo podobne.

Wizualizacje uczenia maszynowego

Oprócz standardowych typów wykresów funkcja display obsługuje wizualizacje następujących parametrów i wyników trenowania uczenia maszynowego:

Wartości resztkowe

W przypadku regresji liniowej i logistycznej funkcja display obsługuje renderowanie wykresu dopasowanych wartości względem wartości resztkowych. Aby uzyskać ten wykres, należy podać model i ramkę danych.

W poniższym przykładzie przeprowadzono regresję liniową dotyczącą populacji miasta do danych dotyczących cen sprzedaży, a następnie wyświetlono wartości resztkowe w porównaniu z danymi dopasowanymi.

# Load data
pop_df = (spark.read
  .format("csv")
  .option("header", "true")
  .option("inferSchema", "true")
  .load("/databricks-datasets/samples/population-vs-price/data_geo.csv")
)

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

Display residuals

Krzywe ROC

W przypadku regresji logistycznej funkcja display obsługuje renderowanie krzywej ROC. Aby uzyskać ten wykres, należy podać model, przygotowane dane, które są wprowadzane do metody fit, i parametr "ROC".

W poniższym przykładzie przedstawiono klasyfikator, który przewiduje, czy dana osoba zarabia <=50 000 lub >50 tys. rocznie z różnych atrybutów danej osoby. Zestaw danych o osobach dorosłych pochodzi ze spisu i składa się z informacji na temat 48 842 osób i ich rocznych dochodów.

W przykładowym kodzie w tej sekcji używane jest kodowanie typu „1 z n”. Nazwa tej funkcji zmieniła się na platformie Apache Spark 3.0, a więc kod nieco się różni w zależności od używanej wersji środowiska Databricks Runtime. Jeśli używasz środowiska Databricks Runtime w wersji 6.x lub starszej, musisz dostosować dwa wiersze w kodzie zgodnie z opisem w komentarzach do kodu.


# 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.schema(schema).format("csv").load("/databricks-datasets/adult/adult.data")

from pyspark.ml import Pipeline
from pyspark.ml.feature import OneHotEncoder, StringIndexer, VectorAssembler
# If you are using Databricks Runtime 6.x or below, comment out the preceding line and uncomment the following line.
# from pyspark.ml.feature import OneHotEncoderEstimator, 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"])
    # If you are using Databricks Runtime 6.x or below, comment out the preceding line and uncomment the following line.
    # encoder = OneHotEncoderEstimator(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")

Display ROC

Aby wyświetlić wartości resztkowe, pomiń parametr "ROC":

display(lrModel, preppedDataDF)

Display logistic regression residuals

Drzewa decyzyjne

Funkcja display obsługuje renderowanie drzewa decyzyjnego.

Aby uzyskać tę wizualizację, należy podać model drzewa decyzyjnego.

Poniższe przykłady trenują drzewo do rozpoznawania cyfr (0–9) z zestawu danych MNIST obrazów cyfr zapisanych ręcznie, a następnie wyświetlania drzewa.

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)

Display decision tree

Funkcja displayHTML

Notesy języka programowania (Python, R i Scala) w usłudze Azure Databricks obsługują grafiki HTML przy użyciu funkcji displayHTML. Można przekazać funkcję dowolnego kodu HTML, CSS lub JavaScript. Ta funkcja obsługuje interaktywne grafiki przy użyciu bibliotek JavaScript, takich jak D3.

Aby poznać przykłady korzystania z funkcji displayHTML, zobacz:

Uwaga

Element iframe displayHTML jest obsługiwany z poziomu domeny databricksusercontent.com, a piaskownica iframe zawiera atrybut allow-same-origin. Domena databricksusercontent.com musi być dostępna z poziomu przeglądarki. Jeśli jest ona obecnie zablokowana przez sieć firmową, musi zostać dodana do listy dozwolonych.

Wizualizacje według języka

W tej sekcji:

Wizualizacje w języku Python

Aby utworzyć wykres danych w języku Python, użyj funkcji display w następujący sposób:

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

Python bar chart

W tej sekcji:

Szczegółowe omówienie — notes języka Python

Aby uzyskać szczegółowe omówienie wizualizacji w języku Python przy użyciu funkcji display, zobacz notes:

Biblioteka seaborn

Do generowania wykresów można także użyć innych bibliotek języka Python. Środowisko Databricks Runtime zawiera bibliotekę wizualizacji seaborn. Aby utworzyć wykres seaborn, zaimportuj bibliotekę, utwórz wykres i przekaż wykres do funkcji 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)

Seaborn plot

Inne biblioteki języka Python

Wizualizacje w języku R

Aby utworzyć wykres danych w języku R, użyj funkcji display w następujący sposób:

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

Możesz użyć domyślnej funkcji wykresu języka R.

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

R default plot

Możesz również użyć dowolnego pakietu wizualizacji języka R. Notes języka R przechwytuje powstający wykres jako plik .png i wyświetla go w postaci śródwierszowej.

W tej sekcji:

Lattice

Pakiet Lattice obsługuje wykresy Trellis — wykresy, w których jest wyświetlana zmienna lub relacja między zmiennymi, które są kondycjonowane w co najmniej jednej innej zmiennej.

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

R Lattice plot

DandEFA

Pakiet DandEFA obsługuje wykresy 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)

R DandEFA plot

Plotly

Pakiet Plotly języka R opiera się na elementach htmlwidgets for R. Aby uzyskać instrukcje dotyczące instalacji i notes, zobacz htmlwidgets.

Inne biblioteki języka R

Wizualizacje w języku Scala

Aby utworzyć wykres danych w języku Scala, użyj funkcji display w następujący sposób:

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

Scala bar chart

Szczegółowe omówienie — notes języka Scala

Aby uzyskać szczegółowe omówienie wizualizacji w języku Scala przy użyciu funkcji display, zobacz notes:

Wizualizacje w języku SQL

Po uruchomieniu zapytania SQL usługa Azure Databricks automatycznie wyodrębnia część danych i wyświetla je jako tabelę.

SELECT color, avg(price) AS price FROM diamonds GROUP BY color ORDER BY COLOR

SQL table

Z tego miejsca można wybrać różne typy wykresów.

SQL bar chart

Profile danych w SQL

Ważne

Ta funkcja jest dostępna w publicznej wersji zapoznawczej.

Począwszy od środowiska Databricks Runtime 9.1, w okienku wyników są wyświetlane dwie karty: Table i Data Profile. Table Wyświetla wyniki w formacie tabelarycznym i zapewnia dostęp do różnych typów wykresów. Data Profile Wyświetla podsumowanie statystyk tabeli w formacie tabelarycznym i graficznym. Aby zapoznać się z przykładowym wyświetlaniem i szczegółowymi informacjami o wyświetlonych profilach danych, zobacz Profile danych.