DMGNN(in_dim, hid_dim, num_classes, num_layers=0, n_emb=128, pair_weight=0.1, step=3, dropout=0.0, act=F.relu, weight_decay=0.0, lr=0.004, epoch=200, device='cuda:0', batch_size=100, num_neigh=-1, verbose=2, **kwargs)

Bases: BaseGDA

Domain-adaptive message passing graph neural network (NN-23).

Parameters:
  • in_dim (int) –

    Input feature dimension.

  • hid_dim (int) –

    Hidden dimension of model.

  • num_classes (int) –

    Total number of classes.

  • dropout (float, default: 0.0 ) –

    Dropout rate. Default: 0..

  • weight_decay (float, default: 0.0 ) –

    Weight decay (L2 penalty). Default: 0..

  • n_emb (int, default: 128 ) –

    Adversarial learning module hidden dimension. Default: 128.

  • pair_weight (float, default: 0.1 ) –

    Trade-off hyper-parameter for pairwise constraint. Default: 0.1.

  • step –

    Propagation steps in PPMI matrix. Default: 3.

  • act (callable activation function or None, default: relu ) –

    Activation function if not None. Default: torch.nn.functional.relu.

  • lr (float, default: 0.004 ) –

    Learning rate. Default: 0.004.

  • epoch (int, default: 200 ) –

    Maximum number of training epoch. Default: 200.

  • device (str, default: 'cuda:0' ) –

    GPU or CPU. Default: cuda:0.

  • batch_size (int, default: 100 ) –

    Minibatch size, 0 for full batch training. Default: 100.

  • num_neigh (int, default: -1 ) –

    Number of neighbors in sampling, -1 for all neighbors. Default: -1.

  • verbose (int, default: 2 ) –

    Verbosity mode. Range in [0, 3]. Larger value for printing out more log information. Default: 2.

  • **kwargs –

    Other parameters for the model.
agg_tran_prob_mat(g, step)

Compute aggregated k-step transition probability matrix.

Parameters:
  • g (csc_matrix) –

    Input graph adjacency matrix.

  • step (int) –

    Number of propagation steps.
Returns:
  • ndarray –

    Aggregated transition probability matrix.
Notes

Implements iterative computation of transition probabilities up to k steps, with step-wise normalization.

batch_generator(data, batch_size, shuffle=True)

Generate mini-batches of data.

Parameters:
  • data (list) –

    List of data arrays to be batched.

  • batch_size (int) –

    Size of each batch.

  • shuffle (bool, default: True ) –

    Whether to shuffle data. Default: True.
Yields:
  • tuple –

    Contains: - batch_data : list List of batched data arrays. - shuffle_index : numpy.ndarray Indices for current batch.
Notes

Implements infinite batch generation with optional shuffling and aligned data handling.

batch_ppmi(batch_size, shuffle_index_s, shuffle_index_t, ppmi_s, ppmi_t)

Generate batch-wise PPMI matrices for source and target domains.

Parameters:
  • batch_size (int) –

    Size of mini-batch.

  • shuffle_index_s (ndarray) –

    Shuffled indices for source domain.

  • shuffle_index_t (ndarray) –

    Shuffled indices for target domain.

  • ppmi_s (ndarray) –

    Source domain PPMI matrix.

  • ppmi_t (ndarray) –

    Target domain PPMI matrix.
Returns:
  • tuple –

    Contains: - a_s : numpy.ndarray Normalized source batch PPMI matrix. - a_t : numpy.ndarray Normalized target batch PPMI matrix.
compute_ppmi(a)

Compute Positive Pointwise Mutual Information matrix.

Parameters:
  • a (ndarray) –

    Aggregated transition probability matrix.
Returns:
  • ndarray –

    PPMI matrix with non-negative entries.
Notes
  1. Removes self-loops
  2. Normalizes transition probabilities
  3. Computes log-based PPMI values
  4. Handles numerical stability
fit(source_data, target_data)

Train the DMGNN model on source and target domain data.

Parameters:
  • source_data (Data) –

    Source domain graph data.

  • target_data (Data) –

    Target domain graph data.
Notes

Training process consists of several key components:

Data Preprocessing

  • Computes PPMI matrices for both domains
  • Generates neighborhood-aware features
  • Prepares one-hot encoded labels
  • Concatenates direct and neighborhood features

Model Setup

  • Initializes DMGNN model
  • Configures Adam optimizer
  • Sets up classification and domain loss functions

Training Loop

  • Generates balanced source/target batches
  • Updates domain adaptation parameter

  • Computes multiple loss components:

    • Classification loss on labeled data
    • Domain adversarial loss
    • Network proximity loss

  • Enhances predictions with neighborhood information

  • Tracks and logs training progress

Batch Processing

  • Handles source and target domains separately
  • Maintains balanced sampling
  • Applies PPMI-based structural learning
  • Implements dynamic batch generation

Loss Computation

  • Classification loss on source domain
  • Domain adaptation through adversarial training
  • Neighborhood proximity preservation
  • Combined loss optimization

Monitoring

  • Tracks epoch-wise loss
  • Computes micro-F1 score
  • Logs training progress
  • Measures computation time
forward_model(**kwargs)

Forward pass placeholder.

Parameters:
  • **kwargs –

    Arbitrary keyword arguments.
Notes

Main forward logic is implemented in fit method due to complex batch processing requirements.

init_model(**kwargs)

Initialize the DMGNN base model.

Parameters:
  • **kwargs –

    Additional parameters for model initialization.
Returns:
  • ACDNEBase –

    Initialized model with specified architecture parameters.
Notes

Configures a two-layer network with:

  • Input dimension handling
  • Hidden layer configuration
  • Embedding dimension for adversarial learning
  • Dropout regularization
  • Batch processing settings
my_scale_sim_mat(w)

Compute L1 row normalization of a matrix.

Parameters:
  • w (ndarray or csc_matrix) –

    Input similarity/adjacency matrix.
Returns:
  • ndarray or csc_matrix –

    Row-normalized matrix.
Notes

Implementation details:

  1. Computes row sums
  2. Handles numerical stability with epsilon
  3. Prevents infinite values
  4. Applies row-wise normalization
nei_prox_loss(emb, a)

Calculate neighborhood proximity loss.

Parameters:
  • emb (Tensor) –

    Node embeddings.

  • a (Tensor) –

    Adjacency/PPMI matrix.
Returns:
  • Tensor –

    Normalized proximity loss between nodes and their neighbors.
Notes

Computes average L2 distance between node embeddings and their neighborhood representations.

predict(data, train=False)

Make predictions on input data.

Parameters:
  • data (Data) –

    Input graph data.

  • train (bool, default: False ) –

    Whether in training mode. Default: False.
Returns:
  • tuple –

    Contains: - logits : torch.Tensor Model predictions. - labels : torch.Tensor True labels.
Notes
  1. Uses stored whole-graph representations
  2. Combines direct and neighborhood predictions
  3. Handles source/target domains differently
process_graph(data)

Process input graph data to compute PPMI matrices and neighborhood features.

Parameters:
  • data (Data) –

    Input graph data.
Returns:
  • tuple –

    Contains: - A_ppmi : numpy.ndarray PPMI matrix for structural information. - X_nei : numpy.ndarray Neighborhood-aware node features.
Notes

Processing steps:

  1. Converts edge index to dense adjacency
  2. Computes k-step transition probabilities
  3. Generates PPMI matrix
  4. Creates neighborhood feature aggregation
shuffle_aligned_list(data)

Shuffle multiple data arrays while maintaining alignment.

Parameters:
  • data (list) –

    List of numpy arrays to be shuffled.
Returns:
  • tuple –

    Contains: - shuffle_index : numpy.ndarray Generated permutation indices. - shuffled_data : list List of shuffled arrays maintaining alignment.
Notes

Ensures consistent shuffling across multiple data arrays, particularly useful for maintaining correspondence between features and labels during batch generation.