[PYTHON] Probieren Sie die neue Scheduler-Verkettung in PyTorch 1.4 aus

Einführung

Haben Sie ein Upgrade auf PyTorch 1.4 durchgeführt? Wenn Sie dies noch nicht getan haben, können Sie von Offiziell hier herausfinden, wie Sie ein Upgrade durchführen können. (Bitte beachten Sie, dass die Python 2-Serie ab der nächsten Version nicht mehr unterstützt wird.)

Als neue Funktion von PyTorch 1.4 wurde die Verkettungsfunktion ** Scheduler ** leise hinzugefügt. (Klicken Sie hier für Versionshinweise) Versuchen Sie es sofort.

Was ist Scheduler?

Mit Scheduler können Sie die Lernrate für jede Epoche ändern. Je höher die Lernrate, desto schneller schreitet das Lernen voran. Wenn die Lernrate jedoch zu hoch bleibt, besteht die Gefahr, dass die optimale Lösung übersprungen wird. Daher ist es üblich, beim Lernen von NN Scheduler zu verwenden und die Lernrate mit zunehmender Anzahl von Epochen schrittweise zu senken. (Obwohl dies nicht direkt mit dieser Geschichte zusammenhängt, beachten Sie bitte, dass der PyTorch-Scheduler implementiert ist, um im Gegensatz zu Keras usw. einen Multiplikator auf die ursprüngliche Lernrate zurückzusetzen.)

Was ist neue Funktionsverkettung?

Laut dem Beamten ** "Eine Funktion, mit der Sie Effekte kombinieren können, indem Sie zwei Scheduler nacheinander definieren und schrittweise ausführen" **. Bisher konnte nur die von einem Scheduler festgelegte Lernrate verwendet werden, aber es scheint möglich zu sein, Matching-Techniken durchzuführen. Es kommt nicht sehr gut heraus, also lassen Sie es uns tatsächlich verschieben und sehen, wie sich die Lernrate ändert.

Überprüfen Sie zunächst, wie es sich mit PyTorch 1.3 verhalten hat

import torch
from torch.optim import SGD
from torch.optim.lr_scheduler import ExponentialLR, StepLR
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = SGD(model, 0.1)
scheduler1 = StepLR(optimizer, step_size=3, gamma=0.5)
scheduler2 = ExponentialLR(optimizer, gamma=0.9)
s1, s2, lr = [], [], []
for epoch in range(100):
    optimizer.step()
    scheduler1.step()
    scheduler2.step()
    s1.append(scheduler1.get_lr()[0])
    s2.append(scheduler2.get_lr()[0])
    for param_group in optimizer.param_groups:
        lr.append(param_group['lr'])

Wir verwenden zwei Scheduler, StepLR und ExponentialLR. Nennen wir sie Scheduler 1 bzw. 2. Zeichnen Sie die Lernrate (s1, s2) des erhaltenen Schedulers.

import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
plt.plot(s1, label='StepLR (scheduler1)')
plt.plot(s2, label='ExponentialLR (scheduler2)')
plt.legend()

Sie können sehen, welche Eigenschaften jeder Scheduler hat. Zeichnen Sie als Nächstes die Lernrate von Optimizer.

plt.plot(lr, label='Learning Rate')
plt.legend()

Wie Sie auf einen Blick sehen können, können Sie sehen, dass die Lernrate von Exponential LR (Scheduler 2) verwendet wird. Anscheinend hat PyTorch 1.3 die Lernrate des Schedulers verwendet, in dem der Schritt zuletzt aufgerufen wurde. Es scheint auch, dass die Planer voneinander unabhängig und ohne besonderen Einfluss arbeiteten.

Bestätigen Sie abschließend den Effekt der Verkettung mit PyTorch 1.4

import torch
from torch.optim import SGD
from torch.optim.lr_scheduler import ExponentialLR, StepLR
model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = SGD(model, 0.1)
scheduler1 = StepLR(optimizer, step_size=3, gamma=0.5)
scheduler2 = ExponentialLR(optimizer, gamma=0.9)
s1, s2, lr = [], [], []
for epoch in range(100):
    optimizer.step()
    scheduler1.step()
    scheduler2.step()
    s1.append(scheduler1.get_last_lr()[0])
    s2.append(scheduler2.get_last_lr()[0])
    for param_group in optimizer.param_groups:
        lr.append(param_group['lr'])

** Beachten Sie, dass wir in PyTorch 1.3 .get_lr () verwendet haben, um die Lernrate des Schedulers zu erhalten, in PyTorch 1.4 jedoch .get_last_lr (). ** **. Sie können auch .get_lr () verwenden. Beachten Sie jedoch, dass möglicherweise nicht der richtige Wert ausgegeben wird. Diese Änderungen wurden offiziell angekündigt.

Zeichnen wir nun die Lernrate jedes Schedulers.

import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
plt.plot(s1, label='StepLR (scheduler1)')
plt.plot(s2, label='ExponentialLR (scheduler2)')
plt.legend()

Zu diesem Zeitpunkt unterscheidet sich die Situation von 1.3. Zeichnen Sie dann die Lernrate von Optimizer.

plt.plot(lr, label='Learning Rate')
plt.legend()

Auf diese Weise können Sie sehen, dass die Lernraten der beiden Scheduler nacheinander multipliziert werden, um die endgültige Lernrate des Optimierers zu erhalten. Es scheint gut zu wissen, dass sich die Lernrate aufgrund des Einflusses der beiden Planer selbst ändert. Es scheint, dass sich die Lernrate von Optimizer auch ändert, wenn sich die Lernrate jedes Schedulers ändert.

Es scheint einfacher zu sein, einen Scheduler zu schreiben, der die Lernrate auf komplizierte Weise ändert, was bisher selbst geschrieben werden musste. Dies scheint besonders nützlich zu sein, wenn Sie ein wenig zyklisches Verhalten hinzufügen möchten.

das ist alles.