Acham

Ei pessoal! Recentemente, passei a certificação profissional de ciência de dados da NVIDIA e estou emocionado em compartilhar algumas idéias para ajudá -lo em sua jornada. Isso faz parte de uma série em que vou dividir os principais conceitos e ferramentas abordados na certificação, concentrando -se em como aproveitar a aceleração da GPU para um aprendizado de máquina incrivelmente rápido. Incluí todos os notebooks do Colab que usei para que você possa entender rapidamente os conceitos executando -os instantaneamente no Google Colab. Vamos começar.

Networkx

O NetworkX é uma potência para a análise de gráficos em Python, amada por sua facilidade de uso e vasta comunidade. No entanto, à medida que os gráficos crescem, sua natureza python pura pode levar a gargalos de desempenho. E se você pudesse manter a API Acquainted Networkx, mas obter uma aceleração enorme para conjuntos de dados maiores? Digitar nx-cugraphum again -end de corredeiras que permite que o Networkx alavance o poder das GPUs da NVIDIA.

Este publish mergulha em como nx-cugraph Pode acelerar significativamente seus fluxos de trabalho do NetworkX, demonstrados com algoritmos de gráficos comuns, como a centralidade entre a entrega e o PageRank.

Hyperlink para o pocket book Colab

O que você aprenderá

• Por que o NetworkX, apesar de sua popularidade, pode ser lento para gráficos grandes.
• Como o NetworkX 3.0+ permite que os algoritmos de despacho aceleram again -ends.
• O que nx-cugraph é e como ele traz aceleração da GPU para o Networkx.
• Como configurar seu ambiente para usar nx-cugraph.
• Consulte Exemplos práticos de acelerações para centralidade entre entrequelas e algoritmos PageRank em conjuntos de dados pequenos e grandes.
• Entenda as alterações mínimas de código necessárias para obter esses benefícios de desempenho.

O desafio do Networkx: desempenho em escala

O NetworkX é incrivelmente fashionable, baixado milhões de vezes. Sua API amigável, documentação extensa e instalação fácil tornam-a uma análise de gráfico. No entanto, essa facilidade vem com uma troca: sua implementação do Python pode lutar com as demandas de desempenho de conjuntos de dados de gráficos maiores do mundo actual.

Acelerou o Networkx para o resgate!

A NetworkX 3.0 introduziu um recurso de mudança de jogo: a capacidade de despachar chamadas de algoritmo para implementações de back-end alternativas e mais executivas. Isso significa que você não precisa abandonar seu código Networkx existente para aproveitar ganhos sérios de desempenho, como os oferecidos pelas GPUs.

O nx-cugraph A biblioteca, parte do ecossistema Nvidia Rapids, é um desses again -end. Ele permite que o Networkx descarregue os cálculos para o NVIDIA GPUS, acelerando drasticamente os algoritmos de gráficos.

Configurando o NetworkX para usar CuGraph por padrão

Uma característica interessante de nx-cugraph (versão 24.10+) é o NX_CUGRAPH_AUTOCONFIG variável de ambiente. Definindo isso para True antes Importar o NetworkX diz ao Networkx para usar o again -end “CuGraph” por padrão.

%env NX_CUGRAPH_AUTOCONFIG=True

import networkx as nx
print(f"utilizing networkx model {nx.__version__}")

# This pocket book makes use of a caching characteristic that may produce warnings for some customers.
# The pocket book makes use of really useful APIs, so we will safely ignore this particular warning.
nx.config.warnings_to_ignore.add("cache")

Com essa configuração, a maioria das suas chamadas de algoritmo NetworkX existente será automaticamente acelerada por GPU sem nenhuma alteração de código adicional!

Ver é acreditar: aceleração do algoritmo

Vamos ver como nx-cugraph acelera alguns algoritmos populares.

Um começo simples: Zachary’s Karate Membership

Começaremos com o gráfico clássico do Zachary’s Karate Membership (34 nós, 78 arestas).

G = nx.karate_club_graph()
G.number_of_nodes(), G.number_of_edges()
# Output: (34, 78)

Centralidade entre entrega

Esse algoritmo mede a importância de um nó com base em quantos caminhos mais curtos passam por ele.

Com nx-cugraph (GPU acelerou, padrão devido a NX_CUGRAPH_AUTOCONFIG):

%%time
nxcg_bc_results = nx.betweenness_centrality(G)
# CPU instances: consumer 177 ms, sys: 70.1 ms, whole: 247 ms
# Wall time: 762 ms

Com o padrão de rede padrão (CPU): Para usar explicitamente a implementação do Networkx authentic, usamos o backend="networkx" argumento.

%%time
nx_bc_results = nx.betweenness_centrality(G, backend="networkx")
# CPU instances: consumer 191 ms, sys: 13.6 ms, whole: 205 ms
# Wall time: 204 ms

Para um gráfico tão pequeno, a sobrecarga dos lançamentos de kernel da GPU pode fazer o nx-cugraph A versão parece um pouco mais lenta. O poder actual brilha com conjuntos de dados maiores. O pocket book visualiza esses resultados, mostrando que ambos os again -end produzem o mesmo rating de centralidade.

PageRank

O PageRank obtém nós com base em sua “importância” relativa, analisando hyperlinks.

Com nx-cugraph (GPU acelerado):

%%time
nxcg_pr_results = nx.pagerank(G)
# CPU instances: consumer 11.4 ms, sys: 10.8 ms, whole: 22.2 ms
# Wall time: 68.2 ms

Com o padrão de rede padrão (CPU):

%%time
nx_pr_results = nx.pagerank(G, backend="networkx")
# CPU instances: consumer 3.8 ms, sys: 1.11 ms, whole: 4.9 ms
# Wall time: 19.8 ms

Novamente, para pequenos gráficos, a CPU pode ser mais rápida. No entanto, os resultados são numericamente muito próximos, como mostrado com compará -los em um DataFrame:

%load_ext cudf.pandas
import pandas as pd
import pytest
from IPython.show import show, HTML

print("Do each outcomes have the identical values (inside tolerance)? "
      f"{nxcg_pr_results == pytest.approx(nx_pr_results, rel=1e-6, abs=1e-11)}")
# Output: Do each outcomes have the identical values (inside tolerance)? True

df = pd.DataFrame(
    columns=["nx node", "nxcg node", "nx PR", "nxcg PR"],
    knowledge=[(a, c, b, d) for (a, b), (c, d) in zip(nx_pr_results.items(),
                                                 nxcg_pr_results.items())])
df.sort_values(by="nx PR", ascending=False, inplace=True)

print("nTop 5 nodes based mostly on PageRank")
show(HTML(df.head(5).to_html(float_format=lambda f: f"{f:.7g}")))

A saída confirma que as pontuações do PageRank são essencialmente idênticas.

Centralidade entre entretenidade em um gráfico grande

Para gráficos grandes, o cálculo dos caminhos mais curtos dos pares para a centralidade entre a entretenidade é frequentemente inviável. Nós usamos o ok parâmetro a se aproximar por amostragem ok nós.

Com o padrão de rede padrão (CPU), ok=1 (maior ok Os valores são impraticáveis):

%%time
bc_results_large_nx = nx.betweenness_centrality(G_large, ok=1, backend="networkx")
# CPU instances: consumer 2min 1s, sys: 4.02 s, whole: 2min 5s
# Wall time: 2min 5s

Com nx-cugraph (GPU), ok=1:

%%time
bc_results_large_nxcg_k1 = nx.betweenness_centrality(G_large, ok=1)
# CPU instances: consumer 935 ms, sys: 200 ms, whole: 1.14 s
# Wall time: 1.17 s

Mais de 100x aceleração! (2min 5s vs 1,17s)

Com nx-cugraphpodemos pagar um muito maior (e mais preciso) ok. Com nx-cugraph (GPU), ok=100:

%%time
bc_results_large_nxcg_k100 = nx.betweenness_centrality(G_large, ok=100)
# CPU instances: consumer 26.7 s, sys: 658 ms, whole: 27.3 s
# Wall time: 27.3 s

Correndo com ok=100 na GPU ainda é significativamente mais rápido (27,3s) do que ok=1 na CPU (2min 5s).

Uma nota sobre comparação betweenness_centrality com ok: Como é uma aproximação baseada em amostras aleatórias, os resultados podem diferir ligeiramente entre o Networkx e nx-cugraph A menos que uma estratégia comum de sementes e amostragem seja usada, que é uma área para atualizações futuras.

PageRank em um gráfico grande

Com o padrão de rede padrão (CPU):

%%time
nx_pr_results_large = nx.pagerank(G_large, backend="networkx")
# CPU instances: consumer 1min 39s, sys: 5.02 s, whole: 1min 44s
# Wall time: 1min 44s

Com nx-cugraph (GPU):

%%time
nxcg_pr_results_large = nx.pagerank(G_large)
# CPU instances: consumer 540 ms, sys: 293 ms, whole: 834 ms
# Wall time: 877 ms

Outra aceleração maciça: mais de 100x! (1min 44s vs 877ms). Os resultados permanecem consistentes dentro da tolerância.

Takeaways para certificação ✨

Migrando seu Fluxos de trabalho da Networkx para aceleração da GPU com nx-cugraph oferece benefícios substanciaisespecialmente à medida que seus dados crescem:

• 🚀 Velocidade em chamas: Experimente melhorias dramáticas de desempenho (geralmente> 100x) para algoritmos de gráfico em grandes conjuntos de dados, alavancando a energia da GPU.
• 💻 Alterações mínimas de código: Graças ao sistema de again -end e NX_CUGRAPH_AUTOCONFIGvocê pode acelerar o código Networkx existente com pouca ou nenhuma modificação.
• 📊 Escalabilidade aprimorada: Abordar problemas gráficos do mundo actual muito maiores que antes eram impraticáveis ​​com o Networkx somente CPU.
• 🛠️ Configuração simples: Instalação fácil by way of pip e configuração direta para ativar o cugraph again -end.
• 🤝 API acquainted de Networkx Acquainted: Proceed trabalhando com a interface Networkx conhecida e amada, minimizando a curva de aprendizado.

Se você está trabalhando com gráficos que estão empurrando os limites do Networkx tradicional, nx-cugraph é uma maneira fantástica de aumentar sua produtividade e desbloquear novas possibilidades em análises de gráficos.