text stringlengths 1 93.6k |
|---|
nodes_list = list(self.node_set)
|
self.max_node = np.max(nodes_list) + 1
|
# self.degree_features = np.eye(self.max_node)[nodes_list]
|
# print("degree_features", degree_features[0:5])
|
self.test_edge_index = np.array(self.test_edge_index).T
|
self.time_stamp = sorted(list(set(self.time_stamp))) # !!! time from 0 to 1
|
self.node_dim = len(self.node_set) # number of nodes 28085
|
self.data_size = 0
|
for s in self.node2hist:
|
hist = self.node2hist[s]
|
hist = sorted(hist,
|
key=lambda x: x[1]) # from past(0) to now(1). This supports the events ranked in time order.
|
self.node2hist[s] = hist
|
self.data_size += len(self.node2hist[s])
|
self.max_nei_len = max(map(lambda x: len(x), self.node2hist.values()))
|
# print('#nodes: {}, #edges: {}, #all time_stamp: {}'.
|
# format(self.node_dim, len(self.edge_list), len(self.time_stamp)))
|
# print('avg. degree: {}'.format(sum(self.degrees.values()) / len(self.degrees)))
|
# print('max neighbors length: {}'.format(self.max_nei_len))
|
self.idx2source_id = np.zeros((self.data_size,), dtype=np.int32)
|
self.idx2target_id = np.zeros((self.data_size,), dtype=np.int32)
|
idx = 0
|
for s_node in self.node2hist:
|
for t_idx in range(len(self.node2hist[
|
s_node])): # Note the range here, which means from 0 to the number of historical neighbors
|
self.idx2source_id[
|
idx] = s_node
|
self.idx2target_id[
|
idx] = t_idx
|
idx += 1
|
print('init. neg_table...')
|
self.neg_table = np.zeros((self.neg_table_size,))
|
self.init_neg_table()
|
self.node_features = torch.load(node_feature_path).numpy()
|
self.node_features = preprocessing.StandardScaler().fit_transform(self.node_features)
|
def get_node_dim(self):
|
return self.node_dim
|
def get_max_d_time(self):
|
return self.max_d_time
|
def init_neg_table(self):
|
tot_sum, cur_sum, por = 0., 0., 0.
|
n_id = 0
|
for k in range(self.node_dim):
|
tot_sum += np.power(self.degrees[k],
|
self.NEG_SAMPLING_POWER) # total number of negtive sampling += (node degree of node i)^0.75
|
for k in range(self.neg_table_size):
|
if (k + 1.) / self.neg_table_size > por:
|
cur_sum += np.power(self.degrees[n_id], self.NEG_SAMPLING_POWER)
|
por = cur_sum / tot_sum
|
n_id += 1
|
self.neg_table[k] = n_id - 1 # negtive table size = 1e8, element inside range from 1~number of total nodes
|
def __len__(self):
|
return len(self.test_edge_index.T)
|
def __getitem__(self, idx):
|
# sampling via htne
|
s_node = self.test_edge_index[:, idx][0]
|
t_node = self.test_edge_index[:, idx][1]
|
e_time = 1.0
|
if len(self.node2hist[s_node]) == 0:
|
s_his_nodes = np.array(s_node).repeat(self.hist_len)
|
s_his_times = np.array(e_time).repeat(self.hist_len)
|
else:
|
if len(self.node2hist[s_node]) < self.hist_len:
|
s_nei_idx = np.random.choice(len(self.node2hist[s_node]), self.hist_len, replace=True)
|
else:
|
s_nei_idx = np.random.choice(len(self.node2hist[s_node]), self.hist_len, replace=False)
|
s_his = [(self.node2hist[s_node])[i] for i in s_nei_idx]
|
s_his_nodes = [h[0] for h in s_his]
|
s_his_times = np.array([h[1] for h in s_his])
|
if len(self.node2hist[t_node]) == 0:
|
t_his_nodes = np.array(t_node).repeat(self.hist_len)
|
t_his_times = np.array(e_time).repeat(self.hist_len)
|
else:
|
if len(self.node2hist[t_node]) < self.hist_len:
|
t_nei_idx = np.random.choice(len(self.node2hist[t_node]), self.hist_len, replace=True)
|
else:
|
t_nei_idx = np.random.choice(len(self.node2hist[t_node]), self.hist_len, replace=False)
|
t_his = [(self.node2hist[t_node])[i] for i in t_nei_idx]
|
t_his_nodes = [h[0] for h in t_his]
|
t_his_times = np.array([h[1] for h in t_his])
|
s_his_tidx_list = []
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.