pytorch_cluster

Clúster de pytorch

---

Este paquete consiste en una pequeña biblioteca de extensión de algoritmos de clúster gráficos altamente optimizados para el uso en Pytorch. El paquete consta de los siguientes algoritmos de agrupación:

• Graclus de Dhillon et al. : Cortes de gráficos ponderados sin vectores propios: un enfoque multinivel (Pami 2007)
• Voxel Grid Agrupo de, por ejemplo , Simonovsky y Komodakis: filtros dinámicos con bordes en redes neuronales convolucionales en gráficos (CVPR 2017)
• Muestreo iterativo de puntos más lejanos de, por ejemplo , Qi et al. : Pointnet ++: aprendizaje de características jerárquicas profundas en conjuntos de puntos en un espacio métrico (NIPS 2017)
• Generación de gráficos K-NN y RADIUS
• Agrupación basada en los puntos más cercanos
• Muestreo de caminatas aleatorias de, por ejemplo , Grover y Leskovec: Node2Vec: aprendizaje de características escalables para redes (KDD 2016)

Todas las operaciones incluidas funcionan en diferentes tipos de datos y se implementan tanto para CPU como para GPU.

Instalación

Anaconda

ACTUALIZACIÓN: Ahora puede instalar pytorch-cluster a través de Anaconda para todas las principales combinaciones de OS/Pytorch/Cuda? Dado que tiene pytorch >= 1.8.0 instalado, simplemente ejecute

 conda install pytorch-cluster -c pyg

Binarios

Alternativamente, proporcionamos ruedas PIP para todas las principales combinaciones de OS/Pytorch/CUDA, ver aquí.

Pytorch 2.5

Para instalar los binarios para Pytorch 2.5.0, simplemente ejecute

 pip install torch-cluster -f https://data.pyg.org/whl/torch-2.5.0+${CUDA}.html

Donde ${CUDA} debe ser reemplazado por cpu , cu118 , cu121 o cu124 dependiendo de su instalación de Pytorch.

	cpu	cu118	cu121	cu124
Linux	✅	✅	✅	✅
Windows	✅	✅	✅	✅
macosa	✅

Pytorch 2.4

Para instalar los binarios para Pytorch 2.4.0, simplemente ejecute

 pip install torch-cluster -f https://data.pyg.org/whl/torch-2.4.0+${CUDA}.html

Donde ${CUDA} debe ser reemplazado por cpu , cu118 , cu121 o cu124 dependiendo de su instalación de Pytorch.

	cpu	cu118	cu121	cu124
Linux	✅	✅	✅	✅
Windows	✅	✅	✅	✅
macosa	✅

Nota: También se proporcionan binarios de las versiones más antiguas para Pytorch 1.4.0, Pytorch 1.5.0, Pytorch 1.6.0, Pytorch 1.7.0/1.7.1, Pytorch 1.8.0/1.8.1, Pytorch 1.9.0, Pytorch 1.10.0/1.10.1/1.10.2, Pytorch 1.11.0, Pytorch 1.12.0/1.12.1, Pytorch 1.13.0/1.13.1, Pytorch 2.0.0/2.0.1, Pytorch 2.1.0/2.1.1/2.1.2, Pytorch 2.2.0/2.2.1/2.2.2 y Pytorch 2.3.0/2.3.1 (siguiente el mismo procedimiento). Para versiones anteriores, debe especificar explícitamente el último número de versión compatible o instalar a través de pip install --no-index para evitar una instalación manual desde la fuente. Puede buscar el último número de versión compatible aquí.

De la fuente

Asegúrese de que al menos Pytorch 1.4.0 esté instalado y verifique que cuda/bin y cuda/include estén en su $PATH y $CPATH respectivamente, por ejemplo :

 $ python -c "import torch; print(torch.__version__)"
>>> 1.4.0

$ python -c "import torch; print(torch.__version__)"
>>> 1.1.0

$ echo $PATH
>>> /usr/local/cuda/bin:...

$ echo $CPATH
>>> /usr/local/cuda/include:...

Luego corre:

 pip install torch-cluster

Cuando se ejecuta en un contenedor Docker sin controlador NVIDIA, Pytorch necesita evaluar las capacidades de cálculo y puede fallar. En este caso, asegúrese de que las capacidades de cálculo se establezcan a través de TORCH_CUDA_ARCH_LIST , EG :

 export TORCH_CUDA_ARCH_LIST = "6.0 6.1 7.2+PTX 7.5+PTX"

Funciones

Graclus

Un algoritmo de agrupamiento codicioso de elegir un vértice sin marcar y coincidirlo con uno de sus vecinos sin marcar (que maximiza el peso de su borde). El algoritmo de GPU está adaptado de Fagginger Auer y Bisseling: un algoritmo de GPU para la coincidencia de gráficos codiciosos (LNCS 2012)

 import torch
from torch_cluster import graclus_cluster

row = torch . tensor ([ 0 , 1 , 1 , 2 ])
col = torch . tensor ([ 1 , 0 , 2 , 1 ])
weight = torch . tensor ([ 1. , 1. , 1. , 1. ])  # Optional edge weights.

cluster = graclus_cluster ( row , col , weight )

 print(cluster)
tensor([0, 0, 1])

Voxelgrid

Un algoritmo de agrupación, que superpone una cuadrícula regular de tamaño definido por el usuario sobre una nube de puntos y agrupa todos los puntos dentro de un vóxel.

 import torch
from torch_cluster import grid_cluster

pos = torch . tensor ([[ 0. , 0. ], [ 11. , 9. ], [ 2. , 8. ], [ 2. , 2. ], [ 8. , 3. ]])
size = torch . Tensor ([ 5 , 5 ])

cluster = grid_cluster ( pos , size )

 print(cluster)
tensor([0, 5, 3, 0, 1])

Muestra de punto más lejano

Un algoritmo de muestreo, que muestra iterativamente el punto más distante con respecto a los puntos de descanso.

 import torch
from torch_cluster import fps

x = torch . tensor ([[ - 1. , - 1. ], [ - 1. , 1. ], [ 1. , - 1. ], [ 1. , 1. ]])
batch = torch . tensor ([ 0 , 0 , 0 , 0 ])
index = fps ( x , batch , ratio = 0.5 , random_start = False )

 print(index)
tensor([0, 3])

gráfico

Calcula los bordes de gráficos a los puntos K más cercanos.

Args:

• x (tensor) : matriz de características de nodo de forma [N, F] .
• K (int) : el número de vecinos.
• lote (Longtensor, opcional) : vector de lotes de forma [N] , que asigna cada nodo a un ejemplo específico. batch necesita ser ordenado. (predeterminado: None )
• bucle (bool, opcional) : si es True , el gráfico contendrá los bucles. (predeterminado: False )
• flujo (cadena, opcional) : la dirección de flujo cuando se usa en combinación con el paso del mensaje ( "source_to_target" o "target_to_source" ). (predeterminado: "source_to_target" )
• coseno (booleano, opcional) : si es True , usará la distancia coseno en lugar de la distancia euclidiana para encontrar vecinos más cercanos. (predeterminado: False )
• num_workers (int) : número de trabajadores para usar para el cálculo. No tiene efecto en el lote de que batch no sea None , o la entrada se encuentra en la GPU. (predeterminado: 1 )

 import torch
from torch_cluster import knn_graph

x = torch . tensor ([[ - 1. , - 1. ], [ - 1. , 1. ], [ 1. , - 1. ], [ 1. , 1. ]])
batch = torch . tensor ([ 0 , 0 , 0 , 0 ])
edge_index = knn_graph ( x , k = 2 , batch = batch , loop = False )

 print(edge_index)
tensor([[1, 2, 0, 3, 0, 3, 1, 2],
        [0, 0, 1, 1, 2, 2, 3, 3]])

Radio-gráfico

Calcula los bordes de gráficos a todos los puntos dentro de una distancia dada.

Args:

• x (tensor) : matriz de características de nodo de forma [N, F] .
• R (flotante) : el radio.
• lote (Longtensor, opcional) : vector de lotes de forma [N] , que asigna cada nodo a un ejemplo específico. batch necesita ser ordenado. (predeterminado: None )
• bucle (bool, opcional) : si es True , el gráfico contendrá los bucles. (predeterminado: False )
• max_num_neighbors (int, opcional) : el número máximo de vecinos para devolver para cada elemento. Si el número de vecinos reales es mayor que max_num_neighbors , los vecinos devueltos se recogen al azar. (predeterminado: 32 )
• flujo (cadena, opcional) : la dirección de flujo cuando se usa en combinación con el paso del mensaje ( "source_to_target" o "target_to_source" ). (predeterminado: "source_to_target" )
• num_workers (int) : número de trabajadores para usar para el cálculo. No tiene efecto en el lote de que batch no sea None , o la entrada se encuentra en la GPU. (predeterminado: 1 )

 import torch
from torch_cluster import radius_graph

x = torch . tensor ([[ - 1. , - 1. ], [ - 1. , 1. ], [ 1. , - 1. ], [ 1. , 1. ]])
batch = torch . tensor ([ 0 , 0 , 0 , 0 ])
edge_index = radius_graph ( x , r = 2.5 , batch = batch , loop = False )

 print(edge_index)
tensor([[1, 2, 0, 3, 0, 3, 1, 2],
        [0, 0, 1, 1, 2, 2, 3, 3]])

Más cercano

Grupos de puntos en X juntos que están más cerca de un punto de consulta dado en y . batch_{x,y} Los vectores deben ordenarse.

 import torch
from torch_cluster import nearest

x = torch . Tensor ([[ - 1 , - 1 ], [ - 1 , 1 ], [ 1 , - 1 ], [ 1 , 1 ]])
batch_x = torch . tensor ([ 0 , 0 , 0 , 0 ])
y = torch . Tensor ([[ - 1 , 0 ], [ 1 , 0 ]])
batch_y = torch . tensor ([ 0 , 0 ])
cluster = nearest ( x , y , batch_x , batch_y )

 print(cluster)
tensor([0, 0, 1, 1])

Muestreo aleatorio

Muestras Pasos aleatorios de longitud walk_length desde todos los índices de nodo en start en el gráfico dado por (row, col) .

 import torch
from torch_cluster import random_walk

row = torch . tensor ([ 0 , 1 , 1 , 1 , 2 , 2 , 3 , 3 , 4 , 4 ])
col = torch . tensor ([ 1 , 0 , 2 , 3 , 1 , 4 , 1 , 4 , 2 , 3 ])
start = torch . tensor ([ 0 , 1 , 2 , 3 , 4 ])

walk = random_walk ( row , col , start , walk_length = 3 )

 print(walk)
tensor([[0, 1, 2, 4],
        [1, 3, 4, 2],
        [2, 4, 2, 1],
        [3, 4, 2, 4],
        [4, 3, 1, 0]])

Pruebas de ejecución

 pytest

API C ++

torch-cluster también ofrece una API C ++ que contiene C ++ equivalente de modelos Python.

 export Torch_DIR=`python -c 'import torch;print(torch.utils.cmake_prefix_path)'`
mkdir build
cd build
# Add -DWITH_CUDA=on support for the CUDA if needed
cmake ..
make
make install