third_party/SGMNet/train/main.py

import torch.utils.data
from dataset import Offline_Dataset
import yaml
from sgmnet.match_model import matcher as SGM_Model
from superglue.match_model import matcher as SG_Model
import torch.distributed as dist
import torch
import os
from collections import namedtuple
from train import train
from config import get_config, print_usage


def main(config, model_config):
    """The main function."""
    # Initialize network
    if config.model_name == "SGM":
        model = SGM_Model(model_config)
    elif config.model_name == "SG":
        model = SG_Model(model_config)
    else:
        raise NotImplementedError

    # initialize ddp
    torch.cuda.set_device(config.local_rank)
    device = torch.device(f"cuda:{config.local_rank}")
    model.to(device)
    dist.init_process_group(backend="nccl", init_method="env://")
    model = torch.nn.parallel.DistributedDataParallel(
        model, device_ids=[config.local_rank]
    )

    if config.local_rank == 0:
        os.system("nvidia-smi")

    # initialize dataset
    train_dataset = Offline_Dataset(config, "train")
    train_sampler = torch.utils.data.distributed.DistributedSampler(
        train_dataset, shuffle=True
    )
    train_loader = torch.utils.data.DataLoader(
        train_dataset,
        batch_size=config.train_batch_size // torch.distributed.get_world_size(),
        num_workers=8 // dist.get_world_size(),
        pin_memory=False,
        sampler=train_sampler,
        collate_fn=train_dataset.collate_fn,
    )

    valid_dataset = Offline_Dataset(config, "valid")
    valid_sampler = torch.utils.data.distributed.DistributedSampler(
        valid_dataset, shuffle=False
    )
    valid_loader = torch.utils.data.DataLoader(
        valid_dataset,
        batch_size=config.train_batch_size,
        num_workers=8 // dist.get_world_size(),
        pin_memory=False,
        collate_fn=valid_dataset.collate_fn,
        sampler=valid_sampler,
    )

    if config.local_rank == 0:
        print("start training .....")
    train(model, train_loader, valid_loader, config, model_config)


if __name__ == "__main__":
    # ----------------------------------------
    # Parse configuration
    config, unparsed = get_config()
    with open(config.config_path, "r") as f:
        model_config = yaml.load(f)
    model_config = namedtuple("model_config", model_config.keys())(
        *model_config.values()
    )
    # If we have unparsed arguments, print usage and exit
    if len(unparsed) > 0:
        print_usage()
        exit(1)

    main(config, model_config)