Jak sprawdzić czy pytorch korzysta z GPU?

Chciałbym wiedzieć, czy pytorchużywa mojego GPU. Można wykryć, nvidia-smiczy w trakcie procesu występuje jakakolwiek aktywność GPU, ale chcę, aby coś było napisane w pythonskrypcie.

Czy jest na to sposób?

To zadziała:

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

To mówi mi, że procesor graficzny GeForce GTX 950Mjest używany przez PyTorch.

Ponieważ nie zostało to tutaj zaproponowane, dodaję metodę wykorzystującą torch.device, ponieważ jest to dość przydatne, również podczas inicjalizacji tensorów na poprawnej 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')

Wynik:

Using device: cuda

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

Jak wspomniano powyżej, stosując deviceto możliwe :

• Aby przenieść tensory do odpowiednich device:

  torch.rand(10).to(device)

• Aby utworzyć tensor bezpośrednio na device:

  torch.rand(10, device=device)

Co sprawia, że ​​przełączanie między procesorem a GPU jest wygodne bez zmiany rzeczywistego kodu.

Edytować:

Ponieważ pojawiło się kilka pytań i nieporozumień dotyczących pamięci podręcznej i przydzielonej , dodam dodatkowe informacje na ten temat:

• torch.cuda.max_memory_cached(device=None)
  
  Zwraca maksymalną ilość pamięci GPU zarządzanej przez alokator buforowania w bajtach dla danego urządzenia.
  

• torch.cuda.memory_allocated(device=None)
  
  Zwraca bieżące użycie pamięci GPU przez tensory w bajtach dla danego urządzenia.

Możesz bezpośrednio przekazać, devicejak określono powyżej w poście, lub pozostawić Brak i użyje rozszerzenia current_device().

Po uruchomieniu pętli szkoleniowej, jeśli chcesz ręcznie obserwować ją z poziomu terminala, czy Twój program wykorzystuje zasoby GPU iw jakim stopniu, możesz po prostu użyć watch:

$ watch -n 2 nvidia-smi

Spowoduje to ciągłą aktualizację statystyk użytkowania co 2 sekundy, aż do naciśnięcia ctrl+c

Jeśli potrzebujesz większej kontroli nad większą liczbą statystyk GPU, których możesz potrzebować, możesz użyć bardziej wyrafinowanej wersji programu nvidia-smiwith--query-gpu=... . Poniżej znajduje się prosta ilustracja tego:

$ 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

który wyświetli statystyki takie jak:

Uwaga : między nazwami zapytań oddzielonych przecinkami w programie nie powinno być spacji --query-gpu=.... W przeciwnym razie te wartości zostaną zignorowane i żadne statystyki nie zostaną zwrócone.

Możesz również sprawdzić, czy Twoja instalacja PyTorch poprawnie wykrywa instalację CUDA, wykonując:

In [13]: import  torch

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

Trueoznacza status że PyTorch jest prawidłowo skonfigurowany i jest przy użyciu GPU chociaż trzeba przesunąć / umieścić tensory z niezbędnych instrukcji w kodzie.

Jeśli chcesz to zrobić wewnątrz kodu Pythona, spójrz na ten moduł:

https://github.com/jonsafari/nvidia-ml-py lub w pypi tutaj: https://pypi.python.org/pypi/nvidia-ml-py/

W witrynie biura i na stronie startowej sprawdź GPU dla PyTorch, jak poniżej:

import torch
torch.cuda.is_available()

Źródła : PyTorch | Rozpocznij

Z praktycznego punktu widzenia tylko jedna drobna dygresja:

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

To devteraz wie, czy CUDA czy CPU.

I jest różnica, jak radzisz sobie z modelem i tensorami podczas przechodzenia do CUDA. Na początku jest to trochę dziwne.

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

To wszystko jest trudne, a zrozumienie tego raz pomaga szybko poradzić sobie z mniejszym debugowaniem.

Aby sprawdzić, czy jest dostępny procesor graficzny:

torch.cuda.is_available()

Jeśli powyższa funkcja zwróci False,

1. albo nie masz GPU,
2. lub sterowniki Nvidia nie zostały zainstalowane, więc system operacyjny nie widzi GPU,
3. lub procesor graficzny jest ukrywany przez zmienną środowiskową CUDA_VISIBLE_DEVICES. Gdy wartość CUDA_VISIBLE_DEVICESwynosi -1, wszystkie urządzenia są ukrywane. Możesz sprawdzić tę wartość w kodzie za pomocą tej linii:os.environ['CUDA_VISIBLE_DEVICES']

Jeśli powyższa funkcja zwróci True, niekoniecznie oznacza to, że używasz GPU. W Pytorch możesz przydzielać tensory do urządzeń podczas ich tworzenia. Domyślnie tensory są przydzielane do cpu. Aby sprawdzić, gdzie jest przydzielony twój tensor, wykonaj:

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

Zauważ, że nie możesz operować na tensorach przydzielonych do różnych urządzeń. Aby zobaczyć, jak przydzielić tensor do GPU, zobacz tutaj: https://pytorch.org/docs/stable/notes/cuda.html

Prawie wszystkie odpowiedzi tutaj odnoszą się torch.cuda.is_available(). Jednak to tylko jedna część medalu. Informuje, czy procesor graficzny (a właściwie CUDA) jest dostępny, a nie, czy jest rzeczywiście używany. W typowej konfiguracji możesz ustawić urządzenie na coś takiego:

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

ale w większych środowiskach (np. badania) często daje się użytkownikowi więcej opcji, więc na podstawie danych wejściowych może wyłączyć CUDA, określić identyfikatory CUDA i tak dalej. W takim przypadku to, czy procesor graficzny jest używany, nie zależy tylko od tego, czy jest dostępny, czy nie. Po ustawieniu urządzenia jako latarki można uzyskać jego typewłaściwość, aby sprawdzić, czy jest to CUDA, czy nie.

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

Po prostu z wiersza poleceń lub środowiska Linux uruchom następujące polecenie.

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

Powyższe powinno zostać wydrukowane True

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

Ten powinien wydrukować:

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

Jeśli jesteś tu, ponieważ pytorch zawsze daje Falseza torch.cuda.is_available()to prawdopodobnie dlatego, że zainstalowano wersję pytorch bez wsparcia GPU. (Np .: zakodowałeś na laptopie, a potem testowałeś na serwerze).

Rozwiązaniem jest odinstalowanie i ponowne zainstalowanie programu pytorch za pomocą odpowiedniego polecenia ze strony pobierania programu pytorch . Odnieś się też do tego problemu z pytorchem.

Utwórz tensor na GPU w następujący sposób:

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

Nie wychodź, otwórz inny terminal i sprawdź, czy proces Pythona używa GPU za pomocą:

$ nvidia-smi