Jõudluse avamine: Põhjalik juhend Pythoni SIMD ja vektoriseerimise kohta

Arvutimaailmas on kiirus esmatähtis. Olenemata sellest, kas olete andmeteadlane, kes treenib masinõppemudelit, finantsanalüütik, kes käivitab simulatsiooni, või tarkvarainsener, kes töötleb suuri andmehulki, teie koodi tõhusus mõjutab otseselt tootlikkust ja ressursside tarbimist. Pythonil, mida kiidetakse selle lihtsuse ja loetavuse eest, on tuntud Achilleuse kand: selle jõudlus arvutusmahukates ülesannetes, eriti nendes, mis hõlmavad tsükleid. Aga mis siis, kui saaksite teostada operatsioone tervete andmekogumitega samaaegselt, mitte ühe elemendi haaval? See on vektoriseeritud arvutuste lubadus, paradigma, mida toetab protsessori funktsioon nimega SIMD.

See juhend viib teid sügavale sukeldumisele Single Instruction, Multiple Data (SIMD) operatsioonide ja vektoriseerimise maailma Pythonis. Me rändame protsessori arhitektuuri põhimõistetest kuni võimsate teekide, nagu NumPy, Numba ja Cython, praktilise rakendamiseni. Meie eesmärk on varustada teid, olenemata teie geograafilisest asukohast või taustast, teadmistega, et muuta teie aeglane, tsüklitega Pythoni kood kõrgelt optimeeritud ja suure jõudlusega rakendusteks.

Alus: Protsessori arhitektuuri ja SIMD mõistmine

Et tõeliselt hinnata vektoriseerimise võimsust, peame esmalt vaatama kapoti alla, kuidas kaasaegne keskprotsessor (CPU) töötab. SIMD maagia ei ole tarkvaraline trikk; see on riistvaraline võimekus, mis on revolutsioneerinud numbrilist andmetöötlust.

SISD-st SIMD-ni: Paradigma nihe arvutustes

Aastaid oli domineeriv arvutusmudel SISD (Single Instruction, Single Data ehk üks käsk, ühed andmed). Kujutage ette kokka, kes hoolikalt tükeldab ühte köögivilja korraga. Kokal on üks käsk ("tükelda") ja ta tegutseb ühe andmeühikuga (üks porgand). See on analoogne traditsioonilise protsessori tuumaga, mis täidab ühe käsu ühe andmeühiku kohta tsüklis. Lihtne Pythoni tsükkel, mis liidab numbreid kahest listist ükshaaval, on täiuslik näide SISD mudelist:

# Kontseptuaalne SISD operatsioon result = [] for i in range(len(list_a)): # Üks käsk (liitmine) ühel andmeühikul (a[i], b[i]) korraga result.append(list_a[i] + list_b[i])

See lähenemine on järjestikune ja tekitab iga iteratsiooniga Pythoni interpretaatorile märkimisväärset lisakoormust. Nüüd kujutage ette, et annate sellele kokale spetsiaalse masina, mis suudab ühe kangi tõmbega tükeldada terve rea neljast porgandist samaaegselt. See on SIMD (Single Instruction, Multiple Data ehk üks käsk, mitu andmehulka) olemus. Protsessor väljastab ühe käsu, kuid see opereerib korraga mitme andmepunktiga, mis on pakitud spetsiaalsesse laia registrisse.

Kuidas SIMD töötab kaasaegsetes protsessorites

Kaasaegsed protsessorid tootjatelt nagu Intel ja AMD on varustatud spetsiaalsete SIMD registrite ja käsustikega nende paralleelsete operatsioonide teostamiseks. Need registrid on palju laiemad kui üldotstarbelised registrid ja suudavad mahutada korraga mitu andmeelementi.

• SIMD registrid: Need on suured riistvaralised registrid protsessoril. Nende suurused on aja jooksul arenenud: 128-bitised, 256-bitised ja nüüd on tavalised ka 512-bitised registrid. Näiteks 256-bitine register mahutab kaheksa 32-bitist ujukomaarvu või neli 64-bitist ujukomaarvu.
• SIMD käsustikud: Protsessoritel on spetsiifilised käsud nende registritega töötamiseks. Olete ehk kuulnud neist lühenditest:
  • SSE (Streaming SIMD Extensions): Vanem 128-bitine käsustik.
  • AVX (Advanced Vector Extensions): 256-bitine käsustik, mis pakub olulist jõudluse kasvu.
  • AVX2: AVX-i laiendus rohkemate käskudega.
  • AVX-512: Võimas 512-bitine käsustik, mida leidub paljudes kaasaegsetes serveri- ja tipptasemel lauaarvutite protsessorites.

Visualiseerime seda. Oletame, et tahame liita kaks massiivi, `A = [1, 2, 3, 4]` ja `B = [5, 6, 7, 8]`, kus iga number on 32-bitine täisarv. 128-bitiste SIMD registritega protsessoril:

1. Protsessor laeb `[1, 2, 3, 4]` SIMD registrisse 1.
2. Protsessor laeb `[5, 6, 7, 8]` SIMD registrisse 2.
3. Protsessor täidab ühe vektoriseeritud "liitmise" käsu (`_mm_add_epi32` on näide tegelikust käsust).
4. Ühe kellatsükli jooksul teostab riistvara paralleelselt neli eraldi liitmist: `1+5`, `2+6`, `3+7`, `4+8`.
5. Tulemus, `[6, 8, 10, 12]`, salvestatakse teise SIMD registrisse.

See on 4x kiirem kui SISD lähenemine põhiarvutuse osas, arvestamata isegi juhiste väljastamise ja tsükli lisakoormuse massiivset vähenemist.

Jõudluse erinevus: Skalaar- vs. vektoroperatsioonid

Traditsioonilise, ühe elemendi kaupa toimuva operatsiooni termin on skalaaroperatsioon. Operatsioon terve massiivi või andmevektori peal on vektoroperatsioon. Jõudluse erinevus ei ole väike; see võib olla suurusjärkude võrra.

• Vähendatud lisakoormus: Pythonis hõlmab iga tsükli iteratsioon lisakoormust: tsükli tingimuse kontrollimine, loenduri suurendamine ja operatsiooni delegeerimine interpretaatori kaudu. Ühel vektoroperatsioonil on ainult üks delegeerimine, olenemata sellest, kas massiivis on tuhat või miljon elementi.
• Riistvaraline paralleelsus: Nagu nägime, kasutab SIMD otse paralleelseid töötlusüksusi ühe protsessori tuuma sees.
• Parem vahemälu lokaalsus: Vektoriseeritud operatsioonid loevad tavaliselt andmeid järjestikustest mälublokkidest. See on väga tõhus protsessori vahemälusüsteemile, mis on loodud andmete järjestikuste tükkidena ette laadimiseks. Juhuslikud juurdepääsumustrid tsüklites võivad põhjustada sagedasi "vahemälu möödalaskmisi", mis on uskumatult aeglased.

Pythoni viis: Vektoriseerimine NumPy abil

Riistvara mõistmine on põnev, kuid selle võimsuse rakendamiseks ei pea te kirjutama madala taseme assemblerikoodi. Pythoni ökosüsteemis on fenomenaalne teek, mis muudab vektoriseerimise kättesaadavaks ja intuitiivseks: NumPy.

NumPy: Teadusarvutuste alustala Pythonis

NumPy on Pythoni numbriliste arvutuste aluspakett. Selle põhifunktsioon on võimas N-mõõtmeline massiivi objekt, `ndarray`. NumPy tõeline maagia seisneb selles, et selle kõige kriitilisemad rutiinid (matemaatilised operatsioonid, massiivide manipuleerimine jne) ei ole kirjutatud Pythonis. Need on kõrgelt optimeeritud, eelkompileeritud C või Fortrani kood, mis on lingitud madala taseme teekidega nagu BLAS (Basic Linear Algebra Subprograms) ja LAPACK (Linear Algebra Package). Need teegid on sageli tootja poolt häälestatud, et optimaalselt ära kasutada hostprotsessori SIMD käsustikke.

Kui kirjutate NumPy's `C = A + B`, ei käivita te Pythoni tsüklit. Te delegeerite ühe käsu kõrgelt optimeeritud C funktsioonile, mis teostab liitmise SIMD käskude abil.

Praktiline näide: Pythoni tsüklist NumPy massiivini

Vaatame seda tegevuses. Liidame kaks suurt numbrite massiivi, esmalt puhta Pythoni tsükliga ja seejärel NumPy'ga. Saate seda koodi käivitada Jupyter Notebookis või Pythoni skriptis, et näha tulemusi oma masinas.

Esmalt seadistame andmed:

import time import numpy as np # Kasutame suurt hulka elemente num_elements = 10_000_000 # Puhtad Pythoni listid list_a = [i * 0.5 for i in range(num_elements)] list_b = [i * 0.2 for i in range(num_elements)] # NumPy massiivid array_a = np.arange(num_elements) * 0.5 array_b = np.arange(num_elements) * 0.2

Nüüd mõõdame puhta Pythoni tsükli aega:

start_time = time.time() result_list = [0] * num_elements for i in range(num_elements): result_list[i] = list_a[i] + list_b[i] end_time = time.time() python_duration = end_time - start_time print(f"Pure Python loop took: {python_duration:.6f} seconds")

Ja nüüd samaväärne NumPy operatsioon:

start_time = time.time() result_array = array_a + array_b end_time = time.time() numpy_duration = end_time - start_time print(f"NumPy vectorized operation took: {numpy_duration:.6f} seconds") # Arvutame kiirenduse if numpy_duration > 0: print(f"NumPy is approximately {python_duration / numpy_duration:.2f}x faster.")

Tavalisel kaasaegsel masinal on väljund vapustav. Võite oodata, et NumPy versioon on 50 kuni 200 korda kiirem. See ei ole väike optimeerimine; see on fundamentaalne muutus arvutuse teostamises.

Universaalsed funktsioonid (ufuncs): NumPy kiiruse mootor

Operatsioon, mille me just läbi viisime (`+`), on näide NumPy universaalsest funktsioonist ehk ufunc'ist. Need on funktsioonid, mis opereerivad `ndarray` massiividel elemendi-kaupa. Need on NumPy vektoriseeritud võimsuse tuum.

Ufunc'ide näited hõlmavad:

• Matemaatilised operatsioonid: `np.add`, `np.subtract`, `np.multiply`, `np.divide`, `np.power`.
• Trigonomeetrilised funktsioonid: `np.sin`, `np.cos`, `np.tan`.
• Loogilised operatsioonid: `np.logical_and`, `np.logical_or`, `np.greater`.
• Eksponentsiaal- ja logaritmilised funktsioonid: `np.exp`, `np.log`.

Saate neid operatsioone aheldada, et väljendada keerulisi valemeid ilma kunagi ekspliitset tsüklit kirjutamata. Mõelgem Gaussi funktsiooni arvutamisele:

# x on NumPy massiiv miljonist punktist x = np.linspace(-5, 5, 1_000_000) # Skalaarne lähenemine (väga aeglane) result = [] for val in x: term = -0.5 * (val ** 2) result.append((1 / np.sqrt(2 * np.pi)) * np.exp(term)) # Vektoriseeritud NumPy lähenemine (äärmiselt kiire) result_vectorized = (1 / np.sqrt(2 * np.pi)) * np.exp(-0.5 * x**2)

Vektoriseeritud versioon ei ole mitte ainult dramaatiliselt kiirem, vaid ka lühem ja loetavam neile, kes on tuttavad numbriliste arvutustega.

Põhitõdedest edasi: Broadcasting ja mälu paigutus

NumPy vektoriseerimisvõimalusi täiustab veelgi kontseptsioon nimega broadcasting. See kirjeldab, kuidas NumPy käsitleb aritmeetiliste operatsioonide ajal erineva kujuga massiive. Broadcasting võimaldab teil teostada operatsioone suure massiivi ja väiksema (nt skalaari) vahel, ilma et peaksite väiksemast massiivist looma koopiaid, mis vastaksid suurema massiivi kujule. See säästab mälu ja parandab jõudlust.

Näiteks, et skaleerida iga elementi massiivis teguriga 10, ei pea te looma massiivi, mis on täis 10-id. Kirjutate lihtsalt:

my_array = np.array([1, 2, 3, 4]) scaled_array = my_array * 10 # Skalaari 10 'broadcastimine' üle my_array

Lisaks on kriitilise tähtsusega see, kuidas andmed on mälus paigutatud. NumPy massiivid salvestatakse järjestikuses mälublokis. See on SIMD jaoks hädavajalik, kuna see nõuab andmete järjestikust laadimist oma laiadesse registritesse. Mälu paigutuse mõistmine (nt C-stiilis reasuunaline vs. Fortrani-stiilis veeru-suunaline) muutub oluliseks täiustatud jõudluse häälestamisel, eriti mitmemõõtmeliste andmetega töötamisel.

Piiride nihutamine: Täiustatud SIMD teegid

NumPy on esimene ja kõige olulisem tööriist vektoriseerimiseks Pythonis. Mida aga teha siis, kui teie algoritmi ei saa lihtsalt väljendada standardsete NumPy ufunc'ide abil? Võib-olla on teil tsükkel keerulise tingimusloogikaga või kohandatud algoritm, mida pole üheski teegis saadaval. Siin tulevad mängu täiustatud tööriistad.

Numba: Just-In-Time (JIT) kompileerimine kiiruse jaoks

Numba on tähelepanuväärne teek, mis toimib Just-In-Time (JIT) kompilaatorina. See loeb teie Pythoni koodi ja käivitamise ajal tõlgib selle kõrgelt optimeeritud masinkoodiks, ilma et peaksite kunagi Pythoni keskkonnast lahkuma. See on eriti geniaalne tsüklite optimeerimisel, mis on standardse Pythoni peamine nõrkus.

Kõige levinum viis Numba kasutamiseks on selle dekoraatori `@jit` kaudu. Võtame näite, mida on NumPy's raske vektoriseerida: kohandatud simulatsioonitsükkel.

import numpy as np from numba import jit # Hüpoteetiline funktsioon, mida on NumPy's raske vektoriseerida def simulate_particles_python(positions, velocities, steps): for _ in range(steps): for i in range(len(positions)): # Mõni keeruline, andmetest sõltuv loogika if positions[i] > 0: velocities[i] -= 9.8 * 0.01 else: velocities[i] = -velocities[i] * 0.9 # Mitteelastne põrge positions[i] += velocities[i] * 0.01 return positions # Täpselt sama funktsioon, kuid Numba JIT dekoraatoriga @jit(nopython=True, fastmath=True) def simulate_particles_numba(positions, velocities, steps): for _ in range(steps): for i in range(len(positions)): if positions[i] > 0: velocities[i] -= 9.8 * 0.01 else: velocities[i] = -velocities[i] * 0.9 positions[i] += velocities[i] * 0.01 return positions

Lihtsalt lisades dekoraatori `@jit(nopython=True)`, annate Numbale käsu see funktsioon masinkoodiks kompileerida. Argument `nopython=True` on ülioluline; see tagab, et Numba genereerib koodi, mis ei lange tagasi aeglase Pythoni interpretaatori peale. Lipp `fastmath=True` lubab Numbal kasutada vähem täpseid, kuid kiiremaid matemaatilisi operatsioone, mis võivad võimaldada automaatset vektoriseerimist. Kui Numba kompilaator analüüsib sisemist tsüklit, suudab see sageli automaatselt genereerida SIMD käske mitme osakese korraga töötlemiseks, isegi tingimusloogikaga, tulemuseks on jõudlus, mis konkureerib või isegi ületab käsitsi kirjutatud C-koodi oma.

Cython: Pythoni segamine C/C++-ga

Enne Numba populaarseks saamist oli Cython peamine tööriist Pythoni koodi kiirendamiseks. Cython on Pythoni keele superkomplekt, mis toetab ka C/C++ funktsioonide kutsumist ja C-tüüpide deklareerimist muutujatele ja klassi atribuutidele. See toimib ahead-of-time (AOT) kompilaatorina. Kirjutate oma koodi `.pyx` faili, mille Cython kompileerib C/C++ lähtefailiks, mis seejärel kompileeritakse standardseks Pythoni laiendusmooduliks.

Cythoni peamine eelis on selle pakutav peeneteraline kontroll. Lisades staatilisi tüübideklaratsioone, saate eemaldada suure osa Pythoni dünaamilisest lisakoormusest.

Lihtne Cythoni funktsioon võib välja näha selline:

# Failis nimega 'sum_module.pyx' def sum_typed(long[:] arr): cdef long total = 0 cdef int i for i in range(arr.shape[0]): total += arr[i] return total

Siin kasutatakse `cdef` C-taseme muutujate (`total`, `i`) deklareerimiseks ja `long[:]` pakub sisendmassiivi tüübitud mäluvaadet. See võimaldab Cythonil genereerida väga tõhusa C-tsükli. Ekspertidele pakub Cython isegi mehhanisme SIMD intrinsic-funktsioonide otse kutsumiseks, pakkudes ülimat kontrollitaset jõudluskriitiliste rakenduste jaoks.

Spetsialiseeritud teegid: Pilguheit ökosüsteemi

Kõrge jõudlusega Pythoni ökosüsteem on lai. Lisaks NumPy'le, Numbale ja Cythonile on olemas ka teisi spetsialiseeritud tööriistu:

• NumExpr: Kiire numbriliste avaldiste hindaja, mis võib mõnikord ületada NumPy jõudlust, optimeerides mälukasutust ja kasutades mitut tuuma avaldiste nagu `2*a + 3*b` hindamiseks.
• Pythran: Ahead-of-time (AOT) kompilaator, mis tõlgib Pythoni koodi alamhulga, eriti NumPy'd kasutava koodi, kõrgelt optimeeritud C++11-ks, võimaldades sageli agressiivset SIMD vektoriseerimist.
• Taichi: Domeenispetsiifiline keel (DSL), mis on Pythonisse sisse ehitatud suure jõudlusega paralleelarvutuste jaoks, eriti populaarne arvutigraafikas ja füüsikasimulatsioonides.

Praktilised kaalutlused ja parimad praktikad globaalsele publikule

Kõrge jõudlusega koodi kirjutamine hõlmab enamat kui lihtsalt õige teegi kasutamist. Siin on mõned universaalselt rakendatavad parimad praktikad.

Kuidas kontrollida SIMD tuge

Saadav jõudlus sõltub riistvarast, millel teie kood töötab. Sageli on kasulik teada, milliseid SIMD käsustikke antud protsessor toetab. Saate kasutada platvormiülest teeki nagu `py-cpuinfo`.

# Installige käsuga: pip install py-cpuinfo import cpuinfo info = cpuinfo.get_cpu_info() supported_flags = info.get('flags', []) print("SIMD Support:") if 'avx512f' in supported_flags: print("- AVX-512 supported") elif 'avx2' in supported_flags: print("- AVX2 supported") elif 'avx' in supported_flags: print("- AVX supported") elif 'sse4_2' in supported_flags: print("- SSE4.2 supported") else: print("- Basic SSE support or older.")

See on globaalses kontekstis ülioluline, kuna pilvandmetöötluse instantsid ja kasutajate riistvara võivad piirkonniti oluliselt erineda. Riistvara võimekuse teadmine aitab teil mõista jõudlusomadusi või isegi kompileerida koodi spetsiifiliste optimeerimistega.

Andmetüüpide olulisus

SIMD operatsioonid on väga spetsiifilised andmetüüpidele (`dtype` NumPy's). Teie SIMD registri laius on fikseeritud. See tähendab, et kui kasutate väiksemat andmetüüpi, mahutate ühte registrisse rohkem elemente ja töötlete ühe käsuga rohkem andmeid.

Näiteks 256-bitine AVX register mahutab:

• Neli 64-bitist ujukomaarvu (`float64` või `double`).
• Kaheksa 32-bitist ujukomaarvu (`float32` või `float`).

Kui teie rakenduse täpsusnõuded on täidetavad 32-bitiste ujukomaarvudega, võib NumPy massiivide `dtype` muutmine `np.float64`-st (paljudes süsteemides vaikimisi) `np.float32`-ks potentsiaalselt kahekordistada teie arvutuslikku läbilaskevõimet AVX-toega riistvaral. Valige alati väikseim andmetüüp, mis tagab teie probleemi jaoks piisava täpsuse.

Millal MITTE vektoriseerida

Vektoriseerimine ei ole imerohi. On stsenaariume, kus see on ebaefektiivne või isegi kahjulik:

• Andmetest sõltuv kontrollvoog: Tsüklid keeruliste `if-elif-else` harudega, mis on ettearvamatud ja viivad lahknevate täitmisteedeni, on kompilaatoritel väga raske automaatselt vektoriseerida.
• Järjestikused sõltuvused: Kui ühe elemendi arvutus sõltub eelmise elemendi tulemusest (nt mõnedes rekursiivsetes valemites), on probleem oma olemuselt järjestikune ja seda ei saa SIMD-ga paralleelistada.
• Väikesed andmekogumid: Väga väikeste massiivide (nt vähem kui tosin elementi) puhul võib vektoriseeritud funktsioonikutse seadistamise lisakoormus NumPy's olla suurem kui lihtsa, otsese Pythoni tsükli maksumus.
• Ebaregulaarne mälukasutus: Kui teie algoritm nõuab mälus ringi hüppamist ettearvamatul mustril, nurjab see protsessori vahemälu ja ettelaadimise mehhanismid, tühistades SIMD peamise eelise.

Juhtumiuuring: Pilditöötlus SIMD abil

Kinnistame need kontseptsioonid praktilise näitega: värvilise pildi teisendamine halltoonidesse. Pilt on lihtsalt 3D numbrite massiiv (kõrgus x laius x värvikanalid), mis teeb sellest ideaalse kandidaadi vektoriseerimiseks.

Standardne heledusvalem on: `Halltoon = 0.299 * R + 0.587 * G + 0.114 * B`.

Oletame, et meil on pilt laaditud NumPy massiivina kujuga `(1920, 1080, 3)` ja `uint8` andmetüübiga.

1. meetod: Puhas Pythoni tsükkel (aeglane viis)

def to_grayscale_python(image): h, w, _ = image.shape grayscale_image = np.zeros((h, w), dtype=np.uint8) for r in range(h): for c in range(w): pixel = image[r, c] gray_value = 0.299 * pixel[0] + 0.587 * pixel[1] + 0.114 * pixel[2] grayscale_image[r, c] = int(gray_value) return grayscale_image

See hõlmab kolme pesastatud tsüklit ja on kõrge eraldusvõimega pildi puhul uskumatult aeglane.

2. meetod: NumPy vektoriseerimine (kiire viis)

def to_grayscale_numpy(image): # Määratle kaalud R, G, B kanalitele weights = np.array([0.299, 0.587, 0.114]) # Kasuta skalaarkorrutist piki viimast telge (värvikanalid) grayscale_image = np.dot(image[...,:3], weights).astype(np.uint8) return grayscale_image

Selles versioonis teostame skalaarkorrutise. NumPy `np.dot` on kõrgelt optimeeritud ja kasutab SIMD-d R, G, B väärtuste korrutamiseks ja summeerimiseks paljude pikslite jaoks samaaegselt. Jõudluse erinevus on nagu öö ja päev – kergesti 100x kiirem või rohkemgi.

Tulevik: SIMD ja Pythoni arenev maastik

Kõrge jõudlusega Pythoni maailm areneb pidevalt. Kurikuulsale globaalsele interpretaatori lukule (GIL), mis takistab mitme lõime paralleelset Pythoni baitkoodi täitmist, esitatakse väljakutseid. Projektid, mille eesmärk on muuta GIL valikuliseks, võivad avada uusi võimalusi paralleelsuseks. Siiski töötab SIMD tuuma-alasel tasemel ja GIL seda ei mõjuta, mis teeb sellest usaldusväärse ja tulevikukindla optimeerimisstrateegia.

Kuna riistvara muutub mitmekesisemaks, spetsialiseeritud kiirendite ja võimsamate vektoriüksustega, muutuvad veelgi olulisemaks tööriistad, mis abstraheerivad riistvara üksikasju, pakkudes samal ajal jõudlust – nagu NumPy ja Numba. Järgmine samm SIMD-st edasi protsessori sees on sageli SIMT (Single Instruction, Multiple Threads) GPU-l ja teegid nagu CuPy (NumPy asendaja NVIDIA GPU-del) rakendavad samu vektoriseerimispõhimõtteid veelgi massiivsemal skaalal.

Kokkuvõte: Võtke vektor omaks

Oleme rännanud protsessori südamest Pythoni kõrgetasemeliste abstraktsioonideni. Peamine järeldus on see, et kiire numbrilise koodi kirjutamiseks Pythonis peate mõtlema massiivides, mitte tsüklites. See on vektoriseerimise olemus.

Võtame oma teekonna kokku:

• Probleem: Puhtad Pythoni tsüklid on numbriliste ülesannete jaoks aeglased interpretaatori lisakoormuse tõttu.
• Riistvaraline lahendus: SIMD võimaldab ühel protsessori tuumal teostada sama operatsiooni mitme andmepunktiga samaaegselt.
• Peamine Pythoni tööriist: NumPy on vektoriseerimise nurgakivi, pakkudes intuitiivset massiiviobjekti ja rikkalikku ufunc'ide teeki, mis täidetakse optimeeritud, SIMD-toega C/Fortrani koodina.
• Täiustatud tööriistad: Kohandatud algoritmide jaoks, mida ei saa NumPy's kergesti väljendada, pakub Numba JIT-kompileerimist teie tsüklite automaatseks optimeerimiseks, samas kui Cython pakub peeneteralist kontrolli, segades Pythonit C-ga.
• Mõtteviis: Tõhus optimeerimine nõuab andmetüüpide, mälumustrite mõistmist ja õige tööriista valimist.

Järgmine kord, kui leiate end kirjutamas `for`-tsüklit suure hulga numbrite töötlemiseks, peatuge ja küsige: "Kas ma saan seda väljendada vektoroperatsioonina?" Seda vektoriseeritud mõtteviisi omaks võttes saate avada kaasaegse riistvara tõelise jõudluse ja tõsta oma Pythoni rakendused uuele kiiruse ja tõhususe tasemele, olenemata sellest, kus maailmas te programmeerite.