Was ist tiefes Lernen?

Deep Learning in Englisch
Eine der Methoden des maschinellen Lernens
Mehrschichtiges neuronales Netzwerk (NN), eine maschinelle Lernmethode, die eine neuronale Schaltung imitiert
NN selbst hat eine mehr als 50-jährige Geschichte und gewann nach mehreren Winter-Epochen (als schlechte Kinder behandelt) 2012 den Bilderkennungswettbewerb ILSVRC mit überwältigender Genauigkeit und dem Titel Deep Learning. Mit Namen wiederbelebt
Es gibt verschiedene Strukturmodelle, und Convolutional Neural Network (CNN) wird häufig zur Bilderkennung verwendet, Generative Adversarial Network (GAN) zur Bilderzeugung und Long Short Term Memory (LSTM) zur Verarbeitung natürlicher Sprache.

Deep Learning als überwachtes maschinelles Lernen

Ich erklärte, dass Deep Learning ein mehrschichtiges NN ist, aber in der Realität ist es heutzutage üblich, komplizierte Konfigurationen wie Faltung, rekursive Berechnung und Selbstaufmerksamkeitsberechnung anstelle einer einfachen mehrschichtigen Berechnung zu verwenden Ich möchte das maschinelle Lernen im Kontext des überwachten Lernens kurz erläutern und dann erklären, welche Komponenten tiefes Lernen sind.

Mit einem Lehrer lernen

Überwachtes maschinelles Lernen ist $ \ boldsymbol {y Ausgabe von einer Eingabe $ \ boldsymbol {x} $ über eine Zuordnungsfunktion $ f $ mit dem Parameter $ \ boldsymbol {w} $, ausgedrückt durch die folgende Gleichung. Formulieren Sie das Problem, um den Parameter $ \ boldsymbol {w '} $ zu schätzen, der den Ausgabewert der Fehlerfunktion $ E $ zwischen} $ und der wahren Antwort $ \ boldsymbol {t} $ minimiert tun können.

\boldsymbol{y} = f(\boldsymbol{w},\boldsymbol{x}) \\
E(\boldsymbol{y}, \boldsymbol{t})← Parameter, die dies minimieren\boldsymbol{w'}Wollte fragen

Der Eingabewert $ \ boldsymbol {x} $ und der Zielausgabewert $ \ boldsymbol {t} $ müssen von Ningen als Daten [^ 1] vorbereitet werden. Handgeschriebener Text (0-9) Identifizieren der Zahlen im Bild aus dem Bild Unter der Annahme einer überwachten maschinellen Lernaufgabe ist $ \ boldsymbol {x} $ ein Vektor der Helligkeitswerte, die in jedem Pixel des handgeschriebenen Textbilds enthalten sind. Ich denke, es wäre schön, wenn Sie sich vorstellen könnten, dass die konvertierte Version $ \ boldsymbol {t} $ ein Vektor ist, der nur den Index der Zahl +1 im Bild, 1 und den Rest enthält.

*** Beispiel) Eingabewert $ \ boldsymbol {x} $, Zielausgabewert $ \ boldsymbol {t} $ ***, wenn die Zahl im handgeschriebenen Zeichenbild 5 ist.

\boldsymbol{x} =
\begin{bmatrix}
0.5 \\
0.3 \\
0.2 \\
0.5 \\

... 
\end{bmatrix}← Hat so viele Dimensionen wie die Anzahl der Pixel, \,
\boldsymbol{t} =
\begin{bmatrix}
0 \\
0 \\
0 \\
0 \\
0 \\
1 \\
0 \\
0 \\
0 \\
0 \\
\end{bmatrix}← Nur der 6. Index steht für 1

Wie finden Sie den Parameter $ \ boldsymbol {w '} $? Es gibt verschiedene Optimierungstechniken, aber im Kontext des tiefen Lernens wird üblicherweise die (probabilistische) Gradientenabstiegsmethode (oder ihre Variante) verwendet. Die Gradientenabstiegsmethode differenziert die Fehlerfunktion $ E $ mit dem Parameter $ \ boldsymbol {w} ^ {(t)} $ und passt den Parameter $ \ boldsymbol {w} $ in Richtung der daraus erhaltenen Steigung an. Suchen Sie durch Wiederholen der Schritte wie z. B. den Parameter, der den Fehler minimiert.

\boldsymbol{w}^{(t+1)}
=
\boldsymbol{w}^{(t)}
-
\epsilon
\frac{\partial E(\boldsymbol{y}, \boldsymbol{t})}{\partial \boldsymbol{w}^{(t)}},
\,\epsilon:Lernrate, \, t:Anzahl der Schritte

Wenn die Fehlerfunktion $ E $ eine quadratische Funktion oder eine kubische Funktion ist, um ein Bild davon zu erhalten, was dies tut, was ist der letzte Parameter $ w $ (Anfangswert: 1,0)? Ich möchte, dass Sie sehen, ob es zu einem bestimmten Wert konvergiert.

*** Beispiel) Im Fall einer quadratischen Funktion ($ y = x ^ 2 $) (vertikale Achse: $ E (w) $, horizontale Achse: $ w $, $ w ^ {(0)} $: 1,0, Schritt Nummer: 25000) ***

*** Beispiel) Im Fall einer kubischen Funktion ($ y = x ^ 3-0,75x + 1 $) (vertikale Achse: $ E (w) $, horizontale Achse: $ w $, $ w ^ {(0)} $: 1,0, Anzahl der Schritte: 25000) ***

Im Beispiel der quadratischen Funktion konvergiert sie nahe dem Minimalwert von 0, während Sie im Beispiel der kubischen Funktion, wenn Sie zur linken Seite gehen, in der Lage sein sollten, zum Minimalwert zu gelangen, jedoch mit einer halben Delle [^ 2]. Es ist konvergiert. Als Name der Gradientenabstiegsmethode wird der Wert von $ w ^ {(t + 1)} $ basierend auf dem Gradienten bestimmt, sodass der Gradient in Kubomi 0 und $ w ^ {(t + 1)} = ist Dies liegt an der Tatsache, dass w ^ {(t)} + 0 $.

\frac{\partial E(w^{(t)})}{\partial w^{(t)}}
← Das ist 0

Es gibt verschiedene Methoden, um dies zu vermeiden, wie die Momentum-Methode und die Methode zur Beschleunigung der Lerngeschwindigkeit [^ 3], wie Adam und AdaGrad (aber wenn Sie sich für diesen Bereich interessieren, googeln Sie bitte). Das Finden (Lernen) des Parameters $ \ boldsymbol {w '} $, der den Fehler minimiert, bedeutet, dass die Ausgabe nahe an der Zielausgabe liegt $ \ boldsymbol {t} $ $ \ boldsymbol {y} = f (\ boldsymbol {w') }, \ boldsymbol {x}) Synonym für $.

Tiefes Lernen

Übrigens ist es eine Geschichte über tiefes Lernen, nicht wahr? Ja. Deep Learning ist $ f $ (obwohl es kein Deep Learning sein muss). Mit anderen Worten, es ist eine Funktion, die die Eingabe $ \ boldsymbol {x} $ der Ausgabe $ \ boldsymbol {y} $ zuordnet. Nun, sind quadratische und kubische Funktionen dann auch tiefes Lernen? Für alle begeisterten Leser, die dachten, ist das nicht der Fall. Was anders ist, ist, dass die Funktionsstruktur unterschiedlich ist. Deep Learning ist eine zusammengesetzte Funktion [^ 4], bei der die Verschachtelung der Verschachtelung überlagert ist, und eine große Anzahl von Parametern $ \ boldsymbol {W} ^ {(1)} in Form der Multiplikation der Ausgabe jeder verschachtelten Funktion. Es hat ..., \ boldsymbol {W} ^ {(n)} $. Auch in der verschachtelten Funktion $ \ boldsymbol {a} ^ {(1)}, ..., \ boldsymbol {a} ^ {(n)} $ können Differenzierungen wie Relu, Sigmoid und tanh [^ 5] Mögliche nichtlineare Funktionen werden verwendet. [^ 6]

\boldsymbol{y}
=
f(\boldsymbol{x})
=
\boldsymbol{W}^{(n)} a^{(n)}(\boldsymbol{W}^{(n-1)}a^{(n-1)}(・ ・ ・(\boldsymbol{W}^{(1)} a^{(1)})・ ・ ・))

Sie fragen sich vielleicht, warum Deep Learning mit einer solchen Struktur genauer ist als andere Methoden des maschinellen Lernens, aber tatsächlich wurde dies mathematisch nicht genau bewiesen [^ 7]. Es gibt jedoch eine Veröffentlichung, in der die lokale optimale Lösung fast dieselbe ist wie die globale optimale Lösung in der Deep-Learning-Methode, die eine ausreichende Tiefe (Verschachtelung von 3 Schichten oder mehr) und eine nichtlineare Funktion aufweist [^ 8]. Dies bedeutet, dass unabhängig vom Anfangswert des Parameters, wenn er durch Drehen der Lernschleife konvergiert, der Konvergenzwert fast die gleiche Genauigkeit aufweist wie die globale optimale Lösung! Ist zu sagen. Ich bin sehr glücklich. Tiefes Lernen, großartig! !! !!

MNIST mit 3-lagigem neuronalen Netzwerk

Gute Nachrichten für alle, die es satt haben, mit weniger strengen Formeln zu erklären. Als nächstes werde ich den nicht strengen Code erklären. Der unten eingefügte Code verwendet ein dreischichtiges neuronales Netzwerk, um einen handschriftlichen Zeichendatensatz mit dem Namen MNIST zu trainieren und zu validieren. Eine ausführliche Erklärung finden Sie im Code. Als Punkt verwende ich das japanische DNN-Framework Chainer [^ 9], und es ist ein neuronales Netz, das mich normalerweise verwirrt, wenn ich versuche, mit vollem Kratzer zu schreiben, aber mit Chainer ist es seltsam, dass es mit weniger als 100 Zeilen einfach ist Ich kann den Code schreiben. (Dasselbe kann mit TensorFlow und Pytorch erreicht werden). Dies ist die Ware.

Umgebung

macOS Catalina 10.15.1
Chaner 7.0.0
Python 3.7.0

`train_test_mnist.py`


##-------------------------------------------
##Bibliothek importieren
##-------------------------------------------
import numpy as np
import chainer
from chainer import Chain, Variable
import chainer.functions as F
import chainer.links as L

##-------------------------------------------
##Modell-(3 Schicht NN)Definition von
##-------------------------------------------
class NN(chainer.Chain):
    def __init__(self, n_units, n_out):
        super(NN, self).__init__()
        with self.init_scope():
            self.l1=L.Linear(None, n_units)
            self.l2=L.Linear(None, n_units)
            self.l3=L.Linear(None, n_out)

    #Vorwärtsberechnung
    def __call__(self, x):
        h1 = F.relu(self.l1(x))       #Aktivierungsfunktion: relu
        h2 = F.relu(self.l2(h1))      #Aktivierungsfunktion: relu
        return F.sigmoid(self.l3(h2)) #Aktivierungsfunktion: sigmoid

##-------------------------------------------
##Eine Funktion, die die richtige Antwortrate und den richtigen Fehlerwert zurückgibt
##-------------------------------------------
def compute_accuracy_loss(model, xs, ts):
    ys = model(xs)
    loss = F.softmax_cross_entropy(ys, ts) #Fehlerfunktion: cross entropy
    ys = np.argmax(ys.data, axis=1)
    cors = (ys == ts)
    num_cors = sum(cors)
    accuracy = num_cors / ts.shape[0]
    return accuracy, loss

def main():
    ##-------------------------------------------
    ##Hyperparameter und andere Einstellungen
    ##-------------------------------------------
    n_units = 100 #Anzahl der Einheiten in der mittleren Schicht
    n_out = 10    #Anzahl der Dimensionen des Ausgabevektors(0~9 von 10)
    n_batch = 100 #Chargengröße
    n_epoch = 100 #Anzahl des Lernens

    ##-------------------------------------------
    ##Modelleinstellungen
    ##-------------------------------------------
    model = NN(n_units, n_out)
    opt = chainer.optimizers.Adam() #Optimierungsmethode: Adam
    opt.setup(model)

    ##-------------------------------------------
    ##Datenaufbereitung
    ##-------------------------------------------    
    train, test = chainer.datasets.get_mnist()
    xs, ts = train._datasets   #Trainingsdaten
    txs, tts = test._datasets  #Testdaten

    ##-------------------------------------------
    ##Lernen
    ##-------------------------------------------        
    for i in range(n_epoch):

        for j in range(600):
            model.zerograds()
            x = xs[(j * n_batch):((j + 1) * n_batch)]
            t = ts[(j * n_batch):((j + 1) * n_batch)]
            t = Variable(np.array(t, "i"))
            y = model(x)                  
            loss = F.softmax_cross_entropy(y, t) #Fehlerberechnung
            loss.backward()                      #Gradientenberechnung
            opt.update()                         #Parameteraktualisierung
            
        ##-------------------------------------------
        ##Prüfung
        ##-------------------------------------------        
        acc_train, loss_train = compute_accuracy_loss(model, xs, ts)
        acc_test, _           = compute_accuracy_loss(model, txs, tts)

        print("Epoch %d loss(train) = %f, accuracy(train) = %f, accuracy(test) = %f" % (i + 1, loss_train.data, acc_train, acc_test))

if __name__ == '__main__':
    main()

Wenn ich diesen Code in meiner schlechten lokalen Umgebung [^ 10] ausführe, erhalte ich die folgenden Lernergebnisse. Wenn die Anzahl der Lernenden 100 erreicht, liegt sie nahe bei 100%.

Schließlich

Vielen Dank, dass Sie so weit gelesen haben. Wie ich oben ein wenig erwähnt habe, ist tiefes Lernen, das in der Welt geflüstert wird, keine elementare Technologie mehr und wird immer mehr zur Ware (wenn es verdorrt). Von nun an ist der Schlüssel, wie Deep Learning mit anderen CS / Web-Technologien kombiniert werden kann, um neue Services und Unternehmen zu schaffen. Persönlich mag ich auch die Welt des Web, daher möchte ich einen Webdienst erstellen, der dieses tiefe Lernen in Zukunft nutzt. Wenn Sie ähnliche Interessen haben, machen wir es mit mir, der im Grunde ich bin! Wir rekrutieren! !!

[^ 1]: Eine große Anzahl von Kombinationen von $ \ boldsymbol {x} $ und $ \ boldsymbol {t} $ werden als Trainingsdaten bezeichnet. [^ 2]: Im hochdimensionalen Raum wird der Gradient selbst an dem Punkt Sattelpunkt zu 0. [^ 3]: Konvergieren Sie mit einer kleinen Anzahl von Schritten [^ 4]: Da die Parameter nach der Gradientenabstiegsmethode berechnet werden, besteht die Mindestanforderung darin, dass sie unterschieden werden können. [^ 5]: [Aktivierungsfunktion](https://ja.wikipedia.org/wiki/%E6%B4%BB%E6%80%A7%E5%8C%96%E9%96%A2%E6% 95% B0 genannt) [^ 6]: Das Problem in der Welt ist [linear trennbar](https://ja.wikipedia.org/wiki/%E7%B7%9A%E5%BD%A2%E5%88%86%E9%9B% A2% E5% 8F% AF% E8% 83% BD) So einfach ist das nicht [^ 7]: Man kann sagen, dass die Genauigkeit in verschiedenen Bereichen empirisch herausgekommen ist. [^ 8]: Quelle erforderlich (wo war das Papier ... das von der MIT-Person veröffentlichte) [^ 9]: Danke Chainer. Und tschüss. Lead Developer Blog [^ 10]: Warum sollte ich ResNet oder eine typische Deep-Learning-Methode zur Bilderkennung verwenden? Mein MacBook Pro hat Angst, Feuer zu fangen. Weil es gibt.

[PYTHON] Katzen haben es schon satt, locker und locker zu lernen