pydgc.models

pydgc.models.ae

class AE(logger, cfg)

Bases: DGCModel

Autoencoder model with MLP as encoder and decoder. Performs kmeans on embeddings.

Parameters:

• logger (Logger) – Logger.

• cfg (CN) – Config.

reset_parameters()

Reset model parameters.

forward(x)

Model forward pass.

Return type:

Tuple[List[Tensor], List[Tensor]]

loss(x, hat_x)

Model loss function.

Parameters:

• x (Tensor) –

• hat_x (Tensor) –

Return type:

Tensor

train_model(data, cfg=None, flag='TRAIN AE')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(x)

Get model embedding.

Parameters:

x (Tensor) –

Return type:

Tensor

clustering(data, method='kmeans_gpu')

Clustering function.

Parameters:

• data (Data) –

• method (str) –

Return type:

Tuple[Tensor, Tensor, Tensor]

evaluate(data)

Model evaluation function.

Parameters:

data (Data) –

training: bool

pydgc.models.agcdrr

new_graph(edge_index, weight, n, device)

Create a new graph with the given edge index, weight, and number of nodes.

Parameters:

• edge_index (Tensor) – Edge index.

• weight (Tensor) – Edge weight.

• n (int) – Number of nodes.

• device (torch.device) – Device.

Returns:

New graph.

Return type:

Tensor

normalize(mx)

Row-normalize sparse matrix.

Parameters:

mx (scipy.sparse.csr_matrix) – Sparse matrix.

Returns:

Row-normalized sparse matrix.

Return type:

scipy.sparse.csr_matrix

class GNNLayer(in_features, out_features)

Bases: Module

Graph Neural Network Layer.

Parameters:

• in_features (int) – Input feature dimension.

• out_features (int) – Output feature dimension.

forward(features, adj, active)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class IGAE_encoder(gae_n_enc_1, gae_n_enc_2, gae_n_enc_3, n_input)

Bases: Module

IGAE encoder.

Parameters:

• gae_n_enc_1 (int) – Number of hidden units in the first layer.

• gae_n_enc_2 (int) – Number of hidden units in the second layer.

• gae_n_enc_3 (int) – Number of hidden units in the third layer.

• n_input (int) – Input feature dimension.

forward(x, adj)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class Cluster_layer(in_dims, out_dims)

Bases: Module

Clustering layer.

Parameters:

• in_dims (int) – Input feature dimension.

• out_dims (int) – Output feature dimension.

forward(h)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class IGAE(gae_n_enc_1, gae_n_enc_2, gae_n_enc_3, n_input, clusters)

Bases: Module

IGAE model.

Parameters:

• gae_n_enc_1 (int) – Number of hidden units in the first layer.

• gae_n_enc_2 (int) – Number of hidden units in the second layer.

• gae_n_enc_3 (int) – Number of hidden units in the third layer.

• n_input (int) – Input feature dimension.

• clusters (int) – Number of clusters.

forward(x, adj)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

static calc_loss(x, x_aug, temperature=0.2, sym=True)

training: bool

class ViewLearner(encoder, embedding_dim)

Bases: Module

View learner.

Parameters:

• encoder (nn.Module) – Encoder model.

• embedding_dim (int) – Embedding dimension.

init_emb()

forward(x, adj, edge_index)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class AGCDRR(logger, cfg)

Bases: DGCModel

Attributed Graph Clustering with Dual Redundancy Reduction.

Reference: https://xinwangliu.github.io/document/new_paper/IJCAI22-Attributed%20Graph%20Clustering%20with%20Dual%20Redundancy%20Reduction.pdf

Parameters:

• logger (Logger) – Logger.

• cfg (CN) – Config.

reset_parameters()

Reset model parameters.

forward(*args, **kwargs)

Model forward pass.

Return type:

Any

loss(*args, **kwargs)

Model loss function.

Return type:

Tensor

train_model(data, cfg=None, flag='TRAIN AGCDRR')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(data)

Get model embedding.

Return type:

Tensor

clustering(data)

Clustering function.

Return type:

Tuple[Tensor, Tensor, None]

evaluate(data)

Model evaluation function.

training: bool

pydgc.models.ccgc

init_clustering(feature, cluster_num)

Initialize clustering with kmeans.

Parameters:

• feature (Tensor) – Input feature.

• cluster_num (int) – Number of clusters.

Returns:

Predicted labels. dis (Tensor): Pairwise distance.

Return type:

predict_labels (Tensor)

class CCGC(logger, cfg)

Bases: DGCModel

Cluster-Guided Contrastive Graph Clustering Network.

Reference: https://ojs.aaai.org/index.php/AAAI/article/view/26285

Parameters:

• logger (Logger) – Logger.

• cfg (CN) – Config.

reset_parameters()

Reset model parameters.

forward(x)

Model forward pass.

Return type:

Any

loss(*args, **kwargs)

Model loss function.

Return type:

Tensor

train_model(data, cfg=None, flag='TRAIN CCGC')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(data)

Get model embedding.

Return type:

Tensor

clustering(data)

Clustering function.

Return type:

Tuple[Tensor, Tensor, Tensor]

evaluate(data)

Model evaluation function.

training: bool

pydgc.models.daegc

class GATE(logger, cfg)

Bases: DGCModel

Graph Attentional Autoencoder.

Parameters:

• logger (Logger) – Logger.

• cfg (CN) – Config.

reset_parameters()

Reset model parameters.

forward(data)

Model forward pass.

loss(adj_label, hat_adj)

Model loss function.

Parameters:

• adj_label (Tensor) –

• hat_adj (Tensor) –

Return type:

Tensor

train_model(data, cfg=None, flag='TRAIN GATE')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

Return type:

List

get_embedding(data)

Get model embedding.

Return type:

Tensor

clustering(data, method='kmeans_gpu')

Clustering function.

Return type:

Tuple[Tensor, Tensor, Tensor]

evaluate(data)

Model evaluation function.

Parameters:

data (Data) –

training: bool

class DAEGC(logger, cfg)

Bases: DGCModel

Attributed Graph Clustering: A Deep Attentional Embedding Approach.

Reference: https://arxiv.org/abs/1906.06532

Parameters:

• logger (Logger) – Logger.

• cfg (CN) – Config.

reset_parameters()

Reset model parameters.

forward(data)

Model forward pass.

loss(adj_label, hat_adj, q)

Model loss function.

Parameters:

• adj_label (Tensor) –

• hat_adj (Tensor) –

• q (Tensor) –

Return type:

Tensor

pretrain(data, cfg=None, flag='PRETRAIN GATE')

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

train_model(data, cfg=None, flag='TRAIN DAEGC')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(data)

Get model embedding.

Return type:

Tensor

clustering(data)

Clustering function.

Return type:

Tuple[Tensor, Tensor, Tensor]

evaluate(data)

Model evaluation function.

Parameters:

data (Data) –

training: bool

pydgc.models.dcrn

normalize_adj(adj, self_loop=True, symmetry=False)

Normalize the adj matrix.

Parameters:

• adj (np.ndarray) – Input adj matrix.

• self_loop (bool, optional) – If add the self loop or not. Defaults to True.

• symmetry (bool, optional) – Symmetry normalize or not. Defaults to False.

Returns:

The normalized adj matrix.

Return type:

np.ndarray

numpy_to_torch(a, sparse=False)

Convert numpy array to torch tensor.

Parameters:

• a (np.ndarray) – Input numpy array.

• sparse (bool, optional) – If sparse tensor or not. Defaults to False.

Returns:

Output torch tensor.

Return type:

torch.Tensor

remove_edge(A, similarity, remove_rate=0.1, device='cuda')

Remove edge based on embedding similarity.

Parameters:

• A (np.ndarray) – The origin adjacency matrix.

• similarity (np.ndarray) – Cosine similarity matrix of embedding.

• remove_rate (float, optional) – The rate of removing linkage relation. Defaults to 0.1.

• device (str, optional) – Device. Defaults to ‘cuda’.

Returns:

Edge-masked adjacency matrix.

Return type:

np.ndarray

reconstruction_loss(X, A_norm, X_hat, Z_hat, A_hat)

Reconstruction loss $L_{rec}$.

Parameters:

• X (torch.Tensor) – The origin feature matrix.

• A_norm (torch.Tensor) – The normalized adj.

• X_hat (torch.Tensor) – The reconstructed X.

• Z_hat (torch.Tensor) – The reconstructed Z.

• A_hat (torch.Tensor) – The reconstructed A.

Returns:

The reconstruction loss.

Return type:

torch.Tensor

target_distribution(Q)

Calculate the target distribution (student-t distribution).

Parameters:

Q (torch.Tensor) – The soft assignment distribution.

Returns:

The target distribution P.

Return type:

torch.Tensor

distribution_loss(Q, P)

Clustering guidance loss $L_{KL}$.

Parameters:

• Q (torch.Tensor) – The soft assignment distribution.

• P (torch.Tensor) – The target distribution.

Returns:

The clustering guidance loss.

Return type:

torch.Tensor

r_loss(AZ, Z, eps=1e-08, clamp_val=0.0001)

Propagated regularization loss $L_{R}$.

Parameters:

• AZ (torch.Tensor) – The propagated embedding.

• Z (torch.Tensor) – The embedding.

• eps (float, optional) – The epsilon value. Defaults to 1e-8.

• clamp_val (float, optional) – The clamp value. Defaults to 1e-4.

Returns:

The propagated regularization loss.

Return type:

torch.Tensor

off_diagonal(x)

Off-diagonal elements of x.

Parameters:

x (torch.Tensor) – Input matrix.

Returns:

Off-diagonal elements of x.

Return type:

torch.Tensor

cross_correlation(Z_v1, Z_v2)

Cross-view correlation matrix S.

Parameters:

• Z_v1 (torch.Tensor) – The first view embedding.

• Z_v2 (torch.Tensor) – The second view embedding.

Returns:

The cross-view correlation matrix S.

Return type:

torch.Tensor

correlation_reduction_loss(S)

Correlation reduction loss $L_{CR}$.

Parameters:

S (torch.Tensor) – The cross-view correlation matrix S.

Returns:

The correlation reduction loss.

Return type:

torch.Tensor

dicr_loss(name, Z_ae, Z_igae, AZ, Z, gamma_value)

Dual Information Correlation Reduction loss $L_{DICR}$.

Parameters:

• name (str) – Dataset name.

• Z_ae (list of torch.Tensor) – AE embedding including two-view node embedding [0, 1] and two-view cluster-level embedding [2, 3].

• Z_igae (list of torch.Tensor) – IGAE embedding including two-view node embedding [0, 1] and two-view cluster-level embedding [2, 3].

• AZ (torch.Tensor) – The propagated fusion embedding AZ.

• Z (torch.Tensor) – The fusion embedding Z.

• gamma_value (float) – Gamma value.

Returns:

The DICR loss.

Return type:

torch.Tensor

gaussian_noised_feature(X, device='cuda')

Add gaussian noise to the attribute matrix X.

Parameters:

• X (torch.Tensor) – The attribute matrix.

• device (str) – Device.

Returns:

The noised attribute matrix X_tilde.

Return type:

torch.Tensor

class AE_encoder(ae_n_enc_1, ae_n_enc_2, ae_n_enc_3, n_input, n_z)

Bases: Module

AE encoder.

Parameters:

• ae_n_enc_1 (int) – The number of neurons in the first layer of the encoder.

• ae_n_enc_2 (int) – The number of neurons in the second layer of the encoder.

• ae_n_enc_3 (int) – The number of neurons in the third layer of the encoder.

• n_input (int) – The number of input features.

• n_z (int) – The number of latent features.

Returns:

The encoded latent features.

Return type:

torch.Tensor

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class AE_decoder(ae_n_dec_1, ae_n_dec_2, ae_n_dec_3, n_input, n_z)

Bases: Module

AE decoder.

Parameters:

• ae_n_dec_1 (int) – The number of neurons in the first layer of the decoder.

• ae_n_dec_2 (int) – The number of neurons in the second layer of the decoder.

• ae_n_dec_3 (int) – The number of neurons in the third layer of the decoder.

• n_input (int) – The number of input features.

• n_z (int) – The number of latent features.

Returns:

The decoded features.

Return type:

torch.Tensor

forward(z_ae)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class AE(ae_n_enc_1, ae_n_enc_2, ae_n_enc_3, ae_n_dec_1, ae_n_dec_2, ae_n_dec_3, n_input, n_z, device='cuda')

Bases: Module

AE module.

Parameters:

• ae_n_enc_1 (int) – The number of neurons in the first layer of the encoder.

• ae_n_enc_2 (int) – The number of neurons in the second layer of the encoder.

• ae_n_enc_3 (int) – The number of neurons in the third layer of the encoder.

• ae_n_dec_1 (int) – The number of neurons in the first layer of the decoder.

• ae_n_dec_2 (int) – The number of neurons in the second layer of the decoder.

• ae_n_dec_3 (int) – The number of neurons in the third layer of the decoder.

• n_input (int) – The number of input features.

• n_z (int) – The number of latent features.

• device (str) – Device.

Returns:

The decoded features.

Return type:

torch.Tensor

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

pretrain(logger, data, cfg=None, flag='PRETRAIN AE')

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

evaluate(logger, embedding, y, edge_index)

training: bool

class GNNLayer(name, in_features, out_features)

Bases: Module

GNN layer.

Parameters:

• name (str) – Name of the GNN layer.

• in_features (int) – Number of input features.

• out_features (int) – Number of output features.

Returns:

Output features.

Return type:

torch.Tensor

forward(features, adj, active=False)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class IGAE_encoder(name, gae_n_enc_1, gae_n_enc_2, gae_n_enc_3, n_input)

Bases: Module

IGAE encoder.

Parameters:

• name (str) – Name of the GNN layer.

• gae_n_enc_1 (int) – The number of neurons in the first layer of the encoder.

• gae_n_enc_2 (int) – The number of neurons in the second layer of the encoder.

• gae_n_enc_3 (int) – The number of neurons in the third layer of the encoder.

• n_input (int) – The number of input features.

Returns:

Output features.

Return type:

torch.Tensor

forward(x, adj)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class IGAE_decoder(name, gae_n_dec_1, gae_n_dec_2, gae_n_dec_3, n_input)

Bases: Module

forward(z_igae, adj)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class IGAE(name, gae_n_enc_1, gae_n_enc_2, gae_n_enc_3, gae_n_dec_1, gae_n_dec_2, gae_n_dec_3, n_input, device='cuda')

Bases: Module

IGAE model.

Parameters:

• name (str) – Name of the GNN layer.

• gae_n_enc_1 (int) – The number of neurons in the first layer of the encoder.

• gae_n_enc_2 (int) – The number of neurons in the second layer of the encoder.

• gae_n_enc_3 (int) – The number of neurons in the third layer of the encoder.

• gae_n_dec_1 (int) – The number of neurons in the first layer of the decoder.

• gae_n_dec_2 (int) – The number of neurons in the second layer of the decoder.

• gae_n_dec_3 (int) – The number of neurons in the third layer of the decoder.

• n_input (int) – The number of input features.

• device (str) – Device.

Returns:

Output features.

Return type:

torch.Tensor

forward(x, adj)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

pretrain(logger, data, cfg=None, flag='PRETRAIN IGAE')

Parameters:

• logger (Logger) –

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

training: bool

class Readout(K)

Bases: Module

Readout layer.

Parameters:

K (int) – Number of clusters.

Returns:

Cluster-level embedding.

Return type:

torch.Tensor

forward(Z)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class DCRN(logger, cfg)

Bases: DGCModel

Deep Graph Clustering via Dual Correlation Reduction.

Reference: https://ojs.aaai.org/index.php/AAAI/article/view/20726

Parameters:

• logger (Logger) – Logger.

• cfg (CN) – Configuration.

Returns:

Output features.

Return type:

torch.Tensor

reset_parameters()

Reset model parameters.

q_distribute(Z, Z_ae, Z_igae)

calculate the soft assignment distribution based on the embedding and the cluster centers :param Z: fusion node embedding :param Z_ae: node embedding encoded by AE :param Z_igae: node embedding encoded by IGAE

Returns:

the soft assignment distribution Q

forward(X_tilde1, Am, X_tilde2, Ad)

Model forward pass.

loss(*args, **kwargs)

Model loss function.

Return type:

Tensor

ae_igae_forward(x, adj)

pretrain(data, cfg=None, flag='PRETRAIN AE_IGAE')

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

train_model(data, cfg=None, flag='TRAIN DCRN')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(data)

Get model embedding.

Return type:

Tensor

clustering(data, method='kmeans_gpu')

Clustering function.

Parameters:

• data (Data) –

• method (str) –

Return type:

Tuple[Tensor, Tensor, Tensor]

training: bool

evaluate(data)

Model evaluation function.

Parameters:

data (Data) –

pydgc.models.dfcn

target_distribution(q)

Target distribution.

Parameters:

q (torch.Tensor) – Input tensor.

Returns:

Target distribution.

Return type:

torch.Tensor

class AE_encoder(ae_n_enc_1, ae_n_enc_2, ae_n_enc_3, n_input, n_z, device='cuda')

Bases: Module

Autoencoder encoder.

Parameters:

• ae_n_enc_1 (int) – The number of neurons in the first layer of the encoder.

• ae_n_enc_2 (int) – The number of neurons in the second layer of the encoder.

• ae_n_enc_3 (int) – The number of neurons in the third layer of the encoder.

• n_input (int) – The number of input features.

• n_z (int) – The number of latent features.

• device (str) – Device.

Returns:

Output features.

Return type:

torch.Tensor

reset_parameters()

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class AE_decoder(ae_n_dec_1, ae_n_dec_2, ae_n_dec_3, n_input, n_z, device='cuda')

Bases: Module

Autoencoder decoder.

Parameters:

• ae_n_dec_1 (int) – The number of neurons in the first layer of the decoder.

• ae_n_dec_2 (int) – The number of neurons in the second layer of the decoder.

• ae_n_dec_3 (int) – The number of neurons in the third layer of the decoder.

• n_input (int) – The number of input features.

• n_z (int) – The number of latent features.

• device (str) – Device.

Returns:

Output features.

Return type:

torch.Tensor

reset_parameters()

forward(z_ae)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class AE(ae_n_enc_1, ae_n_enc_2, ae_n_enc_3, ae_n_dec_1, ae_n_dec_2, ae_n_dec_3, n_input, n_z, device='cuda')

Bases: Module

Autoencoder.

Parameters:

• ae_n_enc_1 (int) – The number of neurons in the first layer of the encoder.

• ae_n_enc_2 (int) – The number of neurons in the second layer of the encoder.

• ae_n_enc_3 (int) – The number of neurons in the third layer of the encoder.

• ae_n_dec_1 (int) – The number of neurons in the first layer of the decoder.

• ae_n_dec_2 (int) – The number of neurons in the second layer of the decoder.

• ae_n_dec_3 (int) – The number of neurons in the third layer of the decoder.

• n_input (int) – The number of input features.

• n_z (int) – The number of latent features.

• device (str) – Device.

Returns:

Output features.

Return type:

torch.Tensor

reset_parameters()

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

pretrain(logger, data, cfg=None, flag='PRETRAIN AE')

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

training: bool

class GNNLayer(name, in_features, out_features, device='cuda')

Bases: Module

Graph neural network layer.

Parameters:

• name (str) – Name of the dataset.

• in_features (int) – Number of input features.

• out_features (int) – Number of output features.

• device (str) – Device.

Returns:

Output features.

Return type:

torch.Tensor

reset_parameters()

forward(features, adj, active=False)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class IGAE_encoder(name, gae_n_enc_1, gae_n_enc_2, gae_n_enc_3, n_input, device='cuda')

Bases: Module

IGAE encoder.

Parameters:

• name (str) – Name of the dataset.

• gae_n_enc_1 (int) – The number of neurons in the first layer of the encoder.

• gae_n_enc_2 (int) – The number of neurons in the second layer of the encoder.

• gae_n_enc_3 (int) – The number of neurons in the third layer of the encoder.

• n_input (int) – The number of input features.

• device (str) – Device.

Returns:

Output features.

Return type:

torch.Tensor

reset_parameters()

forward(x, adj)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class IGAE_decoder(name, gae_n_dec_1, gae_n_dec_2, gae_n_dec_3, n_input, device='cuda')

Bases: Module

IGAE decoder.

Parameters:

• name (str) – Name of the dataset.

• gae_n_dec_1 (int) – The number of neurons in the first layer of the decoder.

• gae_n_dec_2 (int) – The number of neurons in the second layer of the decoder.

• gae_n_dec_3 (int) – The number of neurons in the third layer of the decoder.

• n_input (int) – The number of input features.

• device (str) – Device.

Returns:

Output features.

Return type:

torch.Tensor

reset_parameters()

forward(z_igae, adj)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

class IGAE(name, gae_n_enc_1, gae_n_enc_2, gae_n_enc_3, gae_n_dec_1, gae_n_dec_2, gae_n_dec_3, n_input, device='cuda')

Bases: Module

IGAE model.

Parameters:

• name (str) – Name of the dataset.

• gae_n_enc_1 (int) – The number of neurons in the first layer of the encoder.

• gae_n_enc_2 (int) – The number of neurons in the second layer of the encoder.

• gae_n_enc_3 (int) – The number of neurons in the third layer of the encoder.

• gae_n_dec_1 (int) – The number of neurons in the first layer of the decoder.

• gae_n_dec_2 (int) – The number of neurons in the second layer of the decoder.

• gae_n_dec_3 (int) – The number of neurons in the third layer of the decoder.

• n_input (int) – The number of input features.

• device (str) – Device.

Returns:

Output features.

Return type:

torch.Tensor

reset_parameters()

forward(x, adj)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

pretrain(logger, data, cfg=None, flag='PRETRAIN IGAE')

Parameters:

• logger (Logger) –

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

training: bool

class DFCN(logger, cfg)

Bases: DGCModel

Deep Fusion Clustering Network.

Reference: https://ojs.aaai.org/index.php/AAAI/article/view/17198

Parameters:

• logger (Logger) – Logger.

• cfg (CN) – Configuration.

Returns:

Output features.

Return type:

torch.Tensor

reset_parameters()

Reset model parameters.

forward(data)

Model forward pass.

Parameters:

data (Data) –

Return type:

Any

loss(*args, **kwargs)

Model loss function.

Return type:

Tensor

ae_igae_forward(data)

pretrain(data, cfg=None, flag='PRETRAIN AE_IGAE')

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

train_model(data, cfg=None, flag='TRAIN DFCN')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

training: bool

get_embedding(data)

Get model embedding.

Return type:

Tensor

clustering(data, method='kmeans_gpu')

Clustering function.

Parameters:

• data (Data) –

• method (str) –

Return type:

Tuple[Tensor, Tensor, Tensor]

evaluate(data)

Model evaluation function.

Parameters:

data (Data) –

pydgc.models.dgc_model

class DGCModel(logger, cfg)

Bases: Module, ABC

Deep Graph Clustering base Model.

Implement abstractmethod reset_parameters, forward, loss, train_model, get_embedding, clustering, evaluate.

Parameters:

• logger (Logger) – Logger.

• cfg (CN) – Configuration.

Returns:

Output features.

Return type:

torch.Tensor

abstract reset_parameters()

Reset model parameters.

abstract forward(*args, **kwargs)

Model forward pass.

Return type:

Any

abstract loss(*args, **kwargs)

Model loss function.

Return type:

Tensor

abstract train_model(*args, **kwargs)

Model training function.

Return type:

Tuple[List, List, Tensor, Tensor, Dict]

abstract get_embedding(*args, **kwargs)

Get model embedding.

Return type:

Tensor

abstract clustering(*args, **kwargs)

Clustering function.

Return type:

Tuple[Tensor, Tensor, Tensor]

abstract evaluate(*args, **kwargs)

Model evaluation function.

training: bool

pydgc.models.dgcluster

convert_scipy_torch_sp(sp_adj)

Convert scipy sparse matrix to torch sparse matrix.

Parameters:

sp_adj (scipy.sparse.csr_matrix) – Input sparse matrix.

Returns:

Output sparse matrix.

Return type:

torch.sparse_coo_tensor

aux_objective(output, s, oh_labels)

Auxiliary objective function.

Parameters:

• output (torch.Tensor) – Output tensor.

• s (torch.Tensor) – Sample indices.

• oh_labels (torch.Tensor) – One-hot labels.

Returns:

Auxiliary objective loss.

Return type:

torch.Tensor

regularization(output, s)

Regularization function.

Parameters:

• output (torch.Tensor) – Output tensor.

• s (torch.Tensor) – Sample indices.

Returns:

Regularization loss.

Return type:

torch.Tensor

class DGCLUSTER(logger, cfg)

Bases: DGCModel

DGCLUSTER: A Neural Framework for Attributed Graph Clustering via Modularity Maximization.

Reference: https://ojs.aaai.org/index.php/AAAI/article/view/28983

Parameters:

• logger (Logger) – Logger object.

• cfg (CN) – Configuration object.

training: bool

reset_parameters()

Reset model parameters.

forward(data)

Model forward pass.

Parameters:

data (Data) –

Return type:

Any

loss(output, data, lam, alp)

Model loss function.

Return type:

Tensor

train_model(data, cfg=None, flag='TRAIN DGCLUSTER')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(data)

Get model embedding.

Parameters:

data (Data) –

Return type:

Tensor

clustering(data)

Clustering function.

Parameters:

data (Data) –

Return type:

Tuple[Tensor, Tensor, Tensor]

evaluate(data)

Model evaluation function.

Parameters:

data (Data) –

pydgc.models.gae

class GAE(logger, cfg)

Bases: DGCModel

Variational Graph Auto-Encoders.

Reference: https://arxiv.org/abs/1611.07308

Parameters:

• logger (Logger) – Logger object.

• cfg (CN) – Configuration object.

reset_parameters()

Reset model parameters.

forward(data)

Model forward pass.

loss(edge_index, hat_adj)

Model loss function.

Parameters:

hat_adj (Tensor) –

Return type:

Tensor

train_model(data, cfg=None, flag='TRAIN GAE')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(data)

Get model embedding.

Parameters:

data (Data) –

Return type:

Tensor

clustering(data, method='kmeans_gpu')

Clustering function.

Parameters:

• data (Data) –

• method (str) –

Return type:

Tuple[Tensor, Tensor, Tensor]

evaluate(data)

Model evaluation function.

Parameters:

data (Data) –

training: bool

pydgc.models.gae_ssc

class GAESSC(logger, cfg)

Bases: DGCModel

Graph-autoencoder with self-supervised clustering used in DEC.

Parameters:

• logger (Logger) – Logger object.

• cfg (CN) – Configuration object.

reset_parameters()

Reset model parameters.

forward(data)

Model forward pass.

Return type:

Any

loss(edge_index, hat_adj, q)

Model loss function.

Parameters:

• hat_adj (Tensor) –

• q (Tensor) –

Return type:

Tensor

pretrain(data, cfg=None, flag='PRETRAIN GAE')

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

train_model(data, cfg=None, flag='TRAIN GAE-SSC')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(data)

Get model embedding.

Return type:

Tensor

clustering(data)

Clustering function.

Return type:

Tuple[Tensor, Tensor, Tensor]

evaluate(data)

Model evaluation function.

Parameters:

data (Data) –

training: bool

pydgc.models.hsan

comprehensive_similarity(Z1, Z2, E1, E2, alpha)

Comprehensive similarity function.

Parameters:

• Z1 (torch.Tensor) – Latent representation of the first view.

• Z2 (torch.Tensor) – Latent representation of the second view.

• E1 (torch.Tensor) – Latent representation of the first view.

• E2 (torch.Tensor) – Latent representation of the second view.

• alpha (float) – Weight of the similarity function.

Returns:

Comprehensive similarity matrix.

Return type:

torch.Tensor

hard_sample_aware_infoNCE(S, M, pos_neg_weight, pos_weight, node_num)

Hard sample aware InfoNCE loss function.

Parameters:

• S (torch.Tensor) – Comprehensive similarity matrix.

• M (torch.Tensor) – Mask matrix.

• pos_neg_weight (float) – Weight of the negative samples.

• pos_weight (float) – Weight of the positive samples.

• node_num (int) – Number of nodes.

Returns:

InfoNCE loss.

Return type:

torch.Tensor

square_euclid_distance(Z, center)

Square Euclidean distance function.

Parameters:

• Z (torch.Tensor) – Latent representation.

• center (torch.Tensor) – Clustering centers.

Returns:

Square Euclidean distance matrix.

Return type:

torch.Tensor

phi(embedding, cluster_num)

Clustering function.

Parameters:

• embedding (torch.Tensor) – Latent representation.

• cluster_num (int) – Number of clusters.

Returns:

Clustering labels. torch.Tensor: Clustering centers.

Return type:

torch.Tensor

class HSAN(logger, cfg)

Bases: DGCModel

Hard Sample Aware Network for Contrastive Deep Graph Clustering.

Reference: https://ojs.aaai.org/index.php/AAAI/article/view/26071

Parameters:

• logger (Logger) – Logger object.

• cfg (CN) – Configuration object.

reset_parameters()

Reset model parameters.

forward(data)

Model forward pass.

Return type:

Any

high_confidence(Z, center)

pseudo_matrix(P, S, node_num)

loss(*args, **kwargs)

Model loss function.

Return type:

Tensor

train_model(data, cfg=None, flag='TRAIN HSAN')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(data)

Get model embedding.

Return type:

Tuple[Tensor, Tensor]

clustering(data)

Clustering function.

Return type:

Tuple[Tensor, Tensor, Tensor]

evaluate(data)

Model evaluation function.

training: bool

pydgc.models.magi

class Encoder(in_channels, hidden_channels, base_model=<class 'torch_geometric.nn.conv.gcn_conv.GCNConv'>, dropout=0.5, ns=0.5)

Bases: Module

Encoder for MAGI.

Parameters:

• in_channels (int) – Number of input channels.

• hidden_channels (list) – List of hidden channels.

• base_model (torch.nn.Module) – Base model for graph convolution.

• dropout (float) – Dropout rate.

• ns (float) – Negative slope for leaky ReLU.

reset_parameters()

初始化模型参数

forward(x, edge_index=None, adjs=None, dropout=True)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Parameters:

x (Tensor) –

training: bool

class Loss(temperature=0.07, scale_by_temperature=True, scale_by_weight=False)

Bases: Module

Loss function for MAGI.

Parameters:

• temperature (float) – Temperature

• scale_by_temperature (bool) – Whether to scale loss by temperature.

• scale_by_weight (bool) – Whether to scale loss by weight.

forward(out, mask)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

clustering(feature, n_clusters, true_labels, kmeans_device='cpu', batch_size=100000, tol=0.0001, device=device(type='cuda', index=0), spectral_clustering=False)

Clustering function.

Parameters:

• feature (torch.Tensor) – Latent representation.

• n_clusters (int) – Number of clusters.

• true_labels (torch.Tensor) – True labels.

• kmeans_device (str) – Device for kmeans.

• batch_size (int) – Batch size.

• tol (float) – Tolerance.

• device (torch.device) – Device.

• spectral_clustering (bool) – Whether to use spectral clustering.

Returns:

Clustering labels. None: Clustering centers.

Return type:

torch.Tensor

scale(z)

Scale the latent representation.

Parameters:

z (torch.Tensor) – Latent representation.

Returns:

Scaled latent representation.

Return type:

torch.Tensor

class MAGI(logger, cfg)

Bases: DGCModel

Revisiting Modularity Maximization for Graph Clustering: A Contrastive Learning Perspective.

Reference: https://doi.org/10.1145/3637528.3671967

Parameters:

• logger (Logger) – Logger object.

• cfg (CN) – Configuration object.

reset_parameters()

Reset model parameters.

forward(data)

Model forward pass.

Return type:

Any

loss(*args, **kwargs)

Model loss function.

Return type:

Tensor

train_model(data, cfg=None, flag='TRAIN MAGI')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(data)

Get model embedding.

Return type:

Tensor

clustering(data)

Clustering function.

Return type:

Tuple[Tensor, Tensor, Any]

evaluate(data)

Model evaluation function.

training: bool

pydgc.models.magi_batch

class Encoder(in_channels, hidden_channels, base_model=<class 'torch_geometric.nn.conv.sage_conv.SAGEConv'>, dropout=0.5, ns=0.5)

Bases: Module

Encoder model for MAGI-Batch.

Parameters:

• in_channels (int) – Input feature dimension.

• hidden_channels (list) – Hidden layer dimensions.

• base_model (torch.nn.Module) – Base model for graph convolution.

• dropout (float) – Dropout rate.

• ns (float) – Negative slope for LeakyReLU.

reset_parameters()

初始化模型参数

forward(x, edge_index=None, adjs=None, dropout=True)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Parameters:

x (Tensor) –

training: bool

class Loss(temperature=0.07, scale_by_temperature=True, scale_by_weight=False)

Bases: Module

Loss function for MAGI-Batch.

Parameters:

• temperature (float) – Temperature parameter for softmax.

• scale_by_temperature (bool) – Whether to scale the loss by temperature.

• scale_by_weight (bool) – Whether to scale the loss by weight.

forward(out, mask)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

training: bool

clustering(feature, n_clusters, true_labels, kmeans_device='cpu', batch_size=100000, tol=0.0001, device=device(type='cuda', index=0), spectral_clustering=False)

Clustering function.

Parameters:

• feature (torch.Tensor) – Latent representation.

• n_clusters (int) – Number of clusters.

• true_labels (torch.Tensor) – True labels.

• kmeans_device (str) – Device for kmeans.

• batch_size (int) – Batch size for kmeans.

• tol (float) – Tolerance for kmeans.

• device (torch.device) – Device for kmeans.

• spectral_clustering (bool) – Whether to use spectral clustering.

Returns:

Clustering labels. None: Clustering centers.

Return type:

torch.Tensor

scale(z)

Scale the latent representation.

Parameters:

z (torch.Tensor) – Latent representation.

Returns:

Scaled latent representation.

Return type:

torch.Tensor

class EdgeIndex(edge_index, e_id, size)

Bases: tuple

Parameters:

• edge_index (Tensor) –

• e_id (Tensor | None) –

• size (Tuple[int, int]) –

edge_index: Tensor

Alias for field number 0

e_id: Tensor | None

Alias for field number 1

size: Tuple[int, int]

Alias for field number 2

to(*args, **kwargs)

class Adj(adj_t, e_id, size)

Bases: tuple

Parameters:

• adj_t (SparseTensor) –

• e_id (Tensor | None) –

• size (Tuple[int, int]) –

adj_t: SparseTensor

Alias for field number 0

e_id: Tensor | None

Alias for field number 1

size: Tuple[int, int]

Alias for field number 2

to(*args, **kwargs)

class NeighborSampler(edge_index, adj, sizes, is_train=False, wt=20, wl=4, drop_last=False, node_idx=None, num_nodes=None, return_e_id=True, transform=None, **kwargs)

Bases: DataLoader

Neighbor sampler for graph convolution.

This code adapted from the pytorch geometric (https://github.com/pyg-team/pytorch_geometric/blob/master/torch_geometric/loader/neighbor_sampler.py).

drop_last: bool

get_batch(random_nodes)

sample(batch)

dataset: Dataset[T_co]

batch_size: int | None

num_workers: int

pin_memory: bool

timeout: float

sampler: Sampler | Iterable

pin_memory_device: str

prefetch_factor: int | None

get_mask(adj)

Get mask for positive edges.

Parameters:

adj (SparseTensor) – Adjacency matrix.

Returns:

Masked adjacency matrix.

Return type:

SparseTensor

class MAGIBatch(logger, cfg)

Bases: DGCModel

Revisiting Modularity Maximization for Graph Clustering: A Contrastive Learning Perspective.

Reference: https://doi.org/10.1145/3637528.3671967

Parameters:

• logger (Logger) – Logger object.

• cfg (CN) – Configuration object.

reset_parameters()

Reset model parameters.

forward(data, n_id)

Model forward pass.

Return type:

Any

loss(*args, **kwargs)

Model loss function.

Return type:

Tensor

train_model(data, cfg=None, flag='TRAIN MAGI')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(data)

Get model embedding.

Return type:

Tensor

training: bool

clustering(data)

Clustering function.

Return type:

Tuple[Tensor, Tensor, Any]

evaluate(data)

Model evaluation function.

pydgc.models.ns4gc

mask_feat(X, mask_prob)

Mask feature.

Parameters:

• X (torch.Tensor) – Feature matrix.

• mask_prob (float) – Mask probability.

Returns:

Masked feature matrix.

Return type:

torch.Tensor

drop_edge(A, drop_prob)

Drop edge with drop probability

Parameters:

• A (torch.sparse.Tensor) – Adjacency matrix.

• drop_prob (float) – Drop probability.

Returns:

Dropped adjacency matrix.

Return type:

torch.sparse.Tensor

add_self_loop(A)

Add self loop to the adjacency matrix.

Parameters:

A (torch.sparse.Tensor) – Adjacency matrix.

Returns:

Adjacency matrix with self loop.

Return type:

torch.sparse.Tensor

normalize(A, add_self_loops=True, returnA=False)

Normalized the graph’s adjacency matrix in the torch.sparse.Tensor format.

Parameters:

• A (torch.sparse.Tensor) – Adjacency matrix.

• add_self_loops (bool) – Whether to add self loops.

• returnA (bool) – Whether to return the original adjacency matrix.

Returns:

Normalized adjacency matrix.

Return type:

torch.sparse.Tensor

sparse_identity(dim, device)

Create a sparse identity matrix.

Parameters:

• dim (int) – Dimension of the identity matrix.

• device (torch.device) – Device to create the matrix on.

Returns:

Sparse identity matrix.

Return type:

torch.sparse.Tensor

sparse_diag(V)

Create a sparse diagonal matrix.

Parameters:

V (torch.Tensor) – Diagonal values.

Returns:

Sparse diagonal matrix.

Return type:

torch.sparse.Tensor

augment(A, X, edge_mask_rate, feat_drop_rate)

Augment the graph and feature matrix.

Parameters:

• A (torch.sparse.Tensor) – Adjacency matrix.

• X (torch.Tensor) – Feature matrix.

• edge_mask_rate (float) – Edge mask rate.

• feat_drop_rate (float) – Feature drop rate.

Returns:

Augmented adjacency matrix. torch.Tensor: Augmented feature matrix.

Return type:

torch.sparse.Tensor

class GCNConv(in_dim, out_dim, activation=None)

Bases: Module

Implementation of Graph Convolutional Network (GCN) layer.

Parameters:

• in_dim (int) – Input dimensionality of the layer.

• out_dim (int) – Output dimensionality of the layer.

• activation (callable, optional) – Activation function to use for the final representations. Defaults to None.

reset_parameters()

forward(A_norm, X)

Computes GCN representations according to input features and input graph.

Parameters:

• A_norm (torch.sparse.Tensor) – Normalized (n*n) sparse graph adjacency matrix.

• X (torch.Tensor) – (n*in_dim) node feature matrix.

Returns:

An (n*out_dim) node representation matrix.

Return type:

torch.Tensor

training: bool

class NS4GC(logger, cfg)

Bases: DGCModel

Reliable Node Similarity Matrix Guided Contrastive Graph Clustering.

Reference: https://ieeexplore.ieee.org/abstract/document/10614738/

Parameters:

• logger (Logger) – Logger object.

• cfg (CN) – Configuration object.

reset_parameters()

Reset model parameters.

embed(A_norm, X)

forward(A_norm1, A_norm2, X1, X2)

Model forward pass.

Return type:

Any

loss(*args, **kwargs)

Model loss function.

Return type:

Tensor

train_model(data, cfg=None, flag='TRAIN NS4GC')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

Return type:

Tuple[List, List, Tensor, Tensor, Dict]

get_embedding(data)

Get model embedding.

Parameters:

data (Data) –

Return type:

Tensor

clustering(data, method='kmeans_gpu')

Clustering function.

Parameters:

• data (Data) –

• method (str) –

Return type:

Tuple[Tensor, Tensor, Tensor]

evaluate(data)

Model evaluation function.

Parameters:

data (Data) –

training: bool

pydgc.models.sdcn

class SDCN(logger, cfg)

Bases: DGCModel

Structural Deep Clustering Network.

Reference: https://doi.org/10.1145/3366423.3380214

Parameters:

• logger (Logger) – Logger object.

• cfg (CN) – Configuration object.

reset_parameters()

Reset model parameters.

forward(data, sigma=0.5)

Model forward pass.

Parameters:

• data (Data) –

• sigma (float) –

Return type:

Any

loss(x, hat_x, q, pred)

Model loss function.

Return type:

Tensor

pretrain(data, cfg=None, flag='PRETRAIN AE')

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

train_model(data, cfg=None, flag='TRAIN SDCN')

Model training function.

Parameters:

• data (Data) –

• cfg (CfgNode | None) –

• flag (str) –

get_embedding(data)

Get model embedding.

Return type:

Tuple[Tensor, Tensor]

clustering(data)

Clustering function.

Return type:

Tuple[Tensor, Tensor, Tensor]

evaluate(data)

Model evaluation function.

Parameters:

data (Data) –

training: bool