Comment vérifier si pytorch utilise le GPU?

Je voudrais savoir si j'utilise pytorchmon GPU. Il est possible de détecter avec nvidia-smis'il y a une activité du GPU pendant le processus, mais je veux quelque chose d'écrit dans un pythonscript.

Y a-t-il un moyen de le faire?

Cela va fonctionner:

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

Cela me dit que le GPU GeForce GTX 950Mest utilisé par PyTorch.

Comme cela n'a pas été proposé ici, j'ajoute une méthode utilisant torch.device, car c'est assez pratique, également lors de l'initialisation des tenseurs sur le bon 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')

Production:

Using device: cuda

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

Comme mentionné ci-dessus, en utilisant deviceil est possible de :

• Pour déplacer les tenseurs vers les respectifs device:

  torch.rand(10).to(device)

• Pour créer un tenseur directement sur le device:

  torch.rand(10, device=device)

Ce qui rend la commutation entre CPU et GPU confortable sans changer le code réel.

Éditer:

Comme il y a eu des questions et de la confusion sur la mémoire mise en cache et allouée, j'ajoute des informations supplémentaires à ce sujet:

• torch.cuda.max_memory_cached(device=None)
  
  Renvoie la mémoire GPU maximale gérée par l'allocateur de mise en cache en octets pour un périphérique donné.
  

• torch.cuda.memory_allocated(device=None)
  
  Renvoie l'utilisation actuelle de la mémoire du GPU par tenseurs en octets pour un appareil donné.

Vous pouvez soit remettre directement un devicecomme spécifié ci-dessus dans le message, soit le laisser Aucun et il utilisera le current_device().

Une fois que vous avez commencé à exécuter la boucle d'entraînement, si vous souhaitez la regarder manuellement à partir du terminal, si votre programme utilise les ressources GPU et dans quelle mesure, vous pouvez simplement utiliser watchcomme dans:

$ watch -n 2 nvidia-smi

Cela mettra continuellement à jour les statistiques d'utilisation toutes les 2 secondes jusqu'à ce que vous appuyiez sur ctrl+c

Si vous avez besoin de plus de contrôle sur plus de statistiques GPU dont vous pourriez avoir besoin, vous pouvez utiliser une version plus sophistiquée de nvidia-smiavec--query-gpu=... . Voici une illustration simple de ceci:

$ 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

qui produirait les statistiques quelque chose comme:

Remarque : il ne doit pas y avoir d'espace entre les noms de requête séparés par des virgules dans --query-gpu=.... Sinon, ces valeurs seront ignorées et aucune statistique n'est renvoyée.

En outre, vous pouvez vérifier si votre installation de PyTorch détecte correctement votre installation CUDA en faisant:

In [13]: import  torch

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

Truedes moyens d'état qui PyTorch est correctement configuré et est en utilisant le GPU bien que vous devez déplacer / placer les tenseurs avec les déclarations nécessaires dans votre code.

Si vous voulez faire cela dans le code Python, regardez dans ce module:

https://github.com/jonsafari/nvidia-ml-py ou dans pypi ici: https://pypi.python.org/pypi/nvidia-ml-py/

Sur le site du bureau et la page de démarrage, vérifiez le GPU pour PyTorch comme ci-dessous:

import torch
torch.cuda.is_available()

Référence: PyTorch | Commencer

D'un point de vue pratique, une petite digression:

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

Ce dev sait maintenant si cuda ou cpu.

Et il y a une différence dans la façon dont vous gérez le modèle et les tenseurs lorsque vous passez à cuda. C'est un peu étrange au début.

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

Tout cela est délicat et le comprendre une fois, vous aide à traiter rapidement avec moins de débogage.

Pour vérifier si un GPU est disponible:

torch.cuda.is_available()

Si la fonction ci-dessus renvoie False,

1. soit vous n'avez pas de GPU,
2. ou les pilotes Nvidia n'ont pas été installés donc le système d'exploitation ne voit pas le GPU,
3. ou le GPU est masqué par la variable d'environnement CUDA_VISIBLE_DEVICES. Lorsque la valeur de CUDA_VISIBLE_DEVICESest -1, tous vos appareils sont masqués. Vous pouvez vérifier cette valeur dans le code avec cette ligne:os.environ['CUDA_VISIBLE_DEVICES']

Si la fonction ci-dessus revient, Truecela ne signifie pas nécessairement que vous utilisez le GPU. Dans Pytorch, vous pouvez attribuer des tenseurs aux appareils lorsque vous les créez. Par défaut, les tenseurs sont alloués au cpu. Pour vérifier où votre tenseur est alloué, procédez comme suit:

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

Notez que vous ne pouvez pas opérer sur des tenseurs alloués dans différents appareils. Pour voir comment allouer un tenseur au GPU, voir ici: https://pytorch.org/docs/stable/notes/cuda.html

Presque toutes les réponses ici font référence torch.cuda.is_available(). Cependant, ce n'est qu'une partie de la pièce. Il vous indique si le GPU (en fait CUDA) est disponible, pas s'il est réellement utilisé. Dans une configuration typique, vous définiriez votre appareil avec quelque chose comme ceci:

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

mais dans les environnements plus larges (par exemple la recherche), il est également courant de donner plus d'options à l'utilisateur, donc en fonction des entrées, ils peuvent désactiver CUDA, spécifier les ID CUDA, etc. Dans ce cas, le fait que le GPU soit utilisé ou non ne dépend pas uniquement de sa disponibilité ou non. Une fois que l'appareil a été défini sur un appareil torche, vous pouvez obtenir sa typepropriété pour vérifier s'il s'agit de CUDA ou non.

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

Simplement à partir de l'invite de commande ou de l'environnement Linux, exécutez la commande suivante.

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

Ce qui précède devrait imprimer True

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

Celui-ci devrait imprimer ce qui suit:

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

Si vous êtes ici parce que votre pytorch donne toujours Falsepour torch.cuda.is_available()c'est probablement parce que vous avez installé votre version pytorch sans support GPU. (Par exemple: vous avez codé dans un ordinateur portable puis testez sur le serveur).

La solution est de désinstaller et de réinstaller pytorch avec la bonne commande depuis la page de téléchargement de pytorch . Reportez-vous également à ce numéro de pytorch.

Créez un tenseur sur le GPU comme suit:

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

Ne quittez pas, ouvrez un autre terminal et vérifiez si le processus python utilise le GPU en utilisant:

$ nvidia-smi