def att(alpha=0,
beta=0,
activation=activ,
use_bias=False,
latent_dim=0,
epochs=5,
batch_size=711240):
# recall@k
rec_k_list = [1, 5, 30, 150]
# load training dataset
# x_train0 = np.load(train_pho0)
# x_train1 = np.load(train_pho1)
# x_train_doc = np.load(train_doc)
# y_train = np.load(train_y) # label file
#
# # load testing dataset
# x_test_doc = np.load(test_doc)
# x_test0 = np.load(test_pho0) # feature file
# x_test1 = np.load(test_pho1)
# Model
x_doc = Input(shape=(doc_dim, ))
x_0 = Input(shape=(pho_dim, ))
x_1 = Input(shape=(pho_dim, ))
x_pho, _ = get_weighted([x_0, x_1], pho_dim)
# x_doc_encoder = Dense(units=doc_dim, activation=activation, use_bias=use_bias)(x_doc)
# x_pho_encoder = Dense(units=pho_dim, activation=activation, use_bias=use_bias)(x_pho)
encoder, _ = get_weighted([x_doc, x_pho], pho_dim)
encoder = Dense(units=latent_dim, activation=activation,
use_bias=use_bias)(encoder)
sig = Dense(1, activation='sigmoid', use_bias=use_bias)(encoder)
con = Model(outputs=sig, inputs=[x_doc, x_0, x_1])
print('=======Model Information=======' + '\n')
con.summary()
con.compile(optimizer=optim, loss='binary_crossentropy')
con.fit([x_train_doc, x_train0, x_train1],
y_train,
shuffle=False,
epochs=epochs,
batch_size=batch_size,
verbose=0)
rank = con.predict([x_test_doc, x_test0, x_test1])
rank = rank.reshape(test_num, 300)
rank_list = GR.get_rank_matrix(rank)
result = GR.get_result_by_ranks(rank_list, rec_k_list)
print('=======Attention Result=======' + '\n')
K.clear_session()
return result, con
def rhyme2vec(alpha=0,
beta=0,
activation=activ,
use_bias=False,
latent_dim=100,
epochs=5,
batch_size=200000):
# recall@k
rec_k_list = [1, 5, 30, 150]
# the input dimension
input_shape = pho_dim
# x_train0 = np.load(train_pho0)
# x_train1 = np.load(train_pho1)
# y_train = np.load(train_y) # label file
#
# # load testing dataset
# x_test0 = np.load(test_pho0) # feature file
# x_test1 = np.load(test_pho1)
print('====load dataset done====' + '\n')
x_0 = Input(shape=(input_shape, ))
x_1 = Input(shape=(input_shape, ))
x, att = get_weighted([x_0, x_1], pho_dim)
x = Dense(units=latent_dim, activation=activation, use_bias=use_bias)(x)
sig = Dense(1, activation='sigmoid', use_bias=use_bias)(x)
rhyme = Model(outputs=sig, inputs=[x_0, x_1])
print('=======Model Information=======' + '\n')
# rhyme.summary()
rhyme.compile(optimizer=optim, loss='binary_crossentropy')
rhyme.fit([x_train0, x_train1],
y_train,
shuffle=False,
epochs=epochs,
batch_size=batch_size,
verbose=0)
rank = rhyme.predict([x_test0, x_test1])
rank = rank.reshape(test_num, 300)
rank_list = GR.get_rank_matrix(rank)
result = GR.get_result_by_ranks(rank_list, rec_k_list)
print('=======Rhyme2vec Result=======' + '\n')
K.clear_session()
return result, rhyme
def HAVAE(alpha=1.0,
beta=1.0,
activation=activ,
use_bias=True,
epochs=5,
batch_size=1000,
units=200,
latent_dim=100,
epsilon_std=1.0):
# recall@k
rec_k_list = [1, 5, 30, 150]
# Input
x_doc = Input(shape=(doc_dim, ))
x_0 = Input(shape=(pho_dim, ))
x_1 = Input(shape=(pho_dim, ))
x_pho, att = get_weighted([x_0, x_1], pho_dim)
# Attention Model
# x_a = concatenate([x_doc, x_pho])
# attention = Dense(units=doc_dim + pho_dim, activation='sigmoid')(x_a)
# x_r = multiply([x_a, attention])
# x_r = Dense(units=doc_dim + pho_dim, activation='relu')(x_a)
x_r, _ = get_weighted([x_doc, x_pho], pho_dim)
# VAE model
z_mean = Dense(units=latent_dim,
activation=activation,
use_bias=use_bias,
name='output')(x_r)
z_log_var = Dense(units=latent_dim,
activation=activation,
use_bias=use_bias)(x_r)
def sampling_z(args):
_mean, _log_var = args
# print("=========================================\n\n\n")
# print("mean shape: {}".format(K.shape(_mean)))
# print("\n\n\n=========================================")
epsilon = K.random_normal(shape=(K.shape(_mean)[0], latent_dim),
mean=0.,
stddev=epsilon_std)
return _mean + K.exp(_log_var / 2) * epsilon
z = Lambda(sampling_z)([z_mean, z_log_var])
de_mean = Dense(units=doc_dim, activation=activation, use_bias=use_bias)(z)
de_log_var = Dense(units=doc_dim, activation=activation,
use_bias=use_bias)(z)
def sampling_d(args):
_mean, _log_var = args
# print("=========================================\n\n\n")
# print("mean shape: {}".format(K.shape(_mean)))
# print("\n\n\n=========================================")
epsilon = K.random_normal(shape=(K.shape(_mean)[0], doc_dim + pho_dim),
mean=0.,
stddev=epsilon_std)
return _mean + K.exp(_log_var / 2) * epsilon
# decoder = Lambda(sampling_d)([de_mean, de_log_var])
# _attention = Dense(units=doc_dim + pho_dim, activation='sigmoid')(decoder)
# _x_a = multiply([decoder, _attention])
#
# # Output
# _x_doc = Lambda(slice, arguments={'start': 0, 'end': 125})(_x_a)
# _x_pho = Lambda(slice, arguments={'start': 125, 'end': 250})(_x_a)
y = Input(shape=(1, ), name='y_in')
sig = Dense(1, activation='sigmoid', use_bias=use_bias)(z_mean)
# Label loss
def loss(args):
x, y = args
loss = objectives.binary_crossentropy(x, y)
return loss
label_loss = Lambda(loss)([y, sig])
# Vae loss
# x_doc_loss = Lambda(loss)([x_doc, _x_doc])
# x_pho_loss = Lambda(loss)([x_pho, _x_pho])
def vae_loss(args):
zm, zl, dm, dl, xa = args
kl_loss = -0.5 * K.mean(1 + zl - K.square(zm) - K.exp(zl), axis=-1)
pxz = -K.mean(-0.5 * (np.log(2 * np.pi) + dl) -
0.5 * K.square(xa - dm) / K.exp(dl))
# xent_loss = x + y
return kl_loss + pxz
vae_loss = Lambda(vae_loss)([z_mean, z_log_var, de_mean, de_log_var, x_r])
# Custom loss layer
L = CustomVariationalLayer([alpha, beta])([label_loss, vae_loss])
vaerl2 = Model(outputs=L, inputs=[x_doc, x_0, x_1, y])
print('=======Model Information=======' + '\n')
# vaerl2.summary()
vaerl2.compile(optimizer='adadelta', loss=None, metrics=[])
logger = CSVLogger('train.log')
vaerl2.fit([x_train_doc, x_train0, x_train1, y_train],
shuffle=False,
epochs=epochs,
batch_size=batch_size,
verbose=1,
callbacks=[logger])
vaerl2_sig = Model(inputs=[x_doc, x_0, x_1, y],
outputs=[sig, label_loss, vae_loss])
y_test = np.array(([1] + ([0] * 299)) * test_num)
rank = vaerl2_sig.predict([x_test_doc, x_test0, x_test1, y_test])
scores = rank[0].reshape(test_num, 300)
rank_list = GR.get_rank_matrix(scores)
result = GR.get_result_by_ranks(rank_list, rec_k_list)
l_loss = np.mean(scores[1])
v_loss = np.mean(scores[2])
print('=======HAVAE Result=======' + '\n')
# K.clear_session()
return result, vaerl2
def conVAE(alpha,
beta,
activation=activ,
use_bias=True,
epochs=5,
batch_size=100000,
units=200,
latent_dim=100,
epsilon_std=1.0):
# recall@k
rec_k_list = [1, 5, 30, 150]
# load training dataset
# x_train0 = np.load(train_pho0)
# x_train1 = np.load(train_pho1)
# x_train_doc = np.load(train_doc)
# y_train = np.load(train_y) # label file
#
# # load testing dataset
# x_test0 = np.load(test_pho0) # feature file
# x_test1 = np.load(test_pho1)
# x_test_doc = np.load(test_doc)
# VAE Model
x_doc = Input(shape=(doc_dim, ))
x_0 = Input(shape=(pho_dim, ))
x_1 = Input(shape=(pho_dim, ))
x_pho, att = get_weighted([x_0, x_1], pho_dim)
concat = concatenate([x_doc, x_pho])
z_mean = Dense(units=latent_dim, activation=activation,
use_bias=use_bias)(concat)
z_log_var = Dense(units=latent_dim,
activation=activation,
use_bias=use_bias)(concat)
def sampling(args):
_mean, _log_var = args
epsilon = K.random_normal(shape=(K.shape(_mean)[0], K.shape(_mean)[1]),
mean=0.,
stddev=epsilon_std)
return _mean + K.exp(_log_var / 2) * epsilon
z = Lambda(sampling)([z_mean, z_log_var])
de_mean = Dense(units=doc_dim + pho_dim,
activation=activation,
use_bias=use_bias)(z)
de_log_var = Dense(units=doc_dim + pho_dim,
activation=activation,
use_bias=use_bias)(z)
decoder = Lambda(sampling)([de_mean, de_log_var])
# decoder = Dense(units=doc_dim + pho_dim, activation=activation, use_bias=use_bias)(z)
_x_doc = Lambda(slice, arguments={'start': 0, 'end': 125})(decoder)
_x_pho = Lambda(slice, arguments={'start': 125, 'end': 250})(decoder)
y = Input(shape=(1, ))
sig = Dense(1, activation='sigmoid', use_bias=use_bias)(z_mean)
# Label loss
def bi_loss(args):
x, y = args
loss = objectives.mean_squared_error(x, y)
return loss
label_loss = Lambda(bi_loss)([y, sig])
# VAE loss
def vae_loss(args):
zm, zl, dm, dl, c = args
# xent_loss = objectives.binary_crossentropy(xd, _xd) \
# + objectives.binary_crossentropy(xp, _xp)
pxz = -K.mean(-0.5 * (np.log(2 * np.pi) + dl) -
0.5 * K.square(c - dm) / K.exp(dl))
kl_loss = -0.5 * K.mean(1 + zl - K.square(zm) - K.exp(zl), axis=-1)
return kl_loss + pxz
vae_loss = Lambda(vae_loss)(
[z_mean, z_log_var, de_mean, de_log_var, concat])
# Custom loss layer
L = CustomVariationalLayer([alpha, beta])([label_loss, vae_loss])
con_vae = Model(outputs=L, inputs=[x_doc, x_0, x_1, y])
print('=======Model Information=======' + '\n')
# con_vae.summary()
con_vae.compile(optimizer=optim, loss=None)
con_vae.fit([x_train_doc, x_train0, x_train1, y_train],
shuffle=False,
epochs=epochs,
batch_size=batch_size,
verbose=0)
con_vae_sig = Model(inputs=[x_doc, x_0, x_1], outputs=sig)
rank = con_vae_sig.predict([x_test_doc, x_test0, x_test1])
rank = rank.reshape(test_num, 300)
rank_list = GR.get_rank_matrix(rank)
result = GR.get_result_by_ranks(rank_list, rec_k_list)
print('=======conVAE Result=======' + '\n')
K.clear_session()
return result, con_vae
def conAE(alpha,
beta,
activation=activ,
use_bias=False,
latent_dim=100,
epochs=5,
batch_size=100000):
# recall@k
rec_k_list = [1, 5, 30, 150]
# load training dataset
# x_train0 = np.load(train_pho0)
# x_train1 = np.load(train_pho1)
# x_train_doc = np.load(train_doc)
# y_train = np.load(train_y) # label file
#
# # load testing dataset
# x_test0 = np.load(test_pho0) # feature file
# x_test1 = np.load(test_pho1)
# x_test_doc = np.load(test_doc)
# AE Model
x_doc = Input(shape=(doc_dim, ))
x_0 = Input(shape=(pho_dim, ))
x_1 = Input(shape=(pho_dim, ))
x_pho, att = get_weighted([x_0, x_1], pho_dim)
encoder = concatenate([x_doc, x_pho])
answer = Dense(units=latent_dim, activation=activation,
use_bias=use_bias)(encoder)
decoder = Dense(units=doc_dim + pho_dim,
activation=activation,
use_bias=use_bias)(answer)
_x_doc = Lambda(slice, arguments={'start': 0, 'end': 125})(decoder)
_x_pho = Lambda(slice, arguments={'start': 125, 'end': 250})(decoder)
y = Input(shape=(1, ))
sig = Dense(1, activation='sigmoid', use_bias=use_bias)(answer)
def bi_loss(args):
x, y = args
loss = objectives.mean_squared_error(x, y)
return loss
def ae_loss(args):
xd, _xd, xp, _xp = args
return objectives.binary_crossentropy(xd, _xd) \
+ objectives.binary_crossentropy(xp, _xp)
# Label loss
label_loss = Lambda(bi_loss)([y, sig])
# AE loss
sae_loss = Lambda(ae_loss)([x_doc, _x_doc, x_pho, _x_pho])
# Custom loss layer
L = CustomVariationalLayer([alpha, beta])([label_loss, sae_loss])
AE = Model(outputs=L, inputs=[x_doc, x_0, x_1, y])
print('=======Model Information=======' + '\n')
# AE.summary()
AE.compile(optimizer=optim, loss=None)
AE.fit([x_train_doc, x_train0, x_train1, y_train],
shuffle=False,
epochs=epochs,
batch_size=batch_size,
verbose=0)
AE_sig = Model(inputs=[x_doc, x_0, x_1], outputs=sig)
rank = AE_sig.predict([x_test_doc, x_test0, x_test1])
rank = rank.reshape(test_num, 300)
rank_list = GR.get_rank_matrix(rank)
result = GR.get_result_by_ranks(rank_list, rec_k_list)
print('=======conAE Result=======' + '\n')
K.clear_session()
return result, AE
def create_vaerl2(doc_dim=125,
pho_dim=125,
activation='tanh',
use_bias=True,
units=100,
latent_dim=100,
epsilon_std=1.0,
alpha=1.0,
beta=1.0):
x_doc = Input(shape=(doc_dim, ))
x_0 = Input(shape=(pho_dim, ))
x_1 = Input(shape=(pho_dim, ))
x_pho, att = get_weighted([x_0, x_1], pho_dim)
# Attention Model
# x_a = concatenate([x_doc, x_pho])
# attention = Dense(units=doc_dim + pho_dim, activation='sigmoid')(x_a)
# x_r = multiply([x_a, attention])
# x_r = Dense(units=doc_dim + pho_dim, activation='relu')(x_a)
x_r, _ = get_weighted([x_doc, x_pho], pho_dim)
# VAE model
z_mean = Dense(units=latent_dim,
activation=activation,
use_bias=use_bias,
name='output')(x_r)
z_log_var = Dense(units=latent_dim,
activation=activation,
use_bias=use_bias)(x_r)
def sampling_z(args):
_mean, _log_var = args
# print("=========================================\n\n\n")
# print("mean shape: {}".format(K.shape(_mean)))
# print("\n\n\n=========================================")
epsilon = K.random_normal(shape=(K.shape(_mean)[0], latent_dim),
mean=0.,
stddev=epsilon_std)
return _mean + K.exp(_log_var / 2) * epsilon
z = Lambda(sampling_z)([z_mean, z_log_var])
de_mean = Dense(units=doc_dim, activation=activation, use_bias=use_bias)(z)
de_log_var = Dense(units=doc_dim, activation=activation,
use_bias=use_bias)(z)
def sampling_d(args):
_mean, _log_var = args
# print("=========================================\n\n\n")
# print("mean shape: {}".format(K.shape(_mean)))
# print("\n\n\n=========================================")
epsilon = K.random_normal(shape=(K.shape(_mean)[0], doc_dim + pho_dim),
mean=0.,
stddev=epsilon_std)
return _mean + K.exp(_log_var / 2) * epsilon
# decoder = Lambda(sampling_d)([de_mean, de_log_var])
# _attention = Dense(units=doc_dim + pho_dim, activation='sigmoid')(decoder)
# _x_a = multiply([decoder, _attention])
#
# # Output
# _x_doc = Lambda(slice, arguments={'start': 0, 'end': 125})(_x_a)
# _x_pho = Lambda(slice, arguments={'start': 125, 'end': 250})(_x_a)
y = Input(shape=(1, ), name='y_in')
sig = Dense(1, activation='sigmoid', use_bias=use_bias)(z_mean)
# Label loss
def loss(args):
x, y = args
loss = objectives.binary_crossentropy(x, y)
return loss
label_loss = Lambda(loss)([y, sig])
# Vae loss
# x_doc_loss = Lambda(loss)([x_doc, _x_doc])
# x_pho_loss = Lambda(loss)([x_pho, _x_pho])
def vae_loss(args):
zm, zl, dm, dl, xa = args
kl_loss = -0.5 * K.mean(1 + zl - K.square(zm) - K.exp(zl), axis=-1)
pxz = -K.mean(-0.5 * (np.log(2 * np.pi) + dl) -
0.5 * K.square(xa - dm) / K.exp(dl))
# xent_loss = x + y
return kl_loss + pxz
vae_loss = Lambda(vae_loss)([z_mean, z_log_var, de_mean, de_log_var, x_r])
# Custom loss layer
L = CustomVariationalLayer([alpha, beta])([label_loss, vae_loss])
vaerl2 = Model(outputs=L, inputs=[x_doc, x_0, x_1, y])
print('=======Model Information=======' + '\n')
# vaerl2.summary()
vaerl2.load_weights(weights_fname)
vaerl2_sig = Model(inputs=[x_doc, x_0, x_1], outputs=sig)
return vaerl2_sig