Como verificar se o pytorch está usando a GPU?

Gostaria de saber se pytorchestá usando minha GPU. É possível detectar nvidia-smise há alguma atividade da GPU durante o processo, mas quero algo escrito em umpython script.

Tem algum jeito de fazer isso?

Isso vai 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

Isso me diz que a GPU GeForce GTX 950Mestá sendo usada por PyTorch.

Como não foi proposto aqui, estou adicionando um método usando torch.device, pois isso é bastante útil, também ao inicializar os tensores no correto 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')

Resultado:

Using device: cuda

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

Como mencionado acima, deviceé possível usar :

• Para mover os tensores para os respectivos device:

  torch.rand(10).to(device)

• Para criar um tensor diretamente no device:

  torch.rand(10, device=device)

O que torna a alternância entre CPU e GPU confortável, sem alterar o código real.

Editar:

Como houve algumas perguntas e confusão sobre a memória em cache e alocada , estou adicionando algumas informações adicionais sobre isso:

• torch.cuda.max_memory_cached(device=None)
  
  Retorna a memória GPU máxima gerenciada pelo alocador de cache em bytes para um determinado dispositivo.
  

• torch.cuda.memory_allocated(device=None)
  
  Retorna o uso atual da memória da GPU por tensores em bytes para um determinado dispositivo.

Você pode entregar diretamente um deviceconforme especificado mais acima na postagem ou deixá-lo Nenhum e ele usará o current_device().

Depois de começar a executar o ciclo de treinamento, se você quiser assistir manualmente a partir do terminal, se o seu programa está utilizando os recursos da GPU e até que ponto, você pode simplesmente usá-lo watchcomo em:

$ watch -n 2 nvidia-smi

Isso atualizará continuamente as estatísticas de uso a cada 2 segundos até você pressionar ctrl+c

Se você precisar de mais controle sobre mais estatísticas da GPU, poderá usar a versão mais sofisticada do nvidia-smiwith--query-gpu=... . Abaixo está uma ilustração simples disso:

$ 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 produziria as estatísticas algo como:

Nota : Não deve haver nenhum espaço entre os nomes de consulta separados por vírgula --query-gpu=.... Caso contrário, esses valores serão ignorados e nenhuma estatística será retornada.

Além disso, você pode verificar se sua instalação do PyTorch detecta sua instalação CUDA corretamente, fazendo:

In [13]: import  torch

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

Truestatus significa que o PyTorch está configurado corretamente e está usando a GPU, embora você precise mover / colocar os tensores com as instruções necessárias em seu código.

Se você quiser fazer isso dentro do código Python, consulte este módulo:

https://github.com/jonsafari/nvidia-ml-py ou em pypi aqui: https://pypi.python.org/pypi/nvidia-ml-py/

No site do escritório e na página inicial, verifique a GPU do PyTorch, conforme abaixo:

import torch
torch.cuda.is_available()

Referência: PyTorch | Introdução

Do ponto de vista prático, apenas uma pequena digressão:

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

este dev agora sabe se cuda ou cpu.

E há uma diferença em como você lida com o modelo e com os tensores ao mudar para cuda. É um pouco estranho no começo.

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

Tudo isso é complicado e compreendê-lo uma vez, ajuda a lidar rapidamente com menos depuração.

Para verificar se há uma GPU disponível:

torch.cuda.is_available()

Se a função acima retornar False,

1. você não tem GPU,
2. ou os drivers da Nvidia não foram instalados para que o sistema operacional não veja a GPU,
3. ou a GPU está sendo ocultada pela variável ambiental CUDA_VISIBLE_DEVICES. Quando o valor de CUDA_VISIBLE_DEVICESé -1, todos os seus dispositivos estão sendo ocultos. Você pode verificar esse valor no código com esta linha:os.environ['CUDA_VISIBLE_DEVICES']

Se a função acima retornar, Trueisso não significa necessariamente que você está usando a GPU. No Pytorch, você pode alocar tensores para os dispositivos ao criá-los. Por padrão, os tensores são alocados para cpu. Para verificar onde seu tensor está alocado, faça:

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

Observe que você não pode operar em tensores alocados em dispositivos diferentes. Para ver como alocar um tensor para a GPU, consulte aqui: https://pytorch.org/docs/stable/notes/cuda.html

Quase todas as respostas aqui referenciam torch.cuda.is_available(). No entanto, isso é apenas uma parte da moeda. Indica se a GPU (atualmente CUDA) está disponível, não se está realmente sendo usada. Em uma configuração típica, você configuraria seu dispositivo com algo como isto:

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

mas em ambientes maiores (por exemplo, pesquisa) também é comum oferecer ao usuário mais opções; portanto, com base na entrada, eles podem desativar o CUDA, especificar IDs de CUDA e assim por diante. Nesse caso, o uso ou não da GPU não se baseia apenas em sua disponibilidade ou não. Depois que o dispositivo for definido como um dispositivo de tocha, você poderá obter sua typepropriedade para verificar se é CUDA ou não.

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

Simplesmente no prompt de comando ou no ambiente Linux, execute o seguinte comando.

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

O acima deve ser impresso True

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

Este deve imprimir o seguinte:

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

Se você está aqui porque seu pytorch sempre dá Falseparatorch.cuda.is_available() isso é provavelmente porque você instalou a sua versão pytorch sem o apoio GPU. (Por exemplo: você codificou no laptop e depois testou no servidor).

A solução é desinstalar e instalar o pytorch novamente com o comando certo na página de downloads do pytorch . Consulte também este problema de pytorch.

Crie um tensor na GPU da seguinte maneira:

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

Não saia, abra outro terminal e verifique se o processo python está usando a GPU usando:

$ nvidia-smi