Plot 3D Seaborn

Nous pouvons tracer différents modèles de graphiques 3D avec la configuration des coordonnées tridimensionnelles. L'une des fonctionnalités qui nous incite à voir les graphiques dynamiquement est le graphique 3D; Nous en avons besoin lorsque vous utilisez les graphiques immersifs. Nous pouvons importer les bibliothèques nécessaires, qui incluent certaines fonctions pour créer les graphiques tridimensionnels. Puisqu'il n'y a pas de fonctionnalité intégrée dans le module SeaBorn pour dessiner les graphiques 3D, c'est le plugin Matplotlib qui dépend de faire le travail réel dans les graphiques tridimensionnels. Par conséquent, nous pouvons utiliser SeaBorn pour personnaliser les graphiques 3D. Nous explorerons comment dessiner de nombreux graphiques tridimensionnels différents dans ce tutoriel.

Exemple 1

Un groupe de graphiques de dispersion formés à l'aide des combinaisons de triples est le graphique 3D le plus basique. La fonction PLOT3D () et la méthode Scatter3D (), comme les graphiques 2D les plus fréquents, sont utilisés pour les dessiner. Dans ce cas, nous allons dessiner une hélice hyperbolique, avec divers endroits proches de la ligne.

Importer Numpy comme NP
Importer Matplotlib.pypllot comme plt
Importer Seaborn comme SNS
Fig = plt.chiffre()
hache = plt.Axes (projection = '3d')
zline = np.lispace (0, 20, 2000)
xline = np.péché (zline)
yline = np.cos (zline)
hache.Plot3d (Xline, Yline, Zline, «Gray»)
zdata = 15 * np.aléatoire.Random (200)
xdata = np.sin (zdata) + 0.1 * np.aléatoire.Randn (200)
ydata = np.cos (zdata) + 0.1 * np.aléatoire.Randn (200)
hache.Scatter3d (xdata, ydata, zdata, c = zdata, cmap = 'blues');
PLT.montrer()

Ici, nous importons les fichiers d'en-tête requis. Le module Numpy est introduit comme NP, Matplotlib.Pypllot est introduit comme PLT, et SeaBorn est introduit comme SNS. À l'étape suivante, nous appelons la fonction figure () pour dessiner la figure. Cette fonction appartient à Matplotlib.bibliothèque pypllot. Maintenant, nous utilisons la fonction axes () pour spécifier la valeur de la projection.

Ici, nous voulons créer un tracé en trois dimensions, nous avons donc donné une valeur 3D. Définissons les données d'une ligne 3D. Nous déclarons les trois variables différentes et les assignons aux valeurs des trois axes. Tout d'abord, nous définissons les valeurs d'espacement pour l'axe Z, nous appliquons donc la fonction de lignes d'espace () du package Numpy. À l'aide de la valeur de l'espacement de l'axe Z, nous indiquons les valeurs d'espacement pour les autres axes, X et Y.

Maintenant, pour dessiner une parcelle 3D, nous utilisons la fonction Plot3D (). Ici, nous fournissons l'espacement de tous les axes et la couleur de l'arrière-plan du tracé 3D comme argument de la fonction. De plus, nous définissons les données pour les points de dispersion 3D. Nous appelons séparément la fonction randn () de la bibliothèque Numpy pour tous les trois axes. En faisant cela, nous obtenons les points à partir desquels nous tirons le graphique de dispersion.

Pour dessiner le tracé de dispersion en utilisant ces points, nous utilisons la méthode Scatter3D (). Cette fonction contient plusieurs paramètres qui incluent les données de X, Y et de l'axe Z ainsi que la valeur de «CMAP». La valeur du paramètre «cmap» montre la couleur de la ligne tracée dans le tracé 3D. La méthode show () est appelée pour illustrer la carte.

Exemple 2

Toutes les données requises pour la méthode contour3d () doivent être dans l'état d'un nœud de grille 2D, ainsi que les données Z analysées à chaque point. Un graphique de contour 3D d'une fonction périodique est illustré dans l'illustration suivante:

Importer Numpy comme NP
Importer Matplotlib.pypllot comme plt
Importer Seaborn comme SNS
def f (x, y):
retour np.péché (np.sqrt (x ** 4 + y ** 4))
x = np.lispace (-4, 4, 25)
y = np.lispace (-4, 4, 25)
X, y = np.Meshgrid (x, y)
Z = f (x, y)
Fig = plt.chiffre()
hache = plt.Axes (projection = '3d')
hache.contour3d (x, y, z, 40, cmap = 'binaire')
hache.set_xlabel ('x')
hache.set_ylabel ('y')
hache.set_zlabel ('z')
PLT.montrer()

Au début du programme, nous incorporons les bibliothèques Numpy comme NP, Matplotlib.pypllot comme plt et marin comme sns. Maintenant, nous définissons une fonction f () ayant deux paramètres qui renvoient la valeur en utilisant la méthode sqrt () de la bibliothèque Numpy. Nous indiquons les valeurs d'espacement pour les deux axes x et y à l'aide de lispace ().Cette méthode est liée au cadre Numpy.

Dans la ligne suivante, nous avons appliqué la fonction MeshGrid () pour créer une grille de maillage dans le graphique 3D. Cette fonction contient la valeur de l'espacement des lignes des axes x et y comme paramètres. Ici, nous utilisons la fonction figure () de Matplotlib.bibliothèque pyplot pour créer la figure. Pour définir le niveau de projection, nous utilisons la méthode des axes (). Nous devons construire une carte tridimensionnelle, nous fournissons donc une valeur 3D à la fonction. Nous appliquons maintenant la méthode contour3d ().

En tant que paramètre de la fonction, nous lui donnons l'espacement de tous les axes et la teinte du graphique 3D. Ensuite, nous spécifions les légendes des trois axes afin que la méthode set_label () soit appelée respectivement tous les axes. Pour démontrer le graphique, la fonction show () est utilisée.

Exemple 3

Dans ce cas, nous créons un tracé de surface dans le graphique tridimensionnel en utilisant la méthode Plot_surface ().

Importer Seaborn comme SB
Importer Matplotlib.pypllot comme tracé
Importer Numpy comme NP
def func_z (x, y):
return50 - (x ** 2 + y ** 2)
sb.set_style ('whitegrid')
N = 50
X_val = np.lispace (-5, 5, n)
Y_val = np.lispace (-5, 5, n)
X1, y1 = np.MeshGrid (X_Val, Y_Val)
Z1 = func_z (x1, y1)
Axes = tracé.Axes (projection = '3d')
haches.Plot_surface (X1, Y1, Z1)
parcelle.montrer()

Tout d'abord, nous intégrons les modules Seaborn, Matplotlib.pypllot et np. Nous définissons la fonction de l'axe Z et cette fonction est fournie avec l'axe x et y. Cette fonction renvoie la valeur de l'axe z. Dans la phase suivante, nous utilisons la méthode set_style () pour personnaliser la disposition du tracé. Nous définissons sa valeur sur Whitegrid.

Maintenant, nous déclarons une variable et lui attribuons une valeur. La méthode lispace () est appelée pour indiquer l'espacement de l'axe x et y. Nous dessinons le maillage sur l'axe Z, nous utilisons donc la méthode MeshGrid (). Cette fonction est tirée du package Numpy. Nous appelons la fonction des valeurs de l'axe z. Pour le graphique 3D, il est obligatoire de spécifier la valeur de projection. Pour cela, nous utilisons la fonction axes ().

Pour dessiner le graphique de surface, la fonction Plot_surface () est exécutée. Cette fonction contient la valeur des trois axes. Avant de terminer le code, nous utilisons la méthode Show () pour représenter le tracé finalisé.

Exemple 4

Ici, nous utilisons la méthode wireframe () pour dessiner le wireframe dans le tracé 3D.

Importer Numpy comme NP
Importer Matplotlib.pypllot comme plt
Importer Seaborn comme SNS
Fig = plt.chiffre()
hache = plt.Axes (projection = '3d')
zline = np.lispace (0, 20, 2000)
xline = np.péché (zline)
yline = np.cos (zline)
hache.Plot3d (Xline, Yline, Zline, «Gray»)
zdata = 15 * np.aléatoire.Random (200)
xdata = np.sin (zdata) + 0.1 * np.aléatoire.Randn (200)
ydata = np.cos (zdata) + 0.1 * np.aléatoire.Randn (200)
hache.Scatter3d (xdata, ydata, zdata, c = zdata, cmap = 'blues')
PLT.montrer()

Après avoir introduit les cadres essentiels, nous identifions la fonctionnalité de l'axe Z qui est disponible avec les axes X et Y. La valeur de l'axe Z est obtenue par ce processus. Nous utilisons la fonction Set Style () pour modifier la conception du graphique à l'étape suivante. Sa valeur est configurée pour le Whitegrid. Nous initialisons maintenant une variable n et lui donnons une valeur.

Pour spécifier l'espacement entre les axes x et y, la technique lispace () est appliquée. Nous utilisons la fonction MeshGrid () parce que nous voulons représenter le maillage de l'axe Z. Ceci est une technique de la boîte à outils Numpy. Le composant de la valeur de l'axe Z est considéré. La valeur de projection doit être indiquée pour la visualisation 3D. Nous utilisons la méthode des axes () pour cela. La méthode wireframe () est appliquée pour créer le graphique wireframe. La valeur des trois axes est incorporée dans cette méthode. Nous utilisons la fonction show () pour afficher le graphique entier à la fin.

Conclusion

Dans cette section, nous avons traversé les différentes approches utilisées pour créer une intrigue 3D avec le cadre de Seaborn. Nous avons également appris à dessiner les cartes de contour 3D, à dessiner le wireframe sur le graphique tridimensionnel, et à créer un graphique de surface sur les parcelles 3D. Il n'y a pas de caractéristique tridimensionnelle intégrée dans le cadre de Seaborn.