Keras, wie bekomme ich die Ausgabe jeder Schicht?

Ich habe ein binäres Klassifizierungsmodell mit CNN trainiert und hier ist mein Code

model = Sequential()
model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1],
                        border_mode='valid',
                        input_shape=input_shape))
model.add(Activation('relu'))
model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=pool_size))
# (16, 16, 32)
model.add(Convolution2D(nb_filters*2, kernel_size[0], kernel_size[1]))
model.add(Activation('relu'))
model.add(Convolution2D(nb_filters*2, kernel_size[0], kernel_size[1]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=pool_size))
# (8, 8, 64) = (2048)
model.add(Flatten())
model.add(Dense(1024))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(2))  # define a binary classification problem
model.add(Activation('softmax'))

model.compile(loss='categorical_crossentropy',
              optimizer='adadelta',
              metrics=['accuracy'])
model.fit(x_train, y_train,
          batch_size=batch_size,
          nb_epoch=nb_epoch,
          verbose=1,
          validation_data=(x_test, y_test))

Und hier möchte ich die Ausgabe jeder Ebene genau wie TensorFlow erhalten. Wie kann ich das tun?

Sie können die Ausgaben jeder Ebene einfach abrufen, indem Sie Folgendes verwenden: model.layers[index].output

Verwenden Sie für alle Ebenen Folgendes:

from keras import backend as K

inp = model.input                                           # input placeholder
outputs = [layer.output for layer in model.layers]          # all layer outputs
functors = [K.function([inp, K.learning_phase()], [out]) for out in outputs]    # evaluation functions

# Testing
test = np.random.random(input_shape)[np.newaxis,...]
layer_outs = [func([test, 1.]) for func in functors]
print layer_outs

Hinweis: Um die Dropout-Verwendung learning_phasewie 1.bei einer layer_outsanderen Verwendung zu simulieren0.

Bearbeiten: (basierend auf Kommentaren)

K.function Erstellt die Theano- / Tensorflow-Tensorfunktionen, die später verwendet werden, um die Ausgabe aus dem symbolischen Diagramm bei gegebener Eingabe zu erhalten.

Jetzt K.learning_phase()ist eine Eingabe erforderlich, da viele Keras-Ebenen wie Dropout / Batchnomalization davon abhängen, um das Verhalten während des Trainings und der Testzeit zu ändern.

Wenn Sie also die Dropout-Ebene in Ihrem Code entfernen, können Sie einfach Folgendes verwenden:

from keras import backend as K

inp = model.input                                           # input placeholder
outputs = [layer.output for layer in model.layers]          # all layer outputs
functors = [K.function([inp], [out]) for out in outputs]    # evaluation functions

# Testing
test = np.random.random(input_shape)[np.newaxis,...]
layer_outs = [func([test]) for func in functors]
print layer_outs

Edit 2: Optimierter

Ich habe gerade festgestellt, dass die vorherige Antwort nicht so optimiert ist, da für jede Funktionsbewertung die Daten übertragen werden. CPU-> GPU-Speicher und auch die Tensorberechnungen müssen für die unteren Schichten über und über durchgeführt werden.

Stattdessen ist dies ein viel besserer Weg, da Sie nicht mehrere Funktionen benötigen, sondern eine einzige Funktion, die Ihnen die Liste aller Ausgaben liefert:

from keras import backend as K

inp = model.input                                           # input placeholder
outputs = [layer.output for layer in model.layers]          # all layer outputs
functor = K.function([inp, K.learning_phase()], outputs )   # evaluation function

# Testing
test = np.random.random(input_shape)[np.newaxis,...]
layer_outs = functor([test, 1.])
print layer_outs

Von https://keras.io/getting-started/faq/#how-can-i-obtain-the-output-of-an-intermediate-layer

Eine einfache Möglichkeit besteht darin, ein neues Modell zu erstellen, das die Ebenen ausgibt, an denen Sie interessiert sind:

from keras.models import Model

model = ...  # include here your original model

layer_name = 'my_layer'
intermediate_layer_model = Model(inputs=model.input,
                                 outputs=model.get_layer(layer_name).output)
intermediate_output = intermediate_layer_model.predict(data)

Alternativ können Sie eine Keras-Funktion erstellen, die die Ausgabe einer bestimmten Ebene bei einer bestimmten Eingabe zurückgibt, z. B.:

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]

Basierend auf all den guten Antworten dieses Threads habe ich eine Bibliothek geschrieben, um die Ausgabe jeder Ebene abzurufen. Es abstrahiert die gesamte Komplexität und wurde so benutzerfreundlich wie möglich gestaltet:

https://github.com/philipperemy/keract

Es behandelt fast alle Randfälle

Ich hoffe es hilft!

Folgendes sieht für mich sehr einfach aus:

model.layers[idx].output

Oben befindet sich ein Tensorobjekt, sodass Sie es mithilfe von Operationen ändern können, die auf ein Tensorobjekt angewendet werden können.

Zum Beispiel, um die Form zu bekommen model.layers[idx].output.get_shape()

idx ist der Index der Ebene und Sie können ihn von finden model.summary()

Ich habe diese Funktion für mich selbst geschrieben (in Jupyter) und sie wurde von Indraforyous Antwort inspiriert . Alle Ebenenausgaben werden automatisch geplottet. Ihre Bilder müssen eine (x, y, 1) Form haben, wobei 1 für 1 Kanal steht. Sie rufen einfach plot_layer_outputs (...) auf, um zu zeichnen.

%matplotlib inline
import matplotlib.pyplot as plt
from keras import backend as K

def get_layer_outputs():
    test_image = YOUR IMAGE GOES HERE!!!
    outputs    = [layer.output for layer in model.layers]          # all layer outputs
    comp_graph = [K.function([model.input]+ [K.learning_phase()], [output]) for output in outputs]  # evaluation functions

    # Testing
    layer_outputs_list = [op([test_image, 1.]) for op in comp_graph]
    layer_outputs = []

    for layer_output in layer_outputs_list:
        print(layer_output[0][0].shape, end='\n-------------------\n')
        layer_outputs.append(layer_output[0][0])

    return layer_outputs

def plot_layer_outputs(layer_number):    
    layer_outputs = get_layer_outputs()

    x_max = layer_outputs[layer_number].shape[0]
    y_max = layer_outputs[layer_number].shape[1]
    n     = layer_outputs[layer_number].shape[2]

    L = []
    for i in range(n):
        L.append(np.zeros((x_max, y_max)))

    for i in range(n):
        for x in range(x_max):
            for y in range(y_max):
                L[i][x][y] = layer_outputs[layer_number][x][y][i]


    for img in L:
        plt.figure()
        plt.imshow(img, interpolation='nearest')

Von: https://github.com/philipperemy/keras-visualize-activations/blob/master/read_activations.py

import keras.backend as K

def get_activations(model, model_inputs, print_shape_only=False, layer_name=None):
    print('----- activations -----')
    activations = []
    inp = model.input

    model_multi_inputs_cond = True
    if not isinstance(inp, list):
        # only one input! let's wrap it in a list.
        inp = [inp]
        model_multi_inputs_cond = False

    outputs = [layer.output for layer in model.layers if
               layer.name == layer_name or layer_name is None]  # all layer outputs

    funcs = [K.function(inp + [K.learning_phase()], [out]) for out in outputs]  # evaluation functions

    if model_multi_inputs_cond:
        list_inputs = []
        list_inputs.extend(model_inputs)
        list_inputs.append(0.)
    else:
        list_inputs = [model_inputs, 0.]

    # Learning phase. 0 = Test mode (no dropout or batch normalization)
    # layer_outputs = [func([model_inputs, 0.])[0] for func in funcs]
    layer_outputs = [func(list_inputs)[0] for func in funcs]
    for layer_activations in layer_outputs:
        activations.append(layer_activations)
        if print_shape_only:
            print(layer_activations.shape)
        else:
            print(layer_activations)
    return activations

Wollte dies als Kommentar (aber nicht hoch genug) zu @ indraforyous Antwort hinzufügen, um das in @ mathticks Kommentar erwähnte Problem zu beheben. Um die InvalidArgumentError: input_X:Y is both fed and fetched.Ausnahme zu vermeiden , ersetzen Sie einfach die Zeile outputs = [layer.output for layer in model.layers]durch outputs = [layer.output for layer in model.layers][1:], dh

Anpassen des minimalen Arbeitsbeispiels von indraforyou:

from keras import backend as K 
inp = model.input                                           # input placeholder
outputs = [layer.output for layer in model.layers][1:]        # all layer outputs except first (input) layer
functor = K.function([inp, K.learning_phase()], outputs )   # evaluation function

# Testing
test = np.random.random(input_shape)[np.newaxis,...]
layer_outs = functor([test, 1.])
print layer_outs

ps meine Versuche, Dinge auszuprobieren, wie outputs = [layer.output for layer in model.layers[1:]]sie nicht funktionierten.

Vorausgesetzt, Sie haben:

1- Keras vorab trainiert model.

2- Eingabe xals Bild oder Bildsatz. Die Auflösung des Bildes sollte mit der Dimension der Eingabeebene kompatibel sein. Zum Beispiel 80 * 80 * 3 für 3-Kanal-Bilder (RGB).

3- Der Name des Ausgangs layer, um die Aktivierung zu erhalten. Zum Beispiel die Ebene "flatten_2". Dies sollte in der layer_namesVariablen enthalten sein, repräsentiert den Namen der Ebenen der angegebenen model.

4- batch_sizeist ein optionales Argument.

Dann können Sie einfach die get_activationFunktion verwenden, um die Aktivierung des Ausgangs layerfür einen bestimmten Eingang zu erhalten xund vorab zu trainieren model:

import six
import numpy as np
import keras.backend as k
from numpy import float32
def get_activations(x, model, layer, batch_size=128):
"""
Return the output of the specified layer for input `x`. `layer` is specified by layer index (between 0 and
`nb_layers - 1`) or by name. The number of layers can be determined by counting the results returned by
calling `layer_names`.
:param x: Input for computing the activations.
:type x: `np.ndarray`. Example: x.shape = (80, 80, 3)
:param model: pre-trained Keras model. Including weights.
:type model: keras.engine.sequential.Sequential. Example: model.input_shape = (None, 80, 80, 3)
:param layer: Layer for computing the activations
:type layer: `int` or `str`. Example: layer = 'flatten_2'
:param batch_size: Size of batches.
:type batch_size: `int`
:return: The output of `layer`, where the first dimension is the batch size corresponding to `x`.
:rtype: `np.ndarray`. Example: activations.shape = (1, 2000)
"""

    layer_names = [layer.name for layer in model.layers]
    if isinstance(layer, six.string_types):
        if layer not in layer_names:
            raise ValueError('Layer name %s is not part of the graph.' % layer)
        layer_name = layer
    elif isinstance(layer, int):
        if layer < 0 or layer >= len(layer_names):
            raise ValueError('Layer index %d is outside of range (0 to %d included).'
                             % (layer, len(layer_names) - 1))
        layer_name = layer_names[layer]
    else:
        raise TypeError('Layer must be of type `str` or `int`.')

    layer_output = model.get_layer(layer_name).output
    layer_input = model.input
    output_func = k.function([layer_input], [layer_output])

    # Apply preprocessing
    if x.shape == k.int_shape(model.input)[1:]:
        x_preproc = np.expand_dims(x, 0)
    else:
        x_preproc = x
    assert len(x_preproc.shape) == 4

    # Determine shape of expected output and prepare array
    output_shape = output_func([x_preproc[0][None, ...]])[0].shape
    activations = np.zeros((x_preproc.shape[0],) + output_shape[1:], dtype=float32)

    # Get activations with batching
    for batch_index in range(int(np.ceil(x_preproc.shape[0] / float(batch_size)))):
        begin, end = batch_index * batch_size, min((batch_index + 1) * batch_size, x_preproc.shape[0])
        activations[begin:end] = output_func([x_preproc[begin:end]])[0]

    return activations

Falls Sie einen der folgenden Fälle haben:

• Error: InvalidArgumentError: input_X:Y is both fed and fetched
• Fall von mehreren Eingängen

Sie müssen die folgenden Änderungen vornehmen:

• Filter für Eingabe-Layer in outputsVariable hinzufügen
• minnor change on functorsloop

Minimales Beispiel:

from keras.engine.input_layer import InputLayer
inp = model.input
outputs = [layer.output for layer in model.layers if not isinstance(layer, InputLayer)]
functors = [K.function(inp + [K.learning_phase()], [x]) for x in outputs]
layer_outputs = [fun([x1, x2, xn, 1]) for fun in functors]

Nun, andere Antworten sind sehr vollständig, aber es gibt eine sehr grundlegende Möglichkeit, die Formen zu "sehen" und nicht zu "bekommen".

Mach einfach eine model.summary(). Es werden alle Ebenen und ihre Ausgabeformen gedruckt. "Keine" -Werte geben variable Dimensionen an, und die erste Dimension ist die Stapelgröße.