[PYTHON] DNN (Deep Learning) Library: Vergleich von Chainer und TensorFlow (1)

Einführung

In den letzten Jahren hat Deep Learning (Deep Neural Network: DNN) im Bereich des maschinellen Lernens Aufmerksamkeit erregt. Gleichzeitig wurden verschiedene DNN-Bibliotheken veröffentlicht, aber was sind die Unterschiede zwischen ihnen (welche sollte verwendet werden)? In diesem Artikel möchte ich vergleichen, wie die Netzwerkstruktur von DNN in jeder Bibliothek beschrieben wird. Dieser Artikel richtet sich an Personen, die DNN teilweise kennen, aber keine Kenntnisse über Bibliotheken haben. Wenn Sie die Tutorials für jede Bibliothek gelesen und den Code tatsächlich geschrieben haben, gibt es nichts mehr.

Bibliothek

Es sind viele Bibliotheken verfügbar, aber dieser Artikel befasst sich mit Chainer und TensorFlow. Ich hoffe, dass ich in Zukunft weitere Bibliotheken hinzufügen kann. Im Folgenden werde ich zunächst nur die einfachen Basisinformationen jeder Bibliothek zusammenfassen. Zum Vergleich der Geschwindigkeit usw. [Ich habe die Deep Learning-Bibliothek verglichen, die in Python geschrieben werden kann] [] war leicht zu verstehen, danke. Ich frage mich, ob diese Site ausreicht, aber in diesem Artikel möchte ich den Quellcode speziell anordnen und die Beschreibungen derselben Netzwerkstruktur vergleichen.

TensorFlow

• Entwickler: Google
• Offizielles Tutorial: https://www.tensorflow.org/versions/master/tutorials/index.html
• Github Stars: 19830

Dies ist eine offene Version der Bibliothek, die Google tatsächlich intern verwendet. Ich bin nur von Google angezogen (?

chainer

• Entwickler: Preferred Networks (PFN)
• Offizielles Tutorial: http://docs.chainer.org/en/stable/tutorial/index.html
• Github Stars: 1240

PEN ist ein japanisches Startup und scheint von NTT finanziert zu werden. Sie können japanische Dokumente erwarten (?

Bibliotheksvergleich

Ich habe es gerade mit Bezug auf das Tutorial zusammengefasst ... Da ich ein DNN-Anfänger bin, kann es zu Fehlern in den Begriffen kommen.

Netzwerkstruktur / Datensatz

In diesem Artikel verwenden wir eine dreischichtige MLP-Netzwerkstruktur. Ich wollte unbedingt CNN machen, aber das war das nächste Mal. Die Anzahl der versteckten Ebeneneinheiten beträgt 100. Eingabeebene - Versteckte Ebene - Ausgabeebene

Als Datensatz werden handgeschriebene MNIST-Nummern verwendet. Es scheint, dass es für DNN bereits ein einfaches Problem ist, aber dieses Mal möchte ich hauptsächlich die Beschreibungsmethode vergleichen. Die Eingabeebene hat 784 Dimensionen (28 x 28) und die Ausgabe hat 10 Dimensionen.

Ich habe data.py verwendet, das im Chainer-Beispiel verwendet wurde, um die Daten zu erhalten. In TensorFlow wird häufig ein Beispiel mit dem Namen "input_data.py" verwendet, aber ich habe die aus "data.py" gelesenen Daten für Studienzwecke verwendet. (In data.py wird die Bezeichnung durch eine Zahl und durch einen Vektor wie {1,4,9,2 ...} dargestellt. Andererseits wird in input_data.py ` Es wird durch eine Reihe von One-Hot-Vektoren wie "{0,0, ..., 1,0}" ausgedrückt. Zuerst bemerkte ich diesen Unterschied nicht und bekam den Fehler, dass die Dimension falsch war. Unten: dens_to_one_hot ( Die Konvertierungsoperation wird durch eine Methode namens x) dargestellt.

trainingData

import data
import numpy as np

mnist = data.load_mnist_data()
x_all = mnist['data'].astype(np.float32) / 255
y_all = mnist['target'].astype(np.int32)

#only tensorFlow
y_all = dense_to_one_hot(y_all)

x_train, x_test = np.split(x_all, [60000])
y_train, y_test = np.split(y_all, [60000])

x_train.shape => (60000, 784) y_train.shape => (60000, 1) or (60000, 10)

Es ist.

Umgebung

Dieses Mal wurde ubuntu14.04 (nur CPU) verwendet. Daher könnten beide Bibliotheken leicht mit pip installiert werden. In Fenstern ... werde ich diesmal nicht anfassen.

Netzwerkbeschreibung

chainer

chainer(classDefine)

import chainer
import chainer.functions as F
import chainer.links as L

class MLP(chainer.Chain):
    def __init__(self):
        super(MLP, self).__init__(
                                  l1=L.Linear(784, 100),
                                  l2=L.Linear(100, 100),
                                  l3=L.Linear(100, 10),
                                  )

    def __call__(self, x):
        h1 = F.relu(self.l1(x))
        h2 = F.relu(self.l2(h1))
        y = self.l3(h2)
        return y



class Classifier(Chain):
    def __init__(self, predictor):
        super(Classifier, self).__init__(predictor=predictor)

    def __call__(self, x, t):
        y = self.predictor(x)
        self.loss = F.softmax_cross_entropy(y, t)
        self.accuracy = F.accuracy(y, t)
        return self.loss

Erstellen Sie zunächst eine Klasse, die die Struktur der Ebene definiert, und eine Klasse, die den Ausgabefehler definiert. In der "MLP" -Klasse wird "Linear" (vollständige Bindung, dargestellt durch Gewicht $ W $ und Bias $ b $) für jede Schicht verwendet, und "ReLU (...)" wird als Aktivierungsfunktion verwendet. Sie können sehen, dass es gibt. Durch Ändern dieses Teils scheint es möglich zu sein, "Dropout (...)" oder eine Faltungsschicht hinzuzufügen.

Zusätzlich wird "softmax_cross_entropy (...)", dh die berechnete Kreuzentropie für die Ausgabe der softmax-Funktion, zur Berechnung des Fehlers verwendet. Übrigens ist in der definierten Classifier-Klasse eine ähnliche Klasse als chainer.links.Classifier implementiert. Wenn Sie es so implementieren können, wie es ist, können Sie es verwenden.

chainer(model)

        model = Classifier(MLP()) # same as ``L.Classifier(MLP())``
        optimizer = optimizers.SGD()
        optimizer.setup(model)

Erstellen Sie als Nächstes eine Instanz der definierten Klasse. Hier wird die Optimierungsmethode angegeben, und SGD () (probabilistische Methode mit dem steilsten Abstieg) wird angegeben.

tensorFlow

tensorFlow

import tensorFlow as tf

        # input
            x = tf.placeholder(tf.float32, [None, 784])
        # label
            y_ = tf.placeholder(tf.float32, [None, 10])


        # FC1
            W1 = tf.Variable(tf.random_normal([784, 100], mean=0.0, stddev=0.05))
            b1 = tf.Variable(tf.zeros([100]))
            # layer output
            h1 = tf.nn.relu(tf.matmul(x, W1) + b1)

        # FC2
            W2 = tf.Variable(tf.random_normal([100, 100], mean=0.0, stddev=0.05))
            b2 = tf.Variable(tf.zeros([100]))
            # layer output
            h2 = tf.nn.relu(tf.matmul(h1, W2) + b2)

        # FC3
            W3 = tf.Variable(tf.random_normal([100, 10], mean=0.0, stddev=0.05))
            b3 = tf.Variable(tf.zeros([10]))
            # output
            y = tf.nn.softmax(tf.matmul(h2, W3) + b3)

        # training
            cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
            train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

In tensorFlow wird jede Schicht durch die Matrixberechnungsformel $ y = Wx + b $ unter Verwendung des Gewichts $ W $ und der Vorspannung $ b $ ($ x $: Eingabe, $ y $: Ausgabe) dargestellt. Die Eingabe $ x $ ist diesmal eine Matrix mit dem Namen (Anzahl der Daten, 784). Die Anzahl der Daten ist variabel, indem im Code "Keine" angegeben wird. Das Gewicht "W1" der ersten Schicht ist definiert als "(784,100)", die Vorspannung "b1" ist definiert als "(100,)" und die Ausgabe der ersten Schicht ist "h1". Definieren Sie die Formel für `. Hier wird relu (...) als Aktivierungsfunktion verwendet. Sie können auch sehen, dass die Ausgabeebene "softmax (...)" berechnet. y_ ist eine Variable, die das richtige Antwortetikett speichert und zur Definition des Fehlers cross_entropy verwendet wird. Als Fehler wird eine gekreuzte Entropie verwendet, und "Minimieren" wird mit "GradientDescentOptimizer" angegeben.

Ich bin der Meinung, dass die Beschreibung jeder Schicht problematischer ist als die der Kette, aber als ich darüber nachdachte, die Netzwerkstruktur zu ändern, dachte ich, dass dies einfacher wäre, da die Beschreibung mit der Formel übereinstimmt. (Der Code ist kompliziert, weil ich die Klasse nicht richtig definiere

Lernen

Sei batch_x, batch_y eine Mini-Charge von x_train, y_train. Das Folgende ist die Verarbeitung für eine Mini-Charge.

chainer

chainerTraining

optimizer.update(model, batch_x, batch_y)

Übergeben Sie es an das Argument von optimizer.update.

tensorFlow

tensorFlowTraining

#sess = tf.Session()
sess.run(train_step, feed_dict={x:batch_x, y_:batch_y})

In tensorFlow werden die Daten in Form eines Wörterbuchs als Satz mit dem oben definierten Platzhalter übergeben.

Vergleich von Geschwindigkeit und Genauigkeit

Dieses Mal werden wir es auf einem schwachen Desktop-PC mit nur einer CPU ausführen, daher haben wir bestätigt, dass der Code in der Epoche etwa zehnmal funktioniert. Da es sich um eine weit verbreitete Bibliothek handelt, denke ich, dass sie in Bezug auf Genauigkeit und Geschwindigkeit vergleichbar ist. Ich werde es überprüfen, wenn es in Zukunft eine Gelegenheit gibt.

abschließend

Als zukünftige Themen möchte ich Folgendes angehen.

• Komplexe Netzwerkstrukturen wie CNN und RNN
• GPU
• Verteilungsstatus trainierter Modelle

Es scheint, dass es Unterschiede in den Bibliotheken um die ersten beiden geben wird. Ich möchte versuchen, mehrere GPUs zu unterstützen (die Maschine dafür ist ... Ich habe auch das Gefühl, dass Kaffee usw. oft nur zum Klassifizieren mit einem trainierten Modell verwendet wird (gibt es nicht viele?), Aber ich frage mich auch, ob es für diesen Zweck verwendet werden kann.

Referenz

• Ein entspanntes Ingenieurtagebuch - "[Vergleichen von Deep Learning-Bibliotheken, die in Python geschrieben werden können] []"