[PYTHON] Untersuchen Sie die Beziehung zwischen TensorFlow und Keras in der Übergangszeit

([Unterschied in der Steuerung des Variablennamens](http://qiita.com/TomokIshii/items/178938b6db1edc16b94e#%E8%BF%BD%E8%A8%98%E5%A4%89%E6%95%B0%E5% 90% 8D% E3% 82% B3% E3% 83% B3% E3% 83% 88% E3% 83% AD% E3% 83% BC% E3% 83% AB% E3% 81% AE% E9% 81% Etwa 95% E3% 81% 84tfcontribkeras-vs-tflayers hinzugefügt).)

Einführung

Informationen wurden auf dem TensorFlow Dev Summit usw. veröffentlicht, die Integration von TensorFlow und Keras ist jedoch im Gange. Zitiert aus Keras Blog- Einführung in Keras 2.

Keras is best understood as an API specification, not as a specific codebase. In fact, going fowards there will be two separate implementations of the Keras spec: the internal TensorFlow one, available as tf.keras, written in pure TensorFlow and deeply compatible with all TensorFlow functionality, and the external multi-backend one supporting both Theano and TensorFlow (and likely even more backends in the future).

Keras wird in zwei Implementierungen unterteilt, eine für die TensorFlow-Integration und die andere für das Multi-Backend (Theno, TensorFlow usw.) als unabhängiges Paket. .. Früher habe ich nach Bedarf zu Theano / TensorFlow gewechselt, aber kürzlich wurde das TensorFlow-Backend ausgewählt. Von den beiden Keras-Paketen interessiert mich also mehr die integrierte Version von TensorFlow.

Der folgende Zeitplan wurde neulich auf dem Dev Summit bekannt gegeben. (Auszug aus YouTube)

Keras-take-aways.png

Wie oben erwähnt, scheinen wir Schritte wie "tf.contrib.keras" und "tf.keras" für die Integration zu planen. TensorFlow 1.1 (1.1.0-rc1) wurde dieses Mal veröffentlicht, daher möchte ich es sofort installieren und den Inhalt überprüfen.

(Die Programmierumgebung ist Python 3.5.2, TensorFlow 1.1.0-rc1, Keras 2.0.2.)

Keras 2 (Multi-Backend-Version) wurde ebenfalls veröffentlicht

Keras 2 wurde bereits veröffentlicht und Qiita hat einen Einführungsartikel. (Ich habe es gesehen.) Ich habe auch versucht, es in der Umgebung von TensorFlow 1.0 + Keras 2.0 zu verwenden. Die API hat sich gegenüber der endgültigen Version von Keras 1.0 (1.2.2?) Nicht wesentlich geändert. Die Schlüsselwörter (Argumente, Optionen usw.) einiger Funktionen haben sich jedoch im Detail geändert. Der Beispielcode für die MNIST-Klassifizierung lautet wie folgt.

# Keras 2.0 + TensorFlow 1.0 backend
import numpy as np
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation
from keras.optimizers import Adagrad
from keras.utils import np_utils

(Weggelassen)

model = Sequential()
model.add(Dense(512, input_dim=784))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Dense(10))
model.add(Activation('softmax'))

(Weggelassen)

Ich habe viel ausgelassen, aber achte auf den Importpunkt des Moduls (von keras.xxx).

Versuchen Sie es mit tf.contrib.keras (in TensorFlow 1.1)

Versuchen wir jetzt ** tf.contrib.keras **, das dieses Mal veröffentlicht wurde. Ich habe es codiert, indem ich Änderungen gegenüber dem obigen Code vorgenommen habe (TF 1.0 + Keras 2.0).

import numpy as np

from tensorflow.contrib.keras.python.keras.datasets import mnist
from tensorflow.contrib.keras.python.keras.models import Sequential
from tensorflow.contrib.keras.python.keras.layers import Dense
from tensorflow.contrib.keras.python.keras.layers import Dropout, Activation
from tensorflow.contrib.keras.python.keras.optimizers import Adagrad
from tensorflow.contrib.keras.python.keras.utils import np_utils
from tensorflow.contrib.keras.python.keras import backend as K

def load_data(nb_classes=10):
    # the data, shuffled and split between tran and test sets
    (X_train, y_train), (X_test, y_test) = mnist.load_data()
    X_train = X_train.reshape(60000, 784)
    X_test = X_test.reshape(10000, 784)
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')
    X_train /= 255
    X_test /= 255
    print(X_train.shape[0], 'train samples')
    print(X_test.shape[0], 'test samples')

    # convert class vectors to binary class matrices
    y_train = np_utils.to_categorical(y_train, nb_classes)
    y_test = np_utils.to_categorical(y_test, nb_classes)

    return X_train, y_train, X_test, y_test

def mk_model():
    model = Sequential()
    model.add(Dense(512, input_dim=784))
    model.add(Activation('relu'))
    model.add(Dropout(0.2))
    model.add(Dense(512))
    model.add(Activation('relu'))
    model.add(Dropout(0.2))
    model.add(Dense(10))
    model.add(Activation('softmax'))

    return model

In der ersten Hälfte des Codes ändert sich der Importpunkt des Moduls (offensichtlich). (Das Verzeichnis ist tief.) Obwohl es sich um einen Modellerstellungsteil handelt, ändert sich der Inhalt nicht (obwohl ich ihn in die Funktion "mk_model" eingefügt habe). Sieht aus wie 100% kompatibel mit der Keras 2.0-API (tf.contrib.keras).

Es gab auch keine wesentlichen Änderungen in der zweiten Hälfte des Codes (unten).

if __name__ == '__main__':
    np.random.seed(1337)        # for reproducibility
    batch_size = 128
    nb_epoch = 20

    X_train, y_train, X_test, y_test = load_data()
    model = mk_model()
    model.summary()             # check model configuration

    model.compile(loss='categorical_crossentropy',
                optimizer=Adagrad(),
                metrics=['accuracy'])
    
    model.fit(X_train, y_train,
          batch_size=batch_size, epochs=nb_epoch,
          verbose=1, 
          validation_data=(X_test, y_test))

    score = model.evaluate(X_test, y_test, verbose=0)
    print('\nTest score   : {:>.4f}'.format(score[0]))
    print('Test accuracy: {:>.4f}'.format(score[1]))

    K.clear_session()
    # This statement is fixed the condition of ...
    # Exception ignored in: <bound method BaseSession.__del__ of 
    # <tensorflow.python.client.session.Session object at 0x7fb79a3fa550>>
    # ...
    # AttributeError: 'NoneType' object has no attribute 'TF_NewStatus'
    #
    # TensorFlow issue: Exception ignored in BaseSession.__del__ #3388

Es scheint, dass es kein Funktionsproblem gibt. In Zukunft (obwohl ich das Keras-Paket nicht von der Festplatte gelöscht habe) scheint es, dass die Keras-API nur durch Installation von TensorFlow ohne Installation des Keras-Pakets verwendet werden kann. (Früher, in den Tagen von Keras 1.x.x, musste ich auf die Versionssynchronisation zwischen Keras und TensorFlow achten ...)

Beim Beenden des Programms trat jedoch ein Fehler auf, sodass ich ein wenig nachforschen musste. Es scheint, dass Probleme bei der Verarbeitung im Zusammenhang mit der Freigabe von Computerressourcen auftreten können. (Die Reproduzierbarkeit ist unbekannt, aber in meiner Umgebung ist die meiste Zeit ein Fehler aufgetreten.)

Wie oben erwähnt, besteht die Gegenmaßnahme darin, die Anweisung "K.clear_session ()" einzufügen. (Ich verstehe die Ursache dieses Fehlers und Fehlers nicht vollständig. Wenn Sie interessiert sind, lesen Sie bitte die entsprechende Website.)

Verwenden Sie Keras als Layer-Klassenbibliothek

Da dies Keras selbst ist, verlassen wir das Framework von Keras Model und verwenden es als Layer-Klassenbibliothek. Diese Verwendung wird seit langem unterstützt und ist nicht besonders neu, aber ich werde es mit der neuesten Version der Bibliothek (tf.contrib.keras) versuchen. (Die Quelle ist Keras Blog- Keras als vereinfachte Schnittstelle zu TensorFlow: Tutorial Masu.)

import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

from tensorflow.contrib.keras.python import keras
from tensorflow.contrib.keras.python.keras import backend as K

def load_data():
    dirn = '../MNIST_data'
    mnist = input_data.read_data_sets(dirn, one_hot=True)

    print(mnist.train.num_examples, 'train samples')
    print(mnist.test.num_examples, 'test samples')
    print(mnist.validation.num_examples, 'validation samples (not used)')

    return mnist

def mlp_model(input):
    # MLP network model
    with tf.variable_scope('mlp_model'):
        x = keras.layers.Dense(units=512, activation='relu')(input)
        x = keras.layers.Dropout(0.2)(x)
        x = keras.layers.Dense(units=512, activation='relu')(x)
        x = keras.layers.Dropout(0.2)(x)
        y_pred = keras.layers.Dense(units=10, activation='softmax')(x)

    return y_pred

if __name__ == '__main__':
    mnist = load_data()
    # tensorflow placeholders
    x = tf.placeholder(tf.float32, [None, 784])
    y_ = tf.placeholder(tf.float32, [None, 10])
    # define TF graph
    y_pred = mlp_model(x)
    loss = tf.losses.softmax_cross_entropy(y_, y_pred)
    train_step = tf.train.AdagradOptimizer(0.05).minimize(loss)
    correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    init = tf.global_variables_initializer()

    with tf.Session() as sess:
        sess.run(init)
        print('Training...')
        for i in range(10001):
            batch_xs, batch_ys = mnist.train.next_batch(100)
            train_fd = {x: batch_xs, y_: batch_ys, K.learning_phase(): 1}
            train_step.run(feed_dict=train_fd)
            if i % 1000 == 0:
                batch_xv, batch_yv = mnist.test.next_batch(200)
                val_accuracy = accuracy.eval(
                    {x: batch_xv, y_: batch_yv, K.learning_phase(): 0})
                print('  step, accurary = %6d: %6.3f' % (i, val_accuracy))
    
        test_fd = {x: mnist.test.images, y_: mnist.test.labels, 
                    K.learning_phase(): 0}
        test_accuracy = accuracy.eval(feed_dict=test_fd)
        print('Test accuracy:', test_accuracy)

Ich konnte den Klassifizierungscode basierend auf dem MLP-Modell (Multi-Layer Perceptron) von MNIST als "sauber" schreiben. (Im Vergleich zum "einfachen" TensorFlow-Code, der die HighLevel-API nicht verwendet, bedeutet dies "sauber".)

Der Vorteil der Verwendung von Keras als Layer-Klassenbibliothek besteht darin, dass der Standardwert "entsprechend" festgelegt wird. Dieser Punkt wurde in der Präsentation auf dem TensorFlow Dev Summit als "zugängliche High-Level-API mit guten Standardeinstellungen" hervorgehoben. Im obigen Code wird der Variableninitialisierer in der vollständigen Verbindungsschicht Dense () nicht detailliert festgelegt, aber der Initialisierer von 'glorot_uniform' (Xavier-Uniform) wird für Weight und 'Null' für Bias angewendet. Der Initialisierer wird angewendet. (Es scheint, dass diese Parameterinitialisierungsmethode häufig im aktuellen Beispielcode für neuronale Netze verwendet wird.) (Die Einstellung feed_dict von K.learning_phase () steuert das Verhalten von Dropout. Weitere Informationen finden Sie im Keras-Blog "Keras als vereinfachtes ...".)

Im Moment bin ich gespannt, wie die Tensor-Variable verwendet wird. Überprüfen Sie daher den Namen (Variablenname).

#    vars = tf.global_variables()
#    print('variables:')
#    for v in vars:
#        print(v)

variables:
<tf.Variable 'mlp_model/dense_1/kernel:0' shape=(784, 512) dtype=float32_ref>
<tf.Variable 'mlp_model/dense_1/bias:0' shape=(512,) dtype=float32_ref>
<tf.Variable 'mlp_model/dense_2/kernel:0' shape=(512, 512) dtype=float32_ref>
<tf.Variable 'mlp_model/dense_2/bias:0' shape=(512,) dtype=float32_ref>
<tf.Variable 'mlp_model/dense_3/kernel:0' shape=(512, 10) dtype=float32_ref>
<tf.Variable 'mlp_model/dense_3/bias:0' shape=(10,) dtype=float32_ref>
<tf.Variable 'mlp_model/dense_1/kernel/Adagrad:0' shape=(784, 512) dtype=float32_ref>
<tf.Variable 'mlp_model/dense_1/bias/Adagrad:0' shape=(512,) dtype=float32_ref>
<tf.Variable 'mlp_model/dense_2/kernel/Adagrad:0' shape=(512, 512) dtype=float32_ref>
<tf.Variable 'mlp_model/dense_2/bias/Adagrad:0' shape=(512,) dtype=float32_ref>
<tf.Variable 'mlp_model/dense_3/kernel/Adagrad:0' shape=(512, 10) dtype=float32_ref>
<tf.Variable 'mlp_model/dense_3/bias/Adagrad:0' shape=(10,) dtype=float32_ref>

Von den obigen 12 tf.Variablen sind die ersten 6 das Gewicht (Kernel) und die Vorspannung der dichten Schicht, und die verbleibenden 6 sind die abgeleiteten Variablen des Optimierers. Das root'mlp_model' wurde von mir im Code benannt, aber'dense_1 / kernel ',' dens_1 / Bias ', ... werden automatisch von "tf.contrib.keras" benannt. Es ist. Ich habe die Dokumentation durchsucht, weil ich den Namen dieser Tensor-Variablen selbst bestimmen wollte, aber es scheint, dass sie derzeit keine Benutzernamen unterstützt. (Es kann eine Verwendung sein, die vom Konzept abweicht, kleine Details so weit wie möglich zu verbergen, um die Verwendung zu vereinfachen.)

Wenn Sie über "Name & Variablenbereich" auf Tensorvariablen zugreifen möchten

Wenn Sie auf den Tensor-Variablennamen zugreifen oder den Variablennamen zum Zweck der Gewichtsverteilung usw. selbst festlegen möchten, ist es anscheinend besser, sich von der Keras-API zu entfernen.

import numpy as np
import tensorflow as tf
from tensorflow.python.layers import layers
from tensorflow.examples.tutorials.mnist import input_data
from sklearn.metrics import confusion_matrix

# Create n.n. model
def nn_model(images, drop_rate, vs, reuse=False):
    with tf.variable_scope(vs, reuse=reuse):
        net = tf.layers.dense(images, 512, activation=tf.nn.relu, name='dense1')
        net = tf.layers.dropout(net, rate=drop_rate)
        net = tf.layers.dense(net, 512, activation=tf.nn.relu, name='dense2')
        net = tf.layers.dropout(net, rate=drop_rate)
        net = tf.layers.dense(net, 10, activation=None, name='dense3')
   
    return net

x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])
keep_prob = tf.placeholder(tf.float32)

drop_rate = 1 - keep_prob
mlp1_pred = nn_model(x, drop_rate, 'mlp1')
mlp2_pred = nn_model(x, drop_rate, 'mlp1', reuse=True) 

loss = tf.losses.softmax_cross_entropy(y_, mlp1_pred)
train_step = tf.train.AdagradOptimizer(0.05).minimize(loss)
correct_prediction = tf.equal(tf.argmax(mlp1_pred, 1), tf.argmax(y_, 1))
accuracy1 = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

Das Obige ist die Codierung mit "tf.layers", die von TensorFlow 1.0 oder höher unterstützt werden. Hier können Sie den Variablennamen und den Variablenbereich selbst steuern und gemeinsam genutzte Variablen mit dem Flag "Wiederverwendung" frei festlegen.

(Referenz, Qiita oben)

Übrigens, bemerken Sie etwas, wenn Sie sich den obigen Code auf der Basis von "tf.layers" ansehen?

Ja, die API von "tf.layers" und die API von "tf.contrib.keras" sind sehr ähnlich.

Es wird wahrscheinlich andere geben.

In meiner oben erwähnten "API mit zunehmendem TensorFlow ..." schrieb ich negativ an "tf.layers", da "API nicht organisiert und organisiert ist", sondern in Wirklichkeit Keras API Die Integration mit wurde erwogen. Das in Keras 2.0 geänderte Schlüsselwort soll auch eine Änderung in Bezug auf "tf.layers" sein (ich bedauere meine Gedankenlosigkeit).

Schließlich

Nach vielen Recherchen können wir eine zukünftige Integration von TensorFlow und Keras erwarten, insbesondere die nächste Version, TensorFlow 1.2. (Ist es um Mai-2017?) Es gibt derzeit nicht viele Informationen darüber, um welche Art von API es sich handelt. Angesichts der Beziehung zwischen der aktuellen unabhängigen Paketversion von Keras 2 und "tf.contrib.keras" besteht jedoch ein großes Problem hinsichtlich der API-Kontinuität. Ich erwarte nicht, dass es passiert. Vorerst möchte ich mein Verständnis der aktuellen Version vertiefen und gleichzeitig eine höhere Funktionalität von TensorFlow und Benutzerfreundlichkeit mit "tf.keras" erwarten.

(Ergänzung) Unterschied in der Steuerung des Variablennamens "tf.contrib.keras" vs. "tf.layers"

In der obigen Einführung von tf.conrib.keras schrieb ich: "Derzeit scheint es die Benennung von Benutzern nicht zu unterstützen.", Aber das war falsch. Es scheint, dass Sie die Option "Name" in der Ebenendefinition angeben können. (Obwohl dies im Dokument nicht erläutert wird, gab es einen Teil, in dem "Name" im Testcode in Github verwendet wurde.) Es scheint jedoch, dass die Variable nicht durch Angabe von "Wiederverwendung" wiederverwendet wird. Siehe den Code unten.

import numpy as np
import tensorflow as tf

from tensorflow.contrib.keras.python import keras
from tensorflow.contrib.keras.python.keras import backend as K
from tensorflow.python.layers import layers

def mlp_model_keras1(input):
    # MLP network model
    with tf.variable_scope('mlp_model'):
        x = keras.layers.Dense(units=512, activation='relu', name='my_dense1')(input)
        x = keras.layers.Dense(units=512, activation='relu', name='my_dense2')(x)
        y_pred = keras.layers.Dense(units=10, activation='softmax', name='my_softmax')(x)

    return y_pred

def mlp_model_keras2(input):
    # MLP network model
    with tf.variable_scope('mlp_model', reuse=True):
        x = keras.layers.Dense(units=512, activation='relu', name='my_dense1')(input)
        x = keras.layers.Dense(units=512, activation='relu', name='my_dense2')(x)
        y_pred = keras.layers.Dense(units=10, activation='softmax', name='my_softmax')(x)

    return y_pred

# Create the model
def mlp_model_by_layers1(input):
    with tf.variable_scope('mlp_by_tflayers'):
        net = tf.layers.dense(input, 512, activation=tf.nn.relu, name='his_dense1')
        net = tf.layers.dense(net, 512, activation=tf.nn.relu, name='his_dense2')
        net = tf.layers.dense(net, 10, activation=None, name='his_dense3')
   
    return net

def mlp_model_by_layers2(input):
    with tf.variable_scope('mlp_by_tflayers', reuse=True):
        net = tf.layers.dense(input, 512, activation=tf.nn.relu, name='his_dense1')
        net = tf.layers.dense(net, 512, activation=tf.nn.relu, name='his_dense2')
        net = tf.layers.dense(net, 10, activation=None, name='his_dense3')
   
    return net

if __name__ == '__main__':
    fake_data = np.ones([10, 784], dtype=np.float32) * 0.5
    x = tf.placeholder(tf.float32, [None, 784])

    # define TF graph
    y_pred1 = mlp_model_keras1(x)
    y_pred2 = mlp_model_keras2(x)
    y_pred3 = mlp_model_by_layers1(x)
    y_pred4 = mlp_model_by_layers2(x)
    
    init = tf.global_variables_initializer()

    with tf.Session() as sess:
        sess.run(init)

    vars = tf.global_variables()
    print('variables:')
    for v in vars:
        print(v)
'''
variables:
#Erste Funktion"mlp_model_keras1"Variablen definiert in
<tf.Variable 'mlp_model/my_dense1/kernel:0' shape=(784, 512) dtype=float32_ref>
<tf.Variable 'mlp_model/my_dense1/bias:0' shape=(512,) dtype=float32_ref>
<tf.Variable 'mlp_model/my_dense2/kernel:0' shape=(512, 512) dtype=float32_ref>
<tf.Variable 'mlp_model/my_dense2/bias:0' shape=(512,) dtype=float32_ref>
<tf.Variable 'mlp_model/my_softmax/kernel:0' shape=(512, 10) dtype=float32_ref>
<tf.Variable 'mlp_model/my_softmax/bias:0' shape=(10,) dtype=float32_ref>

#Zweite Funktion"mlp_model_keras2"Variablen definiert in
<tf.Variable 'mlp_model_1/my_dense1/kernel:0' shape=(784, 512) dtype=float32_ref>
<tf.Variable 'mlp_model_1/my_dense1/bias:0' shape=(512,) dtype=float32_ref>
<tf.Variable 'mlp_model_1/my_dense2/kernel:0' shape=(512, 512) dtype=float32_ref>
<tf.Variable 'mlp_model_1/my_dense2/bias:0' shape=(512,) dtype=float32_ref>
<tf.Variable 'mlp_model_1/my_softmax/kernel:0' shape=(512, 10) dtype=float32_ref>
<tf.Variable 'mlp_model_1/my_softmax/bias:0' shape=(10,) dtype=float32_ref>

#Dritte Funktion"mlp_model_by_layers1"Variablen definiert in
<tf.Variable 'mlp_by_tflayers/his_dense1/kernel:0' shape=(784, 512) dtype=float32_ref>
<tf.Variable 'mlp_by_tflayers/his_dense1/bias:0' shape=(512,) dtype=float32_ref>
<tf.Variable 'mlp_by_tflayers/his_dense2/kernel:0' shape=(512, 512) dtype=float32_ref>
<tf.Variable 'mlp_by_tflayers/his_dense2/bias:0' shape=(512,) dtype=float32_ref>
<tf.Variable 'mlp_by_tflayers/his_dense3/kernel:0' shape=(512, 10) dtype=float32_ref>
<tf.Variable 'mlp_by_tflayers/his_dense3/bias:0' shape=(10,) dtype=float32_ref>

#Vierte Funktion"mlp_model_by_layers2"Die in definierten Variablen werden (sonst) nicht gefunden.
'''

Von den vier Modellen verwenden die ersten beiden tf.contrib.keras. Wenn "name" in "keras.layers.Dense" angegeben ist, wird der Name im Variablennamen wiedergegeben. Im zweiten Modell habe ich denselben Variablenbereich (denselben Variablennamen) festgelegt und tf.variable_scope "reuse = True" hinzugefügt. Dies wurde jedoch ignoriert und der Name des Variablenbereichs wurde automatisch von "mlp_model" in "mlp_model_1" geändert. Der Variablenname wurde durch Konvertieren angegeben.

Andererseits bewirkt das Ergebnis, dasselbe für das 3. und 4. tf.layers-Modell zu tun, nicht die automatische Änderung des Bereichsnamens, und das Ergebnis ist wie im Kommentarteil des obigen Codes gezeigt. (Variablen sind nur für die durch die 3. Funktion definierte Variable reserviert, und für die 4. Funktion sind keine neuen Variablen reserviert. Ich habe den Inhalt nicht ordnungsgemäß bestätigt, aber wie erwartet werden die Variablen neu zugewiesen. Es ist wahrscheinlich, dass die Verwendung und die gemeinsam genutzten Variablen festgelegt wurden.

Ich glaube nicht, dass jemand die Bibliothek tf.contrib.keras zusammen mit tf.layers verwendet, aber das Verhalten ist anders, daher denke ich, dass es eine ** "Gefahr des Mischens" ** ist. (Ich denke, dass sich die oben gezeigten Spezifikationen in zukünftigen Versionen ändern können.)

Referenzen, Website

Recommended Posts

Untersuchen Sie die Beziehung zwischen TensorFlow und Keras in der Übergangszeit
Die subtile Beziehung zwischen Gentoo und Pip
Über die Beziehung zwischen Git und GitHub
Ich untersuchte die Beziehung zwischen Keras 'zustandsbehaftetem LSTM und verstecktem Zustand
Über den Unterschied zwischen "==" und "is" in Python
Untersuchung des Zusammenhangs zwischen Eisausgaben und Temperatur
Wählen Sie die erforderlichen Variablen in TensorFlow aus und speichern / wiederherstellen
Vergleiche "log and infininity" mit Gauche (0.9.4) und Python (3.5.1)
Untersuchung der Beziehung zwischen Sprachvorverarbeitung und Transkriptionsgenauigkeit in der Google Cloud Speech API
Clipping und Normalisierung in TensorFlow
Ich berührte Tensorflow und Keras
[Statistik] Lassen Sie uns die Beziehung zwischen der Normalverteilung und der Chi-Quadrat-Verteilung visualisieren.
Unterschied zwischen list () und [] in Python
Untersuchen Sie die Beziehung zwischen zwei Variablen (2)
Unterschied zwischen == und ist in Python
Untersuchen Sie die Beziehung zwischen zwei Variablen (1)
Ich habe das VGG16-Modell mit Keras implementiert und versucht, CIFAR10 zu identifizieren
Unterschied in der Authentizität zwischen Python und JavaScript
Unterschiede zwischen Ruby und Python im Umfang
Unterschied zwischen Anweisungen (Anweisungen) und Ausdrücken (Ausdrücken) in Python
Unterschiede zwischen Python- und Java-Syntax
Vergleichen Sie rohen TensorFlow mit tf.contrib.learn und Keras
Unterschied zwischen @classmethod und @staticmethod in Python
Unterschied zwischen Anhängen und + = in der Python-Liste
Unterschied zwischen nicht lokal und global in Python
Suchen Sie es in der Warteschlange und bearbeiten Sie es
Unterschiede in der Multithread-Verarbeitung zwischen Python und Jython
Beziehung zwischen Netfilter, Firewall, Iptables und Nftables
Differenz- und Kompatibilitätsprüfung zwischen Keras und tf.keras # 1
Erstellen Sie eine REST-API mit dem in Lobe und TensorFlow Serving erlernten Modell.
Verstehen Sie die Bilder verschiedener Matrixoperationen, die in Keras (Tensorflow) verwendet werden, anhand von Beispielen
Lassen Sie uns die Beziehung zwischen Durchschnittsgehalt und Industrie mit XBRL-Daten und Seaborn visualisieren! (7/10)
Was ist der Unterschied zwischen "pip" und "conda"?
Beziehung zwischen Firestore- und Go-Datentypkonvertierung
Unterschiede zwischen queryStringParameters und multiValueQueryStringParameters in AWS Lambda
Zusammenfassung der Unterschiede zwischen PHP und Python
12. Speichern Sie die erste Spalte in col1.txt und die zweite Spalte in col2.txt
Die Antwort von "1/2" unterscheidet sich zwischen Python2 und 3
Unterschied zwischen Variablen und Selbst. Variablen in der [Python] -Klasse
Wenn sich Achse und Beschriftung in matplotlib überlappen
[Keras] Implementiere einen lauten Schüler und überprüfe den Effekt
Berechnen Sie den Winkel zwischen n-dimensionalen Vektoren mit TensorFlow
Über den Unterschied zwischen PostgreSQL su und sudo
Was ist der Unterschied zwischen Unix und Linux?
Verstehen Sie den TensorFlow-Namespace und die gemeinsam genutzten Mastervariablen
[Python] Erläutert anhand eines Beispiels den Unterschied zwischen strftime und strptime im datetime-Modul