KerasでTypeErrorが出てしまいます。

Question

###前提・実現したいこと
KerasでRecognizing Textual Entailmentという問題をとこうと思い、以下のサイトを参考にコードを書いてみましたが、うまくいきません。
LSTMとAttentionを組み合わせようとしているのですが、TypeErrorが出てしまいます。

###参考にしたサイト
Recognizing Textual EntailmentをLSTMで解く
keras-attention-mechanism

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

TypeError: 'Tensor' object is not callable

###該当のソースコード

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import numpy as np
import pandas as pd

import keras.backend as K

from keras.preprocessing.text import Tokenizer
from keras.preprocessing import sequence

from keras.layers.core import *
from keras.layers.recurrent import LSTM

from keras.models import Sequential, Model
from keras.layers import Input, Dense, Embedding, Dropout, LSTM
from keras.layers.normalization import BatchNormalization
from keras.layers.advanced_activations import PReLU
from keras.layers import merge
from keras.utils import np_utils

from keras.callbacks import TensorBoard
from keras.callbacks import EarlyStopping, ModelCheckpoint

from gensim.models import KeyedVectors

np.random.seed(6162)

# =====data preprocess=====
train_df = pd.read_csv("SNLI/snli_1.0/snli_1.0_train.txt", sep="\t", header=0)
dev_df = pd.read_csv("SNLI/snli_1.0/snli_1.0_dev.txt", sep="\t", header=0)
test_df = pd.read_csv("SNLI/snli_1.0/snli_1.0_test.txt", sep="\t", header=0)

# rm y label "-" line and fillna
train_df = train_df[train_df["gold_label"] != "-"].fillna("")
dev_df = dev_df[dev_df["gold_label"] != "-"].fillna("")
test_df = test_df[test_df["gold_label"] != "-"].fillna("")

tokenizer = Tokenizer()
tokenizer.fit_on_texts(train_df["sentence1"])
tokenizer.fit_on_texts(train_df["sentence2"])
tokenizer.fit_on_texts(dev_df["sentence1"])
tokenizer.fit_on_texts(dev_df["sentence2"])
tokenizer.fit_on_texts(test_df["sentence1"])
tokenizer.fit_on_texts(test_df["sentence2"])

seq_train1 = tokenizer.texts_to_sequences(train_df["sentence1"])
seq_train2 = tokenizer.texts_to_sequences(train_df["sentence2"])
seq_dev1 = tokenizer.texts_to_sequences(dev_df["sentence1"])
seq_dev2 = tokenizer.texts_to_sequences(dev_df["sentence2"])
seq_test1 = tokenizer.texts_to_sequences(test_df["sentence1"])
seq_test2 = tokenizer.texts_to_sequences(test_df["sentence2"])

maxlen = 78

X_train1 = sequence.pad_sequences(seq_train1, maxlen=maxlen)
X_train2 = sequence.pad_sequences(seq_train2, maxlen=maxlen)
X_train = [X_train1, X_train2]

y_label = {"contradiction":0, "entailment":1, "neutral":2}
y_train = [y_label[i] for i in train_df["gold_label"]]
y_train = np_utils.to_categorical(y_train, 3)

X_dev1 = sequence.pad_sequences(seq_dev1, maxlen=maxlen)
X_dev2 = sequence.pad_sequences(seq_dev2, maxlen=maxlen)
X_dev = [X_dev1, X_dev2]

y_dev = [y_label[i] for i in dev_df["gold_label"]]
y_dev = np_utils.to_categorical(y_dev, 3)

X_test1 = sequence.pad_sequences(seq_test1, maxlen=maxlen)
X_test2 = sequence.pad_sequences(seq_test2, maxlen=maxlen)
X_test = [X_test1, X_test2]

y_test = [y_label[i] for i in test_df["gold_label"]]
y_test = np_utils.to_categorical(y_test, 3)


# =====preapare embedding matrix=====
word_index = tokenizer.word_index
num_words = len(word_index)

embeddings_index = {}
with open("/SNLI/glove.840B.300d.txt") as f:
    for line in f:
        values = line.split()
        word = values[0]
        coefs = np.asarray(values[1:], dtype="float32")
        embeddings_index[word] = coefs


embedding_matrix = np.zeros((len(word_index) + 1, 200))
for word, i in word_index.items():
    embedding_vector = embeddings_index.get(word)
    if embedding_vector is not None:
        # words not found in embedding index will be all-zeros.
        embedding_matrix[i] = embedding_vector


# =====LSTM model=====
batch_size = 512
nb_epochs = 50
lstm_dim = 200
embedding_dim = 200
max_features = 1000

input1 = Input(shape=(batch_size,))
embed1 = Embedding(num_words + 1,
                   embedding_dim,
                   weights=[embedding_matrix],
                   trainable=False)(input1)
model1 = LSTM(embedding_dim, recurrent_dropout=0.5, dropout=0.5)(embed1)

input2 = Input(shape=(batch_size,))
embed2 = Embedding(num_words + 1,
                   embedding_dim,
                   weights=[embedding_matrix],
                   trainable=False)(input2)
model2 = LSTM(embedding_dim, recurrent_dropout=0.5, dropout=0.5)(embed2)

#--attention--
INPUT_DIM = 2
TIME_STEPS = 20

def attention_3d_block(inputs):
    # inputs.shape = (batch_size, time_steps, input_dim)
    input_dim = int(inputs.shape[2])
    a = Permute((2, 1))(inputs)
    a = Reshape((input_dim, TIME_STEPS))(a) # this line is not useful. It's just to know which dimension is what.
    a = Dense(TIME_STEPS, activation='softmax')(a)
    a_probs = Permute((2, 1), name='attention_vec')(a)
    output_attention_mul = merge([inputs, a_probs], name='attention_mul', mode='mul')
    return output_attention_mul

inputs = Input(shape=(TIME_STEPS, INPUT_DIM,))
# hidden = merge([model1, model2, K.learning_phase()], name='hidden_layer', mode="concat")(inputs)
hidden = merge([model1, model2], name='hidden_layer', mode="concat")(inputs)
lstm_units = 32
lstm_out = LSTM(lstm_units, return_sequences=True)(hidden)
attention_mul = attention_3d_block(lstm_out)
attention_mul = Flatten()(attention_mul)
output = Dense(1, activation='sigmoid')(attention_mul)
model = Model(input=[inputs], output=output)
#-------------
model.compile(loss="categorical_crossentropy",
              optimizer="adam",
              metrics=["accuracy"]
              )


model.fit(X_train, y_train,
          batch_size=batch_size,
          epochs=nb_epochs,
          validation_data=(X_dev, y_dev),
          shuffle=True,
          )

#--attention--
attention_vectors = []
for i in range(300):
    attention_vector = np.mean(get_activations(m,
                                               X_test,
                                               print_shape_only=True,
                                               layer_name='attention_vec')[0], axis=2).squeeze()
    print('attention =', attention_vector)
    assert (np.sum(attention_vector) - 1.0) < 1e-5
    attention_vectors.append(attention_vector)

attention_vector_final = np.mean(np.array(attention_vectors), axis=0)
#-------------

y_pred = model.predict_classes(X_test, batch_size=batch_size).flatten()
score, acc = model.evaluate(X_test, y_test, batch_size=batch_size)

print()
print("Test score:", score)
print("Test accuracy:", acc)

###試したこと
参考にしたサイトでは、Sequentialモデルを使用していましたが、Functional APIに変更しました。

Answer 1

hidden = merge([model1, model2, K.learning_phase()], name='hidden_layer', mode="concat")(inputs)
のK.learning_phase()がTypeErrorの原因です。

Comments

[退会済みユーザー]

回答ありがとうございます！
K.learning_phase()を削除したところ、
TypeError: 'Tensor' object is not callable
という別のエラーが出てしまいました。
もし原因がわかれば教えていただけたら嬉しいです。
よろしくお願いします。

[mkgrei]

エラーのトレースバックはありませんか。

[退会済みユーザー]

Traceback (most recent call last):
File "snli-LSTM-attention.py", line 179, in <module>
hidden = merge([model1, model2], name='hidden_layer', mode="concat")(inputs)
TypeError: 'Tensor' object is not callable
となっています。

[mkgrei]

正しくは、
hidden = merge([model1, model2, inputs], name='hidden_layer', mode="concat")
だったりしませんか。

[mkgrei]

もしくは、
from keras.layers import Concatenate
hidden = Concatenate()([model1, model2, inputs])
でしょうか。

[退会済みユーザー]

回答ありがとうございます。
from keras.layers import Concatenate
hidden = Concatenate()([model1, model2, inputs])
でいけそうです。
また躓いたら、よろしくお願いします。