Added scripts for matris, updated readme

README.md

@@ -10,6 +10,19 @@ size_categories:
 - 10K<n<100K
 ---
 
-# Introduction
 
-Started on ReadMe File. 
+
+## Repository Structure
+
+Datasets are stored in the `datasets/` directory and are provided in both `.h5` and `.xyz` formats.
+
+All model implementations, training code, evaluation code, and checkpoints are located in the `models/` directory. Each model subdirectory contains:
+
+- `runs/` — stores trained model checkpoints and experiment outputs.
+- `scripts/` — contains training, evaluation, and benchmarking shell scripts.
+
+The scripts are configured to be launched from the repository root directory. For example, to start training of a new matris model, run
+
+```bash
+./models/matris/scripts/run_matris.sh
+

models/matris/README.md

@@ -1,5 +0,0 @@
-# Introduction
-
-To train matris, run the run_matris.py script, there's also a ddp version called run_matris_ddp.py
-
-To eval matris, run the eval_matris.py

models/matris/run_matris.py

@@ -1,38 +1,36 @@
 from __future__ import annotations
 
+import argparse
 import collections
+import os
 import random
+from datetime import datetime
 from pathlib import Path
 
 import numpy as np
 import torch
+import torch.distributed as dist
 from torch import nn
+from torch.nn.parallel import DistributedDataParallel as DDP
 from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from tqdm import tqdm
 import wandb
 
 from matris.model.model import MatRIS
 from matris.model.reference_energy import AtomRef
 from matris_dataset import MatRISDataset, matris_collate_fn, move_matris_batch_to_device
-import argparse
-from datetime import datetime
-from tqdm import tqdm
 
 
-# =========================
-# Config
-# =========================
-REPO_ROOT = Path(__file__).resolve().parents[2]
-
-TRAIN_PATH = str(REPO_ROOT / "datasets/xyz/train.xyz")
-VAL_PATH = str(REPO_ROOT / "datasets/xyz/val.xyz")
-SAVE_DIR = REPO_ROOT / "models/matris/checkpoints_matris"
+TRAIN_PATH = "datasets/trainingset_251216_train.xyz"
+VAL_PATH = "datasets/trainingset_251216_val.xyz"
 
 PROJECT_NAME = "matris-minimal-training"
-RUN_NAME = "matris-ef"
+RUN_NAME = "matris-ef-ddp"
 
 BATCH_SIZE = 1
 NUM_WORKERS = 0
-EPOCHS = 100
+EPOCHS = 1000
 LR = 3e-4
 MIN_LR = 3e-6
 WEIGHT_DECAY = 1e-2
@@ -41,30 +39,57 @@ SEED = 42
 ENERGY_LOSS_WEIGHT = 1.0
 FORCE_LOSS_WEIGHT = 1.0
 
-
+SAVE_DIR = Path("checkpoints_matris")
 SAVE_DIR.mkdir(parents=True, exist_ok=True)
 
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-
 E0S_DEFAULT = {
-    1: 2.467478445,   # H
-    6: 8.0273263225,  # C
-    8: 3.334308855,   # O
-    22: 4.879036065,  # Ti
+    1: 2.467478445,
+    6: 8.0273263225,
+    8: 3.334308855,
+    22: 4.879036065,
 }
 
-# NOTE Make sure pretrained changes weights (the model size changes, so that's enough of an gurantee)
 
-# =========================
-# Utils
-# =========================
+def setup_ddp():
+    dist.init_process_group(backend="nccl")
+    local_rank = int(os.environ["LOCAL_RANK"])
+    rank = int(os.environ["RANK"])
+    world_size = int(os.environ["WORLD_SIZE"])
+    torch.cuda.set_device(local_rank)
+    device = f"cuda:{local_rank}"
+    return local_rank, rank, world_size, device
+
+
+def cleanup_ddp():
+    if dist.is_initialized():
+        dist.destroy_process_group()
+
+
+def is_main_process():
+    return (not dist.is_initialized()) or dist.get_rank() == 0
+
+
+def reduce_mean(value: float, device: str) -> float:
+    tensor = torch.tensor(value, device=device, dtype=torch.float32)
+    dist.all_reduce(tensor, op=dist.ReduceOp.SUM)
+    tensor /= dist.get_world_size()
+    return tensor.item()
+
+
 def set_seed(seed: int) -> None:
+    rank = dist.get_rank() if dist.is_initialized() else 0
+    seed = seed + rank
+
     random.seed(seed)
     np.random.seed(seed)
     torch.manual_seed(seed)
     torch.cuda.manual_seed_all(seed)
 
 
+def unwrap_model(model):
+    return model.module if isinstance(model, DDP) else model
+
+
 def build_reference_energy_module(model: MatRIS, e0_dict: dict[int, float]) -> AtomRef:
     atom_ref = AtomRef(reference_energy="mptrj", is_intensive=model.is_intensive)
 
@@ -83,8 +108,6 @@ def build_reference_energy_module(model: MatRIS, e0_dict: dict[int, float]) -> A
     return atom_ref
 
 
-
-# WHat Matris paper is doing
 class WeightedEnergyForcesMAELoss(nn.Module):
     def __init__(self, energy_weight: float = 1.0, forces_weight: float = 1.0):
         super().__init__()
@@ -98,9 +121,8 @@ class WeightedEnergyForcesMAELoss(nn.Module):
         out: dict,
         do_eval: bool = False,
     ):
-        n_atoms = out["atoms_per_graph"].float()  # [B]
-        
-        # NOTE out["e"] is eV/atom if model.is_intensive=True (which it is), else eV total NOTE 
+        n_atoms = out["atoms_per_graph"].float()
+
         if model.is_intensive:
             pred_energy_per_atom = out["e"]
             pred_total_energy = out["e"] * n_atoms
@@ -108,25 +130,18 @@ class WeightedEnergyForcesMAELoss(nn.Module):
             pred_total_energy = out["e"]
             pred_energy_per_atom = pred_total_energy / n_atoms
 
-        ref_total_energy = batch["energy"]              # [B], eV total
+        ref_total_energy = batch["energy"]
         ref_energy_per_atom = ref_total_energy / n_atoms
 
         force_losses = []
         for pred_f, ref_f in zip(out["f"], batch["forces"]):
-            # one scalar per graph: mean over atoms and xyz components
             force_losses.append(torch.abs(pred_f - ref_f).mean())
 
         loss_forces = torch.stack(force_losses).mean()
 
-        # Per atom, also per graph
-        loss_energy = torch.mean(torch.abs(
-            pred_energy_per_atom - ref_energy_per_atom
-        ))
-
-        # Per system
-        # per_system_error = torch.abs(pred_total_energy - ref_total_energy)
-        # loss_energy = torch.sum(per_system_error * n_atoms) / torch.sum(n_atoms)
-
+        loss_energy = torch.mean(
+            torch.abs(pred_energy_per_atom - ref_energy_per_atom)
+        )
 
         total_loss = (
             self.forces_weight * loss_forces
@@ -135,14 +150,15 @@ class WeightedEnergyForcesMAELoss(nn.Module):
 
         return (
             total_loss,
-            loss_energy,       # eV/atom MAE
-            loss_forces,       # force component MAE
+            loss_energy,
+            loss_forces,
             pred_total_energy,
             ref_total_energy,
         )
 
+
 def run_epoch(
-    model: MatRIS,
+    model: DDP,
     loader: DataLoader,
     optimizer: torch.optim.Optimizer | None,
     scheduler: torch.optim.lr_scheduler._LRScheduler | None,
@@ -154,6 +170,8 @@ def run_epoch(
     is_train = optimizer is not None
     model.train(is_train)
 
+    raw_model = unwrap_model(model)
+
     running = {
         "loss": 0.0,
         "energy_mae_per_atom": 0.0,
@@ -163,21 +181,30 @@ def run_epoch(
         "ref_energy_mean": 0.0,
         "lr": 0.0,
     }
-    
 
     n_batches = 0
 
-    for batch in tqdm(loader, desc=f'Running {split}'):
+    iterator = tqdm(loader, desc=f"Running {split}", disable=not is_main_process())
+
+    for batch in iterator:
+        if batch is None:
+            continue
 
         batch = move_matris_batch_to_device(batch, device=device)
 
         if is_train:
-            optimizer.zero_grad()
+            optimizer.zero_grad(set_to_none=True)
 
-        out = model(batch["graphs"], task="ef", is_training=is_train)
+        # Conservative forces need gradients even during validation.
+        if is_train or raw_model.force_stress_head.is_conservation:
+            with torch.enable_grad():
+                out = model(batch["graphs"], task="ef", is_training=is_train)
+        else:
+            with torch.no_grad():
+                out = model(batch["graphs"], task="ef", is_training=False)
 
         loss, energy_loss, force_loss, pred_total_energy, target_total_energy = criterion(
-            model=model,
+            model=raw_model,
             batch=batch,
             out=out,
             do_eval=False,
@@ -187,11 +214,6 @@ def run_epoch(
             loss.backward()
             optimizer.step()
 
-        # For logging: force MAE per atom/component over full batch
-        #pred_forces = torch.cat(out["f"], dim=0)
-        #ref_forces = torch.cat(batch["forces"], dim=0)
-        #force_mae_per_component = torch.abs(pred_forces - ref_forces).mean()
-
         current_lr = optimizer.param_groups[0]["lr"] if is_train else 0.0
 
         running["loss"] += loss.detach().item()
@@ -199,26 +221,40 @@ def run_epoch(
         running["force_mae_per_component"] += force_loss.detach().item()
         running["pred_total_energy_mean"] += pred_total_energy.detach().mean().item()
         running["target_total_energy_mean"] += target_total_energy.detach().mean().item()
-        running["ref_energy_mean"] += out["ref_energy"].detach().mean().item()
-        running["lr"] += current_lr
 
+        ref_energy = out["ref_energy"]
+        if torch.is_tensor(ref_energy):
+            running["ref_energy_mean"] += ref_energy.detach().mean().item()
+        else:
+            running["ref_energy_mean"] += float(ref_energy)
+
+        running["lr"] += current_lr
         n_batches += 1
 
+        del out, loss, energy_loss, force_loss, pred_total_energy, target_total_energy
+
     if n_batches == 0:
-        raise RuntimeError(f"No batches found in {split} loader.")
+        raise RuntimeError(f"No batches found in {split} loader on rank {dist.get_rank()}.")
 
     metrics = {k: v / n_batches for k, v in running.items()}
     metrics["epoch"] = epoch
 
+    # Average metrics across GPUs.
+    for k in list(metrics.keys()):
+        if k != "epoch":
+            metrics[k] = reduce_mean(metrics[k], device=device)
+
     if is_train and scheduler is not None:
         scheduler.step()
 
-    wandb.log({f"{split}/{k}": v for k, v in metrics.items()}, step=epoch)
+    if is_main_process():
+        wandb.log({f"{split}/{k}": v for k, v in metrics.items()}, step=epoch)
 
     return metrics
 
+
 def parse_args():
-    parser = argparse.ArgumentParser(description="Train MatRIS on energy/force data.")
+    parser = argparse.ArgumentParser(description="Train MatRIS on energy/force data with DDP.")
 
     parser.add_argument("--train_path", type=str, default=TRAIN_PATH)
     parser.add_argument("--val_path", type=str, default=VAL_PATH)
@@ -239,13 +275,11 @@ def parse_args():
 
     parser.add_argument("--seed", type=int, default=SEED)
     parser.add_argument("--save_dir", type=str, default=str(SAVE_DIR))
-    parser.add_argument("--device", type=str, default=DEVICE)
 
     parser.add_argument(
         "--is_conservative",
         action=argparse.BooleanOptionalAction,
         default=True,
-        help="Use conservative forces: F = -dE/dx. Use --no-is_conservative for direct force head.",
     )
 
     parser.add_argument(
@@ -258,78 +292,121 @@ def parse_args():
         "--model_name",
         type=str,
         default=None,
-        help="Optional pretrained model name, e.g. matris_10m_oam. If None, trains MatRIS from scratch.",
+    )
+
+    parser.add_argument(
+        "--find_unused_parameters",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Useful if some heads/branches are unused.",
     )
 
     return parser.parse_args()
 
-# =========================
-# Main
-# =========================
-if __name__ == "__main__":
+
+def main():
+    local_rank, rank, world_size, device = setup_ddp()
     args = parse_args()
 
     set_seed(args.seed)
 
     timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-
     run_dir = Path(args.save_dir) / f"{args.run_name}_{timestamp}"
-    run_dir.mkdir(parents=True, exist_ok=True)
-
-    print(f"Saving checkpoints to: {run_dir}")
-
-    wandb.init(
-        project=args.project_name,
-        name=args.run_name,
-        config=vars(args) | {
-            "scheduler": "CosineAnnealingLR",
-            "loss": "forces_mae + energy_mae_per_atom",
-        },
-    )
 
+    if is_main_process():
+        run_dir.mkdir(parents=True, exist_ok=True)
+        print(f"Saving checkpoints to: {run_dir}")
+        print(f"World size: {world_size}")
+        print(f"Per-GPU batch size: {args.batch_size}")
+        print(f"Effective batch size: {args.batch_size * world_size}")
+
+        wandb.init(
+            project=args.project_name,
+            name=args.run_name,
+            config=vars(args) | {
+                "scheduler": "CosineAnnealingLR",
+                "loss": "forces_mae + energy_mae_per_atom",
+                "world_size": world_size,
+                "effective_batch_size": args.batch_size * world_size,
+            },
+        )
 
     if args.model_name is None or args.model_name == "none":
-        print("Training from scratch")
-        model = MatRIS(is_conservation=args.is_conservative).to(args.device)
+        if is_main_process():
+            print("Training from scratch")
+        model = MatRIS(is_conservation=args.is_conservative)
     else:
-        print(f"Starting from foundation model: {args.model_name}")
-        model = MatRIS.load(args.model_name, 
-                            device=args.device,
-                            cache_dir="foundation_models",)
-        # override loaded setting if needed
+        foundation_models_dir = os.environ.get("FOUNDATION_MODELS_DIR", "foundation_models")
+        if is_main_process():
+            print(f"Starting from foundation model: {args.model_name}")
+        model = MatRIS.load(
+            args.model_name,
+            device="cpu",
+            cache_dir=foundation_models_dir,
+        )
         model.force_stress_head.is_conservation = args.is_conservative
 
-
     if args.use_reference_energy:
-        model.reference_energy = build_reference_energy_module(model, E0S_DEFAULT).to(args.device)
+        model.reference_energy = build_reference_energy_module(model, E0S_DEFAULT)
     else:
         model.reference_energy = None
 
-    print("Loaded config is_conservation:", model.config.get("is_conservation"))
-    
-    train_dataset = MatRISDataset(args.train_path, model=model)
-    val_dataset = MatRISDataset(args.val_path, model=model)
+    model = model.to(device)
+
+    model = DDP(
+        model,
+        device_ids=[local_rank],
+        output_device=local_rank,
+        find_unused_parameters=args.find_unused_parameters,
+    )
+
+    raw_model = unwrap_model(model)
+
+    if is_main_process():
+        print("Loaded config is_conservation:", raw_model.config.get("is_conservation"))
+        print("Actual force head is_conservation:", raw_model.force_stress_head.is_conservation)
+        print("Model is_intensive:", raw_model.is_intensive)
+        print(f"Using device: {device}")
+
+    train_dataset = MatRISDataset(args.train_path, model=raw_model)
+    val_dataset = MatRISDataset(args.val_path, model=raw_model)
+
+    train_sampler = DistributedSampler(
+        train_dataset,
+        num_replicas=world_size,
+        rank=rank,
+        shuffle=True,
+        drop_last=False,
+    )
+
+    val_sampler = DistributedSampler(
+        val_dataset,
+        num_replicas=world_size,
+        rank=rank,
+        shuffle=False,
+        drop_last=False,
+    )
 
-    #train_dataset = CachedMatRISDataset(args.train_path)
-    #val_dataset = CachedMatRISDataset(args.val_path)
-    
     train_loader = DataLoader(
         train_dataset,
         batch_size=args.batch_size,
-        shuffle=True,
+        sampler=train_sampler,
+        shuffle=False,
         num_workers=args.num_workers,
         collate_fn=matris_collate_fn,
+        pin_memory=True,
     )
 
     val_loader = DataLoader(
         val_dataset,
         batch_size=args.batch_size,
+        sampler=val_sampler,
         shuffle=False,
         num_workers=args.num_workers,
         collate_fn=matris_collate_fn,
+        pin_memory=True,
     )
 
-
     optimizer = torch.optim.AdamW(
         model.parameters(),
         lr=args.lr,
@@ -347,24 +424,28 @@ if __name__ == "__main__":
         forces_weight=args.force_weight,
     )
 
-    #best_val_loss = float("inf")
-
-    print(f"Using device: {args.device}")
-    print(f"Conservative forces: {args.is_conservative}")
-    print(f"Train size: {len(train_dataset)}")
-    print(f"Val size: {len(val_dataset)}")
+    if is_main_process():
+        print(f"Conservative forces: {args.is_conservative}")
+        print(f"Train size: {len(train_dataset)}")
+        print(f"Val size: {len(val_dataset)}")
 
-    best_checkpoints = []  # [{"path": Path, "val_loss": float, "epoch": int}]
+    best_checkpoints = []
     MAX_BEST_CKPTS = 5
 
-    for epoch in tqdm(range(1, args.epochs + 1), desc=f'Epoch'):
+    for epoch in tqdm(
+        range(1, args.epochs + 1),
+        desc="Epoch",
+        disable=not is_main_process(),
+    ):
+        train_sampler.set_epoch(epoch)
+
         train_metrics = run_epoch(
             model=model,
             loader=train_loader,
             optimizer=optimizer,
             scheduler=scheduler,
             criterion=criterion,
-            device=args.device,
+            device=device,
             epoch=epoch,
             split="train",
         )
@@ -375,79 +456,87 @@ if __name__ == "__main__":
             optimizer=None,
             scheduler=None,
             criterion=criterion,
-            device=args.device,
+            device=device,
             epoch=epoch,
             split="val",
         )
 
         current_lr = optimizer.param_groups[0]["lr"]
 
-        print(
-            f"Epoch {epoch:03d} | "
-            f"lr={current_lr:.2e} | "
-            f"train/loss={train_metrics['loss']:.6f} | "
-            f"train/e_per_atom={train_metrics['energy_mae_per_atom']:.6f} | "
-            f"train/f_per_component={train_metrics['force_mae_per_component']:.6f} | "
-            f"val/loss={val_metrics['loss']:.6f} | "
-            f"val/e_per_atom={val_metrics['energy_mae_per_atom']:.6f} | "
-            f"val/f_per_component={val_metrics['force_mae_per_component']:.6f}"
-        )
+        if is_main_process():
+            print(
+                f"Epoch {epoch:03d} | "
+                f"lr={current_lr:.2e} | "
+                f"train/loss={train_metrics['loss']:.6f} | "
+                f"train/e_per_atom={train_metrics['energy_mae_per_atom']:.6f} | "
+                f"train/f_per_component={train_metrics['force_mae_per_component']:.6f} | "
+                f"val/loss={val_metrics['loss']:.6f} | "
+                f"val/e_per_atom={val_metrics['energy_mae_per_atom']:.6f} | "
+                f"val/f_per_component={val_metrics['force_mae_per_component']:.6f}"
+            )
 
-        wandb.log({"epoch": epoch, "lr": current_lr}, step=epoch)
-
-        ckpt = {
-            "epoch": epoch,
-            "model_state_dict": model.state_dict(),
-            "optimizer_state_dict": optimizer.state_dict(),
-            "scheduler_state_dict": scheduler.state_dict(),
-            "train_metrics": train_metrics,
-            "val_metrics": val_metrics,
-            "args": vars(args),
-        }
-
-        val_loss = val_metrics["loss"]
-        val_e = val_metrics["energy_mae_per_atom"]
-        val_f = val_metrics["force_mae_per_component"]
-
-        ckpt_name = (
-            f"best_epoch={epoch:04d}"
-            f"_val_loss={val_loss:.6f}"
-            f"_val_e_atom={val_e:.6f}"
-            f"_val_f_comp={val_f:.6f}.pt"
-        )        
-        
-        ckpt_path = run_dir / ckpt_name
-
-        should_save = False
-
-        if len(best_checkpoints) < MAX_BEST_CKPTS:
-            should_save = True
-        else:
-            worst_ckpt = max(best_checkpoints, key=lambda x: x["val_loss"])
+            wandb.log({"epoch": epoch, "lr": current_lr}, step=epoch)
+
+            ckpt = {
+                "epoch": epoch,
+                "model_state_dict": raw_model.state_dict(),
+                "optimizer_state_dict": optimizer.state_dict(),
+                "scheduler_state_dict": scheduler.state_dict(),
+                "train_metrics": train_metrics,
+                "val_metrics": val_metrics,
+                "args": vars(args),
+            }
+
+            val_loss = val_metrics["loss"]
+            val_e = val_metrics["energy_mae_per_atom"]
+            val_f = val_metrics["force_mae_per_component"]
+
+            ckpt_name = (
+                f"best_epoch={epoch:04d}"
+                f"_val_loss={val_loss:.6f}"
+                f"_val_e_atom={val_e:.6f}"
+                f"_val_f_comp={val_f:.6f}.pt"
+            )
 
-            if val_loss < worst_ckpt["val_loss"]:
-                if worst_ckpt["path"].exists():
-                    worst_ckpt["path"].unlink()
+            ckpt_path = run_dir / ckpt_name
 
-                best_checkpoints.remove(worst_ckpt)
+            should_save = False
+
+            if len(best_checkpoints) < MAX_BEST_CKPTS:
                 should_save = True
+            else:
+                worst_ckpt = max(best_checkpoints, key=lambda x: x["val_loss"])
+                if val_loss < worst_ckpt["val_loss"]:
+                    if worst_ckpt["path"].exists():
+                        worst_ckpt["path"].unlink()
+                    best_checkpoints.remove(worst_ckpt)
+                    should_save = True
 
-        if should_save:
-            torch.save(ckpt, ckpt_path)
+            if should_save:
+                torch.save(ckpt, ckpt_path)
 
-            best_checkpoints.append(
-                {
-                    "path": ckpt_path,
-                    "val_loss": val_loss,
-                    "epoch": epoch,
-                }
-            )
+                best_checkpoints.append(
+                    {
+                        "path": ckpt_path,
+                        "val_loss": val_loss,
+                        "epoch": epoch,
+                    }
+                )
 
-            best_checkpoints = sorted(best_checkpoints, key=lambda x: x["val_loss"])
+                best_checkpoints = sorted(best_checkpoints, key=lambda x: x["val_loss"])
 
-            print(f"Saved top-{MAX_BEST_CKPTS} checkpoint: {ckpt_name}")
+                print(f"Saved top-{MAX_BEST_CKPTS} checkpoint: {ckpt_name}")
 
-            wandb.run.summary["best_val_loss"] = best_checkpoints[0]["val_loss"]
-            wandb.run.summary["best_epoch"] = best_checkpoints[0]["epoch"]
+                wandb.run.summary["best_val_loss"] = best_checkpoints[0]["val_loss"]
+                wandb.run.summary["best_epoch"] = best_checkpoints[0]["epoch"]
 
-    wandb.finish()
+        dist.barrier()
+
+    if is_main_process():
+        wandb.finish()
+
+    cleanup_ddp()
+
+
+if __name__ == "__main__":
+    main()

models/matris/run_matris_ddp.py

@@ -1,541 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import collections
-import os
-import random
-from datetime import datetime
-from pathlib import Path
-
-import numpy as np
-import torch
-import torch.distributed as dist
-from torch import nn
-from torch.nn.parallel import DistributedDataParallel as DDP
-from torch.utils.data import DataLoader
-from torch.utils.data.distributed import DistributedSampler
-from tqdm import tqdm
-import wandb
-
-from matris.model.model import MatRIS
-from matris.model.reference_energy import AtomRef
-from matris_dataset import MatRISDataset, matris_collate_fn, move_matris_batch_to_device
-
-
-TRAIN_PATH = "datasets/trainingset_251216_train.xyz"
-VAL_PATH = "datasets/trainingset_251216_val.xyz"
-
-PROJECT_NAME = "matris-minimal-training"
-RUN_NAME = "matris-ef-ddp"
-
-BATCH_SIZE = 1
-NUM_WORKERS = 0
-EPOCHS = 1000
-LR = 3e-4
-MIN_LR = 3e-6
-WEIGHT_DECAY = 1e-2
-SEED = 42
-
-ENERGY_LOSS_WEIGHT = 1.0
-FORCE_LOSS_WEIGHT = 1.0
-
-SAVE_DIR = Path("checkpoints_matris")
-SAVE_DIR.mkdir(parents=True, exist_ok=True)
-
-E0S_DEFAULT = {
-    1: 2.467478445,
-    6: 8.0273263225,
-    8: 3.334308855,
-    22: 4.879036065,
-}
-
-
-def setup_ddp():
-    dist.init_process_group(backend="nccl")
-    local_rank = int(os.environ["LOCAL_RANK"])
-    rank = int(os.environ["RANK"])
-    world_size = int(os.environ["WORLD_SIZE"])
-    torch.cuda.set_device(local_rank)
-    device = f"cuda:{local_rank}"
-    return local_rank, rank, world_size, device
-
-
-def cleanup_ddp():
-    if dist.is_initialized():
-        dist.destroy_process_group()
-
-
-def is_main_process():
-    return (not dist.is_initialized()) or dist.get_rank() == 0
-
-
-def reduce_mean(value: float, device: str) -> float:
-    tensor = torch.tensor(value, device=device, dtype=torch.float32)
-    dist.all_reduce(tensor, op=dist.ReduceOp.SUM)
-    tensor /= dist.get_world_size()
-    return tensor.item()
-
-
-def set_seed(seed: int) -> None:
-    rank = dist.get_rank() if dist.is_initialized() else 0
-    seed = seed + rank
-
-    random.seed(seed)
-    np.random.seed(seed)
-    torch.manual_seed(seed)
-    torch.cuda.manual_seed_all(seed)
-
-
-def unwrap_model(model):
-    return model.module if isinstance(model, DDP) else model
-
-
-def build_reference_energy_module(model: MatRIS, e0_dict: dict[int, float]) -> AtomRef:
-    atom_ref = AtomRef(reference_energy="mptrj", is_intensive=model.is_intensive)
-
-    weight = torch.zeros(94, dtype=torch.float32)
-    for Z, e0 in e0_dict.items():
-        weight[Z - 1] = e0
-
-    state_dict = collections.OrderedDict()
-    state_dict["weight"] = weight.view(1, 94)
-    atom_ref.fc.load_state_dict(state_dict)
-
-    atom_ref.fitted = True
-    for p in atom_ref.parameters():
-        p.requires_grad = False
-
-    return atom_ref
-
-
-class WeightedEnergyForcesMAELoss(nn.Module):
-    def __init__(self, energy_weight: float = 1.0, forces_weight: float = 1.0):
-        super().__init__()
-        self.energy_weight = energy_weight
-        self.forces_weight = forces_weight
-
-    def forward(
-        self,
-        model: MatRIS,
-        batch: dict,
-        out: dict,
-        do_eval: bool = False,
-    ):
-        n_atoms = out["atoms_per_graph"].float()
-
-        if model.is_intensive:
-            pred_energy_per_atom = out["e"]
-            pred_total_energy = out["e"] * n_atoms
-        else:
-            pred_total_energy = out["e"]
-            pred_energy_per_atom = pred_total_energy / n_atoms
-
-        ref_total_energy = batch["energy"]
-        ref_energy_per_atom = ref_total_energy / n_atoms
-
-        force_losses = []
-        for pred_f, ref_f in zip(out["f"], batch["forces"]):
-            force_losses.append(torch.abs(pred_f - ref_f).mean())
-
-        loss_forces = torch.stack(force_losses).mean()
-
-        loss_energy = torch.mean(
-            torch.abs(pred_energy_per_atom - ref_energy_per_atom)
-        )
-
-        total_loss = (
-            self.forces_weight * loss_forces
-            + self.energy_weight * loss_energy
-        )
-
-        return (
-            total_loss,
-            loss_energy,
-            loss_forces,
-            pred_total_energy,
-            ref_total_energy,
-        )
-
-
-def run_epoch(
-    model: DDP,
-    loader: DataLoader,
-    optimizer: torch.optim.Optimizer | None,
-    scheduler: torch.optim.lr_scheduler._LRScheduler | None,
-    criterion: WeightedEnergyForcesMAELoss,
-    device: str,
-    epoch: int,
-    split: str,
-) -> dict[str, float]:
-    is_train = optimizer is not None
-    model.train(is_train)
-
-    raw_model = unwrap_model(model)
-
-    running = {
-        "loss": 0.0,
-        "energy_mae_per_atom": 0.0,
-        "force_mae_per_component": 0.0,
-        "pred_total_energy_mean": 0.0,
-        "target_total_energy_mean": 0.0,
-        "ref_energy_mean": 0.0,
-        "lr": 0.0,
-    }
-
-    n_batches = 0
-
-    iterator = tqdm(loader, desc=f"Running {split}", disable=not is_main_process())
-
-    for batch in iterator:
-        if batch is None:
-            continue
-
-        batch = move_matris_batch_to_device(batch, device=device)
-
-        if is_train:
-            optimizer.zero_grad(set_to_none=True)
-
-        # Conservative forces need gradients even during validation.
-        if is_train or raw_model.force_stress_head.is_conservation:
-            with torch.enable_grad():
-                out = model(batch["graphs"], task="ef", is_training=is_train)
-        else:
-            with torch.no_grad():
-                out = model(batch["graphs"], task="ef", is_training=False)
-
-        loss, energy_loss, force_loss, pred_total_energy, target_total_energy = criterion(
-            model=raw_model,
-            batch=batch,
-            out=out,
-            do_eval=False,
-        )
-
-        if is_train:
-            loss.backward()
-            optimizer.step()
-
-        current_lr = optimizer.param_groups[0]["lr"] if is_train else 0.0
-
-        running["loss"] += loss.detach().item()
-        running["energy_mae_per_atom"] += energy_loss.detach().item()
-        running["force_mae_per_component"] += force_loss.detach().item()
-        running["pred_total_energy_mean"] += pred_total_energy.detach().mean().item()
-        running["target_total_energy_mean"] += target_total_energy.detach().mean().item()
-
-        ref_energy = out["ref_energy"]
-        if torch.is_tensor(ref_energy):
-            running["ref_energy_mean"] += ref_energy.detach().mean().item()
-        else:
-            running["ref_energy_mean"] += float(ref_energy)
-
-        running["lr"] += current_lr
-        n_batches += 1
-
-        del out, loss, energy_loss, force_loss, pred_total_energy, target_total_energy
-
-    if n_batches == 0:
-        raise RuntimeError(f"No batches found in {split} loader on rank {dist.get_rank()}.")
-
-    metrics = {k: v / n_batches for k, v in running.items()}
-    metrics["epoch"] = epoch
-
-    # Average metrics across GPUs.
-    for k in list(metrics.keys()):
-        if k != "epoch":
-            metrics[k] = reduce_mean(metrics[k], device=device)
-
-    if is_train and scheduler is not None:
-        scheduler.step()
-
-    if is_main_process():
-        wandb.log({f"{split}/{k}": v for k, v in metrics.items()}, step=epoch)
-
-    return metrics
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Train MatRIS on energy/force data with DDP.")
-
-    parser.add_argument("--train_path", type=str, default=TRAIN_PATH)
-    parser.add_argument("--val_path", type=str, default=VAL_PATH)
-
-    parser.add_argument("--project_name", type=str, default=PROJECT_NAME)
-    parser.add_argument("--run_name", type=str, default=RUN_NAME)
-
-    parser.add_argument("--batch_size", type=int, default=BATCH_SIZE)
-    parser.add_argument("--num_workers", type=int, default=NUM_WORKERS)
-    parser.add_argument("--epochs", type=int, default=EPOCHS)
-
-    parser.add_argument("--lr", type=float, default=LR)
-    parser.add_argument("--min_lr", type=float, default=MIN_LR)
-    parser.add_argument("--weight_decay", type=float, default=WEIGHT_DECAY)
-
-    parser.add_argument("--energy_weight", type=float, default=ENERGY_LOSS_WEIGHT)
-    parser.add_argument("--force_weight", type=float, default=FORCE_LOSS_WEIGHT)
-
-    parser.add_argument("--seed", type=int, default=SEED)
-    parser.add_argument("--save_dir", type=str, default=str(SAVE_DIR))
-
-    parser.add_argument(
-        "--is_conservative",
-        action=argparse.BooleanOptionalAction,
-        default=True,
-    )
-
-    parser.add_argument(
-        "--use_reference_energy",
-        action=argparse.BooleanOptionalAction,
-        default=True,
-    )
-
-    parser.add_argument(
-        "--model_name",
-        type=str,
-        default=None,
-    )
-
-    parser.add_argument(
-        "--find_unused_parameters",
-        action=argparse.BooleanOptionalAction,
-        default=True,
-        help="Useful if some heads/branches are unused.",
-    )
-
-    return parser.parse_args()
-
-
-def main():
-    local_rank, rank, world_size, device = setup_ddp()
-    args = parse_args()
-
-    set_seed(args.seed)
-
-    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-    run_dir = Path(args.save_dir) / f"{args.run_name}_{timestamp}"
-
-    if is_main_process():
-        run_dir.mkdir(parents=True, exist_ok=True)
-        print(f"Saving checkpoints to: {run_dir}")
-        print(f"World size: {world_size}")
-        print(f"Per-GPU batch size: {args.batch_size}")
-        print(f"Effective batch size: {args.batch_size * world_size}")
-
-        wandb.init(
-            project=args.project_name,
-            name=args.run_name,
-            config=vars(args) | {
-                "scheduler": "CosineAnnealingLR",
-                "loss": "forces_mae + energy_mae_per_atom",
-                "world_size": world_size,
-                "effective_batch_size": args.batch_size * world_size,
-            },
-        )
-
-    if args.model_name is None or args.model_name == "none":
-        if is_main_process():
-            print("Training from scratch")
-        model = MatRIS(is_conservation=args.is_conservative)
-    else:
-        if is_main_process():
-            print(f"Starting from foundation model: {args.model_name}")
-        model = MatRIS.load(
-            args.model_name,
-            device="cpu",
-            cache_dir="foundation_models",
-        )
-        model.force_stress_head.is_conservation = args.is_conservative
-
-    if args.use_reference_energy:
-        model.reference_energy = build_reference_energy_module(model, E0S_DEFAULT)
-    else:
-        model.reference_energy = None
-
-    model = model.to(device)
-
-    model = DDP(
-        model,
-        device_ids=[local_rank],
-        output_device=local_rank,
-        find_unused_parameters=args.find_unused_parameters,
-    )
-
-    raw_model = unwrap_model(model)
-
-    if is_main_process():
-        print("Loaded config is_conservation:", raw_model.config.get("is_conservation"))
-        print("Actual force head is_conservation:", raw_model.force_stress_head.is_conservation)
-        print("Model is_intensive:", raw_model.is_intensive)
-        print(f"Using device: {device}")
-
-    train_dataset = MatRISDataset(args.train_path, model=raw_model)
-    val_dataset = MatRISDataset(args.val_path, model=raw_model)
-
-    train_sampler = DistributedSampler(
-        train_dataset,
-        num_replicas=world_size,
-        rank=rank,
-        shuffle=True,
-        drop_last=False,
-    )
-
-    val_sampler = DistributedSampler(
-        val_dataset,
-        num_replicas=world_size,
-        rank=rank,
-        shuffle=False,
-        drop_last=False,
-    )
-
-    train_loader = DataLoader(
-        train_dataset,
-        batch_size=args.batch_size,
-        sampler=train_sampler,
-        shuffle=False,
-        num_workers=args.num_workers,
-        collate_fn=matris_collate_fn,
-        pin_memory=True,
-    )
-
-    val_loader = DataLoader(
-        val_dataset,
-        batch_size=args.batch_size,
-        sampler=val_sampler,
-        shuffle=False,
-        num_workers=args.num_workers,
-        collate_fn=matris_collate_fn,
-        pin_memory=True,
-    )
-
-    optimizer = torch.optim.AdamW(
-        model.parameters(),
-        lr=args.lr,
-        weight_decay=args.weight_decay,
-    )
-
-    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
-        optimizer,
-        T_max=args.epochs,
-        eta_min=args.min_lr,
-    )
-
-    criterion = WeightedEnergyForcesMAELoss(
-        energy_weight=args.energy_weight,
-        forces_weight=args.force_weight,
-    )
-
-    if is_main_process():
-        print(f"Conservative forces: {args.is_conservative}")
-        print(f"Train size: {len(train_dataset)}")
-        print(f"Val size: {len(val_dataset)}")
-
-    best_checkpoints = []
-    MAX_BEST_CKPTS = 5
-
-    for epoch in tqdm(
-        range(1, args.epochs + 1),
-        desc="Epoch",
-        disable=not is_main_process(),
-    ):
-        train_sampler.set_epoch(epoch)
-
-        train_metrics = run_epoch(
-            model=model,
-            loader=train_loader,
-            optimizer=optimizer,
-            scheduler=scheduler,
-            criterion=criterion,
-            device=device,
-            epoch=epoch,
-            split="train",
-        )
-
-        val_metrics = run_epoch(
-            model=model,
-            loader=val_loader,
-            optimizer=None,
-            scheduler=None,
-            criterion=criterion,
-            device=device,
-            epoch=epoch,
-            split="val",
-        )
-
-        current_lr = optimizer.param_groups[0]["lr"]
-
-        if is_main_process():
-            print(
-                f"Epoch {epoch:03d} | "
-                f"lr={current_lr:.2e} | "
-                f"train/loss={train_metrics['loss']:.6f} | "
-                f"train/e_per_atom={train_metrics['energy_mae_per_atom']:.6f} | "
-                f"train/f_per_component={train_metrics['force_mae_per_component']:.6f} | "
-                f"val/loss={val_metrics['loss']:.6f} | "
-                f"val/e_per_atom={val_metrics['energy_mae_per_atom']:.6f} | "
-                f"val/f_per_component={val_metrics['force_mae_per_component']:.6f}"
-            )
-
-            wandb.log({"epoch": epoch, "lr": current_lr}, step=epoch)
-
-            ckpt = {
-                "epoch": epoch,
-                "model_state_dict": raw_model.state_dict(),
-                "optimizer_state_dict": optimizer.state_dict(),
-                "scheduler_state_dict": scheduler.state_dict(),
-                "train_metrics": train_metrics,
-                "val_metrics": val_metrics,
-                "args": vars(args),
-            }
-
-            val_loss = val_metrics["loss"]
-            val_e = val_metrics["energy_mae_per_atom"]
-            val_f = val_metrics["force_mae_per_component"]
-
-            ckpt_name = (
-                f"best_epoch={epoch:04d}"
-                f"_val_loss={val_loss:.6f}"
-                f"_val_e_atom={val_e:.6f}"
-                f"_val_f_comp={val_f:.6f}.pt"
-            )
-
-            ckpt_path = run_dir / ckpt_name
-
-            should_save = False
-
-            if len(best_checkpoints) < MAX_BEST_CKPTS:
-                should_save = True
-            else:
-                worst_ckpt = max(best_checkpoints, key=lambda x: x["val_loss"])
-                if val_loss < worst_ckpt["val_loss"]:
-                    if worst_ckpt["path"].exists():
-                        worst_ckpt["path"].unlink()
-                    best_checkpoints.remove(worst_ckpt)
-                    should_save = True
-
-            if should_save:
-                torch.save(ckpt, ckpt_path)
-
-                best_checkpoints.append(
-                    {
-                        "path": ckpt_path,
-                        "val_loss": val_loss,
-                        "epoch": epoch,
-                    }
-                )
-
-                best_checkpoints = sorted(best_checkpoints, key=lambda x: x["val_loss"])
-
-                print(f"Saved top-{MAX_BEST_CKPTS} checkpoint: {ckpt_name}")
-
-                wandb.run.summary["best_val_loss"] = best_checkpoints[0]["val_loss"]
-                wandb.run.summary["best_epoch"] = best_checkpoints[0]["epoch"]
-
-        dist.barrier()
-
-    if is_main_process():
-        wandb.finish()
-
-    cleanup_ddp()
-
-
-if __name__ == "__main__":
-    main()

models/matris/scripts/bench_matris_speed_single.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+set -euo pipefail
+
+# =========================
+# Resolve paths
+# =========================
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+MATRIS_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+# =========================
+# Config
+# =========================
+BENCH_SCRIPT="$MATRIS_DIR/bench_matris_speed_single.py"
+
+XYZ_PATH="$REPO_ROOT/datasets/xyz/test.xyz"
+
+MODEL_NAME="none" # ["none", "matris_10m_oam", "matris_10m_mp"]
+
+DEVICE="cpu"
+
+TARGET_NATOMS=96
+WARMUP=50
+ITERS=300
+
+IS_CONSERVATIVE=true
+
+# =========================
+# Flags
+# =========================
+CONSERVATIVE_FLAG="--is-conservative"
+
+if [ "$IS_CONSERVATIVE" = false ]; then
+    CONSERVATIVE_FLAG=""
+fi
+
+# =========================
+# Sanity checks
+# =========================
+if [ ! -f "$BENCH_SCRIPT" ]; then
+    echo "ERROR: Benchmark script not found:"
+    echo "$BENCH_SCRIPT"
+    exit 1
+fi
+
+if [ ! -f "$XYZ_PATH" ]; then
+    echo "ERROR: XYZ dataset not found:"
+    echo "$XYZ_PATH"
+    exit 1
+fi
+
+# =========================
+# Run
+# =========================
+echo "======================================"
+echo "Running MatRIS speed benchmark"
+echo "Benchmark script: $BENCH_SCRIPT"
+echo "XYZ path: $XYZ_PATH"
+echo "Model: $MODEL_NAME"
+echo "Device: $DEVICE"
+echo "Target natoms: $TARGET_NATOMS"
+echo "Warmup: $WARMUP"
+echo "Iterations: $ITERS"
+echo "Conservative: $IS_CONSERVATIVE"
+echo "======================================"
+
+python3 "$BENCH_SCRIPT" \
+    --xyz "$XYZ_PATH" \
+    --model-name "$MODEL_NAME" \
+    $CONSERVATIVE_FLAG \
+    --device "$DEVICE" \
+    --target-natoms "$TARGET_NATOMS" \
+    --warmup "$WARMUP" \
+    --iters "$ITERS"

models/matris/scripts/eval_matris.sh

@@ -0,0 +1,103 @@
+#!/bin/bash
+
+set -e
+
+# =========================
+# Resolve paths
+# =========================
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+MATRIS_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+# =========================
+# Config
+# =========================
+TEST_PATH="$REPO_ROOT/datasets/xyz/test.xyz"
+
+CHECKPOINT="$MATRIS_DIR/runs/matris_cons_seed2000_epoch43.pt" # Add checkpoint here
+
+EVAL_SCRIPT="$MATRIS_DIR/eval_matris.py"
+
+RANDOM_INIT=false   # true = evaluate random init model, false = load checkpoint
+
+BATCH_SIZE=1
+DEVICE="cuda"
+
+IS_CONSERVATIVE=true # true = use conservative forces, false = use standard forces
+USE_REFERENCE_ENERGY=true
+
+MODEL_NAME="none"  # ["none", "matris_10m_oam", "matris_10m_mp"]
+
+# =========================
+# Flags
+# =========================
+CONSERVATIVE_FLAG="--is_conservative"
+if [ "$IS_CONSERVATIVE" = false ]; then
+    CONSERVATIVE_FLAG="--no-is_conservative"
+fi
+
+REF_FLAG="--use_reference_energy"
+if [ "$USE_REFERENCE_ENERGY" = false ]; then
+    REF_FLAG="--no-use_reference_energy"
+fi
+
+RANDOM_INIT_ARGS=()
+CHECKPOINT_ARGS=()
+
+
+if [ "$RANDOM_INIT" = true ]; then
+    RANDOM_INIT_FLAG="--random_init"
+else
+    CHECKPOINT_ARGS=(--checkpoint "$CHECKPOINT")
+fi
+
+# =========================
+# Sanity checks
+# =========================
+if [ ! -f "$EVAL_SCRIPT" ]; then
+    echo "ERROR: Eval script not found:"
+    echo "$EVAL_SCRIPT"
+    exit 1
+fi
+
+if [ ! -f "$TEST_PATH" ]; then
+    echo "ERROR: Test dataset not found:"
+    echo "$TEST_PATH"
+    exit 1
+fi
+
+if [ "$RANDOM_INIT" = true ]; then
+    RANDOM_INIT_ARGS=(--random_init)
+else
+    CHECKPOINT_ARGS=(--checkpoint "$CHECKPOINT")
+fi
+
+# =========================
+# Run
+# =========================
+echo "======================================"
+echo "Running MatRIS evaluation"
+echo "Eval script: $EVAL_SCRIPT"
+echo "Random init: $RANDOM_INIT"
+
+if [ "$RANDOM_INIT" = true ]; then
+    echo "Checkpoint: <not used>"
+else
+    echo "Checkpoint: $CHECKPOINT"
+fi
+
+echo "Test path:  $TEST_PATH"
+echo "Model name: $MODEL_NAME"
+echo "Conservative: $IS_CONSERVATIVE"
+echo "Reference energy: $USE_REFERENCE_ENERGY"
+echo "======================================"
+
+python3 "$EVAL_SCRIPT" \
+    --test_path "$TEST_PATH" \
+    "${CHECKPOINT_ARGS[@]}" \
+    --batch_size "$BATCH_SIZE" \
+    --model_name "$MODEL_NAME" \
+    --device "$DEVICE" \
+    "$CONSERVATIVE_FLAG" \
+    "$REF_FLAG" \
+    "${RANDOM_INIT_ARGS[@]}"

models/matris/scripts/run_matris.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+
+# =========================
+# Resolve paths
+# =========================
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+MATRIS_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+
+
+# =========================
+# Default config
+# =========================
+TRAIN_PATH="$REPO_ROOT/datasets/xyz/train.xyz"
+VAL_PATH="$REPO_ROOT/datasets/xyz/val.xyz"
+SAVE_DIR="$MATRIS_DIR/checkpoints_matris"
+TRAIN_SCRIPT="$MATRIS_DIR/run_matris.py"
+FOUNDATION_MODELS_DIR="$MATRIS_DIR/foundation_models"
+
+PROJECT_NAME="matris"
+RUN_NAME="matris"
+
+BATCH_SIZE=1          # per GPU
+NUM_WORKERS=8
+EPOCHS=100
+LR=3e-4
+MIN_LR=3e-6
+WEIGHT_DECAY=1e-2
+
+ENERGY_WEIGHT=5.0
+FORCE_WEIGHT=5.0
+
+SEED=42
+
+
+IS_CONSERVATIVE=true
+USE_REFERENCE_ENERGY=true
+MODEL_NAME="matris_10m_oam" # ["none", "matris_10m_oam", "matris_10m_mp"]
+
+
+# =========================
+# Detect GPUs
+# =========================
+NUM_GPUS="${NUM_GPUS:-}"
+
+if [ -z "$NUM_GPUS" ]; then
+    NUM_GPUS=$(python3 - <<'PY'
+import torch
+print(torch.cuda.device_count())
+PY
+)
+fi
+
+if [ "$NUM_GPUS" -lt 1 ]; then
+    echo "ERROR: No GPUs detected."
+    exit 1
+fi
+
+echo "Detected GPUs: $NUM_GPUS"
+echo "Effective batch size: $((BATCH_SIZE * NUM_GPUS))"
+
+
+# =========================
+# Boolean flags
+# =========================
+CONSERVATIVE_FLAG="--is_conservative"
+if [ "$IS_CONSERVATIVE" = false ]; then
+    CONSERVATIVE_FLAG="--no-is_conservative"
+fi
+
+REF_FLAG="--use_reference_energy"
+if [ "$USE_REFERENCE_ENERGY" = false ]; then
+    REF_FLAG="--no-use_reference_energy"
+fi
+
+MODEL_FLAG=()
+if [ -n "$MODEL_NAME" ]; then
+    MODEL_FLAG=(--model_name "$MODEL_NAME")
+fi
+
+# =========================
+# Run DDP
+# =========================
+export WANDB__SERVICE_WAIT=300
+export FOUNDATION_MODELS_DIR="$FOUNDATION_MODELS_DIR"
+
+torchrun \
+    --standalone \
+    --nproc_per_node="$NUM_GPUS" \
+    "$TRAIN_SCRIPT" \
+    --train_path "$TRAIN_PATH" \
+    --val_path "$VAL_PATH" \
+    --project_name "$PROJECT_NAME" \
+    --run_name "$RUN_NAME" \
+    --batch_size "$BATCH_SIZE" \
+    --num_workers "$NUM_WORKERS" \
+    --epochs "$EPOCHS" \
+    --lr "$LR" \
+    --min_lr "$MIN_LR" \
+    --weight_decay "$WEIGHT_DECAY" \
+    --energy_weight "$ENERGY_WEIGHT" \
+    --force_weight "$FORCE_WEIGHT" \
+    --seed "$SEED" \
+    --save_dir "$SAVE_DIR" \
+    "$CONSERVATIVE_FLAG" \
+    "$REF_FLAG" \
+    "${MODEL_FLAG[@]}"