Starší vizualizace
Tento článek popisuje starší vizualizace Azure Databricks. Informace o podpoře aktuální vizualizace najdete v poznámkových blocích Databricks.
Azure Databricks také nativně podporuje knihovny vizualizace v Pythonu a R a umožňuje instalaci a použití knihoven třetích stran.
Vytvoření starší vizualizace
Pokud chcete vytvořit starší vizualizaci z buňky s výsledky, klikněte + a vyberte Starší vizualizace.
Starší vizualizace podporují bohatou sadu typů vykreslování:
Volba a konfigurace staršího typu grafu
Pokud chcete vybrat pruhový graf, klikněte na ikonu 
pruhového grafu:
Pokud chcete zvolit jiný typ grafu, klikněte 
napravo od pruhového grafu a zvolte typ grafu.
Panel nástrojů starší verze grafu
Spojnicové a pruhové grafy mají integrovaný panel nástrojů, který podporuje celou řadu interakcí na straně klienta.
Pokud chcete nakonfigurovat graf, klikněte na tlačítko Plot options… (Možnosti grafu…).
Spojnicový graf obsahuje několik možností vlastního grafu: nastavení rozsahu osy Y, zobrazení a skrytí bodů a zobrazení osy Y s logaritmickým měřítkem.
Informace o starších typech grafů najdete v tématu:
Konzistence barev v různých grafech
Azure Databricks podporuje dva druhy konzistence barev napříč staršími grafy: sada řad a globální.
Konzistence barev sady řad přiřadí stejnou barvu stejné hodnotě, pokud máte řady se stejnými hodnotami, ale v různých pořadích (například A = ["Apple", "Orange", "Banana"] a B = ["Orange", "Banana", "Apple"]). Hodnoty se seřadí před vykreslením, aby byly obě legendy seřazené stejným způsobem (["Apple", "Banana", "Orange"]) a stejné hodnoty měly stejné barvy. Pokud však máte řadu C = ["Orange", "Banana"], nebude se barevně shodovat s nastavením A, protože nejde o stejnou řadu. Algoritmus řazení přiřadí první barvu banánům v řadě C, ale druhou barvu banánům v řadě A. Pokud chcete, aby byly barvy v řadách konzistentní, můžete u grafů nastavit globální konzistenci barev.
V rámci globální konzistence barev jsou všechny hodnoty vždy namapovány na stejnou barvu bez ohledu na to, jaké hodnoty mají řady. Pokud to chcete nastavit u všech grafů, zaškrtněte políčko Global color consistency (Globální konzistence barev).
Poznámka:
K dosažení této konzistence azure Databricks hashuje hodnoty přímo z hodnot na barvy. Aby nedocházelo ke kolizím (dvě hodnoty se změní na stejnou barvu), je hashování nastaveno na velkou množinu barev. Vedlejším účinkem je, že nelze zaručit dobře vypadající a snadno rozlišitelné barvy. Z důvodu použití mnoha barev je možné, že některé budou vypadat velmi podobně.
Vizualizace strojového učení
Kromě standardních typů grafů podporují starší vizualizace následující parametry a výsledky trénování strojového učení:
Rezidua
U lineárních a logistických regresí můžete vykreslit fitovaný graf a graf reziduí . Chcete-li získat tento graf, zadejte model a datový rámec.
V následujícím příkladu se spustí lineární regrese na populaci města k vytvoření dat o prodejních cenách nemovitostí a pak se zobrazí rezidua a fitované hodnoty.
# 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)
Křivky ROC
U logistických regresí můžete vykreslit křivku ROC . Chcete-li získat tento graf, zadejte model, předem zadaná fit data do metody a parametr "ROC".
Následující příklad vyvíjí klasifikátor, který předpovídá, jestli jednotlivec získá <=50K nebo >50k za rok z různých atributů jednotlivce. Datová sada Adult vychází z dat sčítání lidu a obsahuje informace o 48842 jednotlivcích a jejich ročních příjmech.
Vzorový kód v této části používá kódování 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")
Pokud chcete zobrazit rezidua, vynechte parametr "ROC":
display(lrModel, preppedDataDF)
rozhodovací stromy
Starší vizualizace podporují vykreslování rozhodovacího stromu.
Pokud chcete tuto vizualizaci získat, zadejte model rozhodovacího stromu.
Následující příklady natrénují strom tak, aby rozpoznal číslice (0–9) v datové sadě MNIST obsahující obrázky s ručně psanými číslicemi, a následně zobrazí příslušný strom.
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)
Datové rámce strukturovaného streamování
K vizualizaci výsledku dotazu streamování v reálném čase můžete pomocí funkce display zobrazit datové rámce se strukturovaným streamováním v jazycích Scala a 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 podporuje následující volitelné parametry:
streamName: název dotazu streamování.trigger(Scala) aprocessingTime(Python): Definuje, jak často se spouští dotaz streamování. Pokud tento parametr nezadáte, systém zkontroluje dostupnost nových dat ihned po dokončení předchozího zpracování. Pokud chcete snížit náklady v produkčním prostředí, Databricks doporučuje, abyste vždy nastavili interval pro aktivační událost. Výchozí interval aktivační události je 500 ms.checkpointLocation: místo, kam systém zapisuje všechny informace z kontrolních bodů. Pokud není zadáno, systém automaticky vygeneruje dočasné umístění pro kontrolní body v DBFS. Aby datový proud mohl navázat ve zpracování dat v místě, kde dříve přestal, musíte zadat umístění pro kontrolní body. Databricks doporučuje, abyste v produkčním prostředí vždy zadali možnostcheckpointLocation.
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>")
Další informace o těchto parametrech získáte v tématu Spouštění dotazů streamování.
Funkce displayHTML
Poznámkové bloky programovacích jazyků pro Azure Databricks (Python, R a Scala) podporují grafiku HTML díky funkci displayHTML. Této funkci můžete předat libovolný kód HTML, CSS nebo JavaScript. Tato funkce podporuje interaktivní grafiku s využitím knihoven JavaScriptu, jako je D3.
Příklady použití displayHTML:
Poznámka:
Iframe displayHTML se obsluhuje z domény databricksusercontent.com a sandbox iframe zahrnuje atribut allow-same-origin. Doména databricksusercontent.com musí být přístupná z prohlížeče. Pokud je v tuto chvíli zablokovaná podnikovou sítí, musíte ji přidat do seznamu povolených domén.
Obrázky
Sloupce obsahující datové typy obrázků se vykreslují jako formátovaný formát HTML. Azure Databricks se pokusí vykreslit miniatury obrázků pro DataFrame sloupce odpovídající Spark ImageSchema.
Vykreslování miniatur funguje pro všechny obrázky úspěšně přečtené prostřednictvím spark.read.format('image') funkce. Pro hodnoty obrázků generované jiným způsobem podporuje Azure Databricks vykreslování obrázků s 1, 3 nebo 4 kanály (kde se každý kanál skládá z jednoho bajtu) s následujícími omezeními:
- Obrázky s jedním kanálem:
modePole musí být rovno 0. Poleheight,widthanChannelsmusí přesně popisovat data binárního obrázku v polidata. - Obrázky se třemi kanály:
modePole musí být rovno 16. Poleheight,widthanChannelsmusí přesně popisovat data binárního obrázku v polidata. Poledatamusí obsahovat pixelová data v blocích po třech bajtech s kanály v pořadí(blue, green, red)pro každý pixel. - Obrázky se čtyřmi kanály:
modePole musí být rovno 24. Poleheight,widthanChannelsmusí přesně popisovat data binárního obrázku v polidata. Poledatamusí obsahovat pixelová data v blocích po čtyřech bajtech s kanály v pořadí(blue, green, red, alpha)pro každý pixel.
Příklad
Předpokládejme, že máte složku obsahující obrázky:
Pokud načtete obrázky do datového rámce a pak zobrazíte datový rámec, Azure Databricks vykreslí miniatury obrázků:
image_df = spark.read.format("image").load(sample_img_dir)
display(image_df)
Vizualizace v Pythonu
V této části:
Seaborn
K vygenerování grafů můžete také použít jiné knihovny Pythonu. Databricks Runtime obsahuje knihovnu vizualizací Seaborn. Pokud chcete vytvořit graf pomocí knihovny Seaborn, naimportujte ji, vytvořte graf a předejte ho funkci 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)
Další knihovny pro Python
Vizualizace v jazyce R
Pokud chcete vykreslovat data v R, použijte funkci display následujícím způsobem:
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"))
Můžete použít výchozí funkci grafu v jazyce R.
fit <- lm(Petal.Length ~., data = iris)
layout(matrix(c(1,2,3,4),2,2)) # optional 4 graphs/page
plot(fit)
Můžete také použít libovolný balíček pro vizualizaci R. Poznámkový blok R zachytí výsledný graf jako .png a zobrazí ho jako vložený.
V této části:
Lattice
Balíček Lattice podporuje grafy s šikmou jemnou mřížkou, které zobrazují proměnnou nebo vztah mezi proměnnými podmíněně v jedné nebo více různých proměnných.
library(lattice)
xyplot(price ~ carat | cut, diamonds, scales = list(log = TRUE), type = c("p", "g", "smooth"), ylab = "Log price")
DandEFA
Balíček DandEFA podporuje grafy ve tvaru pampelišek.
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
Balíček Plotly R spoléhá na htmlwidgety pro jazyk R. Pokyny k instalaci a poznámkový blok najdete v tématu htmlwidgets.
Další knihovny R
Vizualizace v jazyce Scala
Pokud chcete vykreslovat data v jazyce Scala, použijte funkci display následujícím způsobem:
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"))
Podrobné poznámkové bloky pro Python a Scala
Podrobné informace o vizualizacích Pythonu najdete v poznámkovém bloku:
Podrobné informace o vizualizacích Scala najdete v poznámkovém bloku:
Váš názor
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu: https://aka.ms/ContentUserFeedback.
Odeslat a zobrazit názory pro