def minimum_gamma(self, user, lambda_U, eta):
# user i
user_id = selected_user.index(user)
sum_t = 0.0
gamma_i = self.gamma[user_id] # 1.0
print("Calculating min target gamma......")
for t in range(1, self.time_num - 1):
neighbors_i = self.neighbors(user, t - 1, 0)
sum_h = np.zeros(self.D)
for h in neighbors_i:
if h > selected_user[-1]:
break
uid_h = selected_user.index(h)
eta_h = eta[uid_h]
sum_h += self.L_hit(h, user, t - 1,
eta_h) * self.user_interest[
t - 1][:, uid_h] # self.U_it(h, t - 1)
# sum_t += (self.Uit_hat(user, t, gamma_i) - self.U_it(user, t)) * (sum_h-self.U_it(user, t - 1))
sum_t += np.dot((self.user_interest_Uit_hat[t][:, user_id] -
self.user_interest[t][:, user_id]),
(sum_h - self.user_interest[t - 1][:, user_id]))
min_target = lambda_U * sum_t
# gamma_i -= self.learning_rate*min_target
# gamma_i = self.pi_x(gamma_i-self.learning_rate*min_target)
for iter in range(self.max_iter):
# print("Iteration: " + str(iter))
inp = min_target # gamma_i -
gamma_i_tmp = gamma_i - self.learning_rate * self.pi_x(inp)
if gamma_i_tmp < 0.0 or gamma_i_tmp > 1.0:
break
else:
gamma_i = gamma_i_tmp
print "gamma: " + str(gamma_i)
return gamma_i
def minimum_gamma(self, user, lambda_U, eta):
# user i
user_id = selected_user.index(user)
sum_t = 0.0
gamma_i = 1.0
for iter in range(self.max_iter):
print("Iteration: " + str(iter))
for t in range(1, self.time_num - 1):
neighbors_i = self.neighbors(user, t - 1, 0)
sum_h = 0.0
for h in neighbors_i:
uid_h = selected_user.index(h)
eta_h = eta[uid_h]
sum_h += self.L_hit(
h, user, t - 1, eta_h) * self.user_interest[
t - 1][:, uid_h] # self.U_it(h, t - 1)
# sum_t += (self.Uit_hat(user, t, gamma_i) - self.U_it(user, t)) * (sum_h-self.U_it(user, t - 1))
sum_t += (self.user_interest_Uit_hat[t][:, user_id] -
self.user_interest[t][:, user_id] *
(sum_h - self.user_interest[t - 1][:, user_id]))
min_target = lambda_U * sum_t
# gamma_i -= self.learning_rate*min_target
gamma_i -= self.learning_rate * self.pi_x(gamma_i - min_target)
print "gamma: " + str(gamma_i)
return gamma_i
def get_friend_type(self, user1, user2, time):
# input user id
# friend_type = np.load(self.rootDir + 'friend_type_uijt.npy')
time = 0
try:
return self.friend_type[time][selected_user.index(user1)][
selected_user.index(user2)]
except Exception as e:
return 0.0
def Uit_hat(self, user, time, gamma_i): # user i
neighbors_i = self.neighbors(user, time - 1, 0)
sum_h = 0.0
for h in neighbors_i:
index_h = selected_user.index(h)
eta_h = self.eta[index_h]
sum_h += self.L_hit(h, user, time - 1, eta_h) * self.U_it(
index_h, time - 1)
Uit_hat = (1 - gamma_i) * self.U_it(selected_user.index(user),
time - 1) + gamma_i * sum_h
self.user_interest_Uit_hat[time][:,
selected_user.index(user)] = Uit_hat
return Uit_hat
def L_hit(self, user_h, user_i, time, eta):
user_h_id = selected_user.index(user_h)
user_i_id = selected_user.index(user_i)
is_friend = self.get_friend_type(
user_h_id, user_i_id, time
) # =0 if user_h has no link with user_i, =0.5 if they are one way fallow, =1 if they are friends
friends_i = self.neighbors(user_i, time, 1)
if len(friends_i) != 0:
friends_h = self.neighbors(user_h, time, 1)
intersec = list(set(friends_i).intersection(set(friends_h)))
L_hit = eta * is_friend + (1 - eta) * float(
len(intersec) / float(len(friends_i)))
else:
L_hit = 0.0
return L_hit
def neighbors(self, user, time, flag):
# user id
# flag = 0 return all neighbors, =1 return only friends.
user_id = selected_user.index(user)
if flag == 0:
with codecs.open(self.rootDir + 'neighbors_flag_0.json',
mode='r') as infile:
neighbors_0 = json.load(infile)
try:
neighbors = [
int(i) for i in neighbors_0[str(time)][str(user_id)]
[1:-1].replace('L', '').split(', ')
]
except Exception as e:
# print e
neighbors = []
else:
with codecs.open(self.rootDir + 'neighbors_flag_1.json',
mode='r') as infile:
neighbors_1 = json.load(infile)
try:
neighbors = [
int(i) for i in neighbors_1[str(time)][str(user_id)]
[1:-1].replace('L', '').split(', ')
]
except Exception as e:
# print e
neighbors = []
return neighbors
def minimum_eta(self, user_i, lambda_U, gamma):
sum_t = 0.0
uid_i = selected_user.index(user_i)
gamma_i = gamma[uid_i]
eta_i = self.eta[uid_i] # 1.0
print("Calculating min target eta......")
for t in range(1, self.time_num - 1):
neighbors_i = self.neighbors(user_i, t - 1, 0)
sum_h = np.zeros(self.D)
for user_h in neighbors_i:
if user_h > selected_user[-1]:
break
uid_h = selected_user.index(user_h)
is_friend = 0 # =0 if user_h has no link with user_i, =0.5 if they are one way fallow, =1 if they are friends
friends_i = self.neighbors(user_i, t, 1)
if len(friends_i) != 0:
friends_h = self.neighbors(user_h, t, 1)
intersec = list(
set(friends_i).intersection(set(friends_h)))
sum_h += (is_friend - float(
len(intersec) / len(friends_i))) * self.user_interest[
t - 1][:, uid_h] # self.U_it(user_h, t-1)
else:
sum_h += 0
# sum_t += (self.Uit_hat(user_i, t, gamma_i) - self.U_it(user_i, t)) * (gamma_i * sum_h + (1-gamma_i) * self.U_it(user_, t-1))
sum_t += np.dot(
(self.user_interest_Uit_hat[t][:, uid_i] -
self.user_interest[t][:, uid_i]),
(gamma_i * sum_h +
(1 - gamma_i) * self.user_interest[t - 1][:, uid_i]))
min_target = lambda_U * sum_t
print("Iteration......")
for iter in range(self.max_iter):
# print("Iteration: " + str(iter))
eta_i_tmp = eta_i - self.learning_rate * self.pi_x(min_target)
if eta_i_tmp < 0.0 or eta_i_tmp > 1.0:
break
else:
eta_i = eta_i_tmp
# eta_i = self.pi_x(eta_i - self.learning_rate * min_target)
print "eta: " + str(eta_i)
return eta_i
def Y_R_ijt(self, user_i, item_j, time):
# Y_ijt = 1 if user_i has a link with item_j at time t, else=0
# R_ijt = rating preference score of user_i to item_j at time t
# R_ij = np.load(self.rootDir+'Actual_Rij_t.npy')
usr_id = selected_user.index(user_i)
R_ijt = self.R_ij[time][usr_id][item_j]
if R_ijt == 0:
Y_ijt = 0
else:
Y_ijt = 1
return Y_ijt, R_ijt
def minimum_Uit(self, user, time, gamma, eta, lambda_U): # , item_set
# user i(id), time t
user_h = self.neighbors(user, time, 0)
user_id = selected_user.index(user)
gamma_i = gamma[user_id]
sum_userh = 0.0
for h in user_h:
uid_h = selected_user.index(h)
gamma_h = gamma[uid_h]
eta_h = eta[uid_h]
sum_userh += gamma_h * self.L_hit(
h, user, time, eta_h) * (self.Uit_hat(h, time + 1, gamma_h) -
self.U_it(uid_h, time + 1))
min_Uit = np.zeros(self.D)
# for minb in range(self.minibatch):
# item_set.append(random.randint(0, self.doc_num-1)) # choose mini_batch number of documents' ids
for iter in range(self.max_iter):
print("Iteration: " + str(iter))
for item in range(self.doc_num):
Y_ijt, R_ijt = self.Y_R_ijt(user, item, time)
# item j
uid_time = self.U_it(user_id, time)
v_j_item = self.V_j(item)
target_min_Uit = np.add(
Y_ijt * (np.dot(uid_time, v_j_item) - R_ijt) * v_j_item,
lambda_U * (uid_time - self.Uit_hat(user, time, gamma_i)))
target_min_Uit = np.add(
target_min_Uit,
lambda_U * (1 - gamma_i) *
(self.U_it(user_id, time + 1) -
self.Uit_hat(user, time + 1, gamma_i)))
target_min_Uit = np.add(target_min_Uit, lambda_U * sum_userh)
min_Uit = min_Uit - self.learning_rate * target_min_Uit # )np.add
if np.isnan(np.sum(min_Uit)):
return self.user_interest[time][:, user_id]
self.update_U_it(min_Uit, user_id, time)
print min_Uit
return min_Uit
def minimum_eta(self, user_i, lambda_U, gamma):
sum_t = 0.0
uid_i = selected_user.index(user_i)
gamma_i = gamma[uid_i]
eta_i = 1.0
for iter in range(self.max_iter):
print("Iteration: " + str(iter))
for t in range(1, self.time_num - 1):
neighbors_i = self.neighbors(user_i, t - 1, 0)
sum_h = 0.0
for user_h in neighbors_i:
uid_h = selected_user.index(user_h)
is_friend = 0 # =0 if user_h has no link with user_i, =0.5 if they are one way fallow, =1 if they are friends
friends_i = self.neighbors(user_i, t, 1)
if len(friends_i) != 0:
friends_h = self.neighbors(user_h, t, 1)
intersec = list(
set(friends_i).intersection(set(friends_h)))
sum_h += (
is_friend - float(len(intersec) / len(friends_i))
) * self.user_interest[
t - 1][:, uid_h] # self.U_it(user_h, t-1)
else:
sum_h += 0
# sum_t += (self.Uit_hat(user_i, t, gamma_i) - self.U_it(user_i, t)) * (gamma_i * sum_h + (1-gamma_i) * self.U_it(user_, t-1))
sum_t += (
self.user_interest_Uit_hat[t][:, uid_i] -
self.user_interest[t][:, uid_i] *
(gamma_i * sum_h +
(1 - gamma_i) * self.user_interest[t - 1][:, uid_i]))
min_target = lambda_U * sum_t
eta_i -= self.learning_rate * self.pi_x(eta_i - min_target)
print "eta: " + str(eta_i)
return eta_i
def sum_userh(self, batch_UserID, time_id):
sum = []
for uid in batch_UserID:
sum_userh = [0.0 for i in range(self.num_feat)]
user_h = self.neighbors(uid, time_id, 0)
for h in user_h:
if h > selected_user[-1]:
break
uid_h = selected_user.index(h)
gamma_h = self.gamma[uid_h]
eta_h = self.eta[uid_h]
sum_userh += gamma_h * self.L_hit(
uid_h, uid, time_id,
eta_h) * (self.Uit_hat([uid_h], time_id + 1) -
self.w_User[time_id + 1][uid_h, :])
sum.append(sum_userh)
return np.array(
sum) # np.array(sum).reshape(self.batch_size, self.num_feat)
def get_R_ui_t():
user_tag_info = pd.read_table(rootDir + 'user_taggedartists.dat',
sep='\t',
header=0)
user_num = 1892
item_num = 12316 # 17632
time_num = 8
aID_id = np.loadtxt(rootDir + 'artistsID_id_havetags_havevecs.txt')
from selected_user import selected_user
R_ua_t = np.zeros((time_num, user_num, item_num), dtype='int')
with codecs.open(rootDir + "user_artists.dat", mode='r',
encoding='utf-8') as uafile:
uafile.readline()
info = uafile.readline().strip('\n').strip('\r')
i = 0
while info:
i += 1
print i
info_split = info.split('\t')
uID, aID, weight = int(info_split[0]), int(
info_split[1]), info_split[2]
res = user_tag_info.loc[(user_tag_info['userID'] == uID)
& (user_tag_info['artistID'] == aID)]
if not res.empty:
time = res.iloc[-1].values[-1]
time_id = int(time) - 2005 + 1
if time_id <= 0:
time_id = 0
else:
time_id = 0
# new_line = info + str(time_id) + '\n'
try:
art_index = np.where(aID_id == aID)[0][0]
user_index = selected_user.index(uID)
R_ua_t[time_id][user_index][art_index] = weight
except Exception as e:
print e, aID
info = uafile.readline().strip('\n').strip('\r')
np.save(rootDir + 'Actual_Rij_t.npy', R_ua_t)
def Uit_hat(self, uid_list, time_id): # user i
Uit_hat = []
for uid in uid_list:
gamma_i = self.gamma[uid]
# user_id = selected_user.index(uid)
neighbors_i = self.neighbors(uid, time_id - 1, 0)
sum_h = 0.0
for h in neighbors_i:
if h > selected_user[-1]:
break
index_h = selected_user.index(h)
eta_h = self.eta[index_h]
sum_h += self.L_hit(
index_h, uid, time_id - 1,
eta_h) * self.w_User[time_id - 1][
index_h, :] # self.U_it(index_h, time_id-1)
uit_each = (1 - gamma_i) * self.w_User[time_id -
1][uid, :] + gamma_i * sum_h
if len(uid_list) == 1:
Uit_hat = uit_each
else:
Uit_hat.append(uit_each) # self.U_it(user_id, time_id-1)
self.w_User_hat[time_id][uid, :] = uit_each
return np.array(Uit_hat) # np.array(Uit_hat)
def minimum_Uit(self, user, time, gamma, eta, lambda_U): # , item_set
# user i(id), time t
user_h = self.neighbors(user, time, 0)
user_id = selected_user.index(user)
gamma_i = gamma[user_id]
sum_userh = 0.0
for h in user_h:
if h > selected_user[-1]:
break
uid_h = selected_user.index(h)
gamma_h = gamma[uid_h]
eta_h = eta[uid_h]
sum_userh += gamma_h * self.L_hit(
h, user, time, eta_h) * (self.Uit_hat(h, time + 1, gamma_h) -
self.U_it(uid_h, time + 1))
Uit = self.U_it(user_id, time)
R_it = self.R_ij[time][user_id]
item_set = [index for index, rijt in enumerate(R_it) if rijt != 0]
if len(item_set) == 0:
for minb in range(self.minibatch):
item_set.append(random.randint(
0, self.doc_num -
1)) # choose mini_batch number of documents' ids
# index = 0
target_min_Uit = np.zeros(self.D)
print("Calculating target_min_Uit......")
for item in item_set: # range(self.doc_num):
Y_ijt, R_ijt = self.Y_R_ijt(user, item, time)
# item j
uid_time = self.U_it(user_id, time)
v_j_item = self.V_j(item)
if np.isnan(np.sum(v_j_item)):
continue
target_min_Uit_tmp = np.add(
target_min_Uit,
Y_ijt * (np.dot(uid_time, v_j_item) - R_ijt) * v_j_item)
target_min_Uit_tmp = np.add(
target_min_Uit_tmp,
lambda_U * (uid_time - self.Uit_hat(user, time, gamma_i)))
target_min_Uit_tmp = np.add(
target_min_Uit_tmp,
lambda_U * (1 - gamma_i) *
(self.U_it(user_id, time + 1) -
self.Uit_hat(user, time + 1, gamma_i)))
target_min_Uit_tmp = np.add(target_min_Uit_tmp,
lambda_U * sum_userh)
if np.isnan(np.sum(target_min_Uit_tmp)):
break
else:
target_min_Uit = target_min_Uit_tmp
# print index, target_min_Uit
# index += 1
print("Iteration......")
for iter in range(self.max_iter):
# print("Iteration: " + str(iter))
min_Uit_tmp = Uit - self.learning_rate * target_min_Uit # )np.add
if not np.isnan(np.sum(min_Uit_tmp)):
Uit = min_Uit_tmp
self.update_U_it(Uit, user_id, time)
print Uit
return Uit
def get_friend_type(self, user1, user2, time):
friend_type = np.load(self.rootDir + 'friend_type_uijt.npy')
return friend_type[time][selected_user.index(user1)][
selected_user.index(user2)]