Model Registration Verification

Purpose

Ensures new models are fully integrated into the training pipeline:

1. •Factory registration — Model must be added to TrainerFactory.TRAINER_REGISTRY in src/yamyam_lab/engine/factory.py
2. •Hydra config — Model must have a YAML config file under config/models/{category}/
3. •Train.py routing — Model must be routed to the correct arg parser in src/yamyam_lab/train.py
4. •Trainer implementation — Trainer class must implement all BaseTrainer abstract methods
5. •Import chain — Factory must import the trainer class, and the trainer must import the model

When to Run

• •After adding a new model class in src/yamyam_lab/model/
• •After creating a new trainer in src/yamyam_lab/engine/
• •After modifying TrainerFactory.TRAINER_REGISTRY
• •After modifying the arg parser routing in train.py
• •Before creating a Pull Request that introduces a new model

Related Files

Workflow

Step 1: Extract Registered Models from Factory

Tool: Read

Read src/yamyam_lab/engine/factory.py and extract all keys from TRAINER_REGISTRY.

Current registered models:

• •als -> ALSTrainer
• •node2vec -> GraphTrainer
• •graphsage -> GraphTrainer
• •metapath2vec -> GraphTrainer
• •lightgcn -> GraphTrainer
• •svd_bias -> TorchTrainer
• •multimodal_triplet -> MultimodalTripletTrainer

Check for any new models added to the registry.

PASS: Registry is consistent with imports at the top of the file.

FAIL: A model references a trainer class that is not imported, or an imported trainer is unused.

Fix: Add the missing import or remove the unused import.

Step 2: Verify Hydra Config Exists for Each Model

Tool: Glob

For each model in TRAINER_REGISTRY, check that a config YAML exists:

ls config/models/graph/{node2vec,graphsage,metapath2vec,lightgcn}.yaml
ls config/models/mf/{als,svd_bias}.yaml
ls config/models/embedding/multimodal_triplet.yaml

For any newly registered model, check:

find config/models -name "{model_name}.yaml"

PASS: Every registered model has a corresponding YAML config file.

FAIL: A registered model has no YAML config.

Fix: Create config/models/{category}/{model_name}.yaml with required sections (preprocess, training, post_training).

Step 3: Verify Train.py Routing

Tool: Read

Read src/yamyam_lab/train.py and verify that every model in TRAINER_REGISTRY is handled in the if/elif chain:

# Current routing:
# graph models: ["node2vec", "graphsage", "metapath2vec", "lightgcn"] -> parse_args_graph()
# als: ["als"] -> parse_args_als()
# multimodal_triplet: ["multimodal_triplet"] -> parse_args_multimodal_triplet()
# torch models: ["svd_bias"] -> parse_args()

PASS: Every model in TRAINER_REGISTRY is routed to a parser in train.py.

FAIL: A registered model is not handled in train.py routing.

Fix: Add the model name to the appropriate parser branch, or create a new parser if needed.

Step 4: Verify Trainer Implements All Abstract Methods

Tool: Read, Grep

Read src/yamyam_lab/engine/base_trainer.py to get the list of abstract methods:

• •load_data(self) -> None
• •build_model(self) -> None
• •build_metric_calculator(self) -> None
• •train_loop(self) -> None
• •evaluate_validation(self) -> None
• •evaluate_test(self) -> None

For each trainer class used by a new model, verify it implements all abstract methods:

grep -n "def load_data\|def build_model\|def build_metric_calculator\|def train_loop\|def evaluate_validation\|def evaluate_test" src/yamyam_lab/engine/{trainer_file}.py

PASS: All 6 abstract methods are implemented.

FAIL: One or more abstract methods are missing.

Fix: Implement the missing abstract methods in the trainer class.

Step 5: Verify Import Chain Integrity

Tool: Grep

For each new model, verify the chain: factory.py imports trainer -> trainer imports model.

grep -n "from.*import.*{TrainerClass}" src/yamyam_lab/engine/factory.py
grep -n "from.*import\|import " src/yamyam_lab/engine/{trainer_file}.py | grep -i model

PASS: Import chain is complete from factory to trainer to model.

FAIL: Broken import chain.

Fix: Add missing imports.

Output Format

| # | Check | Status | Details |
|---|-------|--------|---------|
| 1 | Factory registration | PASS/FAIL | Models: [list], missing imports: [list] |
| 2 | Hydra config | PASS/FAIL | Missing configs: [list] |
| 3 | Train.py routing | PASS/FAIL | Unrouted models: [list] |
| 4 | Abstract methods | PASS/FAIL | Missing implementations: [list] |
| 5 | Import chain | PASS/FAIL | Broken chains: [list] |

Exceptions

1. •Ranker models — Models under src/yamyam_lab/model/rank/ use a different entry point (src/yamyam_lab/rerank.py with Hydra) and do not need to be in TrainerFactory.TRAINER_REGISTRY or train.py
2. •Classic CF models — Models under src/yamyam_lab/model/classic_cf/ (user_based, item_based) may be used independently without factory registration
3. •Classification models — Models under src/yamyam_lab/model/classification/ may use separate entry points
4. •Shared trainers — Multiple models can share the same trainer class (e.g., all graph models use GraphTrainer), so a new model may not need a new trainer