Come verificare se pytorch sta usando la GPU?

Vorrei sapere se pytorchsta usando la mia GPU. È possibile rilevare con nvidia-smise c'è qualche attività dalla GPU durante il processo, ma voglio qualcosa scritto in uno pythonscript.

c'è un modo per farlo?

Questo funzionerà:

In [1]: import torch

In [2]: torch.cuda.current_device()
Out[2]: 0

In [3]: torch.cuda.device(0)
Out[3]: <torch.cuda.device at 0x7efce0b03be0>

In [4]: torch.cuda.device_count()
Out[4]: 1

In [5]: torch.cuda.get_device_name(0)
Out[5]: 'GeForce GTX 950M'

In [6]: torch.cuda.is_available()
Out[6]: True

Questo mi dice che la GPU GeForce GTX 950Mè utilizzata da PyTorch.

Dato che non è stato proposto qui, sto aggiungendo un metodo usando torch.device, poiché è abbastanza utile, anche quando si inizializzano i tensori sul corretto device.

# setting device on GPU if available, else CPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('Using device:', device)
print()

#Additional Info when using cuda
if device.type == 'cuda':
    print(torch.cuda.get_device_name(0))
    print('Memory Usage:')
    print('Allocated:', round(torch.cuda.memory_allocated(0)/1024**3,1), 'GB')
    print('Cached:   ', round(torch.cuda.memory_cached(0)/1024**3,1), 'GB')

Produzione:

Using device: cuda

Tesla K80
Memory Usage:
Allocated: 0.3 GB
Cached:    0.6 GB

Come accennato in precedenza, utilizzandolo deviceè possibile :

• Per spostare i tensori sui rispettivi device:

  torch.rand(10).to(device)

• Per creare un tensore direttamente sul device:

  torch.rand(10, device=device)

Il che rende comodo il passaggio tra CPU e GPU senza cambiare il codice reale.

Modificare:

Poiché ci sono state alcune domande e confusione sulla memoria cache e allocata, sto aggiungendo alcune informazioni aggiuntive al riguardo:

• torch.cuda.max_memory_cached(device=None)
  
  Restituisce la memoria GPU massima gestita dall'allocatore di memorizzazione nella cache in byte per un determinato dispositivo.
  

• torch.cuda.memory_allocated(device=None)
  
  Restituisce l'attuale utilizzo della memoria GPU da parte dei tensori in byte per un determinato dispositivo.

Puoi consegnare direttamente un devicecome specificato più sopra nel post oppure puoi lasciarlo Nessuno e userà il current_device().

Dopo aver iniziato a eseguire il ciclo di allenamento, se vuoi guardarlo manualmente dal terminale se il tuo programma sta utilizzando le risorse della GPU e fino a che punto, puoi semplicemente usare watchcome in:

$ watch -n 2 nvidia-smi

Ciò aggiornerà continuamente le statistiche di utilizzo per ogni 2 secondi fino a quando non si preme ctrl+c

Se hai bisogno di un maggiore controllo su più statistiche GPU di cui potresti aver bisogno, puoi utilizzare una versione più sofisticata di nvidia-smiwith--query-gpu=... . Di seguito è una semplice illustrazione di questo:

$ watch -n 3 nvidia-smi --query-gpu=index,gpu_name,memory.total,memory.used,memory.free,temperature.gpu,pstate,utilization.gpu,utilization.memory --format=csv

che produrrebbe le statistiche in qualche modo:

Nota : non deve esserci spazio tra i nomi delle query separati da virgola --query-gpu=.... Altrimenti, questi valori verranno ignorati e non verranno restituite statistiche.

Inoltre, puoi verificare se la tua installazione di PyTorch rileva correttamente la tua installazione CUDA:

In [13]: import  torch

In [14]: torch.cuda.is_available()
Out[14]: True

True lo stato indica che PyTorch è configurato correttamente e si utilizza la GPU, anche se si deve spostare / posizionare i tensori con le istruzioni necessarie nel codice.

Se vuoi farlo all'interno del codice Python, guarda in questo modulo:

https://github.com/jonsafari/nvidia-ml-py o in pypi qui: https://pypi.python.org/pypi/nvidia-ml-py/

Sul sito dell'ufficio e sulla pagina iniziale get, controlla GPU per PyTorch come di seguito:

import torch
torch.cuda.is_available()

Riferimento: PyTorch | Inizia

Dal punto di vista pratico solo una piccola digressione:

import torch
dev = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")

Questo dev ora sa se cuda o cpu.

E c'è una differenza nel modo in cui gestisci il modello e con i tensori quando ti sposti in cuda. All'inizio è un po 'strano.

import torch
dev = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
t1 = torch.randn(1,2)
t2 = torch.randn(1,2).to(dev)
print(t1)  # tensor([[-0.2678,  1.9252]])
print(t2)  # tensor([[ 0.5117, -3.6247]], device='cuda:0')
t1.to(dev) 
print(t1)  # tensor([[-0.2678,  1.9252]]) 
print(t1.is_cuda) # False
t1=t1.to(dev)
print(t1)  # tensor([[-0.2678,  1.9252]], device='cuda:0') 
print(t1.is_cuda) # True

class M(nn.Module):
def __init__(self):        
    super().__init__()        
    self.l1 = nn.Linear(1,2)

def forward(self, x):                      
    x = self.l1(x)
    return x
model = M()   # not on cuda
model.to(dev) # is on cuda (all parameters)
print(next(model.parameters()).is_cuda) #True

Tutto questo è complicato e capendolo una volta, ti aiuta a gestire rapidamente con meno debug.

Per verificare se è disponibile una GPU:

torch.cuda.is_available()

Se la funzione sopra riportata ritorna False,

1. o non hai GPU,
2. o i driver Nvidia non sono stati installati, quindi il sistema operativo non vede la GPU,
3. oppure la GPU viene nascosta dalla variabile ambientale CUDA_VISIBLE_DEVICES. Quando il valore di CUDA_VISIBLE_DEVICESè -1, tutti i tuoi dispositivi vengono nascosti. Puoi controllare quel valore nel codice con questa riga:os.environ['CUDA_VISIBLE_DEVICES']

Se la funzione sopra riportata ritorna, Trueciò non significa necessariamente che si sta utilizzando la GPU. In Pytorch puoi allocare tensori ai dispositivi quando li crei. Per impostazione predefinita, i tensori vengono assegnati a cpu. Per verificare dove è allocato il tuo tensore, procedi come segue:

# assuming that 'a' is a tensor created somewhere else
a.device  # returns the device where the tensor is allocated

Si noti che non è possibile operare su tensori allocati in diversi dispositivi. Per vedere come allocare un tensore per la GPU, vedere qui: https://pytorch.org/docs/stable/notes/cuda.html

Quasi tutte le risposte qui fanno riferimento torch.cuda.is_available(). Tuttavia, questa è solo una parte della medaglia. Ti dice se la GPU (in realtà CUDA) è disponibile, non se viene effettivamente utilizzata. In una configurazione tipica, dovresti impostare il tuo dispositivo con qualcosa del genere:

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")

ma in ambienti più grandi (ad es. ricerca) è anche comune offrire all'utente più opzioni, quindi in base all'input possono disabilitare CUDA, specificare gli ID CUDA e così via. In tal caso, l'utilizzo o meno della GPU non si basa solo sulla disponibilità o meno. Dopo che il dispositivo è stato impostato su un dispositivo torcia, è possibile ottenere la sua typeproprietà per verificare se è CUDA o meno.

if device.type == 'cuda':
    # do something

Semplicemente dal prompt dei comandi o dall'ambiente Linux, eseguire il comando seguente.

python -c 'import torch; print(torch.cuda.is_available())'

Quanto sopra dovrebbe essere stampato True

python -c 'import torch; print(torch.rand(2,3).cuda())'

Questo dovrebbe stampare quanto segue:

tensor([[0.7997, 0.6170, 0.7042], [0.4174, 0.1494, 0.0516]], device='cuda:0')

Se siete qui perché il vostro pytorch dà sempre Falsepertorch.cuda.is_available() quello probabilmente perché hai installato la tua versione di pytorch senza supporto GPU. (Ad esempio: hai eseguito la codifica nel computer portatile e poi hai testato sul server).

La soluzione è disinstallare e installare nuovamente pytorch con il comando corretto dalla pagina di download di pytorch . Riferisci anche questo problema di Pytorch.

Creare un tensore sulla GPU come segue:

$ python
>>> import torch
>>> print(torch.rand(3,3).cuda()) 

Non uscire, apri un altro terminale e controlla se il processo python sta usando la GPU usando:

$ nvidia-smi