Hogyan használjuk a NumPy-t vektorokkal és statisztikai műveletekkel?

A NumPy könyvtár az egyik legismertebb és leghasznosabb eszköz a Pythonban a numerikus adatok kezelésére. A vektorokkal és mátrixokkal való munka a NumPy alapvető funkciói közé tartozik, és számos egyszerű, de rendkívül hatékony műveletet lehet vele végrehajtani. A következőkben megismerkedünk a NumPy használatával vektorok belső szorzatának kiszámítására, a vektorok normájának meghatározására, illetve különböző statisztikai műveletek elvégzésére.

python
Copy code
import numpy as np
a = np.array([1, 2])
b = np.array([2, 3])
print('a:          ', a)
print('b:          ', b)
print('a.dot(b):   ', a.dot(b))
print('b.dot(a):   ', b.dot(a))
print('np.dot(a,b):', np.dot(a, b))
print('np.dot(b,a):', np.dot(b, a))

A fenti kód eredménye a következő lesz:

makefile
Copy code
a:           [1 2]

b:           [2 3]
a.dot(b):    8
b.dot(a):    8
np.dot(a,b): 8
np.dot(b,a): 8

A dot() függvény mindkét irányban ugyanazt az eredményt adja, hiszen a belső szorzat kommutatív művelet. A np.dot() ugyanazt a műveletet végzi el, de az explicit hívás lehetővé teszi, hogy nagyobb összetettségű számításoknál is egyszerűen alkalmazhassuk.

A következő fontos fogalom, amit érdemes megérteni, a vektorok "normája". A normát egy vektor hosszaként értelmezhetjük, amely a vektor önmagával vett belső szorzatának négyzetgyöke. A NumPy a np.linalg.norm() függvénnyel képes kiszámítani ezt az értéket. Ezen kívül más módszerekkel is meghatározhatjuk a vektor normáját, például a np.sum(np.square(a)) vagy np.sqrt(np.sum(a*a)) kifejezésekkel.

Az alábbi kód segítségével kiszámíthatjuk egy vektor normáját:

python
Copy code
import numpy as np

a = np.array([2, 3])
asquare = np.square(a)
asqsum  = np.sum(np.square(a))
anorm1  = np.sqrt(np.sum(a*a))
anorm2  = np.sqrt(np.sum(np.square(a)))
anorm3  = np.linalg.norm(a)
print('a:      ', a)
print('asquare:', asquare)
print('asqsum: ', asqsum)
print('anorm1: ', anorm1)
print('anorm2: ', anorm2)
print('anorm3: ', anorm3)

A kód kimenete a következő lesz:

makefile
Copy code
a:      [2 3]
asquare: [4 9]
asqsum:  13
anorm1:  3.605551275463989
anorm2:  3.605551275463989
anorm3:  3.605551275463989

Látható, hogy az eredmények egyeznek, de a számítás módja különböző. A np.linalg.norm() függvény használata sokkal egyszerűbb és gyorsabb, mint a többi módszer, amely több lépést is igényel.

A következő fontos művelet, amit érdemes megismerni, az a Hadamard-szorzat. Ez a művelet két vektor komponenseinek szorzatait adja vissza egy harmadik vektorban. A Hadamard-szorzatot az * operátorral hajthatjuk végre NumPy-ban. Ha összegzünk egy ilyen vektort, az összeg ugyanaz lesz, mint a két vektor belső szorzata. Az alábbi példában az a és b vektorok Hadamard-szorzatát végezzük el, majd kiszámoljuk az összegüket:

python
Copy code
import numpy as np

a = np.array([1, 2])
b = np.array([3, 4])
print('a:           ', a)
print('b:           ', b)
print('a*b:         ', a*b)
print('np.sum(a*b): ', np.sum(a*b))
print('(a*b.sum()): ', (a*b).sum())

A kimenet:

makefile
Copy code
a:           [1 2]
b:           [3 4]
a*b:         [3 8]
np.sum(a*b): 11
(a*b.sum()): 11

A Hadamard-szorzat eredményeként a [3, 8] vektort kapjuk, és annak összege megegyezik a belső szorzat eredményével.

python
Copy code
import numpy as np

x = np.array([[2, 3], [4, 5], [6, 7]])

print(x.shape)  # (3, 2)
x = x.reshape((2, 3))
print(x.shape)  # (2, 3)
print('x1:', x)
x = x.reshape((-1))
print(x.shape)  # (6,)
print('x2:', x)
x = x.reshape((6, -1))
print(x.shape)  # (6, 1)
print('x3:', x)
x = x.reshape((-1, 6))
print(x.shape)  # (1, 6)
print('x4:', x)

A kimenet a következő lesz:

lua
Copy code
(3, 2)
(2, 3)
x1: [[2 3 4]
     [5 6 7]]
(6,)

x2: [2 3 4 5 6 7]

(6, 1)
x3: [[2]
     [3]
     [4]
     [5]
     [6]
     [7]]
(1, 6)
x4: [[2 3 4 5 6 7]]

A reshape() módszer rendkívül hasznos, ha egy adatstruktúrát más formában szeretnénk kezelni, például egy mátrixot vektoros formába konvertálni, vagy fordítva.

A statisztikai műveletek is egyszerűen végezhetők el NumPy segítségével. A mean() és std() függvények segítségével könnyedén kiszámíthatjuk egy adathalmaz átlagát és szórását. Az alábbi példa bemutatja, hogyan végezhetjük el ezt:

python
Copy code
import numpy as np
x2 = np.arange(8)
print('mean = ', x2.mean())
print('std = ', x2.std())
x3 = (x2 - x2.mean()) / x2.std()
print('x3 mean = ', x3.mean())
print('x3 std = ', x3.std())

A kimenet a következő lesz:

java
Copy code
mean =  3.5

std =  2.29128784747792
x3 mean =  0.0
x3 std =  1.0

A mean() és std() függvények az adat halmazának átlagát és szórását számolják ki, míg az utolsó két sorban látható, hogyan lehet az adathalmazt normalizálni, hogy annak átlaga 0, szórása pedig 1 legyen.

A kvartilisek kiszámítása is egyszerű a NumPy segítségével. A percentile() függvény segítségével meghatározhatók az

Hogyan használjuk a Pandas DataFrame-eket és a NumPy tömböket statisztikai elemzésekhez?

A Pandas és a NumPy könyvtárak széleskörű eszköztárat kínálnak adatok kezelésére és elemzésére, különösen, ha komplex statisztikai műveletek végrehajtásáról van szó. Ezek a könyvtárak különböző adatstruktúrákat és funkciókat biztosítanak, amelyek segítenek gyorsan és hatékonyan elemezni a nagy adatállományokat. A következő példa és magyarázatok bemutatják, hogyan használhatjuk ezeket az eszközöket a mindennapi adatkezelési feladatokhoz, például adatok leíró statisztikáinak előállításához, szórásdiagramok készítéséhez, valamint egyszerű statisztikai műveletekhez.

A NumPy tömbökkel dolgozó alapvető műveletek egyszerűek. Az alábbi kódban egy NumPy tömb, myarray kerül inicializálásra, majd egy Pandas DataFrame, mydf, jön létre belőle, ahol az adatokat a hónapok és gyümölcsök/italok sorai és oszlopai azonosítják:

python
Copy code
import numpy as np

import pandas as pd
from pandas.plotting import scatter_matrix
import matplotlib.pyplot as plt
myarray = np.array([[10, 30, 20], [50, 40, 60], [1000, 2000, 3000]])
rownames = ['apples', 'oranges', 'beer']
colnames = ['January', 'February', 'March']
mydf = pd.DataFrame(myarray, index=rownames, columns=colnames)
print(mydf)
print(mydf.describe())
scatter_matrix(mydf)
plt.show()

A fenti kódban a describe() függvény automatikusan generálja a statisztikai leírást a mydf DataFrame-ről, amely tartalmazza az alapvető mutatókat, mint például az átlag, a szórás, az minimum és maximum értékek, valamint az interkvartilis tartományok (25%, 50%, 75%). Ezek a statisztikai mutatók fontosak az adatok jellemzésében, mivel segítenek gyorsan feltérképezni az adatok eloszlását és az esetleges anomáliákat.

A következő példa a housing_stats.py scriptet mutatja be, amely segítségével egy lakáspiaci adatokat tartalmazó CSV fájl adatait analizálhatjuk. A script az alábbi módon gyűjti ki a legfontosabb statisztikai mutatókat, például az ingatlanok hálószobáinak számának minimum, medián és maximum értékét:

python
Copy code
import pandas as pd

df = pd.read_csv("housing.csv")
minimum_bdrms = df["bedrooms"].min()
median_bdrms  = df["bedrooms"].median()
maximum_bdrms = df["bedrooms"].max()
print("minimum # of bedrooms:", minimum_bdrms)
print("median # of bedrooms:", median_bdrms)
print("maximum # of bedrooms:", maximum_bdrms)
print("")
print("median values:", df.median().values)
print("")
prices = df["price"]
print("first 5 prices:")
print(prices.head())
print("")
median_price = df["price"].median()
print("median price:", median_price)
print("")
corr_matrix = df.corr()
print("correlation matrix:")
print(corr_matrix["price"].sort_values(ascending=False))

Ez a kód a pandas által biztosított funkciókkal dolgozik, amelyek lehetővé teszik a könnyű és gyors statisztikai elemzést. A read_csv függvény használatával beolvashatjuk az adatokat, majd a min(), median(), max() metódusokkal meghatározhatjuk a kívánt statisztikákat. Emellett a korrelációs mátrix (corr()) segít megérteni az egyes változók közötti kapcsolatokat.

A Pandas más hasznos parancsokat is tartalmaz, amelyeket mindennapi adatfeldolgozáshoz és elemzéshez alkalmazhatunk. Például egy DataFrame mentéséhez CSV fájlba a következő parancsot használhatjuk:

python
Copy code
df.to_csv("data.csv", sep=",", index=False)

Ezen kívül a hiányzó adatok eltávolítására vagy kitöltésére is van lehetőség:

python
Copy code
df.dropna(axis=0, how='any')  # Hiányzó adatok eltávolítása

df.replace(to_replace=None, value=None)  # Hiányzó adatok kitöltése

A Pandas egyedi adatkezelési funkciói között szerepelnek olyan műveletek, mint az adatok rendezése, szűrése és oszlopok vagy sorok eltávolítása. Ezek lehetővé teszik az adatállomány gyors és hatékony manipulálását. Például az alábbiakban bemutatott kóddal egyszerűen megszűrhetjük azokat a sorokat, amelyek egy adott oszlop értékei megfelelnek egy bizonyos kritériumnak:

python
Copy code
df[df["size"] == 7]

Ezen felül az oszlopok átalakításával, például a szöveges típusú adatokat számokká konvertálva is végezhetünk műveleteket:

python
Copy code
pd.to_numeric(df["feature_name"], errors='coerce')

A következő kódban pedig egy véletlenszerű adatokat tartalmazó DataFrame-et generálhatunk, és kiszámíthatjuk a sorok és oszlopok összegét:

python
Copy code
import pandas as pd
import numpy as np
nrows = 4
ncols = 5
np.random.seed(1)
data = np.random.randint(1, 100, size=(nrows, ncols))
df = pd.DataFrame(data)
row_sums = df.sum(axis=1)
column_sums = df.sum(axis=0)
df['Row Sum'] = row_sums
df.loc['Column Sum'] = column_sums
print(df)

Ez a kód generál egy 4x5-ös DataFrame-et véletlenszerű számokkal, majd kiszámítja a sorok és oszlopok összegét, végül ezeket hozzáadja a DataFrame-hez. Az ilyen típusú adatmanipulációk lehetővé teszik az adatok gyors elemzését és a szükséges információk gyors kinyerését.