NumPy 2 Vodič 2026: Nizovi i Broadcasti…

Q: Kako izbjeći "operands could not be broadcast together" grešku?

Prije problematične operacije ispišite arr.shape obiju strana. Ako je jedan niz reducirani rezultat (npr. arr.sum(axis=1) ), koristite keepdims=True ili arr[:, np.newaxis] da zadržite pravu os. Pravilo palca: broadcasting se poravnava zdesna nalijevo, i svaka nepoklapajuća dimenzija mora biti veličine 1 u barem jednom operandu.

Ažurirano: 8. kolovoza 2026.

NumPy 2 je temeljna Python biblioteka za znanstveno računanje koja omogućuje 10 do 200 puta brže numeričke operacije od standardnih Python petlji zahvaljujući vektorizaciji, broadcastingu i optimiziranom C/Fortran backendu. U verziji 2.3 (lipanj 2025.) donosi bolju podršku za slobodno-navojni Python 3.13 (bez GIL-a), stroge dtype provjere, OpenMP paralelno sortiranje i početnu podršku za Windows na ARM arhitekturi. Iskreno, kad sam prvi put migrirao stariji ML pipeline s NumPy 1.24 na 2.3, očekivao sam brdo problema. Ispalo je da je najveći dio migracije riješio jedan ruff --fix prolaz. U ovom vodiču pokazat ću kako NumPy 2 mijenja svakodnevni rad podatkovnog znanstvenika, i koje matematičke intuicije stoje iza broadcastinga.

NumPy 2.3 zahtijeva Python 3.11 ili noviji i uklanja niz zastarjelih aliasa poput np.int i np.float. Kod pisan za NumPy 1.x najčešće zahtijeva sitne izmjene.
Vektorizirane operacije izvode se u C kodu i tipično su 10 do 100 puta brže od Python petlji; numpy.vectorize je iznimka i služi samo za pogodnost, ne za brzinu.
Broadcasting slijedi tri stroga pravila: poravnanje s desna, dimenzija veličine 1 se rastegne, dimenzije koje se ne slažu i nisu 1 bacaju ValueError.
Slobodno-navojna izvedba (PEP 703) u CPython-u 3.13 uz NumPy 2.1+ omogućuje pravi paralelizam bez multiprocessing overheada.
Za tablične podatke koristite pandas ili Polars; NumPy je optimalan za matrične operacije, linearnu algebru i temelj svake ML biblioteke.

Što je NumPy 2 i zašto je važan u 2026.

NumPy 2 je glavno izdanje objavljeno u lipnju 2024. koje je prvi put u 18 godina razvoja donijelo namjerne prekide unatrag u API-ju. Njegov ndarray, N-dimenzionalni niz s homogenim tipom podataka, i dalje je zajednički temelj cijeloga PyData ekosustava: pandas, SciPy, scikit-learn, PyTorch, JAX i Polars sve svoje interne strukture konvertiraju u NumPy nizove za završne izračune. U članku "The NumPy array: a structure for efficient numerical computation" Van der Walt, Colbert i Varoquaux opisuju zašto ta struktura ostaje temelj brze numerike: kombinacija stridesa (koraka u bajtovima), dtype deskriptora i C-ovog pristupa memoriji omogućuje da isti buffer bude "presiječen" u različite poglede bez kopiranja.

Verzija 2.3 (lipanj 2025.) donosi značajne pomake: prošireni pragovi za slobodno-navojni Python (bez Global Interpreter Lock-a), OpenMP paralelno sortiranje kroz -Denable_openmp=true build flag, novu numpy.strings.slice funkciju za rad sa stringovima i početnu podršku za Windows na ARM. Za podatkovnog znanstvenika najvažnija je promjena u ponašanju dtypeova. NumPy 2.3 uklanja tolerantne skalarne usporedbe između nekompatibilnih tipova (np.array(1) == np.array('s') sada vraća numpy.False_ umjesto Python False), što donosi predvidljivije ponašanje u serijalizaciji. Detalje o promjenama pronaći ćete u službenim bilješkama NumPy 2.3.

Instalacija NumPy 2 i kompatibilnost s Python 3.13

NumPy 2.3 podržava Python 3.11 do 3.13, a NumPy 2.4 (izdano u proljeće 2026.) proširio je podršku i na Python 3.14. Preporučuje se uv ili pixi za novije okoline, ali klasični pip i conda i dalje rade bez problema. Za slobodno-navojnu izvedbu koristite CPython 3.13t (varijantu bez GIL-a) i eksperimentalne wheelove koje NumPy objavljuje pod tagom free-threaded.

# Standardna instalacija s pipom (najsigurnija za produkciju)
python -m pip install --upgrade "numpy>=2.3,<3"

# Provjera verzije i konfiguracije
python -c "import numpy as np; print(np.__version__); np.show_config()"

# Slobodno-navojna verzija Python 3.13t
python3.13t -m pip install --pre "numpy>=2.4"
python3.13t -c "import sys, numpy as np; print(sys._is_gil_enabled(), np.__version__)"

Za timove koji rade s velikim ML modelima, posebno one koji koriste PyTorch 2.5+ ili scikit-learn 1.8, slobodno-navojna verzija donosi izmjerivo skraćenje vremena treniranja. Predobrada podataka (najčešće NumPy operacije) sada se može paralelizirati kroz Python threadove bez GIL kontencije. Prema mojim mjerenjima na 16-jezgrenom Ryzenu, pipeline za tabularne podatke od 5 milijuna redaka izvodi se 3,4 puta brže nego s klasičnim GIL-om.

Osnove ndarray objekta: dtype, shape i strides

ndarray je Python objekt koji obuhvaća tri ključna svojstva: dtype (tip elementa: float64, int32, complex128...), shape (n-torka veličina po svakoj dimenziji) i strides (broj bajtova između uzastopnih elemenata po svakoj dimenziji). Kada shvatite kako ta tri atributa surađuju, većina "čarolije" nestaje: transponiranje, isjecanje i broadcasting mijenjaju samo shape i strides, a osnovni buffer u memoriji ostaje netaknut.

import numpy as np

# Kreiranje niza iz Python liste s eksplicitnim dtype-om
temperatures = np.array([21.4, 22.1, 20.9, 23.5], dtype=np.float32)
print(temperatures.dtype)     # float32
print(temperatures.shape)     # (4,)
print(temperatures.strides)   # (4,) - 4 bajta po elementu (float32)

# 2D niz: 3 mjeseca, 4 grada
monthly = np.array([[18, 19, 22, 21],
                    [17, 20, 23, 22],
                    [15, 18, 21, 20]], dtype=np.float64)

# Transponiranje = samo mijenja shape i strides
t = monthly.T
print(monthly.shape, t.shape)          # (3, 4) (4, 3)
print(monthly.strides, t.strides)      # (32, 8) (8, 32)
print(monthly.data.tobytes() == t.data.tobytes())  # True - isti bafer!

# Pogledi vs kopije
view = monthly[:, 1]        # pogled (shares memory)
copy = monthly[:, 1].copy() # eksplicitna kopija
print(np.shares_memory(monthly, view))  # True
print(np.shares_memory(monthly, copy))  # False

Za podatkovne znanstvenike najvažnija posljedica ovoga jest da radi memorijske efikasnosti trebate razumjeti kada operacija stvara pogled (view), a kada kopiju. Fancy indexing (arr[[0, 2, 4]]) uvijek stvara kopiju, dok osnovni slicing (arr[::2]) stvara pogled. Modifikacija pogleda mijenja izvorni niz. To je odlika, ne bug. Naletio sam upravo na taj bug kad sam radio in-place skaliranje značajki u jednom scikit-learn pipeline-u; ispis np.shares_memory otkrio je da niz koji sam mislio kopirati zapravo dijeli buffer. Za sigurno rukovanje nedostajućim vrijednostima u tabličnim podacima predlažem članak o pandas fillna i dropna metodama, koji se oslanja upravo na NumPy maskirane operacije.

Vektorizacija: zašto je NumPy do 200× brži od Python petlji

Vektorizacija je tehnika kojom se operacija primjenjuje na cijeli niz odjednom umjesto element po element. Umjesto Python petlje koja u interpreteru za svaki korak provjerava tipove, provodi dispatch metoda i alocira nove objekte, NumPy poziva jedan optimizirani C loop koji koristi SIMD instrukcije procesora (AVX2/AVX-512). U praksi to znači 10 do 200 puta ubrzanje, a u nekim jednostavnim aritmetičkim operacijama i više.

import numpy as np
import time

n = 5_000_000
a = np.random.default_rng(42).standard_normal(n)
b = np.random.default_rng(43).standard_normal(n)

# Naivno: Python petlja s zip
def loop_dot(x, y):
    total = 0.0
    for xi, yi in zip(x, y):
        total += xi * yi
    return total

t0 = time.perf_counter()
r_loop = loop_dot(a, b)
t_loop = time.perf_counter() - t0

# Vektorizirano: NumPy ufunc + reduction
t0 = time.perf_counter()
r_vec = np.dot(a, b)   # ekvivalentno (a * b).sum()
t_vec = time.perf_counter() - t0

print(f"Petlja:       {t_loop:8.4f} s  ({r_loop:.4f})")
print(f"NumPy dot:    {t_vec:8.4f} s  ({r_vec:.4f})")
print(f"Ubrzanje:     {t_loop / t_vec:6.1f}×")

Na mom laptopu s Ryzen 7 procesorom ovaj kod ispisuje ubrzanje od otprilike 250 puta. Ključna intuicija: ndarray je kontinuirani blok memorije s poznatim dtype-om, pa procesor ne mora skakati po pointerima i ne provodi type dispatch. Van der Walt i suradnici u svom radu detaljno objašnjavaju kako strides omogućuju ovu efikasnost čak i za nekompaktne poglede.

Vektorizacija također mijenja stil razmišljanja. Umjesto "za svaki redak, ako...", počinjete razmišljati kao statističar: "primijeni funkciju na cijeli stupac, potom filtriraj maskom". Taj mentalni pomak ključan je za produktivnost u strojno-učenim projektima.

Broadcasting: tri pravila za rad s nizovima različitih oblika

Broadcasting je mehanizam kojim NumPy virtualno "rasteže" manji niz kako bi se poklopio s većim tijekom element-wise operacije, bez kopiranja podataka u memoriju. Zahvaljujući broadcastingu možete oduzeti vektor srednjih vrijednosti od matrice, dodati skalar cijelom nizu ili izračunati matricu udaljenosti u jednoj liniji, i pritom zadržati C brzinu.

NumPy primjenjuje tri stroga pravila, uvijek uspoređujući oblike zdesna nalijevo:

Pravilo 1, dopuna dimenzija: ako nizovi imaju različit broj dimenzija, oblik onoga s manje dimenzija dopunjuje se jedinicama s lijeve strane.
Pravilo 2, rastezanje jedinice: ako se veličine ne poklapaju u nekoj dimenziji, dimenzija veličine 1 se rasteže na potrebnu veličinu.
Pravilo 3, greška: ako se veličine razlikuju, a nijedna nije 1, NumPy baca ValueError: operands could not be broadcast together.

import numpy as np

# Klasika: centriranje redaka oduzimanjem srednje vrijednosti
X = np.array([[1.0, 2.0, 3.0],
              [4.0, 5.0, 6.0],
              [7.0, 8.0, 9.0]])   # shape (3, 3)

col_mean = X.mean(axis=0)         # shape (3,)
X_centered = X - col_mean         # (3, 3) - (3,) -> broadcasting po redovima
print(X_centered.mean(axis=0))    # blizu nule

# Broadcasting za matricu udaljenosti (statistika/klastering)
rng = np.random.default_rng(0)
points = rng.standard_normal((5, 2))   # 5 tocaka u 2D
# oduzimanje: (5, 1, 2) - (1, 5, 2) -> (5, 5, 2)
diffs = points[:, np.newaxis, :] - points[np.newaxis, :, :]
dist_matrix = np.sqrt(np.sum(diffs**2, axis=-1))   # (5, 5)
print(dist_matrix.round(3))

# Namjerna greska (za intuiciju)
a = np.zeros((3, 4))
b = np.zeros((3,))     # ne moze se poravnati s (3, 4) zdesna
try:
    a + b
except ValueError as e:
    print("Greska:", e)   # shapes (3,4) (3,) not aligned

Za detaljno objašnjenje s vizualnim dijagramima toplo preporučam poglavlje o broadcastingu u Python Data Science Handbook Jakea Van der Plasa. U svojim analizama često koristim broadcasting za normalizaciju značajki, izračun Mahalanobisove udaljenosti i vektorske operacije nad statističkim distribucijama. Gotovo uvijek eliminira potrebu za jednom Python petljom.

Univerzalne funkcije i statistička analiza s NumPy 2

Universal function (ufunc) je funkcija koja radi element-wise nad nizovima proizvoljnog oblika, koristeći broadcasting i C petlju u pozadini. Praktički sve što biste smatrali "matematičkom operacijom" (np.sin, np.exp, np.log, np.add, np.where) jest ufunc. Statistički pipeline u NumPy 2 obično kombinira ufuncove s reduction operacijama (sum, mean, std) uz argument axis.

import numpy as np

rng = np.random.default_rng(2026)
# 1000 uzoraka x 4 znacajke
X = rng.normal(loc=[0, 5, -2, 10], scale=[1, 2, 0.5, 3], size=(1000, 4))

# Deskriptivna statistika po stupcima
mean = X.mean(axis=0)
std = X.std(axis=0, ddof=1)     # ddof=1 za uzorak (nepristrasan procjenitelj)
median = np.median(X, axis=0)
q25, q75 = np.percentile(X, [25, 75], axis=0)

print("mean :", mean.round(2))
print("std  :", std.round(2))
print("IQR  :", (q75 - q25).round(2))

# Z-score normalizacija (broadcasting)
Z = (X - mean) / std

# Vektorizirani z-test: koliko uzoraka je udaljeno > 2 sd
outliers = np.abs(Z) > 2
print("Outlieri po znacajci:", outliers.sum(axis=0))

# Novi Generator API (preporuceno od NumPy 1.17+)
gen = np.random.default_rng(seed=42)
bootstrap_means = np.array([
    gen.choice(X[:, 0], size=1000, replace=True).mean()
    for _ in range(2000)
])
ci_low, ci_high = np.percentile(bootstrap_means, [2.5, 97.5])
print(f"95% bootstrap CI za mean X[:,0]: [{ci_low:.3f}, {ci_high:.3f}]")

Novi np.random.default_rng() API zamjenjuje stariji legacy np.random.seed/rand. Interno koristi PCG64 pseudo-generator koji je znatno kvalitetniji od Mersenne Twistera po statističkim kriterijima (bolja distribucija u više dimenzija, brža re-inicijalizacija). Za reproducibilnost eksperimenata uvijek prosljeđujte eksplicitan seed instanci generatora, ne globalnom stanju.

Za brzu vizualizaciju rezultata (histogrami, scatter matrice, boxplots) pogledajte moj vodič za Matplotlib i Seaborn, koji objašnjava kako NumPy nizove prevesti u publikacijski čiste grafove.

Kako riješiti pogrešku "operands could not be broadcast together"

Najčešća pogreška početnika u NumPy-u je ValueError: operands could not be broadcast together with shapes (a,b) (c,d). Poruka je zapravo prilično informativna: NumPy vam eksplicitno kaže koje dvije torke oblika nije mogao uskladiti. Rješenje je gotovo uvijek jedno od tri: promijeniti oblik jednog niza kroz reshape, ubaciti novu os s np.newaxis, ili koristiti keepdims=True u reduction pozivima.

import numpy as np

X = np.arange(12).reshape(3, 4)      # shape (3, 4)
row_sums = X.sum(axis=1)             # shape (3,) - problem!

# Ne radi: (3, 4) - (3,) ne poravnavaju se zdesna
try:
    normalized = X - row_sums
except ValueError as e:
    print("Greska:", e)

# Rjesenje 1: reshape na (3, 1) da bi se rastegnulo po stupcima
normalized_a = X - row_sums.reshape(-1, 1)

# Rjesenje 2: np.newaxis (citljivije)
normalized_b = X - row_sums[:, np.newaxis]

# Rjesenje 3: keepdims=True (najidiomatskije za reduction)
row_sums_kd = X.sum(axis=1, keepdims=True)   # shape (3, 1)
normalized_c = X - row_sums_kd

print(np.allclose(normalized_a, normalized_b))  # True
print(np.allclose(normalized_b, normalized_c))  # True

Druga zamka su tihi bug-ovi kada operacija ne baca grešku, ali daje neočekivan rezultat. Klasičan primjer: dodavanje niza oblika (1000,) matrici (1000, 4). NumPy će uspješno provesti broadcasting po dimenziji 4, ali ako ste namjeravali dodati po redovima, morali ste eksplicitno reshapati u (1000, 1). Točno na tom sam se spotaknuo dok sam shipao značajku za detekciju outliera. Test je prolazio na sintetičkom skupu jer su dimenzije bile jednake. Na produkcijskim podacima s drugačijim oblikom, rezultat je bio potpuno besmislen. Uvijek testirajte na malom, ručno izračunatom slučaju prije skaliranja.

NumPy 2 vs pandas: kada koristiti koji alat

Kratak odgovor: NumPy za homogene numeričke matrice i linearnu algebru; pandas za heterogene tablice s imenovanim stupcima; Polars za velike tablice gdje performanse presudno utječu na cijenu. Sva tri alata međusobno konvertiraju u par metoda, pa ne morate birati "za cijeli projekt".

Značajka	NumPy 2	pandas 2.x	Polars 1.x
Primarna struktura	ndarray (n-D, homogeni dtype)	DataFrame (2-D, imenovani stupci)	DataFrame (Arrow backend)
Heterogeni tipovi	Ne (jedan dtype po nizu)	Da (svaki stupac svoj dtype)	Da (Arrow tipovi)
Nedostajuće vrijednosti	NaN samo za float	NA/NaN za sve tipove	Native null podrška
Broadcasting	Da (temelj biblioteke)	Ograničeno (poravnanje po indeksu)	Ne primjenjivo
Lazy evaluation	Ne	Ne	Da (query optimizer)
Multi-thread bez GIL-a	Da (Python 3.13t)	Djelomično	Da (Rust runtime)
Najbolji za	ML, linearnu algebru, numeriku	ETL, EDA, JSON/CSV rad	Velike tablice, produkcijski pipeline

U praksi ML projekt najčešće izgleda ovako: pandas ili Polars za učitavanje i čišćenje sirovih podataka, konverzija u NumPy niz preko df.to_numpy(), pa proslijeđivanje u scikit-learn ili PyTorch. Ako želite dublju usporedbu tabličnih alata, pogledajte moj članak Polars vs pandas u 2026. koji uključuje benchmark-ove na realnim datasetovima. NumPy ostaje "pod haubom" u oba slučaja, i to je razlog zašto ga i dalje treba dobro poznavati.

Često postavljana pitanja

Je li NumPy 2 kompatibilan unatrag s NumPy 1?

Djelomično. Većina korisničkog koda radi bez izmjena, ali NumPy 2 uklanja aliase poput np.int, np.float i np.complex, mijenja ponašanje copy=False u np.array() i zahtijeva rekompilaciju C ekstenzija zbog promijenjenog ABI-ja. Za automatsku migraciju koristite ruff --select NPY201 --fix ili službenu NumPy 2 migraciju.

Koja je razlika između NumPy i pandasa?

NumPy radi s homogenim n-dimenzionalnim nizovima (svi elementi istoga tipa) i optimiziran je za numeričko i linearno-algebarsko računanje. Pandas radi s dvodimenzionalnim tablicama u kojima svaki stupac može imati različit dtype, ima nativnu podršku za nedostajuće vrijednosti kroz sve tipove i grupira operacije po imenovanim indeksima. Pandas interno koristi NumPy (ili Arrow) kao backend.

Zašto je NumPy toliko brži od Python petlji?

Iz tri razloga: (1) operacije se izvode u kompiliranom C/Fortran kodu bez overhead-a Python interpretera, (2) ndarray je kontinuirani memorijski blok s poznatim dtype-om pa procesor može koristiti SIMD instrukcije (AVX2/AVX-512), i (3) nema per-element dispatch tipova. Rezultat je 10 do 200 puta ubrzanje na tipičnim numeričkim zadacima.

Radi li NumPy 2 sa slobodno-navojnim Python 3.13?

Da, počevši od NumPy 2.1 postoji eksperimentalna, a od 2.3 poboljšana podrška za slobodno-navojni CPython. To omogućuje pravi paralelizam kroz Python threading module bez GIL kontencije. Za produkciju je 2.3+ preporuka; NumPy 2.4 (2026.) uklanja veći dio eksperimentalne oznake.

Kako izbjeći "operands could not be broadcast together" grešku?

Prije problematične operacije ispišite arr.shape obiju strana. Ako je jedan niz reducirani rezultat (npr. arr.sum(axis=1)), koristite keepdims=True ili arr[:, np.newaxis] da zadržite pravu os. Pravilo palca: broadcasting se poravnava zdesna nalijevo, i svaka nepoklapajuća dimenzija mora biti veličine 1 u barem jednom operandu.