mcy98's picture
Add files using upload-large-folder tool
0ca2ffc verified
Raw History Blame Contribute Delete
9.38 kB
import unittest
import torch
import torch.nn as nn
import numpy as np
from types import SimpleNamespace
import copy
from graphmetro.models.canonical import MoEModel as CanonicalMoEModel
from graphmetro.models.moe import MoEModel as GeneratedMoEModel
from . import canonical
from . import moe as generation
mock_cfg = SimpleNamespace(
device='cpu',
dataset=SimpleNamespace(
task='node'
)
)
canonical.cfg = mock_cfg
generation.cfg = mock_cfg
class MockEncoder(nn.Module):
def __init__(self, in_dim, out_dim):
super().__init__()
self.linear = nn.Linear(in_dim, out_dim)
def forward(self, x, edge_index, edge_attr, batch):
return self.linear(x)
class MockExpertModel(nn.Module):
def __init__(self, in_dim=8, emb_dim=16, out_dim=4):
super().__init__()
self.encoder = MockEncoder(in_dim, emb_dim)
self.classifier = nn.Linear(emb_dim, out_dim)
def forward(self, x, edge_index, edge_attr, batch):
return self.encoder(x, edge_index, edge_attr, batch)
class MockGatingModel(nn.Module):
def __init__(self, in_dim, num_experts):
super().__init__()
self.scorer = nn.Linear(in_dim, num_experts)
def forward(self, x, edge_index, edge_attr, batch):
return self.scorer(x)
class TestMoEModelEquivalence(unittest.TestCase):
@classmethod
def setUpClass(cls):
torch.manual_seed(42)
np.random.seed(42)
cls.num_nodes = 10
cls.num_edges = 20
cls.feat_dim = 8
cls.emb_dim = 16
cls.num_experts = 3
cls.num_classes = 4
cls.original_data = SimpleNamespace(
x=torch.randn(cls.num_nodes, cls.feat_dim),
edge_index=torch.randint(0, cls.num_nodes, (2, cls.num_edges)),
edge_attr=torch.randn(cls.num_edges, 1),
batch=torch.sort(torch.randint(0, 2, (cls.num_nodes,)))[0]
)
cls.transformed_data = SimpleNamespace(
x=torch.randn(cls.num_nodes, cls.feat_dim),
edge_index=torch.randint(0, cls.num_nodes, (2, cls.num_edges)),
edge_attr=torch.randn(cls.num_edges, 1),
batch=cls.original_data.batch
)
cls.node_mask = torch.ones(cls.num_nodes, dtype=torch.bool)
cls.gating_targets = torch.tensor([0.0, 1.0, 0.0])
cls.trans_func_dict = {f'trans_{i}': lambda x: x for i in range(cls.num_experts)}
gating_model = MockGatingModel(cls.feat_dim, cls.num_experts)
expert_models = [MockExpertModel(cls.feat_dim, cls.emb_dim, cls.num_classes) for _ in range(cls.num_experts)]
cls.canonical_model = CanonicalMoEModel(
trans_func_dict=cls.trans_func_dict,
gating_model=gating_model,
expert_models=copy.deepcopy(expert_models)
)
cls.generated_model = GeneratedMoEModel(
trans_func_dict=cls.trans_func_dict,
gating_model=gating_model,
expert_models=copy.deepcopy(expert_models)
)
cls.canonical_model.eval()
cls.generated_model.eval()
def assert_tensors_close(self, tensor1, tensor2, msg):
self.assertIsInstance(tensor1, torch.Tensor, f"{msg} - Canonical output is not a tensor.")
self.assertIsInstance(tensor2, torch.Tensor, f"{msg} - Generated output is not a tensor.")
self.assertEqual(tensor1.shape, tensor2.shape, f"{msg} - Shape mismatch.")
torch.testing.assert_close(tensor1, tensor2, rtol=1e-5, atol=1e-6, msg=msg)
def test_01_init_equivalence(self):
self.assertEqual(self.canonical_model.num_experts, self.generated_model.num_experts)
self.assertIsNotNone(self.canonical_model.classifier)
self.assertIsNotNone(self.generated_model.classifier)
self.assertEqual(len(list(self.canonical_model.classifier.parameters())), len(list(self.generated_model.classifier.parameters())))
for i in range(self.num_experts):
self.assertIsNone(self.canonical_model.experts[i].classifier, f"Canonical expert {i} still has a classifier.")
self.assertIsNone(self.generated_model.experts[i].classifier, f"Generated expert {i} still has a classifier.")
def test_02_get_expert_weights_equivalence(self):
canonical_weights_softmax = self.canonical_model.get_expert_weights(self.transformed_data, softmax=True)
generated_weights_softmax = self.generated_model.get_expert_weights(self.transformed_data, softmax=True)
self.assert_tensors_close(canonical_weights_softmax, generated_weights_softmax, "Weight mismatch with softmax=True")
canonical_weights_logits = self.canonical_model.get_expert_weights(self.transformed_data, softmax=False)
generated_weights_logits = self.generated_model.get_expert_weights(self.transformed_data, softmax=False)
self.assert_tensors_close(canonical_weights_logits, generated_weights_logits, "Weight mismatch with softmax=False (logits)")
def test_03_aggregate_equivalence(self):
weights = torch.rand(self.num_nodes, self.num_experts)
weights = weights.softmax(dim=-1)
canonical_soft = self.canonical_model._aggregate(self.original_data, weights, hard=False)
generated_soft = self.generated_model._aggregate(self.original_data, weights, hard=False)
self.assert_tensors_close(canonical_soft, generated_soft, "Mismatch in soft aggregation")
canonical_hard = self.canonical_model._aggregate(self.original_data, weights, hard=True)
generated_hard = self.generated_model._aggregate(self.original_data, weights, hard=True)
self.assert_tensors_close(canonical_hard, generated_hard, "Mismatch in hard aggregation from weights")
expert_idx = 1
canonical_hard_idx = self.canonical_model._aggregate(self.original_data, expert_idx, hard=True)
generated_hard_idx = self.generated_model._aggregate(self.original_data, expert_idx, hard=True)
self.assert_tensors_close(canonical_hard_idx, generated_hard_idx, "Mismatch in hard aggregation from integer index")
def test_04_forward_equivalence(self):
c_out_hard, c_gate_hard = self.canonical_model.forward(self.transformed_data, hard=True, return_gating_out=True)
g_out_hard, g_gate_hard = self.generated_model.forward(self.transformed_data, hard=True, return_gating_out=True)
self.assert_tensors_close(c_out_hard, g_out_hard, "Mismatch in forward output (hard agg)")
self.assert_tensors_close(c_gate_hard, g_gate_hard, "Mismatch in forward gating weights (hard agg)")
c_out_soft, c_gate_soft = self.canonical_model.forward(self.transformed_data, hard=False, return_gating_out=True)
g_out_soft, g_gate_soft = self.generated_model.forward(self.transformed_data, hard=False, return_gating_out=True)
self.assert_tensors_close(c_out_soft, g_out_soft, "Mismatch in forward output (soft agg)")
self.assert_tensors_close(c_gate_soft, g_gate_soft, "Mismatch in forward gating weights (soft agg)")
c_out_only = self.canonical_model.forward(self.transformed_data, hard=False, return_gating_out=False)
g_out_only = self.generated_model.forward(self.transformed_data, hard=False, return_gating_out=False)
self.assertIsInstance(c_out_only, torch.Tensor)
self.assert_tensors_close(c_out_only, g_out_only, "Mismatch in forward output (gating output off)")
def test_05_losses_equivalence(self):
c_loss_vals = self.canonical_model.losses(self.original_data, self.transformed_data, self.node_mask, self.gating_targets, hard=True)
g_loss_vals = self.generated_model.losses(self.original_data, self.transformed_data, self.node_mask, self.gating_targets, hard=True)
self.assertEqual(len(c_loss_vals), 4, "Canonical losses should return 4 values")
self.assertEqual(len(g_loss_vals), 4, "Generated losses should return 4 values")
c_emb, c_gloss, c_aloss, c_gacc = c_loss_vals
g_emb, g_gloss, g_aloss, g_gacc = g_loss_vals
self.assert_tensors_close(c_emb, g_emb, "Mismatch in aggregated embedding from losses (hard agg)")
self.assert_tensors_close(c_gloss, g_gloss, "Mismatch in gating loss from losses (hard agg)")
self.assert_tensors_close(c_aloss, g_aloss, "Mismatch in alignment loss from losses (hard agg)")
self.assert_tensors_close(c_gacc, g_gacc, "Mismatch in gating accuracy from losses (hard agg)")
c_loss_vals_soft = self.canonical_model.losses(self.original_data, self.transformed_data, self.node_mask, self.gating_targets, hard=False)
g_loss_vals_soft = self.generated_model.losses(self.original_data, self.transformed_data, self.node_mask, self.gating_targets, hard=False)
c_emb_s, c_gloss_s, c_aloss_s, c_gacc_s = c_loss_vals_soft
g_emb_s, g_gloss_s, g_aloss_s, g_gacc_s = g_loss_vals_soft
self.assert_tensors_close(c_emb_s, g_emb_s, "Mismatch in aggregated embedding from losses (soft agg)")
self.assert_tensors_close(c_gloss_s, g_gloss_s, "Mismatch in gating loss from losses (soft agg)")
self.assert_tensors_close(c_gloss, c_gloss_s, "Canonical gating loss should be independent of 'hard' flag")
self.assert_tensors_close(c_aloss_s, g_aloss_s, "Mismatch in alignment loss from losses (soft agg)")
if __name__ == '__main__':
unittest.main()