Sådan normaliseres NumPy-arrays: En hurtig guide

Hvis du har arbejdet med Python til dataanalyse eller maskinlæring, er du sandsynligvis stødt på NumPy-arrays. De er et kraftfuldt værktøj til at håndtere numeriske data, men nogle gange skal dataene i disse arrays justeres eller 'normaliseres' for effektivt at blive brugt i dine algoritmer. Men hvad vil det sige at normalisere et array?

For at normalisere et NumPy array skal du justere værdierne i arrayet, så de falder inden for et bestemt område, typisk mellem 0 og 1, eller så de har en standard normalfordeling med et gennemsnit på 0 og en standardafvigelse på 1 Dette gøres ofte inden for maskinlæring og dataanalyse for at sikre, at alle inputfunktioner har samme skala.

I denne artikel vil vi undersøge, hvordan du kan normalisere et NumPy-array i Python. Vi ser på de forskellige metoder, du kan bruge til at normalisere et NumPy-array, og vi ser også på eksempler for at hjælpe dig med bedre at forstå konceptet.

Lad os komme ind i det!

Indholdsfortegnelse

• Hvad er det grundlæggende ved normalisering i Python?
  • Hvad er normalisering?
  • Hvorfor er normalisering vigtig?
  • Hvad er normer?
  • Hvad er normalisering i maskinlæring?
• Hvad er normaliseringsteknikkerne i Python?
  • 1. Sådan udføres Min-Max-skalering
  • 2. Sådan udføres L1-normalisering
  • 3. Sådan udføres L2-normalisering
• Sådan bruges Scikit-Learn til normalisering i Python
  • 1. Sådan normaliseres array ved hjælp af MinMaxScaler
  • 2. Sådan udføres rækkenormalisering på stedet
• Afsluttende tanker

Hvad er det grundlæggende ved normalisering i Python?

Før vi implementerer normalisering i Python, skal du forstå, hvad normalisering betyder.

Derfor vil vi i dette afsnit gennemgå, hvad der er normalisering og dets kernebegreber.

Hvad er normalisering?

Normalisering er en proces, der skalerer og transformerer data til et standardiseret område. Dette gøres ved at dividere hvert element i dataene med en parameter. Parameteren kan være den maksimale værdi, rækkevidde eller en anden norm.

Du kan normalisere NumPy-arrayet ved hjælp af den euklidiske norm (også kendt som L2-normen). Desuden kan du også normalisere NumPy-arrays ved at omskalere værdierne mellem et bestemt område, normalt 0 til 1.

I Python giver NumPy-biblioteket en effektiv måde at normalisere arrays på. Dette inkluderer også multidimensionelle arrays og matricer.

Hvorfor er normalisering vigtig?

Normalisering er vigtig, da det sikrer, at forskellige funktioner behandles ens, når man sammenligner og analyserer data. Du kan bruge det til at eliminere potentielle skævheder eller uoverensstemmelser, der kan opstå på grund af varierende skalaer.

Hvad er normer?

Parameteren, som du bruger til normalisering, kan være forskellige normer , såsom den euklidiske norm (L2), Manhattan-normen (L1) eller den maksimale norm (L_inf). Du bruger normer til at beregne størrelsen af ​​en vektor eller matrix . Disse bruges derefter som en skaleringsfaktor til at normalisere dataene.

Når vi arbejder med matricer, bruger vi ofte Frobenius-normen , som er en generalisering af den euklidiske norm for flerdimensionelle arrays.

Følgende eksempel viser normaliseringen af ​​en matrix ved hjælp af Frobenius-normen:

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)

Denne Python-kode importerer først NumPy-biblioteket og bruger det til at oprette en matrix. Den beregner derefter Frobenius-normen for matricen og dividerer derefter hvert element i matricen med denne værdi for at normalisere den.

Outputtet af denne kode er givet nedenfor:

Hvad er normalisering i maskinlæring?

I maskinlæring er normalisering et vigtigt forbehandlingstrin, da det forbedrer ydeevnen af ​​algoritmer.

Når du udfører gradientbaserede optimeringsteknikker, vil du opdage, at optimerede funktioner har tendens til at konvergere hurtigere og mere effektivt. Dette er fordi det reducerer risikoen for dårlig skalering eller forsvindende gradienter.

Hvad er normaliseringsteknikkerne i Python?

Du kan udføre normalisering af arrays på en række måder. Nogle metoder er dog mere populære end andre på grund af deres høje effektivitet.

Til dette afsnit vil vi se på de tre almindeligt anvendte normaliseringsteknikker:

1. Min-Max skalering

2. L1 Normalisering

3. L2 Normalisering

1. Sådan udføres Min-Max-skalering

Min-max-skalering er også kendt som lineær normalisering eller funktionsskalering. I min-max-skalering skalerer vi værdierne af et NumPy-array, så de falder inden for et specificeret område, typisk mellem 0 og 1.

For at gøre dette trækker du minimumsværdien fra hvert element og dividerer resultatet med forskellen mellem maksimum- og minimumværdierne.

Du kan repræsentere min-max skaleringen matematisk som:

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

Følgende eksempel viser, hvordan du kan udføre min-max-skalering ved hjælp af NumPy-biblioteket:

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)

Denne kode vil først importere NumPy og derefter beregne minimums- og maksimumværdierne i matrixen, som den derefter skalerer, således at alle værdier er mellem 0 (svarende til den oprindelige minimumsværdi) og 1 (svarende til den oprindelige maksimumværdi).

Outputtet af denne kode er givet nedenfor:

Min-max skalering er en meget almindelig form for skalering i maskinlæring og dataforbehandling.

2. Sådan udføres L1-normalisering

L1-normalisering anvender L1-normen, som er summen af ​​de absolutte værdier af array-elementerne. Dette er især nyttigt for sparsomme matricer. Det sikrer, at summen af ​​de absolutte værdier af de normaliserede matrixelementer er lig med 1.

Formlen for L1 normalisering er:

x' = x / sum(|x|)

Følgende eksempel viser, hvordan du kan udføre L1-normalisering ved hjælp af NumPy:

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)

I denne kode beregner np.linalg.norm (matrix, 1, akse=1, keepdims=True) L1-normen for hver række (dette gøres ved at angive akse=1).

Denne operation returnerer en kolonnevektor, hvor hvert element er L1-normen for den tilsvarende række. Ved at dividere den oprindelige matrix med disse normer (udføre divisionen element-mæssigt), opnår vi den L1 normaliserede version af matricen.

Outputtet er givet nedenfor:

3. Sådan udføres L2-normalisering

L2-normalisering bruger L2-normen, som er kvadratroden af ​​summen af ​​de kvadrerede matrixelementer.

Denne metode konverterer det normaliserede array til en enhedsvektor med en 2-norm på 1. L2-normalisering er nyttig til dimensionsreduktion og sikrer lige stor betydning for alle funktioner.

Formlen for L2 normalisering er:

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

Sådan kan du udføre L2-normalisering ved hjælp af NumPy :

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)

I denne kode beregner np.linalg.norm(matrix, 2, akse=1, keepdims=True) L2-normen (Euklidisk norm) for hver række (dette gøres ved at angive akse=1). Denne operation returnerer en kolonnevektor, hvor hvert element er L2-normen for den tilsvarende række.

Ved at dividere den oprindelige matrix med disse normer (udføre divisionen element-mæssigt), opnår vi den L2 normaliserede version af matricen.

Outputtet er givet nedenfor:

Okay, nu hvor vi har gennemgået de populære måder at skabe et normaliseret array ved hjælp af NumPy, lad os tage et kig på, hvordan du kan gøre det samme ved at bruge andre Python-biblioteker i næste afsnit.

Sådan bruges Scikit-Learn til normalisering i Python

Scikit-learn er et kraftfuldt Python-bibliotek til maskinlæring. Det giver flere værktøjer til dataforbehandling.

Et værktøj, du kan bruge, er modulet sklearn.preprocessing , som tilbyder forskellige teknikker til at udføre normalisering. Der er mange forskellige skaleringsfunktioner, transformere og normalisatorer tilgængelige. Vi vil dog fokusere på MinMaxScaler og normaliseringen .

For at forbehandle data med scikit-learn, bruger du hovedsageligt transformer API. Dette inkluderer metoderne fit , transform og fit_transform .

1. Sådan normaliseres array ved hjælp af MinMaxScaler

MinMaxScaler er en scaler, der normaliserer data til et specificeret område, normalt [0, 1] .

Formlen for MinMaxScalar er givet nedenfor:

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

For at implementere MinMaxScaler kan du følge disse trin:

1. Importer de nødvendige biblioteker:

   import numpy as np
   from sklearn.preprocessing import MinMaxScaler

2. Opret et NumPy-array:

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

3. Instantiér MinMaxScaler og tilpas den til dataene:

   scaler = MinMaxScaler()
   scaler.fit(data)

4. Transformer dataene ved hjælp af transform eller fit_transform metoden:

   normalized_data = scaler.transform(data)

Outputtet af denne kode er givet nedenfor:

Som du kan se i outputtet, har MinMaxScalarMatrix kun værdier fra 0 til 1.

2. Sådan udføres rækkenormalisering på stedet

Du kan også bruge in-place rækkenormaliseringen som et alternativ ved at bruge normaliseringsfunktionen .

Denne metode normaliserer hver input-array eller funktion uafhængigt ved at skalere vektoren til en enhedsnorm. Som standard bruger normaliseringsfunktionen L2-normen til at udføre simpel normalisering, men du kan vælge andre normindstillinger.

Følgende eksempel viser normalisering af rækker på stedet:

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)

I denne kode kalder vi normaliseringsfunktionen fra sklearn , definerer den norm, der skal bruges ('l2' i dette tilfælde), og indstiller copy=False for at udføre normalisering på stedet.

Outputtet af denne kode er givet nedenfor:

For at lære mere om maskinlæring i , se følgende video:

Afsluttende tanker

Når du udforsker datavidenskab og maskinlæring yderligere, vil du opdage, at normaliseringsprocessen er et væsentligt trin i din dataforbehandlingspipeline.

For det første placerer det forskellige funktioner på en fælles skala. Dette gør dine modeller mindre følsomme over for omfanget af input. Det kan i høj grad forbedre ydeevnen af ​​mange maskinlæringsalgoritmer.

For det andet hjælper det dig med at fremskynde træningsprocessen. Nogle algoritmer, især dem, der er baseret på beregnede afstandsberegninger, konvergerer hurtigere, når data normaliseres.

Ved at lære at normalisere data, udstyrer du dig selv med en afgørende færdighed. Normalisering er et praktisk værktøj, der bruges rutinemæssigt i applikationer fra den virkelige verden. Det vil hjælpe dig med at reducere sandsynligheden for uventede resultater på grund af afvigelser eller forskelle i enheder.

Som ethvert værktøj ligger nøglen til at mestre normalisering i praksis. Så tøv ikke med at gøre dine hænder snavsede og eksperimentere med forskellige datasæt og tilfældige værdier. Verden af ​​er din østers. God kodning!