PyTorch ziet de GPU niet: diagnose in de juiste volgorde

Het diagnosetraject in vier beslissingen

Het doel is de eerste laag te vinden die faalt, niet om meerdere installaties na elkaar te proberen. Bewaar het uitgevoerde commando, het eerste foutbericht en het resultaat van elke controle. Als je tegelijk Python, het PyTorch-pakket en de batchgrootte wijzigt, weet je niet meer welke aanpassing het probleem heeft opgelost.

Het downloadbare script volgt deze progressie en produceert een beperkt technisch rapport. Het start je model niet en wijzigt je installatie niet. Gebruik het in dezelfde omgeving als je project, anders controleer je een andere interpreter dan die van het programma dat vastloopt.

Scroll door de tabel om alle kolommen te lezen.

Stop bij de eerste stap die faalt.
Controle	Als de controle faalt	Wat slagen hiervan mogelijk maakt
1. Interpreter en import	De gebruikte Python of de PyTorch-installatie ervan corrigeren.	De versie en backend lezen van het pakket dat werkelijk geïmporteerd wordt.
2. Backend en apparaat	Het pakket, de driver, de zichtbaarheid van de GPU en de rechten onderzoeken.	Een toewijzing aanvragen op de beoogde GPU.
3. Kleine GPU-berekening	De toewijzings-, reken- of synchronisatiefout bewaren.	Overstappen op een kleinere invoer van de applicatie.
4. Representatieve applicatie	Gewichten, extensie, formaat, geheugen of onjuiste uitvoer isoleren.	Het werkelijke werk geleidelijk opvoeren.

1. De Python identificeren die werkelijk wordt uitgevoerd

Een terminal, een notebook en een service kunnen verschillende interpreters gebruiken. Toon sys.executable in de context die het project start en controleer vervolgens de versie. Het pad helpt een vergeten virtuele omgeving of een notebook dat op een andere kernel is blijven staan op te sporen. Onderzoek het op je eigen machine; het is niet nodig je persoonlijke mappenstructuur in een rapport te publiceren.

Gebruik daarna dezelfde interpreter om de pakketten op te vragen. Het commando python -m pip show torch geeft de informatie van de PyTorch die aan deze Python gekoppeld is. Als import torch faalt, bestaat de volgende stap erin die installatie te corrigeren: de batch verkleinen of de gewichten van het model wijzigen lost een ontbrekende module niet op.

Uit te voeren in dezelfde omgeving als het project

python -c "import sys; print(sys.executable); print(sys.version)"
python -m pip show torch

2. CUDA, ROCm en een pakket zonder GPU-versnelling onderscheiden

Noteer afzonderlijk torch.__version__, torch.version.cuda en torch.version.hip. Trek niet de conclusie "CPU-pakket" op basis van alleen de waarde None van torch.version.cuda: PyTorch voor ROCm gebruikt HIP, hergebruikt torch.cuda en verwacht eveneens een apparaat met de naam cuda. Die naam vervangen door rocm of hip is niet de correctie die je moet toepassen.

Controleer vervolgens torch.cuda.is_available() en torch.cuda.device_count(). Deze resultaten beschrijven wat deze Python-omgeving op dat moment kan gebruiken. Ze vervangen de minimale berekening niet. Een systeemhulpmiddel kan een kaart zien terwijl het pakket, de voor het proces toegankelijke driver of zijn omgeving PyTorch ervan weerhouden deze te gebruiken.

Indicatoren lezen zonder een model te laden

python -c "import torch; print(torch.__version__); print(torch.version.cuda); print(torch.version.hip); print(torch.cuda.is_available()); print(torch.cuda.device_count())"

3. Het rapport genereren met het Kernodeck-script

Nadat u het bestand hebt gedownload, plaatst u het in een werkmap en start u het met de Python van het project. Standaard vereist het een GPU. De CPU-modus moet expliciet worden aangevraagd: een succesvolle uitvoering verifieert de CPU-tak van de diagnose en verandert een niet-beschikbare GPU nooit in een gevalideerde GPU. Het rapport wordt naar de terminal geschreven en, met --output, naar een nieuw JSON-bestand. Een bestaand bestand wordt nooit overschreven: kies een andere naam voor uw volgende poging.

Het script alloceert twee 2 × 2-matrices in float32, controleert hun product en vervolgens een gradiënt en synchroniseert het GPU-apparaat. De verwachte loss is 196 voor deze vaste berekening. Deze zeer korte controle laadt geen modelgewichten en meet geen doorvoer. Hij vraagt een kleine echte berekening aan de backend, verder dan een simpele apparaatdetectie.

De optionele systeemcontrole gebruikt nvidia-smi wanneer dit aanwezig is. Hij rapporteert alleen de versie van de NVIDIA-driver en het totale geheugen dat dit hulpmiddel ziet; het is geen gelijkwaardige systeemcontrole voor ROCm. De time-out van de berekening is standaard 30 seconden en kan variëren van 5 tot 120 seconden. De systeemcontrole heeft zijn eigen maximale time-out van 3 seconden.

GPU-controle en opslaan van het rapport

python kernodeck-diagnostic-v1.py --device-index 0 --timeout 30 --output diagnostic-gpu.json

CPU-controle bewust apart

python kernodeck-diagnostic-v1.py --device cpu --output diagnostic-cpu.json

De optionele NVIDIA-systeemcontrole toevoegen

python kernodeck-diagnostic-v1.py --host-check --output diagnostic-gpu-systeme.json

4. Het rapport lezen en de volgende actie kiezen

Begin met status, code, exit_code en stage. Het blok runtime identificeert de Python-versie en de systeemfamilie. Het blok pytorch onderscheidt het geïmporteerde pakket, zijn CUDA/HIP-compilatieversies, de opgegeven backend en de zichtbare apparaten. Het blok execution geeft aan waar de berekening daadwerkelijk heeft plaatsgevonden en of het product en de gradiënt zijn geverifieerd.

In CPU-modus blijven gpu_available en visible_device_count op null: het script vraagt niet naar de status van de GPU-driver. Dit is geen nul en geen storing. Lees ook execution.device: een pakket dat voor CUDA is gecompileerd, kan deze controle heel goed op CPU uitvoeren wanneer dat expliciet wordt gevraagd.

Het rapport bevat een selectie van technische gegevens. Het bevat niet de omgevingsvariabelen, de paden van de machine, de sessie-identificaties, een volledige pakketlijst of de ruwe stacktrace van een uitzondering. Het script stuurt geen enkel rapport naar Kernodeck. Bewaar voor een gedetailleerde fout van uw applicatie de stacktrace in uw werkruimte en verwijder secrets voordat u deze deelt.

Scroll door de tabel om alle kolommen te lezen.

Nuttige codes om te beslissen over het vervolg; de volledige lijst wordt bij het script geleverd.
Resultaat	Betekenis	Volgende actie
GPU_CHECK_PASSED · 0	Product en gradiënt geverifieerd op de gekozen GPU.	Ga verder met een kleine invoer van uw applicatie.
CPU_CHECK_PASSED · 0	Product en gradiënt alleen op CPU geverifieerd.	Trek geen conclusies over CUDA of ROCm.
TORCH_MISSING · 3 / TORCH_IMPORT_FAILED · 4	PyTorch ontbreekt in deze Python, of de import is mislukt.	Controleer de interpreter, het pakket en zijn afhankelijkheden.
GPU_BACKEND_ABSENT · 5	Het pakket declareert noch CUDA noch HIP.	Installeer het pakket dat bij uw omgeving past.
GPU_UNAVAILABLE · 6 / DEVICE_INDEX_INVALID · 7	GPU onbruikbaar in dit proces, of index buiten de zichtbare apparaten.	Controleer de zichtbaarheid van de kaarten, de driver en de gevraagde index.
CHECK_FAILED · 8 / OUT_OF_MEMORY of RUNTIME_ERROR · 9	Mislukking van de vaste berekening, de allocatie of een backend-operatie.	Lees de gemelde stap voordat u het volledige model start.
TIMEOUT · 10 / WORKER_FAILED · 11	Controle gestopt door de time-out, of zonder bruikbaar rapport.	Behandel de controle als een fout; onderzoek de omgeving.
OUTPUT_WRITE_FAILED · 12	Het rapport is niet opgeslagen op de opgegeven bestemming.	Gebruik een nieuwe, toegankelijke bestandsnaam.

5. Van de kleine berekening naar je eigen applicatie

Zorg voor de start voor een reproduceerbaar commando, een geïdentificeerd model, een kleine dataset en een toegankelijke uitvoermap. Kies een invoer die de belangrijke kenmerken van het uiteindelijke werk behoudt: tekstlengte, beeldafmetingen, audioformaat of verplichte velden. Een kunstmatig korte invoer kan het probleem verbergen dat je juist wilt observeren.

Schrijf een concreet succes criterium. Voor een embeddings-berekening moet elke invoer-id een vector van de verwachte dimensie opleveren, met eindige waarden. Voor een training moet één stap een bruikbare loss opleveren, de bedoelde parameters bijwerken en een opslag mogelijk maken. De exitcode van het proces vult deze controles aan; hij vervangt ze niet.

Voeg markeringen toe vóór en na het lezen van de parameters, het importeren van de bibliotheken, het laden van de gewichten, het voorbereiden van de gegevens, het overzetten ervan, de berekening en het schrijven. Geef elke poging een id en bewaar de bijbehorende parameters. Een bericht 'model geladen' moet overeenkomen met een afgeronde gebeurtenis, niet slechts met de intentie om te laden.

Log de vormen, typen en apparaten van de relevante tensors zonder de hele dataset te kopiëren. Een samenvatting zoals 'invoer: 8 sequenties, maximale lengte 512, apparaat cuda:0' helpt om twee pogingen te vergelijken. Deze getallen beschrijven hier een voorbeeld van een log, niet een universele configuratie. Vermijd het opnemen van toegangstokens of gevoelige invoergegevens in deze berichten.

6. De fout in de juiste laag oplossen

Als de kleine berekening slaagt maar de gewichten niet gevonden worden, controleer dan hun pad, formaat en toegangsrechten. Als een extensie niet importeert, controleer dan de compatibiliteit met het PyTorch-pakket en de backend van het project. Een geslaagde diagnose kwalificeert niet alle extensies van de applicatie. Pak de eerste stap aan die faalt in plaats van meerdere afhankelijkheden tegelijk te wijzigen.

Een apparaatfout kan komen van een invoer die op de CPU is achtergebleven terwijl het model op de GPU staat. Een typefout kan komen van een gedeeltelijke conversie of van een operator die niet compatibel is met de gekozen precisie. Bewaar het eerste volledige bericht en de bijbehorende trace. Wijzig telkens één aanname en start daarna de minimale invoer opnieuw voordat je het uiteindelijke volume weer toevoegt.

7. Als het model start en daarna het geheugen overschrijdt

Stel vast of de overschrijding optreedt bij het laden van de gewichten, bij de eerste berekening of na meerdere iteraties. Deze momenten wijzen op verschillende oorzaken: een te groot model, grote activaties of generatiecache, ophoping van bewaarde tensors. Noteer torch.cuda.memory_allocated() en torch.cuda.memory_reserved() op dezelfde stappen. De eerste volgt de toewijzingen van de tensors; de tweede dekt het geheugen dat door de allocator wordt beheerd.

torch.cuda.empty_cache() kan ongebruikte cache vrijgeven, maar verwijdert geen tensors die nog steeds worden gerefereerd. Inspecteer daarom de uitvoerlijsten, de loss-geschiedenissen en de objecten die een berekeningsgrafiek vasthouden. Verklein daarna de batch of de invoerlengte om de bepalende factor te isoleren. Overstappen naar een andere kaart wordt een geïnformeerde beslissing wanneer je weet welke fase wordt overschreden en welke marge daadwerkelijk nodig is.

8. Berekenen meten zonder het asynchrone karakter te vergeten

GPU-bewerkingen kunnen asynchroon verlopen ten opzichte van het Python-programma. Een timer rond een aanroep meet daardoor vooral het versturen van het werk. Synchroniseer voor een diagnostische meting de GPU op de grenzen van het geobserveerde segment, of gebruik geschikte events. Deze synchronisatie verandert het verloop: houd deze instrumentatie gescheiden van de normale werking van je applicatie.

Bouw een eenvoudig voorbeeld met drie segmenten: voorbereiding van de input, berekening, wegschrijven van de output. Roep voor het GPU-segment torch.cuda.synchronize() aan, lees time.perf_counter() uit, voer de berekening uit, synchroniseer opnieuw en bereken dan het verschil. Houd de eerste passage en de volgende apart. Een laadtijd of initialisatie mag niet verdwijnen in een gemiddelde dat als volledige responstijd wordt gepresenteerd.

PyTorch: synchronisatie en meting van GPU-berekening

9. Outputs controleren en een herbruikbare diagnose bewaren

Voor klassieke inferentie stelt model.eval() het gedrag van de betrokken modules in, terwijl torch.inference_mode() de tracking uitschakelt die nodig is voor gradiënten. Deze twee instellingen hebben verschillende functies. Gebruik de tweede wanneer de geproduceerde tensors daarna niet mogen deelnemen aan een berekening met gradiënten. Een modelevaluatie tijdens de training vereist dat je expliciet de juiste modus herstelt voordat je verdergaat.

Vergelijk nu de outputs met het voorbereide contract: aantal resultaten, overeenkomst van identifiers, dimensies, eindige waarden en de gepaste bedrijfsmetriek. Als je de batch vergroot, controleer dan opnieuw of dit klopt. Als je GPU's toevoegt, controleer dan de verdeling van de inputs en het verzamelen van de outputs. Huurbatches verwijzen naar bestelde kaarten; batch verwijst naar voorbeelden die je programma samen verwerkt.

Het resultaat van deze methode is een klein dossier: commando, versies, parameters, minimale input, laatste geslaagde stap, eerste fout, geheugenobservaties en verkregen output. Als de start werkt, bewaar dit dossier dan als vergelijkingspunt voordat je de belasting opvoert. Als de start mislukt, kun je met dit dossier het probleem reproduceren zonder het hele onderzoek opnieuw te doen.

Voer voor een langdurige verwerking ook een schone stop en herstart uit op deze kleine set inputs. Controleer dat reeds weggeschreven outputs niet verloren gaan of dubbel worden geteld. Zodra deze controles slagen, verhoog je geleidelijk één enkele as — batch, lengte, gelijktijdigheid of aantal processen — en noteer je de waargenomen limiet. Zo krijg je een gemeten werkbereik voor je toepassing, in plaats van een aanname op basis van de naam van de GPU.

Het geleverde bewijs en zijn beperkingen

De downloadbare voorbeelden komen uit echte controles uitgevoerd op 24 september 2026. De twee uitvoeringen met PyTorch gebruiken Windows, Python 3.14.6 en PyTorch 2.11.0+cu128. De GPU-controle gebruikt CUDA, op een NVIDIA GeForce RTX 5070; de CPU-controle vraagt expliciet om de CPU. Deze controlehardware wordt niet gepresenteerd als een Kernodeck-aanbod. Er is geen enkele ROCm-berekening uitgevoerd voor dit bewijs.

Een kleine geslaagde berekening toont aan dat een pad voor allocatie en berekening werkt op het gekozen apparaat. Het meet niet de snelheid van je model, noch het geheugen dat nodig is voor de grootste inputs, noch de compatibiliteit met een specifieke extensie. Het rapport certificeert ook geen multikaart-topologie. Ga over op de representatieve test voordat je besluit de belasting of de huur op te voeren.

Vergelijk voor een CUDA-toepassing een NVIDIA-fiche met je behoeften op het gebied van geheugen en bibliotheek; bekijk voor een ROCm-keten de voorwaarden van de MI300X. De gelinkte fiches zijn opties om te kwalificeren voor je project, niet de lijst van hardware die in het bewijs is gebruikt. Reken de initiële controletijd en de export mee in je periode van 3, 7 of 30 dagen.

Scroll door de tabel om alle kolommen te lezen.

Waargenomen resultaten van script v1.0.0; geen prestatiecijfers.
Echte controle	Waargenomen resultaat	Bereik
Expliciete CPU · Python 3.14.6 / PyTorch 2.11.0+cu128	CPU_CHECK_PASSED; product en gradiënt exact; verlies 196.	De vaste berekening werkt op CPU.
CUDA · RTX 5070 / CUDA-pakket 12.8	GPU_CHECK_PASSED; product en gradiënt exact; verlies 196.	De vaste berekening werkt op deze kaart in deze omgeving.
PyTorch ontbreekt · Python 3.12.14	TORCH_MISSING; exitcode 3.	Het ontbreken van de module leidt tot een expliciete fout.
GPU onzichtbaar gemaakt voor het controleproces	GPU_UNAVAILABLE; exitcode 6.	Het script vervangt de GPU niet stilzwijgend door de CPU.