A l'origine, j'étudiais "Theano", un framework pour Deep Learning, mais récemment je me suis intéressé à "TensorFlow" sorti le mois dernier (novembre 2015), et récemment je l'ai principalement utilisé. En touchant TensorFlow, j'ai senti que "c'est proche de" Theano ", c'est assez différent", mais pour confirmer la différence entre les deux, j'ai porté un simple code de "TensorFlow" vers "Theano". (Habituellement, je pense que la direction est opposée.)
Tout d'abord, nous comparons les contours des deux cadres.
| article | Theano | TensorFlow |
|---|---|---|
| Entité de développement | académique(University of Montreal) | Compagnie(Google) |
| Année de publication | À propos de 2010(?) | 2015 |
| Tensor operation | support | support |
| numpy 'basic'fonction de niveau | support | support |
| Différenciation automatique(Graph Transformation) | support | support |
| Arithmétique GPU | support | support |
| Graph Visualization | support (Il y a pour le moment) | support (Vous connaissez Tensorboard) |
| Optimizer | not support (built-Signifie pas dans) | Divers soutien |
| Fonctions du système de réseau neuronal | support | (divers) support |
En termes de fonctionnalité, il existe des différences dans la dernière partie du tableau ci-dessus. Dans Theano, vous devez préparer vous-même les détails, mais dans ThensorFlow, vous avez l'impression que diverses fonctions de la bibliothèque sont préparées dès le début. (Pour ceux qui ne veulent pas programmer à partir des détails de Theano, il existe une bibliothèque haute performance basée sur Theano, telle que Pylearn2.)
Ici, vous pouvez écrire du code dans "Theano" et "ThensorFlow" de la même manière. Ceci est un extrait du code MLP (Multi-layer Perceptron) qui effectue la classification multi-classes introduit dans Article précédent.
** Version TensorFlow **
# 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
** Version Theano **
# 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
Si vous n'y regardez pas de près, la différence est que vous venez de changer "tf." En "T.". En ce qui concerne la fonction d'activation, j'ai pensé que le dernier TenfsorFlow serait plus pratique à cause de "tf.nn.relu ()" etc., mais Theano prend également en charge relu () (Rectified Linear Unit) à partir de la version 0.7.1 Il semble. (Les programmes utilisés dans cet article sont Python ver.2.7.10, TensorFlow ver.0.5.0, Theano ver.0.7.0.)
La fonction Softmax est également naturellement prise en charge par les deux.
Ici, il y a une différence entre les deux (Tensor Flow vs. Theano). Dans TensorFlow, la bibliothèque de classes Optimizer est étendue, tandis que dans Theano, vous devez préparer la bibliothèque de classes Optimizer vous-même.
** Version de TensorFlow (exemple d'utilisation d'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))
Dans TensorFlow, spécifiez l'optimiseur pour exécuter Session. Le flux de fourniture de données de train sous la forme de Feed_dict dans Seesion.
** Version Theano (exemple d'implémentation d'Adagrad) ** J'avais l'intention d'écrire la méthode pour appeler la fonction aussi près que possible du code TensorFlow, mais c'est devenu comme suit.
# 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
Utilisez-les pour exécuter le processus d'optimisation (apprentissage).
# 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))
De cette manière, dans le cadre du processus d'optimisation ** Dans TensorFlow ... ** Après avoir initialisé les variables, exécutez Session. Les données d'entraînement sont données pendant la session sous la forme de op.run ({Feed_dict}). ** Chez Theano ... ** Le flux du processus d'apprentissage (y compris la fourniture de données de formation) est défini dans la fonction ano. (). Effectuer des calculs d'apprentissage itératifs à l'aide de la fonction définie (fonction theano.), La différence est visible.
Quand j'ai commencé à apprendre "Theano", je me souviens avoir eu du mal à utiliser cette fonction theano.function (), mais en la comparant avec "TensorFlow" comme décrit ci-dessus, j'ai approfondi ma compréhension de la fonction theano.function (). C'était. (D'un point de vue différent, si vous avez une bonne compréhension de la fonction ano. (), vous pourrez bien utiliser Theano.)
Puisqu'il s'agit d'un framework utilisé dans le même but, il existe de nombreuses similitudes. En termes de fonctionnalités, TensorFlow est plus complet, il peut donc être plus facile de porter le code Theno pour ThenorFlow. Cependant, une fois que l'optimiseur et les nouvelles fonctions sont implémentés, ils peuvent être réutilisés, donc Theano n'est pas un inconvénient. (Le code de l'ancêtre est également utile, et il existe de nombreuses bibliothèques complémentaires.)
Je n'ai pas essayé de modèles de réseau plus complexes simplement en regardant le code MLP, mais les deux semblent être des outils très potentiels. (J'ai également installé Chainer, mais je n'ai pas pu l'obtenir ...)
Lorsque j'ai vérifié le site sur la bibliothèque de réseau neuronal "Keras" au moment de la rédaction de cet article, il semble qu'en plus de la bibliothèque utilisée en combinaison avec "Theano", celle utilisée en combinaison avec "TensorFlow" a été publiée. (J'aimerais le savoir plus tard.)
Keras: Deep Learning library for Theano and TensorFlow