Aller au contenu principal
Page non répertoriée
Cette page n'est pas répertoriée. Les moteurs de recherche ne l'indexeront pas, et seuls les utilisateurs ayant un lien direct peuvent y accéder.
Dernière mise à jour le

Anciennes visualisations

Cet article décrit les visualisations Databricks héritées. Reportez-vous à Visualisations dans les notebooks et l'éditeur SQL Databricks pour connaître la prise en charge actuelle de la visualisation lors de la création de visualisations dans l'éditeur SQL ou un notebook. Pour plus d'informations sur l'utilisation des visualisations dans les AI/BI dashboards, consultez types de visualisation des AI/BI dashboards.

Databricks prend également en mode natif en charge les bibliothèques de visualisation en Python et R, et vous permet d'installer et d'utiliser des bibliothèques tierces.

Créer une visualisation héritée​

Pour créer une visualisation héritée à partir d'une cellule de résultats, cliquez sur + et sélectionnez Visualisation héritée .

Les anciennes visualisations prennent en charge un riche ensemble de types de tracé :

Types de graphique

Choisissez et configurez un type de graphique d'ancienne génération​

Pour choisir un graphique à barres, cliquez sur l'icône de graphique à barres Bouton graphique:

Icône de graphique à barres

Pour choisir un autre type de graphique, cliquez sur Bouton Bas à droite du graphique à barres Bouton graphique et choisissez le type de graphique.

Barre d’outils des graphiques d’ancienne génération​

Les graphiques linéaires et à barres disposent d'une barre d'outils intégrée qui prend en charge un ensemble riche d'interactions côté client.

Barre d'outils des graphiques

Pour configurer un graphique, cliquez sur Options du tracé… .

Options de tracé

Le graphique linéaire dispose de plusieurs options personnalisées : la définition d'une plage pour l'axe Y, l'affichage et le masquage des points, et l'affichage de l'axe Y avec une échelle logarithmique.

Pour plus d’informations sur les types de graphiques hérités, consultez :

Cohérence des couleurs dans les graphiques​

Databricks prend en charge deux types de cohérence des couleurs pour les graphiques d'ancienne génération : séries définies et globales.

La cohérence des couleurs du jeu de séries attribue la même couleur à la même valeur si vous avez des séries avec les mêmes valeurs mais dans des ordres différents (par exemple, A = ["Apple", "Orange", "Banana"] et B = ["Orange", "Banana", "Apple"]). Les valeurs sont triées avant le traçage, ainsi les deux légendes sont triées de la même manière (["Apple", "Banana", "Orange"]), et les mêmes valeurs reçoivent les mêmes couleurs. Cependant, si vous avez une série C = ["Orange", "Banana"], elle ne serait pas cohérente en termes de couleur avec l'ensemble A car l'ensemble n'est pas le même. L'algorithme de tri attribuerait la première couleur à « Banana » dans l'ensemble C, mais la deuxième couleur à « Banana » dans l'ensemble A. Si vous souhaitez que ces séries soient cohérentes en termes de couleur, vous pouvez spécifier que les graphiques doivent avoir une cohérence globale des couleurs.

Dans la cohérence des couleurs globale , chaque valeur est toujours associée à la même couleur, indépendamment des valeurs des séries. Pour l'activer pour chaque graphique, cochez la case Cohérence globale des couleurs .

Cohérence globale des couleurs

remarque

Pour atteindre cette cohérence, Databricks hache directement des valeurs aux couleurs. Pour éviter les collisions (lorsque deux valeurs aboutissent à la même couleur exacte), le hachage s'effectue sur un grand ensemble de couleurs, ce qui a pour effet secondaire que de belles couleurs ou des couleurs facilement distinguables ne peuvent être garanties ; avec de nombreuses couleurs, il est inévitable que certaines se ressemblent beaucoup.

Visualisations Machine Learning​

En plus des types de graphiques standards, les visualisations héritées prennent en charge les paramètres et les résultats d'entraînement Machine Learning suivants :

Résidus​

Pour les régressions linéaires et logistiques, vous pouvez rendre un tracé ajusté par rapport aux résidus. Pour obtenir ce tracé, fournissez le modèle et le DataFrame.

L'exemple suivant exécute une régression linéaire sur les données de la population de la ville par rapport au prix de vente des maisons, puis affiche les résidus par rapport aux données ajustées.

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

Afficher les résidus

Courbes ROC​

Pour les régressions logistiques, vous pouvez afficher une courbe ROC. Pour obtenir ce tracé, fournissez le modèle, les données préparées qui sont entrées dans la méthode fit et le paramètre "ROC".

L’exemple suivant développe un classificateur qui prédit si un individu gagne <=50K ou >50k par an à partir de divers attributs de l’individu. Le dataset Adult dérive des données de recensement et contient des informations sur 48 842 individus et leur revenu annuel.

Le code d'exemple dans cette section utilise l'encodage one-hot.

Python

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

Afficher la courbe ROC

Pour afficher les résidus, omettez le paramètre "ROC" :

Python
display(lrModel, preppedDataDF)

Afficher les résidus de régression logistique

Arbres de décision​

Les visualisations héritées prennent en charge le rendu d’un arbre de décision.

Pour obtenir cette visualisation, fournissez le modèle d'arbre de décision.

Les exemples suivants entraînent un arbre à reconnaître les chiffres (0 - 9) du dataset MNIST d'images de chiffres manuscrits, puis affichent l'arbre.

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

Afficher l&#39;arbre de décision

DataFrames Structured Streaming​

Pour visualiser le résultat d'une query de streaming en temps réel, vous pouvez display un DataFrame Structured Streaming en Scala et Python.

Python
streaming_df = spark.readStream.format("rate").load()
display(streaming_df.groupBy().count())

display prend en charge les paramètres facultatifs suivants :

  • streamName: le nom de la query de streaming.
  • trigger (Scala) et processingTime (Python) : définit la fréquence d’exécution de la query de streaming. Si non spécifié, le système vérifie la disponibilité de nouvelles données dès que le traitement précédent est terminé. Pour réduire les coûts en production, Databricks vous recommande de toujours définir un intervalle de trigger. L’intervalle de default Trigger est de 500 ms.
  • checkpointLocation: l'emplacement où le système écrit toutes les informations de point de contrôle. S'il n'est pas spécifié, le système génère automatiquement un emplacement de point de contrôle temporaire sur DBFS. Pour que votre Stream continue de traiter les données là où il s'est arrêté, vous devez fournir un emplacement de point de contrôle. Databricks recommande qu'en production, vous toujours spécifiiez l'option checkpointLocation.
Python
streaming_df = spark.readStream.format("rate").load()
display(streaming_df.groupBy().count(), processingTime = "5 seconds", checkpointLocation = "dbfs:/<checkpoint-path>")

Pour plus d’information sur ces parameters, consultez Démarrer les query de streaming.

displayHTML fonction​

Les Notebooks de langage de programmation Databricks (Python, R et Scala) prennent en charge les graphiques HTML à l'aide de la fonction displayHTML ; vous pouvez passer à la fonction n'importe quel code HTML, CSS ou JavaScript. Cette fonction prend en charge les graphiques interactifs utilisant des bibliothèques JavaScript telles que D3.

Pour des exemples d'utilisation de displayHTML, voir :

remarque

L'iframe displayHTML est servi depuis le domaine databricksusercontent.com, et le sandbox de l'iframe inclut l'attribut allow-same-origin. databricksusercontent.com doit être accessible depuis votre navigateur. S'il est actuellement bloqué par votre réseau d'entreprise, il doit être ajouté à une liste d'autorisation.

Images​

Les colonnes contenant des types de données image sont rendues sous forme de HTML enrichi. Databricks tente de rendre les miniatures d'images pour les colonnes DataFrame correspondant à l'ImageSchema de Spark. Le rendu des miniatures fonctionne pour toutes les images lues avec succès par la fonction spark.read.format('image'). Pour les valeurs d'image générées par d'autres moyens, Databricks prend en charge le rendu d'images à 1, 3 ou 4 canaux (où chaque canal est constitué d'un seul octet), avec les contraintes suivantes :

  • Images monocanal : Le champ mode doit être égal à 0. Les champs height, width et nChannels doivent décrire précisément les données d'image binaires dans le champ data.
  • Images à trois canaux : mode le champ doit être égal à 16. height Leswidth champs, et nChannels doivent décrire avec précision les données d'image binaire dans le data champ. Le champ data doit contenir des données de pixel par blocs de trois octets, avec l'ordre des canaux (blue, green, red) pour chaque pixel.
  • Images à quatre canaux : le champ mode doit être égal à 24. Les champs height, width et nChannels doivent décrire précisément les données d'image binaires du champ data. Le champ data doit contenir des données de pixels par blocs de quatre octets, avec l'ordonnancement des canaux (blue, green, red, alpha) pour chaque pixel.

Exemple​

Supposons que vous ayez un dossier contenant des images :

Dossier de données images

Si vous lisez les images dans un DataFrame et que vous affichez ensuite le DataFrame, Databricks affiche des miniatures des images :

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

Affichez le DataFrame de l&#39;image.

Visualisations en Python​

Dans cette section :

Seaborn​

Vous pouvez également utiliser d'autres bibliothèques Python pour générer des tracés. Le Databricks Runtime inclut la bibliothèque de visualisation seaborn. Pour créer un tracé Seaborn, importez la bibliothèque, créez un tracé et passez le tracé à la fonction display.

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

Tracé Seaborn

Autres bibliothèques Python​

Visualisations dans R​

Pour tracer des données dans R, utilisez la fonction display comme suit :

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

Vous pouvez utiliser la fonction plot R par default.

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

Tracé R par default

Vous pouvez également utiliser tout package de visualisation R. Le notebook R capture le tracé résultant en tant que .png et l'affiche en ligne.

Dans cette section :

Lattice​

Le package Lattice prend en charge les graphes en treillis, c'est-à-dire des graphes qui affichent une variable ou la relation entre des variables, conditionnées par une ou plusieurs autres variables.

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

Diagramme en treillis R

DandEFA​

Le package DandEFA prend en charge les diagrammes en pissenlit.

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

Diagramme R DandEFA

Plotly​

Le package Plotly R repose sur htmlwidgets for R. Pour les instructions d'installation et un Notebook, consultez htmlwidgets.

Autres bibliothèques R​

Visualisations en Scala​

Pour tracer des données en Scala, utilisez la fonction display comme suit :

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

Notebooks approfondis pour Python et Scala​

Pour une plongée approfondie dans les visualisations Python, consultez le notebook :

Pour une étude approfondie des visualisations Scala, consultez le notebook :

Sur cette page