programing

Keras, 각 레이어의 출력을 취득하려면 어떻게 해야 합니까?

newsource 2022. 9. 27. 23:56

Keras, 각 레이어의 출력을 취득하려면 어떻게 해야 합니까?

CNN과 함께 2진수 분류 모델을 훈련했고, 여기 내 코드가 있다.

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

여기서 Tensor Flow와 같이 각 레이어의 출력을 얻고 싶은데 어떻게 하면 될까요?

다음을 사용하면 모든 계층의 출력을 쉽게 얻을 수 있습니다.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는 나중에 입력이 주어진 심볼 그래프에서 출력을 가져오는 데 사용되는 테아노/트랜스플로 텐서 함수를 생성합니다.

지금이다K.learning_phase()Dropout/Batchonomalization과 같은 많은 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 메모리 전송되고 하위 계층에 대한 텐서 계산도 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

https://keras.io/getting-started/faq/ 에서 #how-can-i-display-of-an-state-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]

이 스레드의 모든 좋은 답변을 바탕으로 각 레이어의 출력을 가져오기 위해 라이브러리를 작성했습니다.모든 복잡성을 추상화하고 가능한 한 사용하기 쉽게 설계되어 있습니다.

https://github.com/philipperemy/keract

거의 모든 엣지 케이스를 처리합니다.

도움이 됐으면 좋겠다!

다음은 매우 간단해 보입니다.

model.layers[idx].output

위는 텐서 객체이므로 텐서 객체에 적용할 수 있는 연산을 사용하여 수정할 수 있습니다.

예를 들어, 모양을 가져오려면model.layers[idx].output.get_shape()

idx레이어 인덱스입니다.model.summary()

이 답변은 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)

이 함수는 (주피터로) 제가 직접 썼는데, 인드라포리오우의 답변에서 영감을 받았습니다.모든 레이어 출력을 자동으로 플롯합니다.이미지는 (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')

송신원: 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

이전의 솔루션은 나에게 효과가 없었다.저는 이 문제를 아래와 같이 처리했습니다.

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)

@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:]]동작하지 않았다.

다음을 전제로 합니다.

- 훈련1 - Keras 。model

2-입력x이미지 또는 이미지 세트로 표시됩니다.이미지의 해상도는 입력 레이어의 치수와 호환성이 있어야 합니다.를 들어 3채널(RGB) 이미지의 경우 80*80*3 입니다.

출력명- 출력명- 출력명layer활성화 시킬게요.평탄하다은 '아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아,layer_namesvariable은 , 레이어 을 나타냅니다.model.

batch_size는 옵션 인수입니다.

쓸 수 요.get_activationlayer의 입력에 , 「」를 참조해 주세요.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

다음의 몇개의 케이스가 있는 경우:

  • "Displays: "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]

음, 다른 답은 매우 완벽하지만, 모양을 "얻는" 방법이 아니라 "보는" 매우 기본적인 방법이 있습니다.

ㅇㅇㅇㅇㅇ로 요.model.summary()입니다."없음" 값은 가변 치수를 나타내며 첫 번째 치수는 배치 크기입니다.

언급URL : https://stackoverflow.com/questions/41711190/keras-how-to-get-the-output-of-each-layer