¿Cómo verifico si PyTorch está usando la GPU?

9 minutos de lectura

avatar de usuario
Vinzee

¿Cómo verifico si PyTorch está usando la GPU? los nvidia-smi El comando puede detectar la actividad de la GPU, pero quiero verificarlo directamente desde dentro de un script de Python.

  • ¿Hay alguna manera de obtener una lista de todos los gpus disponibles actualmente? algo como devices = torch.get_all_devices() # [0, 1, 2] or whatever their name is

    –Charlie Parker

    10 de noviembre de 2020 a las 19:57

  • Consulte stackoverflow.com/questions/64776822/…: [torch.cuda.device(i) for i in range(torch.cuda.device_count())]

    – Vinzee

    10 de noviembre de 2020 a las 21:14

  • me dijeron que esto funciona list(range(torch.cuda.device_count())). ¡Gracias!

    –Charlie Parker

    11 de noviembre de 2020 a las 14:31

  • @CharlieParker, te gustaría (suponiendo que hayas import torch): devices = [d for d in range(torch.cuda.device_count())] Y si quieres los nombres: device_names = [torch.cuda.get_device_name(d) for d in devices] Es posible que, como yo, desee mapear estos como dict para la gestión de máquinas cruzadas: device_to_name = dict( device_names, devices )

    – hola_allí_andy

    7 oct 2021 a las 0:32


avatar de usuario
Vinzee

Estas funciones deberían ayudar:

>>> import torch

>>> torch.cuda.is_available()
True

>>> torch.cuda.device_count()
1

>>> torch.cuda.current_device()
0

>>> torch.cuda.device(0)
<torch.cuda.device at 0x7efce0b03be0>

>>> torch.cuda.get_device_name(0)
'GeForce GTX 950M'

Esto nos dice:

  • CUDA está disponible y puede ser utilizado por un dispositivo.
  • Device 0 se refiere a la GPU GeForce GTX 950My PyTorch lo elige actualmente.

  • Creo que esto solo muestra que estos dispositivos están disponibles en la máquina, pero no estoy seguro de si puede obtener la cantidad de memoria que se usa de cada GPU más o menos.

    – kmario23

    10 de enero de 2018 a las 1:12

  • correr torch.cuda.current_device() fue útil para mí. Mostró que, lamentablemente, mi gpu es demasiado antigua: “GPU0 GeForce GTX 760 encontrada, que tiene capacidad cuda 3.0. PyTorch ya no es compatible con esta GPU porque es demasiado antigua”.

    – JohnnyFun

    3 de marzo de 2019 a las 14:22

  • torch.cuda.is_available()

    – mrgloom

    24 de marzo de 2019 a las 12:40

  • @ kmario23 Gracias por señalar esto. ¿Hay una llamada de función que nos proporcione esa información (cuánta memoria utiliza cada GPU)? 🙂

    – Nathan

    31 de julio de 2019 a las 1:08

  • @frank Sí, simplemente este comando: $ watch -n 2 nvidia-smi hace el trabajo. Para obtener más detalles, consulte mi respuesta a continuación.

    – kmario23

    31 de julio de 2019 a las 3:07

avatar de usuario
MBT

Como no se ha propuesto aquí, estoy agregando un método usando torch.deviceya que esto es bastante útil, también al inicializar tensores en el 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_reserved(0)/1024**3,1), 'GB')

Editar: torch.cuda.memory_cached ha sido renombrado a torch.cuda.memory_reserved. Así que usa memory_cached para versiones anteriores.

Producción:

Using device: cuda

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

Como se mencionó anteriormente, usando device es posible que:

  • A Muevete tensores a los respectivos device:

    torch.rand(10).to(device)
    
  • A crear un tensor directamente sobre el device:

    torch.rand(10, device=device)
    

Lo que hace cambiar entre UPC y GPU cómodo sin cambiar el código real.


Editar:

Como ha habido algunas preguntas y confusión sobre el en caché y asignado memory Estoy agregando información adicional al respecto:

Puede entregar directamente un device como se especifica más arriba en la publicación o puede dejarlo Ninguna y utilizará el current_device().


Nota adicional: las tarjetas gráficas antiguas con capacidad de cómputo Cuda 3.0 o inferior pueden verse, pero Pytorch no puede usarlas.
¡Gracias a hekimgil por señalar esto! – “GPU0 GeForce GT 750M encontrada que tiene capacidad cuda 3.0. PyTorch ya no es compatible con esta GPU porque es demasiado antigua. La capacidad cuda mínima que admitimos es 3.5”.

  • Probé tu código, reconoce la tarjeta gráfica, pero la asignada y la almacenada en caché son 0 GB. ¿Es normal o necesito configurarlos?

    – KubiK888

    29 de marzo de 2019 a las 17:04

  • @ KubiK888 Si no ha realizado ningún cálculo antes, esto es perfectamente normal. También es poco probable que pueda detectar el modelo de GPU dentro de PyTorch pero no acceder a él. Intente hacer algunos cálculos en GPU y debería ver que los valores cambian.

    – MBT

    29 de marzo de 2019 a las 18:05

  • @ KubiK888 Debe ser coherente, no puede realizar operaciones entre dispositivos. Cualquier operación como my_tensor_on_gpu * my_tensor_on_cpu fallará.

    – MBT

    29 de marzo de 2019 a las 20:28

  • Su respuesta es excelente, pero para la primera línea de asignación de dispositivos, me gustaría señalar que el hecho de que haya un dispositivo cuda disponible no significa que podamos usarlo. Por ejemplo, tengo esto en mi vieja computadora de confianza: Found GPU0 GeForce GT 750M which is of cuda capability 3.0. PyTorch no longer supports this GPU because it is too old. The minimum cuda capability that we support is 3.5.

    – hekimgil

    11 de marzo de 2020 a las 1:24


  • @CharlieParker No he probado esto, pero creo que puedes usar torch.cuda.device_count() dónde list(range(torch.cuda.device_count())) debería darle una lista sobre todos los índices de dispositivos.

    – MBT

    11 de noviembre de 2020 a las 7:21

avatar de usuario
kmario23

Después de comenzar a ejecutar el ciclo de entrenamiento, si desea a mano mírelo desde la terminal si su programa está utilizando los recursos de GPU y en qué medida, entonces simplemente puede usar watch como en:

$ watch -n 2 nvidia-smi

Esto actualizará continuamente las estadísticas de uso cada 2 segundos hasta que presione control+C


Si necesita más control sobre más estadísticas de GPU que pueda necesitar, puede usar versión más sofisticada de nvidia-smi con --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

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

ingrese la descripción de la imagen aquí

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


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

In [13]: import  torch

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

True estado significa que PyTorch está configurado correctamente y es usando la GPU aunque tiene que mover/colocar los tensores con las declaraciones necesarias en su código.


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

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

  • Solo recuerda que PyTorch usa un asignador de memoria de GPU en caché. Es posible que vea GPU-Utill baja para nividia-smi, incluso si se usa por completo.

    – Jakub Bielan

    29 de marzo de 2019 a las 14:19

  • @JakubBielan gracias! ¿podría proporcionar una referencia para leer más sobre esto?

    – kmario23

    22 de abril de 2019 a las 14:35

  • Que watch es útil

    – Proyectos de la costa oeste

    10 de abril de 2020 a las 4:37

  • esto es solo para linux?

    – Gulzar

    7 oct 2020 a las 16:05

  • nvidia-smi tiene un indicador -l para segundos de bucle, por lo que no tiene que usar watch: nvidia-smi -l 2 O en milisegundos: nvidia-smi -lms 2000

    – meferne

    28 de septiembre de 2021 a las 13:37

avatar de usuario
prosti

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")

Este dev ahora sabe si cuda o cpu.

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

import torch
import torch.nn as nn
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 lo ayuda a lidiar rápidamente con menos depuración.

avatar de usuario
TiempoCostura

Desde la página de inicio del sitio oficial, puede verificar si la GPU está disponible para PyTorch de la siguiente manera:

import torch
torch.cuda.is_available()

Referencia: PyTorch | Empezar

Consulta Dominio
¿PyTorch ve alguna GPU? torch.cuda.is_available()
¿Los tensores se almacenan en la GPU de forma predeterminada? torch.rand(10).device
Establezca el tipo de tensor predeterminado en CUDA: torch.set_default_tensor_type(torch.cuda.FloatTensor)
¿Es este tensor un tensor GPU? my_tensor.is_cuda
¿Este modelo está almacenado en la GPU? all(p.is_cuda for p in my_model.parameters())

Para comprobar si hay una GPU disponible:

torch.cuda.is_available()

Si la función anterior devuelve 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_DEVICES es -1, entonces todos sus dispositivos están ocultos. Puede verificar ese valor en el código con esta línea: os.environ['CUDA_VISIBLE_DEVICES']

Si la función anterior devuelve True eso no significa necesariamente que esté utilizando la GPU. En Pytorch puede asignar tensores a dispositivos cuando los crea. Por defecto, los tensores se asignan al 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 en 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

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad