def ConvMF(res_dir,
train_user,
train_item,
valid_user,
test_user,
R,
CNN_X,
vocab_size,
init_W=None,
give_item_weight=True,
max_iter=50,
lambda_u=1,
lambda_v=100,
dimension=50,
dropout_rate=0.2,
emb_dim=200,
max_len=300,
num_kernel_per_ws=100):
# explicit setting
a = 1
b = 0
num_user = R.shape[0]
num_item = R.shape[1]
PREV_LOSS = 1e-50
if not os.path.exists(res_dir):
os.makedirs(res_dir)
f1 = open(res_dir + '/state.log', 'w')
Train_R_I = train_user[1]
Train_R_J = train_item[1]
Test_R = test_user[1]
Valid_R = valid_user[1]
if give_item_weight is True:
item_weight = np.array([math.sqrt(len(i)) for i in Train_R_J],
dtype=float)
item_weight = (float(num_item) / item_weight.sum()) * item_weight
else:
item_weight = np.ones(num_item, dtype=float)
pre_val_eval = 1e10
cnn_module = CNN_module(dimension, vocab_size, dropout_rate, emb_dim,
max_len, num_kernel_per_ws, init_W)
theta = cnn_module.get_projection_layer(CNN_X)
np.random.seed(133)
U = np.random.uniform(size=(num_user, dimension))
V = theta
endure_count = 5
count = 0
for iteration in range(max_iter):
loss = 0
tic = time.time()
print("%d iteration\t(patience: %d)" % (iteration, count))
VV = b * (V.T.dot(V)) + lambda_u * np.eye(dimension)
sub_loss = np.zeros(num_user)
for i in range(num_user):
idx_item = train_user[0][i]
V_i = V[idx_item]
R_i = Train_R_I[i]
A = VV + (a - b) * (V_i.T.dot(V_i))
B = (a * V_i * (np.tile(R_i, (dimension, 1)).T)).sum(0)
U[i] = np.linalg.solve(A, B)
sub_loss[i] = -0.5 * lambda_u * np.dot(U[i], U[i])
loss = loss + np.sum(sub_loss)
sub_loss = np.zeros(num_item)
UU = b * (U.T.dot(U))
for j in range(num_item):
idx_user = train_item[0][j]
U_j = U[idx_user]
R_j = Train_R_J[j]
tmp_A = UU + (a - b) * (U_j.T.dot(U_j))
A = tmp_A + lambda_v * item_weight[j] * np.eye(dimension)
B = (a * U_j * (np.tile(R_j, (dimension, 1)).T)
).sum(0) + lambda_v * item_weight[j] * theta[j]
V[j] = np.linalg.solve(A, B)
sub_loss[j] = -0.5 * np.square(R_j * a).sum()
sub_loss[j] = sub_loss[j] + a * np.sum((U_j.dot(V[j])) * R_j)
sub_loss[j] = sub_loss[j] - 0.5 * np.dot(V[j].dot(tmp_A), V[j])
loss = loss + np.sum(sub_loss)
seed = np.random.randint(100000)
history = cnn_module.train(CNN_X, V, item_weight, seed)
theta = cnn_module.get_projection_layer(CNN_X)
cnn_loss = history.history['loss'][-1]
loss = loss - 0.5 * lambda_v * cnn_loss * num_item
tr_eval = eval_RMSE(Train_R_I, U, V, train_user[0])
val_eval = eval_RMSE(Valid_R, U, V, valid_user[0])
te_eval = eval_RMSE(Test_R, U, V, test_user[0])
toc = time.time()
elapsed = toc - tic
converge = abs((loss - PREV_LOSS) / PREV_LOSS)
if (val_eval < pre_val_eval):
cnn_module.save_model(res_dir + '/CNN_weights.hdf5')
np.savetxt(res_dir + '/U.dat', U)
np.savetxt(res_dir + '/V.dat', V)
np.savetxt(res_dir + '/theta.dat', theta)
else:
count = count + 1
pre_val_eval = val_eval
print(
"Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f"
% (loss, elapsed, converge, tr_eval, val_eval, te_eval))
f1.write(
"Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f\n"
% (loss, elapsed, converge, tr_eval, val_eval, te_eval))
if (count == endure_count):
break
PREV_LOSS = loss
f1.close()
def ConvMF(res_dir,
train_user,
train_item,
valid_user,
test_user,
R,
CNN_X,
vocab_size,
if_cuda,
init_W=None,
give_item_weight=True,
max_iter=50,
lambda_u=1,
lambda_v=100,
dimension=50,
dropout_rate=0.2,
emb_dim=200,
max_len=300,
num_kernel_per_ws=100):
# explicit setting
a = 1
b = 0
num_user = R.shape[0]
num_item = R.shape[1]
PREV_LOSS = 1e-50
if not os.path.exists(res_dir):
os.makedirs(res_dir)
f1 = open(res_dir + '/state.log', 'w')
# state.log record
Train_R_I = train_user[1] # 6040
Train_R_J = train_item[1] # 3544
Test_R = test_user[1]
Valid_R = valid_user[1]
if give_item_weight is True:
item_weight = np.array([math.sqrt(len(i)) for i in Train_R_J],
dtype=float)
item_weight *= (float(num_item) / item_weight.sum())
else:
item_weight = np.ones(num_item, dtype=float)
pre_val_eval = 1e10
best_tr_eval, best_val_eval, best_te_eval = 1e10, 1e10, 1e10
# dimension: 用户和物品的隐特征维数
# emb_dim: 词向量的维数
# if_cuda: 是否用GPU训练CNN
cnn_module = CNN(dimension, vocab_size, dropout_rate, emb_dim, max_len,
num_kernel_per_ws, if_cuda, init_W)
# 返回CNN的output
# size of V is (num_item, dimension)
if if_cuda:
cnn_module = cnn_module.cuda()
theta = cnn_module.get_projection_layer(CNN_X)
U = np.random.uniform(size=(num_user, dimension))
V = theta
endure_count = 5
count = 0
# max_iter is 50
for iteration in range(max_iter):
loss = 0
tic = time.time()
print("%d iteration\t(patience: %d)" % (iteration, count))
VV = b * (V.T.dot(V)) + lambda_u * np.eye(dimension)
sub_loss = np.zeros(num_user)
for i in range(num_user):
idx_item = train_user[0][i]
V_i = V[idx_item]
R_i = Train_R_I[i]
A = VV + (a - b) * (V_i.T.dot(V_i))
B = (a * V_i * np.tile(R_i, (dimension, 1)).T).sum(0)
U[i] = np.linalg.solve(A, B)
sub_loss[i] = -0.5 * lambda_u * np.dot(U[i], U[i])
loss = loss + np.sum(sub_loss)
sub_loss = np.zeros(num_item)
UU = b * (U.T.dot(U))
for j in range(num_item):
idx_user = train_item[0][j]
U_j = U[idx_user]
R_j = Train_R_J[j]
tmp_A = UU + (a - b) * (U_j.T.dot(U_j))
A = tmp_A + lambda_v * item_weight[j] * np.eye(dimension)
B = (a * U_j * np.tile(R_j, (dimension, 1)).T
).sum(0) + lambda_v * item_weight[j] * theta[j]
V[j] = np.linalg.solve(A, B)
sub_loss[j] = -0.5 * np.square(R_j * a).sum()
sub_loss[j] = sub_loss[j] + a * np.sum((U_j.dot(V[j])) * R_j)
sub_loss[j] = sub_loss[j] - 0.5 * np.dot(V[j].dot(tmp_A), V[j])
loss = loss + np.sum(sub_loss)
# 用V训练CNN模型，更新V
cnn_module.train(CNN_X, V)
theta = cnn_module.get_projection_layer(CNN_X)
# 这部分添加计算CNN模型的损失
# cnn_loss = history.history['loss'][-1]
# loss -= 0.5 * lambda_v * cnn_loss * num_item
tr_eval = eval_RMSE(Train_R_I, U, V, train_user[0])
val_eval = eval_RMSE(Valid_R, U, V, valid_user[0])
te_eval = eval_RMSE(Test_R, U, V, test_user[0])
# 计算一次迭代的时间
toc = time.time()
elapsed = toc - tic
# 计算Loss下降率
converge = abs((loss - PREV_LOSS) / PREV_LOSS)
# 存储效果最好的模型参数
if val_eval < pre_val_eval:
torch.save(cnn_module, res_dir + 'CNN_model.pt')
best_tr_eval, best_val_eval, best_te_eval = tr_eval, val_eval, te_eval
np.savetxt(res_dir + '/U.dat', U)
np.savetxt(res_dir + '/V.dat', V)
np.savetxt(res_dir + '/theta.dat', theta)
else:
count += 1
pre_val_eval = val_eval
print(
"Elpased: %.4fs Converge: %.6f Train: %.5f Valid: %.5f Test: %.5f"
% (elapsed, converge, tr_eval, val_eval, te_eval))
f1.write(
"Elpased: %.4fs Converge: %.6f Train: %.5f Valid: %.5f Test: %.5f\n"
% (elapsed, converge, tr_eval, val_eval, te_eval))
# 超过五次则退出迭代训练
if count == endure_count:
print("\n\nBest Model: Train: %.5f Valid: %.5f Test: %.5f" %
(best_tr_eval, best_val_eval, best_te_eval))
f1.write("\n\nBest Model: Train: %.5f Valid: %.5f Test: %.5f\n" %
(best_tr_eval, best_val_eval, best_te_eval))
break
PREV_LOSS = loss
f1.close()
def ConvMF(res_dir,
train_user,
train_item,
valid_user,
test_user,
R,
CNN_X,
vocab_size,
init_W=None,
give_item_weight=True,
max_iter=50,
lambda_u=1,
lambda_v=100,
dimension=50,
dropout_rate=0.2,
emb_dim=200,
max_len=300,
num_kernel_per_ws=100):
'''
构造并训练卷积矩阵分解模型
:param res_dir:结果文件路径
:param train_user:训练集用户稀疏评分向量（libSVM format）
:param train_item:训练集物品稀疏评分向量（libSVM format）
:param valid_user:测试集用户稀疏评分向量（libSVM format）
:param test_user:测试集物品稀疏评分向量（libSVM format）
:param R:原始评分数据,format: user id::item id::rating
:param CNN_X:物品描述词序列
:param vocab_size:词表大小
:param init_W:如果为None则动态训练词向量权重
:param give_item_weight:如果为True则使用静态词向量，否则动态训练词向量
:param max_iter:最大迭代次数
:param lambda_u:用户端正则惩罚项系数
:param lambda_v:用户端正则惩罚项系数
:param dimension:隐变量维度
:param dropout_rate:丢弃率
:param emb_dim:词嵌入维度
:param max_len:物品文本描述序列最大长度
:param num_kernel_per_ws:CNN的卷积核个数
:return:None
'''
# explicit setting
a = 1
b = 0
num_user = R.shape[0] #6040
num_item = R.shape[1] #3544
PREV_LOSS = 1e-50
if not os.path.exists(res_dir):
os.makedirs(res_dir)
f1 = open(res_dir + '/state.log', 'w')
Train_R_I = train_user[1] #user rating_list
Train_R_J = train_item[1] #item rating_list
Test_R = test_user[1]
Valid_R = valid_user[1]
if give_item_weight is True:
item_weight = np.array([math.sqrt(len(i)) for i in Train_R_J],
dtype=float)
item_weight = (float(num_item) / item_weight.sum()) * item_weight
else:
item_weight = np.ones(num_item, dtype=float)
pre_val_eval = 1e10
## init CNN model
cnn_module = CNN_module(dimension, vocab_size, dropout_rate, emb_dim,
max_len, num_kernel_per_ws, init_W)
theta = cnn_module.get_projection_layer(CNN_X)
np.random.seed(133)
# user-latent matrix
U = np.random.uniform(size=(num_user, dimension))
# item-latent matrix
V = theta
endure_count = 5 #超出５次则退出迭代训练
count = 0
for iteration in range(max_iter):
loss = 0
tic = time.time()
print("%d iteration\t(patience: %d)" % (iteration, count))
##get user-latent matirx loss
VV = b * (V.T.dot(V)) + lambda_u * np.eye(dimension) #theta V
sub_loss = np.zeros(num_user)
for i in range(num_user):
idx_item = train_user[0][i]
V_i = V[idx_item]
R_i = Train_R_I[i]
A = VV + (a - b) * (V_i.T.dot(V_i))
B = (a * V_i * (np.tile(R_i, (dimension, 1)).T)).sum(0)
U[i] = np.linalg.solve(A, B)
sub_loss[i] = -0.5 * lambda_u * np.dot(U[i], U[i])
loss = loss + np.sum(sub_loss)
##get item-latent matirx loss
sub_loss = np.zeros(num_item)
UU = b * (U.T.dot(U))
for j in range(num_item):
idx_user = train_item[0][j]
U_j = U[idx_user]
R_j = Train_R_J[j]
tmp_A = UU + (a - b) * (U_j.T.dot(U_j))
A = tmp_A + lambda_v * item_weight[j] * np.eye(dimension)
B = (a * U_j * (np.tile(R_j, (dimension, 1)).T)
).sum(0) + lambda_v * item_weight[j] * theta[j]
V[j] = np.linalg.solve(A, B)
sub_loss[j] = -0.5 * np.square(R_j * a).sum()
sub_loss[j] = sub_loss[j] + a * np.sum((U_j.dot(V[j])) * R_j)
sub_loss[j] = sub_loss[j] - 0.5 * np.dot(V[j].dot(tmp_A), V[j])
loss = loss + np.sum(sub_loss)
seed = np.random.randint(100000)
# get cnn loss
history = cnn_module.train(CNN_X, V, item_weight, seed)
theta = cnn_module.get_projection_layer(CNN_X)
cnn_loss = history.history['loss'][-1]
loss = loss - 0.5 * lambda_v * cnn_loss * num_item
# get rmse eval
tr_eval = eval_RMSE(Train_R_I, U, V, train_user[0])
val_eval = eval_RMSE(Valid_R, U, V, valid_user[0])
te_eval = eval_RMSE(Test_R, U, V, test_user[0])
toc = time.time()
elapsed = toc - tic
converge = abs((loss - PREV_LOSS) / PREV_LOSS)
#save u,v,w weight
if (val_eval < pre_val_eval):
cnn_module.save_model(res_dir + '/CNN_weights.hdf5')
np.savetxt(res_dir + '/U.dat', U)
np.savetxt(res_dir + '/V.dat', V)
np.savetxt(res_dir + '/theta.dat', theta)
else:
count = count + 1
pre_val_eval = val_eval
print(
"Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f"
% (loss, elapsed, converge, tr_eval, val_eval, te_eval))
f1.write(
"Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f\n"
% (loss, elapsed, converge, tr_eval, val_eval, te_eval))
if (count == endure_count):
break
PREV_LOSS = loss
f1.close()
def PMF(res_dir,
train_user,
train_item,
valid_user,
test_user,
R,
max_iter=50,
lambda_u=1,
lambda_v=100,
dimension=50):
# explicit setting
a = 1
b = 0
num_user = R.shape[0]
num_item = R.shape[1]
PREV_LOSS = 1e-50
if not os.path.exists(res_dir):
os.makedirs(res_dir)
f1 = open(res_dir + '/state.log', 'w')
Train_R_I = train_user[1]
Train_R_J = train_item[1]
Test_R = test_user[1]
Valid_R = valid_user[1]
pre_val_eval = 1e10
np.random.seed(133)
U = np.random.uniform(size=(num_user, dimension))
V = np.random.uniform(size=(num_item, dimension))
endure_count = 5
count = 0
for iteration in range(max_iter):
loss = 0
tic = time.time()
print("%d iteration\t(patience: %d)" % (iteration, count))
VV = b * (V.T.dot(V)) + lambda_u * np.eye(dimension)
sub_loss = np.zeros(num_user)
for i in range(num_user):
idx_item = train_user[0][i]
V_i = V[idx_item]
R_i = Train_R_I[i]
A = VV + (a - b) * (V_i.T.dot(V_i))
B = (a * V_i * (np.tile(R_i, (dimension, 1)).T)).sum(0)
U[i] = np.linalg.solve(A, B)
sub_loss[i] = -0.5 * lambda_u * np.dot(U[i], U[i])
loss = loss + np.sum(sub_loss)
sub_loss = np.zeros(num_item)
UU = b * (U.T.dot(U))
for j in range(num_item):
idx_user = train_item[0][j]
U_j = U[idx_user]
R_j = Train_R_J[j]
tmp_A = UU + (a - b) * (U_j.T.dot(U_j))
A = tmp_A + lambda_v * np.eye(dimension)
B = (a * U_j * (np.tile(R_j, (dimension, 1)).T)).sum(0)
V[j] = np.linalg.solve(A, B)
sub_loss[j] = -0.5 * np.dot(V[j], V[j])
sub_loss[j] = -0.5 * np.square(R_j * a).sum()
sub_loss[j] = sub_loss[j] + a * np.sum((U_j.dot(V[j])) * R_j)
sub_loss[j] = sub_loss[j] - 0.5 * np.dot(V[j].dot(tmp_A), V[j])
loss = loss + np.sum(sub_loss)
tr_eval = eval_RMSE(Train_R_I, U, V, train_user[0])
val_eval = eval_RMSE(Valid_R, U, V, valid_user[0])
te_eval = eval_RMSE(Test_R, U, V, test_user[0])
toc = time.time()
elapsed = toc - tic
converge = abs((loss - PREV_LOSS) / PREV_LOSS)
if (val_eval < pre_val_eval):
np.savetxt(res_dir + '/U.dat', U)
np.savetxt(res_dir + '/V.dat', V)
else:
count = count + 1
pre_val_eval = val_eval
print(
"Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f"
% (loss, elapsed, converge, tr_eval, val_eval, te_eval))
f1.write(
"Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f\n"
% (loss, elapsed, converge, tr_eval, val_eval, te_eval))
if (count == endure_count):
break
PREV_LOSS = loss
f1.close()
def ConvMF(res_dir, train_user, train_item, valid_user, test_user,
R, CNN_X, vocab_size, init_W=None, give_item_weight=True,
max_iter=50, lambda_u=1, lambda_v=100, dimension=50,
dropout_rate=0.2, emb_dim=200, max_len=300, num_kernel_per_ws=100):
# explicit setting
a = 1
b = 0
num_user = R.shape[0]
num_item = R.shape[1]
PREV_LOSS = 1e-50
if not os.path.exists(res_dir):
os.makedirs(res_dir)
f1 = open(res_dir + '/state.log', 'w')
Train_R_I = train_user[1]
Train_R_J = train_item[1]
Test_R = test_user[1]
Valid_R = valid_user[1]
if give_item_weight is True:
item_weight = np.array([math.sqrt(len(i))
for i in Train_R_J], dtype=float)
item_weight = (float(num_item) / item_weight.sum()) * item_weight
else:
item_weight = np.ones(num_item, dtype=float)
pre_val_eval = 1e10
cnn_module = CNN_module(dimension, vocab_size, dropout_rate,
emb_dim, max_len, num_kernel_per_ws, init_W)
theta = cnn_module.get_projection_layer(CNN_X)
np.random.seed(133)
U = np.random.uniform(size=(num_user, dimension))
V = theta
endure_count = 5
count = 0
for iteration in xrange(max_iter):
loss = 0
tic = time.time()
print "%d iteration\t(patience: %d)" % (iteration, count)
VV = b * (V.T.dot(V)) + lambda_u * np.eye(dimension)
sub_loss = np.zeros(num_user)
for i in xrange(num_user):
idx_item = train_user[0][i]
V_i = V[idx_item]
R_i = Train_R_I[i]
A = VV + (a - b) * (V_i.T.dot(V_i))
B = (a * V_i * (np.tile(R_i, (dimension, 1)).T)).sum(0)
U[i] = np.linalg.solve(A, B)
sub_loss[i] = -0.5 * lambda_u * np.dot(U[i], U[i])
loss = loss + np.sum(sub_loss)
sub_loss = np.zeros(num_item)
UU = b * (U.T.dot(U))
for j in xrange(num_item):
idx_user = train_item[0][j]
U_j = U[idx_user]
R_j = Train_R_J[j]
tmp_A = UU + (a - b) * (U_j.T.dot(U_j))
A = tmp_A + lambda_v * item_weight[j] * np.eye(dimension)
B = (a * U_j * (np.tile(R_j, (dimension, 1)).T)
).sum(0) + lambda_v * item_weight[j] * theta[j]
V[j] = np.linalg.solve(A, B)
sub_loss[j] = -0.5 * np.square(R_j * a).sum()
sub_loss[j] = sub_loss[j] + a * np.sum((U_j.dot(V[j])) * R_j)
sub_loss[j] = sub_loss[j] - 0.5 * np.dot(V[j].dot(tmp_A), V[j])
loss = loss + np.sum(sub_loss)
seed = np.random.randint(100000)
history = cnn_module.train(CNN_X, V, item_weight, seed)
theta = cnn_module.get_projection_layer(CNN_X)
cnn_loss = history.history['loss'][-1]
loss = loss - 0.5 * lambda_v * cnn_loss * num_item
tr_eval = eval_RMSE(Train_R_I, U, V, train_user[0])
val_eval = eval_RMSE(Valid_R, U, V, valid_user[0])
te_eval = eval_RMSE(Test_R, U, V, test_user[0])
toc = time.time()
elapsed = toc - tic
converge = abs((loss - PREV_LOSS) / PREV_LOSS)
if (val_eval < pre_val_eval):
cnn_module.save_model(res_dir + '/CNN_weights.hdf5')
np.savetxt(res_dir + '/U.dat', U)
np.savetxt(res_dir + '/V.dat', V)
np.savetxt(res_dir + '/theta.dat', theta)
else:
count = count + 1
pre_val_eval = val_eval
print "Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f" % (
loss, elapsed, converge, tr_eval, val_eval, te_eval)
f1.write("Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f\n" % (
loss, elapsed, converge, tr_eval, val_eval, te_eval))
if (count == endure_count):
break
PREV_LOSS = loss
f1.close()
def NN_stacking_CNN_CAE(res_dir, state_log_dir, train_user, train_item, valid_user, test_user,
R, CNN_theta, CAE_gamma,
max_iter, lambda_u, lambda_v, dimension, lr=0.01,
dropout_rate=0.2, a=1, b=0.01, give_item_weight=False):
# explicit settinggit
a = 1
b = 0.01
num_user = R.shape[0]
num_item = R.shape[1]
PREV_LOSS = -1e-50
if not os.path.exists(res_dir):
os.makedirs(res_dir)
os.chdir(res_dir)
# f1 = open(res_dir + '/state.log', 'w')
if not os.path.exists(state_log_dir):
os.makedirs(state_log_dir)
f1 = open(state_log_dir + '/state.log', 'w')
# log metrics into tf.summary
log_dir_name = os.path.basename(os.path.dirname(state_log_dir + '/'))
log_dir = os.path.join(state_log_dir, log_dir_name)
logger_tb = Tb_Logger(log_dir)
# indicate folder to save, plus other options
tensorboard = TensorBoard(log_dir=log_dir, histogram_freq=0,
write_graph=False, write_images=False)
# save it in your callback list, where you can include other callbacks
callbacks_list = [tensorboard]
# then pass to fit as callback, remember to use validation_data also
Train_R_I = train_user[1]
Train_R_J = train_item[1]
Test_R = test_user[1]
no_validation = False
if valid_user:
Valid_R = valid_user[1]
else:
no_validation = True
if give_item_weight is True:
item_weight = np.array([math.sqrt(len(i))
for i in Train_R_J], dtype=float)
item_weight = (float(num_item) / item_weight.sum()) * item_weight
item_weight[item_weight == 0] = 1
else:
item_weight = np.ones(num_item, dtype=float)
pre_val_eval = 1e10
theta_gamma_train = np.concatenate([CNN_theta, CAE_gamma], axis=1)
stacking_module = Stacking_NN_CNN_CAE(input_dim=theta_gamma_train.shape[1],output_dimesion=dimension
,num_layers=1,hidden_dim=300, dropout_rate=dropout_rate)
phi = stacking_module.get_projection_layer(theta_gamma_train)
np.random.seed(133)
U = np.random.uniform(size=(num_user, dimension))
if (theta_gamma_train.shape == dimension * 2):
V = (CNN_theta + CAE_gamma) / 2
else:
V = CNN_theta
print ('Training CNN-MF ...')
endure_count = 5
count = 0
converge_threshold = 1e-4
converge = 1.0
iteration = 0
while (iteration < max_iter and converge > converge_threshold) or iteration < min_iter:
# for iteration in xrange(max_iter):
loss = 0
tic = time.time()
print "%d iteration\t(patience: %d)" % (iteration, count)
VV = b * (V.T.dot(V)) + lambda_u * np.eye(dimension)
sub_loss = np.zeros(num_user)
for i in xrange(num_user):
idx_item = train_user[0][i]
V_i = V[idx_item]
R_i = Train_R_I[i]
A = VV + (a - b) * (V_i.T.dot(V_i))
B = (a * V_i * (np.tile(R_i, (dimension, 1)).T)).sum(0)
U[i] = np.linalg.solve(A, B)
sub_loss[i] = -0.5 * lambda_u * np.dot(U[i], U[i])
loss = loss + np.sum(sub_loss)
sub_loss = np.zeros(num_item)
UU = b * (U.T.dot(U))
for j in xrange(num_item):
idx_user = train_item[0][j]
U_j = U[idx_user]
R_j = Train_R_J[j]
if len(U_j) > 0:
tmp_A = UU + (a - b) * (U_j.T.dot(U_j))
A = tmp_A + lambda_v * item_weight[j] * np.eye(dimension)
B = (a * U_j * (np.tile(R_j, (dimension, 1)).T)
).sum(0) + lambda_v * item_weight[j] * phi[j]
V[j] = np.linalg.solve(A, B)
sub_loss[j] = -0.5 * np.square(R_j * a).sum()
sub_loss[j] = sub_loss[j] + a * np.sum((U_j.dot(V[j])) * R_j)
sub_loss[j] = sub_loss[j] - 0.5 * np.dot(V[j].dot(tmp_A), V[j])
else:
V[j] = phi[j]
loss = loss + np.sum(sub_loss)
seed = np.random.randint(100000)
history = stacking_module.train(theta_gamma_train, V, item_weight, seed, callbacks_list)
theta = stacking_module.get_projection_layer(theta_gamma_train)
stacking_loss = history.history['loss'][-1]
loss = loss - 0.5 * lambda_v * stacking_loss * num_item
tr_eval = eval_RMSE(Train_R_I, U, V, train_user[0])
if not no_validation:
val_eval = eval_RMSE(Valid_R, U, V, valid_user[0])
else:
val_eval = -1
te_eval = eval_RMSE(Test_R, U, V, test_user[0])
logger_tb.log_scalar('train_rmse', tr_eval, iteration)
if not no_validation:
logger_tb.log_scalar('eval_rmse', val_eval, iteration)
logger_tb.log_scalar('test_rmse', te_eval, iteration)
logger_tb.writer.flush()
toc = time.time()
elapsed = toc - tic
converge = abs((loss - PREV_LOSS) / PREV_LOSS)
# if (val_eval < pre_val_eval):
if (loss > PREV_LOSS):
# count = 0
print ("likelihood is increasing!")
stacking_module.save_model(res_dir + '/stacking_weights.hdf5')
np.savetxt(res_dir + '/final-U.dat', U)
np.savetxt(res_dir + '/final-V.dat', V)
np.savetxt(res_dir + '/theta.dat', theta)
best_train_rmse = tr_eval
best_test_rmse = te_eval
best_val_rmse = val_eval
else:
count = count + 1
# if (val_eval < pre_val_eval):
# count = 0
# cnn_module.save_model(res_dir + '/CNN_weights.hdf5')
# np.savetxt(res_dir + '/final-U.dat', U)
# np.savetxt(res_dir + '/final-V.dat', V)
# np.savetxt(res_dir + '/theta.dat', theta)
# else:
# count = count + 1
pre_val_eval = val_eval
print "Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f" % (
loss, elapsed, converge, tr_eval, val_eval, te_eval)
f1.write("Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f\n" % (
loss, elapsed, converge, tr_eval, val_eval, te_eval))
if (count >= endure_count and iteration > min_iter):
# if (count == endure_count):
break
elif (iteration < min_iter):
count = 0
PREV_LOSS = loss
iteration += 1
f1.close()
return best_train_rmse, best_test_rmse, best_val_rmse
def stacking_CNN_CAE(res_dir, state_log_dir, train_user, train_item, valid_user, test_user,
R, CNN_theta, CAE_gamma,
max_iter, lambda_u, lambda_v, dimension, lr=0.01,
dropout_rate=0.2, a=1, b=0.01, give_item_weight=False):
# explicit setting
# a = 1
# b = 0.01
num_user = R.shape[0]
num_item = R.shape[1]
'''prepare path to store results and log'''
if not os.path.exists(res_dir):
os.makedirs(res_dir)
os.chdir(res_dir)
if not os.path.exists(state_log_dir):
os.makedirs(state_log_dir)
f1 = open(state_log_dir + '/state.log', 'w')
'''log metrics using tf.summary '''
log_dir_name = os.path.basename(os.path.dirname(state_log_dir + '/'))
log_dir = os.path.join(state_log_dir, log_dir_name)
logger_tb = Tb_Logger(log_dir)
# indicate folder to save, plus other options
tensorboard = TensorBoard(log_dir=log_dir, histogram_freq=0,
write_graph=False, write_images=False)
# save it in your callback list, where you can include other callbacks
callbacks_list = [tensorboard]
# then pass to fit as callback, remember to use validation_data also
Train_R_I = train_user[1]
Train_R_J = train_item[1]
Test_R = test_user[1]
# check if the dataset has validation set
no_validation = False
if valid_user:
Valid_R = valid_user[1]
else:
no_validation = True
# assign weights to each item according to the number of time the item was rated
if give_item_weight is True:
item_weight = np.array([math.sqrt(len(i))
for i in Train_R_J], dtype=float)
item_weight = (float(num_item) / item_weight.sum()) * item_weight
item_weight[item_weight == 0] = 1
else:
item_weight = np.ones(num_item, dtype=float)
alpha = 1
beta = 1
# theta = (alpha* CNN_theta + beta *CAE_gamma) / 2
np.random.seed(133)
U = np.random.uniform(size=(num_user, dimension))
V = (alpha * CNN_theta + beta * CAE_gamma) / 2
print ('Training Stacking-CNN-CAE_MF ...')
pre_val_eval = -1e10
PREV_LOSS = -1e-50
endure_count = 5
count = 0
converge_threshold = 1e-4
converge = 1.0
iteration = 0
while (iteration < max_iter and converge > converge_threshold) or iteration < min_iter:
# for iteration in xrange(max_iter):
loss = 0
tic = time.time()
print "%d iteration\t(patience: %d)" % (iteration, count)
# Update U
VV = b * (V.T.dot(V)) + lambda_u * np.eye(dimension)
sub_loss = np.zeros(num_user)
for i in xrange(num_user):
idx_item = train_user[0][i]
V_i = V[idx_item]
R_i = Train_R_I[i]
A = VV + (a - b) * (V_i.T.dot(V_i))
B = (a * V_i * (np.tile(R_i, (dimension, 1)).T)).sum(0)
U[i] = np.linalg.solve(A, B)
sub_loss[i] = -0.5 * lambda_u * np.dot(U[i], U[i])
loss = loss + np.sum(sub_loss)
# Update V
sub_loss = np.zeros(num_item)
UU = b * (U.T.dot(U))
for j in xrange(num_item):
idx_user = train_item[0][j]
U_j = U[idx_user]
R_j = Train_R_J[j]
if len(U_j) > 0:
tmp_A = UU + (a - b) * (U_j.T.dot(U_j))
A = tmp_A + lambda_v * item_weight[j] * np.eye(dimension)
B = (a * U_j * (np.tile(R_j, (dimension, 1)).T)
).sum(0) + lambda_v * item_weight[j] * (alpha * CNN_theta[j] + beta * CAE_gamma[j])
V[j] = np.linalg.solve(A, B)
sub_loss[j] = -0.5 * np.square(R_j * a).sum()
sub_loss[j] = sub_loss[j] + a * np.sum((U_j.dot(V[j])) * R_j)
sub_loss[j] = sub_loss[j] - 0.5 * np.dot(V[j].dot(tmp_A), V[j])
else:
# in case the item has no ratings
V[j] = (alpha * CNN_theta[j] + beta * CAE_gamma[j])
loss = loss + np.sum(sub_loss)
# Update alpha and beta
seed = np.random.randint(100000)
alpha = alpha - lr * (np.sum(CNN_theta * (V - (alpha * CNN_theta + beta * CAE_gamma))))
alpha_loss = - np.sum((V - (alpha * CNN_theta + beta * CAE_gamma)) ** 2)
beta = beta - lr * (np.sum(CAE_gamma * (V - (alpha * CNN_theta + beta * CAE_gamma))))
beta_loss = np.sum((V - (alpha * CNN_theta + beta * CAE_gamma)) ** 2)
loss = loss - 0.5 * lambda_v * (alpha_loss + beta_loss)
toc = time.time()
elapsed = toc - tic
'''calculate RMSE'''
tr_eval = eval_RMSE(Train_R_I, U, V, train_user[0])
if not no_validation:
val_eval = eval_RMSE(Valid_R, U, V, valid_user[0])
else:
val_eval = -1
te_eval = eval_RMSE(Test_R, U, V, test_user[0])
''' write tf.summary'''
logger_tb.log_scalar('train_rmse', tr_eval, iteration)
if not no_validation:
logger_tb.log_scalar('eval_rmse', val_eval, iteration)
logger_tb.log_scalar('test_rmse', te_eval, iteration)
logger_tb.writer.flush()
'''Calculate converge and stor best values of U,V,theta'''
converge = abs((loss - PREV_LOSS) / PREV_LOSS)
# if (val_eval < pre_val_eval):
if (loss > PREV_LOSS):
# count = 0
print ("likelihood is increasing!")
with open(res_dir + '/alpha_beta.txt', 'w') as the_file:
the_file.write('alpha: %f' % alpha)
the_file.write('beta: %f' % beta)
np.savetxt(res_dir + '/final-U.dat', U)
np.savetxt(res_dir + '/final-V.dat', V)
best_train_rmse = tr_eval
best_test_rmse = te_eval
best_val_rmse = val_eval
else:
count = count + 1
pre_val_eval = val_eval
print "Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f" % (
loss, elapsed, converge, tr_eval, val_eval, te_eval)
f1.write("Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f\n" % (
loss, elapsed, converge, tr_eval, val_eval, te_eval))
if (count >= endure_count and iteration > min_iter):
# if (count == endure_count):
break
elif (iteration < min_iter):
count = 0
PREV_LOSS = loss
iteration += 1
f1.close()
return best_train_rmse, best_test_rmse, best_val_rmse
def MF(res_dir, state_log_dir, train_user, train_item, valid_user, test_user,
R, give_item_weight=False,
max_iter=50, lambda_u=1, lambda_v=100, dimension=200,
a=1, b=0.01):
# explicit setting
# a = 1
# b = 0.01
num_user = R.shape[0]
num_item = R.shape[1]
PREV_LOSS = 1e50
if not os.path.exists(res_dir):
os.makedirs(res_dir)
os.chdir(res_dir)
if not os.path.exists(state_log_dir):
os.makedirs(state_log_dir)
f1 = open(state_log_dir + '/state.log', 'w')
# log metrics into tf.summary
log_dir_name = os.path.basename(os.path.dirname(state_log_dir + '/'))
log_dir = os.path.join(state_log_dir, log_dir_name)
logger_tb = Tb_Logger(log_dir)
# indicate folder to save, plus other options
tensorboard = TensorBoard(log_dir=log_dir, histogram_freq=0,
write_graph=False, write_images=False)
# save it in your callback list, where you can include other callbacks
callbacks_list = [tensorboard]
# then pass to fit as callback, remember to use validation_data also
Train_R_I = train_user[1]
Train_R_J = train_item[1]
Test_R = test_user[1]
no_validation = False
if valid_user:
Valid_R = valid_user[1]
else:
no_validation = True
if give_item_weight is True:
item_weight = np.array([math.sqrt(len(i))
for i in Train_R_J], dtype=float)
item_weight = (float(num_item) / item_weight.sum()) * item_weight
item_weight[item_weight == 0] = 1
else:
item_weight = np.ones(num_item, dtype=float)
np.random.seed(133)
U = np.random.uniform(size=(num_user, dimension))
V = np.random.uniform(size=(num_item, dimension))
converge_threshold = 1e-4
converge = 1.0
pre_val_eval = 1e10
PREV_LOSS = -1e-50
count = 0
print ('Training MF ...')
iteration = 0
while (iteration < max_iter and converge > converge_threshold) or iteration < min_iter:
# for iteration in xrange(max_iter):
loss = 0
tic = time.time()
print "%d iteration\t(patience: %d)" % (iteration, count)
VV = b * (V.T.dot(V)) + lambda_u * np.eye(dimension)
sub_loss = np.zeros(num_user)
for i in xrange(num_user):
idx_item = train_user[0][i]
V_i = V[idx_item]
R_i = Train_R_I[i]
A = VV + (a - b) * (V_i.T.dot(V_i))
B = (a * V_i * (np.tile(R_i, (dimension, 1)).T)).sum(0)
U[i] = np.linalg.solve(A, B)
sub_loss[i] = -0.5 * lambda_u * np.dot(U[i], U[i])
loss = loss + np.sum(sub_loss)
sub_loss = np.zeros(num_item)
UU = b * (U.T.dot(U))
for j in xrange(num_item):
idx_user = train_item[0][j]
U_j = U[idx_user]
R_j = Train_R_J[j]
tmp_A = UU + (a - b) * (U_j.T.dot(U_j))
A = tmp_A + lambda_v * item_weight[j] * np.eye(dimension)
B = (a * U_j * (np.tile(R_j, (dimension, 1)).T)
).sum(0)
V[j] = np.linalg.solve(A, B)
sub_loss[j] = -0.5 * np.square(R_j * a).sum()
sub_loss[j] = sub_loss[j] + a * np.sum((U_j.dot(V[j])) * R_j)
sub_loss[j] = sub_loss[j] - 0.5 * np.dot(V[j].dot(tmp_A), V[j])
loss = loss + np.sum(sub_loss)
tr_eval = eval_RMSE(Train_R_I, U, V, train_user[0])
if not no_validation:
val_eval = eval_RMSE(Valid_R, U, V, valid_user[0])
else:
val_eval = -1
te_eval = eval_RMSE(Test_R, U, V, test_user[0])
logger_tb.log_scalar('train_rmse', tr_eval, iteration)
if not no_validation:
logger_tb.log_scalar('evale_rmse', val_eval, iteration)
logger_tb.log_scalar('test_rmse', te_eval, iteration)
logger_tb.writer.flush()
toc = time.time()
elapsed = toc - tic
converge = abs((loss - PREV_LOSS) / PREV_LOSS)
if (loss > PREV_LOSS):
# if (val_eval < pre_val_eval):
# count = 0
print ("likelihood is increasing!")
np.savetxt(res_dir + '/final-U.dat', U)
np.savetxt(res_dir + '/final-V.dat', V)
best_train_rmse = tr_eval
best_test_rmse = te_eval
best_val_rmse = val_eval
else:
count = count + 1
# if (val_eval < pre_val_eval):
# count = 0
# np.savetxt(res_dir + '/final-U.dat', U)
# np.savetxt(res_dir + '/final-V.dat', V)
# else:
# count = count + 1
pre_val_eval = val_eval
print "Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f" % (
loss, elapsed, converge, tr_eval, val_eval, te_eval)
f1.write("Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f\n" % (
loss, elapsed, converge, tr_eval, val_eval, te_eval))
if (count == endure_count):
break
PREV_LOSS = loss
iteration += 1
f1.close()
return best_train_rmse, best_test_rmse, best_val_rmse
def ConvCAEMF(res_dir, state_log_dir, train_user, train_item, valid_user, test_user,
R, attributes_X, CNN_X, vocab_size, init_W, cae_output_dim,
max_iter, lambda_u, lambda_v, dimension,
dropout_rate=0.2, emb_dim=200, max_len=300, num_kernel_per_ws=100,
a=1, b=0.01, give_item_weight=False, use_transfer_block=True):
# explicit setting
# a = 1
# b = 0.01
num_user = R.shape[0]
num_item = R.shape[1]
num_features = attributes_X.shape[1]
'''prepare path to store results and log'''
if not os.path.exists(res_dir):
os.makedirs(res_dir)
os.chdir(res_dir)
if not os.path.exists(state_log_dir):
os.makedirs(state_log_dir)
f1 = open(state_log_dir + '/state.log', 'w')
'''log metrics using tf.summary '''
log_dir_name = os.path.basename(os.path.dirname(state_log_dir + '/'))
log_dir = os.path.join(state_log_dir, log_dir_name)
logger_tb = Tb_Logger(log_dir)
# indicate folder to save, plus other options
tensorboard = TensorBoard(log_dir=log_dir, histogram_freq=0,
write_graph=False, write_images=False)
# save it in your callback list, where you can include other callbacks
callbacks_list = [tensorboard]
# then pass to fit as callback, remember to use validation_data also
Train_R_I = train_user[1]
Train_R_J = train_item[1]
Test_R = test_user[1]
# check if the dataset has validation set
no_validation = False
if valid_user:
Valid_R = valid_user[1]
else:
no_validation = True
# assign weights to each item according to the number of time the item was rated
if give_item_weight is True:
item_weight = np.array([math.sqrt(len(i))
for i in Train_R_J], dtype=float)
item_weight = (float(num_item) / item_weight.sum()) * item_weight
item_weight[item_weight == 0] = 1
else:
item_weight = np.ones(num_item, dtype=float)
'''initialize'''
if use_transfer_block:
cnn_cae_module = CNN_CAE_transfer_module(dimension, vocab_size, dropout_rate,
emb_dim, max_len, num_kernel_per_ws, init_W,
cae_N_hidden=cae_output_dim,
nb_features=num_features)
else:
cnn_cae_module = CNN_CAE_module(dimension, vocab_size, dropout_rate,
emb_dim, max_len, num_kernel_per_ws, init_W, cae_N_hidden=cae_output_dim,
nb_features=num_features)
theta = cnn_cae_module.get_projection_layer(CNN_X, attributes_X)
np.random.seed(133)
U = np.random.uniform(size=(num_user, dimension))
V = theta
print ('Training CNN-CAE-MF ...')
pre_val_eval = -1e10
PREV_LOSS = -1e-50
endure_count = 5
count = 0
converge_threshold = 1e-4
converge = 1.0
iteration = 0
while (iteration < max_iter and converge > converge_threshold) or iteration < min_iter:
# for iteration in xrange(max_iter):
loss = 0
tic = time.time()
print "%d iteration\t(patience: %d)" % (iteration, count)
# Update U
VV = b * (V.T.dot(V)) + lambda_u * np.eye(dimension)
sub_loss = np.zeros(num_user)
for i in xrange(num_user):
idx_item = train_user[0][i]
V_i = V[idx_item]
R_i = Train_R_I[i]
A = VV + (a - b) * (V_i.T.dot(V_i))
B = (a * V_i * (np.tile(R_i, (dimension, 1)).T)).sum(0)
U[i] = np.linalg.solve(A, B)
sub_loss[i] = -0.5 * lambda_u * np.dot(U[i], U[i])
loss = loss + np.sum(sub_loss)
# Update V
sub_loss = np.zeros(num_item)
UU = b * (U.T.dot(U))
for j in xrange(num_item):
idx_user = train_item[0][j]
U_j = U[idx_user]
R_j = Train_R_J[j]
if len(U_j) > 0:
tmp_A = UU + (a - b) * (U_j.T.dot(U_j))
A = tmp_A + lambda_v * item_weight[j] * np.eye(dimension)
B = (a * U_j * (np.tile(R_j, (dimension, 1)).T)
).sum(0) + lambda_v * item_weight[j] * theta[j]
V[j] = np.linalg.solve(A, B)
sub_loss[j] = -0.5 * np.square(R_j * a).sum()
sub_loss[j] = sub_loss[j] + a * np.sum((U_j.dot(V[j])) * R_j)
sub_loss[j] = sub_loss[j] - 0.5 * np.dot(V[j].dot(tmp_A), V[j])
else:
# in case the item has no ratings
V[j] = theta[j]
loss = loss + np.sum(sub_loss)
# Update theta
seed = np.random.randint(100000)
history = cnn_cae_module.train(CNN_X, V, att_train=attributes_X, item_weight=item_weight,
seed=seed, callbacks_list=callbacks_list)
theta = cnn_cae_module.get_projection_layer(CNN_X, attributes_X)
cnn_loss = history.history['loss'][-1]
loss = loss - 0.5 * lambda_v * cnn_loss * num_item
toc = time.time()
elapsed = toc - tic
'''calculate RMSE'''
tr_eval = eval_RMSE(Train_R_I, U, V, train_user[0])
if not no_validation:
val_eval = eval_RMSE(Valid_R, U, V, valid_user[0])
else:
val_eval = -1
te_eval = eval_RMSE(Test_R, U, V, test_user[0])
''' write tf.summary'''
logger_tb.log_scalar('train_rmse', tr_eval, iteration)
if not no_validation:
logger_tb.log_scalar('eval_rmse', val_eval, iteration)
logger_tb.log_scalar('test_rmse', te_eval, iteration)
logger_tb.writer.flush()
'''Calculate converge and stor best values of U,V,theta'''
converge = abs((loss - PREV_LOSS) / PREV_LOSS)
# if (val_eval < pre_val_eval):
if (loss > PREV_LOSS):
# count = 0
print ("likelihood is increasing!")
cnn_cae_module.save_model(res_dir + '/CNN_CAE_weights.hdf5')
np.savetxt(res_dir + '/final-U.dat', U)
np.savetxt(res_dir + '/final-V.dat', V)
np.savetxt(res_dir + '/theta.dat', theta)
best_train_rmse = tr_eval
best_test_rmse = te_eval
best_val_rmse = val_eval
else:
count = count + 1
pre_val_eval = val_eval
print "Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f" % (
loss, elapsed, converge, tr_eval, val_eval, te_eval)
f1.write("Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f\n" % (
loss, elapsed, converge, tr_eval, val_eval, te_eval))
if (count >= endure_count and iteration > min_iter):
# if (count == endure_count):
break
elif (iteration < min_iter):
count = 0
PREV_LOSS = loss
iteration += 1
f1.close()
return best_train_rmse, best_test_rmse, best_val_rmse
def ConvMF(res_dir,
train_user,
train_item,
valid_user,
test_user,
R,
CNN_X,
vocab_size,
init_W=None,
give_item_weight=True,
max_iter=50,
lambda_u=1,
lambda_v=100,
dimension=50,
dropout_rate=0.2,
emb_dim=200,
max_len=300,
num_kernel_per_ws=100):
# explicit setting
a = 1
b = 0
num_user = R.shape[0]
num_item = R.shape[1]
print "===================================ConvMF Models==================================="
print "\tnum_user is:{}".format(num_user)
print "\tnum_item is:{}".format(num_item)
print "==================================================================================="
PREV_LOSS = 1e-50
if not os.path.exists(res_dir):
os.makedirs(res_dir)
f1 = open(res_dir + '/state.log', 'w')
Train_R_I = train_user[
1] #this is rating; train_user_[0] is the item_index
Train_R_J = train_item[1]
Test_R = test_user[1]
Valid_R = valid_user[1]
if give_item_weight is True:
item_weight = np.array([math.sqrt(len(i)) for i in Train_R_J],
dtype=float)
item_weight = (float(num_item) / item_weight.sum()) * item_weight
else:
item_weight = np.ones(num_item, dtype=float)
pre_val_eval = 1e10
# cnn_module = CNN_module(dimension, vocab_size, dropout_rate,
# emb_dim, max_len, num_kernel_per_ws, init_W )
cnn_module = CNN_module(dimension, vocab_size, dropout_rate, emb_dim,
max_len, num_kernel_per_ws, init_W, num_item)
theta = np.random.uniform(size=(num_item, dimension))
#cnn_module.get_projection_layer(CNN_X)
np.random.seed(133)
U = np.random.uniform(size=(num_user, dimension))
V = theta
'''
add index of items
'''
item_index = np.arange(num_item).reshape(-1, 1)
m_VV = np.concatenate((theta, item_index), axis=1)
# seed = np.random.randint(100000)
# cnn_module.train(CNN_X,m_VV,item_weight,seed)
# cnn_loss=cnn_module.train_loss
# theta=cnn_module.get_projection_layer()
# return
endure_count = 5
count = 0
print "===================================numpy dot==================================="
print np.dot.__module__
print "==============================================================================="
for iteration in xrange(max_iter):
loss = 0
tic = time.time()
print "%d iteration\t(patience: %d)" % (iteration, count)
VV = b * (V.T.dot(V)) + lambda_u * np.eye(dimension) #diagonal matrix
sub_loss = np.zeros(num_user)
print "=================================================================="
print "the shape of U, U[i] {} {}".format(U.shape, U[0].shape)
print "=================================================================="
for i in xrange(num_user):
idx_item = train_user[0][i]
#train_user[0]=[[item1,item2,item3...],[item1,itme3],[item3,item2]...]
#train_user[1]=[[rating1,rating2,rating3...],[rating1,rating3],[rating2,rating5]...]
V_i = V[idx_item]
R_i = Train_R_I[i] #[rating1,rating2,rating3...]
A = VV + (a - b) * (V_i.T.dot(V_i))
B = (a * V_i * (np.tile(R_i, (dimension, 1)).T)).sum(
0
) #np.tile() array copy; sum(0) is the sum of each column,sum(1) is the sum of each row;
U[i] = np.linalg.solve(A, B) #AX=B,X=A^(-1)B
sub_loss[i] = -0.5 * lambda_u * np.dot(U[i], U[i])
loss = loss + np.sum(sub_loss)
print "=================================================================="
print "the shape of V, V[i] {} {}".format(V.shape, V[0].shape)
print "=================================================================="
sub_loss = np.zeros(num_item)
UU = b * (U.T.dot(U))
for j in xrange(num_item):
idx_user = train_item[0][j]
U_j = U[idx_user]
R_j = Train_R_J[j]
tmp_A = UU + (a - b) * (U_j.T.dot(U_j))
A = tmp_A + lambda_v * item_weight[j] * np.eye(dimension)
B = (a * U_j * (np.tile(R_j, (dimension, 1)).T)
).sum(0) + lambda_v * item_weight[j] * theta[j]
V[j] = np.linalg.solve(A, B) #A*X=B X =A^-1*B
sub_loss[j] = -0.5 * np.square(R_j * a).sum()
sub_loss[j] = sub_loss[j] + a * np.sum((U_j.dot(V[j])) * R_j)
sub_loss[j] = sub_loss[j] - 0.5 * np.dot(V[j].dot(tmp_A), V[j])
loss = loss + np.sum(sub_loss)
seed = np.random.randint(100000)
# history = cnn_module.train(CNN_X, V, item_weight, seed)
# theta = cnn_module.get_projection_layer(CNN_X)
# print history,history.history.keys(),
# print history.history['loss']
# cnn_loss = history.history['loss'][-1]
m_VV = np.concatenate((V, item_index), axis=1)
cnn_module.train(CNN_X, m_VV, item_weight, seed)
cnn_loss = cnn_module.train_loss
logging.info("----------------------------------")
logging.info("CNN loss".format(cnn_loss))
logging.info("----------------------------------")
theta = cnn_module.get_projection_layer()
loss = loss - 0.5 * lambda_v * cnn_loss * num_item
tr_eval = eval_RMSE(Train_R_I, U, V, train_user[0])
val_eval = eval_RMSE(Valid_R, U, V, valid_user[0])
te_eval = eval_RMSE(Test_R, U, V, test_user[0])
toc = time.time()
elapsed = toc - tic
converge = abs((loss - PREV_LOSS) / PREV_LOSS)
if (val_eval < pre_val_eval):
# # cnn_module.save_model(res_dir + '/CNN_weights.hdf5')
# np.savetxt(res_dir + '/U.dat', U)
# np.savetxt(res_dir + '/V.dat', V)
# np.savetxt(res_dir + '/theta.dat', theta)
pass
else:
count = count + 1
pre_val_eval = val_eval
print "Loss: %.5f Elpased: %.4fs Converge: %.6f Train: %.5f Validation: %.5f Test: %.5f" % (
loss, elapsed, converge, tr_eval, val_eval, te_eval)
f1.write(
"Loss: %.5f Elpased: %.4fs Converge: %.6f Train: %.5f Validation: %.5f Test: %.5f\n"
% (loss, elapsed, converge, tr_eval, val_eval, te_eval))
if (count == endure_count):
break
PREV_LOSS = loss
f1.close()
