[PYTHON] Tensorflows praktische Bibliothek TF-Slim

Tensorflows praktische Bibliothek TF-Slim

Früher habe ich über die Wrapper-Bibliothek von Tensorflow geschrieben.

MNIST auf Keras (TensorFlow-Backend) MNIST mit skflow

~~ Keras scheint einfach zu bedienen zu sein, aber es gab einige, die keine Entfaltung (transponierte Faltung) usw. hatten, also ~~ (Wenn Sie genau hinschauen, können Sie Upsampling2D und Convolution2D verwenden) Als ich mir das Tutorial ansah, um Skflow und Raw Tensorflow zu studieren, fand ich eine versteckte nützliche Bibliothek.

TensorFlow-Slim

Es scheint, dass das Github-Repository von 0.9 hinzugefügt wurde.

Einige der Beiträge sind nicht sehr gut angekündigt, aber sie sind nett, daher halte ich es für eine gute Idee, einen Blick darauf zu werfen. Es heißt, es wird offiziell nicht unterstützt und ich weiß nicht, was in Zukunft passieren wird.

tensorflow/tensorflow/contrib/

Der folgende Inhalt kann sich in Zukunft erheblich ändern.

Import von TF-Slim

python


import tensorflow as tf
from tensorflow.contrib import slim

Gewichtsinitialisierung

python


weights = slim.variables.variable('weights',
                             shape=[10, 10, 3 , 3],
                             initializer=tf.truncated_normal_initializer(stddev=0.1),
                             regularizer=slim.l2_regularizer(0.05),
                             device='/CPU:0')

Es heißt, dass es funktioniert, aber es scheint, dass die als Variable bezeichnete Methode derzeit nicht implementiert ist. Daher müssen Sie möglicherweise das, was am Anfang steht, mitbringen und importieren.

models/inception/inception/

Ebenendefinition

Die Schichten von ~~ (conv + pool) * 5, fc * 3 können wie folgt geschrieben werden ~~ Wie in der README geschrieben, war es VGG16. conv2 pool conv2 pool conv3 pool conv3 pool conv3 pool fc3

python


with slim.arg_scope([slim.ops.conv2d, slim.ops.fc], stddev=0.01, weight_decay=0.0005):
  net = slim.ops.repeat_op(2, inputs, slim.ops.conv2d, 64, [3, 3], scope='conv1')
  net = slim.ops.max_pool(net, [2, 2], scope='pool1')
  net = slim.ops.repeat_op(2, net, slim.ops.conv2d, 128, [3, 3], scope='conv2')
  net = slim.ops.max_pool(net, [2, 2], scope='pool2')
  net = slim.ops.repeat_op(3, net, slim.ops.conv2d, 256, [3, 3], scope='conv3')
  net = slim.ops.max_pool(net, [2, 2], scope='pool3')
  net = slim.ops.repeat_op(3, net, slim.ops.conv2d, 512, [3, 3], scope='conv4')
  net = slim.ops.max_pool(net, [2, 2], scope='pool4')
  net = slim.ops.repeat_op(3, net, slim.ops.conv2d, 512, [3, 3], scope='conv5')
  net = slim.ops.max_pool(net, [2, 2], scope='pool5')
  net = slim.ops.flatten(net, scope='flatten5')
  net = slim.ops.fc(net, 4096, scope='fc6')
  net = slim.ops.dropout(net, 0.5, scope='dropout6')
  net = slim.ops.fc(net, 4096, scope='fc7')
  net = slim.ops.dropout(net, 0.5, scope='dropout7')
  net = slim.ops.fc(net, 1000, activation=None, scope='fc8')
return net

Sie können den Conv * 3 + -Pool auch so verkürzen

python


net = ...
for i in range(3):
  net = slim.ops.conv2d(net, 256, [3, 3], scope='conv3_' % (i+1))
net = slim.ops.max_pool(net, [2, 2], scope='pool3')

Wenn Sie die Wiederholungsmethode von slim verwenden

python


net = slim.ops.repeat_op(net, 3, slim.conv2d, 256, [3, 3], scope='conv3')
net = slim.ops.max_pool(net, [2, 2], scope='pool2')

Es scheint, dass dies den Bereich richtig an 'conv3 / conv3_1', 'conv3 / conv3_2' und 'conv3 / conv3_3' anpassen wird.

fc * 3 hat auch Folgendes

python


x = slim.ops.fc(x, 32, scope='fc/fc_1')
x = slim.ops.fc(x, 64, scope='fc/fc_2')
x = slim.ops.fc(x, 128, scope='fc/fc_3')

Kann in einer Zeile geschrieben werden

python


slim.stack(x, slim.fully_connected, [32, 64, 128], scope='fc')

Natürlich auch Conv

python


slim.stack(x, slim.ops.conv2d, [(32, [3, 3]), (32, [1, 1]), (64, [3, 3]), (64, [1, 1])], scope='core')

Es ist in der README von OK und Contrib geschrieben, aber es gibt keine Implementierung. (Nicht in der README von Inception geschrieben)

Umfang

Zum Beispiel, wenn es eine solche Schicht von conv * 3 gibt

python


padding = 'SAME'
initializer = tf.truncated_normal_initializer(stddev=0.01)
regularizer = slim.losses.l2_regularizer(0.0005)
net = slim.ops.conv2d(inputs, 64, [11, 11], 4,
                      padding=padding,
                      weights_initializer=initializer,
                      weights_regularizer=regularizer,
                      scope='conv1')
net = slim.ops.conv2d(net, 128, [11, 11],
                      padding='VALID',
                      weights_initializer=initializer,
                      weights_regularizer=regularizer,
                      scope='conv2')
net = slim.ops.conv2d(net, 256, [11, 11],
                      padding=padding,
                      weights_initializer=initializer,
                      weights_regularizer=regularizer,
                      scope='conv3')

Wenn Sie den für slim vorbereiteten Bereich verwenden, können Sie nur die Teile mit unterschiedlichen Argumenten beschreiben und den Rest weglassen.

python


with slim.arg_scope([slim.ops.conv2d], padding='SAME',
                    weights_initializer=tf.truncated_normal_initializer(stddev=0.01)
                    weights_regularizer=slim.losses.l2_regularizer(0.0005)):
  net = slim.ops.conv2d(inputs, 64, [11, 11], scope='conv1')
  net = slim.ops.conv2d(net, 128, [11, 11], padding='VALID', scope='conv2')
  net = slim.ops.conv2d(net, 256, [11, 11], scope='conv3')

Überlappen Sie außerdem den Bereich

python


with slim.arg_scope([slim.ops.conv2d, slim.ops.fc],
                    activation_fn=tf.nn.relu,
                    weights_initializer=tf.truncated_normal_initializer(stddev=0.01),
                    weights_regularizer=slim.losses.l2_regularizer(0.0005)):
with arg_scope([slim.ops.conv2d], stride=1, padding='SAME'):
  net = slim.ops.conv2d(inputs, 64, [11, 11], 4, padding='VALID', scope='conv1')
  net = slim.ops.conv2d(net, 256, [5, 5],
                    weights_initializer=tf.truncated_normal_initializer(stddev=0.03),
                    scope='conv2')
  net = slim.ops.fc(net, 1000, activation_fn=None, scope='fc')

Nachdem Sie definiert haben, was für conv und fc gemeinsam ist, können Sie definieren, was nur für conv gilt.

Verlustfunktion

Das ist in Ordnung

python


loss = slim.losses.cross_entropy_loss(predictions, labels)

Ausbildung

slim.learning ist in Inception nicht enthalten und in slim in Contrib vorhanden.

python


g = tf.Graph()

#Modell und Verlustfunktion definieren
# ...

total_loss = tf.get_collection(slim.losses.LOSSES_COLLECTION)
optimizer = tf.train.GradientDescentOptimizer(learning_rate)

train_op = slim.learning.create_train_op(total_loss, optimizer)
logdir = './stored_log/'

slim.learning.train(
    train_op,
    logdir,
    number_of_steps=1000,
    save_summaries_secs=300,
    save_interval_secs=600)

Impressionen

Ich denke, dass es sehr praktisch sein wird, wenn es tatsächlich verwendet werden kann. Ich bin ziemlich froh, dass v0.10 normal verwendet werden kann.

Recommended Posts

Tensorflows praktische Bibliothek TF-Slim
Tensorflow / Keras-Zusammenfassung
Installation von TensorFlow, einer Bibliothek für maschinelles Lernen von Google
DNN (Deep Learning) Library: Vergleich von Chainer und TensorFlow (1)
Empfehlung der binpacking Bibliothek von Python
Experiment zur Optimierung der Tensorflow-Daten
Ich habe versucht, das CNN-Modell von TensorFlow mit TF-Slim umzugestalten
Einführung in die Konfiguration einer selbst erstellten Bibliothek
Bequeme Nutzungsübersicht von Flask
Installieren Sie eine ältere Version von Tensorflow
Zusammenfassung verschiedener Operationen in Tensorflow
Keras als Wrapper von Theano & TensorFlow
TensorFlow Tutorial-Vektordarstellung von Wörtern (Übersetzung)