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 같은 각 층의 출력을 얻을 싶어 내 코드는 내가 그렇게 할 수있는 방법인가?

Answer 1

쉽게 사용하여 모든 레이어의 출력을 얻을 수 있습니다 :

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 

참고 : 모든 레이어에 대한 model.layers[index].output

이를 사용 layer_outs에 1.로 드롭 아웃 사용 learning_phase을 시뮬레이션하기 위해, 그렇지 않으면 사용 0.

편집 : (의견 기반)

K.function은 theano/tensorflow tensor 함수를 만듭니다.이 함수는 나중에 입력이 주어진 심볼 그래프에서 출력을 가져 오는 데 사용됩니다.

지금은 누락/Batchnomalization과 같은 많은 Keras 레이어가 교육 및 테스트 시간 동안 동작을 변경하는 데 의존하므로 입력으로가 필요합니다. 당신이 당신의 코드에서 드롭 아웃 층을 제거하면

그래서 당신은 간단하게 사용할 수 있습니다

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 

Answer 2

내가 (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') 

Answer 3

다른 답변은 매우 완전하지만 형태를 "얻지"않는 "보는"매우 기본적인 방법이 있습니다.

그냥 model.summary()하십시오. 모든 레이어와 출력 모양을 인쇄합니다. 나에게 매우 간단한

Answer 4

다음과 같습니다 당신이 텐서 객체에 적용 할 수있는 작업을 사용하여 수정할 수 있도록

model.layers[idx].output 

은 위, 텐서 개체입니다.

예를 들어, 레이어의 인덱스를 모양 model.layers[idx].output.get_shape()

idx입니다 얻을 당신은 https://keras.io/getting-started/faq/#how-can-i-obtain-the-output-of-an-intermediate-layer에서 model.summary()

Answer 5

에서 찾을 수 있습니다 :

One simple way is to create a new Model that will output the layers that you are interested in: 

from keras.models import Model 

model = ... # create the 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) 
Alternatively, you can build a Keras function that will return the output of a certain layer given a certain input, for example: 

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] 

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