プログラム内で作成した画像を入力した時に”Error when checking input”と出てしまいます

Question

前提・実現したいこと

こちらのブログを参考にし、VGGFaceというものに画像のどの部分を見ているかをヒートマップで表すGradCAMを実装しました。
これにMTCNNという画像の顔部分を抽出するものを実装し、適当な画像を入れた時に顔部分を抽出した画像を入力としてとしてヒートマップを出力しようとしましたがうまくいきません。
また、上記とは関係ないのですがコマンドライン引数を用いて入力した画像のファイル名を元に顔を抽出した画像を保存したいのですがどのように改善すればよいでしょうか。

発生している問題・エラーメッセージ

File "vggface-gradcam+mtcnn.py", line 200, in <module>
    predictions = model.predict(preprocessed_input)
  File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/keras/engine/training.py", line 1149, in predict
    x, _, _ = self._standardize_user_data(x)
  File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/keras/engine/training.py", line 751, in _standardize_user_data
    exception_prefix='input')
  File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/keras/engine/training_utils.py", line 128, in standardize_input_data
    'with shape ' + str(data_shape))
ValueError: Error when checking input: expected input_1 to have 4 dimensions, but got array with shape (224, 224, 3)

該当のソースコード

どの部分を修正するべきかわからないので長いのですが以下がコードになります。

def extract_face(filename, required_size=(224, 224)):
	# load image from file
	pixels = pyplot.imread(filename)
	# create the detector, using default weights
	detector = MTCNN()
	# detect faces in the image
	results = detector.detect_faces(pixels)
	# extract the bounding box from the first face
	x1, y1, width, height = results[0]['box']
	x2, y2 = x1 + width, y1 + height
	# extract the face
	face = pixels[y1:y2, x1:x2]
	# resize pixels to the model size
	image = Image.fromarray(face)
	image = image.resize(required_size)
	face_array = asarray(image)
	return face_array

# load the photo and extract the face
pixels = extract_face(sys.argv[1])
img = Image.fromarray(pixels, 'RGB')
img.save('1.jpg')
#img.show()

def target_category_loss(x, category_index, nb_classes):
    return tf.multiply(x, K.one_hot([category_index], nb_classes))

def target_category_loss_output_shape(input_shape):
    return input_shape

def normalize(x):
    # utility function to normalize a tensor by its L2 norm
    return x / (K.sqrt(K.mean(K.square(x))) + 1e-5)
'''
def load_image(path):
    img_path = sys.argv[1]
    img = image.load_img(img_path, target_size=(224,224))  #299,299))  #224, 224)
    x = image.img_to_array(img)
    x = np.expand_dims(x, axis=0)
    x = preprocess_input(x)
    return x
'''
def register_gradient():
    if "GuidedBackProp" not in ops._gradient_registry._registry:
        @ops.RegisterGradient("GuidedBackProp")
        def _GuidedBackProp(op, grad):
            dtype = op.inputs[0].dtype
            return grad * tf.cast(grad > 0., dtype) * \
                tf.cast(op.inputs[0] > 0., dtype)

def compile_saliency_function(model, activation_layer='conv5_3'): #mixed10 'activation_49' add_16 add_32 activation_98
    input_img = model.input
    layer_dict = dict([(layer.name, layer) for layer in model.layers[1:]])
    #print(layer_dict)
    layer_output = layer_dict[activation_layer].output
    max_output = K.max(layer_output, axis=3)
    saliency = K.gradients(K.sum(max_output), input_img)[0]
    return K.function([input_img, K.learning_phase()], [saliency])

def modify_backprop(model, name):
    g = tf.get_default_graph()
    with g.gradient_override_map({'Relu': name}):

        # get layers that have an activation
        layer_dict = [layer for layer in model.layers[1:]
                      if hasattr(layer, 'activation')]

        # replace relu activation
        for layer in layer_dict:
            if layer.activation == keras.activations.relu:
                layer.activation = tf.nn.relu

        # re-instanciate a new model
        new_model = VGGFace(weights='vggface')
        #new_model = ResNet50(weights='imagenet')
        new_model.summary()
    return new_model

def deprocess_image(x):
    '''
    Same normalization as in:
    https://github.com/fchollet/keras/blob/master/examples/conv_filter_visualization.py
    '''
    if np.ndim(x) > 3:
        x = np.squeeze(x)
    # normalize tensor: center on 0., ensure std is 0.1
    x -= x.mean()
    x /= (x.std() + 1e-5)
    x *= 0.1

    # clip to [0, 1]
    x += 0.5
    x = np.clip(x, 0, 1)

    # convert to RGB array
    x *= 255
    if K.image_dim_ordering() == 'th':
        x = x.transpose((1, 2, 0))
    x = np.clip(x, 0, 255).astype('uint8')
    return x

def _compute_gradients(tensor, var_list):
    grads = tf.gradients(tensor, var_list)
    return [grad if grad is not None else tf.zeros_like(var) for var, grad in zip(var_list, grads)]

def grad_cam(input_model, image, category_index, layer_name):
    nb_classes = 2622
    target_layer = lambda x: target_category_loss(x, category_index, nb_classes)
    x = Lambda(target_layer, output_shape = target_category_loss_output_shape)(input_model.output)
    model = Model(inputs=input_model.input, outputs=x)
    #model.summary()
    loss = K.sum(model.output)
    conv_output =  [l for l in model.layers if l.name == layer_name][0].output  #is
    grads = normalize(_compute_gradients(loss, [conv_output])[0])
    gradient_function = K.function([model.input], [conv_output, grads])

    output, grads_val = gradient_function([image])
    output, grads_val = output[0, :], grads_val[0, :, :, :]

    weights = np.mean(grads_val, axis = (0, 1))
    cam = np.zeros(output.shape[0 : 2], dtype = np.float32)

    for i, w in enumerate(weights):
        cam += w * output[:, :, i]

    cam = cv2.resize(cam, (224,224))
    cam = np.maximum(cam, 0)
    #heatmap = cam / np.max(cam)
    heatmap = (cam - np.min(cam))/(np.max(cam) - np.min(cam))

    #Return to BGR [0..255] from the preprocessed image
    image = image[0, :]
    image -= np.min(image)
    image = np.minimum(image, 255)

    cam = cv2.applyColorMap(np.uint8(255*heatmap), cv2.COLORMAP_JET)
    cam = np.float32(cam) + np.float32(image)
    cam = 255 * cam / np.max(cam)
    return np.uint8(cam), heatmap

preprocessed_input = extract_face(sys.argv[1]) #if tmp[1:] else '',
model =  VGGFace()
target_layer = 'conv5_3' #'activation_49' add_16 "block5_conv3"
predictions = model.predict(preprocessed_input)
register_gradient()
guided_model = modify_backprop(model, 'GuidedBackProp')
guided_model.summary()
for i in range(5):
    top_1 = decode_predictions(predictions)[0][i]
    print('label番号',predictions.argsort()[0][::-1][i])
    print('%s (%s) with probability %.2f',(top_1))
    predicted_class = predictions.argsort()[0][::-1][i]
    cam, heatmap = grad_cam(model, preprocessed_input, predicted_class, target_layer)
    cv2.imwrite(str(i)+"gradcam"+str(predictions.argsort()[0][::-1][i])+".jpg", cam)
    saliency_fn = compile_saliency_function(guided_model)
    saliency = saliency_fn([preprocessed_input, 0])
    gradcam = saliency[0] * heatmap[..., np.newaxis]
    cv2.imwrite(str(i)+"guided"+str(predictions.argsort()[0][::-1][i])+".jpg", deprocess_image(gradcam))

顔を抽出した画像を保存する

pixels = extract_face(sys.argv[1])
img = Image.fromarray(pixels, 'RGB')
img.save('1.jpg')

文が変かもしれませんがよろしくお願いします。

Comments

[meg_]

リンクは「リンクの挿入」で記入しましょう。

[meg_]

コマンドライン引数には何を指定しましたか？　参考にされたサイトでは「PNG」ファイルを指定しているようですが質問者さんもPNGファイルでしたか？

[satoUmino]

お返事が遅くなりすみません
ファイルは参考にしたサイトのプログラムを"PNG"を”JPG”に変更しても動作したためJPGを使用しました。
また、上記に乗せているプログラムを”PNG”で動作させても同じエラーが出ました。

Answer 1

質問のコードは下記サイトのコピペでしょうか？
How to Perform Face Recognition With VGGFace2 in Keras

であれば、下記の辺りが抜けているのではないでしょうか？

from keras_vggface.utils import preprocess_input

# load the photo and extract the face
pixels = extract_face('sharon_stone1.jpg')
# convert one face into samples
pixels = pixels.astype('float32')
samples = expand_dims(pixels, axis=0)
# prepare the face for the model, e.g. center pixels
samples = preprocess_input(samples, version=2)

Comments

[satoUmino]

回答ありがとうございます。
サイトの方参考にしコードを追加しました。
回答のコードをつけたしてみましたが、エラーは解決されませんでした。

Answer 2

エラーが発生した行番号まで記載いただいたほうが回答が得やすいと思います。 NHWC あるいは NCHW の N (バッチサイズ) の部分が足りていないのではないかと思いますが、エラーの箇所を特定するのが回答者側の視点ではかなり難易度が高いですし時間がかかります。
NHWCの意味

エラー箇所の直前で配列の先頭に次元をひとつ追加することで解決するかもしれません。

b = a[np.newaxis, :, :, :]

エラーの箇所がわからないため、ほぼ勘です。

Comments

[satoUmino]

回答ありがとうございます。
エラー文の箇所を訂正しましたの再度見てもらえたら幸いです。