Örökölt vizualizációk

Ez a cikk az örökölt Azure Databricks-vizualizációkat ismerteti. A Vizualizációk a Databricks-jegyzetfüzetekben és az SQL-szerkesztőben a vizualizációk sql-szerkesztőben vagy jegyzetfüzetben való létrehozásakor az aktuális vizualizációs támogatásért lásd. Az AI/BI-irányítópultok vizualizációinak használatával kapcsolatos információkért tekintse meg az AI/BI-irányítópultok vizualizációtípusait.

Az Azure Databricks emellett natív módon támogatja a Python és az R vizualizációs kódtárait, és lehetővé teszi külső kódtárak telepítését és használatát is.

Örökölt vizualizáció létrehozása

Ha egy eredménycellából szeretne örökölt vizualizációt létrehozni, kattintson a + elemre, és válassza Örökölt vizualizációlehetőséget.

Az örökölt vizualizációk számos diagramtípust támogatnak:

Örökölt diagramtípus kiválasztása és konfigurálása

Sávdiagram kiválasztásához kattintson a sávdiagram ikonra :

Másik diagramtípus kiválasztásához kattintson a sávdiagram jobb oldalára, és válassza ki a diagram típusát.

Örökölt diagram eszköztára

A vonal- és sávdiagramok beépített eszköztárral rendelkeznek, amely számos ügyféloldali interakciót támogat.

Diagram konfigurálásához kattintson az Ábrázolási beállítások... elemre.

A vonaldiagramok számára több egyéni diagrambeállítás megadható: az Y tengely tartományának beállítása, pontok megjelenítése és elrejtése, vagy az Y tengely megjelenítése logaritmikus skálával.

További információ az örökölt diagramtípusokról:

• Örökölt vonaldiagramok migrálása

Színkonzisztencia a diagramokban

Az Azure Databricks kétféle színkonzisztenciát támogat az örökölt diagramok között: sorozatkészlet és globális.

adatsorkészlet színkonzisztencia ugyanazt a színt rendeli ugyanahhoz az értékhez, ha azonos értékekkel rendelkezik, de különböző sorrendben (például A = ["Apple", "Orange", "Banana"] és B = ["Orange", "Banana", "Apple"]). Az értékek rendezése a ábrázolás előtt történik, így mindkét jelmagyarázat ugyanúgy lesz rendezve (["Apple", "Banana", "Orange"]), és ugyanazok az értékek ugyanazt a színt kapják. Ha azonban C = ["Orange", "Banana"]sorozattal rendelkezik, az nem lenne színkonzisztens az A beállítással, mert a készlet nem azonos. A rendezési algoritmus az első színt a "Banán" értékhez rendeli a C halmazban, a második színt pedig a "Banán" értékhez az A beállításban. Ha azt szeretné, hogy ezek az adatsorok színkonzisztensek legyenek, megadhatja, hogy a diagramoknak globális színkonzisztenciájúnak kell lenniük.

A globális színkonzisztenciában minden érték mindig ugyanarra a színre van leképezve, függetlenül attól, hogy az adatsor milyen értékekkel rendelkezik. Ha ezt minden diagramhoz engedélyezni szeretné, jelölje be a Globális színkonzisztencia jelölőnégyzetet.

Megjegyzés

Ennek a konzisztenciának elérése érdekében az Azure Databricks közvetlenül az értékekről a színekre kivonatokat ad. Az ütközések elkerülése érdekében (amikor két érték pontosan ugyanarra a színre esik), a hash egy nagy színkészlethez rendel, amelynek mellékhatása, hogy a szép vagy könnyen megkülönböztethető színek nem garantálhatók; sok szín esetén valószínűleg lesznek olyanok, amelyek nagyon hasonló megjelenésűek.

Gépi tanulási vizualizációk

A hagyományos diagramtípusok mellett az örökölt vizualizációk a következő gépi tanulási betanítási paramétereket és eredményeket támogatják:

• Reziduálisok
• ROC-görbék
• Döntési fák

Maradványok

Lineáris és logisztikai regressziók esetén egy illesztett és egy reziduális diagramot jeleníthet meg. A diagram beszerzéséhez adja meg a modellt és a DataFrame-et.

Az alábbi példa lineáris regressziót futtat a városi populáción a házak eladási árainak adataira vonatkozóan, majd megjeleníti a reziduálisokat az illesztett adatokkal összevetésben.

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

ROC-görbék

Logisztikai regressziók esetén ROC-görbét jeleníthet meg. A diagram beszerzéséhez adja meg a modellt, a metódushoz fit bemenetként megadott előre beírt adatokat és a paramétert "ROC".

Az alábbi példa egy osztályozót fejleszt, amely előrejelzi, hogy egy személy évente <=50K vagy >50k-nál kevesebbet keres-e az egyén különböző attribútumai alapján. Az Adult adathalmaz népszámlálási adatokból származik, 48 842 személlyel és éves jövedelmükkel kapcsolatos információkból áll.

Az ebben a szakaszban található példakód one-hot kódolást használ.

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

A reziduálisok megjelenítéséhez hagyja ki a "ROC" paramétert:

display(lrModel, preppedDataDF)

Döntési fák

Az örökölt vizualizációk támogatják a döntési fa megjelenítését.

A vizualizáció eléréséhez adja meg a döntési fa modelljét.

Az alábbi példák egy döntési fát tanítanak be a számjegyek (0–9) felismerésére az MNIST kézzel írt számjegyekről készült képeinek adathalmazából, majd megjelenítik a fát.

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)

Strukturált streamelési adatkeretek

Egy streamelési lekérdezés eredményének valós idejű megjelenítéséhez a display függvénnyel megjeleníthet egy strukturáltan streamelt adatkeretet Scala vagy Python nyelven.

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 a következő választható paramétereket támogatja:

• streamName: a streamelési lekérdezés neve.
• trigger (Scala) és processingTime (Python): a streamelési lekérdezés futtatásának gyakoriságát határozza meg. Ha nincs megadva, a rendszer az előző feldolgozás befejezése után azonnal ellenőrzi, hogy elérhetők-e új adatok. A gyártási költségek csökkentése érdekében a Databricks azt javasolja, hogy mindig állítson be egy indító időközt. Az alapértelmezett triggerintervallum 500 ms.
• checkpointLocation: az a hely, ahol a rendszer minden ellenőrzőpont-információt megír. Ha nincs megadva, a rendszer automatikusan létrehoz egy ideiglenes ellenőrzőponthelyet a DBFS-ben. Ahhoz, hogy a stream folytassa az adatok feldolgozását onnan, ahonnan abbahagyta, meg kell adnia egy ellenőrzőpont helyét. A Databricks azt javasolja, hogy éles környezetben mindig adja meg a checkpointLocation paramétert.

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

További információ ezekről a paraméterekről: Streamlekérdezések indítása.

A displayHTML függvény

Az Azure Databricks programozási nyelvi jegyzetfüzetei (Python, R és Scala) a displayHTML függvénnyel támogatják a HTML-grafikákat; a függvénynek bármilyen HTML-, CSS- vagy JavaScript-kódot átadhat. A függvény támogatja az interaktív grafikákat is a JavaScript-kódtárak, például a D3 használatával.

Példák a displayHTML használatára:

• HTML, D3 és SVG használata jegyzetfüzetekben

• Statikus képek beágyazása jegyzetfüzetekbe

Megjegyzés

A displayHTML iframe kiszolgálása a databricksusercontent.com tartományból történik, és az iframe tesztkörnyezet magában foglalja az allow-same-origin attribútumot. A databricksusercontent.com címnek elérhetőnek kell lennie a böngészőből. Ha a vállalati hálózat jelenleg letiltja, fel kell vennie egy engedélyezési listára.

Képek

A képadattípusokat tartalmazó oszlopok gazdag HTML-formátumban jelennek meg. Az Azure Databricks megkísérli renderelni a Spark DataFramemegfelelő oszlopok miniatűrjeit. A miniatűrök renderelése minden olyan képnél működik, amelyet sikeresen beolvasott a spark.read.format('image') függvény. Más eszközökkel létrehozott képértékek esetében az Azure Databricks 1, 3 vagy 4 csatornás rendszerkép renderelését támogatja (ahol az egyes csatornák egyetlen bájtból állnak), az alábbi korlátozásokkal:

• Egycsatornás képek: A mode mezőnek 0-val kell egyenlőnek lennie. A height, width és nChannels mezőnek pontosan kell leírnia a data mezőben található bináris képadatokat.
• Háromcsatornás képek: A mode mezőnek 16-tal kell egyenlőnek lennie. A height, width és nChannels mezőnek pontosan kell leírnia a data mezőben található bináris képadatokat. A data mezőnek képpontadatokat kell tartalmaznia hárombájtos adattömbökben az egyes képpontok csatornasorrendjével (blue, green, red).
• Négycsatornás képek: A mode mezőnek 24-gyel kell egyenlőnek lennie. A height, width és nChannels mezőnek pontosan kell leírnia a data mezőben található bináris képadatokat. A data mezőnek képpontadatokat kell tartalmaznia négybájtos adattömbökben az egyes képpontok csatornasorrendjével (blue, green, red, alpha).

Példa

Tegyük fel, hogy van egy néhány képet tartalmazó mappa:

Ha beolvassa a képeket egy DataFrame-be, majd megjeleníti a DataFrame-et, az Azure Databricks megjeleníti a képek miniatűrjeit:

image_df = spark.read.format("image").load(sample_img_dir)
display(image_df)

Vizualizációk Python nyelven

Ebben a szakaszban:

• Seaborn
• Egyéb Python-kódtárak

tengerből származó

Más Python-kódtárak használatával is létrehozhat diagramokat. A Databricks Runtime magában foglalja a seaborn vizualizációs kódtárat. Seaborn-ábrázolás létrehozásához importálja a kódtárat, hozzon létre egy ábrázolást, és adja át a display függvénynek.

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)

Egyéb Python-kódtárak

• Bokeh
• Matplotlib
• Plotly

Vizualizációk R nyelven

Az adatok R nyelven történő ábrázolásához az alábbiak szerint használja a display függvényt:

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

Használja az R alapértelmezett plot függvényét.

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

Emellett használhat bármilyen R nyelvű vizualizációs csomagot. Az R-jegyzetfüzet az eredményül kapott grafikont .png-ként rögzíti, és beágyazva jeleníti meg.

Ebben a szakaszban:

• Rács
• DandEFA
• Plotly
• Egyéb R-kódtárak

Rács

A Lattice csomag a hálógráfokat támogatja, amelyek egy változót vagy változók közötti viszonyt jelenítenek meg, egy vagy több más változóra vonatkozó feltételhez kötve.

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

DandEFA

A DandEFA csomag a pitypangábrázolásokat támogatja.

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)

Ábrázolás

A Plotly R csomag az R htmlwidgetjeire támaszkodik. A telepítési utasításokat és a jegyzetfüzetet a htmlwidgets című témakörben találja.

Egyéb R-kódtárak

• ggplot2
• htmlwidgets

Vizualizációk Scala nyelven

Az adatok Scala nyelven történő ábrázolásához az alábbiak szerint használja a display függvényt:

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

Mélybe merülő jegyzetfüzetek Pythonhoz és Scalához

A Python-vizualizációk részletes bemutatása a jegyzetfüzetben található:

• Vizualizáció részletes bemutatása Python nyelven

A Scala-vizualizációk részletes bemutatása a jegyzetfüzetben található:

• Vizualizáció részletes bemutatása Scala nyelven