Matematikai Algoritmusok és Felfedezések I.

7. Előadás: Numpy

2021 március 22.

Tudományos csomagok (Python Scientific stack)

csomag
NumPy	Hatékony N-dimenziós tömb
SciPy	Numerikus számítások
Matplotlib	Grafikonok és rajzok
IPython (Jupyter)	Interaktív notebook
SymPy	Szimbolikus számítások
Pandas	Adatbányászat

Numpy

A Python Scientific stack (és sok más) alap modulja.

https://numpy.org/

• lineáris algebra, Fourier transzformáció, random számok,
• könnyen használható mátrixok, tömbök
• erősen opitmalizált
• C/C++/Fortran integráció.

Mandelbrot halmaz

A Mandelbrot-halmaz azon $c$ komplex számokból áll, melyekre az alábbi $x_{n}$ rekurzív sorozat:

$x_{1}=c$

$x_{n+1}:=(x_{n})^{2}+c$

nem tart végtelenbe, azaz abszolút értékben (hosszára nézve) korlátos.

Importálási konvenció: import numpy as np

import numpy as np

N-dimenziós tömbök

A numpy központi objektuma az ndarray ($n$-dimenziós tömb).

A = np.array([[1, 2], [3, 4], [5, 6]])     
A

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

type(A)

numpy.ndarray

A.shape egy tuple a tömb dimenzióival, alakjával.

A.shape

(3, 2)

Többdimenzió

Többdimenziós tömbökkel sok helyen találkozhatunk. Egyik tipikus megjelenésük a képek tárolása. Minden tömb egy háromdimenziós tömb, ahol az első két dimenzió az x és y koordinátának felel meg, a harmadik mentén pedig felsoroljuk az RGB értékeket. Az RGB értékek 0 és 255 közötti egészek.

import imageio                                  #kép beolvasáshoz
import matplotlib.pyplot as plt                 #kép megjelenítéshez

fig_size = plt.rcParams["figure.figsize"]       #kép méret növelése
fig_size[0] = 10
fig_size[1] = 8
plt.rcParams["figure.figsize"] = fig_size

dragon = imageio.imread('dragon.jpg')
print(type(dragon))

dragon.shape, dragon.dtype

<class 'imageio.core.util.Array'>

((453, 640, 3), dtype('uint8'))

dragon[0,0]

Array([255, 255, 255], dtype=uint8)

plt.imshow(dragon)
plt.show()

dtype

A listákkal ellentétben nem tárolhatunk benne bármit! A dtype megadja a tárolt elemek típusát

A.dtype

dtype('int32')

a=10**30            #Ez sima ügy
#A[0,0]=10**30      #Ez túl nagy lenne

A = np.array([1.5, 2])
A.dtype

dtype('float64')

Megadhatjuk a dtype-ot amikor létrehozzuk a tömböt.

np.array(['10', '20'], dtype="float32")

array([10., 20.], dtype=float32)

String tömbök

T = np.array(['körte', 'alma'])
print(T)
print(T.shape, T.dtype, type(T))

['körte' 'alma']
(2,) <U5 <class 'numpy.ndarray'>

Fix hosszúságú karakter tömböket tárol!!

T[1] = "banana"
T

array(['körte', 'banan'], dtype='<U5')

Az elemek elérése

Egy sor:

A = np.array([[1, 2], [3, 4], [5, 6]])
A

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

A[0], A[1]

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

Egy oszlop:

A[:, 0]

array([1, 3, 5])

egy elem:

A[2][1], A[2, 1], type(A[2, 1])

(6, 6, numpy.int32)

néhány sor vagy oszlop

A = np.array([[1, 2], [3, 4], [5, 6]])
A

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

A[:2]  # vagy A[:2, :]

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

A[:, 1:]

array([[2],
       [4],
       [6]])

A[::2]

array([[1, 2],
       [5, 6]])

B = np.array([[[1, 2, 3],[4, 5, 6]]])
B.shape,  B.ndim

((1, 2, 3), 3)

B

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

B[0].shape

(2, 3)

B[0, 1], B[0, 1].shape

(array([4, 5, 6]), (3,))

B[0, 1, 2]

6

Operációk

Elemenkénti műveletek

A leggyakrabban használt matematikai fügvények is elérhetőek és elemenként hatnak.

A = np.array([[1, 2], [3, 4], [5, 6]])
print(A)
A + A

[[1 2]
 [3 4]
 [5 6]]

array([[ 2,  4],
       [ 6,  8],
       [10, 12]])

A * A

array([[ 1,  4],
       [ 9, 16],
       [25, 36]])

print(np.exp(A))
print(np.sin(A*np.pi/6))
print(2**A)
print(1/A)

[[  2.71828183   7.3890561 ]
 [ 20.08553692  54.59815003]
 [148.4131591  403.42879349]]
[[5.00000000e-01 8.66025404e-01]
 [1.00000000e+00 8.66025404e-01]
 [5.00000000e-01 1.22464680e-16]]
[[ 2  4]
 [ 8 16]
 [32 64]]
[[1.         0.5       ]
 [0.33333333 0.25      ]
 [0.2        0.16666667]]

Logikai műveletek

A=np.array([1,1,1,0]) & np.array([1,0,1,1]) 
A

array([1, 0, 1, 0], dtype=int32)

A=np.array([1,1,1,0]) | np.array([1,0,1,1]) 
A

array([1, 1, 1, 1], dtype=int32)

A = np.array([[1, 3], [2, 4]])
P = (A >= 2)
print(P)
print(P.dtype)

[[False  True]
 [ True  True]]
bool

Indexelés listákkal (Advanced indexing)

Egy listával vagy tömbbel fogjuk megadni, hogy hanyadik elemeket szeretnénk.

B = np.array(["a","b","c","d","e","f","g"])

np.array([B[0],B[3],B[4],B[6]])

array(['a', 'd', 'e', 'g'], dtype='<U1')

B[[0,3,4,6]]            #gyorsabban ugyanaz

array(['a', 'd', 'e', 'g'], dtype='<U1')

B[np.array([0,3,4,6])]  #tömbbel ugyanaz

array(['a', 'd', 'e', 'g'], dtype='<U1')

Több dimenzióban komplikálódnak a dolgok.

Ha egyetlen index tömbbel indexelünk, annak elemei megfelelnek M első kordináta szerint vett elemeinek.

M = np.arange(12).reshape(3,4)
M

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

np.array([[M[0],M[1]],[M[2],M[2]]])

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

       [[ 8,  9, 10, 11],
        [ 8,  9, 10, 11]]])

M[np.array([[0,1],[2,2]])] #gyorsabban ugyanaz

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

       [[ 8,  9, 10, 11],
        [ 8,  9, 10, 11]]])

Ha több index tömbbel indexelünk, akkor az első az első koordinátnak a második a másodiknak, ... felel meg.

np.array([M[0][2],M[1][2],M[1][0]])

array([2, 6, 4])

np.array([M[0,2],M[1,2],M[1,0]])

array([2, 6, 4])

M[np.array([0,1,1]),np.array([2,2,0])] #gyorsabban ugyanaz

array([2, 6, 4])

np.array([[M[0,1],M[1,0]],[M[2,1],M[2,3]]])

array([[ 1,  4],
       [ 9, 11]])

M[np.array([[0,1],[2,2]]),np.array([[1,0],[1,3]])]  #gyorsabban ugyanaz

array([[ 1,  4],
       [ 9, 11]])

M[:,[1,3]]

array([[ 1,  3],
       [ 5,  7],
       [ 9, 11]])

M[[1,2],:]

array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

Többször is kiválaszthatjuk ugyanazt a sort vagy oszlopot:

M[[2,1,2],:]

array([[ 8,  9, 10, 11],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

Többdimenzióban még komplikáltabba a helyzet. https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html

A tömb alakjának megváltoztatása

A reshape függvénnyel megváltoztathatjuk a tömb alakját anélkül, hogy a tartalmazott elemek megváltoznának, vagy akár lemásolódnának a hattérben.

B = np.array([[[1, 2, 3], [4, 5, 6]]])
B.reshape((2, 3))

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

B.reshape((3, 2))

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

ValueError hibát kapunk ha rosz alakot adunk meg.

#B.reshape(7)  # raises ValueError

np.array(range(6)).reshape((1, 2, 3))

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

Ha -1-et adunk meg, megpróbálja kitalálni, hogy annak a dimenziónak mekkorának kell lennie az elemek száma alapján.

X = np.array(range(12)).reshape((2, -1, 2))
print("X.shape:", X.shape)
print(X)

X.shape: (2, 3, 2)
[[[ 0  1]
  [ 2  3]
  [ 4  5]]

 [[ 6  7]
  [ 8  9]
  [10 11]]]

A resize akkor is működik, ha az elemek száma nem passzol. Ilyenkor töröl, vagy feltölt nullákkal. Magát a tömböt változtatja meg.

X = np.array([[1, 2], [3, 4]])
X.resize((5, 3))
X.resize((1, 2))
X

array([[1, 2]])

Tömbök létrehozása

Ritkán akarjuk egyesével megadni az elemeket, ezért van egy csomó gyorsabb módszer:

• arange: range megfelelője csak nem listát hoz létre, hanem tömböt.
• linspace: egyenletesen felosztott intervallum
• ones, ones_like, csupa egyes
• zeros, zeros_like, csupa nulla
• eye: indetitás mátrix 2 dimenzióban
• fromfunction függvény alapján

Az np.ones_like() és np.zeros_like() függvények megtartják a formát és a dtype-ot!

np.arange(10), np.arange(10).shape

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

np.arange(1, 21, 2).reshape(5, -1)

array([[ 1,  3],
       [ 5,  7],
       [ 9, 11],
       [13, 15],
       [17, 19]])

np.linspace(0, 4, 11)

array([0. , 0.4, 0.8, 1.2, 1.6, 2. , 2.4, 2.8, 3.2, 3.6, 4. ])

np.ones((3, 2)) 

array([[1., 1.],
       [1., 1.],
       [1., 1.]])

np.zeros((2, 3, 2))

array([[[0., 0.],
        [0., 0.],
        [0., 0.]],

       [[0., 0.],
        [0., 0.],
        [0., 0.]]])

A = np.arange(6).reshape(3, -1)
np.zeros_like(A)

array([[0, 0],
       [0, 0],
       [0, 0]])

np.eye(5)

array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

np.eye(4, dtype=bool)

array([[ True, False, False, False],
       [False,  True, False, False],
       [False, False,  True, False],
       [False, False, False,  True]])

Az egyik leghasznosabb, hogy az indexek függvényében is definiálhatjuk a tömböt:

np.fromfunction(lambda i, j: i == j, (3, 3))

array([[ True, False, False],
       [False,  True, False],
       [False, False,  True]])

np.fromfunction(lambda i,j: 100*i+j, (5,5))

array([[  0.,   1.,   2.,   3.,   4.],
       [100., 101., 102., 103., 104.],
       [200., 201., 202., 203., 204.],
       [300., 301., 302., 303., 304.],
       [400., 401., 402., 403., 404.]])

Tömbök összeragasztása

Bármelyik dimenzió szerint ragaszthatunk, ha megfelelőek a dimenziók.

A = np.arange(8).reshape(2, -1)
B = np.arange(8).reshape(2, -1)

np.concatenate((A, B), axis=0)

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

np.concatenate((A, B), axis=-1)  # utolsó dimenzió dimension

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

Mivel általában az első vagy második koordináta szerint ragasztunk, ezekre vannak rövidítések:

A = np.arange(6).reshape(2, -1)
B = np.arange(8).reshape(2, -1)

np.hstack((A, B))

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

A = np.arange(6).reshape(-1, 2)
B = np.arange(8).reshape(-1, 2)
print(A.shape, B.shape)

np.vstack((A, B))

(3, 2) (4, 2)

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

plt.imshow(np.vstack((dragon,dragon)))
plt.show()
plt.imshow(np.hstack((dragon,dragon)))
plt.show()