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)]