Keras，如何获取每个层的输出？

Question

我用CNN训练了一个二分类模型，这是我的代码

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

我想要像TensorFlow一样获取每一层的输出，应该怎么做？

- GoingMyWay

Answer 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

注意：要模拟 Dropout，请在层输出中使用 learning_phase 作为 1.，否则请使用 0.。

编辑：（基于评论） K.function 创建 theano/tensorflow 张量函数，稍后用于根据输入从符号图获取输出。

现在需要将 K.learning_phase() 作为输入，因为许多 Keras 层（如 Dropout/Batchnomalization）依赖它在训练和测试时更改行为。

因此，如果您在代码中删除了dropout层，则可以简单地使用:

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内存，并且张量计算需要在底层多次执行。

相反，这是一种更好的方式，因为你不需要多个函数，而是一个单一的函数给你所有输出的列表：

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

- indraforyou

---

先生，您的回答很好，那么在您的代码中K.function（[inp]+ [K.learning_phase()]，[out]）是什么意思呢？ - GoingMyWay

Model使用K.function来构建预测函数在这里，并在预测循环中使用它在这里。如果未设置batch size，则预测将循环默认大小为32，但这是为了缓解GPU内存的限制。因此我不确定您为什么观察到model.predict更快。 - indraforyou

这里给我一个错误：ValueError("Tensor %s is not an element of this graph." % obj)。我的张量对象是 Tensor("data:0", shape=(?, 224, 224, 3), dtype=float32)。 - Ramesh-X

我得到了这个错误信息：InvalidArgumentError: S_input_39:0 同时被输入和输出。... 有没有人有什么想法？ - mathtick

错误：ValueError：Functional 的输入张量必须来自 tf.keras.Input。接收到：0（缺少先前层的元数据）。简单模型：inputs = tf.keras.layers.Input(shape=input_shape) x = tf.keras.layers.Dense(256, activation=None)(inputs) model = tf.keras.Model(inputs=inputs, outputs=x)。TensorFlow 版本为 2.5.0。只有第一个方法有效。 - Krzysztof Maliszewski

Answer 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]

- blue-sky

---

如果可以的话，我会给你两个^。这种方式在有大量输入时非常方便。 - Dan Erez

从你上面的代码来看很清楚，但只想再确认一下我的理解：在从已有模型创建一个新模型（假设它已经被训练）后，不需要调用set_weights来设置新模型的权重。这是正确的吗？ - JZ_42

layer_output = get_3rd_layer_output([X, 0])[0] 和 layer_output = get_3rd_layer_output([X, 1])[0] 的区别是什么？文档提到了训练模式和测试模式。 - Jason

抱歉，您能解释一下这个模型具体是做什么的吗？您需要对它进行训练吗？我无法想象出任何与之相关的图表。您是在将另一个模型的输入层添加到此模型中，然后将该其他模型的随机中间层作为输出层，并向其提供输入吗？为什么不直接使用原始模型并直接访问其中任何中间层呢？为什么要创建这个额外的奇怪模型？它不会影响输出结果吗？它是否会尝试学习或需要训练，或者该层是否带有从原始模型预先训练好的权重？ - PedroD

这个答案很好。感谢提供这个答案。 - Akhil Surapuram

Answer 3

基于本帖所有好的回答，我编写了一个库来获取每个层的输出。它抽象了所有的复杂性，并且被设计为尽可能用户友好：

https://github.com/philipperemy/keract

它可以处理几乎所有的边缘情况。

希望对您有所帮助！

- Philippe Remy

Answer 4

对我来说，以下看起来非常简单：

model.layers[idx].output

上面是一个张量对象，因此您可以使用适用于张量对象的操作对其进行修改。

例如，要获取形状model.layers[idx].output.get_shape()

idx是层的索引，您可以从model.summary()中找到它。

- devil in the detail

---

这个答案有什么问题吗？为什么它没有被投票为最佳答案？ - Black Jack 21

返回的是张量对象，而不是数据帧。与tf相关的对象使用起来比较奇怪。 - Kermit

海报表示他们想要获得每一层的输出。给定一些数据，如何从 model.layers[idx].output 中获取该层的输出？ - JoAnn Alvarez

Answer 5

这个答案基于：https://stackoverflow.com/a/59557567/2585501 要打印单个层的输出：

from tensorflow.keras import backend as K
layerIndex = 1
func = K.function([model.get_layer(index=0).input], model.get_layer(index=layerIndex).output)
layerOutput = func([input_data])  # input_data is a numpy array
print(layerOutput)

打印每个层的输出：

from tensorflow.keras import backend as K
for layerIndex, layer in enumerate(model.layers):
    func = K.function([model.get_layer(index=0).input], layer.output)
    layerOutput = func([input_data])  # input_data is a numpy array
    print(layerOutput)

- user2585501

---

我在拟合后使用了您的代码行，并打印出了梯度下降权重...如果我的使用是正确的，那么我得到的矩阵是否就是梯度（这里是权重）？无论如何，谢谢！ - JeeyCi

输入数据是指我用来获取模型预测的测试数据吗？就像我使用pred = my_model.predict(X)进行预测一样。我应该使用这个X而不是input_data吗？ - Kebby

Answer 6

之前的解决方案对我不起作用。我按照以下方式处理了这个问题。

layer_outputs = []
for i in range(1, len(model.layers)):
    tmp_model = Model(model.layers[0].input, model.layers[i].output)
    tmp_output = tmp_model.predict(img)[0]
    layer_outputs.append(tmp_output)

- johncasey

---

这里的“Model”是什么？ - Yash Gupta

正是我所需要的！+1 - spstrademark

Answer 7

我为自己编写了这个函数（在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')

- Miladiouss

---

如果模型有多个输入，你该如何指定这些输入？ - Antonio Sesto

在这一行代码中：layer_outputs_list = [op([test_image, 1.])。1.需要改成0吗？貌似1代表训练，0代表测试是吧？不是吗？ - Kongsea

这对我不起作用。我使用了一张彩色图像，但它给出了错误：InvalidArgumentError: input_2:0 被同时提供和获取。 - Vaibhav K

Answer 8

来源：https://github.com/philipperemy/keras-visualize-activations/blob/master/read_activations.py

此代码从Keras深度学习模型中读取激活值，并以易于理解的方式显示它们。

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

- cannin

---

链接已经过时。 - Saeed

如果您能解释您的代码并提供更多信息，那将是非常好的。 - nivalderramas

Answer 9

希望作为评论添加（但没有足够高的声誉）到@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:]，即可解决问题。

适应于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

p.s. 我尝试了像 outputs = [layer.output for layer in model.layers[1:]] 这样的方法，并没有成功。

- KamKam

---

这并不完全正确。只有在输入层是第一个定义的情况下才是如此。 - Mpizos Dimitris

谢谢，这个方法对我起作用了，我只是想确认一下自己的理解是否正确，根据Mpizos的评论：我的模型只有3层（单词嵌入 - 双向LSTM - CRF），所以我猜我必须排除layer[0]，因为它只是嵌入而不应该有激活函数，对吧？ - KMunro

@MpizosDimitris 是的，那是正确的，但在 @indraforyou 提供的示例中（我正在修改），情况就是这样。@KMunro 如果我理解正确，那么您不关心第一层的输出的原因是因为它只是单纯的词嵌入的输出，它本身就是张量形式的词嵌入（这只是您 keras 模型中“网络”部分的输入）。您的词嵌入层相当于此处提供的示例中的输入层。 - KamKam

Answer 10

假设你已经有了以下内容：

1. Keras 预训练的 `model`。

2. 输入 `x` 作为图像或一组图像。图像的分辨率应与输入层的维度兼容。例如，对于 3 通道（RGB）图像，大小为80*80*3。

3. 输出 `layer` 的名称以获取激活值。例如，“flatten_2” 层。此应包含在 `layer_names` 变量中，代表给定 `model` 的层的名称。

4. `batch_size` 是一个可选参数。

那么，您可以轻松使用 `get_activation` 函数获取给定输入 `x` 和预训练 `model` 下输出 `layer` 的激活值。

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

- imanzabet