Ursprünglich habe ich "Theano" studiert, ein Framework für Deep Learning, aber kürzlich interessierte ich mich für "TensorFlow", das letzten Monat (November 2015) veröffentlicht wurde, und kürzlich habe ich es hauptsächlich verwendet. Während ich TensorFlow berührte, hatte ich das Gefühl, dass "dies in der Nähe von" Theano "ist, dies ist ganz anders", aber um den Unterschied zwischen den beiden zu bestätigen, habe ich einen einfachen Code von "TensorFlow" nach "Theano" portiert. (Normalerweise denke ich, dass die Richtung entgegengesetzt ist.)
Zunächst vergleichen wir die Umrisse der beiden Frameworks.
| Artikel | Theano | TensorFlow |
|---|---|---|
| Entwicklungseinheit | akademisch(University of Montreal) | Unternehmen(Google) |
| Erscheinungsjahr | Über 2010(?) | 2015 |
| Tensor operation | support | support |
| numpy 'basic'Level-Funktion | support | support |
| Automatische Differenzierung(Graph Transformation) | support | support |
| GPU-Arithmetik | support | support |
| Graph Visualization | support (Es gibt vorerst) | support (Sie kennen Tensorboard) |
| Optimizer | not support (built-Bedeutet nicht in) | Verschiedene Unterstützung |
| Systemfunktionen des neuronalen Netzwerks | support | (verschiedene) support |
In Bezug auf die Funktionalität gibt es Unterschiede im letzten Teil der obigen Tabelle. In Theano müssen Sie die Details selbst vorbereiten, in ThensorFlow haben Sie jedoch den Eindruck, dass verschiedene Bibliotheksfunktionen von Anfang an vorbereitet sind. (Für diejenigen, die nicht anhand der Details in Theano programmieren möchten, gibt es eine auf Theano basierende Hochleistungsbibliothek wie Pylearn2.)
Hier können Sie Code in "Theano" und "ThensorFlow" auf die gleiche Weise schreiben. Dies ist ein Auszug aus dem MLP-Code (Multi-Layer Perceptron), der eine in Vorheriger Artikel eingeführte Klassifizierung mehrerer Klassen durchführt.
** TensorFlow-Version **
# Hidden Layer
class HiddenLayer(object):
def __init__(self, input, n_in, n_out):
self.input = input
w_h = tf.Variable(tf.random_normal([n_in,n_out],mean=0.0,stddev=0.05))
b_h = tf.Variable(tf.zeros([n_out]))
self.w = w_h
self.b = b_h
self.params = [self.w, self.b]
def output(self):
linarg = tf.matmul(self.input, self.w) + self.b
self.output = tf.nn.relu(linarg) # switch sigmoid() to relu()
return self.output
# Read-out Layer
class ReadOutLayer(object):
def __init__(self, input, n_in, n_out):
self.input = input
w_o = tf.Variable(tf.random_normal([n_in,n_out],mean=0.0,stddev=0.05))
b_o = tf.Variable(tf.zeros([n_out]))
self.w = w_o
self.b = b_o
self.params = [self.w, self.b]
def output(self):
linarg = tf.matmul(self.input, self.w) + self.b
self.output = tf.nn.softmax(linarg)
return self.output
** Theano Version **
# Hidden Layer
class HiddenLayer(object):
def __init__(self, input, n_in, n_out):
self.input = input
w_h = theano.shared(floatX(np.random.standard_normal([n_in, n_out]))
* 0.05)
b_h = theano.shared(floatX(np.zeros(n_out)))
self.w = w_h
self.b = b_h
self.params = [self.w, self.b]
def output(self):
linarg = T.dot(self.input, self.w) + self.b
# self.output = T.nnet.relu(linarg)
self.output = T.nnet.sigmoid(linarg)
return self.output
# Read-out Layer
class ReadOutLayer(object):
def __init__(self, input, n_in, n_out):
self.input = input
w_o = theano.shared(floatX(np.random.standard_normal([n_in,n_out]))
* 0.05)
b_o = theano.shared(floatX(np.zeros(n_out)))
self.w = w_o
self.b = b_o
self.params = [self.w, self.b]
def output(self):
linarg = T.dot(self.input, self.w) + self.b
self.output = T.nnet.softmax(linarg)
return self.output
Wenn Sie nicht genau hinschauen, ist der Unterschied "nur geändert" tf. "Zu" T. "". In Bezug auf die Aktivierungsfunktion dachte ich, dass der spätere TenfsorFlow aufgrund von "tf.nn.relu ()" usw. bequemer wäre, aber Theano unterstützt auch relu () (Rectified Linear Unit) ab Version 0.7.1 Es scheint. (Die in diesem Artikel verwendeten Programme sind Python Version 2.7.10, TensorFlow Version 0.5.0, Theano Version 0.7.0.)
Die Softmax-Funktion wird natürlich auch von beiden unterstützt.
Hier gibt es einen Unterschied zwischen den beiden (Tensor Flow vs. Theano). In TensorFlow ist die Optimizer-Klassenbibliothek umfangreich, während Sie in Theano die Optimizer-Klassenbibliothek selbst vorbereiten müssen.
** TensorFlow-Version (Verwendungsbeispiel für Adagrad Optimzer) **
# Train
optimizer = tf.train.AdagradOptimizer(0.01)
train_op = optimizer.minimize(loss)
init = tf.initialize_all_variables()
with tf.Session() as sess:
sess.run(init)
print('Training...')
for i in range(10001):
train_op.run({x: train_x, y_: train_y})
if i % 1000 == 0: # echo status on screen
train_accuracy = accuracy.eval({x: train_x, y_: train_y})
print(' step, accurary = %6d: %8.3f' % (i, train_accuracy))
Geben Sie in TensorFlow das Optimierungsprogramm an, um die Sitzung auszuführen. Der Fluss der Bereitstellung von Zugdaten in Form von Feed_dict in Seesion.
** Theano-Version (Beispiel für die Implementierung von Adagrad) ** Ich wollte schreiben, wie man die Funktion so nah wie möglich am TensorFlow-Code aufruft, aber es wurde wie folgt.
# Optimizers - (GradientDescent), AdaGrad
class Optimizer(object):
def __init__(self, params, learning_rate=0.01):
self.lr = learning_rate
self.params = params
def minimize(self, loss):
self.gradparams = [T.grad(loss, param) for param in params]
class AdagradOptimizer(Optimizer):
def __init__(self, params, learning_rate=0.01, eps=1.e-6):
super(AdagradOptimizer, self).__init__(params, learning_rate)
self.eps = eps
self.accugrads = [theano.shared(floatX(np.zeros(t.shape.eval())),
'accugrad') for t in self.params
]
def minimize(self, loss):
super(AdagradOptimizer, self).minimize(loss)
self.updates = OrderedDict() # for Theano's rule
for accugrad, param, gparam in zip(
self.accugrads, self.params, self.gradparams):
agrad = accugrad + gparam * gparam
dx = - (self.lr / T.sqrt(agrad + self.eps)) * gparam
self.updates[param] = param + dx
self.updates[accugrad] = agrad
return self.updates
Verwenden Sie diese, um den Optimierungsprozess (Lernen) auszuführen.
# Train
myoptimizer = AdagradOptimizer(params, learning_rate=0.01, eps=1.e-8)
one_update = myoptimizer.minimize(loss)
# Compile ... define theano.function
train_model = theano.function(
inputs=[],
outputs=[loss, accuracy],
updates=one_update,
givens=[(x, strain_x), (y_, strain_y)],
allow_input_downcast=True
)
n_epochs = 10001
epoch = 0
while (epoch < n_epochs):
epoch += 1
loss, accu = train_model()
if epoch % 1000 == 0:
print('epoch[%5d] : cost =%8.4f, accyracy =%8.4f' % (epoch, loss, accu))
Auf diese Weise im Teil des Optimierungsprozesses ** In TensorFlow ... ** Führen Sie nach dem Initialisieren der Variablen Session aus. Trainingsdaten werden während der Sitzung in Form von op.run ({Feed_dict}) angegeben. ** Bei Theano ... ** Der Ablauf des Lernprozesses (einschließlich der Bereitstellung von Trainingsdaten) wird in theano.function () definiert. Führen Sie iterative Lernberechnungen mit der definierten Funktion (theano.function) durch. Der Unterschied ist zu sehen.
Als ich anfing, "Theano" zu lernen, erinnere ich mich, dass ich Probleme hatte, diese theano.function () zu verwenden, aber durch den Vergleich mit "TensorFlow" wie oben beschrieben, vertiefte ich mein Verständnis von theano.function (). Es war. (Unter einem anderen Gesichtspunkt können Sie Theano gut verwenden, wenn Sie ein gutes Verständnis von theano.function () haben.)
Da es sich um ein Framework handelt, das für denselben Zweck verwendet wird, gibt es viele Ähnlichkeiten. In Bezug auf die Funktionalität ist TensorFlow vollständiger, sodass es möglicherweise einfacher ist, den Theno-Code für ThenorFlow zu portieren. Sobald der Optimierer und neue Funktionen implementiert sind, können sie jedoch wiederverwendet werden, sodass Theano kein Nachteil ist. (Der Code des Vorfahren ist ebenfalls hilfreich, und es gibt viele Zusatzbibliotheken.)
Ich habe komplexere Netzwerkmodelle nicht nur anhand des MLP-Codes ausprobiert, aber beide scheinen sehr potenzielle Werkzeuge zu sein. (Ich habe auch Chainer installiert, aber ich konnte es nicht bekommen ...)
Als ich zum Zeitpunkt des Schreibens dieses Artikels die Website über die neuronale Netzwerkbibliothek "Keras" überprüft habe, scheint es, dass zusätzlich zu der in Kombination mit "Theano" verwendeten Bibliothek die in Kombination mit "TensorFlow" verwendete Bibliothek veröffentlicht wurde. (Ich würde es gerne später herausfinden.)
Keras: Deep Learning library for Theano and TensorFlow
Recommended Posts