[Introduction à Data Scientist] Bases du calcul scientifique, du traitement des données et comment utiliser la bibliothèque de dessin de graphes ♬ Bases de Matplotlib

Hier soir, [Introduction aux scientifiques des données] j'ai résumé les bases de Pandas comme base du calcul scientifique, du traitement des données et comment utiliser la bibliothèque de dessin de graphes, mais ce soir, je résumerai les bases de Matplotlib de la bibliothèque de dessins de graphiques. Je compléterai les explications de ce livre. 【Mise en garde】 Après avoir lu le "Cours de formation de Data Scientist à l'Université de Tokyo", je voudrais résumer les points sur lesquels j'ai des doutes ou que je trouve utiles. Par conséquent, je pense que le synopsis sera simple, mais veuillez le lire en pensant que le contenu n'a rien à voir avec ce livre.

Chapitre 2-5 Bases de Matplotlib

2-5-1 Préparation à l'utilisation de Matplotlib

La plupart du temps, j'utilise plt sur la troisième ligne. Puisqu'il est utilisé ci-dessous, numpy est également décrit.

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

2-5-2 Diagramme de dispersion

Donnez x, y et dessinez un diagramme de dispersion

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()

Faire de x un nombre continu comme les données de séries chronologiques

Augmentation du nombre de données de 10 fois La composante aléatoire a été réduite de moitié afin que la courbe sin de la fluctuation de l'axe y soit visible. Ce qui suit relie les points o de la parcelle à une ligne d'arrêt.

np.random.seed(0)
x = np.arange(30)
y = np.sin(x) + 0.5*np.random.randn(30) #Effet aléatoire réduit de moitié
plt.figure(figsize=(20,6))
plt.plot(x,y, label = 'Label') #'o'Connectez-vous avec une gomme
plt.legend()

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

Quittez l'intrigue o. Modifiez l'argument de plt.plot comme suit.

matplotlib: Specifying Colors; Tableau de comparaison de l'apparence réelle des couleurs matplotlib.markers symbole de tracé et tableau de comparaison des marqueurs réels plt.plot(x,y,color='red', lw=1, linestyle='-',marker='o', label = 'Label')

Augmentez le nombre de données à 300 et ajustez le dessin à 5 cycles

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()

Dessinez une marche aléatoire au fil du temps

np.random.seed(0)
x = np.arange(300)
y = np.random.randn(300).cumsum() #Changer ici en somme cumulée cum
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) ou x = np.linspace (0,299,300) ou x = np.arange (0., 300., 1.) (Supplément)

C'est une histoire boueuse, mais je vais la compléter. Le résultat est le suivant.

• Faites attention à l'attribut du nombre traité comme point final (valeur limite)

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 Division du graphique (ci-après, les étiquettes des axes, etc. sont brisées)

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()

En 4 quadrants, il peut être dessiné comme suit.

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()

Il peut également être dessiné comme suit.

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()

Habituellement, il est dessiné comme suit. Le contenu du graphique est difficile, mais je pense que l'apparence est facile à comprendre.

• Vous pouvez également dessiner un graphique avec une échelle logarithmique avec une base de 2 (arbitraire) normalement. 【référence】 ・ Démo du journal Matplotlib

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 Dessiner un graphe de fonctions

Affichez le graphique de la fonction suivante utilisée dans la méthode Newton. De plus, tracez la solution obtenue par la méthode de Newton.

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()

J'ai également essayé la fonction suivante.

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

Cela semble instable, mais une solution est recherchée. Ici, le tracé des marqueurs est conçu, Référence du marqueur a une description des attributs du marqueur, et l'exemple suivant a été utilisé comme référence.

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

Histogramme 2-5-5

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()

Exercice 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()

Exercice 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()

Problème global

-Utilisez deux ensembles de 0-1 nombres aléatoires uniformes pour trouver le rapport de circonférence à partir de la fréquence d'entrée des cercles et des carrés. · Graphique

>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

Tout au plus, le nombre de nombres valides est de 4 chiffres jusqu'au 3ème chiffre, et il y a une erreur dans ce chiffre.

• Il ressort de cet exemple que l'évaluation des erreurs du résultat du calcul doit être faite scientifiquement.

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))
#La sortie a été modifiée mais omise

Bien qu'il soit loin de la convergence, il produit jusqu'à 100 000 données. Vous pouvez voir l'atmosphère se rapprocher progressivement de 3,1415 ...

Résumé

・ Organisé les bases de l'utilisation de Matplotlib ・ La division graphique est un résumé de celles générales ・ Plt.savefig a été utilisé pour des problèmes généraux ・ Calculez π par la méthode de Monte Carlo et visualisez-le dans un graphique

・ Ce livre sera utilisé partout dans le futur.

prime

Je pense qu'il est préférable de voir des exemples aussi spécifiques que possible, je vais donc créer un lien ci-dessous. Matplotlib Gallery Le Tutrial suivant est un exemple simple et explique en fonction du niveau de difficulté. Matplotlib Tutorials