From 8035bb5dc64c0183c5baafb37502c63d00e80e08 Mon Sep 17 00:00:00 2001 From: Don Acosta <97529984+acostadon@users.noreply.github.com> Date: Mon, 2 Dec 2024 14:49:39 -0500 Subject: [PATCH 1/2] Notebook to run Centrality against PatentsView data for Medium Blog (#4769) Authors: - Don Acosta (https://github.com/acostadon) Approvers: - Joseph Nke (https://github.com/jnke2016) - Brad Rees (https://github.com/BradReesWork) URL: https://github.com/rapidsai/cugraph/pull/4769 --- notebooks/demo/centrality_patentsview.ipynb | 1852 +++++++++++++++++++ 1 file changed, 1852 insertions(+) create mode 100644 notebooks/demo/centrality_patentsview.ipynb diff --git a/notebooks/demo/centrality_patentsview.ipynb b/notebooks/demo/centrality_patentsview.ipynb new file mode 100644 index 0000000000..be201fc392 --- /dev/null +++ b/notebooks/demo/centrality_patentsview.ipynb @@ -0,0 +1,1852 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "xkg10FrNThrK" + }, + "source": [ + "# Centrality Measures with cuGraph and US Patent Citations.\n", + "This notebook will demonstrate RAPIDS cuGraph to do centrality calculations on US Patent data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mefjUEAnZ4pq" + }, + "source": [ + "# Downloading the data\n", + "\n", + "Citation: U.S. Patent and Trademark Office. “Data Download Tables.” PatentsView. Accessed [10/06/2024]. https://patentsview.org/download/data-download-tables.\n", + "\n", + " Both files are used under the Creative Commons license https://creativecommons.org/licenses/by/4.0/\n", + "\n", + "\n", + "The first file, g_patent.tsv.zip, contains summary data for each patent such as id, title and the location of the original patent document. The table description is available on the [PatentsView site](https://patentsview.org/download/data-download-dictionary).\n", + "\n", + "The second file, g_us_patent_citation.tsv.zip, contains a record for every citation between USPatents. The description of this table is also available on the [PatentsView site](https://patentsview.org/download/data-download-dictionary)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Removing the comment character \"#\" and running the below lines will download and expand the data into the directory the notebook expects it to be in." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "lyYF0LbtFwjh" + }, + "outputs": [], + "source": [ + "#!wget https://s3.amazonaws.com/data.patentsview.org/download/g_patent.tsv.zip\n", + "#!unzip ./g_patent.tsv.zip\n", + "#!wget https://s3.amazonaws.com/data.patentsview.org/download/g_us_patent_citation.tsv.zip\n", + "#!unzip ./g_us_patent_citation.tsv.zip" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# We will create the dataframes using cudf and create the graphs with cuGraph\n", + "import cudf\n", + "import cugraph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This method takes a list of patents and goes out one hop. It returns the new list of all the patents which can\n", + "be used to in the same function to go out an additional hop." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def next_hop(seeds):\n", + " seed_df = seeds.to_frame('seed')\n", + " source_df = citation_df.merge(seed_df, left_on='source', right_on='seed', how='inner')\n", + " target_df = (citation_df.merge(seed_df, left_on='target', right_on='seed', how='inner'))\n", + " links_df = cudf.concat([source_df,target_df])\n", + " links_df = links_df.drop('seed', axis=1)\n", + " new_seed_set = links_df.melt()\n", + " new_seed_set = new_seed_set.drop('variable',axis=1)\n", + " new_seed_set = new_seed_set['value'].drop_duplicates()\n", + " return links_df.drop_duplicates(), new_seed_set" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This function displays the top results of all the centrality algorithms" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Print function\n", + "def print_centrality(k, dc, bc, kr, pr, ev):\n", + "\n", + " dc_top = dc.sort_values(by='degree_centrality', ascending=False).head(k).to_pandas()\n", + " bc_top = bc.sort_values(by='betweenness_centrality', ascending=False).head(k).to_pandas()\n", + " kr_top = kr.sort_values(by='katz_centrality', ascending=False).head(k).to_pandas()\n", + " pr_top = pr.sort_values(by='pagerank', ascending=False).head(k).to_pandas()\n", + " ev_top = ev.sort_values(by='eigenvector_centrality', ascending=False).head(k).to_pandas()\n", + " \n", + " df1_styler = dc_top.style.set_table_attributes(\"style='display:inline'\").set_caption('Degree').hide(axis='index')\n", + " df2_styler = bc_top.style.set_table_attributes(\"style='display:inline'\").set_caption('Betweenness').hide(axis='index')\n", + " df3_styler = kr_top.style.set_table_attributes(\"style='display:inline'\").set_caption('Katz').hide(axis='index')\n", + " df4_styler = pr_top.style.set_table_attributes(\"style='display:inline'\").set_caption('PageRank').hide(axis='index')\n", + " df5_styler = ev_top.style.set_table_attributes(\"style='display:inline'\").set_caption('EigenVector').hide(axis='index')\n", + "\n", + " display_html(df1_styler._repr_html_()+df2_styler._repr_html_()+df3_styler._repr_html_()+df4_styler._repr_html_()+df5_styler._repr_html_(), raw=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After running the centrality algorithms, this function displays the supplied graph. The dataframe from any of the centrality calculations is also supplied along with the number of the highest ranking nodes we want to emphasize with labels and scale with size based on the centrality value." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def draw_centrality_graph(graph_df, number_to_label, cent_df):\n", + " import networkx as nx\n", + " import matplotlib.pyplot as plt\n", + "\n", + " top_ones = cent_df.sort_values(by=cent_df.columns[0], ascending=False).head(number_to_label)[cent_df.columns[1]].to_pandas()\n", + " print(top_ones)\n", + " sizes = []\n", + " nodes = []\n", + "\n", + " plt.rcParams['figure.figsize'] = [12, 8]\n", + " nx_g = nx.from_pandas_edgelist(graph_df.to_pandas())\n", + "\n", + " for node in nx_g.nodes():\n", + " cent_value =cent_df.loc[cent_df['vertex'] == node, cent_df.columns[0]].values[0]\n", + " nodes.append(node)\n", + " sizes.append((cent_value[0]*3000+10).item())\n", + "\n", + " pos = nx.spring_layout(nx_g)\n", + " labels = {node: node for node in top_ones}\n", + " nx.draw(nx_g, pos=pos, nodelist=nodes,font_color='red' ,node_size=sizes,node_color='grey', node_shape='o', linewidths=2, labels=labels)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This function executes the five centrality algorithms." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute Centrality\n", + "# the centrality calls are very straightforward with the graph being the primary argument\n", + "# we are using the default argument values for all centrality functions except where noted.\n", + "\n", + "def compute_centrality(_graph, highest_degree=2000) :\n", + "\n", + " # Compute Degree Centrality\n", + " _d = cugraph.degree_centrality(_graph)\n", + " print(\"Degree Centrality done\")\n", + "\n", + " # Compute the Betweenness Centrality\n", + " # The k value is needed in large graphs as by default, it will calculate the\n", + " # betweenness centrality score based on every possible pairs in the graph.\n", + " # Limiting the number of vertices involved in the shortest path search leads to a better runtime.\n", + " # In this case we limit it to 100 samples at most.\n", + " _b = cugraph.betweenness_centrality(_graph,k=100)\n", + " print(\"Between Centrality done\")\n", + "\n", + " # Compute Katz Centrality\n", + " # alpha is set to one divided by the maximum degree in the graph. This will enable convergence\n", + " # max_iter will determine how many iterations will be run before giving up if convergence doesn't occur\n", + " # tol is the tolerance which determines the maximum difference that indicatates convergence \n", + " _k = cugraph.katz_centrality(_graph, max_iter=1000, tol=1.0e-2,alpha=1/highest_degree)\n", + " print(\"Katz Centrality done\")\n", + "\n", + " # Compute PageRank Centrality\n", + " _p = cugraph.pagerank(_graph)\n", + " print(\"Pagerank done\")\n", + "\n", + " # Compute EigenVector Centrality\n", + " _e = cugraph.eigenvector_centrality(_graph, max_iter=1000, tol=1.0e-3)\n", + " print(\"Eigenvector Centrality done\")\n", + "\n", + " return _d, _b, _k, _p, _e" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we load the entire US patent citation edge list into a cuDF dataframe." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# load the citation graph\n", + "import cudf\n", + "citation_df = cudf.read_csv(\"../data/g_us_patent_citation.tsv\",\n", + " sep='\\t',\n", + " header=0,\n", + " usecols=[0,2],\n", + " names=[\"source\", \"target\"],\n", + " dtype={\"source\":str,\"target\":str},\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sourcetarget
0100000005093563
1100000005751830
2100000017804268
3100000019022767
4100000019090016
\n", + "
" + ], + "text/plain": [ + " source target\n", + "0 10000000 5093563\n", + "1 10000000 5751830\n", + "2 10000001 7804268\n", + "3 10000001 9022767\n", + "4 10000001 9090016" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Display the first five edges in the dataframe.\n", + "citation_df.head(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting dataframe has over 142 million edges" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "142183260" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(citation_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Choose a patent of interest. In this case we will choose a patent representing an advance in visualizing machine learning models. Adding additional patents to the seed list can be done here." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "poi = [\"10810491\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Go out one hop from the patent(s) supplied." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "seed_series=cudf.Series(poi)\n", + "first_hop_df, first_set = next_hop(seed_series)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Show how many patents cite or are cited by the starting one(s)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "32" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(first_hop_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this case we will just use the second hop edge/patent list. However, for demonstation purposes, we show the next_hop function can go out as many hops as necessary to build a relevant graph as needed for different data sets. The code below goes out four levels of separation." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "second_hop_df, second_hop_seeds = next_hop(first_set)\n", + "third_hop_df, third_hop_seeds = next_hop(second_hop_seeds)\n", + "fourth_hop_df, fourth_hop_seeds = next_hop(third_hop_seeds)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These are node (patent) counts at each hop." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(33, 402, 29916, 659475)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(first_set), len(second_hop_seeds),len(third_hop_seeds),len(fourth_hop_seeds)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These are edge(citation) counts at each hop." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(32, 465, 122774, 5177479)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(first_hop_df), len(second_hop_df),len(third_hop_df),len(fourth_hop_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The contents of the dataframe we will use contains 2 hops." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sourcetarget
0108104918234228
1108104916038337
2110864715222210
3110864716049793
4110864717475072
.........
213RE463106038337
214RE480566038337
215RE479086038337
216RE493346038337
217RE493876038337
\n", + "

465 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " source target\n", + "0 10810491 8234228\n", + "1 10810491 6038337\n", + "2 11086471 5222210\n", + "3 11086471 6049793\n", + "4 11086471 7475072\n", + ".. ... ...\n", + "213 RE46310 6038337\n", + "214 RE48056 6038337\n", + "215 RE47908 6038337\n", + "216 RE49334 6038337\n", + "217 RE49387 6038337\n", + "\n", + "[465 rows x 2 columns]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "second_hop_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will build a directed Graph in cuGraph from the second hop dataframe created above" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 92 ms, sys: 24.9 ms, total: 117 ms\n", + "Wall time: 114 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "G = cugraph.from_cudf_edgelist(second_hop_df,create_using=cugraph.Graph(directed=True),source='source', destination='target')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We use the compute_centrality function above to calculate and note the execution time" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Degree Centrality done\n", + "Between Centrality done\n", + "Katz Centrality done\n", + "Pagerank done\n", + "Eigenvector Centrality done\n", + "CPU times: user 115 ms, sys: 24.6 ms, total: 139 ms\n", + "Wall time: 137 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/dacosta/miniforge3/lib/python3.12/site-packages/cugraph/centrality/katz_centrality.py:121: UserWarning: Katz centrality expects the 'store_transposed' flag to be set to 'True' for optimal performance during the graph creation\n", + " warnings.warn(warning_msg, UserWarning)\n", + "/home/dacosta/miniforge3/lib/python3.12/site-packages/cugraph/link_analysis/pagerank.py:227: UserWarning: Pagerank expects the 'store_transposed' flag to be set to 'True' for optimal performance during the graph creation\n", + " warnings.warn(warning_msg, UserWarning)\n", + "/home/dacosta/miniforge3/lib/python3.12/site-packages/cugraph/centrality/eigenvector_centrality.py:88: UserWarning: Eigenvector centrality expects the 'store_transposed' flag to be set to 'True' for optimal performance during the graph creation\n", + " warnings.warn(warning_msg, UserWarning)\n" + ] + } + ], + "source": [ + "%%time\n", + "dc, bc, kc, pr, ev = compute_centrality(G)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We import the formatting package and print out the top 10 patents for each centrality measure" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Degree
degree_centralityvertex
0.3940156038337
0.15212011412041
0.07980110810491
0.06982511977958
0.0548638234228
0.05486311769180
0.05486311682052
0.04987511900046
0.04738211921730
0.03990011960575
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Betweenness
betweenness_centralityvertex
0.0039856038337
0.00105310810491
0.00045111182695
0.0002768234228
0.0000008910022
0.00000010884769
0.0000008311967
0.00000010318474
0.00000010621019
0.0000006760808
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Katz
katz_centralityvertex
0.0537106038337
0.05059410810491
0.0503708234228
0.04999611182695
0.0499219652109
0.04992110706450
0.0499219092802
0.04992110929916
0.04992110402061
0.0499217703036
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PageRank
pagerankvertex
0.1848896038337
0.0537555450504
0.0537555408585
0.0537555497430
0.0288058234228
0.0258547398259
0.01524910810491
0.00835411182695
0.00408611304074
0.00396910379502
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EigenVector
eigenvector_centralityvertex
0.5358825450504
0.5358825408585
0.5358825497430
0.2806926038337
0.1873557398259
0.1389018234228
0.06137510810491
0.01751110379502
0.01751110432689
0.0098619743237
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import display_html\n", + "\n", + "print_centrality(10, dc, bc, kc, pr, ev)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now call the function that draws the graph with the specified number of the most central nodes labeled.\n", + "The final parameter, pr in this case, for PageRank sends in the particular algorithm results to graph." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "306 6038337\n", + "7 5450504\n", + "284 5408585\n", + "355 5497430\n", + "307 8234228\n", + "21 7398259\n", + "320 10810491\n", + "308 11182695\n", + "312 11304074\n", + "256 10379502\n", + "257 10432689\n", + "339 9743237\n", + "Name: vertex, dtype: object\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_centrality_graph(second_hop_df,12, pr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets run edge betweenness centrality to find the central edges in the graph." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
betweenness_centralitysrcdst
1940.00121660383375408585
1950.00121660383375450504
1960.00121660383375497430
2070.000993108104916038337
2080.000509108104918234228
380.00038582342287398259
3070.0003041118269510810491
2910.0001301130407410810491
2030.0000871151436110810491
3010.0000871131496910810491
\n", + "
" + ], + "text/plain": [ + " betweenness_centrality src dst\n", + "194 0.001216 6038337 5408585\n", + "195 0.001216 6038337 5450504\n", + "196 0.001216 6038337 5497430\n", + "207 0.000993 10810491 6038337\n", + "208 0.000509 10810491 8234228\n", + "38 0.000385 8234228 7398259\n", + "307 0.000304 11182695 10810491\n", + "291 0.000130 11304074 10810491\n", + "203 0.000087 11514361 10810491\n", + "301 0.000087 11314969 10810491" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "G_2_hops = cugraph.from_cudf_edgelist(second_hop_df,create_using=cugraph.Graph(directed=True),source='source', destination='target')\n", + "results=cugraph.edge_betweenness_centrality(G_2_hops).sort_values(ascending=False,by=['betweenness_centrality'])\n", + "results.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now load the enrichment data. We are only loading the patent_id and title but other columns are available.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8890049" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "title_df = cudf.read_csv(\"/home/dacosta/data/g_patent.tsv\",\n", + " sep='\\t',\n", + " header=0,\n", + " usecols=[0,3],\n", + " names=[\"patent_id\", \"patent_title\"],\n", + " dtype={\"patent_id\":\"str\",\"patent_title\":str},\n", + ")\n", + "len(title_df)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
betweenness_centralitysrcdst
1940.00121660383375408585
1950.00121660383375450504
1960.00121660383375497430
2080.000993108104916038337
970.000509108104918234228
570.00038582342287398259
2910.0003041118269510810491
3230.0001301130407410810491
2030.0000871151436110810491
3330.0000871131496910810491
\n", + "
" + ], + "text/plain": [ + " betweenness_centrality src dst\n", + "194 0.001216 6038337 5408585\n", + "195 0.001216 6038337 5450504\n", + "196 0.001216 6038337 5497430\n", + "208 0.000993 10810491 6038337\n", + "97 0.000509 10810491 8234228\n", + "57 0.000385 8234228 7398259\n", + "291 0.000304 11182695 10810491\n", + "323 0.000130 11304074 10810491\n", + "203 0.000087 11514361 10810491\n", + "333 0.000087 11314969 10810491" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "G_2_hops = cugraph.from_cudf_edgelist(second_hop_df,create_using=cugraph.Graph(directed=True),source='source', destination='target')\n", + "results=cugraph.edge_betweenness_centrality(G_2_hops).sort_values(ascending=False,by=['betweenness_centrality'])\n", + "results.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Merge the enrichment data with the highest ranking patent ids found above." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['vertex'], dtype='object')\n" + ] + } + ], + "source": [ + "# top number of Patents we are interested in\n", + "k=20\n", + "\n", + "dc_top = dc.sort_values(by='degree_centrality', ascending=False).head(k)\n", + "bc_top = bc.sort_values(by='betweenness_centrality', ascending=False).head(k)\n", + "kr_top = kc.sort_values(by='katz_centrality', ascending=False).head(k)\n", + "pr_top = pr.sort_values(by='pagerank', ascending=False).head(k)\n", + "ev_top = ev.sort_values(by='eigenvector_centrality', ascending=False).head(k)\n", + "\n", + "df_list = [dc_top, bc_top, kr_top, pr_top, ev_top]\n", + "combined = cudf.concat(df_list, axis=0)\n", + "combined = cudf.DataFrame(combined['vertex'])\n", + "print(combined.columns)\n", + "combined = combined.drop_duplicates()\n", + "enriched_df = title_df.merge(combined, left_on='patent_id', right_on='vertex', how='inner')\n", + "enriched_df = enriched_df.drop('vertex', axis=1 )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Display the results of the enriched dataframe. We do this in pandas in order to override the default max column width." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
patent_idpatent_title
010074111Automatically determining a current value for a home
110176435Method and apparatus for combining techniques of calculus, statistics and data normalization in machine learning for analyzing large volumes of data
210228959Virtual network for virtual machine communication and migration
310318474Data storage system with heterogenous parallel processors
410379502Control system with machine learning time-series modeling
510388274Confidence checking for speech processing and query answering
610402061Productivity tools for content authoring
710432689Feature generation for online/offline machine learning
810460012Enhanced document services
910599924Semantic page segmentation of vector graphics documents
1010621019Using a client to manage remote machine learning jobs
1110649619System and method of using context in selecting a response to user device interaction
1210706450Artificial intelligence system for generating intent-aware recommendations
1310810491Real-time visualization of machine learning models
1410884769Photo-editing application recommendations
1510929916Persona based food recommendation systems and methods
1610951485System, method, and computer program for operating a multi-stage artificial intelligence (AI) analysis in a communication network
1710956132Unified code and data management for model development
1811036811Categorical data transformation and clustering for machine learning using data repository systems
1911086471Visualizing neural networks
2011151471Method and apparatus for predictive classification of actionable network alerts
2111182695Method, apparatus, and computer program product for machine learning model lifecycle management
2211304074Systems and methods for orchestration and optimization of wireless networks
2311314969Semantic page segmentation of vector graphics documents
2411347756Deep command search within and across applications
2511392998System and method for collecting and managing property information
2611412041Automatic intervention of global coordinator
2711514361Automated artificial intelligence radial visualization
2811537439Intelligent compute resource selection for machine learning training jobs
2911544604Adaptive model insights visualization engine for complex machine learning models
3011682052Machine learning systems and methods for determining home value
3111694090Debugging deep neural networks
3211710076Method, apparatus, and computer program product for machine learning model lifecycle management
3311769180Machine learning systems and methods for determining home value
3411798167Long-term and continuous animal behavioral monitoring
3511900046Intelligent feature identification and presentation
3611907191Content based log retrieval by using embedding feature extraction
3711921730Deep command search within and across applications
3811941519Machine learning training platform
3911960575Data processing for machine learning using a graphical user interface
4011977958Network-accessible machine learning model training and hosting system
415408585Internal connection method for neural networks
425450504Method for finding a most likely matching of a target facial image in a data base of facial images
435497430Method and apparatus for image recognition using invariant feature signals
446038337Method and apparatus for object recognition
456058454Method and system for automatically configuring redundant arrays of disk memory devices
466356949Automatic data collection device that receives data output instruction from data consumer
476760808Computer system and process for transferring multiple high bandwidth streams of data between multiple storage units and multiple applications in a scalable and reliable manner
487398259Training of a physical neural network
497415356Techniques for accurately synchronizing portions of an aerial image with composited visual information
507703036User interface for displaying selectable software functionality controls that are relevant to a selected object
518234228Method for training a learning machine having a deep multi-layered network with labeled and unlabeled training data
528290939Visualizing query results in stream processing systems
538311967Predictive analytical model matching
548910022Retrieval of encoded data slices and encoded instruction slices by a computing device
558948171System and method for IP multicast
569092802Statistical machine learning and business process models systems and methods
579483742Intelligent traffic analysis to detect malicious activity
589652109Predictive contextual toolbar for productivity applications
599743237Method and apparatus for predicting mobility based on relative mobile characteristics
\n", + "
" + ], + "text/plain": [ + " patent_id \\\n", + "0 10074111 \n", + "1 10176435 \n", + "2 10228959 \n", + "3 10318474 \n", + "4 10379502 \n", + "5 10388274 \n", + "6 10402061 \n", + "7 10432689 \n", + "8 10460012 \n", + "9 10599924 \n", + "10 10621019 \n", + "11 10649619 \n", + "12 10706450 \n", + "13 10810491 \n", + "14 10884769 \n", + "15 10929916 \n", + "16 10951485 \n", + "17 10956132 \n", + "18 11036811 \n", + "19 11086471 \n", + "20 11151471 \n", + "21 11182695 \n", + "22 11304074 \n", + "23 11314969 \n", + "24 11347756 \n", + "25 11392998 \n", + "26 11412041 \n", + "27 11514361 \n", + "28 11537439 \n", + "29 11544604 \n", + "30 11682052 \n", + "31 11694090 \n", + "32 11710076 \n", + "33 11769180 \n", + "34 11798167 \n", + "35 11900046 \n", + "36 11907191 \n", + "37 11921730 \n", + "38 11941519 \n", + "39 11960575 \n", + "40 11977958 \n", + "41 5408585 \n", + "42 5450504 \n", + "43 5497430 \n", + "44 6038337 \n", + "45 6058454 \n", + "46 6356949 \n", + "47 6760808 \n", + "48 7398259 \n", + "49 7415356 \n", + "50 7703036 \n", + "51 8234228 \n", + "52 8290939 \n", + "53 8311967 \n", + "54 8910022 \n", + "55 8948171 \n", + "56 9092802 \n", + "57 9483742 \n", + "58 9652109 \n", + "59 9743237 \n", + "\n", + " patent_title \n", + "0 Automatically determining a current value for a home \n", + "1 Method and apparatus for combining techniques of calculus, statistics and data normalization in machine learning for analyzing large volumes of data \n", + "2 Virtual network for virtual machine communication and migration \n", + "3 Data storage system with heterogenous parallel processors \n", + "4 Control system with machine learning time-series modeling \n", + "5 Confidence checking for speech processing and query answering \n", + "6 Productivity tools for content authoring \n", + "7 Feature generation for online/offline machine learning \n", + "8 Enhanced document services \n", + "9 Semantic page segmentation of vector graphics documents \n", + "10 Using a client to manage remote machine learning jobs \n", + "11 System and method of using context in selecting a response to user device interaction \n", + "12 Artificial intelligence system for generating intent-aware recommendations \n", + "13 Real-time visualization of machine learning models \n", + "14 Photo-editing application recommendations \n", + "15 Persona based food recommendation systems and methods \n", + "16 System, method, and computer program for operating a multi-stage artificial intelligence (AI) analysis in a communication network \n", + "17 Unified code and data management for model development \n", + "18 Categorical data transformation and clustering for machine learning using data repository systems \n", + "19 Visualizing neural networks \n", + "20 Method and apparatus for predictive classification of actionable network alerts \n", + "21 Method, apparatus, and computer program product for machine learning model lifecycle management \n", + "22 Systems and methods for orchestration and optimization of wireless networks \n", + "23 Semantic page segmentation of vector graphics documents \n", + "24 Deep command search within and across applications \n", + "25 System and method for collecting and managing property information \n", + "26 Automatic intervention of global coordinator \n", + "27 Automated artificial intelligence radial visualization \n", + "28 Intelligent compute resource selection for machine learning training jobs \n", + "29 Adaptive model insights visualization engine for complex machine learning models \n", + "30 Machine learning systems and methods for determining home value \n", + "31 Debugging deep neural networks \n", + "32 Method, apparatus, and computer program product for machine learning model lifecycle management \n", + "33 Machine learning systems and methods for determining home value \n", + "34 Long-term and continuous animal behavioral monitoring \n", + "35 Intelligent feature identification and presentation \n", + "36 Content based log retrieval by using embedding feature extraction \n", + "37 Deep command search within and across applications \n", + "38 Machine learning training platform \n", + "39 Data processing for machine learning using a graphical user interface \n", + "40 Network-accessible machine learning model training and hosting system \n", + "41 Internal connection method for neural networks \n", + "42 Method for finding a most likely matching of a target facial image in a data base of facial images \n", + "43 Method and apparatus for image recognition using invariant feature signals \n", + "44 Method and apparatus for object recognition \n", + "45 Method and system for automatically configuring redundant arrays of disk memory devices \n", + "46 Automatic data collection device that receives data output instruction from data consumer \n", + "47 Computer system and process for transferring multiple high bandwidth streams of data between multiple storage units and multiple applications in a scalable and reliable manner \n", + "48 Training of a physical neural network \n", + "49 Techniques for accurately synchronizing portions of an aerial image with composited visual information \n", + "50 User interface for displaying selectable software functionality controls that are relevant to a selected object \n", + "51 Method for training a learning machine having a deep multi-layered network with labeled and unlabeled training data \n", + "52 Visualizing query results in stream processing systems \n", + "53 Predictive analytical model matching \n", + "54 Retrieval of encoded data slices and encoded instruction slices by a computing device \n", + "55 System and method for IP multicast \n", + "56 Statistical machine learning and business process models systems and methods \n", + "57 Intelligent traffic analysis to detect malicious activity \n", + "58 Predictive contextual toolbar for productivity applications \n", + "59 Method and apparatus for predicting mobility based on relative mobile characteristics " + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "pd.set_option('display.max_colwidth', None)\n", + "enriched_df.to_pandas()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "k2DfAaZaDIBj" + }, + "source": [ + "---\n", + "U.S. Patent and Trademark Office. “Data Download Tables.” PatentsView. Accessed [10/06/2024]. https://patentsview.org/ download/data-download-tables.\n", + "\n", + "Data used is Licensed under Creative Commons 4.0 \n", + "https://creativecommons.org/licenses/by/4.0/" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "___\n", + "Copyright (c) 2024, NVIDIA CORPORATION.\n", + "\n", + "Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.\n", + "___" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 94c6ee4804a773a1314e0c7a86d8389fddeafd44 Mon Sep 17 00:00:00 2001 From: James Lamb Date: Mon, 2 Dec 2024 16:36:53 -0600 Subject: [PATCH 2/2] pip devcontainers: use UCX 1.17, prefer system installation (#4792) Contributes to https://github.com/rapidsai/build-planning/issues/118 Proposes the following changes for pip devcontainers: * use UCX 1.17 (ref: https://github.com/rapidsai/cugraph-gnn/pull/79#discussion_r1861029925) * prefer system installation of ucx to the one provided by the `libucx-cu{11,12}` wheels (ref: https://github.com/rapidsai/devcontainers/pull/421#issuecomment-2502324982) And one other related change: * skip most CI when a PR only changes files in the `.devcontainer/` directory (this was incorrectly spelled `.devcontainers/` before) Authors: - James Lamb (https://github.com/jameslamb) Approvers: - Jake Awe (https://github.com/AyodeAwe) URL: https://github.com/rapidsai/cugraph/pull/4792 --- .devcontainer/Dockerfile | 1 + .devcontainer/cuda11.8-pip/devcontainer.json | 2 +- .github/workflows/pr.yaml | 6 +++--- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index 96e491f4cb..231f6ecf44 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -6,6 +6,7 @@ ARG PYTHON_PACKAGE_MANAGER=conda FROM ${BASE} as pip-base ENV DEFAULT_VIRTUAL_ENV=rapids +ENV RAPIDS_LIBUCX_PREFER_SYSTEM_LIBRARY=true RUN apt update -y \ && DEBIAN_FRONTEND=noninteractive apt install -y \ diff --git a/.devcontainer/cuda11.8-pip/devcontainer.json b/.devcontainer/cuda11.8-pip/devcontainer.json index 6af84ebf51..f2abf493e1 100644 --- a/.devcontainer/cuda11.8-pip/devcontainer.json +++ b/.devcontainer/cuda11.8-pip/devcontainer.json @@ -5,7 +5,7 @@ "args": { "CUDA": "11.8", "PYTHON_PACKAGE_MANAGER": "pip", - "BASE": "rapidsai/devcontainers:25.02-cpp-cuda11.8-ucx1.15.0-openmpi-ubuntu22.04" + "BASE": "rapidsai/devcontainers:25.02-cpp-cuda11.8-ucx1.17.0-openmpi-ubuntu22.04" } }, "runArgs": [ diff --git a/.github/workflows/pr.yaml b/.github/workflows/pr.yaml index af9f23cbe8..43200a5360 100644 --- a/.github/workflows/pr.yaml +++ b/.github/workflows/pr.yaml @@ -49,7 +49,7 @@ jobs: files_yaml: | test_cpp: - '**' - - '!.devcontainers/**' + - '!.devcontainer/**' - '!CONTRIBUTING.md' - '!README.md' - '!docs/**' @@ -60,13 +60,13 @@ jobs: - '!readme_pages/**' test_notebooks: - '**' - - '!.devcontainers/**' + - '!.devcontainer/**' - '!CONTRIBUTING.md' - '!README.md' - '!docs/**' test_python: - '**' - - '!.devcontainers/**' + - '!.devcontainer/**' - '!CONTRIBUTING.md' - '!README.md' - '!docs/**'