Tracer.graph_objects.Disperser

Selon votre environnement, accélérez vos chiffres à l'aide d'un navigateur Web. Un navigateur Web prend en charge les capacités de rendu API SVG et WebGL. Le rendu SVG utilise le rendu vectoriel tandis que WebGL utilise l'API Canvas, rendu plus rapide à l'aide de GPU et de l'API WebGL.

En règle générale, vous ne remarquerez pas la différence entre le SVG et le chiffre rendu Webgl, sauf si vous tracez une grande quantité d'ensemble de données. En effet, WebGl est conçu pour gérer de grandes quantités de calcul en utilisant le GPU.

Dans cet article, nous allons tenter de vous montrer comment utiliser la classe Scandrgl à partir de l'intrigue Graph_Objects pour tracer un tracé de dispersion à l'aide de webgl.

Traçant 1 million de points en utilisant

Bien que l'intrigue Graph_Objects fournit une grande personnalisation et un contrôle de bas niveau, il est bon de comprendre la méthode la plus rapide et la plus efficace pour créer un tracé rendu Webgl.

C'est là que Plotly Express se trouve. À l'aide du paramètre Render_Mode, vous pouvez créer un tracé de diffusion et dire à Imply pour utiliser WebGL au lieu de SVG pour rendre une figure.

Un exemple est comme indiqué dans ce qui suit:

Importer un terrain.Exprime comme PX
Importer Numpy comme NP
Importer des pandas en tant que PD
n = 100000
df = pd.DataFrame (dict (
x = np.aléatoire.randn (n),
y = np.aléatoire.randn (n)
))
Fig = px.disperser (df, x = 'x', y = 'y')
figue.montrer()

Le code précédent crée un tracé de dispersion de 10000 points à l'aide du WEBLG Renderer Activer.

Utilisation de tracé Graph_Objects

Heureusement, dans Plotly Graph_Objects, nous pouvons utiliser la fonction ScatchGl qui utilise le WebGL par défaut.

L'exemple de code est comme indiqué dans les éléments suivants:

Importer un terrain.Graph_objects comme Go
Importer Numpy comme NP
n = 100000
Fig = aller.Chiffre()
figue.add_trace (
aller.ScatchGl (
x = np.aléatoire.randn (n),
y = np.aléatoire.randn (n),
mode = 'marqueurs'
)
)
figue.montrer()

Rendre le temps (SVG vs webgl)

Comme mentionné, WebGL offre un avantage des performances sur SVG. Cela peut être illustré lors du traçage d'un grand ensemble de données.

Exemple 1: Utilisation de ScatterGl

Importer un terrain.Graph_objects comme Go
Importer Numpy comme NP
n = 10000000
Fig = aller.Chiffre()
figue.add_trace (
aller.ScatchGl (
x = np.aléatoire.randn (n),
y = np.aléatoire.randn (n),
mode = 'marqueurs'
)
)
figue.montrer()

Le code précédent rend environ 3m 8.3 secondes.

Exemple 2: sans webgl

Importer un terrain.Exprime comme PX
Importer Numpy comme NP
Importer des pandas en tant que PD
n = 10000000
df = pd.DataFrame (dict (
x = np.aléatoire.randn (n),
y = np.aléatoire.randn (n)
))
Fig = px.disperser (df, x = 'x', y = 'y')
figue.montrer()

Ce code rend environ 5 minutes 12.5 secondes.

Gardez à l'esprit que les valeurs précédentes proviennent d'une seule fois mais ne reflètent pas avec précision l'avantage de WebGL sur SVG et vice versa.

Nous vous recommandons de faire votre test qui correspond à votre environnement et à vos besoins de calcul.

Conclusion

Dans cet article, nous avons illustré comment nous pouvons créer un tracé de dispersion à l'aide de SVG et de rendu Webgl dans l'intrigue.