OSCR

Rule-guided Skip-GCN in neural latent information diffusion network for social recommendation.

Code ↔ Paper

The paper beside its authors' code: matches between them have not been computed for this paper yet.

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 646 lines · 34 KB · no license

  1. #-*- coding: utf-8 -*-
  3. from __future__ import division
  4. from cmath import tau
  5. from collections import defaultdict
  6. import numpy as np
  7. from time import time
  8. import random
  9. import tensorflow as tf
  11. tau_uiu = 0.2
  12. tau_ii = 0.3 #### yelp: 0.3 flickr: 0.7
  15. class DataModule():
  16. def __init__(self, conf, filename):
  17. self.conf = conf
  18. self.data_dict = {}
  19. self.terminal_flag = 1
  20. self.filename = filename
  21. self.index = 0
  23. ####### Initalize Procedures #######
  24. def prepareModelSupplement(self, model):
  25. data_dict = {}
  26. if 'CONSUMED_ITEMS_SPARSE_MATRIX' in model.supply_set:
  27. self.generateConsumedItemsSparseMatrix()
  28. #self.arrangePositiveData()
  29. data_dict['CONSUMED_ITEMS_INDICES_INPUT'] = self.consumed_items_indices_list
  30. data_dict['CONSUMED_ITEMS_VALUES_INPUT'] = self.consumed_items_values_list
  31. data_dict['CONSUMED_ITEMS_VALUES_WEIGHT_AVG_INPUT'] = self.consumed_items_values_weight_avg_list
  32. data_dict['CONSUMED_ITEMS_NUM_INPUT'] = self.consumed_item_num_list
  33. data_dict['CONSUMED_ITEMS_NUM_DICT_INPUT'] = self.user_item_num_dict
  34. # data_dict['USER_ITEM_SPARSITY_DICT'] = self.user_item_sparsity_dict ##### 用不到！！！！！！
  36. if 'SOCIAL_NEIGHBORS_SPARSE_MATRIX' in model.supply_set:
  37. self.readSocialNeighbors()
  38. self.generateSocialNeighborsSparseMatrix()
  39. data_dict['SOCIAL_NEIGHBORS_INDICES_INPUT'] = self.social_neighbors_indices_list
  40. data_dict['SOCIAL_NEIGHBORS_VALUES_INPUT'] = self.social_neighbors_values_list
  41. data_dict['SOCIAL_NEIGHBORS_VALUES_WEIGHT_AVG_INPUT'] = self.social_neighbors_values_weight_avg_list
  42. data_dict['SOCIAL_NEIGHBORS_NUM_INPUT'] = self.social_neighbor_num_list
  43. data_dict['SOCIAL_NEIGHBORS_NUM_DICT_INPUT'] = self.social_neighbors_num_dict
  44. # data_dict['USER_USER_SPARSITY_DICT']= self.user_user_sparsity_dict #### 用不到！！！！！！
  45. ##################################################################
  46. ##################################################################
  47. ##################################################################
  48. data_dict['user_user_uiu_indices_input'] = self.user_user_uiu_indices_list
  49. data_dict['user_user_uiu_values_input'] = self.user_user_uiu_values_list
  50. data_dict['user_user_uiu_values_weight_avg_input'] = self.user_user_uiu_values_weight_avg_list
  51. data_dict['user_user_u0u_indices_input'] = self.user_user_u0u_indices_list
  52. data_dict['user_user_u0u_values_input'] = self.user_user_u0u_values_list
  53. data_dict['user_user_u0u_values_weight_avg_input'] = self.user_user_u0u_values_weight_avg_list
  55. if 'ITEM_CUSTOMER_SPARSE_MATRIX' in model.supply_set:
  56. self.generateConsumedItemsSparseMatrixForItemUser()
  57. data_dict['ITEM_CUSTOMER_INDICES_INPUT'] = self.item_customer_indices_list
  58. data_dict['ITEM_CUSTOMER_VALUES_INPUT'] = self.item_customer_values_list
  59. data_dict['ITEM_CUSTOMER_VALUES_WEIGHT_AVG_INPUT'] = self.item_customer_values_weight_avg_list
  60. data_dict['ITEM_CUSTOMER_NUM_INPUT'] = self.item_customer_num_list
  61. data_dict['ITEM_USER_NUM_DICT_INPUT'] = self.item_user_num_dict
  62. ##################################################################
  63. ##################################################################
  64. ##################################################################
  65. data_dict['item_item_iui_indices_input'] = self.item_item_iui_indices_list
  66. data_dict['item_item_iui_values_input'] = self.item_item_iui_values_list
  67. data_dict['item_item_iui_values_weight_avg_input'] = self.item_item_iui_values_weight_avg_list
  68. data_dict['item_item_iui_num_input'] = self.item_item_iui_num_list
  69. data_dict['item_item_iui_num_dict_input'] = self.item_item_iui_num_dict
  71. return data_dict
  73. def initializeRankingTrain(self):
  74. self.readData()
  75. self.arrangePositiveData()
  76. self.arrangePositiveDataForItemUser()
  77. self.generateTrainNegative()
  79. def initializeRankingVT(self):
  80. self.readData()
  81. self.arrangePositiveData()
  82. self.arrangePositiveDataForItemUser()
  83. self.generateTrainNegative()
  85. def initalizeRankingEva(self):
  86. self.readData()
  87. self.getEvaPositiveBatch()
  88. self.generateEvaNegative()
  90. def linkedMap(self):
  91. self.data_dict['USER_LIST'] = self.user_list
  92. self.data_dict['ITEM_LIST'] = self.item_list
  93. self.data_dict['LABEL_LIST'] = self.labels_list
  95. def linkedRankingEvaMap(self):
  96. self.data_dict['EVA_USER_LIST'] = self.eva_user_list
  97. self.data_dict['EVA_ITEM_LIST'] = self.eva_item_list
  99. ####### Data Loading #######
  100. def readData(self):
  101. f = open(self.filename)
  102. total_user_list = set()
  103. hash_data = defaultdict(int)
  104. for _, line in enumerate(f):
  105. arr = line.split("\t")
  106. hash_data[(int(arr[0]), int(arr[1]))] = 1
  107. total_user_list.add(int(arr[0]))
  109. self.total_user_list = list(total_user_list) ####
  110. self.hash_data = hash_data #### hash_data[(userID, itemID)] = 1
  112. # def arrangePositiveData(self): ####
  113. # positive_data = defaultdict(set)
  114. # user_item_num_dict = defaultdict(set)
  115. # total_data = set()
  116. # hash_data = self.hash_data
  117. # for (u, i) in hash_data:
  118. # total_data.add((u, i))
  119. # positive_data[u].add(i)
  121. # user_list = sorted(list(positive_data.keys()))
  123. # for u in range(self.conf.num_users):
  124. # user_item_num_dict[u] = len(positive_data[u]) + 1
  125. # self.positive_data = positive_data #### positive_data
  126. # self.user_item_num_dict = user_item_num_dict #### 一个user
  127. # self.user_item_num_for_sparsity_dict = user_item_num_for_sparsity_dict
  128. # self.total_data = len(total_data) ####（user-item）pair
  130. # def Sparsity_analysis_for_user_item_network(self): #### 用不到！！！！！！！！！！！！！！！
  131. # hash_data_for_user_item = self.hash_data
  132. # sparisty_user_item_dict = {}
  134. def arrangePositiveDataForItemUser(self):
  135. positive_data_for_item_user = defaultdict(set)
  136. item_user_num_dict = defaultdict(int)
  138. total_data_for_item_user = set()
  139. hash_data_for_item_user = self.hash_data
  140. for (u, i) in hash_data_for_item_user:
  141. total_data_for_item_user.add((i, u))
  142. positive_data_for_item_user[i].add(u)
  144. # item_list = sorted(list(positive_data_for_item_user.keys()))
  146. for i in range(self.conf.num_items):
  147. item_user_num_dict[i] = len(positive_data_for_item_user[i]) + 1 #### 一个user
  149. self.item_user_num_dict = item_user_num_dict
  150. self.positive_data_for_item_user = positive_data_for_item_user #### positive_data_for _item_user
  151. self.total_data_for_item_user = len(total_data_for_item_user) #### (item-user)pair
  154. # ----------------------
  155. # This function designes for generating train/val/test negative
  156. def generateTrainNegative(self):
  157. num_items = self.conf.num_items
  158. num_negatives = self.conf.num_negatives
  159. negative_data = defaultdict(set)
  160. total_data = set()
  161. hash_data = self.hash_data #### hash_data[(userID, itemID)] = 1
  162. for (u, i) in hash_data:
  163. total_data.add((u, i))
  164. for _ in range(num_negatives): ####
  165. j = np.random.randint(num_items) ####
  166. while (u, j) in hash_data:
  167. j = np.random.randint(num_items)
  168. negative_data[u].add(j)
  169. total_data.add((u, j)) #### ----
  170. self.negative_data = negative_data
  171. self.terminal_flag = 1 ####
  174. # ----------------------
  175. # This function designes for val/test set, compute loss #### 为validation/test
  176. def getVTRankingOneBatch(self):
  177. positive_data = self.positive_data
  178. negative_data = self.negative_data
  179. total_user_list = self.total_user_list
  180. user_list = []
  181. item_list = []
  182. labels_list = []
  183. for u in total_user_list:
  184. user_list.extend([u] * len(positive_data[u]))
  185. item_list.extend(positive_data[u])
  186. labels_list.extend([1] * len(positive_data[u])) ####
  187. user_list.extend([u] * len(negative_data[u]))
  188. item_list.extend(negative_data[u])
  189. labels_list.extend([0] * len(negative_data[u])) ####
  191. self.user_list = np.reshape(user_list, [-1, 1]) ####
  192. self.item_list = np.reshape(item_list, [-1, 1])
  193. self.labels_list = np.reshape(labels_list, [-1, 1])
  195. # ----------------------
  196. # This function designes for the training process
  197. def getTrainRankingBatch(self): #### 为train
  198. positive_data = self.positive_data
  199. negative_data = self.negative_data
  200. total_user_list = self.total_user_list
  201. index = self.index
  202. batch_size = self.conf.training_batch_size
  204. user_list, item_list, labels_list = [], [], []
  206. if index + batch_size < len(total_user_list):
  207. target_user_list = total_user_list[index:index+batch_size]
  208. self.index = index + batch_size
  209. else:
  210. target_user_list = total_user_list[index:len(total_user_list)]
  211. self.index = 0 ####
  212. self.terminal_flag = 0
  214. for u in target_user_list:
  215. user_list.extend([u] * len(positive_data[u]))
  216. item_list.extend(list(positive_data[u]))
  217. labels_list.extend([1] * len(positive_data[u])) ####
  218. user_list.extend([u] * len(negative_data[u]))
  219. item_list.extend(list(negative_data[u]))
  220. labels_list.extend([0] * len(negative_data[u])) ####
  222. self.user_list = np.reshape(user_list, [-1, 1]) ####
  223. self.item_list = np.reshape(item_list, [-1, 1])
  224. self.labels_list = np.reshape(labels_list, [-1, 1])
  226. # ----------------------
  227. # This function is designed for the positive data
  228. def getEvaPositiveBatch(self):
  229. hash_data = self.hash_data
  230. user_list = []
  231. item_list = []
  232. index_dict = defaultdict(list)
  233. index = 0 ####
  234. for (u, i) in hash_data:
  235. user_list.append(u)
  236. item_list.append(i)
  237. index_dict[u].append(index)
  238. index = index + 1
  239. self.eva_user_list = np.reshape(user_list, [-1, 1])
  240. self.eva_item_list = np.reshape(item_list, [-1, 1])
  241. self.eva_index_dict = index_dict
  244. # ----------------------
  245. #This function is designed for generating negative data
  246. def generateEvaNegative(self):
  247. hash_data = self.hash_data
  248. total_user_list = self.total_user_list
  249. num_evaluate = self.conf.num_evaluate
  250. num_items = self.conf.num_items
  251. eva_negative_data = defaultdict(list) ####
  252. for u in total_user_list:
  253. for _ in range(num_evaluate): ####
  254. j = np.random.randint(num_items)
  255. while (u, j) in hash_data:
  256. j = np.random.randint(num_items)
  257. eva_negative_data[u].append(j)
  258. self.eva_negative_data = eva_negative_data
  260. # ----------------------
  261. #This function designs for generating negative batch in rating evaluation,
  262. def getEvaRankingBatch(self):
  263. batch_size = self.conf.evaluate_batch_size
  264. num_evaluate = self.conf.num_evaluate
  265. eva_negative_data = self.eva_negative_data
  266. total_user_list = self.total_user_list
  267. index = self.index
  268. terminal_flag = 1
  269. total_users = len(total_user_list)
  270. user_list = []
  271. item_list = []
  272. if index + batch_size < total_users: ####
  273. batch_user_list = total_user_list[index:index+batch_size]
  274. self.index = index + batch_size
  275. else:
  276. terminal_flag = 0
  277. batch_user_list = total_user_list[index:total_users]
  278. self.index = 0
  279. for u in batch_user_list:
  280. user_list.extend([u]*num_evaluate) ####
  281. item_list.extend(eva_negative_data[u])
  282. self.eva_user_list = np.reshape(user_list, [-1, 1]) ####
  283. self.eva_item_list = np.reshape(item_list, [-1, 1])
  284. return batch_user_list, terminal_flag
  287. # ----------------------
  288. # Read social network information
  289. def readSocialNeighbors(self, friends_flag = 1): ####
  290. social_neighbors = defaultdict(set)
  291. social_neighbors_num_dict = defaultdict(int)
  293. links_file = open(self.conf.links_filename) ####
  294. for _, line in enumerate(links_file):
  295. tmp = line.split('\t')
  296. u1, u2 = int(tmp[0]), int(tmp[1])
  297. social_neighbors[u1].add(u2)
  298. if friends_flag == 1: ####
  299. social_neighbors[u2].add(u1) #### 无向
  300. # user_list = sorted(list(social_neighbors.keys())) #### ----
  301. for u in range(self.conf.num_users):
  302. social_neighbors_num_dict[u] = len(social_neighbors[u]) + 1 ##### 每个user
  304. self.social_neighbors_num_dict = social_neighbors_num_dict
  305. self.social_neighbors = social_neighbors
  307. def arrangePositiveData(self): ####
  308. positive_data = defaultdict(set)
  309. user_item_num_dict = defaultdict(int)
  310. total_data = set()
  311. hash_data = self.hash_data
  313. ############################################################################
  314. ############################################################################
  315. ############################################################################
  316. item_users = defaultdict(set)
  318. for (u, i) in hash_data:
  319. total_data.add((u, i))
  320. positive_data[u].add(i)
  321. item_users[i].add(u)
  323. user_list = sorted(list(positive_data.keys()))
  324. for u in range(self.conf.num_users):
  325. user_item_num_dict[u] = len(positive_data[u]) + 1
  327. self.positive_data = positive_data
  328. self.user_item_num_dict = user_item_num_dict #### 89
  329. self.total_data = len(total_data)
  331. #############################################################################
  332. #############################################################################
  333. #############################################################################
  334. self.user_items = self.positive_data
  335. self.item_users = item_users
  337. # ----------------------
  338. #Generate Social Neighbors Sparse Matrix Indices and Values
  339. def generateSocialNeighborsSparseMatrix(self):
  340. social_neighbors = self.social_neighbors ####
  341. social_neighbors_num_dict = self.social_neighbors_num_dict #weight avg ####
  343. social_neighbors_indices_list = []
  344. social_neighbors_values_list = []
  345. social_neighbors_values_weight_avg_list = []
  346. social_neighbor_num_list = []
  347. social_neighbors_dict = defaultdict(list)
  349. # user_user_num_for_sparsity_dict = defaultdict(set) ####
  350. # user_user_sparsity_dict = {}
  352. # user_user_sparsity_dict['0-4'] = [] #### 0 <= x < 4 （左闭右开）
  353. # user_user_sparsity_dict['4-8'] = []
  354. # user_user_sparsity_dict['8-16'] = []
  355. # user_user_sparsity_dict['16-32'] = []
  356. # user_user_sparsity_dict['32-64'] = []
  357. # user_user_sparsity_dict['64-'] = []
  359. # for u in range(self.conf.num_users):
  360. # user_user_num_for_sparsity_dict[u] = len(social_neighbors[u]) ####
  362. for u in social_neighbors:
  363. social_neighbors_dict[u] = sorted(social_neighbors[u])
  365. user_list = sorted(list(social_neighbors.keys()))
  367. #node att ####
  368. for user in range(self.conf.num_users):
  369. if user in social_neighbors_dict:
  370. social_neighbor_num_list.append(len(social_neighbors_dict[user])) ####
  371. else:
  372. social_neighbor_num_list.append(1) ####
  373. print("{} 没有trust的朋友！！！！！！！！！！！".format(user)) ####
  375. for user in user_list:
  376. for friend in social_neighbors_dict[user]:
  377. social_neighbors_indices_list.append([user, friend])
  378. social_neighbors_values_list.append(1.0/len(social_neighbors_dict[user]))
  379. social_neighbors_values_weight_avg_list.append(1.0 / ( np.sqrt(social_neighbors_num_dict[user]) * np.sqrt(social_neighbors_num_dict[friend]) ) ) #weight avg
  381. # for u in range(self.conf.num_users):
  382. # cur_user_neighbors_num = user_user_num_for_sparsity_dict[u] ####
  383. # if( (cur_user_neighbors_num >=0) & (cur_user_neighbors_num<4) ):
  384. # user_user_sparsity_dict['0-4'].append(u)
  385. # elif( (cur_user_neighbors_num >=4) & (cur_user_neighbors_num<8) ):
  386. # user_user_sparsity_dict['4-8'].append(u)
  387. # elif( (cur_user_neighbors_num >=8) & (cur_user_neighbors_num<16) ):
  388. # user_user_sparsity_dict['8-16'].append(u)
  389. # elif( (cur_user_neighbors_num >=16) & (cur_user_neighbors_num<32) ):
  390. # user_user_sparsity_dict['16-32'].append(u)
  391. # elif( (cur_user_neighbors_num >=32) & (cur_user_neighbors_num<64) ):
  392. # user_user_sparsity_dict['32-64'].append(u)
  393. # elif( cur_user_neighbors_num >=64):
  394. # user_user_sparsity_dict['64-'].append(u)
  397. # self.user_user_sparsity_dict = user_user_sparsity_dict ####
  398. self.social_neighbors_indices_list = np.array(social_neighbors_indices_list).astype(np.int64)
  399. self.social_neighbors_values_list = np.array(social_neighbors_values_list).astype(np.float32)
  400. self.social_neighbors_values_weight_avg_list = np.array(social_neighbors_values_weight_avg_list).astype(np.float32) # weight avg
  401. self.social_neighbor_num_list = np.array(social_neighbor_num_list).astype(np.int64)
  402. #self.social_neighbors_values_list = tf.Variable(tf.random_normal([len(self.social_neighbors_indices_list)], stddev=0.01)) ####
  405. ################################################################################################
  406. ################################################################################################
  407. ################################################################################################
  408. #### u1与u2之间有共同的item
  409. user_user_uiu_indices_list = []
  410. user_user_uiu_indeces_visited = set() ####
  411. user_user_uiu_values_list = []
  412. user_user_uiu_values_weight_avg_list = []
  414. #### u1与u2之间没有共同的item
  415. user_user_u0u_indices_list = []
  416. user_user_u0u_indices_visited = set()
  417. user_user_u0u_values_list = []
  418. user_user_u0u_values_weight_avg_list = []
  421. print('此时的user-user阈值是{}'.format(tau_uiu))
  423. ID = 0
  425. for u1 in user_list:
  426. u1_items_set = set(self.user_items[u1])
  427. # print(u1_items_set)
  428. for u2 in social_neighbors_dict[u1]:
  429. u1_u2_common_item = set() ####
  430. u2_items_set = set(self.user_items[u2])
  431. for i2 in u2_items_set:
  432. if i2 in u1_items_set:
  433. u1_u2_common_item.add(i2)
  434. # print(have_common_item)
  435. if len(u1_u2_common_item) > 0:
  436. if (u1, u2) in user_user_uiu_indeces_visited:
  437. continue ####
  438. user_user_uiu_indices_list.append([u1, u2])
  439. user_user_uiu_indeces_visited.add((u1, u2)) ####
  440. user_user_uiu_values_list.append(1.0/len(social_neighbors_dict[u1]))
  441. user_user_uiu_values_weight_avg_list.append(1.0 / ( np.sqrt(social_neighbors_num_dict[u1]) * np.sqrt(social_neighbors_num_dict[u2]) ) ) #weight avg
  442. ###################################################################################################
  443. ###################################################################################################
  444. ###################################################################################################
  445. if len(u1_u2_common_item) / len(u1_items_set) >= tau_uiu and len(u1_u2_common_item) / len(u2_items_set) >= tau_uiu:
  446. for u3 in social_neighbors_dict[u2]:
  447. if u1 == u3 or u1 == u2 or u2 == u3:
  448. continue
  449. for i3 in self.user_items[u3]:
  450. if i3 in u1_u2_common_item:
  451. if (u1, u3) in user_user_uiu_indeces_visited:
  452. continue ####
  453. user_user_uiu_indices_list.append([u1, u3])
  454. user_user_uiu_indeces_visited.add((u1, u3)) ####
  455. user_user_uiu_values_list.append(1.0/len(social_neighbors_dict[u1]))
  456. user_user_uiu_values_weight_avg_list.append(1.0 / ( np.sqrt(social_neighbors_num_dict[u1]) * np.sqrt(social_neighbors_num_dict[u3]) ) ) #weight avg
  457. # print(ID)
  458. ID += 1
  459. # for u4 in social_neighbors_dict[u3]:
  460. # if len(set([u1, u2, u3, u4])) != 4:
  461. # continue
  462. # for i4 in self.user_items[u4]:
  463. # if i4 in u1_items_set:
  464. # user_user_uiu_indices_list.append([u1, u4])
  465. # user_user_uiu_values_list.append(1.0/len(social_neighbors_dict[u1]))
  466. # user_user_uiu_values_weight_avg_list.append(1.0 / ( np.sqrt(social_neighbors_num_dict[u1]) * np.sqrt(social_neighbors_num_dict[u4]) ) ) #weight avg
  467. # break
  468. break
  469. else:
  470. if (u1, u2) in user_user_u0u_indices_visited:
  471. continue ####
  472. user_user_u0u_indices_list.append([u1, u2])
  473. user_user_u0u_indices_visited.add((u1, u2)) ####
  474. user_user_u0u_values_list.append(1.0/len(social_neighbors_dict[u1]))
  475. user_user_u0u_values_weight_avg_list.append(1.0 / ( np.sqrt(social_neighbors_num_dict[u1]) * np.sqrt(social_neighbors_num_dict[u2]) ) ) #weight avg
  477. print(ID)
  479. self.user_user_uiu_indices_list = np.array(user_user_uiu_indices_list).astype(np.int64)
  480. self.user_user_uiu_values_list = np.array(user_user_uiu_values_list).astype(np.float32)
  481. self.user_user_uiu_values_weight_avg_list = np.array(user_user_uiu_values_weight_avg_list).astype(np.float32)
  482. self.user_user_u0u_indices_list = np.array(user_user_u0u_indices_list).astype(np.int64)
  483. self.user_user_u0u_values_list = np.array(user_user_u0u_values_list).astype(np.float32)
  484. self.user_user_u0u_values_weight_avg_list = np.array(user_user_u0u_values_weight_avg_list).astype(np.float32)
  486. # ----------------------
  487. #Generate Consumed Items Sparse Matrix Indices and Values
  488. def generateConsumedItemsSparseMatrix(self):
  489. positive_data = self.positive_data
  490. consumed_items_indices_list = []
  491. consumed_items_values_list = []
  492. consumed_items_values_weight_avg_list = []
  493. consumed_item_num_list = []
  494. consumed_items_dict = defaultdict(list)
  495. # user_item_num_for_sparsity_dict = defaultdict(set) #####
  496. # user_item_sparsity_dict = {}
  498. # user_item_sparsity_dict['0-4'] = [] ####
  499. # user_item_sparsity_dict['4-8'] = []
  500. # user_item_sparsity_dict['8-16'] = []
  501. # user_item_sparsity_dict['16-32'] = []
  502. # user_item_sparsity_dict['32-64'] = []
  503. # user_item_sparsity_dict['64-'] = []
  505. consumed_items_num_dict = self.user_item_num_dict #weight avg
  506. #social_neighbors_num_dict = self.social_neighbors_num_dict #weight avg
  507. item_user_num_dict = self.item_user_num_dict #weight avg
  509. for u in positive_data:
  510. consumed_items_dict[u] = sorted(positive_data[u]) ####
  512. user_list = sorted(list(positive_data.keys())) #### userID
  514. # for u in range(self.conf.num_users):
  515. # user_item_num_for_sparsity_dict[u] = len(positive_data[u]) ####
  517. for user in range(self.conf.num_users):
  518. if user in consumed_items_dict:
  519. consumed_item_num_list.append(len(consumed_items_dict[user])) ####
  520. else:
  521. consumed_item_num_list.append(1) ####
  523. for u in user_list:
  524. for i in consumed_items_dict[u]:
  525. consumed_items_indices_list.append([u, i])
  526. consumed_items_values_list.append(1.0/len(consumed_items_dict[u]))
  527. consumed_items_values_weight_avg_list.append(1.0/( np.sqrt(consumed_items_num_dict[u]) * np.sqrt(item_user_num_dict[i]) )) #weight avg
  529. # for u in range(self.conf.num_users): ####
  530. # cur_user_consumed_item_num = user_item_num_for_sparsity_dict[u]
  531. # if( (cur_user_consumed_item_num >=0) & (cur_user_consumed_item_num<4) ):
  532. # user_item_sparsity_dict['0-4'].append(u)
  533. # elif( (cur_user_consumed_item_num >=4) & (cur_user_consumed_item_num<8) ):
  534. # user_item_sparsity_dict['4-8'].append(u)
  535. # elif( (cur_user_consumed_item_num >=8) & (cur_user_consumed_item_num<16) ):
  536. # user_item_sparsity_dict['8-16'].append(u)
  537. # elif( (cur_user_consumed_item_num >=16) & (cur_user_consumed_item_num<32) ):
  538. # user_item_sparsity_dict['16-32'].append(u)
  539. # elif( (cur_user_consumed_item_num >=32) & (cur_user_consumed_item_num<64) ):
  540. # user_item_sparsity_dict['32-64'].append(u)
  541. # elif( cur_user_consumed_item_num >=64):
  542. # user_item_sparsity_dict['64-'].append(u)
  544. # self.user_item_sparsity_dict = user_item_sparsity_dict ####
  545. self.consumed_items_indices_list = np.array(consumed_items_indices_list).astype(np.int64)
  546. self.consumed_items_values_list = np.array(consumed_items_values_list).astype(np.float32)
  547. self.consumed_items_values_weight_avg_list = np.array(consumed_items_values_weight_avg_list).astype(np.float32) #weight avg
  548. self.consumed_item_num_list = np.array(consumed_item_num_list).astype(np.int64)
  552. def generateConsumedItemsSparseMatrixForItemUser(self):
  553. positive_data_for_item_user = self.positive_data_for_item_user
  554. item_customer_indices_list = []
  555. item_customer_values_list = []
  556. item_customer_values_weight_avg_list = []
  557. item_customer_num_list = []
  558. item_customer_dict = defaultdict(list)
  560. consumed_items_num_dict = self.user_item_num_dict #weight avg ####
  561. #social_neighbors_num_dict = self.social_neighbors_num_dict #weight avg
  562. item_user_num_dict = self.item_user_num_dict #weight avg ####
  564. for i in positive_data_for_item_user: ####
  565. item_customer_dict[i] = sorted(positive_data_for_item_user[i])
  566. item_list = sorted(list(positive_data_for_item_user.keys()))
  568. for item in range(self.conf.num_items):
  569. if item in item_customer_dict:
  570. item_customer_num_list.append(len(item_customer_dict[item])) ####
  571. else:
  572. item_customer_num_list.append(1) ####
  574. for i in item_list:
  575. for u in item_customer_dict[i]:
  576. item_customer_indices_list.append([i, u])
  577. item_customer_values_list.append(1.0/len(item_customer_dict[i])) ####
  578. item_customer_values_weight_avg_list.append(1.0/( np.sqrt(consumed_items_num_dict[u]) * np.sqrt(item_user_num_dict[i]) )) #
  580. self.item_customer_indices_list = np.array(item_customer_indices_list).astype(np.int64)
  581. self.item_customer_values_list = np.array(item_customer_values_list).astype(np.float32)
  582. self.item_customer_num_list = np.array(item_customer_num_list).astype(np.int64)
  583. self.item_customer_values_weight_avg_list = np.array(item_customer_values_weight_avg_list).astype(np.float32)
  588. ################################################################################################
  589. ################################################################################################
  590. ################################################################################################
  591. #### u1与u2之间有共同的item
  592. item_item_iui_indices_list = []
  593. item_item_iui_values_list = []
  594. item_item_iui_num_list = []
  595. item_item_iui_values_weight_avg_list = []
  596. self.item_items = defaultdict(set)
  597. self.item_item_iui_num_dict = defaultdict(int)
  599. ######## item-item
  600. print('此时item-item阈值是{}'.format(tau_ii))
  602. ID = 0
  603. for i1 in item_list:
  604. i1_users_set = set(self.item_users[i1])
  605. for u1 in i1_users_set:
  606. for i2 in self.user_items[u1]:
  607. if i1 == i2:
  608. continue
  609. i2_users_set = set(self.item_users[i2])
  610. common_user_set = set()
  611. for u2 in i2_users_set:
  612. if u2 in i1_users_set:
  613. common_user_set.add(u2)
  614. if len(common_user_set) / len(i1_users_set) >= tau_ii and len(common_user_set) / len(i2_users_set) >= tau_ii:
  615. # if len(common_user_set) / len(i1_users_set) >= 0.5 and len(common_user_set) / len(i2_users_set) >= 0.5:
  616. # print(ID) ##########################################################
  617. ID += 1
  618. self.item_items[i1].add(i2)
  619. print(ID)
  621. for i1 in range(self.conf.num_items):
  622. if i1 in self.item_items:
  623. self.item_item_iui_num_dict[i1] = len(self.item_items[i1]) + 1
  624. else:
  625. self.item_item_iui_num_dict[i1] = 1
  628. for i1 in range(self.conf.num_items):
  629. if i1 in self.item_items:
  630. item_item_iui_num_list.append(len(self.item_items[i1]))
  631. else:
  632. item_item_iui_num_list.append(1)
  635. for i1 in self.item_items.keys():
  636. for i2 in self.item_items[i1]:
  637. item_item_iui_indices_list.append([i1, i2])
  638. item_item_iui_values_list.append(1.0 / len(self.item_items[i1]))
  639. item_item_iui_values_weight_avg_list.append(1.0 / ( np.sqrt(self.item_item_iui_num_dict[i1]) * np.sqrt(self.item_item_iui_num_dict[i2]) ) ) #weight avg
  642. self.item_item_iui_indices_list = np.array(item_item_iui_indices_list).astype(np.int64)
  643. self.item_item_iui_values_list = np.array(item_item_iui_values_list).astype(np.float32)
  644. self.item_item_iui_num_list = np.array(item_item_iui_num_list).astype(np.int64)
  645. self.item_item_iui_values_weight_avg_list = np.array(item_item_iui_values_weight_avg_list).astype(np.float32)

DataModule.py at commit 7bf4320, no license · at the source

Overview

Authors: Rui Cao1, Jindong Li1, He Kong1, Qi Wang1,2, Yi Chang1,2,3
  1. School of Artificial Intelligence, Jilin University, Changchun, 130012 China
  2. Engineering Research Center of Knowledge-Driven Human-Machine Intelligence, Ministry of Education, Changchun, China
  3. International Center of Future Science, Jilin University, Changchun, China
Institutions: Jilin University (China)
Journal: Scientific reports, volume 16, issue 1, article 25452
Dates: received 18 April 2024; accepted 14 April 2026; published online 4 June 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41598-026-49379-1 · PMID 42243206 · PMCID PMC13473486 · OpenAlex W7163566133
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: methods / tools (subfield)
Keywords: Computer science, Information technology
Topic: Recommender Systems and Techniques (Information Systems, Computer Science), according to OpenAlex
Funding: National Natural Science Foundation of China (No. 62206107)
Citations: not cited yet (Europe PMC); 57 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

Its files are read in the Code ↔ Paper reader above.

CAorvi/DiffRSG

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 7bf4320502cab3b875f9f1940e2bbea37a3079a9, 10 August 2025
Languages: Python (8)
Size: 33 files, 8 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, continuous integration
Not found: license file, CITATION.cff, environment file, tests, documentation
Tools: NumPy (4 files), TensorFlow (3 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
9 files
At the source: github.com/CAorvi/DiffRSG

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 8 scripts, each with its path and the digest of its content;
  • no match between paragraphs and code yet;
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41598-026-49379-1.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 2 keywords, 1 funder, 54 references.

Cite

This paper

Cao, R., Li, J., Kong, H., Wang, Q., & Chang, Y. (2026). Rule-guided Skip-GCN in neural latent information diffusion network for social recommendation. Scientific reports, 16(1), 25452. https://doi.org/10.1038/s41598-026-49379-1

BibTeX

@article{cao2026rule,
author = {Cao, Rui and Li, Jindong and Kong, He and Wang, Qi and Chang, Yi},
title = {{Rule-guided Skip-GCN in neural latent information diffusion network for social recommendation}},
journal = {Scientific reports},
year = {2026},
month = jun,
volume = {16},
number = {1},
pages = {25452},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-026-49379-1},
url = {https://doi.org/10.1038/s41598-026-49379-1},
pmid = {42243206},
pmcid = {PMC13473486}
}

RIS

TY - JOUR
AU - Cao, Rui
AU - Li, Jindong
AU - Kong, He
AU - Wang, Qi
AU - Chang, Yi
TI - Rule-guided Skip-GCN in neural latent information diffusion network for social recommendation
T2 - Scientific reports
J2 - Sci Rep
PY - 2026
DA - 2026/06/04
VL - 16
IS - 1
SP - 25452
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-026-49379-1
UR - https://doi.org/10.1038/s41598-026-49379-1
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-026-49379-1",
"type": "article-journal",
"title": "Rule-guided Skip-GCN in neural latent information diffusion network for social recommendation",
"container-title": "Scientific reports",
"author": [
{
"family": "Cao",
"given": "Rui"
},
{
"family": "Li",
"given": "Jindong"
},
{
"family": "Kong",
"given": "He"
},
{
"family": "Wang",
"given": "Qi"
},
{
"family": "Chang",
"given": "Yi"
}
],
"container-title-short": "Sci Rep",
"volume": "16",
"issue": "1",
"page": "25452",
"DOI": "10.1038/s41598-026-49379-1",
"PMID": "42243206",
"PMCID": "PMC13473486",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-026-49379-1",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
4
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: TensorFlow, NumPy, methods / tools
[2] doi:10.1162/imag.a.1366 [code]
MICAFlow: Fast and robust MRI preprocessing bridging research neuroimaging and clinical practice.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: TensorFlow, NumPy, methods / tools
[3] doi:10.1126/sciadv.aed3650 [code]
Truthful visualizations for mass spectrometry imaging enable high-spatial-resolution interactive &lt;i&gt;m/z&lt;/i&gt; mapping and exploration.
Journal: Science advances
In common: TensorFlow, NumPy, methods / tools
[4] doi:10.1038/s41592-026-03194-8 [code]
Beyond benchmarking: an expert-guided consensus approach to spatially aware clustering.
Journal: Nature methods
In common: TensorFlow, NumPy, methods / tools
[5] doi:10.1371/journal.pone.0354976 [code]
Improved motor imagery BCI performance via task-unaware compression in the BELT Bayesian Edge-Cloud architecture.
Journal: PloS one
In common: TensorFlow, NumPy, methods / tools
[6] doi:10.1016/j.ncrna.2026.06.004 [code]
LncPNdeep: A long non-coding RNA classifier based on large language model with peptide and nucleotide embedding.
Journal: Non-coding RNA research
In common: TensorFlow, NumPy, methods / tools
[7] doi:10.1093/bioinformatics/btag601 [code]
SIMLINK enables accurate variant pathogenicity prediction through modeling the gene-variant-feature association structure.
Journal: Bioinformatics (Oxford, England)
In common: TensorFlow, NumPy, methods / tools
[8] doi:10.1162/imag.a.1301 [code]
MEG-GPT: A transformer-based foundation model for magnetoencephalography data.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: TensorFlow, NumPy, methods / tools
[9] doi:10.1039/d6ra03343a [code]
A benchmark dataset and interpretable deep learning framework for drug-induced developmental neurotoxicity prediction.
Journal: RSC advances
In common: TensorFlow, NumPy, methods / tools
[10] doi:10.1364/boe.600665 [code]
NeuroSeg-MF: robust neuron segmentation in two-photon Ca&lt;sup&gt;2+&lt;/sup&gt; imaging using multi-feature fusion and detection-guided SAM.
Journal: Biomedical optics express
In common: TensorFlow, NumPy, methods / tools

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.