Updates README file to include nx-cugraph user documentation, adds nx…

…-cugraph to main README (#3984)

* Updates the nx-cugraph README file to include nx-cugraph user documentation
* Adds nx-cugraph and new News section to main README
* Updates software strack diagram to remove DGL and PyG since they are not currently using PropertyGraph or cugraph-service

Authors:
   - Rick Ratzel (https://github.com/rlratzel)
   - Ralph Liu (https://github.com/nv-rliu)

Approvers:
   - Brad Rees (https://github.com/BradReesWork)

README.md

@@ -35,8 +35,18 @@
 </div>
 
 -----
+## News
 
-## Table of content
+___NEW!___   _[nx-cugraph](./python/nx-cugraph/README.md)_, a NetworkX backend that provides GPU acceleration to NetworkX with zero code change.
+```
+> pip install nx-cugraph-cu11 --extra-index-url https://pypi.nvidia.com
+> export NETWORKX_AUTOMATIC_BACKENDS=cugraph
+```
+That's it.  NetworkX now leverages cuGraph for accelerated graph algorithms.
+
+-----
+
+## Table of contents
 - Installation
   - [Getting cuGraph Packages](./docs/cugraph/source/installation/getting_cugraph.md)
   - [Building from Source](./docs/cugraph/source/installation/source_build.md)
@@ -52,6 +62,7 @@
     - [External Data Types](./readme_pages/data_types.md)
   - [pylibcugraph](./readme_pages/pylibcugraph.md)
   - [libcugraph (C/C++/CUDA)](./readme_pages/libcugraph.md)
+  - [nx-cugraph](./python/nx-cugraph/README.md)
   - [cugraph-service](./readme_pages/cugraph_service.md)
   - [cugraph-dgl](./readme_pages/cugraph_dgl.md)
   - [cugraph-ops](./readme_pages/cugraph_ops.md)
@@ -116,6 +127,7 @@ df_page.sort_values('pagerank', ascending=False).head(10)
 * ArangoDB - a free and open-source native multi-model database system  - https://www.arangodb.com/
 * CuPy - "NumPy/SciPy-compatible Array Library for GPU-accelerated Computing with Python" -  https://cupy.dev/
 * Memgraph - In-memory Graph database - https://memgraph.com/
+* NetworkX (via [nx-cugraph](./python/nx-cugraph/README.md) backend) - an extremely popular, free and open-source package for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks - https://networkx.org/
 * PyGraphistry - free and open-source GPU graph ETL, AI, and visualization, including native RAPIDS & cuGraph support - http://github.com/graphistry/pygraphistry
 * ScanPy - a scalable toolkit for analyzing single-cell gene expression data - https://scanpy.readthedocs.io/en/stable/
 

python/nx-cugraph/README.md

@@ -2,31 +2,134 @@
 
 ## Description
 [RAPIDS](https://rapids.ai) nx-cugraph is a [backend to NetworkX](https://networkx.org/documentation/stable/reference/classes/index.html#backends)
-with minimal dependencies (`networkx`, `cupy`, and `pylibcugraph`) to run graph algorithms on the GPU.
+to run supported algorithms with GPU acceleration.
 
-### Contribute
+## System Requirements
 
-Follow instructions for [contributing to cugraph](https://github.com/rapidsai/cugraph/blob/branch-23.12
-and [building from source](https://docs.rapids.ai/api/cugraph/stable/installation/source_build/), then build nx-cugraph in develop (i.e., editable) mode:
-```
-$ ./build.sh nx-cugraph --pydevelop
-```
+nx-cugraph requires the following:
+
+ * NVIDIA GPU, Pascal architecture or later
+ * CUDA 11.2, 11.4, 11.5, 11.8, or 12.0
+ * Python versions 3.9, 3.10, or 3.11
+ * NetworkX >= version 3.2
 
-### Run tests
+More details about system requirements can be found in the [RAPIDS System Requirements documentation](https://docs.rapids.ai/install#system-req)..
 
-Run nx-cugraph tests from `cugraph/python/nx-cugraph` directory:
+## Installation
+
+nx-cugraph can be installed using either conda or pip.
+
+### conda
 ```
-$ pytest
+conda install -c rapidsai-nightly -c conda-forge -c nvidia nx-cugraph
 ```
-Run nx-cugraph benchmarks:
+### pip
 ```
-$ pytest --bench
+python -m pip install nx-cugraph-cu11 --extra-index-url https://pypi.nvidia.com
 ```
-Run networkx tests (requires networkx version 3.2):
+Notes:
+
+ * Nightly wheel builds will not be available until the 23.12 release, therefore the index URL for the stable release version is being used in the pip install command above.
+ * Additional information relevant to installing any RAPIDS package can be found [here](https://rapids.ai/#quick-start).
+
+## Enabling nx-cugraph
+
+NetworkX will use nx-cugraph as the graph analytics backend if any of the
+following are are used:
+
+### `NETWORKX_AUTOMATIC_BACKENDS` environment variable.
+The `NETWORKX_AUTOMATIC_BACKENDS` environment variable can be used to have NetworkX automatically dispatch to specified backends an API is called that the backend supports.
+Set `NETWORKX_AUTOMATIC_BACKENDS=cugraph` to use nx-cugraph to GPU accelerate supported APIs with no code changes.
+Example:
 ```
-$ ./run_nx_tests.sh
+bash> NETWORKX_AUTOMATIC_BACKENDS=cugraph python my_networkx_script.py
 ```
-Additional arguments may be passed to pytest such as:
+
+### `backend=` keyword argument
+To explicitly specify a particular backend for an API, use the `backend=`
+keyword argument. This argument takes precedence over the
+`NETWORKX_AUTOMATIC_BACKENDS` environment variable. This requires anyone
+running code that uses the `backend=` keyword argument to have the specified
+backend installed.
+
+Example:
 ```
-$ ./run_nx_tests.sh -x --sw -k betweenness
+nx.betweenness_centrality(cit_patents_graph, k=k, backend="cugraph")
 ```
+
+### Type-based dispatching
+
+NetworkX also supports automatically dispatching to backends associated with
+specific graph types. Like the `backend=` keyword argument example above, this
+requires the user to write code for a specific backend, and therefore requires
+the backend to be installed, but has the advantage of ensuring a particular
+behavior without the potential for runtime conversions.
+
+To use type-based dispatching with nx-cugraph, the user must import the backend
+directly in their code to access the utilities provided to create a Graph
+instance specifically for the nx-cugraph backend.
+
+Example:
+```
+import networkx as nx
+import nx_cugraph as nxcg
+
+G = nx.Graph()
+...
+nxcg_G = nxcg.from_networkx(G)             # conversion happens once here
+nx.betweenness_centrality(nxcg_G, k=1000)  # nxcg Graph type causes cugraph backend
+                                           # to be used, no conversion necessary
+```
+
+## Supported Algorithms
+
+The nx-cugraph backend to NetworkX connects
+[pylibcugraph](../../readme_pages/pylibcugraph.md) (cuGraph's low-level python
+interface to its CUDA-based graph analytics library) and
+[CuPy](https://cupy.dev/) (a GPU-accelerated array library) to NetworkX's
+familiar and easy-to-use API.
+
+Below is the list of algorithms (many listed using pylibcugraph names),
+available today in pylibcugraph or implemented using CuPy, that are or will be
+supported in nx-cugraph.
+
+| feature/algo | release/target version |
+| ----- | ----- |
+| analyze_clustering_edge_cut | ? |
+| analyze_clustering_modularity | ? |
+| analyze_clustering_ratio_cut | ? |
+| balanced_cut_clustering | ? |
+| betweenness_centrality | 23.10 |
+| bfs | ? |
+| core_number | ? |
+| degree_centrality | 23.12 |
+| ecg | ? |
+| edge_betweenness_centrality | 23.10 |
+| ego_graph | ? |
+| eigenvector_centrality | 23.12 |
+| get_two_hop_neighbors | ? |
+| hits | 23.12 |
+| in_degree_centrality | 23.12 |
+| induced_subgraph | ? |
+| jaccard_coefficients | ? |
+| katz_centrality | 23.12 |
+| k_core | ? |
+| k_truss_subgraph | 23.12 |
+| leiden | ? |
+| louvain | 23.10 |
+| node2vec | ? |
+| out_degree_centrality | 23.12 |
+| overlap_coefficients | ? |
+| pagerank | 23.12 |
+| personalized_pagerank | ? |
+| sorensen_coefficients | ? |
+| spectral_modularity_maximization | ? |
+| sssp | 23.12 |
+| strongly_connected_components | ? |
+| triangle_count | ? |
+| uniform_neighbor_sample | ? |
+| uniform_random_walks | ? |
+| weakly_connected_components | ? |
+
+To request nx-cugraph backend support for a NetworkX API that is not listed
+above, visit the [cuGraph GitHub repo](https://github.com/rapidsai/cugraph).