J'ai acheté ce livre parce que je voulais en savoir plus sur PyTorch.
Après avoir comparé certains d'entre eux, j'ai choisi celui pour les débutants, mais ... `Je ne sais pas! !! !! C'est devenu ". _ ** Je n'ai pas écrit la sortie, donc je ne sais pas quelle est la sortie et quel type de point de vue je devrais vérifier! !! ** _
Donc, j'ai mis en place un ** supplément ** qui dit que c'est probablement ce que j'essaie de dire. L'environnement d'exécution est Google Colaboratory.
Comme préparation préliminaire, installez PyTorch.
IN
import torch
PyTorch utilise le GPU. Vérifions si le GPU est disponible.
IN
#Vérifiez si le GPU est disponible
print(torch.cuda.is_available())
OUT
True
Selon le livre, Tensor est
--Une structure de données pour la gestion de tableaux multidimensionnels --A presque la même API que le ndarray de Numpy
C'est vrai.
En bref, c'est le «tableau multidimensionnel» de PyTorch. Dans le livre, il y avait des explications et des exemples de code de désordre et de types de données, mais je viens de le définir ** Je n'ai pas du tout confirmé le contenu **. Donc, ** je vais vérifier les données **.
IN
#Créer en passant une liste imbriquée
t = torch.tensor([[1, 2], [3, 4.]])
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t
OUT
dtype: torch.float32
device: cpu
tensor([[1., 2.],
[3., 4.]])
«dtype» est le type de données, et «device» indique si le Tensor est sur le CPU ou le GPU. Créons un Tensor sur le GPU.
IN
t = torch.tensor([[1, 2], [2, 4.]], device="cuda:0")
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t
OUT
dtype: torch.float32
device: cuda:0
tensor([[1., 2.],
[2., 4.]], device='cuda:0')
Il semble que vous puissiez également créer un Tensor sur le GPU avec torch.cuda.FloatTensor.
IN
t = torch.cuda.FloatTensor([[1, 2], [2, 4.]])
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t
dtype: torch.float32
device: cuda:0
tensor([[1., 2.],
[2., 4.]], device='cuda:0')
À propos, cuda est selon Wikipedia
CUDA (Compute Unified Device Architecture) est une plate-forme de calcul parallèle polyvalente (architecture de calcul parallèle) et un modèle de programmation pour les GPU développés et fournis par NVIDIA.
C'est vrai.
Modifions maintenant le type de données.
IN
#Spécifiez le type de données 64 bits
t = torch.tensor([[1, 2], [2, 4.]], dtype=torch.float64)
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t
OUT
dtype: torch.float64
device: cpu
tensor([[1., 2.],
[2., 4.]], dtype=torch.float64)
Un entier signé 64 bits peut également être défini avec torch.LongTensor.
IN
t = torch.LongTensor([[1, 2], [2, 4.]])
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t
OUT
dtype: torch.int64
device: cpu
tensor([[1, 2],
[2, 4]])
Les types de données sont résumés dans ce document. https://pytorch.org/docs/stable/tensors.html
Essayez de transférer le Tensor créé sur le CPU vers le GPU.
IN
t = torch.zeros(100, 10).to("cuda:0")
print("dtype: {}\ndevice: {}".format(t.dtype, t.device))
t[:2] #Les tranches sont également disponibles dans Tensor
OUT
dtype: torch.float32
device: cuda:0
tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], device='cuda:0')
Si vous voulez vérifier la forme de Tensor, utilisez la fonction de taille au lieu de la fonction de forme.
Ceci est différent de NumPy.
IN
#la forme est obtenue par la taille
# t.shape() #Erreur de compilation
t.size()
OUT
torch.Size([100, 10])
Utilisez la fonction numpy pour convertir Tensor en ndarray de Numpy.
IN
t = torch.tensor([[1, 2], [3, 4.]])
x = t.numpy()
print("type: {}".format(type(x)))
x
OUT
type: <class 'numpy.ndarray'>
array([[1., 2.],
[3., 4.]], dtype=float32)
Tensor sur GPU doit être converti en CPU.
IN
t = torch.cuda.FloatTensor([[1, 2], [3, 4.]])
x = t.to("cpu").numpy()
print("type: {}".format(type(x)))
x
OUT
type: <class 'numpy.ndarray'>
array([[1., 2.],
[3., 4.]], dtype=float32)
Essayons une manière déroutante de convertir Tensor.
Le remodelage dans Numpy est exécuté par la fonction de vue.
IN
# 2 *2 à 4*Changer en 1
#la vue est similaire au remodelage de ndarray
x1 = torch.tensor([[1, 2], [3, 4.]])
x1.view(4, 1)
OUT
tensor([[1.],
[2.],
[3.],
[4.]])
Il existe plusieurs manières d'écrire une translocation.
IN
x2 = torch.tensor([[10, 20, 30], [40, 50, 60.]])
x2.T
OUT
tensor([[10., 40.],
[20., 50.],
[30., 60.]])
IN
x2.t()
OUT
tensor([[10., 40.],
[20., 50.],
[30., 60.]])
La transposition peut également être transposée, mais en plus de la transposition, elle peut également être utilisée pour trier le format des données d'image de HWC (vertical, horizontal, couleur) à CHW (couleur, horizontal, vertical).
IN
hwc_img_data = torch.rand(1, 5, 4, 3)
hwc_img_data
OUT
tensor([[[[0.9248, 0.7545, 0.5603],
[0.5339, 0.6627, 0.7652],
[0.7082, 0.5146, 0.9273],
[0.8437, 0.7064, 0.1053]],
[[0.2080, 0.8018, 0.6833],
[0.5892, 0.9264, 0.9315],
[0.0872, 0.1898, 0.5745],
[0.2192, 0.1187, 0.7537]],
[[0.9680, 0.9239, 0.8698],
[0.2339, 0.9918, 0.3446],
[0.6669, 0.4148, 0.2037],
[0.1055, 0.0353, 0.3679]],
[[0.7079, 0.4069, 0.1181],
[0.1983, 0.0452, 0.5788],
[0.6378, 0.7050, 0.1148],
[0.3960, 0.1924, 0.2714]],
[[0.3127, 0.1320, 0.7232],
[0.3484, 0.7617, 0.4725],
[0.4863, 0.9178, 0.3092],
[0.6279, 0.4259, 0.3828]]]])
J'ai en quelque sorte compris que je changerais de 1 * 5 * 4 * 3 à 1 * 4 * 5 * 3 (5 et 4 seraient interchangés).
IN
# 1 * 5 * 4 *3 à 1* 4 * 5 *Changer en 3
hwc_img_data.transpose(1, 2)
OUT
tensor([[[[0.9248, 0.7545, 0.5603],
[0.2080, 0.8018, 0.6833],
[0.9680, 0.9239, 0.8698],
[0.7079, 0.4069, 0.1181],
[0.3127, 0.1320, 0.7232]],
[[0.5339, 0.6627, 0.7652],
[0.5892, 0.9264, 0.9315],
[0.2339, 0.9918, 0.3446],
[0.1983, 0.0452, 0.5788],
[0.3484, 0.7617, 0.4725]],
[[0.7082, 0.5146, 0.9273],
[0.0872, 0.1898, 0.5745],
[0.6669, 0.4148, 0.2037],
[0.6378, 0.7050, 0.1148],
[0.4863, 0.9178, 0.3092]],
[[0.8437, 0.7064, 0.1053],
[0.2192, 0.1187, 0.7537],
[0.1055, 0.0353, 0.3679],
[0.3960, 0.1924, 0.2714],
[0.6279, 0.4259, 0.3828]]]])
IN
#1 de plus* 4 * 5 *3 à 1* 3 * 4 *Changer en 5
#Maintenant, vous pouvez convertir de hwc en cwh
hwc_img_data.transpose(1, 2).transpose(1, 3)
OUT
tensor([[[[0.9248, 0.5339, 0.7082, 0.8437],
[0.2080, 0.5892, 0.0872, 0.2192],
[0.9680, 0.2339, 0.6669, 0.1055],
[0.7079, 0.1983, 0.6378, 0.3960],
[0.3127, 0.3484, 0.4863, 0.6279]],
[[0.7545, 0.6627, 0.5146, 0.7064],
[0.8018, 0.9264, 0.1898, 0.1187],
[0.9239, 0.9918, 0.4148, 0.0353],
[0.4069, 0.0452, 0.7050, 0.1924],
[0.1320, 0.7617, 0.9178, 0.4259]],
[[0.5603, 0.7652, 0.9273, 0.1053],
[0.6833, 0.9315, 0.5745, 0.7537],
[0.8698, 0.3446, 0.2037, 0.3679],
[0.1181, 0.5788, 0.1148, 0.2714],
[0.7232, 0.4725, 0.3092, 0.3828]]]])
La différenciation automatique est effectuée lorsque l'attribut requires_grad est défini sur True. Le livre ne décrit pas en détail où et ce qui apparaîtra, je vais donc l'ajouter.
IN
x = torch.randn(100, 3)
a = torch.tensor([1, 2, 3.], requires_grad=True)
y = torch.mv(x, a)
print(y.grad_fn) #Assurez-vous que le graphique de calcul pour le calcul du gradient est stocké
o = y.sum()
#Obtenez un dégradé
#Les variables qui fonctionnent à l'envers doivent être scalaires
o.backward()
#Une différenciation automatique est effectuée, un.Le gradient est acquis en grad
print(a.grad)
a.grad != x.sum(0)
OUT
<MvBackward object at 0x7f9c7998e3c8>
tensor([ 2.5016, 6.3925, -6.3674])
tensor([False, False, False])
Recommended Posts