5. előadás¶

Tartalom: Numpy modul bevezetése és használata, diagramok megjelenítése numpy felhasználásával

A numpy egy széles körben elterjedt Python modul, aminek a segítségével különféle numerikus számításokat végezhetünk, különösen a különféle 1 és több dimenziós adatszerkezetek tekintetében, mint vektorok és mátrixok. A modulban több hasznos, a vektorok és mátrixok esetén értelmezett művelet meg van valósítva, ezek magas hatékonysággal működnek.

A numpy telepíthető a pip install numpy paranccsal, de például a matplotlib csomag telepítése során automatikusan települ.

A numpy modult a következő módon importáljuk:

In [1]:

import numpy as np

A numpy segítségével több módon lehetséges tömb adatszerkezetet létrehozni. Az array metódus segítségével 1 és több dimenziós tömböket hozhatunk létre, az elemeinek felsorolásával.

A v változóban egy 1 dimenziós, 3 elemű tömb (vektor) lesz.

In [2]:

v = np.array([1, 2, 3])

In [3]:

print(v)

[1 2 3]

In [4]:

Out[4]:

array([1, 2, 3])

Az M változóba egy 2 dimenziós, 4 elemű tömb (mátrix) lesz.

In [5]:

M = np.array([[1.0, 2.0], [3.0, 4.0]])

In [6]:

print(M)

[[1. 2.]
 [3. 4.]]

In [7]:

Out[7]:

array([[1., 2.],
       [3., 4.]])

A shape metódus segítségével megtudhatjuk egy tömb dimenzióit és méreteit. Látható, hogy a visszatérési értéke egy tuple.

In [8]:

v.shape

Out[8]:

(3,)

In [9]:

M.shape

Out[9]:

(2, 2)

Ahogy azt már tanultuk, tuple esetén hivatkozhatunk az egyes értékekre is.

In [10]:

M.shape[1]

Out[10]:

A size metódus megadja, hogy az adatszerkezet hány elemet tartalmaz összesen.

In [11]:

v.size

Out[11]:

In [12]:

M.size

Out[12]:

A shape és size a következő módon is használható.

In [13]:

np.shape(v)

Out[13]:

(3,)

In [14]:

np.size(v)

Out[14]:

In [15]:

np.shape(M)

Out[15]:

(2, 2)

In [16]:

np.size(M)

Out[16]:

Egy numpy tömbtől lekérdezhető annak adattípusa a dtype metódus segítségével.

In [17]:

v.dtype

Out[17]:

dtype('int32')

In [18]:

M.dtype

Out[18]:

dtype('float64')

Az egyes elemeket indexeléssel érhetjük el.

In [19]:

v[0]

Out[19]:

Hasonló módon változtathatók egy tömb elemei.

In [20]:

v[0] = 42
v

Out[20]:

array([42,  2,  3])

De a típusa nem módosítható.

In [21]:

v[0] = 3.6 #Egész számra fogja kényszeríteni.
v

Out[21]:

array([3, 2, 3])

v[0] = "abc" # Nem tudja egész számként megfeleltetni, hibát kapunk.

ValueError 
----> 1 v[0] = "abc" 

ValueError: invalid literal for int() with base 10: 'abc'

In [22]:

v #Ezért v értékei változatlanok.

Out[22]:

array([3, 2, 3])

A listák esetén tanult indexelési lehetőségek numpy tömbök esetén is ugyanúgy működnek.

Például kérhetjük a tömböt elemeinek fordított sorrendjében.

In [23]:

v[::-1]

Out[23]:

array([3, 2, 3])

Ha több dimenziós adatszerkezetet használunk, azt úgy fogjuk fel mint egy 1 dimenziós szerkezetet, ami további 1 dimenziós szerkezeteket tartalmaz. Ebből kifolyólag a következő kódsor az M mátrix két sorát "cseréli fel".

In [24]:

M[::-1]

Out[24]:

array([[3., 4.],
       [1., 2.]])

A következő sor pedig a két oszlopát fordítja meg.

In [25]:

M[::, ::-1]

Out[25]:

array([[2., 1.],
       [4., 3.]])

Az arange metódus segítségével is generálhatunk numpy tömböt.

In [26]:

x = np.arange(0, 10, 1) #paraméterek: start, stop, lépésköz
x

Out[26]:

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [27]:

x = np.arange(0, 1, 0.01)
x

Out[27]:

array([0.  , 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1 ,
       0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2 , 0.21,
       0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3 , 0.31, 0.32,
       0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4 , 0.41, 0.42, 0.43,
       0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5 , 0.51, 0.52, 0.53, 0.54,
       0.55, 0.56, 0.57, 0.58, 0.59, 0.6 , 0.61, 0.62, 0.63, 0.64, 0.65,
       0.66, 0.67, 0.68, 0.69, 0.7 , 0.71, 0.72, 0.73, 0.74, 0.75, 0.76,
       0.77, 0.78, 0.79, 0.8 , 0.81, 0.82, 0.83, 0.84, 0.85, 0.86, 0.87,
       0.88, 0.89, 0.9 , 0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98,
       0.99])

In [28]:

x = np.arange(5, 0, -1)
x

Out[28]:

array([5, 4, 3, 2, 1])

Lehetőségünk van arra is, hogy véletlenszerű értékekkel feltöltött tömböt generáljunk a megadott méretben. A tömb értékei a [0;1] tartományba fognak esni.

In [29]:

r1 = np.random.random([3, 8])
print(r1)

[[0.34687163 0.37510313 0.67158997 0.67600103 0.14222258 0.43552257
  0.37888162 0.95326703]
 [0.37723136 0.40794039 0.61950294 0.7040759  0.92962434 0.62688732
  0.75129845 0.9189319 ]
 [0.28927758 0.68487346 0.97830981 0.47986638 0.82312922 0.01326377
  0.34561041 0.45007201]]

In [30]:

import matplotlib.pyplot as plt
%matplotlib inline
plt.imshow(r1)
plt.colorbar()
plt.show()

In [31]:

plt.figure(1, figsize=(10,4))
plt.subplot(221)
plt.imshow(r1)
plt.subplot(222)
plt.imshow(r1[:, ::-1])
plt.subplot(223)
plt.imshow(r1[::-1, :])
plt.subplot(224)
plt.imshow(r1[::-1, ::-1])
plt.show()

Hogyan tudunk tetszőleges [min; max] tartományba generálni véletlen értékeket?

In [32]:

min = 10
max = 13
np.random.random([5, 3]) * (max - min) + min

Out[32]:

array([[11.28204377, 10.57470843, 12.7258235 ],
       [10.54668512, 10.90371156, 11.87194907],
       [11.52005672, 11.62528317, 10.99931438],
       [11.7669422 , 10.71012168, 11.37296749],
       [12.65355602, 11.99816744, 10.02294519]])

Ahogy a fenti példa is mutatja, numpy tömbök esetén az alapvető matematikai műveletek tagonként értendők. Tehát, ha egy numpy tömböt szorzunk, osztunk, összeadunk vagy kivonunk egy skalárral, akkor azt tagonként végzi el.

In [33]:

M * 10

Out[33]:

array([[10., 20.],
       [30., 40.]])

In [34]:

M / 10

Out[34]:

array([[0.1, 0.2],
       [0.3, 0.4]])

In [35]:

M + 10

Out[35]:

array([[11., 12.],
       [13., 14.]])

In [36]:

M - 10

Out[36]:

array([[-9., -8.],
       [-7., -6.]])

Ugyanez igaz, ha a vektorokat és mátrixokat szorzunk egymással. Itt tagonkénti szorzás fog végbemenni.

In [37]:

v * v

Out[37]:

array([9, 4, 9])

In [38]:

M * M

Out[38]:

array([[ 1.,  4.],
       [ 9., 16.]])

Vektor és mátrix között is értelmezett a szorzás, de ügyeljünk az adatszerkezetek méreteire.

M * v # Nem fog működni, a méretük nem összeegyeztethető.

---------------------------------------------------------------------------
ValueError 
----> 1 M * v 

ValueError: operands could not be broadcast together with shapes (2,2) (3,)

A szorzás itt is tagonként történik.

In [39]:

b = np.array([1, 2])

In [40]:

M * b

Out[40]:

array([[1., 4.],
       [3., 8.]])

Ha a mátrixok és vektorok klasszikus értelemben vett szorzását akarjuk végrehajtani, akkor azt a dot függvény hívásával tehetjük meg.

In [41]:

M.dot(M)

Out[41]:

array([[ 7., 10.],
       [15., 22.]])

In [42]:

M.dot(b)

Out[42]:

array([ 5., 11.])

A min és max fügvényekkel kérhetjük az adott szerkezet legkisebb és legnagyobb értékét.

In [43]:

np.min(M)

Out[43]:

1.0

In [44]:

np.max(M)

Out[44]:

4.0

Az értékeket összegezhetjük a sum fügvénnyel.

In [45]:

np.sum(M)

Out[45]:

10.0

Az átlagot pedig a mean függvénnyel számíthatjuk.

In [46]:

np.mean(M)

Out[46]:

2.5

Numpy tömböket is megjeleníthetünk diagaramok segítségével. A felhasználásuk ugyanolyan módon történik, mint azt már a listák esetén tanultuk.

In [47]:

import matplotlib.pyplot as plt

%matplotlib inline

x = np.arange(1000)
y = np.random.random([1000])

plt.plot(x, y, "g")
plt.show()
plt.hist(y, 20, density=True) # hisztogram, gyakorisági sűrűség
plt.show()

A density=True a hisztogram érékeinek normalizálására szolgál.

Emlékeztetőül (valszám)¶

Az x valószínűségi változó normális eloszlású akkor, ha sűrűségfüggvénye:

$f(x) = \frac{1}{{\sigma \sqrt {2\pi\sigma^2} }} e^{{(x-\mu)^2} / {2\sigma^2}}$

A következő jelölésekkel: $\sigma^2$ (sigma) a szórásnégyzet; $\mu$ (mu) pedig a középérték.

A normális eloszlás egyik fő tulajdonsága, hogy a középértéktől 1 sigma távolságra esik az összes előfordulás 68%-a, 2 sigma távolságra pedig az összes előfordulás 95%-a.

In [48]:

mu = 10 # középérték 
sigma = 5 # szórás
s = np.random.normal(mu, sigma, 1000)
plt.plot(s, "g")
plt.show()
plt.hist(s, 20, density = True)
plt.show()

Itt már látszik a normál eloszlást jellemző harnaggörbe, de jelenítsük ezt meg pontosabban.

A $f(x) = \frac{1}{{\sigma \sqrt {2\pi\sigma^2} }} e^{{(x-\mu)^2} / {2\sigma^2}}$ képlet pythonban így formalizálható:

ys = 1/(sigma * np.sqrt(2 * np.pi)) * np.exp(-(xs - mu)**2 / (2 * sigma**2))

In [49]:

xs = np.arange(mu - 3*sigma, mu + 3*sigma, 0.1)
ys = 1/(sigma * np.sqrt(2 * np.pi)) * np.exp(-(xs - mu)**2 / (2 * sigma**2))
plt.hist(s, 20, density = True)
plt.plot(xs, ys, "r", linewidth = 4)
plt.show()

Used sources / Felhasznált források¶

Shannon Turner: Python lessons repository MIT license (c) Shannon Turner 2013-2014
Siki Zoltán: Python mogyoróhéjban GNU FDL license (c) Siki Zoltán

További olvasnivaló:¶

https://en.wikipedia.org/wiki/Normal_distribution