models/equiformerv2/training_equiformer.py

import os 
import sys
ROOT = os.path.dirname(os.path.abspath(__file__))           # path to experiments/
ROOT = os.path.abspath(os.path.join(ROOT, "."))             # repo root
sys.path.insert(0, ROOT)                                    # so local packages import
sys.path.insert(0, os.path.join(ROOT, "equiformer_v2/ocp")) # so 'ocpmodels' resolves
import argparse
from datetime import datetime
import torch
from torch import nn, optim
import torch.nn.functional as F
from torch.utils.data import DataLoader, DistributedSampler
from torch.optim.lr_scheduler import CosineAnnealingLR, LambdaLR
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from pytorch_lightning import seed_everything
from tqdm import tqdm
from datetime import datetime
from equiformer_v2.nets.equiformer_v2.equiformer_v2_oc20 import EquiformerV2_OC20 as EquiformerV2
from utils import * 
from model_configs import *
from types import SimpleNamespace
import wandb



def main():

    parser = argparse.ArgumentParser()

    parser.add_argument(
    "--name",
    type=str,
    default="default",
    help="Optional experiment name prefix (used in checkpoint path and logging)."
    )

    # New: experiment controls
    parser.add_argument(
        "--model_config",
        type=str,
        choices=["orig", "small"],
        default="orig",
        help="Choose Equiformer model config preset."
    )
    parser.add_argument(
        "--seed",
        type=int,
        default=42,
        help="Random seed."
    )

    parser.add_argument(
    "--dataset",
    type=str,
    required=True,
    help="Path to the training/validation .h5 dataset.",
    )



    #-------------------------------------

    args, _ = parser.parse_known_args()

    # DDP
    local_rank = int(os.environ.get("LOCAL_RANK", 0))

    torch.cuda.set_device(local_rank)
    dist.init_process_group(backend="nccl", init_method="env://")

    device = torch.device(f'cuda:{local_rank}' if torch.cuda.is_available() else "cpu")


    # hyperparams:
    num_epochs = 100
    lr = 0.0004
    weight_decay = 1e-3
    loss_forces_weight = 25

    batch_size = 1
    eval_batch_size = 1

    # NOTE idk why
    SEED = args.seed

    DATA_PATH = args.dataset
    #TEST_DATA_PATH = args.test_data_path

    if args.model_config == "orig":
        model_config = model_config_orig
        model_config = {**model_config, "avg_num_nodes": 86.7569, "avg_degree": 18.64958191066762} # avg_num_nodes is NOT used and is given here for the sake of completeness
    else:
        model_config = model_config_small
        # NOTE They will change I'm pretty sure later
        model_config = {**model_config, "avg_num_nodes": 86.7569, "avg_degree": 18.64958191066762} # avg_num_nodes is NOT used and is given here for the sake of completeness

    seed_everything(SEED, workers=True)

    # NOTE Needed?
    if torch.cuda.is_available():
        torch.backends.cudnn.deterministic = True
        torch.backends.cudnn.benchmark = False


    train_dataset = DFTDatasetH5(DATA_PATH, split="train")#, verify_splits=True)
    val_dataset   = DFTDatasetH5(DATA_PATH, split="val")#, verify_splits=True)
    #test_dataset  = DFTDatasetH5(TEST_DATA_PATH)

    # create DistributedSampler for each dataset:
    train_sampler = DistributedSampler(train_dataset, shuffle=True)
    val_sampler = DistributedSampler(val_dataset)
    #test_sampler = DistributedSampler(test_dataset)

    # adjust the DataLoaders:
    train_loader = DataLoader(train_dataset, batch_size, sampler=train_sampler, shuffle=False, collate_fn=custom_collate_fn)
    val_loader = DataLoader(val_dataset, eval_batch_size, sampler=val_sampler, shuffle=False, collate_fn=custom_collate_fn)
    #test_loader = DataLoader(test_dataset, eval_batch_size, sampler=test_sampler, shuffle=False, collate_fn=custom_collate_fn) 



    model = EquiformerV2(None, None, None, **model_config).to(device)
    model = DDP(model, device_ids=[local_rank], output_device=local_rank)


    CHECKPOINT_PATH = (
    f"checkpoints/equiformer/"
    f"{datetime.now().strftime('%y%m%d_%H%M%S')}_"
    f"{args.name}_"
    f"{args.model_config}_"
    f"{args.dataset}_"
    f"seed{SEED}"
    )   

    # Set up Wandb
    run = None
    if dist.get_rank() == 0:
        run = wandb.init(
            project="equimodel-mxene",              # change
            name=os.path.basename(CHECKPOINT_PATH), # nice readable run name
            config={
                "seed": SEED,
                "dataset": args.dataset,
                "model_config": args.model_config,
                "num_epochs": num_epochs,
                "lr": lr,
                "weight_decay": weight_decay,
                "loss_forces_weight": loss_forces_weight,
                "batch_size": batch_size,
                "eval_batch_size": eval_batch_size,
                "world_size": dist.get_world_size(),
            },
        )

        # (Optional) make W&B charts nicer by telling it what the “step” axis is
        wandb.define_metric("epoch")
        wandb.define_metric("train/*", step_metric="epoch")
        wandb.define_metric("val/*", step_metric="epoch")
        wandb.define_metric("test/*", step_metric="epoch")



    if dist.get_rank() == 0:
        print("Running...\n")
        print(f'Seed: {args.seed}')
        print(f'Model config: {args.model_config}')
        print(f'Dataset: {args.dataset}\n')
        print(f"Dataset size:\ntrain: {len(train_dataset)}, val: {len(val_dataset)}, test: {len([])}")
        count_parameters(model)
        print(f'Checkpoint path: {CHECKPOINT_PATH}')
        os.makedirs(CHECKPOINT_PATH, exist_ok=True)
    #dist.barrier()


    best_val_metric = float('inf')  # for tracking the best validation loss
    criterion = nn.L1Loss(reduction="mean")
    optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=weight_decay)
    scheduler = CosineAnnealingLR(optimizer, T_max=num_epochs, eta_min=0.01*lr)

    # train and validate the model:
    train_ls, train_ls_f, train_ls_e, val_ls, val_ls_f, val_ls_e = \
        train_and_validate(
        model, 
        train_loader, 
        val_loader, 
        criterion, 
        optimizer, 
        device,
        loss_forces_weight=loss_forces_weight, 
        num_epochs=num_epochs, 
        scheduler=scheduler,
        best_val_metric=best_val_metric,
        checkpoint_path=CHECKPOINT_PATH)

    # if args.do_test:

    #     # load the best model:
    #     model, optimizer, epoch, best_val_metric = load_checkpoint(CHECKPOINT_PATH+"/best_model.pth", model, optimizer)
    #     if dist.get_rank() == 0:        
    #         print(f"Model successfully loaded. Best val metric: {best_val_metric}")

    #     # sanity check: test on the validation set again
    #     if dist.get_rank() == 0:        
    #         print(f"\nSanity check: testing on the validation set")
    #     _val_ls, _val_ls_forces, _val_ls_energy = test(model, val_loader, criterion, device)

    #     # test the model:
    #     test_ls, test_ls_forces, test_ls_energy = test(model, test_loader, criterion, device)

    # if dist.get_rank() == 0:
    #     wandb.finish()

    # dist.destroy_process_group()


def train_and_validate(model, train_loader, val_loader, criterion, optimizer, device,
                       num_epochs=10, loss_forces_weight=10, scheduler=None,
                       best_val_metric=float('inf'), checkpoint_path=''):
    if dist.get_rank() == 0:
        print("\n\nTraining the model")

    train_ls, train_ls_f, train_ls_e, val_ls, val_ls_f, val_ls_e = [], [], [], [], [], []
    t0 = datetime.now()

    # global step for per-batch logging if you want it later
    global_step = 0

    for epoch in range(num_epochs):
        train_loader.sampler.set_epoch(epoch)
        model.train()
        
        train_loss_optim_num = 0.0
        train_loss_forces = 0.0
        train_loss_energy = 0.0
        total_atoms = 0
        total_batch_systems = 0

        # tqdm for training loop (only on main process)
        train_iter = train_loader
        if dist.get_rank() == 0:
            train_iter = tqdm(train_loader, desc=f"Epoch {epoch+1}/{num_epochs} [Train]", leave=False)

        for data in train_iter:
            data = {k: v.to(device) for k, v in data.items()}
            data = SimpleNamespace(**data)
            optimizer.zero_grad()

            eff_batch_size = data.natoms.sum().item()
            batch_systems = data.natoms.shape[0]
            total_atoms += eff_batch_size
            total_batch_systems += batch_systems

            pred_energy, pred_forces = model(data)
            
            loss_forces = criterion(pred_forces, data.forces)
            loss_energy = criterion(pred_energy, data.energy)
            
            loss = loss_forces_weight * loss_forces + (1 / eff_batch_size) * loss_energy

            # NOTE Logging what we actually optimize as well
            train_loss_optim_num += loss.item() * eff_batch_size
            # train_loss_optim_num += (
            # loss_forces_weight * loss_forces.item() * eff_batch_size
            # + loss_energy.item()
            # )


            loss.backward()
            optimizer.step()

            train_loss_forces += loss_forces.item() * eff_batch_size
            train_loss_energy += loss_energy.item() * batch_systems

            if dist.get_rank() == 0:
                train_iter.set_postfix({
                    "forces_loss": f"{loss_forces.item():.4f}",
                    "energy_loss": f"{loss_energy.item():.4f}"
                })
           
            global_step += 1
            
            

        if scheduler is not None:
            scheduler.step()

        torch.cuda.synchronize()
        torch.cuda.empty_cache()

        train_loss_tensor = torch.tensor([train_loss_forces, train_loss_energy, train_loss_optim_num,
                                          total_atoms, total_batch_systems], device=device) # NOTE removed train_loss from index 0
        
        dist.all_reduce(train_loss_tensor, op=dist.ReduceOp.SUM)

        train_force_num, train_energy_num, train_optim_num, train_atoms_den, train_systems_den = train_loss_tensor.tolist()
        
        train_loss_forces = train_force_num / train_atoms_den
        train_loss_energy = train_energy_num / train_systems_den
        
        train_loss = train_loss_forces + train_loss_energy
        train_loss_optim = train_optim_num / train_atoms_den
        
        # NOTE Skipping the indexing
        #train_loss_forces = train_loss_tensor[0].item() / train_loss_tensor[2].item()
        #train_loss_energy = train_loss_tensor[1].item() / train_loss_tensor[3].item()
        #train_loss = train_loss_forces + train_loss_energy

        # validation phase:
        model.eval()
        val_loss_optim_num = 0.0
        val_loss_forces = 0.0
        val_loss_energy = 0.0
        total_val_atoms = 0
        total_val_batch_systems = 0

        val_iter = val_loader
        if dist.get_rank() == 0:
            val_iter = tqdm(val_loader, desc=f"Epoch {epoch+1}/{num_epochs} [Val]", leave=False)

        with torch.no_grad():
            for data in val_iter:
                data = {k: v.to(device) for k, v in data.items()}
                data = SimpleNamespace(**data)

                eff_batch_size = data.natoms.sum().item()
                batch_systems = data.natoms.shape[0]
                total_val_atoms += eff_batch_size
                total_val_batch_systems += batch_systems

                pred_energy, pred_forces = model(data)
                
                loss_forces = criterion(pred_forces, data.forces)
                loss_energy = criterion(pred_energy, data.energy)
                loss = loss_forces + loss_energy

                # NOTE Logging what we actually optimize as well
                loss_optim = loss_forces_weight * loss_forces + (1.0 / eff_batch_size) * loss_energy
                val_loss_optim_num += loss_optim.item() * eff_batch_size

                val_loss_forces += loss_forces.item() * eff_batch_size
                val_loss_energy += loss_energy.item() * batch_systems

                if dist.get_rank() == 0:
                    val_iter.set_postfix({
                        "forces_loss": f"{loss_forces.item():.4f}",
                        "energy_loss": f"{loss_energy.item():.4f}"
                    })

        val_loss_tensor = torch.tensor([val_loss_forces, val_loss_energy, val_loss_optim_num,
                                        total_val_atoms, total_val_batch_systems], device=device)
        dist.all_reduce(val_loss_tensor, op=dist.ReduceOp.SUM)
        
        val_force_num, val_energy_num, val_optim_num, val_atoms_den, val_systems_den = val_loss_tensor.tolist()

        val_loss_forces = val_force_num / val_atoms_den
        val_loss_energy = val_energy_num / val_systems_den
        
        val_loss = val_loss_forces + val_loss_energy
        val_loss_optim = val_optim_num / val_atoms_den
        
        #val_loss_forces = val_loss_tensor[1].item() / val_loss_tensor[-2].item()
        #val_loss_energy = val_loss_tensor[2].item() / val_loss_tensor[-1].item()
        #val_loss = val_loss_forces + val_loss_energy

        # collect losses
        train_ls.append(train_loss)
        train_ls_f.append(train_loss_forces)
        train_ls_e.append(train_loss_energy)
        val_ls.append(val_loss)
        val_ls_f.append(val_loss_forces)
        val_ls_e.append(val_loss_energy)

        if dist.get_rank() == 0:
            wandb.log(
            {
                "epoch": epoch + 1,

                "train/loss_forces": train_loss_forces,
                "train/loss_energy": train_loss_energy,
                "train/loss_total": train_loss,
                "train/loss_optim": train_loss_optim,

                "val/loss_forces": val_loss_forces,
                "val/loss_energy": val_loss_energy,
                "val/loss_total": val_loss,
                "val/loss_optim": val_loss_optim,

                "lr": optimizer.param_groups[0]["lr"],
            },
            step=epoch + 1,  # epoch-step
            )
                

            if val_loss < best_val_metric:
                best_val_metric = val_loss
                save_checkpoint(model, optimizer, epoch, best_val_metric, checkpoint_path, is_best=True)
                print(f"Epoch {epoch+1}: New best model saved with validation loss {val_loss:.4f}")

            if epoch == num_epochs - 1:
                save_checkpoint(model, optimizer, epoch, val_loss, checkpoint_path, is_best=False)
                print(f"Epoch {epoch+1}: Model saved with validation loss {val_loss:.4f}")

            t1 = datetime.now()
            print(f"Epoch {epoch+1} ({t1 - t0}): "
                  f"Train Loss: {train_loss_forces:.4f} + {train_loss_energy:.4f} = {train_loss:.4f}, "
                  f"Validation Loss: {val_loss_forces:.4f} + {val_loss_energy:.4f} = {val_loss:.4f}")

    print("Training and validation done")
    return train_ls, train_ls_f, train_ls_e, val_ls, val_ls_f, val_ls_e

def test(model, test_loader, criterion, device):
    if dist.get_rank() == 0:
        print("\n\nTesting the model")
    model.eval()

    test_loss = torch.tensor(0.0, device=device)
    test_loss_forces = torch.tensor(0.0, device=device)
    test_loss_energy = torch.tensor(0.0, device=device)
    total_test_atoms = torch.tensor(0, device=device)
    total_test_batch_systems = torch.tensor(0, device=device)

    with torch.no_grad():
        for data in test_loader:
            data = {k: v.to(device) for k, v in data.items()}
            data = SimpleNamespace(**data)

            pred_energy, pred_forces= model(data)
            loss_forces = criterion(pred_forces, data.forces)
            loss_energy = criterion(pred_energy, data.energy)
            loss = loss_forces + loss_energy

            eff_batch_size = data.natoms.sum().item()
            batch_systems = data.natoms.shape[0]
            total_test_atoms += eff_batch_size
            total_test_batch_systems += batch_systems

            test_loss_forces += loss_forces * eff_batch_size
            test_loss_energy += loss_energy * batch_systems

    dist.all_reduce(test_loss_forces, op=dist.ReduceOp.SUM)
    dist.all_reduce(test_loss_energy, op=dist.ReduceOp.SUM)
    dist.all_reduce(total_test_atoms, op=dist.ReduceOp.SUM)
    dist.all_reduce(total_test_batch_systems, op=dist.ReduceOp.SUM)

    test_loss_forces = test_loss_forces.item() / total_test_atoms.item()
    test_loss_energy = test_loss_energy.item() / total_test_batch_systems.item()
    test_loss = test_loss_forces + test_loss_energy

    if dist.get_rank() == 0:
        # NOTE Perhaps we can skip logging in test
        # wandb.log(
        # {
        #     "epoch": num_epochs,  # or epoch+1 if you pass it in
        #     "test/loss_forces": test_loss_forces,
        #     "test/loss_energy": test_loss_energy,
        #     "test/loss_total": test_loss,
        # },
        # step=num_epochs,
        # )
        print(f'Test Loss: {test_loss_forces:.4f} + {test_loss_energy:.4f} = {test_loss:.4f}')
        return test_loss, test_loss_forces, test_loss_energy
    else:
        return None, None, None


if __name__ == "__main__":
    main()