Forward-merge branch-23.08 to branch-23.10

python/cugraph-pyg/cugraph_pyg/loader/cugraph_node_loader.py

@@ -154,13 +154,23 @@ def __init__(
         if isinstance(num_neighbors, dict):
             raise ValueError("num_neighbors dict is currently unsupported!")
 
+        renumber = (
+            True
+            if (
+                (len(self.__graph_store.node_types) == 1)
+                and (len(self.__graph_store.edge_types) == 1)
+            )
+            else False
+        )
+
         bulk_sampler = BulkSampler(
             batch_size,
             self.__directory.name,
             self.__graph_store._subgraph(edge_types),
             fanout_vals=num_neighbors,
             with_replacement=replace,
             batches_per_partition=self.__batches_per_partition,
+            renumber=renumber,
             **kwargs,
         )
 
@@ -223,7 +233,8 @@ def __next__(self):
             if m is None:
                 raise ValueError(f"Invalid parquet filename {fname}")
 
-            self.__next_batch, end_inclusive = [int(g) for g in m.groups()]
+            self.__start_inclusive, end_inclusive = [int(g) for g in m.groups()]
+            self.__next_batch = self.__start_inclusive
             self.__end_exclusive = end_inclusive + 1
 
             parquet_path = os.path.join(
@@ -239,14 +250,31 @@ def __next__(self):
                 "batch_id": "int32",
                 "hop_id": "int32",
             }
-            self.__data = cudf.read_parquet(parquet_path)
-            self.__data = self.__data[list(columns.keys())].astype(columns)
+
+            raw_sample_data = cudf.read_parquet(parquet_path)
+            if "map" in raw_sample_data.columns:
+                self.__renumber_map = raw_sample_data["map"]
+                raw_sample_data.drop("map", axis=1, inplace=True)
+            else:
+                self.__renumber_map = None
+
+            self.__data = raw_sample_data[list(columns.keys())].astype(columns)
+            self.__data.dropna(inplace=True)
 
         # Pull the next set of sampling results out of the dataframe in memory
         f = self.__data["batch_id"] == self.__next_batch
+        if self.__renumber_map is not None:
+            i = self.__next_batch - self.__start_inclusive
+            ix = self.__renumber_map.iloc[[i, i + 1]]
+            ix_start, ix_end = ix.iloc[0], ix.iloc[1]
+            current_renumber_map = self.__renumber_map.iloc[ix_start:ix_end]
+            if len(current_renumber_map) != ix_end - ix_start:
+                raise ValueError("invalid renumber map")
+        else:
+            current_renumber_map = None
 
         sampler_output = _sampler_output_from_sampling_results(
-            self.__data[f], self.__graph_store
+            self.__data[f], current_renumber_map, self.__graph_store
         )
 
         # Get ready for next iteration

python/cugraph-pyg/cugraph_pyg/sampler/cugraph_sampler.py

@@ -85,6 +85,7 @@ def _count_unique_nodes(
 
 def _sampler_output_from_sampling_results(
     sampling_results: cudf.DataFrame,
+    renumber_map: cudf.Series,
     graph_store: CuGraphStore,
     metadata: Sequence = None,
 ) -> HeteroSamplerOutput:
@@ -93,6 +94,9 @@ def _sampler_output_from_sampling_results(
     ----------
     sampling_results: cudf.DataFrame
         The dataframe containing sampling results.
+    renumber_map: cudf.Series
+        The series containing the renumber map, or None if there
+        is no renumber map.
     graph_store: CuGraphStore
         The graph store containing the structure of the sampled graph.
     metadata: Tensor
@@ -129,39 +133,69 @@ def _sampler_output_from_sampling_results(
             )
             num_nodes_per_hop_dict[node_type][0] = num_unique_nodes
 
-    # Calculate nodes of interest based on unique nodes in order of appearance
-    # Use hop 0 sources since those are the only ones not included in destinations
-    # Use torch.concat based on benchmark performance (vs. cudf.concat)
-    nodes_of_interest = (
-        cudf.Series(
-            torch.concat(
-                [
-                    torch.as_tensor(
-                        sampling_results_hop_0.sources.values, device="cuda"
-                    ),
-                    torch.as_tensor(
-                        sampling_results.destinations.values, device="cuda"
-                    ),
-                ]
+    if renumber_map is not None:
+        if len(graph_store.node_types) > 1 or len(graph_store.edge_types) > 1:
+            raise ValueError(
+                "Precomputing the renumber map is currently "
+                "unsupported for heterogeneous graphs."
+            )
+
+        node_type = graph_store.node_types[0]
+        if not isinstance(node_type, str):
+            raise ValueError("Node types must be strings")
+        noi_index = {node_type: torch.as_tensor(renumber_map.values, device="cuda")}
+
+        edge_type = graph_store.edge_types[0]
+        if (
+            not isinstance(edge_type, tuple)
+            or not isinstance(edge_type[0], str)
+            or len(edge_type) != 3
+        ):
+            raise ValueError("Edge types must be 3-tuples of strings")
+        if edge_type[0] != node_type or edge_type[2] != node_type:
+            raise ValueError("Edge src/dst type must match for homogeneous graphs")
+        row_dict = {
+            edge_type: torch.as_tensor(sampling_results.sources.values, device="cuda"),
+        }
+        col_dict = {
+            edge_type: torch.as_tensor(
+                sampling_results.destinations.values, device="cuda"
             ),
-            name="nodes_of_interest",
+        }
+    else:
+        # Calculate nodes of interest based on unique nodes in order of appearance
+        # Use hop 0 sources since those are the only ones not included in destinations
+        # Use torch.concat based on benchmark performance (vs. cudf.concat)
+        nodes_of_interest = (
+            cudf.Series(
+                torch.concat(
+                    [
+                        torch.as_tensor(
+                            sampling_results_hop_0.sources.values, device="cuda"
+                        ),
+                        torch.as_tensor(
+                            sampling_results.destinations.values, device="cuda"
+                        ),
+                    ]
+                ),
+                name="nodes_of_interest",
+            )
+            .drop_duplicates()
+            .sort_index()
         )
-        .drop_duplicates()
-        .sort_index()
-    )
-    del sampling_results_hop_0
+        del sampling_results_hop_0
 
-    # Get the grouped node index (for creating the renumbered grouped edge index)
-    noi_index = graph_store._get_vertex_groups_from_sample(
-        torch.as_tensor(nodes_of_interest.values, device="cuda")
-    )
-    del nodes_of_interest
+        # Get the grouped node index (for creating the renumbered grouped edge index)
+        noi_index = graph_store._get_vertex_groups_from_sample(
+            torch.as_tensor(nodes_of_interest.values, device="cuda")
+        )
+        del nodes_of_interest
 
-    # Get the new edge index (by type as expected for HeteroData)
-    # FIXME handle edge ids/types after the C++ updates
-    row_dict, col_dict = graph_store._get_renumbered_edge_groups_from_sample(
-        sampling_results, noi_index
-    )
+        # Get the new edge index (by type as expected for HeteroData)
+        # FIXME handle edge ids/types after the C++ updates
+        row_dict, col_dict = graph_store._get_renumbered_edge_groups_from_sample(
+            sampling_results, noi_index
+        )
 
     for hop in range(len(hops)):
         hop_ix_start = hops[hop]

python/cugraph-pyg/cugraph_pyg/tests/mg/test_mg_cugraph_sampler.py

@@ -43,13 +43,15 @@ def test_neighbor_sample(dask_client, basic_graph_1):
             batch_id_list=cudf.Series(cupy.zeros(5, dtype="int32")),
             random_state=62,
             return_offsets=False,
+            return_hops=True,
         )
-        .sort_values(by=["sources", "destinations"])
         .compute()
+        .sort_values(by=["sources", "destinations"])
     )
 
     out = _sampler_output_from_sampling_results(
         sampling_results=sampling_results,
+        renumber_map=None,
         graph_store=cugraph_store,
         metadata=torch.arange(6, dtype=torch.int64),
     )
@@ -83,6 +85,7 @@ def test_neighbor_sample(dask_client, basic_graph_1):
 
 @pytest.mark.cugraph_ops
 @pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not available")
+@pytest.mark.skip(reason="broken")
 def test_neighbor_sample_multi_vertex(dask_client, multi_edge_multi_vertex_graph_1):
     F, G, N = multi_edge_multi_vertex_graph_1
     cugraph_store = CuGraphStore(F, G, N, multi_gpu=True)
@@ -104,6 +107,7 @@ def test_neighbor_sample_multi_vertex(dask_client, multi_edge_multi_vertex_graph
 
     out = _sampler_output_from_sampling_results(
         sampling_results=sampling_results,
+        renumber_map=None,
         graph_store=cugraph_store,
         metadata=torch.arange(6, dtype=torch.int64),
     )
@@ -181,7 +185,7 @@ def test_neighbor_sample_mock_sampling_results(dask_client):
     )
 
     out = _sampler_output_from_sampling_results(
-        mock_sampling_results, graph_store, None
+        mock_sampling_results, None, graph_store, None
     )
 
     assert out.metadata is None
@@ -208,3 +212,9 @@ def test_neighbor_sample_mock_sampling_results(dask_client):
     assert out.num_sampled_edges[("A", "ab", "B")].tolist() == [3, 0, 1, 0]
     assert out.num_sampled_edges[("B", "ba", "A")].tolist() == [0, 1, 0, 1]
     assert out.num_sampled_edges[("B", "bc", "C")].tolist() == [0, 2, 0, 2]
+
+
+@pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not available")
+@pytest.mark.skip("needs to be written")
+def test_neighbor_sample_renumbered(dask_client):
+    pass

python/cugraph-pyg/cugraph_pyg/tests/test_cugraph_loader.py

@@ -163,3 +163,59 @@ def test_cugraph_loader_from_disk_subset():
         assert list(sample[("t0", "knows", "t0")]["edge_index"].shape) == [2, 7]
 
     assert num_samples == 100
+
+
+@pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not available")
+def test_cugraph_loader_from_disk_subset_renumbered():
+    F = FeatureStore()
+    F.add_data(torch.tensor([1, 2, 3, 4, 5, 6, 7]), "t0", "x")
+
+    G = {("t0", "knows", "t0"): 7}
+    N = {"t0": 7}
+
+    cugraph_store = CuGraphStore(F, G, N)
+
+    bogus_samples = cudf.DataFrame(
+        {
+            "sources": [0, 1, 2, 3, 4, 5, 6],
+            "destinations": [6, 4, 3, 2, 2, 1, 5],
+            "edge_type": cudf.Series([0, 0, 0, 0, 0, 0, 0], dtype="int32"),
+            "edge_id": [5, 10, 15, 20, 25, 30, 35],
+            "hop_id": cudf.Series([0, 0, 0, 1, 1, 2, 2], dtype="int32"),
+        }
+    )
+
+    map = cudf.Series([2, 9, 0, 2, 1, 3, 4, 6, 5], name="map")
+    bogus_samples = bogus_samples.join(map, how="outer").sort_index()
+
+    tempdir = tempfile.TemporaryDirectory()
+    for s in range(256):
+        bogus_samples["batch_id"] = cupy.int32(s)
+        bogus_samples.to_parquet(os.path.join(tempdir.name, f"batch={s}-{s}.parquet"))
+
+    loader = BulkSampleLoader(
+        feature_store=cugraph_store,
+        graph_store=cugraph_store,
+        directory=tempdir,
+        input_files=list(os.listdir(tempdir.name))[100:200],
+    )
+
+    num_samples = 0
+    for sample in loader:
+        num_samples += 1
+        assert sample["t0"]["num_nodes"] == 7
+        # correct vertex order is [0, 2, 1, 3, 4, 6, 5]; x = [1, 3, 2, 4, 5, 7, 6]
+        assert sample["t0"]["x"].tolist() == [1, 3, 2, 4, 5, 7, 6]
+
+        edge_index = sample[("t0", "knows", "t0")]["edge_index"]
+        assert list(edge_index.shape) == [2, 7]
+        assert (
+            edge_index[0].tolist()
+            == bogus_samples.sources.dropna().values_host.tolist()
+        )
+        assert (
+            edge_index[1].tolist()
+            == bogus_samples.destinations.dropna().values_host.tolist()
+        )
+
+    assert num_samples == 100

python/cugraph-pyg/cugraph_pyg/tests/test_cugraph_sampler.py

@@ -44,6 +44,7 @@ def test_neighbor_sample(basic_graph_1):
 
     out = _sampler_output_from_sampling_results(
         sampling_results=sampling_results,
+        renumber_map=None,
         graph_store=cugraph_store,
         metadata=torch.arange(6, dtype=torch.int64),
     )
@@ -94,6 +95,7 @@ def test_neighbor_sample_multi_vertex(multi_edge_multi_vertex_graph_1):
 
     out = _sampler_output_from_sampling_results(
         sampling_results=sampling_results,
+        renumber_map=None,
         graph_store=cugraph_store,
         metadata=torch.arange(6, dtype=torch.int64),
     )
@@ -144,7 +146,7 @@ def test_neighbor_sample_mock_sampling_results(abc_graph):
     )
 
     out = _sampler_output_from_sampling_results(
-        mock_sampling_results, graph_store, None
+        mock_sampling_results, None, graph_store, None
     )
 
     assert out.metadata is None
@@ -171,3 +173,9 @@ def test_neighbor_sample_mock_sampling_results(abc_graph):
     assert out.num_sampled_edges[("A", "ab", "B")].tolist() == [3, 0, 1, 0]
     assert out.num_sampled_edges[("B", "ba", "A")].tolist() == [0, 1, 0, 1]
     assert out.num_sampled_edges[("B", "bc", "C")].tolist() == [0, 2, 0, 2]
+
+
+@pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not available")
+@pytest.mark.skip("needs to be written")
+def test_neighbor_sample_renumbered():
+    pass