Quelle #39 la différence entre la remodelage et la vue en pytorch?

Question

Dans numpy, nous utilisons `` pour remodeler un tableau.

J'ai remarqué que dans pytorch, les gens utilisent pour le même but, mais en même temps, il ya aussi un existant.

Donc, je me demande quelles sont les différences entre eux et quand je devrais utiliser l'un d'eux?

Answer 1

torch.view a existé pendant une longue période. Il sera de retour un tenseur avec la nouvelle forme. Le retour de l'tenseur partagera le sous-fifre de données avec le tenseur d'origine. Voir la documentation ici.

D'autre part, il semble qu' torch.reshape a été introduite récemment dans la version 0.4. Selon le document, cette méthode

Retourne un tenseur avec les mêmes données et le nombre d'éléments en entrée, mais avec une forme. Lorsque cela est possible, le retour de l'tenseur va être une vue de l'entrée. Sinon, il sera une copie. Contiguë entrées et les entrées compatible avec le progrès peut être modifiée sans la copier, mais vous ne devrait pas dépendre de la copie vs affichage de comportement.

Cela signifie qu' torch.reshape peut retourner une copie ou d'une vue sur le tenseur d'origine. Vous ne pouvez pas compter sur que pour revenir à une vue ou une copie. Selon le développeur:

si vous avez besoin d'une copie de l'utilisation clone() si vous avez besoin de la même stockage, l'utilisation afficher(). La sémantique de remodeler (), il peut ou peut ne pas partager le stockage et vous ne savez pas à l'avance.

Une autre différence est que l' reshape() peuvent fonctionner sur les deux contigus et non contigus du tenseur de tout view() ne peut fonctionner que sur contiguë tenseur. Voir aussi ici sur le sens de l' contiguous.

Answer 2

Bien que les deux torch.view et torch.reshape sont utilisés pour transformer les tenseurs, voici les différences entre eux.

1. Comme son nom l'indique, torch.view crée simplement une vue de l'tenseur d'origine. Le nouveau tenseur sera toujours partager ses données avec le tenseur d'origine. Cela signifie que si vous modifiez le tenseur d'origine, une reconfiguration du tenseur de change et vice versa.

>>> z = torch.zeros(3, 2)
>>> x = z.view(2, 3)
>>> z.fill_(1)
>>> x
tensor([[1., 1., 1.],
        [1., 1., 1.]])

2. Pour s'assurer que le nouveau tenseur toujours partage ses données avec l'original, torch.view impose certaines contraintes de contiguïté sur les formes des deux tenseurs [docs]. Le plus souvent ce n'est pas un problème, mais parfois, torch.view déclenche une erreur, même si les formes des deux tenseurs sont compatibles. Voici un célèbre contre-exemple.

>>> z = torch.zeros(3, 2)
>>> y = z.t()
>>> y.size()
torch.Size([2, 3])
>>> y.view(6)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: invalid argument 2: view size is not compatible with input tensor's
size and stride (at least one dimension spans across two contiguous subspaces).
Call .contiguous() before .view().

3. torch.reshape n'impose pas la contiguïté des contraintes, mais aussi de ne pas garantir le partage des données. Le nouveau tenseur peut être une vue de l'tenseur d'origine, ou il peut être un nouveau tenseur complètement.

>>> z = torch.zeros(3, 2)
>>> y = z.reshape(6)
>>> x = z.t().reshape(6)
>>> z.fill_(1)
tensor([[1., 1.],
        [1., 1.],
        [1., 1.]])
>>> y
tensor([1., 1., 1., 1., 1., 1.])
>>> x
tensor([0., 0., 0., 0., 0., 0.])

TL;DR:
Si vous voulez juste pour remodeler les tenseurs, utilisez torch.reshape. Si vous êtes aussi préoccupé par l'utilisation de la mémoire et vous voulez vous assurer que les deux tenseurs de partager les mêmes données, utilisez torch.view.

Answer 3

est plus robuste. Il fonctionnera sur n'importe quel tenseur, tandis que ne fonctionne que sur le tenseur où .

Pour expliquer sur non-contigus et contigus est une autre histoire de temps, mais vous pouvez toujours faire le tenseur contigu est que vous appelez et puis vous pouvez appeler sans `` l'erreur.