[PYTHON] Anwendungsbeispiel für Keras: Eingabe (Einbetten + Reduzieren)

1. Installieren Sie Keras

Da die Installationsmethode von Tensorflow und Theano an verschiedenen Standorten eingeführt wird, wird hier auf eine ausführliche Erläuterung verzichtet. Keras-Installation

pip install Keras

Spielen Sie dann einfach mit der Konfigurationsdatei herum und wählen Sie Theano oder Tensorflow. Wenn Sie Tensorflow im Backend verwenden, wird automatisch die GPU verwendet.

Bei Verwendung von Tensorflow mit Keras ab Januar 2017 kann der folgende Fehler auftreten.

AttributeError: 'module' object has no attribute 'control_flow_ops'

Es scheint, dass ein solcher Fehler auftritt, weil python.control_flow_ops im Tensorflow nicht vorhanden ist. StackOverflow, [git Discussion](https://github.com / fchollet / keras / issue / 3857). Es kann geheilt werden, indem es am Anfang des Skripts wie folgt definiert wird.

import tensorflow as tf
tf.python.control_flow_ops = tf

2. Input(Embedding + Flatten) + Layer + Dropout + Output

Dies ist der Beispielcode, der in Kaggle Summary: Redhat eingeführt wurde. Das ursprüngliche Problem ist ein binäres Klassifizierungsproblem, ob ein unbekannter Kunde einen Dienst aus ungefähr 100 Variablen basierend auf Kundeninformationen kauft oder nicht. Unter ihnen veröffentlichte Qianqian eine Analysemethode mit Keras. ** Normalerweise werden Variablen so konstruiert und vorverarbeitet und dann unverändert in die Eingabeebene eingefügt. Qianqian leitet jedoch jede Variable unabhängig voneinander durch die Einbettungsebene und die Ebene "Reduzieren" und führt sie dann zusammen. ** ** **

Autorencode (qianqian) oder [dieser Code](https: // Bitte verwenden Sie gist.github.com/TomHortons/dd672a4323f42aed59316c9f56f72574).

Hier ist ein Diagramm, das das erstellte Modell mit visualize_util visualisiert. (Siehe "Andere" in diesem Artikel)

Hier konzentrieren wir uns auf die Erklärung der Embedding + Flatten-Verarbeitung aus dem Referenzquellcode.

Schauen wir uns zunächst den Teil zur Erstellung von Eingaben an. Die Eingabe wird mit dem folgenden Code erstellt.

flatten_layers = []
inputs = []

for c in columns:

    inputs_c = Input(shape=(1,), dtype='int32')

    num_c = len(np.unique(data[c].values))

    embed_c = Embedding(
                    num_c,
                    dim,
                    dropout=0.2,
                    input_length=1
                    )(inputs_c)
    flatten_c= Flatten()(embed_c)

    inputs.append(inputs_c)
    flatten_layers.append(flatten_c)

flatten = merge(flatten_layers,mode='concat')

Spalten ist eine Liste, in der Spaltennamen gespeichert werden. Wie Sie der ersten Abbildung entnehmen können, wird nicht jede Variable so eingegeben, wie sie ist. Eingabe-> Einbetten-> Reduzieren wird für jede Variable ausgeführt, und alle 1600 Variablen werden zusammengeführt, um sie zu einer Eingabeebene zu machen. Mit anderen Worten, eindimensionale numerische Daten werden auf 32 Dimensionen erweitert und eingegeben.

fc1 = Dense(hidden,activation='relu')(flatten)
dp1 = Dropout(0.5)(fc1)

outputs = Dense(1,activation='sigmoid')(dp1)

Danach werden eine Zwischenschicht (fc1) und ein Dropbou (dp1) als Ausgabe gesetzt.

Wie Sie in diesem Artikel sehen können, Deep Language Modeling for Question Answering using Keras Das Einbetten scheint als Word2Vec beim Sprachenlernen verwendet zu werden. Es war ein Rätsel, warum Embedding für numerische Daten verwendet wurde, bei denen es sich nicht um Sprachenlernen handelte. Deshalb habe ich das Kaggle-Forum überprüft.

Es sieht so aus, wenn ich es grob erkläre.

Die Einbettungsebene transformiert jede Kategorie in einen anderen Funktionsbereich. Es ist nicht einfach, eine Darstellung zu finden, die die besten Funktionen codiert, und können Sie all dies mit dieser Technik trainieren? .. Das beste Neuronale besteht nur aus der Einbettungsschicht mit einer Punktzahl von 0,9877. Durch Hinzufügen weiterer Funktionen wird es auf 0,989 verbessert. Es ist zunächst schwierig, jeden Parameter (Anzahl der ausgeblendeten Ebenen, Einbettungsdimension, Methode zum Zusammenführen zusätzlicher Features, Stapelgröße, Anzahl der Zug-Epochen) zu bestimmen.

Die Einbettungsebene hat die folgenden Funktionen. Für Kategoriedaten [1,2,3]

1. Codierung durchführen, 1: [1,0,0], 2: [0,1,0], 3: [0,0,1]
2. Multiplizieren Sie die Gewichtsmatrix W mit der Form (3, k).
3. Schließlich wird eine One-Hot-Matrix (spezifischer Wert ist 1 und dann Null) mit der Form (4, k) fertiggestellt.

Wobei k die Dimension des vom Benutzer festgelegten potenziellen Merkmals ist. Mit anderen Worten führt die Einbettungsschicht eine lineare Transformation der Kategoriedaten durch.

Darüber hinaus gibt es die folgende Erklärung für die flache Zehnschicht.

Da es nur einen Typ von Eingabesequenz gibt (die Eingabe ist eindimensional), ist die Ausgabe der Einbettungsschicht N * 1 * 32. Daher ist es notwendig, die Form der Ausgabe in N * 32 umzuwandeln. Wobei N die Anzahl der Eingabedaten ist (wahrscheinlich). Wenn M die Anzahl der Merkmalsgrößen der Kategorie ist, hat es eine dimensionale Eingabe von M * 32. Aus den oben genannten Gründen wird die abgeflachte Ausgabe verkettet. Die Eingabe des Keras-Modells ist die in einer Liste ausgedrückte Eingabeebene.

Sehr freundlich hat er die Beziehung zwischen der Einbettungsschicht und der Abflachungsebene neu geschrieben, sodass Sie die Ausgabe der mittleren Ebene sehen können.

inputs = [model.layers[0].input,K.learning_phase()]
outputs = [model.layers[3].output]
func = K.function(inputs, outputs)

sample_size = data.shape[0]
data_ae = []
batches = make_batches(sample_size, batch_size)
for batch_index, (batch_start, batch_end) in enumerate(batches):
    X_0 = data[batch_start:batch_end].toarray()
    yy = func([X_0,0])[0]
    print yy.shape
    data_ae.append(yy)


data_ae = np.vstack(data_ae)

Andere

Visualisieren Sie jede Ebene des von Keras erstellten Modells.

Installieren Sie pydot-ng und

pip install pydot-ng

Führen Sie wie folgt aus.

from keras.utils.visualize_util import plot
plot(model, to_file="model.png ", show_shapes=True)

Überprüfen Sie die Ausgabe der mittleren Ebene

Beim Entwerfen eines Keras-Modells möchten Sie manchmal das Verhalten der Zwischenebene überprüfen. In Document wird die Ausgabe der Zwischenebene durch Beschreiben der Keras-Funktion visualisiert.

from keras import backend as K

# with a Sequential model
get_3rd_layer_output = K.function([model.layers[0].input],
                                  [model.layers[3].output])
layer_output = get_3rd_layer_output([X])[0]

Wenn es eine Dropout-Ebene gibt, funktioniert dies, wenn das Lernphasen-Flag gesetzt ist.

get_3rd_layer_output = K.function([model.layers[0].input, K.learning_phase()],
                                  [model.layers[3].output])

# output in test mode = 0
layer_output = get_3rd_layer_output([X, 0])[0]

# output in train mode = 1
layer_output = get_3rd_layer_output([X, 1])[0]