Debuggen von Pytorch-Speicherleckproblemen mithilfe von Kontextdekoratoren

Dekoratoren sind spezifische Implementierungen von Python-Kontextmanagern. In diesem Artikel wird die Verwendung anhand eines Beispiels für das Debuggen einer Pytorch-GPU veranschaulicht. Auch wenn es nicht in jeder Situation funktioniert, empfand ich sie als sehr nützlich.

Probleme mit Speicherlecks beheben

Es gibt viele Möglichkeiten, Speicherlecks zu beheben. In diesem Artikel wird eine nützliche Methode zum Identifizieren problematischer Zeilen in Ihrem Code demonstriert. Diese Methode kann dabei helfen, den spezifischen Standort präzise zu finden.

Manuelles Debuggen Zeile für Zeile

Wenn Sie auf ein Problem stoßen, besteht eine klassische und häufig verwendete Methode darin, den Debugger zur zeilenweisen Überprüfung zu verwenden, wie im folgenden Beispiel:

• Finden Sie in der Suchmaschine, wie man berechnet Alle Tensoren in Pytorch Gesamtcode-Snippet, zum Beispiel: tensor-counter-snippet
• Setzen Sie Haltepunkte im Code
• Verwenden Sie tensor-counter-snippet, um Gesamttensorstatistiken zu erhalten
• Verwenden Sie den Debugger, um den nächsten Schritt auszuführen
• Führen Sie den Tensor erneut aus - Counter-Snippet und prüfen, ob die Tensoranzahl erhöht wird
• Wiederholen Sie die obigen Schritte

Es funktioniert, aber eine solche Operation klingt umständlich. Wir können es in eine Funktion kapseln, die bei Bedarf aufgerufen werden kann, sodass der vorhandene Code fast nicht geändert werden muss, was uns dazu veranlasst, die Funktion des Dekorators einzuführen.

Python-Dekoratoren

Dekoratoren können in jeden Teil des Codes eingebunden werden. Hier verwenden wir den Dekorator, um zu prüfen, ob zusätzliche Tensoren vorhanden sind. Darüber hinaus benötigen wir auch einen Zähler, da die Anzahl der Tensoren vor und nach der Ausführung berechnet werden muss. Das Muster sieht so aus:

def memleak_wrapper(func):
def wrap(*args, **kwargs):
print("num tensors start is ...")
out = func(*args, **kwargs)
print("num tensors end is ...")
return out
return wrap@memleak_wrapper
 def function_to_debug(x):
print(f"put line(s) of code here. Input is {x}")
out = x + 10
return outout = function_to_debug(x=1000)
 print(f"out is {out}")
 
 #输入类似这样
 #num tensors start is ...
 #put line(s) of code here. Input is 1000
 #num tensors end is ...
 #outis 1010

Um diesen Code auszuführen, müssen wir die Codezeile, die wir überprüfen möchten, in eine Funktion (function_to_debug) einfügen. Dies ist jedoch nicht das Beste, da wir immer noch viel Code manuell einfügen müssen. Die andere Sache ist, dass Sie, wenn der Codeblock mehr als eine Variable generiert, zusätzliche Lösungen finden müssen, um diese Downstream-Variablen zu verwenden.

Kontextdekorator

Um das oben genannte Problem zu lösen, können wir den Kontextmanager anstelle des Funktionsdekorators verwenden. Das am häufigsten verwendete Beispiel für einen Kontextmanager ist die Instanziierung eines Kontexts mithilfe der with-Anweisung. Die gebräuchlichste war früher:

with open("file") as f:
…

Mit der contextlib-Bibliothek von Python können Python-Benutzer ganz einfach selbst Kontextmanager erstellen. In diesem Artikel werden wir also ContextDecorator verwenden, um die Arbeit abzuschließen, die wir oben mit Decorator versucht haben. Weil es einfacher zu entwickeln und einfacher zu verwenden ist:

 from contextlib import ContextDecorator
 
 class check_memory_leak_context(ContextDecorator):
def __enter__(self):
print('Starting')
return self
 
def __exit__(self, *exc):
print('Finishing')
return False

ContextDecorator verfügt über zwei Methoden: enter() und exit(), die aufgerufen werden, wenn wir den Kontext betreten oder verlassen. Der Parameter *exc in __exit__ stellt jede eingehende Ausnahme dar.

Nun nutzen wir es, um das oben genannte Problem zu lösen.

Verwenden Sie ContextDecorator, um Speicherlecks zu finden

Da wir die Gesamtzahl der Tensoren berechnen müssen, kapseln wir den Berechnungsprozess in eine Funktion get_n_tensors(), damit die Anzahl der Tensoren am Anfang und Ende des Kontexts berechnet werden kann :

class check_memory_leak_context(ContextDecorator):
def __enter__(self):
self.start = get_n_tensors()
return self def __exit__(self, *exc):
self.end = get_n_tensors()
increase = self.end — self.start
 
if increase > 0:
print(f”num tensors increased with"
f"{self.end — self.start} !”)
else:
print(”no added tensors”)
return False

Wenn es Erhöhungen gibt, drucken Sie diese auf der Konsole aus.

get_n_tensor() verwendet einen Garbage Collector (GC) und ist für Pytorch angepasst, kann aber leicht für andere Bibliotheken geändert werden:

 import gc
 def get_n_tensors():
tensors= []
for obj in gc.get_objects():
try:
if (torch.is_tensor(obj) or
(hasattr(obj, ‘data’) and
torch.is_tensor(obj.data))):
tensors.append(obj)
except:
pass
return len(tensors)

Es funktioniert jetzt, wir verwenden dies für jede Codezeile (oder jeden Block) Kontext:

 x = arbitrary_operation(x)
 ...
 with check_memory_leak_context():
y = x[0].permute(1, 2, 0).cpu().detach().numpy()
x = some_harmless_operation()
 ...
 x = another_arbitrary_operation(x)

Wenn innerhalb der vom Kontextdekorator umschlossenen Zeile ein neuer Tensor erstellt wird, wird dieser gedruckt.

Zusammenfassung

Dies ist ein sehr gutes Code-Snippet. Sie können es während der Entwicklung in eine separate Datei einfügen. Hier ist der vollständige Code dieses Artikels:

https://gist.github.com/MarkTension /4783697ebd5212ba500cdd829b364338

Abschließend hoffe ich, dass dieser kleine Artikel Ihnen helfen kann zu verstehen, was ein Kontextmanager ist, wie man Kontextdekoratoren verwendet und wie man sie zum Debuggen von Pytorch anwendet.

Das obige ist der detaillierte Inhalt vonDebuggen von Pytorch-Speicherleckproblemen mithilfe von Kontextdekoratoren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!