Beste Methode, um ein trainiertes Modell in PyTorch zu speichern?

War ich auf der Suche nach alternativen Möglichkeiten, um speichern Sie eine trainierte Modell in PyTorch. Bisher habe ich zwei alternativen gefunden.

Fackel.save() zum speichern einer Modell-und Fackel.load() ein Modell laden.
Modell.state_dict() speichern Sie eine trainierte Modell und Modell.load_state_dict() laden des gespeicherten Modells.

Komme ich in dieses Diskussion wo der Ansatz 2 ist besser als Methode 1.

Meine Frage ist, warum der zweite Ansatz ist vorzuziehen? Ist es nur, weil Fackel.nn Module haben diese beiden Funktionen sind und wir werden ermutigt, Sie zu nutzen?

InformationsquelleAutor der Frage Wasi Ahmad | 2017-03-09

78

Habe ich gefunden auf dieser Seite auf Ihre github-repo, ich werde fügen Sie den Inhalt hier.

Empfohlene Vorgehensweise zum speichern einer Modell

Gibt es zwei wesentliche Ansätze für die Serialisierung und die Wiederherstellung eines Modells.

Die erste (empfohlen) speichert und lädt nur die Modell-Parameter:
```
torch.save(the_model.state_dict(), PATH)
```
Dann später:
```
the_model = TheModelClass(*args, **kwargs)
the_model.load_state_dict(torch.load(PATH))
```
Die zweite speichert und lädt das gesamte Modell:
```
torch.save(the_model, PATH)
```
Dann später:
```
the_model = torch.load(PATH)
```
Jedoch in diesem Fall die serialisierten Daten ist gebunden an die spezifische Klassen
und die exakte Verzeichnis-Struktur verwendet, so kann es zu brechen in verschiedene Arten, wenn
in anderen Projekten verwendet, oder nach einigen schweren refactors.

InformationsquelleAutor der Antwort dontloo
24

Es hängt davon ab, was Sie tun möchten.

Fall # 1: Speichern Sie das Modell zu verwenden, es selbst für eine Schlussfolgerung: speichern Sie das Modell, das Sie wiederherstellen, und dann ändern Sie das Modell bis zur Auswertung-Modus. Dies geschieht, weil Sie haben in der Regel BatchNorm und Dropout Ebenen, die standardmäßig im Zug-Modus auf dem Bau:
```
torch.save(model.state_dict(), filepath)

#Later to restore:
model.load_state_dict(torch.load(filepath))
model.eval()
```
Fall # 2: Speichern von Modell zu Lebenslauf Ausbildung später: Wenn Sie brauchen, um die Ausbildung das Modell, das Sie zu speichern, müssen Sie mehr sparen, als nur das Modell. Sie müssen auch zum speichern des Zustand des Optimierers, Epochen, Note, etc. Sie würde es so machen:
```
state = {
    'epoch': epoch,
    'state_dict': model.state_dict(),
    'optimizer': optimizer.state_dict(),
    ...
}
torch.save(state, filepath)
```
Fortsetzen Ausbildung würden Sie Dinge tun, wie: state = torch.load(filepath)und dann, zur Wiederherstellung der Zustand jedes einzelnen Objekts, so etwas wie dieses:
```
model.load_state_dict(state['state_dict'])
optimizer.load_state_dict(stata['optimizer'])
```
Da Sie die Wiederaufnahme der Ausbildung, die NICHT anrufen model.eval() sobald Sie wieder die Staaten beim laden.

Fall # 3: Modell von jemand anderem verwendet werden, die keinen Zugang zu Ihren code:
In Tensorflow können Sie erstellen eine .pb - Datei, definiert die Architektur und die GEWICHTE des Modells. Dies ist sehr praktisch, speziell bei der Verwendung von Tensorflow serve. Die entsprechende Möglichkeit, dies zu tun in Pytorch wäre:
```
torch.save(model, filepath)

# Then later:
model = torch.load(filepath)
```
Dieser Weg ist noch nicht bullet proof, und da pytorch ist noch in eine Menge änderungen, ich würde es nicht empfehlen.

InformationsquelleAutor der Antwort Jadiel de Armas
0

Menschen, die dies Lesen, möchten vielleicht auch, um einen Blick auf torch.onnx.

https://github.com/onnx/tutorials/blob/master/tutorials/PytorchOnnxExport.ipynb

InformationsquelleAutor der Antwort f1confusion

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Empfohlene Vorgehensweise zum speichern einer Modell