Esto debería funcionar:

 import torch torch.cuda.is_available() >>> True torch.cuda.current_device() >>> 0 torch.cuda.device(0) >>> <torch.cuda.device at 0x7efce0b03be0> torch.cuda.device_count() >>> 1 torch.cuda.get_device_name(0) >>> 'GeForce GTX 950M'

Esto me dice que CUDA está disponible y se puede usar en uno de sus dispositivos (GPU). Y actualmente, PyTorch utiliza el Device 0 o la GPU GeForce GTX 950M PyTorch .

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 usar el watch como en:

 $ watch -n 2 nvidia-smi

Esto actualizará continuamente las estadísticas de uso 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-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:

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

El estado True significa que PyTorch está configurado correctamente y está usando 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, consulte este módulo:

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

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

En el sitio de la oficina y en la página de inicio, verifique GPU para PyTorch como se muestra a continuación:

 import torch torch.cuda.is_available()

Referencia: PyTorch|Comenzar

Como no se ha propuesto aquí, estoy agregando un método usando torch.device , ya que es bastante útil, también cuando se inicializan los tensores en el device correcto.

 # 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 el device es posible :

• Para mover tensores al device respectivo:

   torch.rand(10).to(device)

• Para crear un tensor directamente en el device :

   torch.rand(10, device=device)

Lo que hace que cambiar 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 almacenada 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 de memoria GPU actual por tensores en bytes para un dispositivo determinado.

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

Nota adicional: ¡Las tarjetas gráficas antiguas con capacidad de cómputo Cuda 3.0 o inferior pueden estar visibles pero no pueden ser utilizadas por Pytorch!
¡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".

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, todos sus dispositivos se ocultan. 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. De forma predeterminada, 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 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

Si está aquí porque su pytorch siempre da False para torch.cuda.is_available() , probablemente se deba a que instaló su versión de pytorch sin compatibilidad con GPU. (Por ejemplo: codificaste en la computadora portátil y luego probaste en el servidor).

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

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 desarrollador ahora sabe si dev 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.

Casi todas las respuestas aquí hacen referencia torch.cuda.is_available() . Sin embargo, eso es sólo una parte de la moneda. Le dice 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 brindar al usuario más opciones, de modo que, en función de la entrada, puedan 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. Una vez que el dispositivo se ha configurado como un dispositivo antorcha, puede obtener su propiedad de type 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 debe imprimir lo siguiente:

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

Usando el código de abajo

 import torch torch.cuda.is_available()

solo mostrará si la GPU está presente y detectada por pytorch o no.

Pero en el "administrador de tareas -> rendimiento", la utilización de la GPU será muy pequeña.

Lo que significa que en realidad está ejecutando usando la CPU.

Para resolver el problema anterior, verifique y cambie:

1. Configuración de gráficos --> Active la configuración de GPU acelerada por hardware, reinicie.
2. Abra el panel de control de NVIDIA -> Escritorio -> Mostrar GPU en el área de notificación [Nota: si ha instalado Windows recientemente, también debe aceptar los términos y condiciones en el panel de control de NVIDIA]

¡Esto debería funcionar!