Cara menggunakan plot 2d python

Matplotlib adalah pustaka python yang digunakan untuk membuat grafik dan plot 2D dengan menggunakan skrip python. Memiliki modul bernama pyplot yang memudahkan plotting dengan menyediakan fitur untuk mengontrol gaya garis, properti font, sumbu pemformatan, dll. Mendukung berbagai macam grafik dan plot yaitu - histogram, diagram batang, spektrum daya, diagram kesalahan, dll. Ini digunakan bersama dengan NumPy untuk menyediakan lingkungan yang merupakan alternatif open source yang efektif untuk MatLab. Ini juga dapat digunakan dengan toolkit grafis seperti PyQt dan wxPython.

Biasanya, paket diimpor ke skrip Python dengan menambahkan pernyataan berikut -

from matplotlib import pyplot as plt

Contoh Matplotlib

Skrip berikut menghasilkan plot gelombang sinus menggunakan matplotlib.

Contoh

import numpy as np 
import matplotlib.pyplot as plt  

# Compute the x and y coordinates for points on a sine curve 
x = np.arange(0, 3 * np.pi, 0.1) 
y = np.sin(x) 
plt.title("sine wave form") 

# Plot the points using matplotlib 
plt.plot(x, y) 
plt.show() 

Its keluaran adalah sebagai berikut -

Kita akan melihat banyak contoh penggunaan pustaka Matplotlib python dalam pekerjaan Data science di bab-bab berikutnya.

Saya memiliki daftar 3-tupel yang mewakili sekumpulan titik dalam ruang 3D. Saya ingin menggambar permukaan yang mencakup semua titik ini. Fungsi plot_surface dalam paket mplot3d membutuhkan argumen X, Y dan Z yang merupakan array 2d. Apakah plot_surface fungsi yang tepat untuk memplot permukaan dan bagaimana cara mengubah data saya ke format yang diperlukan?

data = [(x1,y1,z1),(x2,y2,z2),.....,(xn,yn,zn)]

Untuk permukaan sedikit berbeda dari daftar 3-tupel, Anda harus memasukkan dalam kisi untuk domain dalam array 2d.

Jika semua yang Anda miliki adalah daftar titik-titik 3d, daripada beberapa fungsi f(x, y) -> z, maka Anda akan memiliki masalah karena ada beberapa cara untuk melakukan triangulasi awan titik 3d tersebut ke permukaan.

Inilah contoh permukaan yang halus:

import numpy as np
from mpl_toolkits.mplot3d import Axes3D  
# Axes3D import has side effects, it enables using projection='3d' in add_subplot
import matplotlib.pyplot as plt
import random

def fun(x, y):
    return x**2 + y

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x = y = np.arange(-3.0, 3.0, 0.05)
X, Y = np.meshgrid(x, y)
zs = np.array(fun(np.ravel(X), np.ravel(Y)))
Z = zs.reshape(X.shape)

ax.plot_surface(X, Y, Z)

ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')

plt.show()

Anda dapat membaca data langsung dari beberapa file dan plot

from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
from matplotlib import cm
import numpy as np
from sys import argv

x,y,z = np.loadtxt('your_file', unpack=True)

fig = plt.figure()
ax = Axes3D(fig)
surf = ax.plot_trisurf(x, y, z, cmap=cm.jet, linewidth=0.1)
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.savefig('teste.pdf')
plt.show()

Jika perlu Anda bisa melewati vmin dan vmax untuk menentukan rentang colorbar, mis.

surf = ax.plot_trisurf(x, y, z, cmap=cm.jet, linewidth=0.1, vmin=0, vmax=2000)

Bagian Bonus

Saya bertanya-tanya bagaimana cara membuat beberapa plot interaktif, dalam hal ini dengan data buatan

from __future__ import print_function
from ipywidgets import interact, interactive, fixed, interact_manual
import ipywidgets as widgets
from IPython.display import Image

from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits import mplot3d

def f(x, y):
    return np.sin(np.sqrt(x ** 2 + y ** 2))

def plot(i):

    fig = plt.figure()
    ax = plt.axes(projection='3d')

    theta = 2 * np.pi * np.random.random(1000)
    r = i * np.random.random(1000)
    x = np.ravel(r * np.sin(theta))
    y = np.ravel(r * np.cos(theta))
    z = f(x, y)

    ax.plot_trisurf(x, y, z, cmap='viridis', edgecolor='none')
    fig.tight_layout()

interactive_plot = interactive(plot, i=(2, 10))
interactive_plot

Saya baru saja menemukan masalah yang sama. Saya telah meratakan spasi data secara merata dalam 3 array 1-D dan bukannya array 2-D yang matplotlib's plot_surface inginkan. Data saya kebetulan berada dalam pandas.DataFrame jadi di sini adalah contoh matplotlib.plot_surface) dengan modifikasi untuk plot 3 array 1-D.

from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import matplotlib.pyplot as plt
import numpy as np

X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm,
    linewidth=0, antialiased=False)
ax.set_zlim(-1.01, 1.01)

ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))

fig.colorbar(surf, shrink=0.5, aspect=5)
plt.title('Original Code')

Itu adalah contoh aslinya. Menambahkan bit ini selanjutnya akan membuat plot yang sama dari array 3-D.

# ~~~~ MODIFICATION TO EXAMPLE BEGINS HERE ~~~~ #
import pandas as pd
from scipy.interpolate import griddata
# create 1D-arrays from the 2D-arrays
x = X.reshape(1600)
y = Y.reshape(1600)
z = Z.reshape(1600)
xyz = {'x': x, 'y': y, 'z': z}

# put the data into a pandas DataFrame (this is what my data looks like)
df = pd.DataFrame(xyz, index=range(len(xyz['x']))) 

# re-create the 2D-arrays
x1 = np.linspace(df['x'].min(), df['x'].max(), len(df['x'].unique()))
y1 = np.linspace(df['y'].min(), df['y'].max(), len(df['y'].unique()))
x2, y2 = np.meshgrid(x1, y1)
z2 = griddata((df['x'], df['y']), df['z'], (x2, y2), method='cubic')

fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(x2, y2, z2, rstride=1, cstride=1, cmap=cm.coolwarm,
    linewidth=0, antialiased=False)
ax.set_zlim(-1.01, 1.01)

ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))

fig.colorbar(surf, shrink=0.5, aspect=5)
plt.title('Meshgrid Created from 3 1D Arrays')
# ~~~~ MODIFICATION TO EXAMPLE ENDS HERE ~~~~ #

plt.show()

Berikut adalah angka yang dihasilkan:

periksa contoh resmi. X, Y dan Z adalah memang array 2d, numpy.meshgrid () adalah cara sederhana untuk mendapatkan 2d x, y mesh keluar dari nilai 1d x dan y.

http://matplotlib.sourceforge.net/mpl_examples/mplot3d/surface3d_demo.py

inilah cara Pythonic untuk mengubah 3-tupel menjadi 3 array 1d.

data = [(1,2,3), (10,20,30), (11, 22, 33), (110, 220, 330)]
X,Y,Z = Zip(*data)
In [7]: X
Out[7]: (1, 10, 11, 110)
In [8]: Y
Out[8]: (2, 20, 22, 220)
In [9]: Z
Out[9]: (3, 30, 33, 330)

Inilah triangulasi mtaplotlib delaunay (interpolasi), ini mengubah 1d x, y, z menjadi sesuatu yang sesuai (?):

http://matplotlib.sourceforge.net/api/mlab_api.html#matplotlib.mlab.griddata

Hanya untuk berpadu, Emanuel memiliki jawaban yang saya (dan mungkin banyak lainnya) cari. Jika Anda memiliki data tersebar 3d dalam 3 array terpisah, pandas adalah bantuan luar biasa dan bekerja jauh lebih baik daripada opsi lain. Untuk menguraikan, anggap x, y, z Anda adalah beberapa variabel arbitrer. Dalam kasus saya ini adalah c, gamma, dan kesalahan karena saya sedang menguji mesin vektor dukungan. Ada banyak pilihan potensial untuk memplot data:

• scatter3D (cParams, gammas, avg_errors_array) - ini berfungsi tetapi terlalu sederhana
• plot_wireframe (cParams, gammas, avg_errors_array) - ini berfungsi, tetapi akan terlihat jelek jika data Anda tidak diurutkan dengan baik, seperti yang berpotensi terjadi dengan potongan besar data ilmiah nyata
• ax.plot3D (cParams, gammas, avg_errors_array) - mirip dengan wireframe

Plot data wireframe

3d pencar data

Kode terlihat seperti ini:

    fig = plt.figure()
    ax = fig.gca(projection='3d')
    ax.set_xlabel('c parameter')
    ax.set_ylabel('gamma parameter')
    ax.set_zlabel('Error rate')
    #ax.plot_wireframe(cParams, gammas, avg_errors_array)
    #ax.plot3D(cParams, gammas, avg_errors_array)
    #ax.scatter3D(cParams, gammas, avg_errors_array, zdir='z',cmap='viridis')

    df = pd.DataFrame({'x': cParams, 'y': gammas, 'z': avg_errors_array})
    surf = ax.plot_trisurf(df.x, df.y, df.z, cmap=cm.jet, linewidth=0.1)
    fig.colorbar(surf, shrink=0.5, aspect=5)    
    plt.savefig('./plots/avgErrs_vs_C_andgamma_type_%s.png'%(k))
    plt.show()

Ini adalah hasil akhirnya:

Dalam Matlab saya melakukan sesuatu yang mirip menggunakan fungsi delaunay pada x, y hanya coords (bukan z), kemudian merencanakan dengan trimesh atau trisurf, menggunakan z sebagai ketinggian.

SciPy memiliki kelas Delaunay , yang didasarkan pada pustaka QHull yang mendasari yang sama dengan fungsi delaunay dari Matlab, jadi Anda harus mendapatkan hasil yang identik.

Dari sana, harus ada beberapa baris kode untuk mengonversinya Merencanakan 3D Polygon dalam python-matplotlib contoh menjadi apa yang ingin Anda capai, karena Delaunay memberi Anda spesifikasi dari setiap poligon segitiga.

Tidak mungkin membuat permukaan 3d secara langsung menggunakan data Anda. Saya akan merekomendasikan Anda untuk membangun model interpolasi menggunakan beberapa alat seperti pykridge . Proses ini akan mencakup tiga langkah:

1. Latih model interpolasi menggunakan pykridge
2. Buat kisi dari X dan Y menggunakan meshgrid
3. Nilai-nilai interpolasi untuk Z

Setelah membuat kisi-kisi Anda dan nilai-nilai Z yang sesuai, sekarang Anda siap menggunakan plot_surface. Perhatikan bahwa tergantung pada ukuran data Anda, fungsi meshgrid dapat berjalan untuk sementara waktu. Solusinya adalah membuat sampel dengan spasi yang sama menggunakan np.linspace untuk X dan Y sumbu, kemudian menerapkan interpolasi untuk menyimpulkan nilai Z yang diperlukan. Jika demikian, nilai yang diinterpolasi mungkin berbeda dari Z asli karena X dan Y telah berubah.