Seaborn 3D -plot

Vi kan plotte forskjellige mønstre av 3D-grafer med konfigurasjonen av de tredimensjonale koordinatene. En av funksjonene som insentiverer oss fra å se grafene dynamisk er 3D -grafingen; Vi trenger det når du bruker den oppslukende grafikken. Vi kan importere de nødvendige bibliotekene, som inkluderer noen funksjoner for å lage de tredimensjonale grafene. Siden det ikke er noen innebygd funksjonalitet i Seaborn-modulen for å tegne 3D-grafene, er det matplotlib-plugin som er avhengig av for å gjøre det faktiske arbeidet i de tredimensjonale grafene. Derfor kan vi bruke Seaborn til å tilpasse 3D -grafikken. Vi vil utforske hvordan du tegner mange forskjellige tredimensjonale grafer i denne opplæringen.

Eksempel 1

En gruppe spredningsgrafer dannet ved hjelp av kombinasjonene av tripler er den mest grunnleggende 3D -grafen. PLOT3D () -funksjonen og SCATTER3D () -metoden, som de hyppigere 2D -diagrammer, brukes til å tegne disse. I dette tilfellet tegner vi en hyperbolsk helix, med forskjellige steder nær linjen.

Importer numpy som NP
Importer matplotlib.Pyplot som Plt
Importer sjøborn som SNS
Fig = plt.figur()
AX = plt.Axes (projeksjon = '3d')
zline = np.Linspace (0, 20, 2000)
xline = np.Sin (Zline)
Yline = NP.cos (zline)
øks.plot3d (xline, yline, zline, 'grå')
zdata = 15 * np.tilfeldig.Tilfeldig (200)
xData = np.sin (zdata) + 0.1 * np.tilfeldig.Randn (200)
ydata = np.cos (zdata) + 0.1 * np.tilfeldig.Randn (200)
øks.scatter3d (xdata, ydata, zdata, c = zdata, cmap = 'blues');
plt.forestilling()

Her importerer vi de nødvendige overskriftsfilene. Numpy -modulen introduseres som NP, Matplotlib.Pyplot introduseres som PLT, og Seaborn blir introdusert som SNS. I neste trinn kaller vi figur () -funksjonen for å tegne figuren. Denne funksjonen tilhører matplotlib.Pyplot Library. Nå bruker vi Axes () -funksjonen for å spesifisere verdien av projeksjonen.

Her ønsker vi å lage et tredimensjonalt plot, så vi har gitt en 3D-verdi. La oss definere dataene for en 3D -linje. Vi erklærer de tre forskjellige variablene og tildeler dem verdiene for alle de tre aksene. Først setter vi verdiene for avstand for z-aksen, så vi bruker linjens () -funksjonen til Numpy-pakken. Ved hjelp av verdien av z-aksetavstand indikerer vi verdiene for avstand for andre akser, x og y.

Nå, for å tegne en 3D -plott, bruker vi PLOT3D () -funksjonen. Her gir vi avstanden til alle akser og fargen på bakgrunnen på 3D -plottet som funksjonens argument. Videre setter vi dataene for 3D -spredningspunktene. Vi kaller separat Randn () -funksjonen til det numpy biblioteket for alle de tre aksene. Ved å gjøre dette får vi poengene vi tegner spredningsgrafen.

For å tegne spredningsplottet ved å bruke disse punktene, bruker vi SCATTER3D () -metoden. Denne funksjonen inneholder flere parametere som inkluderer data fra x, y og z-aksen samt verdien av "CMAP". Verdien på parameteren “CMAP” viser fargen på linjen trukket i 3D -plottet. Show () -metoden kalles for å illustrere kartet.

Eksempel 2

Alle data som kreves for Contour3D () -metoden, må være i tilstanden til et 2D -rutenett, så vel som Z -dataene som er analysert på hvert punkt. En 3D -konturgraf av en periodisk funksjon er vist i følgende illustrasjon:

Importer numpy som NP
Importer matplotlib.Pyplot som Plt
Importer sjøborn som SNS
def f (x, y):
Return NP.Synd (np.SQRT (x ** 4 + y ** 4))
x = np.Linspace (-4, 4, 25)
y = np.Linspace (-4, 4, 25)
X, y = np.MeshGrid (x, y)
Z = f (x, y)
Fig = plt.figur()
AX = plt.Axes (projeksjon = '3d')
øks.kontur3d (x, y, z, 40, cmap = 'binær')
øks.set_xlabel ('x')
øks.set_ylabel ('y')
øks.set_zlabel ('z')
plt.forestilling()

I starten av programmet innlemmer vi bibliotekene Numpy som NP, Matplotlib.Pyplot som PLT, og Seaborn som SNS. Nå definerer vi en F () -funksjon med to parametere som returnerer verdien ved å bruke SQRT () -metoden til Numpy Library. Vi indikerer verdiene for avstand for både akser X og Y ved hjelp av Linspace ().Denne metoden er relatert til Numpy Framework.

I neste linje har vi brukt MeshGrid () -funksjonen for å lage et nettnett i 3D -grafen. Denne funksjonen har verdien av linjeavstand til x- og y -akser som parametere. Her bruker vi figur () -funksjonen til matplotlib.Pyplot -biblioteket for å lage figuren. For å definere projeksjonsnivået, bruker vi Axes () -metoden. Vi må konstruere et tredimensjonalt kart, så vi gir en 3D-verdi til funksjonen. Vi bruker nå Contour3D () -metoden.

Som funksjonens parameter gir vi den avstanden til alle akser og skyggen på 3D -grafen. Deretter spesifiserer vi bildetekstene til alle de tre aksene, slik at metoden set_label () kalles henholdsvis alle akser. For å demonstrere diagrammet brukes showet () funksjonen.

Eksempel 3

I dette tilfellet lager vi et overflateplott i den tredimensjonale grafen ved å bruke metoden plot_surface ().

Importer sjøborn som SB
Importer matplotlib.Pyplot som plot
Importer numpy som NP
def func_z (x, y):
retur50 - (x ** 2 + y ** 2)
SB.set_style ('whiteGrid')
N = 50
X_val = np.Linspace (-5, 5, n)
Y_val = np.Linspace (-5, 5, n)
X1, y1 = np.MeshGrid (X_VAL, Y_VAL)
Z1 = func_z (x1, y1)
Axes = Plot.Axes (projeksjon = '3d')
akser.plot_surface (x1, y1, z1)
plott.forestilling()

Først av alt integrerer vi modulene Seaborn, Matplotlib.Pyplot, og NP. Vi definerer funksjonen for z-aksen, og denne funksjonen er utstyrt med x- og y-aksen. Denne funksjonen returnerer verdien av z-aksen. I neste fase bruker vi Set_Style () -metoden for å tilpasse utformingen av plottet. Vi setter verdien til WhiteGrid.

Nå erklærer vi en variabel og tildeler den en verdi. Linspace () -metoden kalles for å indikere avstanden til x- og y-aksen. Vi tegner meshgrid til z-aksen, så vi bruker MeshGrid () -metoden. Denne funksjonen er hentet fra Numpy -pakken. Vi kaller funksjonen for verdiene til z-aksen. For 3D -plottet er det obligatorisk å spesifisere projeksjonsverdien. For dette bruker vi Axes () -funksjonen.

For å tegne overflategrafen, utføres plot_surface () -funksjonen. Denne funksjonen inneholder verdien av alle de tre aksene. Før vi avslutter koden, bruker vi Show () -metoden for å skildre den ferdige plottet.

Eksempel 4

Her bruker vi wireframe () -metoden for å tegne wireframe i 3D -plottet.

Importer numpy som NP
Importer matplotlib.Pyplot som Plt
Importer sjøborn som SNS
Fig = plt.figur()
AX = plt.Axes (projeksjon = '3d')
zline = np.Linspace (0, 20, 2000)
xline = np.Sin (Zline)
Yline = NP.cos (zline)
øks.plot3d (xline, yline, zline, 'grå')
zdata = 15 * np.tilfeldig.Tilfeldig (200)
xData = np.sin (zdata) + 0.1 * np.tilfeldig.Randn (200)
ydata = np.cos (zdata) + 0.1 * np.tilfeldig.Randn (200)
øks.scatter3d (xdata, ydata, zdata, c = zdata, cmap = 'blues')
plt.forestilling()

Etter å ha introdusert de essensielle rammene, identifiserer vi Z-Axis-funksjonen som er tilgjengelig med X- og Y-aksene. Z-aksens verdi oppnås ved denne prosessen. Vi bruker SET Style () -funksjonen for å endre grafens design i neste trinn. Verdien er konfigurert til WhiteGrid. Vi initialiserer nå en variabel n og gir den en verdi.

For å spesifisere avstanden mellom x- og y -aksene, brukes linspace () -teknikken. Vi bruker MeshGrid () -funksjonen fordi vi ønsker å skildre meshgrid til z-aksen. Dette er en teknikk for numpy verktøysett. Komponenten for z-aksens verdi blir vurdert. Projeksjonsverdien må angis for 3D -visualiseringen. Vi bruker Axes () -metoden for dette. Wireframe () -metoden brukes for å lage wireframe -diagrammet. Verdien av alle de tre aksene er inkorporert i denne metoden. Vi bruker show () -funksjonen for å vise hele grafen til slutt.

Konklusjon

I dette avsnittet har vi gått hele veien gjennom forskjellige tilnærminger som brukes til å lage en 3D -plott med Seaborn Framework. Vi lærte også hvordan vi tegner 3D-konturkartene, hvordan du tegner wireframe på det tredimensjonale diagrammet, og hvordan du lager en overflategraf på 3D-plottene. Det er ingen integrert tredimensjonal funksjon i Seaborn Framework.