PricingLoginStart free
Machine Learning Academy · Lekcja

Podstawy NumPy: tablice i operacje matematyczne

Twórz i modyfikuj tablice NumPy, wykonuj zwektoryzowane działania arytmetyczne oraz poznaj broadcasting, aby sprawnie przetwarzać dane numeryczne.

Lekcja 2 z 413 kroki

Podstawy NumPy: tablice i operacje matematyczne to bezpłatna lekcja Machine Learning Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Machine Learning Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Machine Learning Academy zawiera 4 lekcji w sumie.

Dlaczego NumPy jest podstawą ML

NumPy stanowi podstawę każdej biblioteki ML. Jego największą zaletą jest wektoryzacja obliczeń: operuje jednocześnie na całych tablicach, korzystając z szybkiego kodu C, dzięki czemu pętle Pythona pozostają daleko w tyle.

import numpy as np
import time

# Speed comparison: NumPy vs Python list
n = 1_000_000
python_list = list(range(n))
np_array = np.arange(n)

# Python loop (slow)
start = time.time()
result = [x * 2 for x in python_list]
print(f'Python loop: {time.time() - start:.3f}s')

# NumPy vectorised (fast)
start = time.time()
result = np_array * 2
print(f'NumPy vectorised: {time.time() - start:.4f}s')

Tworzenie tablic NumPy

Podstawowym obiektem NumPy jest tablica. Jej najważniejszą cechą jest shape — krotka określająca rozmiar każdego wymiaru, na przykład (wiersze, kolumny). Kod pokazuje, jak je tworzyć.

import numpy as np

# From Python list
a = np.array([1, 2, 3, 4, 5])
print('1D array:', a, '| shape:', a.shape)  # (5,)

# 2D matrix from nested list
M = np.array([[1, 2, 3], [4, 5, 6]])
print('2D matrix shape:', M.shape)  # (2, 3)

# Built-in generators
zeros = np.zeros((3, 4))   # 3x4 matrix of zeros
ones = np.ones((2, 5))     # 2x5 matrix of ones
range_arr = np.arange(0, 10, 2)   # [0 2 4 6 8]
linspace = np.linspace(0, 1, 5)   # 5 evenly spaced points
random = np.random.randn(3, 3)    # 3x3 standard normal

Indeksowanie i wycinanie tablic

Tablice indeksuje się za pomocą [wiersz, kolumna], a wycina przy użyciu start:stop:step. Uwaga: slice jest widokiem, a nie kopią — zmiana wycinka zmienia też oryginał. Dla bezpieczeństwa użyj .copy().

import numpy as np

M = np.array([[1, 2, 3, 4],
              [5, 6, 7, 8],
              [9, 10, 11, 12]])

# Single element
print(M[1, 2])   # 7 (row 1, column 2)

# Slice rows and columns
print(M[0:2, 1:3])  # rows 0-1, columns 1-2 -> [[2,3],[6,7]]

# All rows, last column
print(M[:, -1])  # [4, 8, 12]

# Boolean indexing
print(M[M > 6])  # [7, 8, 9, 10, 11, 12]

Wektoryzowane operacje arytmetyczne

Operacje matematyczne NumPy są domyślnie wykonywane element po elemencie: a + b dodaje odpowiadające sobie elementy bez używania pętli. Kod wykonywany jest w skompilowanym C, dlatego operacje na milionach liczb są tak szybkie. Zobacz kod.

import numpy as np

a = np.array([1.0, 2.0, 3.0, 4.0])
b = np.array([10.0, 20.0, 30.0, 40.0])

print('Addition:', a + b)        # [11. 22. 33. 44.]
print('Multiply:', a * b)        # [10. 40. 90. 160.]
print('Power:', a ** 2)          # [ 1.  4.  9. 16.]
print('Divide:', b / a)          # [10. 10. 10. 10.]

# Scalar operations apply to all elements
print('Add scalar:', a + 100)    # [101. 102. 103. 104.]
print('Square root:', np.sqrt(a)) # [1. 1.41 1.73 2.]

Broadcasting: operacje na różnych kształtach

Broadcasting pozwala NumPy łączyć tablice o różnych kształtach, rozszerzając mniejszą z nich tak, aby pasowała do większej. Dzięki temu można dodać wektor obciążenia do całej partii danych bez pisania pętli.

import numpy as np

# Matrix + vector (broadcasting)
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])  # shape (3, 3)

bias = np.array([10, 20, 30])   # shape (3,) -> broadcasts to (3, 3)

result = matrix + bias
print(result)
# [[11 22 33]
#  [14 25 36]
#  [17 28 39]]

# Normalize each column to zero mean (ML preprocessing)
mean = matrix.mean(axis=0)  # shape (3,)
centered = matrix - mean    # broadcasts across rows

Funkcje agregujące

Operacje agregujące, takie jak średnia i suma, redukują tablicę. Parametr axis określa kierunek: axis=0 działa w dół kolumn, a axis=1 w poprzek wierszy. Kod pokazuje oba przypadki.

import numpy as np

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

print('Global mean:', X.mean())           # 5.0
print('Column means:', X.mean(axis=0))   # [4. 5. 6.]
print('Row means:', X.mean(axis=1))      # [2. 5. 8.]
print('Global std:', X.std())            # ~2.58
print('Column max:', X.max(axis=0))      # [7. 8. 9.]
print('Row sum:', X.sum(axis=1))         # [ 6. 15. 24.]

Mnożenie macierzy: serce ML

Mnożenie macierzy jest sercem ML — każda warstwa sieci neuronowej i każda predykcja wykorzystuje tę operację. Używaj @, a nie *, które działa element po elemencie. Wewnętrzne wymiary muszą się zgadzać: (m,k) razy (k,n).

import numpy as np

# Linear regression prediction: y_hat = X @ weights + bias
X = np.random.randn(100, 5)   # 100 samples, 5 features
weights = np.random.randn(5)  # one weight per feature
bias = 0.5

y_hat = X @ weights + bias    # shape: (100,)
print('Predictions shape:', y_hat.shape)

# Matrix-matrix multiplication (e.g., two weight layers)
A = np.random.randn(4, 3)   # (4, 3)
B = np.random.randn(3, 5)   # (3, 5)
C = A @ B                    # (4, 5)
print('A @ B shape:', C.shape)

Zmiana kształtu i łączenie tablic

Zmiana kształtu modyfikuje shape tablicy bez zmiany jej danych — podobnie jak spłaszczenie obrazu 28x28 do 784 liczb. Łączenie za pomocą vstack lub hstack scala tablice.

import numpy as np

# Reshape: 1D to 2D
a = np.arange(12)          # [0, 1, ..., 11]
matrix = a.reshape(3, 4)   # shape (3, 4)
print('Reshaped:', matrix.shape)

# Use -1 to infer one dimension automatically
flat = matrix.reshape(-1)  # back to 1D (12,)
row = matrix.reshape(1, -1)  # shape (1, 12)
col = matrix.reshape(-1, 1)  # shape (12, 1)

# Stack two arrays row-wise
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
stacked = np.vstack([A, B])  # shape (4, 2)

Generowanie liczb losowych na potrzeby ML

Liczby losowe służą do inicjalizacji wag, tasowania danych i dzielenia ich na zbiory treningowe i testowe. Zawsze ustawiaj seed, aby wyniki można było powtórzyć — bez tego każdy przebieg będzie inny, a debugowanie stanie się uciążliwe.

import numpy as np

# Set seed for reproducibility
rng = np.random.default_rng(seed=42)

# Common distributions used in ML
uniform = rng.uniform(0, 1, size=(3, 3))   # Uniform [0, 1)
normal = rng.normal(0, 1, size=(3, 3))     # Standard normal
integers = rng.integers(0, 10, size=5)     # Random integers

# Shuffle an array
data = np.arange(10)
rng.shuffle(data)
print('Shuffled:', data)

# Random sampling without replacement
idxs = rng.choice(100, size=20, replace=False)  # 20 unique indices

Maski boolowskie i zaawansowane indeksowanie

Maskowanie boolowskie filtruje tablice w jednym przejrzystym wierszu: porównujesz wartości z warunkiem, a następnie wybierasz pasujące elementy. Zaawansowane indeksowanie wybiera elementy na podstawie jawnej listy pozycji.

import numpy as np

scores = np.array([85, 42, 91, 67, 55, 78, 33, 95])

# Boolean mask: select scores above 70
mask = scores > 70
print('Mask:', mask)  # [T F T F F T F T]
print('High scores:', scores[mask])  # [85 91 78 95]

# Count how many passed
print('Passed:', mask.sum())  # 4

# Fancy indexing: select by explicit indices
indices = np.array([0, 2, 7])
print('Selected:', scores[indices])  # [85 91 95]

# Replace outliers
scores[scores < 50] = 50  # clip low scores to 50

NumPy w przepływach pracy scikit-learn

scikit-learn wymaga prawidłowych kształtów: X powinno być 2D (próbki, cechy), a y — 1D (próbki). Kształt (100,) zamiast (100, 1) to częsty błąd — reshape(-1, 1) go naprawia.

import numpy as np
from sklearn.linear_model import LinearRegression

# X must be 2D: (n_samples, n_features)
X = np.array([1, 2, 3, 4, 5])   # shape (5,) -- WRONG
# Fix:
X = X.reshape(-1, 1)            # shape (5, 1) -- CORRECT

y = np.array([2.1, 4.0, 5.9, 8.1, 10.0])  # shape (5,) -- correct

model = LinearRegression()
model.fit(X, y)
print('Learned slope:', round(model.coef_[0], 2))  # ~2.0

Szybki test

Sprawdź swoją znajomość pojęć związanych z uczeniem maszynowym w Pythonie z tego rozdziału.

Odpowiedz w interaktywnej lekcji

Podsumowanie rozdziału

Poznałeś(-aś) podstawy NumPy: tablice stanowią fundament całego ML, wektoryzowana matematyka i broadcasting eliminują powolne pętle, a operator @ wykonuje operacje wykorzystywane przez każdy model. Następnie: Pandas. 🐼

Bezpłatny start

Ucz się Python dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
30
Lekcje
120
Zacznij naukę bezpłatnieWyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Podstawy NumPy: tablice i operacje matematyczne” jest bezpłatna?

Tak — pełny tekst „Podstawy NumPy: tablice i operacje matematyczne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Machine Learning Academy, przejdź na CoddyKit PRO. Kurs Machine Learning Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Podstawy NumPy: tablice i operacje matematyczne”?

Twórz i modyfikuj tablice NumPy, wykonuj zwektoryzowane działania arytmetyczne oraz poznaj broadcasting, aby sprawnie przetwarzać dane numeryczne. Ćwiczysz Machine Learning Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Machine Learning Academy?

Nie wymagamy żadnego doświadczenia. Machine Learning Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Podstawy NumPy: tablice i operacje matematyczne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Machine Learning Academy?

Tak. Każda lekcja Machine Learning Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Instalowanie Anacondy i Jupyter Notebook
  2. Podstawy NumPy: tablice i operacje matematyczne
  3. Pandas do przetwarzania danych
  4. Wizualizacja danych za pomocą Matplotlib i Seaborn
← Powrót do Machine Learning Academy