change np.long to np.longlong to support numpy with newer version

Author: yule-BUAA

README.md

@@ -4,7 +4,7 @@
 ## Overview
 Dynamic Graph Library (DyGLib) is an open-source toolkit with standard training pipelines, extensible coding interfaces, and comprehensive evaluating strategies, 
 which aims to promote standard, scalable, and reproducible dynamic graph learning research. Diverse benchmark datasets and thorough baselines are involved in DyGLib.
-![](figures/CTDyGLib_procedure.jpg)
+![](figures/DyGLib_procedure.jpg)
 
 
 ## Benchmark Datasets and Preprocessing

figures/CTDyGLib_procedure.jpg figures/DyGLib_procedure.jpg

@@ -142,7 +142,7 @@ def convert_format_from_tree_to_array(self, node_ids: np.ndarray, node_interact_
         # add the target node to the list to generate random walks in array-like format
         nodes_neighbor_ids = [node_ids[:, np.newaxis]] + nodes_neighbor_ids
         # follow the CAWN official implementation, the edge ids of the target node is denoted by zeros
-        nodes_edge_ids = [np.zeros((len(node_ids), 1)).astype(np.long)] + nodes_edge_ids
+        nodes_edge_ids = [np.zeros((len(node_ids), 1)).astype(np.longlong)] + nodes_edge_ids
         nodes_neighbor_times = [node_interact_times[:, np.newaxis]] + nodes_neighbor_times
 
         array_format_data_list = []

models/CAWN.py

@@ -227,8 +227,8 @@ def pad_sequences(self, node_ids: np.ndarray, node_interact_times: np.ndarray, n
 
         # pad the sequences
         # three ndarrays with shape (batch_size, max_seq_length)
-        padded_nodes_neighbor_ids = np.zeros((len(node_ids), max_seq_length)).astype(np.long)
-        padded_nodes_edge_ids = np.zeros((len(node_ids), max_seq_length)).astype(np.long)
+        padded_nodes_neighbor_ids = np.zeros((len(node_ids), max_seq_length)).astype(np.longlong)
+        padded_nodes_edge_ids = np.zeros((len(node_ids), max_seq_length)).astype(np.longlong)
         padded_nodes_neighbor_times = np.zeros((len(node_ids), max_seq_length)).astype(np.float32)
 
         for idx in range(len(node_ids)):

models/DyGFormer.py

@@ -84,14 +84,14 @@ def compute_src_dst_node_temporal_embeddings(self, src_node_ids: np.ndarray, dst
         # src_neighbor_node_ids, ndarray, shape (batch_size, num_neighbors + 1)
         src_neighbor_node_ids = np.concatenate((src_node_ids[:, np.newaxis], src_neighbor_node_ids), axis=1)
         # src_neighbor_edge_ids, ndarray, shape (batch_size, num_neighbors + 1)
-        src_neighbor_edge_ids = np.concatenate((np.zeros((len(src_node_ids), 1)).astype(np.long), src_neighbor_edge_ids), axis=1)
+        src_neighbor_edge_ids = np.concatenate((np.zeros((len(src_node_ids), 1)).astype(np.longlong), src_neighbor_edge_ids), axis=1)
         # src_neighbor_times, ndarray, shape (batch_size, num_neighbors + 1)
         src_neighbor_times = np.concatenate((node_interact_times[:, np.newaxis], src_neighbor_times), axis=1)
 
         # dst_neighbor_node_ids, ndarray, shape (batch_size, num_neighbors + 1)
         dst_neighbor_node_ids = np.concatenate((dst_node_ids[:, np.newaxis], dst_neighbor_node_ids), axis=1)
         # dst_neighbor_edge_ids, ndarray, shape (batch_size, num_neighbors + 1)
-        dst_neighbor_edge_ids = np.concatenate((np.zeros((len(dst_node_ids), 1)).astype(np.long), dst_neighbor_edge_ids), axis=1)
+        dst_neighbor_edge_ids = np.concatenate((np.zeros((len(dst_node_ids), 1)).astype(np.longlong), dst_neighbor_edge_ids), axis=1)
         # dst_neighbor_times, ndarray, shape (batch_size, num_neighbors + 1)
         dst_neighbor_times = np.concatenate((node_interact_times[:, np.newaxis], dst_neighbor_times), axis=1)
 

models/TCL.py

@@ -94,10 +94,10 @@ def get_link_prediction_data(dataset_name: str, val_ratio: float, test_ratio: fl
     # get the timestamp of validate and test set
     val_time, test_time = list(np.quantile(graph_df.ts, [(1 - val_ratio - test_ratio), (1 - test_ratio)]))
 
-    src_node_ids = graph_df.u.values.astype(np.long)
-    dst_node_ids = graph_df.i.values.astype(np.long)
+    src_node_ids = graph_df.u.values.astype(np.longlong)
+    dst_node_ids = graph_df.i.values.astype(np.longlong)
     node_interact_times = graph_df.ts.values.astype(np.float64)
-    edge_ids = graph_df.idx.values.astype(np.long)
+    edge_ids = graph_df.idx.values.astype(np.longlong)
     labels = graph_df.label.values
 
     full_data = Data(src_node_ids=src_node_ids, dst_node_ids=dst_node_ids, node_interact_times=node_interact_times, edge_ids=edge_ids, labels=labels)
@@ -204,10 +204,10 @@ def get_node_classification_data(dataset_name: str, val_ratio: float, test_ratio
     # get the timestamp of validate and test set
     val_time, test_time = list(np.quantile(graph_df.ts, [(1 - val_ratio - test_ratio), (1 - test_ratio)]))
 
-    src_node_ids = graph_df.u.values.astype(np.long)
-    dst_node_ids = graph_df.i.values.astype(np.long)
+    src_node_ids = graph_df.u.values.astype(np.longlong)
+    dst_node_ids = graph_df.i.values.astype(np.longlong)
     node_interact_times = graph_df.ts.values.astype(np.float64)
-    edge_ids = graph_df.idx.values.astype(np.long)
+    edge_ids = graph_df.idx.values.astype(np.longlong)
     labels = graph_df.label.values
 
     # The setting of seed follows previous works

utils/DataLoader.py

@@ -157,10 +157,10 @@ def get_historical_neighbors(self, node_ids: np.ndarray, node_interact_times: np
         # All interactions described in the following three matrices are sorted in each row by time
         # each entry in position (i,j) represents the id of the j-th dst node of src node node_ids[i] with an interaction before node_interact_times[i]
         # ndarray, shape (batch_size, num_neighbors)
-        nodes_neighbor_ids = np.zeros((len(node_ids), num_neighbors)).astype(np.long)
+        nodes_neighbor_ids = np.zeros((len(node_ids), num_neighbors)).astype(np.longlong)
         # each entry in position (i,j) represents the id of the edge with src node node_ids[i] and dst node nodes_neighbor_ids[i][j] with an interaction before node_interact_times[i]
         # ndarray, shape (batch_size, num_neighbors)
-        nodes_edge_ids = np.zeros((len(node_ids), num_neighbors)).astype(np.long)
+        nodes_edge_ids = np.zeros((len(node_ids), num_neighbors)).astype(np.longlong)
         # each entry in position (i,j) represents the interaction time between src node node_ids[i] and dst node nodes_neighbor_ids[i][j], before node_interact_times[i]
         # ndarray, shape (batch_size, num_neighbors)
         nodes_neighbor_times = np.zeros((len(node_ids), num_neighbors)).astype(np.float32)
@@ -444,7 +444,7 @@ def historical_sample(self, size: int, batch_src_node_ids: np.ndarray, batch_dst
 
         # Note that if one of the input of np.concatenate is empty, the output will be composed of floats.
         # Hence, convert the type to long to guarantee valid index
-        return negative_src_node_ids.astype(np.long), negative_dst_node_ids.astype(np.long)
+        return negative_src_node_ids.astype(np.longlong), negative_dst_node_ids.astype(np.longlong)
 
     def inductive_sample(self, size: int, batch_src_node_ids: np.ndarray, batch_dst_node_ids: np.ndarray,
                          current_batch_start_time: float, current_batch_end_time: float):
@@ -484,7 +484,7 @@ def inductive_sample(self, size: int, batch_src_node_ids: np.ndarray, batch_dst_
 
         # Note that if one of the input of np.concatenate is empty, the output will be composed of floats.
         # Hence, convert the type to long to guarantee valid index
-        return negative_src_node_ids.astype(np.long), negative_dst_node_ids.astype(np.long)
+        return negative_src_node_ids.astype(np.longlong), negative_dst_node_ids.astype(np.longlong)
 
     def reset_random_state(self):
         """