A NumPy tömbök normalizálása: Gyors útmutató

Ha Pythonnal dolgozott adatelemzés vagy gépi tanulás céljából, valószínűleg találkozott már NumPy tömbökkel. Hatékony eszköz a numerikus adatok kezelésére, de néha az ezekben a tömbökben lévő adatokat módosítani vagy „normalizálni” kell, hogy hatékonyan felhasználhassák az algoritmusokban. De mit jelent egy tömb normalizálása?

A NumPy tömb normalizálásához a tömbben lévő értékeket úgy kell beállítani, hogy azok egy bizonyos tartományba esjenek, jellemzően 0 és 1 közé, vagy hogy szabványos normális eloszlásuk legyen 0 átlaggal és 1 szórással. Ezt gyakran a gépi tanulás és az adatelemzés területén teszik annak biztosítására, hogy minden bemeneti funkció azonos léptékű legyen.

Ebben a cikkben megvizsgáljuk, hogyan normalizálhatja a NumPy tömböt a Pythonban. Megvizsgáljuk a NumPy tömb normalizálására használható különféle módszereket, és példákat is megnézünk, amelyek segítenek jobban megérteni a koncepciót.

Menjünk bele!

Tartalomjegyzék

• Mik a normalizálás alapjai a Pythonban?
  • Mi a normalizálás?
  • Miért fontos a normalizálás?
  • Mik azok a normák?
  • Mi a normalizálás a gépi tanulásban?
• Mik a normalizálás technikái a Pythonban?
  • 1. Min-Max méretezés végrehajtása
  • 2. Az L1 normalizálás végrehajtása
  • 3. Az L2 normalizálás végrehajtása
• A Scikit-Learn használata a Python normalizálására
  • 1. A tömb normalizálása a MinMaxScaler segítségével
  • 2. Helyi sornormalizálás végrehajtása
• Végső gondolatok

Mik a normalizálás alapjai a Pythonban?

Mielőtt a normalizálást végrehajtanánk a Pythonban, meg kell értenie, mit jelent a normalizálás.

Ezért ebben a részben áttekintjük, mi a normalizálás és annak alapvető fogalmai.

Mi a normalizálás?

A normalizálás egy olyan folyamat, amely az adatokat skálázza és szabványosított tartományba alakítja át . Ez úgy történik, hogy az adatok minden elemét elosztjuk egy paraméterrel . A paraméter lehet a maximális érték, tartomány vagy más norma.

Normalizálhatja a NumPy tömböt az euklideszi normával (más néven L2 normával). Ezenkívül normalizálhatja a NumPy tömböket az értékek átskálázásával egy bizonyos tartomány között, általában 0 és 1 között.

A Pythonban a NumPy könyvtár hatékony módszert biztosít a tömbök normalizálására. Ez magában foglalja a többdimenziós tömböket és mátrixokat is.

Miért fontos a normalizálás?

A normalizálás azért fontos, mert biztosítja, hogy a különböző jellemzőket egyenlően kezeljék az adatok összehasonlítása és elemzése során. Használhatja a különböző léptékek miatt felmerülő esetleges torzítások vagy eltérések kiküszöbölésére.

Mik azok a normák?

A normalizáláshoz használt paraméter különböző normák lehetnek , például az euklideszi norma (L2), a manhattani norma (L1) vagy a maximális norma (L_inf). Egy vektor vagy mátrix nagyságának kiszámításához normákat használ . Ezeket azután skálázási tényezőként használják az adatok normalizálására.

Amikor mátrixokkal dolgozunk, gyakran használjuk a Frobenius-normát , amely a többdimenziós tömbök euklideszi normájának általánosítása.

A következő példa egy mátrix normalizálását mutatja be a Frobenius-norma használatával:

import numpy as np

# Initialize your matrix
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Calculate the Frobenius norm
frobenius_norm = np.linalg.norm(matrix, 'fro')

# Normalize the matrix
normalized_matrix = matrix / frobenius_norm

print('Original Matrix:')
print(matrix)
print('nFrobenius Norm:')
print(frobenius_norm)
print('nNormalized Matrix:')
print(normalized_matrix)

Ez a Python-kód először importálja a NumPy könyvtárat, és mátrix létrehozásához használja. Ezután kiszámítja a mátrix Frobenius-normáját, majd a mátrix minden elemét elosztja ezzel az értékkel, hogy normalizálja azt.

Ennek a kódnak a kimenete az alábbiakban látható:

Mi a normalizálás a gépi tanulásban?

A gépi tanulásban a normalizálás fontos előfeldolgozási lépés, mivel javítja az algoritmusok teljesítményét.

Gradiens alapú optimalizálási technikák végrehajtásakor azt tapasztalhatja, hogy az optimalizált funkciók gyorsabban és hatékonyabban konvergálnak. Ennek az az oka, hogy csökkenti a rossz skálázás vagy a színátmenetek eltűnésének kockázatát.

Mik a normalizálás technikái a Pythonban?

A tömbök normalizálását számos módon végezheti el. Egyes módszerek azonban nagy hatékonyságuk miatt népszerűbbek, mint mások.

Ebben a részben a három széles körben használt normalizálási technikát nézzük meg:

1. Min-Max méretezés

2. L1 Normalizálás

3. L2 Normalizálás

1. Min-Max méretezés végrehajtása

A min-max méretezést lineáris normalizálásnak vagy jellemzőskálázásnak is nevezik. A min-max skálázásnál a NumPy tömb értékeit úgy méretezzük, hogy azok egy meghatározott tartományba esjenek, jellemzően 0 és 1 közé.

Ehhez minden elemből le kell vonni a minimális értéket, és az eredményt el kell osztani a maximális és minimális érték különbségével.

A min-max skálázást matematikailag ábrázolhatja:

x' = (x - min(x)) / (max(x) - min(x))

A következő példa bemutatja, hogyan hajthat végre min-max méretezést a NumPy könyvtár használatával:

import numpy as np

# Initialize your matrix
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Perform min-max scaling
min_val = np.min(matrix)
max_val = np.max(matrix)

scaled_matrix = (matrix - min_val) / (max_val - min_val)

print('Original Matrix:')
print(matrix)
print('nMin-Max Scaled Matrix:')
print(scaled_matrix)

Ez a kód először a NumPy-t importálja, majd kiszámítja a mátrix minimális és maximális értékét, amelyet aztán úgy méretez, hogy minden érték 0 (az eredeti minimális értéknek megfelelő) és 1 (az eredeti maximális értéknek megfelelő) között legyen.

Ennek a kódnak a kimenete az alábbiakban látható:

A min-max méretezés a gépi tanulásban és az adat-előfeldolgozásban nagyon gyakori méretezési forma.

2. Az L1 normalizálás végrehajtása

Az L1 normalizálás az L1 normát használja, amely a tömbelemek abszolút értékeinek összege. Ez különösen ritka mátrixok esetén hasznos. Biztosítja, hogy a normalizált tömbelemek abszolút értékeinek összege 1 legyen.

Az L1 normalizálás képlete a következő:

x' = x / sum(|x|)

A következő példa bemutatja, hogyan hajthat végre L1 normalizálást a NumPy használatával:

import numpy as np

# Initialize your matrix
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Perform L1 normalization
l1_norm = np.linalg.norm(matrix, 1, axis=1, keepdims=True)
l1_normalized_matrix = matrix / l1_norm

print('Original Matrix:')
print(matrix)
print('nL1 Normalized Matrix:')
print(l1_normalized_matrix)

Ebben a kódban az np.linalg.norm (mátrix, 1, axis=1, keepdims=True) minden sorhoz kiszámítja az L1 normát (ez az axis=1 megadásával történik).

Ez a művelet egy oszlopvektort ad vissza, ahol minden elem a megfelelő sor L1 normája. Az eredeti mátrixot ezekkel a normákkal elosztva (az osztás elemenkénti végrehajtásával) megkapjuk a mátrix L1 normalizált változatát.

A kimenet az alábbiakban látható:

3. Az L2 normalizálás végrehajtása

Az L2 normalizálás az L2-normát használja, amely a négyzetes tömbelemek összegének négyzetgyöke.

Ez a módszer átalakítja a normalizált tömböt egységvektorrá, amelynek 2-normája 1. Az L2 normalizálás hasznos a dimenziócsökkentéshez, és egyenlő fontosságot biztosít az összes jellemző számára.

Az L2 normalizálásának képlete a következő:

x' = x / sqrt(sum(x^2))

Így hajthatja végre az L2 normalizálását a NumPy segítségével :

import numpy as np

# Initialize your matrix
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Perform L2 normalization
l2_norm = np.linalg.norm(matrix, 2, axis=1, keepdims=True)
l2_normalized_matrix = matrix / l2_norm

print('Original Matrix:')
print(matrix)
print('nL2 Normalized Matrix:')
print(l2_normalized_matrix)

Ebben a kódban az np.linalg.norm(mátrix, 2, tengely=1, keepdims=True) minden sorhoz kiszámítja az L2 normát (euklideszi normát) (ez az axis=1 megadásával történik). Ez a művelet egy oszlopvektort ad vissza, ahol minden elem a megfelelő sor L2 normája.

Az eredeti mátrixot ezekkel a normákkal elosztva (az osztás elemenkénti végrehajtásával) megkapjuk a mátrix L2 normalizált változatát.

A kimenet az alábbiakban látható:

Rendben, most, hogy áttekintettük a normalizált tömb NumPy használatával történő létrehozásának népszerű módjait, a következő részben nézzük meg, hogyan teheti meg ugyanezt más Python-könyvtárak használatával.

A Scikit-Learn használata a Python normalizálására

A Scikit-learn egy hatékony Python-könyvtár a gépi tanuláshoz. Számos eszközt biztosít az adatok előfeldolgozásához.

Az egyik használható eszköz a sklearn.preprocessing modul, amely különféle technikákat kínál a normalizálás végrehajtásához. Számos különböző skálázó funkció, transzformátor és normalizáló áll rendelkezésre. Mi azonban a MinMaxScalerre és a normalizálásra fogunk összpontosítani .

Az adatok scikit-learn segítségével történő előfeldolgozásához elsősorban a transzformátor API-t kell használni. Ez magában foglalja a fit , transform és fit_transform metódusokat.

1. A tömb normalizálása a MinMaxScaler segítségével

A MinMaxScaler egy skálázó, amely egy meghatározott tartományra normalizálja az adatokat, általában [0, 1].

A MinMaxScalar képlete az alábbiakban található:

scaled_value = (value - min_value) / (max_value - min_value)

A MinMaxScaler megvalósításához kövesse az alábbi lépéseket:

1. Importálja a szükséges könyvtárakat:

   import numpy as np
   from sklearn.preprocessing import MinMaxScaler

2. Hozzon létre egy NumPy tömböt:

   data = np.array([[1., 2., 5.], [3., 6., 8.], [5., 10., 12.]])

3. Példányosítsa a MinMaxScalert , és illessze az adatokhoz:

   scaler = MinMaxScaler()
   scaler.fit(data)

4. Alakítsa át az adatokat a transzformáció vagy a fit_transform metódussal:

   normalized_data = scaler.transform(data)

Ennek a kódnak a kimenete az alábbiakban látható:

Amint a kimeneten látható, a MinMaxScalarMatrix csak 0 és 1 közötti értékeket tartalmaz.

2. Helyi sornormalizálás végrehajtása

Alternatívaként használhatja a helybeni sornormalizálást is, a normalizálás funkció használatával.

Ez a módszer az egyes bemeneti tömböket vagy jellemzőket egymástól függetlenül normalizálja úgy, hogy a vektort egységnormára skálázza. Alapértelmezés szerint a normalizálás funkció az L2 normát használja az egyszerű normalizáláshoz, de választhat más normalehetőségeket is.

A következő példa a sorok helyben történő normalizálását mutatja be:

from sklearn.preprocessing import normalize
import numpy as np

# Initialize your matrix
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=float)

# Apply in-place row normalization
normalize(matrix, norm='l2', copy=False)

print('L2 Normalized Matrix:')
print(matrix)

Ebben a kódban meghívjuk a sklearn normalize függvényét , meghatározzuk a használandó normát (ebben az esetben 'l2'), és beállítjuk a copy=False értéket a helyben történő normalizálás végrehajtásához.

Ennek a kódnak a kimenete az alábbiakban látható:

Ha többet szeretne megtudni a gépi tanulásról itt: , tekintse meg a következő videót:

Végső gondolatok

Ahogy tovább kutatja az adattudományt és a gépi tanulást, rá fog jönni, hogy a normalizálási folyamat az adat-előfeldolgozási folyamat lényeges lépése.

Először is, a különböző jellemzőket egy közös skálára helyezi. Ezáltal a modellek kevésbé érzékenyek a bemenetek léptékére. Nagyban javíthatja számos gépi tanulási algoritmus teljesítményét.

Másodszor, segít az edzési folyamat felgyorsításában. Egyes algoritmusok, különösen azok, amelyek számított távolságszámításokon alapulnak, gyorsabban konvergálnak, amikor az adatokat normalizálják.

Azáltal, hogy megtanulja az adatok normalizálását, kulcsfontosságú készségekkel gazdagodik. A normalizálás egy praktikus eszköz, amelyet rutinszerűen használnak a valós alkalmazásokban. Segít csökkenteni annak a valószínűségét, hogy a kiugró értékek vagy az egységek eltérései miatt váratlan eredményeket kapjon.

Mint minden eszköz, a normalizálás elsajátításának kulcsa a gyakorlatban rejlik. Tehát ne habozzon bepiszkolni a kezét, és kísérletezzen különböző adatkészletekkel és véletlenszerű értékekkel. A világ a te osztrigád. Boldog kódolást!