Keras, Как получить выход каждого слоя?

Ответ 1

Вы можете легко получить выходные данные любого слоя, используя: model.layers[index].output

Для всех слоев используйте это:

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

Примечание. Чтобы смоделировать выпадение, используйте learning_phase в качестве 1. в layer_outs, в противном случае используйте 0.

Изменить: (на основе комментариев)

K.function создает тензорные функции theano/tenorflow, которые позже используются для получения выходных данных из символьного графа с учетом входных данных.

Теперь K.learning_phase() требуется в качестве входных данных, так как многие слои Keras, такие как Dropout/Batchnomalization, зависят от него, чтобы изменить поведение во время обучения и тестирования.

Поэтому, если вы удалите слой исключения в своем коде, вы можете просто использовать:

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

Изменить 2: более оптимизировано

Я только что понял, что предыдущий ответ не настолько оптимизирован, так как для каждой оценки функции данные будут передаваться CPU-> память GPU, а также необходимо выполнить тензорные вычисления для нижних уровней сверх n-более.

Вместо этого это гораздо лучший способ, так как вам не нужно несколько функций, а одна функция, предоставляющая вам список всех выходных данных:

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

Ответ 2

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

Один простой способ - создать новую модель, которая выведет интересующие вас слои:

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)

В качестве альтернативы, вы можете создать функцию Keras, которая будет возвращать выходные данные определенного слоя при заданном входном сигнале, например:

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]

Ответ 3

Я написал эту функцию для себя (в Jupyter), и она была вдохновлена ​​ответом indraforyou. Он автоматически выведет на экран все выходы уровня. Ваши изображения должны иметь форму (x, y, 1), где 1 обозначает 1 канал. Вы просто вызываете plot_layer_outputs (...) для построения.

%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')

Ответ 4

Основываясь на всех хороших ответах этой темы, я написал библиотеку для извлечения выходных данных каждого слоя. Он абстрагирует всю сложность и был разработан как можно более удобным для пользователя:

https://github.com/philipperemy/keract

Он обрабатывает почти все крайние случаи

Надеюсь, это поможет!

Ответ 5

После этого выглядит очень просто:

model.layers[idx].output

Выше - тензорный объект, поэтому вы можете его изменить, используя операции, которые могут быть применены к тензорному объекту.

Например, чтобы получить форму model.layers[idx].output.get_shape()

idx - это индекс слоя, и вы можете найти его из model.summary()

Ответ 6

От: 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 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

Ответ 7

Хотел добавить это в качестве комментария (но у него недостаточно высокой репутации) к ответу @indraforyou, чтобы исправить проблему, упомянутую в комментарии @mathtick. Чтобы избежать исключения InvalidArgumentError: input_X:Y is both fed and fetched., просто замените строку outputs = [layer.output for layer in model.layers] на outputs = [layer.output for layer in model.layers][1:], т.е.

адаптируясь под минимальный рабочий пример:

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

P.S. мои попытки пробовать такие вещи, как outputs = [layer.output for layer in model.layers[1:]], не сработали.

Ответ 8

Ну, другие ответы очень полны, но есть очень простой способ "увидеть", а не "получить" формы.

Просто сделайте model.summary(). Он напечатает все слои и их выходные формы. "None" значения будут указывать на переменные размеры, а первое измерение будет размером пакета.

Ответ 9

Если у вас есть:

1- Керас предварительно обучен model.

2- Введите x как изображение или набор изображений. Разрешение изображения должно соответствовать размеру входного слоя. Например, 80 * 80 * 3 для каналов 3- (RGB).

3- Имя выхода layer для получения активации. Например, слой "flatten_2". Это должно быть включено в переменную layer_names, представляющее имя слоев данного model.

4- batch_size - необязательный аргумент.

Затем вы можете легко использовать функцию get_activation, чтобы получить активацию выхода layer для данного входа x и предварительно обученного 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

Ответ 10

Если у вас есть один из следующих случаев:

• ошибка: InvalidArgumentError: input_X:Y is both fed and fetched
• случай нескольких входов

Вам необходимо внести следующие изменения:

• добавить фильтр для входных слоев в переменную outputs
• изменение миннора в цикле functors

Минимальный пример:

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]