Binnen de AI-runtime: PyTorch, C++, CUDA en verder

Home » Python » Binnen de AI-runtime: PyTorch, C++, CUDA en verder

Moderne AI-runtimeomgevingen bevinden zich op het kruispunt van Python, C++, JavaScript en CUDA-gebaseerde GPU's, en PyTorch is uitgegroeid tot hét voorbeeld van hoe al deze werelden efficiënt met elkaar verbonden kunnen worden. Achter de ogenschijnlijk eenvoudige Python API's schuilt een geavanceerde C++-kern, een automatische differentiatie-engine, een JIT-compiler, CUDA-integratie en zelfs experimentele runtimes zoals NVIDIA's VibeTensor, die onderzoeken hoe ver door AI gegenereerde code kan gaan.

Als je krachtige AI-systemen bouwt, is het begrijpen van de werking van PyTorch's C++-runtime, CUDA-backend, TorchScript, C++-extensies en geheugenbeheer essentieel. Dit is het verschil tussen "het werkt" en "het schaalt en presteert razendsnel". In deze handleiding doorlopen we die lagen, leggen we uit hoe ze zich verhouden tot Python- en JavaScript-omgevingen en verbinden we ze met CUDA-tools en nieuwe benaderingen zoals AI-ondersteunde runtimes.

PyTorch als runtime: van Python API naar C++ en CUDA

Op het eerste gezicht lijkt PyTorch een pure Python-bibliotheek, maar in werkelijkheid is het een gelaagde runtime waarvan de kern in C++ is geschreven, met een nauwe integratie met CUDA en geoptimaliseerde bibliotheken zoals cuDNN, NCCL, oneDNN en Intel MKL. Python coördineert voornamelijk de bewerkingen, terwijl het zware werk wordt gedaan door native code op de CPU en GPU.

In grote lijnen kun je PyTorch beschouwen als opgebouwd uit verschillende belangrijke componenten: de tensorbibliotheek, de autograd-engine, hulpprogramma's voor neurale netwerken, de JIT-compiler (TorchScript), hulpmiddelen voor multiprocessing en een verzameling hulpprogramma's voor het laden en serialiseren van gegevens. Samen bieden ze zowel een NumPy-achtige tensorinterface als een flexibel deep-learningplatform.

De openbare C++ API weerspiegelt deze architectuur grotendeels en is opgesplitst in ATen, Autograd, de C++ frontend, TorchScript-bindings en C++-extensies, die elk een specifieke laag van de rekenstack aanspreken. Het begrijpen van deze onderdelen is essentieel als u verder wilt gaan dan Python, wilt integreren met aangepaste C++- of CUDA-kernels, of uw modellen wilt blootstellen aan omgevingen zoals Node.js of browserruntimes via bindings.

In de basis maakt PyTorch gebruik van de NVIDIA CUDA Toolkit, die een compiler, GPU-versnelde wiskundige bibliotheken, debug- en profilingtools en de CUDA-runtime levert die wordt gebruikt door torch.cuda en door aangepaste extensies. Deze toolkit stelt PyTorch uiteindelijk in staat om het volledige potentieel van moderne GPU's in datacenters, werkstations en embedded systemen te benutten.

ATen: de basis voor tensors en operators

ATen is de low-level tensorbibliotheek die de basis vormt voor vrijwel elke tensorbewerking in PyTorch, ongeacht of je deze vanuit Python of C++ aanroept. Het definieert de kern at::Tensor type plus honderden wiskundige, indexerings-, lineaire-algebra- en reductiebewerkingen geïmplementeerd voor zowel CPU als GPU.

Elke ATen-tensor bevat metadata over het apparaat en het gegevenstype, en de toewijzing aan CPU- of CUDA-implementaties gebeurt dynamisch op basis van die metadata, zodat hetzelfde C++-operatorsymbool naadloos op verschillende backends kan worden uitgevoerd. Dit maakt het mogelijk om gegevens te verplaatsen via .to("cuda") or .cuda() in Python zonder de daadwerkelijke bewerking die je aanroept te wijzigen.

Hoewel ATen rechtstreeks via de C++ API kan worden gebruikt (alles bevindt zich in de at:: naamruimte), in typische workflows raak je ATen slechts indirect aan via modules op een hoger niveau, zoals torch, torch.nn of de C++ frontend. Toch biedt werken op ATen-niveau vaak de meeste controle voor prestatiekritieke code of aangepaste kernels.

Het ontwerp van ATen legt de nadruk op snelle, gevectoriseerde kernels, krachtige GPU-acceleratie en goede CPU-prestaties, waardoor het geschikt is voor zowel onderzoeks- als productietoepassingen. Internally maakt het gebruik van bibliotheken van leveranciers (MKL, cuBLAS, cuDNN, enz.) waar dat zinvol is, in plaats van goed geoptimaliseerde wiskundige modellen opnieuw uit te vinden.

Autograd: automatische differentiatie bovenop tensors

Autograd is het subsysteem dat ATen-tensoren uitbreidt met gradiënttracking, waardoor pure tensorberekeningen worden omgezet in differentieerbare berekeningsgrafieken. Wanneer autograd is ingeschakeld, genereren bewerkingen op tensors een interne grafiek die achterwaarts kan worden doorlopen om gradiënten voor training te berekenen.

De autograd-engine is gebouwd rond een concept dat vaak een "tape" of differentiatiegrafiek in omgekeerde modus wordt genoemd, waarbij tussenliggende bewerkingen tijdens de voorwaartse doorgang worden vastgelegd en op verzoek in achterwaartse richting worden afgespeeld. het roepen .backward() Op een bladtensor met een gradiënt wordt deze grafiekdoorloop gestart en worden afgeleiden in de parameters geaccumuleerd.

Een belangrijk subtiliteit is dat het ruwe at::Tensor Het type ATen is standaard niet differentieerbaar, dus voor gradiëntbewuste tensors in C++ gebruik je de torch:: naamruimtefabriekfuncties (zoals torch::ones) in plaats van de at:: fabrieken. De eerste methode creëert tensoren die zijn gekoppeld aan het autograd-systeem, terwijl de tweede methode puur numeriek blijft.

Deze scheiding is opzettelijk: het stelt je in staat te kiezen of de overhead van autograd aanwezig moet zijn, wat cruciaal is voor paden die alleen op inferentie gebaseerd zijn of paden met een lage latentie waar gradiënten niet nodig zijn. Datzelfde onderscheid blijft behouden in de C++-frontend en in de TorchScript-grafieken.

C++ Frontend: modellen bouwen en trainen zonder Python

De PyTorch C++-frontend is een API op hoog niveau die veel overeenkomsten vertoont met... torch.nn, torch.optim, torch.utils.data en verwante Python-modules, maar is geïmplementeerd als idiomatisch modern C++. Het is ontworpen voor scenario's waarin je native prestaties nodig hebt, een nauwere integratie met bestaande C++-systemen of een implementatieomgeving zonder Python.

Bij gebruik van de C++-frontend definieer je modellen als hiërarchieën van modules, in dezelfde geest als torch.nn.Module, waarbij parameters binnen klassen worden geregistreerd en samengevoegd tot grotere netwerken. Er bestaat een "standaardbibliotheek" van lagen: convoluties, RNN's, batchnormalisatie, lineaire lagen en vele andere die zich vrijwel identiek gedragen aan hun Python-tegenhangers.

De frontend biedt tevens een optimalisatie-API met klassieke algoritmen zoals SGD, Adam en RMSprop, datasetabstracties en dataladers die data van meerdere CPU-threads kunnen streamen, en hulpprogramma's voor het serialiseren van checkpoints. In principe, als je weet hoe je een trainingslus in Python schrijft (en problemen zoals deze vermijdt)... overfitting versus underfitting), het overzetten naar de C++ frontend is grotendeels mechanisch.

Op systemen met meerdere GPU's biedt de C++-frontend hulpmiddelen voor automatische parallelisatie van modellen over meerdere CUDA-apparaten, op een manier die vergelijkbaar is met... torch.nn.parallel.DataParallel. Het bevat bovendien ondersteunende code voor het terugkoppelen van C++-modellen naar Python met pybind11, voor het geval je een hybride workflow wilt.

TorchScript: JIT-compilatie en Python-vrije uitvoering

TorchScript is een statisch analyseerbare subset van Python plus de PyTorch API die kan worden gecompileerd, geoptimaliseerd en geserialiseerd voor implementatie. Het is conceptueel gezien een kleine programmeertaal die is ontworpen rond tensorbewerkingen en controlestructuren die veelvuldig in modellen worden gebruikt.

Vanuit C++-perspectief biedt TorchScript drie belangrijke mogelijkheden: het laden en uitvoeren van geserialiseerde modellen die in Python zijn gemaakt, het definiëren van aangepaste operators die de standaardbibliotheek van TorchScript uitbreiden, en het rechtstreeks compileren van TorchScript-broncode vanuit C++. Dit alles is toegankelijk via de torch::jit naamruimte.

Een veelvoorkomend productiepatroon is om modellen volledig in Python te schrijven en te trainen, ze te exporteren als TorchScript-modules en die modules vervolgens in te bedden in een C++-service die inferentie met lage latentie uitvoert zonder afhankelijk te zijn van een Python-runtime. Dit is met name aantrekkelijk voor gecontaineriseerde microservices en prestatiegevoelige backends.

Gevorderde gebruikers kunnen aangepaste operators registreren, waaronder CUDA-versnelde kernels, die TorchScript kan aanroepen alsof het ingebouwde operators zijn; deze aangepaste operators zijn serialiseerbaar en werken in zowel Python- als C++-contexten wanneer ze correct zijn geregistreerd. Tot slot, functies zoals torch::jit::compile Hiermee kun je TorchScript-modules dynamisch creëren vanuit C++-strings of AST-achtige constructies.

C++- en CUDA-extensies: je eigen kernels toevoegen

Het C++-extensiemechanisme van PyTorch biedt een eenvoudige manier om aangepaste C++- en CUDA-code in reguliere Python-workflows te injecteren, terwijl tegelijkertijd gebruik wordt gemaakt van ATen, autograd en de dispatcher. Je gebruikt deze extensies doorgaans om aangepaste operators te implementeren of om gespecialiseerde workloads te versnellen die niet goed worden ondersteund door de ingebouwde operators.

De extensie-API zelf introduceert geen nieuwe tensor-semantiek; in plaats daarvan koppelt deze uw code aan het pakketbeheersysteem van Python (via setuptools of alternatieve backends) en aan de JIT-compilatietools van PyTorch, zodat kernels compileren met de juiste ABI en linkvlaggen. Onder de motorkap bevinden zich helpers zoals CUDAExtension Voeg standaardcode toe voor NVCC, inclusief paden en linkopties.

Wat de bindingen betreft, wordt pybind11 vaak gebruikt om C++-functies of -klassen als Python-symbolen beschikbaar te maken, en die bindingen werken samen met torch::Tensor objecten die dezelfde opslagruimte delen met Python-tensors. Dit minimaliseert het aantal datakopieën en zorgt ervoor dat autograd de nieuwe operators kan herkennen als je backward passes correct implementeert.

Eenmaal gecompileerd gedragen deze extensies zich als gewone Python-modules, kunnen ze worden geïmporteerd vanuit trainingsscripts en werken ze zelfs goed samen met TorchScript als je de bewerkingen registreert voor JIT-gebruik. Voor onderzoek dat intensief gebruikmaakt van CUDA, is dit vaak de snelste manier om met nieuwe kernels te experimenteren en tegelijkertijd de productiviteit van Python te behouden.

Torch- en CUDA-bibliotheken met elkaar verbinden: een GEMM-voorbeeld met CUTLASS

Wanneer je de volledige prestaties van NVIDIA GPU's wilt benutten, is het gebruikelijk om de tensor-runtime van PyTorch te koppelen aan sterk geoptimaliseerde CUDA C++-bibliotheken zoals CUTLASS of aangepaste kernels die niet als ingebouwde functies beschikbaar zijn. Een klassiek voorbeeld is het schrijven van een geoptimaliseerde GEMM-operator (matrixvermenigvuldiging).

Het algemene patroon is om een ​​C++ wrapperfunctie te schrijven die accepteert... torch::Tensor Het programma neemt de invoergegevens in ontvangst, extraheert hun vorm, gegevenstypen en gegevenspointers, en stuurt deze door naar CUTLASS of een andere CUDA-bibliotheekfunctie. De tensorafmetingen worden verkregen via .sizes(), gegevenstypen via .dtype()en ruwe pointers via .data_ptr() (eventueel te combineren met) reinterpret_cast als je aangepaste typen nodig hebt, zoals cutlass::half_t).

Omdat sjabloonparameters in C++ tijdens het compileren worden bepaald, terwijl tensor-datatypen pas tijdens de uitvoering bekend zijn, bevat de wrapper meestal voorwaardelijke dispatch-logica die de juiste sjablooninstantie selecteert (voor float16, float32, enz.) op basis van de datatypen van de tensors. Voor complexe sjabloonhiërarchieën genereren mensen die standaardcode vaak met Python-scripts om te voorkomen dat ze veel vertakkingen handmatig moeten schrijven.

Inputvalidatie is cruciaal: tensors moeten compatibel zijn met GEMM, op ​​een CUDA-apparaat staan ​​en aaneengesloten in het geheugen zijn opgeslagen, omdat CUTLASS verwacht dat aangrenzende elementen sequentieel worden gerangschikt. Je kunt de nabijheid controleren met .is_contiguous() en repareer het met .contiguous()Indien nodig worden de resultaten teruggekopieerd naar de oorspronkelijke tensor wanneer in-place semantiek gewenst is.

Om aan te sluiten bij de stijl van PyTorch, maak je uitvoertensors doorgaans optioneel met behulp van c10::optional<torch::Tensor>En als er geen wordt opgegeven, wijs je een nieuwe toe met de juiste gegevens. device en dtype gebruikmakend van ATen-fabrieksfuncties. Door die tensor terug te geven, blijft de API symmetrisch met ingebouwde operators zoals torch.mm.

Het binden en bouwen van CUDA-extensies met PyBind11 en setuptools

Zodra de C++-wrapper klaar is, moet je deze aan Python koppelen en compileren. Daarvoor zijn pybind11 en de build-hulpprogramma's van PyTorch nodig. Een pybind11-module declareert doorgaans een functie zoals m.def("cutlass_gemm", &cutlass_gemm, "GEMM with CUTLASS", py::arg("A"), py::arg("B"), py::arg("out") = py::none()); om je C++-functie beschikbaar te maken voor Python-code.

Aan de build-kant begrijpt setuptools standaard geen nvcc, daarom levert PyTorch een hulpklasse mee genaamd CUDAExtension Dat configureert automatisch de include-paden, CUDA-compilatievlaggen en koppeling met libtorch. Je geeft je .cpp en .cu bronnen naar CUDAExtension net als een standaard setuptools Extension.

Nadat de extensie is geïnstalleerd, kan uw Python-code deze importeren als een reguliere module. Vanaf dat moment ziet een aanroep naar uw aangepaste operator er vrijwel hetzelfde uit als een aanroep naar ingebouwde PyTorch-operators. Je behoudt de mogelijkheid om samen te werken met autograd, TorchScript en CUDA-streams, zolang je de conventies van PyTorch respecteert.

Als je liever niet afhankelijk bent van PyTorch voor de build zelf (bijvoorbeeld als je CUDA-bibliotheek meerdere frameworks ondersteunt), kun je alternatieve backends gebruiken zoals scikit-build-core met CMake, of de nvcc-integratie handmatig configureren in setuptools. CUDAExtension is verreweg de eenvoudigste optie voor PyTorch-gebruikers.

De CUDA Toolkit: compiler, bibliotheken en runtime-laag

De NVIDIA CUDA Toolkit vormt de basis van de GPU-runtime van PyTorch door een C/C++-compiler, GPU-geoptimaliseerde numerieke bibliotheken, debug- en profilingtools en de low-level runtime te leveren die door PyTorch wordt gebruikt. torch.cuda en aangepaste extensies. Het is gericht op een breed scala aan platforms, van embedded boards tot cloudclusters.

Door complexe lineaire algebra-, convolutie- en FFT-taken uit te besteden aan CUDA-bibliotheken, maakt PyTorch gebruik van sterk geoptimaliseerde implementaties die de specifieke kenmerken van elke GPU-architectuur kennen en prestaties kunnen leveren die veel verder gaan dan wat eenvoudige GPU-code zou kunnen bieden. Voor veel AI-workloads is dit de belangrijkste reden waarom PyTorch zo goed schaalt op nieuwe GPU-generaties.

Ontwikkelaars die CUDA-extensies schrijven, compileren doorgaans nog steeds C++-kernels met nvcc, en door ze te koppelen aan PyTorch kunnen ze worden aangestuurd vanuit Python-, C++- of zelfs JavaScript-runtimeomgevingen die gebruikmaken van gedeelde bibliotheken. Dit is de ideale oplossing voor teams die beschikken over bestaande C++- of CUDA-codebases, maar deze willen ontsluiten via API's in PyTorch-stijl.

torch.cuda: apparaatselectie, precisiemodi en uitvoeringsmodel

De Politia Militar hield zelfs tijdens de pre-carnaval festiviteiten de zaken al nauwlettend in de gaten. torch.cuda Deze module is de gebruikersinterface voor CUDA vanuit PyTorch en regelt de apparaatselectie, het streambeheer, de geheugenallocatie en de runtimeconfiguratie. Alle CUDA-tensors gebruiken standaard het momenteel geselecteerde apparaat, dat u kunt wijzigen met torch.cuda.device als contextmanager of door expliciet specifieke apparaten te targeten.

Cross-GPU-bewerkingen zijn opzettelijk beperkt: afgezien van kopieerachtige bewerkingen (zoals copy_(), to(), cuda()De meeste bewerkingen kunnen niet over meerdere apparaten worden uitgevoerd, tenzij peer-to-peer geheugentoegang is ingeschakeld, om subtiele prestatie- en correctheidsproblemen te voorkomen. Tensors houden bij op welk apparaat ze zich bevinden, en de uitvoer blijft op hetzelfde apparaat als de invoer.

PyTorch biedt gedetailleerde controle over de rekenprecisie op CUDA-backends, waaronder TensorFloat-32 (TF32) op Ampere en latere GPU's, gereduceerde precisie voor FP16- en BF16-GEMM's, en opties voor volledige FP16-accumulatie wanneer ondersteund door de hardware. Deze vlaggen kunnen per backend (CUDA, cuDNN) en zelfs per operator worden aangepast, waardoor je numerieke nauwkeurigheid kunt inruilen voor snelheid.

GPU-bewerkingen zijn standaard asynchroon: wanneer je een CUDA-bewerking aanroept, wordt deze in een apparaatstream geplaatst, maar kan later worden uitgevoerd. Dit maakt overlapping van CPU-berekeningen, gegevensoverdracht en kernels mogelijk. Het correct timen van dergelijke code vereist ofwel expliciete torch.cuda.synchronize() aanroepen of het gebruik van CUDA-gebeurtenissen; omgevingsvariabelen zoals CUDA_LAUNCH_BLOCKING=1 Ze zijn handig voor het debuggen, maar niet voor prestatietests.

Voor meer geavanceerde toepassingen biedt PyTorch CUDA-streams en -events, waarmee je meerdere parallelle streams kunt orkestreren, selectief kunt synchroniseren en ervoor kunt zorgen dat tensors niet worden vrijgegeven voordat al het lopende werk eraan is voltooid. Functies zoals record_stream() en wait_stream() staan ​​centraal in deze patronen.

CUDA-geheugenbeheer, allocators en instelmogelijkheden

PyTorch gebruikt een caching-allocator op CUDA-apparaten om frequente toewijzingen en vrijgaven snel te laten verlopen zonder constante synchronisatie met de GPU (zie Hoe werkt geheugen in C++? (voor verwante concepten). In plaats van te bellen cudaMalloc en cudaFree Voor elke tensor worden geheugenblokken bijgehouden die bij verschillende toewijzingen hergebruikt kunnen worden.

Als gevolg hiervan zijn tools zoals nvidia-smi Vaak wordt er meer geheugen "in gebruik" weergegeven dan er daadwerkelijk door tensors wordt ingenomen, omdat een deel van dat geheugen door de allocator is gereserveerd maar momenteel niet is toegewezen. Functies zoals memory_allocated(), max_memory_allocated(), memory_reserved() en max_memory_reserved() Helpt onderscheid te maken tussen live gebruik van tensors en gecachede capaciteit.

U kunt ongebruikt cachegeheugen vrijgeven met torch.cuda.empty_cache(), wat blokken teruggeeft aan de CUDA-driver, maar het geheugen dat nog in gebruik is door actieve tensors niet vrijgeeft. Voor een grondigere inspectie, memory_stats() en memory_snapshot() Biedt gedetailleerde informatie over geheugenallocatie die cruciaal kan zijn bij het opsporen van fragmentatie of geheugenproblemen.

Het gedrag van de allocator kan worden aangepast via de PYTORCH_ALLOC_CONF (of zijn alias PYTORCH_CUDA_ALLOC_CONF) omgevingsvariabele waarmee je de backend-implementatie kunt kiezen, de splitsingsgroottes kunt aanpassen, afrondingsstrategieën kunt instellen, drempelwaarden voor garbage collection kunt bepalen en meer. Er is ook een optie om CUDA te gebruiken. cudaMallocAsync-gebaseerde allocator als alternatieve backend op ondersteunde toolkits.

Naast de ingebouwde allocator ondersteunt PyTorch ook pluggable CUDA-allocators via gedeelde bibliotheken die in C of C++ zijn geschreven. Deze kunnen worden geïntegreerd met externe systemen zoals NCCL's NVLink Switch Reductions of aangepaste CPU-GPU-geheugenplaatsingsstrategieën, en zijn beschikbaar in Python via torch.cuda.memory.CUDAPluggableAllocator en torch.cuda.MemPool.

CUDA-grafieken en prestatiegerichte best practices

CUDA-grafieken zijn een krachtige functie om de CPU-belasting te verminderen door een reeks GPU-bewerkingen als grafiek vast te leggen en deze met één enkele aanroep opnieuw af te spelen. PyTorch integreert deze functie via torch.cuda.CUDAGraph torch.cuda.graph contextmanager en de torch.cuda.make_graphed_callables() helper.

Grafiekcaptatie werkt het beste wanneer uw workload statische vormen, een deterministische controlestroom en geen CPU-GPU-synchronisatie in het kritieke pad heeft. Tijdens de opname wordt het werk van de GPU geregistreerd in plaats van uitgevoerd, en bij het afspelen wordt exact dezelfde reeks kernels uitgevoerd, waarbij van dezelfde virtuele adressen wordt gelezen en naar dezelfde adressen wordt geschreven.

Omdat de vastgelegde grafiek uitgaat van vaste tensorindelingen, wijst PyTorch grafiekspecifieke geheugenpools toe waarvan de levensduur gekoppeld is aan de grafiek zelf. CUDAGraph object en naar de tensors die binnen de capture zijn gecreëerd. Deze geheugenpools kunnen worden gedeeld tussen gerelateerde grafieken om geheugen te besparen, mits een consistente uitvoeringsvolgorde en het voorkomen van gelijktijdige uitvoering worden gegarandeerd.

In gedistribueerde omgevingen, met name met DistributedDataParallel De integratie van NCCL en CUDA Graph vereist de nodige aandacht, zoals het garanderen van compatibele NCCL-versies, het uitschakelen van bepaalde asynchrone foutafhandelaars en het uitvoeren van opwarmstappen om het veilig vastleggen van collectieven mogelijk te maken. Mits correct uitgevoerd, kan het de doorvoer voor stabiele, productieklare trainingsloops aanzienlijk verhogen.

Naast grafieken raadt de PyTorch-documentatie aan om vastgezet CPU-geheugen te gebruiken voor snellere overdrachten van host naar GPU, waarbij de voorkeur uitgaat naar... DistributedDataParallel over DataParallel of naïeve multiprocessing voor training met meerdere GPU's, en het schrijven van apparaat-onafhankelijke code die soepel schakelt tussen CPU en GPU via torch.device. Deze werkwijzen helpen je gezamenlijk de ideale balans tussen ergonomie en prestatie te vinden.

Installatie, configuratieopties en hardware-backends

PyTorch kan worden geïnstalleerd via Conda, pip wheels of vanuit de broncode. Er zijn vooraf gecompileerde binaire bestanden beschikbaar voor gangbare Linux-, macOS- en Windows-systemen, evenals gespecialiseerde builds voor NVIDIA Jetson-platforms. Elke distributie is gericht op specifieke CUDA-versies volgens een gepubliceerde ondersteuningsmatrix.

Bij het compileren vanuit de broncode heb je Python 3.10 of nieuwer nodig, een moderne C++17-compatibele compiler (bijvoorbeeld GCC 9.4+ op Linux) en de juiste toolchain op Windows (Visual Studio of de standalone Build Tools). Je kunt compileren met of zonder CUDA-, ROCm- (voor AMD GPU's) of Intel GPU-ondersteuning door de bijbehorende SDK's te installeren en vlaggen in te stellen zoals USE_CUDA, USE_ROCM en USE_XPU.

Voor builds die uitsluitend op de CPU draaien, kan speciale aandacht nodig zijn bij het koppelen van de gewenste OpenMP-implementatie (vaak Intel OpenMP) en BLAS-bibliotheken, met name op Windows waar CMake anders mogelijk terugvalt op de standaard MSVC-runtime. Voor CUDA-builds kunnen extra bibliotheken zoals Magma of oneDNN worden toegevoegd om specifieke bewerkingen te versnellen.

PyTorch biedt ook Docker-images met vooraf geconfigureerde CUDA- en cuDNN-omgevingen (zie een Inleiding tot containerisatieDeze afbeeldingen maken gebruik van gedeelde geheugensegmenten voor het laden van gegevens met meerdere processen, waardoor het vaak nodig is om het gedeelde geheugen te vergroten via --ipc=host or --shm-size on docker run. Het is essentieel om ervoor te zorgen dat uw Docker- en NVIDIA-stuurprogrammaversies compatibel zijn met de CUDA-toolkitversie.

De documentatie zelf is gemaakt met Sphinx en een aangepast thema, en kan worden gegenereerd in HTML- of PDF-formaat als je de benodigde Python-afhankelijkheden, TeX-tools en het PyTorch-pakket in een lokale omgeving installeert. Dit is handig wanneer je nieuwe modules of docstrings toevoegt en deze wilt bekijken voordat je ze naar de upstream-repository stuurt.

VibeTensor: een door AI gegenereerde runtime, geïnspireerd op PyTorch.

Het VibeTensor-project van NVIDIA illustreert een andere invalshoek op runtime-omgevingen: het is een experimentele uitvoeringsomgeving, conceptueel vergelijkbaar met PyTorch, waarvan de codebasis grotendeels is gegenereerd door AI-agenten onder menselijk toezicht. Het idee is om te zien hoe ver "vibe coding" — waarbij sterk wordt vertrouwd op AI-assistenten om code te schrijven — kan worden doorgevoerd voor een complex systeem.

De architectuur van VibeTensor combineert een API die geschikt is voor Python en JavaScript met een C++ runtime-kern, aangepaste tensor-opslagallocators, een autograd-engine, een dispatcher, een geavanceerd indexeringssubsysteem en een CUDA-gestuurde geheugencache, allemaal gericht op Linux x86_64 en NVIDIA GPU's. Er bestaat zelfs een experimenteel Fabric-subsysteem dat CUDA P2P gebruikt voor uitvoering op meerdere GPU's.

Het project ondersteunt ook externe GPU-plugins, zoals een backend voor de aankomende Blackwell-architectuur (SM100/SM103), en laat zien dat deze plugins zelf kunnen worden opgestart met door AI gegenereerde code, zolang mensen maar beperkingen en validatie aanleveren. Hoewel de prestaties en functies momenteel niet kunnen wedijveren met PyTorch, dient het project als een proof of concept voor AI-ondersteunde systeemprogrammering.

Tijdens de ongeveer twee maanden durende ontwikkeling concentreerden menselijke ingenieurs zich voornamelijk op het definiëren van taken, beperkingen en beoordelingscycli, terwijl AI-agenten iteratief code genereerden, vergelijkingen uitvoerden, compileerden, testten en implementaties verfijnden. Deze hybride workflow onderstreept zowel de kracht als de beperkingen van AI: het grootste deel van de standaardteksten en repetitieve patronen kan worden geautomatiseerd, maar correctheid en architectuur vereisen nog steeds menselijk oordeel.

Voor professionals is VibeTensor minder een directe vervanging voor PyTorch en meer een verkenning van hoe toekomstige runtime-omgevingen eruit zouden kunnen zien wanneer AI een belangrijke rol speelt in hun ontwerp en ontwikkeling, met name in omgevingen die Python, JavaScript, C++ en CUDA combineren. Het geeft een voorproefje van een wereld waarin gespecialiseerde runtime-omgevingen voor specifieke workloads veel sneller kunnen worden opgezet dan voorheen.

Als je al deze onderdelen samenvoegt — de tensor- en autograd-kern van PyTorch, de C++-frontend, TorchScript, C++- en CUDA-extensies, de verfijnde CUDA-integratie en experimentele initiatieven zoals VibeTensor — krijg je een beeld van een AI-runtime-ecosysteem waarin Python, C++, JavaScript en CUDA nauw met elkaar verweven zijn en waarin ontwikkelaars vloeiend de laag kunnen kiezen die de beste balans biedt tussen productiviteit, controle en pure prestaties voor hun specifieke workload.