Respuestas:
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 950M
está siendo utilizada por PyTorch
.
torch.cuda.current_device()
fue útil para mí. Demostró que mi gpu es desafortunadamente demasiado vieja: "Se encontró GPU0 GeForce GTX 760 que tiene la capacidad de 3.0 cuda. PyTorch ya no es compatible con esta GPU porque es demasiado vieja".
torch.cuda.is_available()
$ watch -n 2 nvidia-smi
hace el trabajo. Para más detalles, vea mi respuesta a continuación .
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 device
es 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.
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 device
como se especifica más arriba en la publicación o puede dejarlo Ninguno y usará el current_device()
.
## neural network in pytorch
, luego agrego su código al final. Todavía muestra Usando dispositivo: cuda; y 0 Gb para asignado y en caché. También intenté insertarlo al final del ciclo for for i in range(epoch):
después de la propagación hacia atrás, todavía todos
my_tensor_on_gpu * my_tensor_on_cpu
fallará.
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.
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 watch
como 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-smi
with--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
True
El 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/
watch
es útil
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.
M()
? ¿Dónde se M
define?
Para verificar si hay una GPU disponible:
torch.cuda.is_available()
Si la función anterior vuelve False
,
CUDA_VISIBLE_DEVICES
. Cuando el valor de CUDA_VISIBLE_DEVICES
es -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, 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 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 type
propiedad 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 False
portorch.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
nvidia-smi
desde la línea de comandos
nvidia-smi
.