¿Cómo verificar si pytorch está usando la GPU?

Me gustaría saber si pytorchestá usando mi GPU. Es posible detectar nvidia-smisi hay alguna actividad de la GPU durante el proceso, pero quiero algo escrito en un pythonscript.

¿Hay una manera de hacerlo?

Esto va a funcionar :

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

Esto me dice que la GPU GeForce GTX 950Mestá siendo utilizada por PyTorch.

Como no se ha propuesto aquí, estoy agregando un método usando torch.device, ya que esto es bastante útil, también al inicializar los tensores en el correcto 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')

Salida:

Using device: cuda

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

Como se mencionó anteriormente, su uso devicees posible :

• Para mover los tensores a los respectivos device:

  torch.rand(10).to(device)

• Para crear un tensor directamente en device:

  torch.rand(10, device=device)

Lo que hace que el cambio entre CPU y GPU sea cómodo sin cambiar el código real.

Editar:

Como ha habido algunas preguntas y confusión sobre la memoria en caché y asignada , estoy agregando información adicional al respecto:

• torch.cuda.max_memory_cached(device=None)
  
  Devuelve la memoria de GPU máxima administrada por el asignador de almacenamiento en caché en bytes para un dispositivo determinado.
  

• torch.cuda.memory_allocated(device=None)
  
  Devuelve el uso actual de la memoria de la GPU por los tensores en bytes para un dispositivo dado.

Puede entregar directamente uno devicecomo se especifica más arriba en la publicación o puede dejarlo Ninguno y usará el current_device().

Después de comenzar a ejecutar el ciclo de entrenamiento, si desea verlo manualmente desde la terminal si su programa está utilizando los recursos de la GPU y en qué medida, simplemente puede usarlo watchcomo en:

$ watch -n 2 nvidia-smi

Esto actualizará continuamente las estadísticas de uso por cada 2 segundos hasta que presione ctrl+c

Si necesita más control sobre más estadísticas de GPU que pueda necesitar, puede usar una versión más sofisticada de nvidia-smiwith--query-gpu=... . A continuación se muestra una ilustración simple de esto:

$ 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

que generaría las estadísticas algo así como:

Nota : No debe haber ningún espacio entre los nombres de consulta separados por comas en --query-gpu=.... De lo contrario, esos valores serán ignorados y no se devolverán estadísticas.

Además, puede verificar si su instalación de PyTorch detecta su instalación CUDA correctamente haciendo lo siguiente:

In [13]: import  torch

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

TrueEl estado significa que PyTorch está configurado correctamente y está utilizando la GPU, aunque debe mover / colocar los tensores con las declaraciones necesarias en su código.

Si desea hacer esto dentro del código de Python, busque en este módulo:

https://github.com/jonsafari/nvidia-ml-py o en pypi aquí: https://pypi.python.org/pypi/nvidia-ml-py/

En el sitio de la oficina y en la página de inicio, verifique la GPU para PyTorch de la siguiente manera:

import torch
torch.cuda.is_available()

Referencia: PyTorch | Comenzar

Desde el punto de vista práctico, solo una digresión menor:

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

Esta dev ahora sabe si cuda o cpu.

Y hay una diferencia en cómo manejas el modelo y los tensores cuando te mueves a cuda. Es un poco extraño al principio.

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

Todo esto es complicado y comprenderlo una vez te ayuda a lidiar rápidamente con menos depuración.

Para verificar si hay una GPU disponible:

torch.cuda.is_available()

Si la función anterior vuelve False,

1. o no tienes GPU,
2. o los controladores de Nvidia no se han instalado, por lo que el sistema operativo no ve la GPU,
3. o la GPU está oculta por la variable ambiental CUDA_VISIBLE_DEVICES. Cuando el valor de CUDA_VISIBLE_DEVICESes -1, todos sus dispositivos están ocultos. Puede verificar ese valor en código con esta línea:os.environ['CUDA_VISIBLE_DEVICES']

Si la función anterior vuelve, Trueeso no significa necesariamente que esté utilizando la GPU. En Pytorch puede asignar tensores a dispositivos cuando los crea. Por defecto, los tensores se asignan a la cpu. Para verificar dónde está asignado su tensor, haga lo siguiente:

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

Tenga en cuenta que no puede operar con tensores asignados en diferentes dispositivos. Para ver cómo asignar un tensor a la GPU, consulte aquí: https://pytorch.org/docs/stable/notes/cuda.html

Casi todas las respuestas aquí hacen referencia torch.cuda.is_available(). Sin embargo, eso es solo una parte de la moneda. Le indica si la GPU (en realidad CUDA) está disponible, no si realmente se está utilizando. En una configuración típica, configuraría su dispositivo con algo como esto:

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

pero en entornos más grandes (p. ej., investigación) también es común dar al usuario más opciones, por lo que, según la entrada, puede deshabilitar CUDA, especificar ID de CUDA, etc. En tal caso, si se usa o no la GPU no solo se basa en si está disponible o no. Después de que el dispositivo se haya configurado en un dispositivo de antorcha, puede obtener su typepropiedad para verificar si es CUDA o no.

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

Simplemente desde el símbolo del sistema o el entorno Linux ejecute el siguiente comando.

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

Lo anterior debe imprimir True

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

Este debería imprimir lo siguiente:

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

Si estás aquí porque tu pytorch siempre da Falseportorch.cuda.is_available() , probablemente sea porque instaló su versión de pytorch sin soporte de GPU. (Por ejemplo: codificó en una computadora portátil y luego realizó una prueba en el servidor).

La solución es desinstalar e instalar pytorch nuevamente con el comando correcto de la página de descargas de pytorch . Consulte también este problema de pytorch.

Cree un tensor en la GPU de la siguiente manera:

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

No salga, abra otra terminal y verifique si el proceso de Python está usando la GPU usando:

$ nvidia-smi