Unutar AI Runtime-a: PyTorch, C++, CUDA i dalje

Početna » piton » Unutar AI Runtime-a: PyTorch, C++, CUDA i dalje

Moderna AI okruženja za izvršavanje nalaze se na raskršću Pythona, C++, JavaScripta i CUDA-pokretanih GPU-a, a PyTorch je postao de facto primjer kako efikasno povezati sve ove svjetove. Iza naizgled jednostavnih Python API-ja krije se sofisticirana C++ jezgra, mehanizam za automatsku diferencijaciju, JIT kompajler, CUDA integracija, pa čak i eksperimentalni okruženja poput NVIDIA-inog VibeTensora koja istražuju koliko daleko kod generiran umjetnom inteligencijom može ići.

Ako gradite visokoperformansne AI sisteme, razumijevanje načina na koji funkcionišu PyTorch-ov C++ runtime, CUDA backend, TorchScript, C++ ekstenzije i upravljanje memorijom je razlika između „radi“ i „skalira i leti“. U ovom vodiču prolazimo kroz te slojeve, objašnjavamo kako se oni odnose na Python i JavaScript okruženja i povezujemo ih s CUDA alatima i novim pristupima kao što su okruženja za izvršavanje potpomognuta umjetnom inteligencijom.

PyTorch kao runtime okruženje: od Python API-ja do C++ i CUDA-e

Na prvi pogled PyTorch izgleda kao čista Python biblioteka, ali u stvarnosti je to slojevito okruženje za izvršavanje čija je jezgra napisana u C++ s bliskom integracijom s CUDA-om i optimiziranim bibliotekama kao što su cuDNN, NCCL, oneDNN i Intel MKL. Python uglavnom orkestrira operacije, dok se teški posao obavlja izvornim kodom na CPU-u i GPU-u.

Gledano u širem kontekstu, PyTorch se može smatrati sastavljenim od nekoliko ključnih komponenti: tenzorske biblioteke, autograd mehanizma, uslužnih programa za neuronske mreže, JIT kompajlera (TorchScript), pomoćnih programa za višestruku obradu i skupa alata za učitavanje i serijalizaciju podataka. Zajedno pružaju i tenzorski interfejs sličan NumPy-u i fleksibilnu platformu za duboko učenje.

Javni C++ API grubo odražava ovu arhitekturu i podijeljen je na ATen, Autograd, C++ Frontend, TorchScript povezivanja i C++ proširenja, od kojih svako adresira određeni sloj računskog steka. Razumijevanje ovih dijelova je ključno ako planirate ići dalje od Pythona, integrirati se s prilagođenim C++ ili CUDA kernelima ili izložiti svoje modele okruženjima poput Node.js-a ili runtime-ova preglednika putem povezivanja.

Ispod svega, PyTorch koristi NVIDIA CUDA Toolkit, koji pruža kompajler, GPU-ubrzane matematičke biblioteke, alate za otklanjanje grešaka i profiliranje, te CUDA runtime koji koriste torch.cuda i prilagođena proširenja. Ovaj set alata je ono što u konačnici omogućava PyTorchu da zasiti moderne GPU-ove u podatkovnim centrima, radnim stanicama i ugrađenim sistemima.

ATen: okosnica tenzora i operatora

ATen je tenzorska biblioteka niskog nivoa koja podržava gotovo svaku tenzorsku operaciju u PyTorchu, bez obzira da li je pozivate iz Pythona ili iz C++. To definiše jezgro at::Tensor tip plus stotine matematičkih, indeksnih, linearno-algebarskih i redukcijskih operacija implementiranih i za CPU i za GPU.

Svaki ATen tenzor nosi metapodatke uređaja i tipa podataka, a slanje na CPU ili CUDA implementacije se odvija dinamički na osnovu tih metapodataka, tako da isti C++ simbol operatora može besprijekorno raditi na različitim backend-ovima. Ovo vam omogućava premještanje podataka putem .to("cuda") or .cuda() u Pythonu bez promjene stvarne operacije koju pozivate.

Iako se ATen može koristiti direktno putem C++ API-ja (sve se nalazi u at:: imenski prostor), u tipičnim radnim procesima dodirujete ATen samo indirektno putem modula višeg nivoa kao što su torch, torch.nn ili C++ Frontend. Ipak, za kod kritičan za performanse ili prilagođene kernele, rad na ATen nivou je često mjesto gdje imate najveću kontrolu.

ATenov dizajn naglašava brze vektorizirane kernele, snažno ubrzanje GPU-a i dobre performanse CPU-a, što ga čini pogodnim i za istraživačke prototipe i za produkcijska opterećenja. Interno, oslanja se na biblioteke dobavljača (MKL, cuBLAS, cuDNN, itd.) gdje god to ima smisla, umjesto ponovnog izmišljanja dobro optimizirane matematike.

Autograd: automatska diferencijacija na vrhu tenzora

Autograd je podsistem koji proširuje ATen tenzore praćenjem gradijenta, pretvarajući čistu tenzorsku matematiku u grafove diferencijalnih računanja. Kada je autograd omogućen, operacije na tenzorima generiraju interni graf koji se može pregledavati unatrag kako bi se izračunali gradijenti za obuku.

Autogradni mehanizam je izgrađen oko koncepta koji se često naziva "traka" ili graf diferencijacije u obrnutom modu, u kojem se međuoperacije snimaju tokom prolaska unaprijed i reproduciraju unazad po zahtjevu. Pozivanje .backward() Na tenzoru listova s ​​gradijentom, ovaj obilazak grafa akumulira derivate u parametre.

Važna suptilnost je da sirovo at::Tensor Tip iz ATen-a nije diferencijabilan po defaultu, tako da za tenzore koji su svjesni gradijenta u C++ koristite torch:: funkcije fabrike imenskog prostora (kao što su torch::ones) umjesto at:: fabrika. Prvi kreira tenzore povezane s autogradnim sistemom, dok drugi ostaje čisto numerički.

Ovo odvajanje je namjerno: omogućava vam da odaberete da li treba postojati dodatno opterećenje autogradacije, što je ključno za putanje samo s inferencijom ili putanje s niskom latencijom gdje gradijenti nisu potrebni. Ista razlika je sačuvana u C++ Frontendu i u TorchScript grafovima.

C++ Frontend: izgradnja i obučavanje modela bez Pythona

PyTorch C++ Frontend je API visokog nivoa koji odražava veliki dio torch.nn, torch.optim, torch.utils.data i srodne Python module, ali je implementiran kao idiomatski moderni C++. Dizajniran je za scenarije u kojima su vam potrebne izvorne performanse, čvršća integracija s postojećim C++ sistemima ili okruženje za implementaciju bez Pythona.

Koristeći C++ Frontend, definirate modele kao hijerarhije modula u istom duhu kao torch.nn.Module, s parametrima registrovanim unutar klasa i sastavljenim u veće mreže. Postoji „standardna biblioteka“ slojeva: konvolucije, RNN-ovi, normalizacija serija, linearni slojevi i mnogi drugi koji se ponašaju gotovo identično svojim Python ekvivalentima.

Frontend također pruža API za optimizaciju s klasičnim algoritmima poput SGD-a, Adama i RMSpropa, apstrakcijama skupova podataka i učitavačima podataka sposobnim za strimovanje podataka iz mnogih CPU niti, te uslužnim programima za serijalizaciju kontrolnih tačaka. U suštini, ako znate kako napisati petlju za učenje u Pythonu (i izbjeći probleme poput prekomjerno naspram nedovoljnog prilagođavanja), prenošenje na C++ Frontend je uglavnom mehaničko.

Na sistemima sa više grafičkih procesora (Multi-GPU), C++ Frontend pruža pomoćne programe za automatsku paralelizaciju modela preko nekoliko CUDA uređaja na sličan način kao torch.nn.parallel.DataParallel. Dodatno uključuje kod podrške za povezivanje C++ modela nazad u Python pomoću pybind11 kada želite hibridni radni tok.

TorchScript: JIT kompilacija i izvršavanje bez Pythona

TorchScript je statički analiziran podskup Pythona i PyTorch API-ja koji se može kompajlirati, optimizirati i serijalizirati za implementaciju. Konceptualno, to je mali programski jezik dizajniran oko tenzorskih operacija i konstrukata toka upravljanja koji se obično koriste u modelima.

Sa strane C++-a, TorchScript nudi tri primarne mogućnosti: učitavanje i pokretanje serijaliziranih modela kreiranih u Pythonu, definiranje prilagođenih operatora koji proširuju standardnu ​​biblioteku TorchScript-a i kompajliranje izvornog koda TorchScript-a direktno iz C++-a. Svemu ovome je moguće pristupiti putem torch::jit imenskog prostora.

Uobičajeni obrazac produkcije je kreiranje i obučavanje modela u potpunosti u Pythonu, njihov izvoz kao TorchScript modula, a zatim ugradnja tih modula u C++ servis koji izvodi zaključivanje s malom latencijom bez oslanjanja na Python runtime. Ovo je posebno atraktivno u kontejneriziranim mikroservisima i backendovima osjetljivim na performanse.

Napredni korisnici mogu registrirati prilagođene operatore, uključujući CUDA-akcelerirane kernele, koje TorchScript može pozivati ​​kao da su ugrađene operacije; ove prilagođene operacije se mogu serijalizirati i rade u Python i C++ kontekstima kada su pravilno registrovane. Konačno, funkcije poput torch::jit::compile omogućavaju vam da kreirate TorchScript module u hodu iz C++ stringova ili AST-sličnih konstrukcija.

C++ i CUDA ekstenzije: uključivanje vlastitih kernela

PyTorch-ov mehanizam proširenja C++-a nudi jednostavan način ubrizgavanja prilagođenog C++ i CUDA koda u redovne Python tokove rada, a istovremeno iskorištava prednosti ATen-a, autograd-a i dispatcher-a. Ova proširenja obično koristite za implementaciju prilagođenih operatora ili ubrzavanje specijaliziranih radnih opterećenja koja ugrađeni operatori ne podržavaju dobro.

Sam API za proširenje ne uvodi novu tenzorsku semantiku; umjesto toga, povezuje vaš kod sa Python-ovim sistemom pakovanja (putem setuptools-a ili alternativnih backend-ova) i sa PyTorch-ovim JIT alatima za kompilaciju tako da se kerneli kompajliraju sa ispravnim ABI i link flag-ovima. Ispod haube, pomagači poput CUDAExtension dodajte standardni kod za nvcc, uključite putanje i opcije linkova.

Na strani povezivanja, pybind11 se obično koristi za izlaganje C++ funkcija ili klasa kao Python simbola, a ta povezivanja interaguju sa torch::Tensor objekti koji dijele memoriju sa Python tenzorima. Ovo svodi kopiranje podataka na minimum i omogućava autograd-u da vidi nove operatore ako ispravno implementirate prolaze unazad.

Nakon kompajliranja, ova proširenja se ponašaju kao obični Python moduli, mogu se uvesti iz skripti za obuku, pa čak i lijepo funkcioniraju s TorchScript-om ako registrirate operacije za JIT upotrebu. Za istraživanja koja se intenzivno bave CUDA-om, ovaj put je često najbrži način za eksperimentiranje s novim jezgrama, a istovremeno očuvanje produktivnosti Pythona.

Premošćavanje Torch i CUDA biblioteka: GEMM primjer sa CUTLASS-om

Kada trebate iskoristiti pune performanse NVIDIA GPU-ova, uobičajeno je povezati PyTorch-ov tensor runtime sa visoko podešenim CUDA C++ bibliotekama kao što je CUTLASS ili prilagođenim kernelima koji nisu dostupni kao ugrađene operacije. Klasičan primjer je pisanje optimiziranog GEMM (matrično množenje) operatora.

Opći obrazac je napisati C++ omotačku funkciju koja prihvata torch::Tensor ulaze, izdvaja njihove oblike, tipove podataka i pokazivače podataka, te ih prosljeđuje u CUTLASS ili neku drugu CUDA bibliotečku funkciju. Dimenzije tenzora se dobijaju putem .sizes(), tipovi podataka putem .dtype()i sirove pokazivače putem .data_ptr() (opciono u kombinaciji sa reinterpret_cast ako su vam potrebni prilagođeni tipovi kao što su cutlass::half_t).

Budući da se parametri šablona u C++ razrješavaju u vrijeme kompajliranja, dok su tipovi podataka tenzora poznati tek u vrijeme izvršavanja, omotač obično sadrži logiku uvjetnog slanja koja odabire ispravnu instancu šablona (za float16, float32, itd.) na osnovu dtipova tenzora. Za složene hijerarhije predložaka, ljudi često generiraju taj standardni kod koristeći Python skripte kako bi izbjegli ručno pisanje mnogih grana.

Validacija ulaza je ključna: tenzori moraju imati kompatibilne oblike za GEMM, nalaziti se na CUDA uređaju i biti susjedni u memoriji jer CUTLASS očekuje da susjedni elementi budu postavljeni sekvencijalno. Možete provjeriti susjednost sa .is_contiguous() i popravite to pomoću .contiguous(), kopirajući rezultate u originalni tenzor ako je potrebno kada je potrebna semantika na licu mjesta.

Da biste se uskladili sa PyTorch stilom, obično izlazne tenzore učinite opcionalnim koristeći c10::optional<torch::Tensor>, a ako nijedan nije naveden, dodjeljujete novi s pravom device i dtype korištenjem ATen-ovih fabričkih funkcija. Vraćanje tog tenzora održava API simetričnim s ugrađenim operatorima kao što je torch.mm.

Povezivanje i izgradnja CUDA ekstenzija pomoću PyBind11 i setuptools-a

Kada je C++ omotač spreman, morate ga povezati s Pythonom i kompajlirati, gdje na scenu stupaju pybind11 i PyTorch-ovi alati za izgradnju. Modul pybind11 obično deklariše funkciju kao što je m.def("cutlass_gemm", &cutlass_gemm, "GEMM with CUTLASS", py::arg("A"), py::arg("B"), py::arg("out") = py::none()); da biste svoju C++ funkciju izložili Python kodu.

Na strani izgradnje, obični setuptools ne razumije izvorno nvcc, tako da PyTorch isporučuje pomoćnu klasu pod nazivom CUDAExtension koji automatski konfiguriše putanje uključivanja, CUDA zastavice kompilacije i povezivanje sa libtorch-om. Prođeš svoj .cpp i .cu izvori za CUDAExtension slično kao standardni alati za podešavanje Extension.

Kada se ekstenzija instalira, vaš Python kod je može uvesti kao regularni modul, i od tog trenutka poziv vaše prilagođene operacije izgleda gotovo identično pozivu ugrađenih PyTorch operatora. Zadržavate mogućnost interakcije sa autograd, TorchScript i CUDA streamovima sve dok poštujete PyTorch konvencije.

Ako ne želite da se oslanjate na PyTorch za samu izgradnju (na primjer, ako vaša CUDA biblioteka cilja više frameworkova), možete koristiti alternativne backendove poput scikit-build-core sa CMake-om ili ručno konfigurirati nvcc integraciju u setuptools-u, ali CUDAExtension je daleko najjednostavniji za korisnike PyTorcha.

CUDA Toolkit: kompajler, biblioteke i sloj za izvršavanje

NVIDIA CUDA Toolkit podržava PyTorch-ovo GPU runtime okruženje pružajući C/C++ kompajler, numeričke biblioteke optimizovane za GPU, alate za otklanjanje grešaka i profilisanje, te niskonivojsko runtime okruženje koje koristi... torch.cuda i prilagođena proširenja. Cilja širok spektar platformi, od ugrađenih ploča do cloud klastera.

Delegiranjem teških zadataka linearne algebre, konvolucije i FFT-a CUDA bibliotekama, PyTorch koristi visoko podešene implementacije koje poznaju specifičnosti svake GPU arhitekture i mogu otključati performanse daleko izvan naivnog GPU koda. Za mnoga AI opterećenja, ovo je glavni razlog zašto se PyTorch tako dobro skalira na novim generacijama GPU-a.

Programeri koji pišu CUDA ekstenzije i dalje obično pišu C++ kernele kompajlirane s nvcc-om, a njihovo povezivanje s PyTorch-om znači da se mogu orkestrirati iz Python, C++ ili čak JavaScript runtime okruženja koja pozivaju dijeljene biblioteke. Ovo je idealno mjesto za timove koji imaju naslijeđene C++ ili CUDA kodne baze, ali ih žele izložiti putem API-ja u stilu PyTorch-a.

torch.cuda: odabir uređaja, precizni načini rada i model izvršavanja

The torch.cuda Modul je korisnički pristupnik CUDA-i iz PyTorcha, koji upravlja odabirom uređaja, upravljanjem streamom, alokacijom memorije i konfiguracijom vremena izvođenja. Svi CUDA tenzori se podrazumijevaju na trenutno odabrani uređaj, što možete promijeniti pomoću torch.cuda.device kao upravitelj konteksta ili eksplicitnim ciljanjem određenih uređaja.

Operacije koje se izvode putem više grafičkih procesora (Cross-GPU) su namjerno ograničene: osim operacija sličnih kopiranju (kao što su copy_(), to(), cuda()), većina operacija ne može obuhvatiti uređaje osim ako nije omogućen peer-to-peer pristup memoriji, kako bi se spriječili suptilni problemi s performansama i ispravnošću. Tenzori prate svoj uređaj, a izlazi ostaju na istom uređaju kao i njihovi ulazi.

PyTorch nudi detaljne kontrole nad preciznošću izračunavanja na CUDA backendovima, uključujući TensorFloat‑32 (TF32) na Ampere i novijim GPU-ima, smanjena smanjenja preciznosti za FP16 i BF16 GEMM-ove, te opcije za punu FP16 akumulaciju kada to hardver podržava. Ove zastavice se mogu podešavati za svaki backend (CUDA, cuDNN), pa čak i za svakog operatora, što vam omogućava da žrtvujete numeričku tačnost za brzinu.

GPU operacije su podrazumevano asinhrone: kada pozovete CUDA operaciju, ona se stavlja u red čekanja na streamu uređaja, ali se može izvršiti kasnije, što omogućava preklapanje CPU izračunavanja, transfera i kernela. Ispravno tempiranje takvog koda zahtijeva ili eksplicitno torch.cuda.synchronize() pozivi ili korištenje CUDA događaja; varijable okruženja poput CUDA_LAUNCH_BLOCKING=1 su korisni za otklanjanje grešaka, ali ne i za performanse.

Za naprednije slučajeve upotrebe, PyTorch nudi CUDA streamove i događaje, omogućavajući vam orkestriranje više paralelnih streamova, selektivnu sinhronizaciju i osiguravanje da tenzori ne budu dealocirani prije nego što se završi sav neriješeni posao na njima. Funkcije poput record_stream() i wait_stream() su centralni u ovim obrascima.

CUDA upravljanje memorijom, alokatori i dugmići za podešavanje

PyTorch koristi alokator keširanja na CUDA uređajima kako bi često alokirao i brzo oslobađao memorije bez stalne sinhronizacije sa GPU-om (vidi Kako memorija funkcioniše u C++-u za povezane koncepte). Umjesto pozivanja cudaMalloc i cudaFree Za svaki tenzor, čuva skupove memorijskih blokova koji se mogu ponovo koristiti u različitim alokacijama.

Kao rezultat toga, alati poput nvidia-smi često prikazuju više memorije "u upotrebi" nego što je tenzori zapravo zauzimaju, jer je dio te memorije rezerviran od strane alokatora, ali trenutno nije dodijeljen. Funkcije kao što su memory_allocated(), max_memory_allocated(), memory_reserved() i max_memory_reserved() pomoći u razlikovanju korištenja aktivnog tenzora od keširanog kapaciteta.

Neiskorištenu keširanu memoriju možete osloboditi pomoću torch.cuda.empty_cache(), koji vraća blokove CUDA drajveru, ali ne oslobađa memoriju koju još uvijek posjeduju aktivni tenzori. Za dublji pregled, memory_stats() i memory_snapshot() pružaju informacije o alokaciji niskog nivoa koje mogu biti ključne u borbi protiv fragmentacije ili OOM-a.

Ponašanje alokatora se može podesiti putem PYTORCH_ALLOC_CONF (ili njegov alias PYTORCH_CUDA_ALLOC_CONF) varijabla okruženja, koja vam omogućava da odaberete implementaciju pozadinskog sistema, podesite veličine podjele, strategije zaokruživanja, pragove sakupljanja smeća i još mnogo toga. Također postoji opcija korištenja CUDA-e. cudaMallocAsyncalokator zasnovan na .NET-u kao alternativni backend na podržanim kompletima alata.

Pored ugrađenog alokatora, PyTorch podržava i priključne CUDA alokatore putem dijeljenih biblioteka napisanih u C ili C++. Oni se mogu integrirati s vanjskim sistemima kao što su NCCL-ovi NVLink Switch Reductions ili prilagođene strategije smještaja memorije CPU-GPU-a, a izloženi su u Pythonu putem... torch.cuda.memory.CUDAPluggableAllocator i torch.cuda.MemPool.

CUDA grafovi i najbolje prakse usmjerene na performanse

CUDA grafovi su moćna funkcija za smanjenje opterećenja CPU-a snimanjem serije GPU operacija kao grafa i njihovim ponavljanjem jednim pozivom za pokretanje. PyTorch integriše ovu funkciju putem torch.cuda.CUDAGraph, u torch.cuda.graph upravitelj konteksta i torch.cuda.make_graphed_callables() pomagač.

Snimanje grafa najbolje funkcionira kada vaše radno opterećenje ima statičke oblike, deterministički tok kontrole i nema sinhronizacije CPU-GPU u aktivnoj putanji. Tokom snimanja, rad GPU-a se snima umjesto da se izvršava, a prilikom ponovnog prikazivanja se izvršava potpuno isti niz kernela, čitajući sa i pišući na iste virtuelne adrese.

Budući da snimljeni graf pretpostavlja fiksne tenzorske rasporede, PyTorch alocira privatne memorijske bazene grafa čiji su životni vijekovi vezani za CUDAGraph objekta i tenzora kreiranih unutar snimanja. Ovi skupovi se mogu dijeliti između povezanih grafova radi uštede memorije, pod uslovom da garantujete konzistentan redoslijed izvršavanja i da nema konkurentnosti.

U distribuiranim postavkama, posebno sa DistributedDataParallel i NCCL, integracija CUDA Graph-a zahtijeva određenu pažnju, kao što je osiguranje kompatibilnih NCCL verzija, onemogućavanje određenih rukovatelja asinhronim greškama i rukovanje koracima zagrijavanja kako bi se omogućilo sigurno snimanje kolektiva. Ako se pravilno uradi, može dramatično povećati propusnost za stabilne petlje obuke produkcijskog nivoa.

Pored grafova, dokumentacija PyTorcha preporučuje korištenje pričvršćene CPU memorije za brži prijenos s hosta na GPU, preferirajući DistributedDataParallel više DataParallel ili naivno multiprocesiranje za obuku više grafičkih procesora i pisanje koda neovisnog o uređaju koji se jednostavno prebacuje između CPU-a i GPU-a putem torch.device. Ove prakse zajedno vam pomažu da pronađete idealnu ravnotežu između ergonomije i performansi.

Instalacija, opcije izgradnje i hardverski backendovi

PyTorch se može instalirati putem Conde, pip wheels-a ili iz izvornog koda, s unaprijed izgrađenim binarnim datotekama dostupnim za tipične Linux, macOS i Windows postavke i specijaliziranim verzijama za NVIDIA Jetson platforme. Svaka distribucija cilja određene CUDA verzije prema objavljenoj matrici podrške.

Prilikom izgradnje iz izvornog koda, potreban vam je Python 3.10 ili noviji, moderni C++17 kompatibilan kompajler (na primjer GCC 9.4+ na Linuxu) i odgovarajući skup alata na Windowsu (Visual Studio ili samostalni alati za izgradnju). Možete kompajlirati sa ili bez podrške za CUDA, ROCm (za AMD GPU-ove) ili Intel GPU instaliranjem odgovarajućih SDK-ova i postavljanjem zastavica kao što su USE_CUDA, USE_ROCM i USE_XPU.

Za verzije koje koriste samo CPU, posebna pažnja može biti potrebna za povezivanje željene OpenMP implementacije (često Intel OpenMP) i BLAS biblioteka, posebno na Windowsu gdje bi CMake inače mogao da se vrati na podrazumevano MSVC okruženje za izvršavanje. Za CUDA verzije, dodatne biblioteke poput Magme ili oneDNN mogu se uvesti kako bi se ubrzale određene operacije.

PyTorch također nudi Docker slike s unaprijed konfiguriranim CUDA i cuDNN okruženjima (pogledajte uvod u kontejnerizaciju); ove slike se oslanjaju na segmente dijeljene memorije za višeprocesorske učitavače podataka, tako da često trebate povećati dijeljenu memoriju putem --ipc=host or --shm-size on docker run. Obavezno je osigurati da su verzije vaših Docker i NVIDIA drajvera kompatibilne s verzijom CUDA alata.

Sama dokumentacija je izgrađena pomoću Sphinxa i prilagođene teme, te se može generirati u HTML ili PDF formatu ako instalirate potrebne Python zavisnosti, TeX alate i PyTorch paket u lokalnom okruženju. Ovo je korisno kada dodajete nove module ili dokumentacijske nizove i želite ih pregledati prije nego što doprinesete izvornom projektu.

VibeTensor: Izvršno okruženje generirano umjetnom inteligencijom inspirirano PyTorchom

NVIDIA-in VibeTensor projekat ilustruje drugačiji ugao gledanja na okruženja za izvršavanje: to je eksperimentalno okruženje za izvršavanje, konceptualno slično PyTorchu, čiju su kodnu bazu uglavnom generirali AI agenti pod ljudskim nadzorom. Ideja je vidjeti koliko daleko se može ići "vibracijsko kodiranje" - oslanjanje na AI asistente za pisanje koda - za složeni sistem.

VibeTensorova arhitektura kombinuje API prilagođen Pythonu i JavaScriptu sa C++ runtime jezgrom, prilagođenim alokatorima tenzorske memorije, autograd mehanizmom, dispečerom, naprednim podsistemom za indeksiranje i CUDA-vođenom keš memorijom, a sve je usmjereno na Linux x86_64 i NVIDIA GPU-ove. Postoji čak i eksperimentalni Fabric podsistem koji koristi CUDA P2P za izvršavanje na više GPU-ova.

Projekat takođe podržava eksterne GPU dodatke, kao što je backend za nadolazeću Blackwell arhitekturu (SM100/SM103), i pokazuje da se ovi dodaci mogu pokrenuti pomoću koda generisanog pomoću vještačke inteligencije, sve dok ljudi obezbede ograničenja i validaciju. Iako performanse i funkcije trenutno ne konkurišu PyTorchu, projekat služi kao dokaz koncepta za programiranje sistema potpomognutih vještačkom inteligencijom.

Tokom otprilike dva mjeseca razvoja, ljudski inženjeri su se uglavnom fokusirali na definiranje zadataka, ograničenja i petlji pregleda, dok su agenti umjetne inteligencije iterativno proizvodili kod, izvršavali poređenja, kompajlirali, testirali i usavršavali implementacije. Ovaj hibridni radni tok naglašava i snagu i ograničenja vještačke inteligencije: većina standardnih i repetitivnih obrazaca može se automatizirati, ali ispravnost i arhitektura i dalje zahtijevaju ljudsku prosudbu.

Za praktičare, VibeTensor je manje zamjena za PyTorch, a više istraživanje kako bi mogla izgledati buduća okruženja kada je vještačka inteligencija duboko uključena u njihov dizajn i evoluciju, posebno u okruženjima koja miješaju Python, JavaScript, C++ i CUDA. To nagovještava svijet u kojem se specijalizirana okruženja za nišne zadatke mogu pokretati mnogo brže nego prije.

Spajanjem svih ovih dijelova - PyTorchovog tensor i autograd jezgra, C++ Frontenda, TorchScript, C++ i CUDA ekstenzija, fino podešene CUDA integracije i eksperimentalnih napora poput VibeTensora - dobija se slika AI runtime ekosistema gdje su Python, C++, JavaScript i CUDA čvrsto isprepleteni, i gdje programeri mogu fluidno birati sloj koji najbolje balansira produktivnost, kontrolu i sirove performanse za njihovo određeno radno opterećenje.