Réponses:
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 950M
est utilisé par PyTorch
.
torch.cuda.current_device()
été utile pour moi. Il a montré que mon GPU est malheureusement trop vieux: "On a trouvé le GPU0 GeForce GTX 760 qui est de capacité cuda 3.0. PyTorch ne prend plus en charge ce GPU car il est trop ancien."
torch.cuda.is_available()
$ watch -n 2 nvidia-smi
fait le travail. Pour plus de détails, veuillez consulter ma réponse ci-dessous .
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 device
il 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.
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 device
comme spécifié ci-dessus dans le message, soit le laisser Aucun et il utilisera le current_device()
.
## neural network in pytorch
, puis j'ajoute votre code à la fin. Il montre toujours Utilisation de l'appareil: cuda; et 0 Go pour Allocated et Cached. for i in range(epoch):
my_tensor_on_gpu * my_tensor_on_cpu
ci échouera.
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.
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 watch
comme 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-smi
avec--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
True
des 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/
watch
utile
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.
M()
? Où est M
défini?
Pour vérifier si un GPU est disponible:
torch.cuda.is_available()
Si la fonction ci-dessus renvoie False
,
CUDA_VISIBLE_DEVICES
. Lorsque la valeur de CUDA_VISIBLE_DEVICES
est -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, True
cela 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 type
proprié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 False
pour 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
nvidia-smi
de la ligne de commande
nvidia-smi
.