Keras, como obter a saída de cada camada?

155

Treinei um modelo de classificação binária com a CNN, e aqui está o meu código

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

E aqui, eu quero obter a saída de cada camada como o TensorFlow, como posso fazer isso?

Indo à minha maneira
fonte

Respostas:

182

Você pode obter facilmente as saídas de qualquer camada usando: model.layers[index].output

Para todas as camadas, use o seguinte:

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

Nota: Para simular o Dropout, use learning_phasecomo 1.de layer_outsoutra forma0.

Editar: (com base nos comentários)

K.function cria as funções tensor de fluxo de tensão / fluxo de tensão que são usadas posteriormente para obter a saída do gráfico simbólico, conforme a entrada.

Agora K.learning_phase()é necessário como entrada, pois muitas camadas Keras, como Dropout / Batchnomalization, dependem dela para alterar o comportamento durante o treinamento e o tempo de teste.

Portanto, se você remover a camada dropout no seu código, poderá simplesmente usar:

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

Edição 2: mais otimizado

Acabei de perceber que a resposta anterior não é tão otimizada quanto a cada avaliação de função, os dados serão transferidos para CPU-> GPU de memória e também os cálculos de tensor precisam ser feitos para as camadas inferiores repetidas vezes.

Em vez disso, é uma maneira muito melhor, pois você não precisa de várias funções, mas de uma única função, fornecendo a lista de todas as saídas:

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
fonte
2
senhor, sua resposta é boa, o que K.function([inp]+ [K.learning_phase()], [out])significa no seu código?
GoingMyWay 18/01/19
Excelente resposta, np.random.random(input_shape)[np.newaxis,...]também pode ser escrito comonp.random.random(input_shape)[np.newaxis,:]
Tom
O que é o K.function? como passou para GPU (MPI?)? o que há nos bastidores? Como são as negociações com a CUDA? onde está o código fonte?
precisa saber é o seguinte
3
O @StavBodik Model cria a função de previsão usando K.function aqui e a previsão usa-a no loop de previsão aqui . Preveja loops sobre o tamanho do lote (se não definido, o padrão será 32), mas isso atenua as restrições na memória da GPU. Então, eu não sei por que você está observando model.predicté mais rápido.
Indraforyou
1
Estou recebendo o seguinte: InvalidArgumentError: S_input_39: 0 é alimentado e buscado. ... alguém com idéias?
mathtick
137

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

Uma maneira simples é criar um novo modelo que produza as camadas nas quais você está interessado:

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)

Como alternativa, você pode criar uma função Keras que retornará a saída de uma determinada camada, dada uma determinada entrada, por exemplo:

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]
céu azul
fonte
se eu pudesse, daria a vocês dois ^, dessa maneira é muuuito mais conveniente quando você tem várias entradas.
Dan Erez
Está bem claro no seu código acima, mas apenas para verificar meu entendimento: depois de criar um modelo a partir de um modelo existente (supondo que ele já esteja treinado), não há necessidade de chamar set_weights no novo modelo. Isso está correto?
JZ
qual é a diferença entre layer_output = get_3rd_layer_output([X, 0])[0]e layer_output = get_3rd_layer_output([X, 1])[0]Os documentos mencionam o modo de trem e o modo de teste
Jason
desculpe, você pode me explicar o que esse modelo faz exatamente? Você tem que treiná-lo também? Não consigo imaginar nenhum diagrama para isso. Você adiciona a camada de entrada de outro modelo, depois adiciona uma camada intermediária aleatória desse outro modelo como saída e alimenta entradas a ele? Por que isso, em vez de alimentar o modelo original e obter acesso direto a qualquer camada intermediária? Por que criar esse modelo extra estranho? E isso não afetará a saída? ele não tenta aprender ou requer treinamento, ou a camada traz seus próprios pesos pré-treinados a partir do modelo original?
PedroD 9/09/19
19

Com base em todas as boas respostas deste tópico, escrevi uma biblioteca para buscar a saída de cada camada. Ele abstrai toda a complexidade e foi projetado para ser o mais amigável possível:

https://github.com/philipperemy/keract

Ele lida com quase todos os casos extremos

Espero que ajude!

Philippe Remy
fonte
8

A seguir parece muito simples para mim:

model.layers[idx].output

Acima, há um objeto tensor, para que você possa modificá-lo usando operações que podem ser aplicadas a um objeto tensor.

Por exemplo, para obter a forma model.layers[idx].output.get_shape()

idx é o índice da camada e você pode encontrá-lo em model.summary()

diabo nos detalhes
fonte
1
O que há de errado com esta resposta? Por que isso não é votado como a melhor resposta?
Black Jack 21
1
Ele retorna um objeto tensor, não um quadro de dados. É estranho trabalhar com objetos.
HashRocketSyntax
7

Eu escrevi essa função para mim (em Jupyter) e foi inspirada na resposta de indraforyou . Ele plotará todas as saídas da camada automaticamente. Suas imagens devem ter um formato (x, y, 1) em que 1 representa 1 canal. Você acabou de chamar plot_layer_outputs (...) para plotar.

%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
fonte
E se o modelo tiver várias entradas? Como você especifica as entradas?
Antonio Sesto
Nesta linha: layer_outputs_list = [op ([test_image, 1.]). 1. precisa ser 0? Parece 1 significa treinamento e 0 significa teste? Não é é?
Kongsea
Isso não está funcionando para mim. Eu usei uma imagem colorida e está me dando um erro: InvalidArgumentError: input_2: 0 é alimentado e buscado.
Vaibhav K
5

De: 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
cannin
fonte
O link está obsoleto.
Saeed
5

Queria adicionar isso como um comentário (mas não possui representante suficiente) à resposta de @ indraforyou para corrigir o problema mencionado no comentário de @ mathtick. Para evitar a InvalidArgumentError: input_X:Y is both fed and fetched.exceção, basta substituir a linha outputs = [layer.output for layer in model.layers]com outputs = [layer.output for layer in model.layers][1:], ou seja,

adaptando o exemplo de trabalho mínimo da 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 minhas tentativas tentando coisas como outputs = [layer.output for layer in model.layers[1:]]não funcionou.

KamKam
fonte
1
isso não é exatamente correto. Isso é apenas se a camada de entrada for a primeira definida.
Mpizos Dimitris 02/10/19
Obrigado, isso funcionou para mim e eu só quero verificar o porquê, com base no comentário de Mpizos: meu modelo tem apenas 3 camadas (incorporação de palavras - BiLSTM - CRF), então acho que tive que excluir a camada [0], pois é apenas casamentos e não deve ter uma ativação, certo?
KMunro
@MpizosDimitris sim, isso está correto, mas no exemplo fornecido por @indraforyou (que eu estava alterando), esse foi o caso. @KMunro Se estou entendendo corretamente, o motivo pelo qual você não se importa com a saída da primeira camada é porque é simplesmente a saída da palavra incorporação que é apenas a palavra incorporada em forma de tensor (que é apenas a entrada na parte "rede" do seu kerasmodelo). Sua camada de incorporação de palavras é equivalente à camada de entrada no exemplo fornecido aqui.
KamKam
3

Supondo que você tenha:

1- Keras pré-treinado model.

2- Insira xcomo imagem ou conjunto de imagens. A resolução da imagem deve ser compatível com a dimensão da camada de entrada. Por exemplo 80 * 80 * 3 para imagem de 3 canais (RGB).

3- O nome da saída layerpara obter a ativação. Por exemplo, camada "flatten_2". Isso deve ser incluído na layer_namesvariável, representa o nome das camadas do dado model.

4- batch_sizeé um argumento opcional.

Em seguida, você pode usar facilmente a get_activationfunção para obter a ativação da saída layerpara uma determinada entrada xe pré-treinada 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
imanzabet
fonte
2

Caso você tenha um dos seguintes casos:

  • erro: InvalidArgumentError: input_X:Y is both fed and fetched
  • caso de múltiplas entradas

Você precisa fazer as seguintes alterações:

  • adicione filtro para as camadas de entrada na outputsvariável
  • mudança mínima no functorsloop

Exemplo mínimo:

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]
Mpizos Dimitris
fonte
O que se entende por [x1, x2, xn, 1]? Meu x1 não está definido e eu gostaria de entender o que você está definindo lá.
HashRocketSyntax
@HashRocketSyntax x1e x2são as entradas do modelo. Como foi dito, você tem 2 entradas no seu modelo.
Mpizos Dimitris 14/10/19
1

Bem, outras respostas são muito completas, mas há uma maneira muito básica de "ver", não de "obter" as formas.

Apenas faça um model.summary(). Ele imprimirá todas as camadas e suas formas de saída. Os valores "Nenhum" indicarão dimensões variáveis ​​e a primeira dimensão será o tamanho do lote.

Daniel Möller
fonte
Trata-se da saída da camada (dados fornecidos para a camada base) e não da camada.
mathtick