Keras，如何获取每一层的输出？
Keras, How to get the output of each layer?
我已经用 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 一样获取每一层的输出，我该怎么做？
您可以使用以下方法轻松获取任何层的输出：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 作为 layer_outs 中的 1. 否则使用 0.
编辑：（基于评论）
K.function 创建 theano/tensorflow 张量函数，稍后用于在给定输入的情况下从符号图中获取输出。
现在需要 K.learning_phase() 作为输入，因为像 Dropout/Batchnomalization 这样的许多 Keras 层都依赖它来改变训练和测试期间的行为。
因此，如果您删除代码中的 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内存并且还需要为较低层进行张量计算over-n-over。
相反，这是一种更好的方法，因为您不需要多个函数，只需一个函数即可为您提供所有输出的列表：
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
我为自己（在 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')
好吧，其他答案很完整，但是有一个非常基本的方法 "see"，而不是 "get" 形状。
就做一个model.summary()。它将打印所有图层及其输出形状。 "None" 值将指示可变维度，第一个维度将是批量大小。
以下在我看来很简单：
model.layers[idx].output
以上是一个张量对象，因此您可以使用可应用于张量对象的操作对其进行修改。
例如得到形状model.layers[idx].output.get_shape()
idx是图层的索引，可以从model.summary()
中找到
来自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 函数，该函数将 return 给定特定输入的特定层的输出，例如：
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]
发件人：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
想将此作为评论（但没有足够高的代表）添加到@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:]] 之类的尝试没有奏效。
假设您有：
1- Keras pre-trained model。
2- 输入 x 作为图像或图像集。图像的分辨率应与输入层的尺寸兼容。例如 80*80*3 用于 3 通道 (RGB) 图像。
3- 获得激活的输出名称layer。例如，"flatten_2"层。这应该包含在 layer_names 变量中，表示给定 model.
的图层名称
4- batch_size 是可选参数。
然后你可以很容易地使用get_activation函数来激活输出layer给定输入x和pre-trainedmodel:
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
基于这个线程的所有好的答案，我写了一个库来获取每一层的输出。它抽象了所有的复杂性，并被设计为尽可能user-friendly：
https://github.com/philipperemy/keract
它处理几乎所有的边缘情况。
希望对您有所帮助！
如果您有以下情况之一：
- 错误：
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]
此答案基于：
要打印单层的输出：
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)
以前的解决方案对我不起作用。我按如下所示处理了这个问题。
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)
我已经用 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 一样获取每一层的输出，我该怎么做？
您可以使用以下方法轻松获取任何层的输出：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 作为 layer_outs 中的 1. 否则使用 0.
编辑：（基于评论）
K.function 创建 theano/tensorflow 张量函数，稍后用于在给定输入的情况下从符号图中获取输出。
现在需要 K.learning_phase() 作为输入，因为像 Dropout/Batchnomalization 这样的许多 Keras 层都依赖它来改变训练和测试期间的行为。
因此，如果您删除代码中的 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内存并且还需要为较低层进行张量计算over-n-over。
相反，这是一种更好的方法，因为您不需要多个函数，只需一个函数即可为您提供所有输出的列表：
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
我为自己（在 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')
好吧，其他答案很完整，但是有一个非常基本的方法 "see"，而不是 "get" 形状。
就做一个model.summary()。它将打印所有图层及其输出形状。 "None" 值将指示可变维度，第一个维度将是批量大小。
以下在我看来很简单：
model.layers[idx].output
以上是一个张量对象，因此您可以使用可应用于张量对象的操作对其进行修改。
例如得到形状model.layers[idx].output.get_shape()
idx是图层的索引，可以从model.summary()
来自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 函数，该函数将 return 给定特定输入的特定层的输出，例如：
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]
发件人：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
想将此作为评论（但没有足够高的代表）添加到@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:]] 之类的尝试没有奏效。
假设您有：
1- Keras pre-trained model。
2- 输入 x 作为图像或图像集。图像的分辨率应与输入层的尺寸兼容。例如 80*80*3 用于 3 通道 (RGB) 图像。
3- 获得激活的输出名称layer。例如，"flatten_2"层。这应该包含在 layer_names 变量中，表示给定 model.
4- batch_size 是可选参数。
然后你可以很容易地使用get_activation函数来激活输出layer给定输入x和pre-trainedmodel:
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
基于这个线程的所有好的答案，我写了一个库来获取每一层的输出。它抽象了所有的复杂性，并被设计为尽可能user-friendly：
https://github.com/philipperemy/keract
它处理几乎所有的边缘情况。
希望对您有所帮助！
如果您有以下情况之一：
- 错误：
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]
此答案基于：
要打印单层的输出：
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)
以前的解决方案对我不起作用。我按如下所示处理了这个问题。
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)