Dies ist eine Fortsetzung dieses Artikels. Othello-Aus der dritten Zeile von "Implementation Deep Learning" (1) http://qiita.com/Kumapapa2012/items/cb89d73782ddda618c99 Othello-Aus der dritten Zeile von "Implementation Deep Learning" (2) http://qiita.com/Kumapapa2012/items/f6c654d7c789a074c69b

Klicken Sie hier für nachfolgende Artikel. Othello-Aus der dritten Zeile von "Implementation Deep Learning" (4) [Ende] http://qiita.com/Kumapapa2012/items/9cec4e6d2c935d11f108

Ich habe die Aktivierungsfunktion im ersten Artikel erwähnt, aber angesichts des Potenzials, ReLU zu sterben, spielen wir ein Othello-Spiel mit dem vielleicht einfachsten und schnellsten Weg, dies zu umgehen, Leaky ReLU. Ich versuchte es. Der Code ist hier. https://github.com/Kumapapa2012/Learning-Machine-Learning/tree/master/Reversi

Leaky ReLU ReLU ist eine Aktivierungsfunktion, die alle Werte unter 0 auf 0 setzt.

f = \max(0,x)

Diese NN ist eine vollständige Verknüpfung, kann jedoch, wie bereits beschrieben (http://qiita.com/Kumapapa2012/items/cb89d73782ddda618c99), das Problem des Absterbens von ReLU verursachen. Eine Lösung hierfür ist Leaky ReLU, bei der negative Werte geringfügig geneigt werden (Standard 0,2 für Chainer).

{f = \begin{cases}
    x & (x>0) 
    \\
    0.2x  & (x<=0)
  \end{cases}
}

Dies eliminiert die Nullsteigung. Dies ist eine persönliche Interpretation, aber das Absterben von ReLU ist im Wesentlichen auf die Tatsache zurückzuführen, dass die Steigung des negativen Werts 0 ist, sodass Sie eine Steigung hinzufügen können. Da wir jedoch die Merkmale von ReLU "positive Steigung ist 1 und negative Steigung ist 0" beibehalten möchten, wie z. B. einfache Differenzierung und schnelles Berechnen und Lernen (Backpropagation), ist die Steigung klein. Ich denke, es ist eine Funktion von Leaky ReLU.

Ich habe versucht, Leaky ReLU zu verwenden.

Ändern Sie die Aktivierungsfunktion von ReLU in Leaky ReLU, indem Sie nur 8 Codezeilen in agent.py ändern.

$ diff ~/git/Learning-Machine-Learning/Reversi/agent.py agent.py 
47,55c47,55
<         h = F.relu(self.l1(x))
<         h = F.relu(self.l20(h))
<         h = F.relu(self.l21(h))
<         h = F.relu(self.l22(h))
<         h = F.relu(self.l23(h))
<         h = F.relu(self.l24(h))
<         h = F.relu(self.l25(h))
<         h = F.relu(self.l26(h))
<         h = F.relu(self.l27(h))
---
>         h = F.leaky_relu(self.l1(x))   #slope=0.2(default)
>         h = F.leaky_relu(self.l20(h))
>         h = F.leaky_relu(self.l21(h))
>         h = F.leaky_relu(self.l22(h))
>         h = F.leaky_relu(self.l23(h))
>         h = F.leaky_relu(self.l24(h))
>         h = F.leaky_relu(self.l25(h))
>         h = F.leaky_relu(self.l26(h))
>         h = F.leaky_relu(self.l27(h))

Infolgedessen hat sich die Gewinnrate auf dem 6x6-Board stetig erhöht. ** Bei Verwendung von Leaky ReLU (Steigung = 0,2) **

Es ist ganz anders als das vorherige Ergebnis. Gab es schließlich eine sterbende ReLU? ** Bei Verwendung von ReLU **

Als nächstes im Fall von 8x8 Board ... Die Gewinnrate war nicht stabil / (^ o ^)
** Bei Verwendung von Leaky ReLU (Steigung = 0,2) **

Im ersten Ergebnis scheint die Gewinnrate am Ende zu konvergieren. ** Bei Verwendung von ReLU **

Wenn Sie ganz einfach denken, wenn die Gewinnrate ReLU ist, dh Leaky ReLU mit Slope = 0, scheint sie zu konvergieren, und wenn sie nicht konvergiert, wenn Leaky ReLU mit Slope = 0,2, kann es in der Zwischenzeit einen optimalen Wert geben. Vielleicht. Ich würde es gerne später mit Slope = 0.1 versuchen. Das größere Problem ist jedoch, dass es eine Welle von Gewinnraten gibt. Welligkeit scheint zu bedeuten, dass das Lernen nicht am richtigen Ort aufhört. Dies scheint mit der Lernrate in Zusammenhang zu stehen. Gemäß Kapitel 6 des Buches "Deep Learning from Zero" ist die Lernrate im Wesentlichen ein Koeffizient, der den Aktualisierungsgrad des Gewichts W angibt. Je höher der Wert, desto höher der Aktualisierungsgrad von W und desto schneller schreitet das Lernen voran, aber es divergiert. Es besteht die Möglichkeit [^ 1]. Wenn es jedoch zu klein ist, ist das Lernen zu langsam. Das ist. Das Argument lr (Lernrate = Lernrate) von RMSPropGraves, das dieses Mal verwendet wird, ist 0,00025. In RMSPropGraves von chainer ist der Standardwert lr 0,0001, daher ist dieses Beispiel etwas größer. Wahrscheinlich ist diese 0,00025 ein Wert, der für die Lerngeschwindigkeit der Drei-Wege-Anordnung optimiert ist, und im Fall der 8x8-Karte von Othello ist der Wert von W diesmal nicht stabil, und als Ergebnis ist die Gewinnrate wie in der obigen Grafik gezeigt. Es wird angenommen, dass es instabil geworden ist. Aus diesem Grund möchte ich versuchen, in Zukunft eine niedrige Lernrate festzulegen. [^ 2]

Verweise

Computer Othello https://ja.m.wikipedia.org/wiki/%E3%82%B3%E3%83%B3%E3%83%94%E3%83%A5%E3%83%BC%E3%82%BF%E3%82%AA%E3%82%BB%E3%83%AD
Sprechen Sie über Fehlererfahrungen und Anti-Muster im neuronalen Netz http://nonbiri-tereka.hatenablog.com/entry/2016/03/10/073633 (Andere werden zu einem späteren Zeitpunkt hinzugefügt)

[^ 1]: Die Ausweitung der Gewichtsschwankung aufgrund einer hohen Lernrate kann auch ein Faktor sein, der dazu führt, dass ReLU stirbt. [^ 2]: Ist die Aktivierungsfunktion der Ausgabeebene überhaupt die gleiche wie die der verborgenen Ebene? Sollte ich separat darüber nachdenken? Darüber mache ich mir auch Sorgen.

[PYTHON] Othello-Aus der dritten Zeile von "Implementation Deep Learning" (3)

Ich habe versucht, Leaky ReLU zu verwenden.

Verweise