[PYTHON] [Einführung in Data Scientist] Grundlagen der wissenschaftlichen Berechnung, Datenverarbeitung und Verwendung der Grafikzeichnungsbibliothek ♬ Grundlagen von Matplotlib

Letzte Nacht, [Einführung in Data Scientists], habe ich die Grundlagen von Pandas als Grundlage für wissenschaftliche Berechnungen, Datenverarbeitung und die Verwendung der Grafikzeichnungsbibliothek zusammengefasst, aber heute Abend werde ich die Grundlagen von Matplotlib der Grafikzeichnungsbibliothek zusammenfassen. Ich werde die Erklärungen in diesem Buch ergänzen. 【Hinweis】 Nachdem ich den "Data Scientist Training Course an der Universität von Tokio" gelesen habe, möchte ich die Punkte zusammenfassen, an denen ich Zweifel habe oder die ich nützlich finde. Daher denke ich, dass die Zusammenfassung unkompliziert sein wird, aber bitte lesen Sie sie, da der Inhalt nichts mit diesem Buch zu tun hat.

Kapitel 2-5 Grundlagen von Matplotlib

2-5-1 Vorbereitung zur Verwendung von Matplotlib

Meistens benutze ich plt in der dritten Zeile. Da es unten verwendet wird, wird auch numpy beschrieben.

import matplotlb as mlp
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

2-5-2 Streudiagramm

Geben Sie x, y an und zeichnen Sie ein Streudiagramm

np.random.seed(0)
x = np.random.randn(30)
y = np.sin(x) + np.random.randn(30)
plt.figure(figsize=(20,6))
plt.plot(x,y, 'o')  #alphabet o
#plt.scatter(x,y)
plt.title('Title name')
plt.xlabel('X')
plt.ylabel('Y')
plt.grid(True)
plt.show()

Machen Sie x zu einer fortlaufenden Zahl wie Zeitreihendaten

Die Anzahl der Daten wurde um das 10-fache erhöht Die Zufallskomponente wurde um die Hälfte reduziert, so dass die Sinuskurve der Fluktuation der y-Achse sichtbar ist. Im Folgenden werden die Punkte o auf dem Plot mit einer Stopplinie verbunden.

np.random.seed(0)
x = np.arange(30)
y = np.sin(x) + 0.5*np.random.randn(30) #Zufälliger Effekt halbiert
plt.figure(figsize=(20,6))
plt.plot(x,y, label = 'Label') #'o'Mit einem Radiergummi verbinden
plt.legend()

plt.title('Title name')
plt.xlabel('X')
plt.ylabel('Y')
plt.grid(True)
plt.show()

Grundstück verlassen o. Ändern Sie das Argument von plt.plot wie folgt.

matplotlib: Festlegen von Farben; Vergleichstabelle, wie Farben tatsächlich aussehen matplotlib.markers Plotsymbol und tatsächliche Markervergleichstabelle plt.plot(x,y,color='red', lw=1, linestyle='-',marker='o', label = 'Label')

Erhöhen Sie die Anzahl der Daten auf 300 und passen Sie sie an die Zeichnung mit 5 Zyklen an

np.random.seed(0)
x = np.arange(300)
y = np.sin(np.pi*x/30) + 0.5*np.random.randn(300)
plt.figure(figsize=(20,6))
plt.plot(x,y,color='blue', lw=1, linestyle='-',marker='o', label = 'Label') #linestyle='--' 'red'
plt.legend()

plt.title('Title name')
plt.xlabel('X')
plt.ylabel('Y')
plt.grid(True)
plt.show()

Zeichnen Sie einen zufälligen Spaziergang über die Zeit

np.random.seed(0)
x = np.arange(300)
y = np.random.randn(300).cumsum() #Wechseln Sie hier zu kumulativer Summensumme
plt.figure(figsize=(20,6))
plt.plot(x,y,color='blue', lw=1, linestyle='-',marker='o', label = 'Label')
plt.legend()

plt.title('Title name')
plt.xlabel('X')
plt.ylabel('Y')
plt.grid(True)
plt.show()

X = np.arange (300) oder x = np.linspace (0,299.300) oder x = np.arange (0., 300., 1.)

Es ist eine schlammige Geschichte, aber ich werde sie ergänzen. Das Ergebnis ist wie folgt.

• Achten Sie auf das Attribut der als Endpunkt behandelten Zahl (Grenzwert)

x = np.arange(300)
print(type(x),len(x),type(x[0]),x)
#<class 'numpy.ndarray'> 300 <class 'numpy.int32'> [  0   1   2...299]
x = np.linspace(0,299,300)
print(type(x),len(x),x)
#<class 'numpy.ndarray'> 300 <class 'numpy.float64'> [  0.   1.   2. ...299.]
x = np.arange(0,300,1)
print(type(x),len(x),type(x[0]),x)
#<class 'numpy.ndarray'> 300 <class 'numpy.int32'> [  0   1   2 ...299]
x = np.arange(0.,300.,1.)
print(type(x),len(x),type(x[0]),x)
#<class 'numpy.ndarray'> 300 <class 'numpy.float64'> [  0.   1.   2. ...299.]

2-5-3 Teilen des Diagramms (im Folgenden werden die Achsenbeschriftungen usw. unterbrochen)

plt.figure(figsize=(20,6))

plt.subplot(2,1,1)
x = np.linspace(-10,10,100)
plt.plot(x,np.sin(x))

plt.subplot(2,1,2)
y = np.linspace(-10,10,100)
plt.plot(y,np.sin(2*y))

plt.grid(True)
plt.show()

In 4 Quadranten kann es wie folgt gezeichnet werden.

plt.figure(figsize=(20,6))
x = np.linspace(-10,10,100)
plt.subplot(2,2,1)
plt.plot(x,np.sin(x))
plt.subplot(2,2,2)
plt.plot(x,np.sin(2*x))
plt.subplot(2,2,3)
plt.plot(x,np.sin(3*x))
plt.subplot(2,2,4)
plt.plot(x,np.sin(4*x))
plt.grid(True)
plt.show()

Es kann auch wie folgt gezeichnet werden.

plt.figure(figsize=(20,6))
x = np.linspace(-10,10,100)
for n in range(1,5,1):
    plt.subplot(2,2,n)
    plt.plot(x,np.sin(n*x))
plt.grid(True)
plt.show()

Normalerweise wird es wie folgt gezeichnet. Der Inhalt des Diagramms ist schwierig, aber ich denke, das Erscheinungsbild ist leicht zu verstehen.

• Sie können normalerweise auch ein Diagramm mit einer logarithmischen Skala mit einer Basis von 2 (beliebig) zeichnen. 【Referenz】 ・ Matplotlib Log Demo

import numpy as np
import matplotlib.pyplot as plt

# Data for plotting
t = np.arange(0.01, 20.0, 0.01)

# Create figure
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(8,6))

# log y axis
ax1.semilogy(t, np.exp(-t / 5.0))
ax1.set(title='semilogy')
ax1.grid()

# log x axis
ax2.semilogx(t, np.sin(2 * np.pi * t))
ax2.set(title='semilogx')
ax2.grid()

# log x and y axis
ax3.loglog(t, 20 * np.exp(-t / 10.0), basex=2)
ax3.set(title='loglog base 2 on x')
ax3.grid()

# With errorbars: clip non-positive values
# Use new data for plotting
x = 10.0**np.linspace(0.0, 2.0, 20)
y = x**2.0

ax4.set_xscale("log", nonposx='clip')
ax4.set_yscale("log", nonposy='clip')
ax4.set(title='Errorbars go negative')
ax4.errorbar(x, y, xerr=0.1 * x, yerr=5.0 + 0.75 * y)
# ylim must be set after errorbar to allow errorbar to autoscale limits
ax4.set_ylim(bottom=0.1)

fig.tight_layout()
plt.show()

2-5-4 Zeichnen eines Funktionsgraphen

Zeigen Sie das Diagramm der folgenden Funktion an, die in der Newton-Methode verwendet wird. Zeichnen Sie außerdem die nach der Newton-Methode erhaltene Lösung.

f(x) = x^2 + 2x + 1

def my_function(x):
    return x**2 + 2 * x + 1

from scipy.optimize import newton
x0 = newton(my_function,0)

x = np.arange(-10,10)
plt.figure(figsize = (8, 6))
plt.plot(x, my_function(x))
plt.plot(x0, 0, 'red', marker = 'o',markersize=20)
plt.plot(x0, 0, 'black', marker = 'o',markersize=5)
plt.grid(True)
plt.show()

Ich habe auch die folgende Funktion ausprobiert.

def my_function(x):
    return x**3 + 2 * x + 1

Es scheint instabil, aber es wird nach einer Lösung gesucht. Hier wird das Markierungsdiagramm erstellt, Marker-Referenz enthält eine Beschreibung der Marker-Attribute. Das folgende Beispiel wurde als Referenz verwendet.

marker_style = dict(linestyle=':', color='0.8', markersize=10,
                    markerfacecolor="tab:blue", markeredgecolor="tab:blue")

2-5-5 Histogramm

np.random.seed(0)
plt.figure(figsize = (8,6))
y = np.random.randn(10**5)*10 + 50
plt.hist(y, bins = 60, range =(20,80))
plt.grid(True)
plt.show()

Übung 2-11

x = np.arange(-10,10,0.1)
plt.figure(figsize = (8, 6))
plt.plot(x, np.sin(x), 'red', marker = 'o', linestyle = '-', label = 'sin')
plt.plot(x, np.cos(x), 'blue', marker = 'o', linestyle = '--', label = 'cos')
plt.legend()
plt.grid(True)
plt.show()
plt.close()

Übung 2-12

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8,6))
np.random.seed(0)
y1 = np.random.uniform(0.0,1.0,100000)
ax1.hist(y1, bins = 100, range =(0.0,1.0))
ax1.set_ylabel('y100000')
y2 = np.random.uniform(0.0,1.0,10000)
ax2.hist(y2, bins = 100, range =(0.0,1.0))
ax2.set_ylabel('y10000')
plt.grid(True)
plt.show()

Umfassendes Problem

• Verwenden Sie zwei Sätze von 0-1 einheitlichen Zufallszahlen, um das Umfangsverhältnis aus der Häufigkeit der Eingabe von Kreisen und Quadraten zu ermitteln. ・ Grafik

>python pipi.py
pipi= 3.6 9 10
pipi= 3.4 17 20
pipi= 3.466666666666667 26 30
pipi= 3.3 33 40
pipi= 3.44 43 50
pipi= 3.3333333333333335 50 60
pipi= 3.3714285714285714 59 70
pipi= 3.35 67 80
pipi= 3.422222222222222 77 90
pipi= 3.4 85 100
pipi= 3.3 165 200
pipi= 3.26 326 400
pipi= 3.1266666666666665 469 600
pipi= 3.12 624 800
pipi= 3.104 776 1000
pipi= 3.024 1512 2000
pipi= 3.036 2277 3000
pipi= 3.054 3054 4000
pipi= 3.0712 3839 5000
pipi= 3.082666666666667 4624 6000
pipi= 3.0908571428571427 5409 7000
pipi= 3.0985 6197 8000
pipi= 3.104 6984 9000
pipi= 3.1068 7767 10000
pipi= 3.1224 15612 20000
pipi= 3.126 23445 30000
pipi= 3.1283 31283 40000
pipi= 3.13176 39147 50000
pipi= 3.138 47070 60000
pipi= 3.1370857142857145 54899 70000
pipi= 3.13575 62715 80000
pipi= 3.1347555555555555 70532 90000
pipi= 3.13364 78341 100000

Die Anzahl der gültigen Nummern beträgt höchstens 4 Ziffern bis zur 3. Ziffer, und in dieser Ziffer liegt ein Fehler vor.

• Aus diesem Beispiel ist ersichtlich, dass die Fehlerbewertung des Berechnungsergebnisses wissenschaftlich erfolgen muss.

import numpy as np
import matplotlib.pyplot as plt

fig, (ax1,ax2) = plt.subplots(2, 1, figsize=(8,16))
np.random.seed(0)
s = 10000
x = np.random.uniform(0.0,1.0,s)
y = np.random.uniform(0.0,1.0,s)
x1 = np.arange(0,np.pi/2,0.01)
y1 = np.sin(x1)
y2 = np.cos(x1)
ax1.plot(y1,y2, lw = 3)
plt.grid(True)
count = 0
s1 = 0
for i in range(s):
    s1 += 1
    #print(i)
    if np.math.hypot(x[i],y[i]) <= 1:
        count += 1
        ax1.plot(x[i],y[i], color = 'green',marker = 'o', markersize = 3)
    else:
        ax1.plot(x[i],y[i], color = 'red', marker = 'o', markersize = 3)
    rate = count/s1
    ax2.plot(s1,4*rate,color = 'blue', marker = 'o',linestyle = '-', markersize = 3)
    #plt.pause(0.1)
    if i%500==499:
        print('pipi=',4*rate,count,s1)
        plt.savefig("./fig/pipi{}.png ".format(i))
#Die Ausgabe wurde geändert, aber weggelassen

Obwohl es weit von einer Konvergenz entfernt ist, werden bis zu 100.000 Daten ausgegeben. Sie können sehen, dass sich die Atmosphäre allmählich 3.1415 nähert ...

Zusammenfassung

・ Organisierte die Grundlagen der Verwendung von Matplotlib ・ Die Graphenteilung ist eine Zusammenfassung der allgemeinen ・ Plt.savefig wurde für allgemeine Probleme verwendet ・ Berechnen Sie π nach der Monte-Carlo-Methode und visualisieren Sie es in einem Diagramm

・ Dieses Buch wird in Zukunft überall verwendet.

Bonus

Ich denke, es ist am besten, so spezifische Beispiele wie möglich zu sehen, also werde ich unten verlinken. Matplotlib Gallery Das folgende Tutrial ist ein einfaches Beispiel und wird nach Schwierigkeitsgrad erklärt. Matplotlib Tutorials