PyTorch - zusammenhängend ()

Ich habe dieses Beispiel eines LSTM-Sprachmodells auf Github (Link) durchgearbeitet . Was es im Allgemeinen macht, ist mir ziemlich klar. Aber ich habe immer noch Schwierigkeiten zu verstehen, was das Aufrufen contiguous()bewirkt, was im Code mehrmals vorkommt.

Beispielsweise werden in Zeile 74/75 der Codeeingabe und Zielsequenzen des LSTM erstellt. Daten (gespeichert in ids) sind zweidimensional, wobei die erste Dimension die Stapelgröße ist.

for i in range(0, ids.size(1) - seq_length, seq_length):
    # Get batch inputs and targets
    inputs = Variable(ids[:, i:i+seq_length])
    targets = Variable(ids[:, (i+1):(i+1)+seq_length].contiguous())

So wie ein einfaches Beispiel, bei der Verwendung von Losgröße 1 und seq_length10 inputsund targetssieht wie folgt aus :

inputs Variable containing:
0     1     2     3     4     5     6     7     8     9
[torch.LongTensor of size 1x10]

targets Variable containing:
1     2     3     4     5     6     7     8     9    10
[torch.LongTensor of size 1x10]

Im Allgemeinen ist meine Frage also, was macht contiguous()und warum brauche ich es?

Außerdem verstehe ich nicht, warum die Methode für die Zielsequenz und nicht für die Eingabesequenz aufgerufen wird, da beide Variablen aus denselben Daten bestehen.

Wie könnte es targetsnicht zusammenhängend und inputsdennoch zusammenhängend sein?

BEARBEITEN: Ich habe versucht, das Anrufen wegzulassen contiguous(), aber dies führt zu einer Fehlermeldung bei der Berechnung des Verlusts.

RuntimeError: invalid argument 1: input is not contiguous at .../src/torch/lib/TH/generic/THTensor.c:231

Daher ist es offensichtlich contiguous()notwendig, dieses Beispiel aufzurufen .

(Um dies lesbar zu halten, habe ich es vermieden, den vollständigen Code hier zu veröffentlichen. Er kann über den obigen GitHub-Link gefunden werden.)

Danke im Voraus!

Es gibt nur wenige Operationen für Tensor in PyTorch, die den Inhalt des Tensors nicht wirklich ändern, sondern nur, wie Indizes in Tensor in Byte-Position konvertiert werden. Diese Operationen umfassen:

narrow(), view(), expand()Undtranspose()

Beispiel: Wenn Sie aufrufen transpose(), generiert PyTorch keinen neuen Tensor mit neuem Layout, sondern ändert lediglich die Metainformationen im Tensor-Objekt, sodass Versatz und Schritt für eine neue Form gelten. Der transponierte Tensor und der ursprüngliche Tensor teilen tatsächlich die Erinnerung!

x = torch.randn(3,2)
y = torch.transpose(x, 0, 1)
x[0, 0] = 42
print(y[0,0])
# prints 42

Hier kommt das Konzept des Zusammenhängens ins Spiel . Oben xist zusammenhängend, aber ynicht, weil sich sein Speicherlayout von einem Tensor derselben Form unterscheidet, der von Grund auf neu erstellt wurde. Beachten Sie, dass das Wort "zusammenhängend" etwas irreführend ist, da der Inhalt des Tensors nicht auf nicht verbundene Speicherblöcke verteilt ist. Hier werden Bytes noch in einem Speicherblock zugeordnet, aber die Reihenfolge der Elemente ist unterschiedlich!

Wenn Sie aufrufen contiguous(), wird tatsächlich eine Kopie des Tensors erstellt, sodass die Reihenfolge der Elemente dieselbe ist, als ob der Tensor derselben Form von Grund auf neu erstellt worden wäre.

Normalerweise brauchen Sie sich darüber keine Sorgen zu machen. Wenn PyTorch einen zusammenhängenden Tensor erwartet, dies aber nicht der Fall RuntimeError: input is not contiguousist, erhalten Sie einen Anruf und fügen ihn einfach hinzu contiguous().

Aus der [Pytorch-Dokumentation] [1]:

zusammenhängend () → Tensor

Returns a contiguous tensor containing the same data as self 

Tensor. Wenn der Selbsttensor zusammenhängend ist, gibt diese Funktion den Selbsttensor zurück.

Wo contiguoushier nicht nur zusammenhängend im Speicher bedeutet, sondern auch in derselben Reihenfolge im Speicher wie die Indexreihenfolge: Wenn Sie beispielsweise eine Transposition durchführen, werden die Daten im Speicher nicht geändert, sondern wenn Sie dann einfach die Zuordnung von Indizes zu Speicherzeigern ändern Beim Anwenden contiguous()werden die Daten im Speicher so geändert, dass die Zuordnung von Indizes zum Speicherort kanonisch ist. [1]: http://pytorch.org/docs/master/tensors.html

tensor.contiguous () erstellt eine Kopie des Tensors, und das Element in der Kopie wird zusammenhängend im Speicher gespeichert. Die zusammenhängende () Funktion wird normalerweise benötigt, wenn wir zuerst einen Tensor transponieren () und ihn dann umformen (anzeigen). Lassen Sie uns zunächst einen zusammenhängenden Tensor erstellen:

aaa = torch.Tensor( [[1,2,3],[4,5,6]] )
print(aaa.stride())
print(aaa.is_contiguous())
#(3,1)
#True

Die Rückgabe von stride () (3,1) bedeutet: Wenn wir uns bei jedem Schritt (Zeile für Zeile) entlang der ersten Dimension bewegen, müssen wir 3 Schritte im Speicher verschieben. Wenn wir uns entlang der zweiten Dimension (Spalte für Spalte) bewegen, müssen wir 1 Schritt im Speicher verschieben. Dies zeigt an, dass die Elemente im Tensor zusammenhängend gespeichert sind.

Jetzt versuchen wir, Come-Funktionen auf den Tensor anzuwenden:

bbb = aaa.transpose(0,1)
print(bbb.stride())
print(bbb.is_contiguous())

#(1, 3)
#False


ccc = aaa.narrow(1,1,2)   ## equivalent to matrix slicing aaa[:,1:3]
print(ccc.stride())
print(ccc.is_contiguous())

#(3, 1)
#False


ddd = aaa.repeat(2,1)   # The first dimension repeat once, the second dimension repeat twice
print(ddd.stride())
print(ddd.is_contiguous())

#(3, 1)
#True


## expand is different from repeat.
## if a tensor has a shape [d1,d2,1], it can only be expanded using "expand(d1,d2,d3)", which
## means the singleton dimension is repeated d3 times
eee = aaa.unsqueeze(2).expand(2,3,3)
print(eee.stride())
print(eee.is_contiguous())

#(3, 1, 0)
#False


fff = aaa.unsqueeze(2).repeat(1,1,8).view(2,-1,2)
print(fff.stride())
print(fff.is_contiguous())

#(24, 2, 1)
#True

Ok, wir können feststellen, dass transponieren (), schmales () und Tensor-Schneiden und expandieren () den erzeugten Tensor nicht zusammenhängend machen. Interessanterweise macht repeat () und view () es nicht uneinheitlich. Die Frage ist nun: Was passiert, wenn ich einen nicht zusammenhängenden Tensor verwende?

Die Antwort ist, dass die view () -Funktion nicht auf einen nicht zusammenhängenden Tensor angewendet werden kann. Dies liegt wahrscheinlich daran, dass view () erfordert, dass der Tensor zusammenhängend gespeichert wird, damit er sich schnell im Speicher umformen kann. z.B:

bbb.view(-1,3)

Wir werden den Fehler bekommen:

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-63-eec5319b0ac5> in <module>()
----> 1 bbb.view(-1,3)

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(). at /pytorch/aten/src/TH/generic/THTensor.cpp:203

Um dies zu lösen, fügen Sie einfach contiguous () zu einem nicht zusammenhängenden Tensor hinzu, um eine zusammenhängende Kopie zu erstellen, und wenden Sie dann view () an.

bbb.contiguous().view(-1,3)
#tensor([[1., 4., 2.],
        [5., 3., 6.]])

Da in der vorherigen Antwort contigous () zusammenhängende Speicherblöcke zugewiesen wurden , ist es hilfreich, wenn wir den Tensor an c- oder c ++ - Backend-Code übergeben, in dem Tensoren als Zeiger übergeben werden

Die akzeptierten Antworten waren so großartig und ich habe versucht, den transpose()Funktionseffekt zu täuschen . Ich habe die beiden Funktionen erstellt, mit denen das samestorage()und das überprüft werden können contiguous.

def samestorage(x,y):
    if x.storage().data_ptr()==y.storage().data_ptr():
        print("same storage")
    else:
        print("different storage")
def contiguous(y):
    if True==y.is_contiguous():
        print("contiguous")
    else:
        print("non contiguous")

Ich habe dieses Ergebnis als Tabelle überprüft und erhalten:

Sie können den Prüfcode unten überprüfen, aber geben wir ein Beispiel, wenn der Tensor nicht zusammenhängend ist . Wir können view()diesen Tensor nicht einfach anrufen , wir würden ihn brauchen reshape()oder wir könnten auch anrufen .contiguous().view().

x = torch.randn(3,2)
y = x.transpose(0, 1)
y.view(6) # RuntimeError: view size is not compatible with input tensor's size and stride (at least one dimension spans across two contiguous subspaces). Use .reshape(...) instead.
  
x = torch.randn(3,2)
y = x.transpose(0, 1)
y.reshape(6)

x = torch.randn(3,2)
y = x.transpose(0, 1)
y.contiguous().view(6)

Weiterhin ist zu beachten, dass es Methoden gibt, die am Ende zusammenhängende und nicht zusammenhängende Tensoren erzeugen . Es gibt Methoden, die auf demselben Speicher ausgeführt werden können , und einige Methoden flip()erstellen einen neuen Speicher (lesen: Klonen des Tensors) vor der Rückkehr.

Der Prüfcode:

import torch
x = torch.randn(3,2)
y = x.transpose(0, 1) # flips two axes
print("\ntranspose")
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\nnarrow")
x = torch.randn(3,2)
y = x.narrow(0, 1, 2) #dim, start, len  
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\npermute")
x = torch.randn(3,2)
y = x.permute(1, 0) # sets the axis order
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\nview")
x = torch.randn(3,2)
y=x.view(2,3)
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\nreshape")
x = torch.randn(3,2)
y = x.reshape(6,1)
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\nflip")
x = torch.randn(3,2)
y = x.flip(0)
print(x)
print(y)
contiguous(y)
samestorage(x,y)

print("\nexpand")
x = torch.randn(3,2)
y = x.expand(2,-1,-1)
print(x)
print(y)
contiguous(y)
samestorage(x,y) 

Soweit ich das verstehe, eine zusammengefasstere Antwort:

Zusammenhängend ist der Begriff, der verwendet wird, um anzuzeigen, dass das Speicherlayout eines Tensors nicht mit seinen angekündigten Metadaten oder Forminformationen übereinstimmt.

Meiner Meinung nach ist das Wort "zusammenhängend" ein verwirrender / irreführender Begriff, da es in normalen Kontexten bedeutet, dass das Gedächtnis nicht in getrennten Blöcken verteilt ist (dh "zusammenhängend / verbunden / kontinuierlich").

Einige Vorgänge benötigen diese zusammenhängende Eigenschaft möglicherweise aus irgendeinem Grund (höchstwahrscheinlich Effizienz in GPU usw.).

Beachten Sie, dass dies .viewein weiterer Vorgang ist, der dieses Problem verursachen kann. Schauen Sie sich den folgenden Code an, den ich durch einfaches Aufrufen von zusammenhängend behoben habe (anstelle des typischen Transponierungsproblems, das ihn hier verursacht, ist dies ein Beispiel, das verursacht wird, wenn ein RNN mit seiner Eingabe nicht zufrieden ist):

        # normal lstm([loss, grad_prep, train_err]) = lstm(xn)
        n_learner_params = xn_lstm.size(1)
        (lstmh, lstmc) = hs[0] # previous hx from first (standard) lstm i.e. lstm_hx = (lstmh, lstmc) = hs[0]
        if lstmh.size(1) != xn_lstm.size(1): # only true when prev lstm_hx is equal to decoder/controllers hx
            # make sure that h, c from decoder/controller has the right size to go into the meta-optimizer
            expand_size = torch.Size([1,n_learner_params,self.lstm.hidden_size])
            lstmh, lstmc = lstmh.squeeze(0).expand(expand_size).contiguous(), lstmc.squeeze(0).expand(expand_size).contiguous()
        lstm_out, (lstmh, lstmc) = self.lstm(input=xn_lstm, hx=(lstmh, lstmc))

Fehler, den ich bekommen habe:

RuntimeError: rnn: hx is not contiguous

Quellen / Ressource:

• https://discuss.pytorch.org/t/contigious-vs-non-contigious-tensor/30107/7
• PyTorch - zusammenhängend ()