def METHOD_NAME(self, model_path, inputs=None, outputs=None):
    # debug prints
    # print(model_path, inputs, outputs)
    print(f"Loading model from {model_path}")
    print("Initializing embeddings...")
    dist.init_process_group(backend=self.dist_backend, rank=0, world_size=1)
    eb_configs = [
        EmbeddingBagConfig(
            name=f"t_{feature_name}",
            embedding_dim=self.embedding_dim,
            num_embeddings=self.num_embeddings_per_feature[feature_idx],
            feature_names=[feature_name],
        )
        for feature_idx, feature_name in enumerate(DEFAULT_CAT_NAMES)
    ]
    print("Initializing model...")
    dlrm_model = DLRM_DCN(
        embedding_bag_collection=EmbeddingBagCollection(
            tables=eb_configs, device=torch.device("meta")
        ),
        dense_in_features=len(DEFAULT_INT_NAMES),
        dense_arch_layer_sizes=self.dense_arch_layer_sizes,
        over_arch_layer_sizes=self.over_arch_layer_sizes,
        dcn_num_layers=self.dcn_num_layers,
        dcn_low_rank_dim=self.dcn_low_rank_dim,
        dense_device=self.device,
    )
    model = DLRMTrain(dlrm_model)
    print("Distributing the model...")
    planner = EmbeddingShardingPlanner(
        topology=Topology(
            local_world_size=get_local_size(),
            world_size=dist.get_world_size(),
            compute_device=self.device.type,
        ),
        storage_reservation=HeuristicalStorageReservation(percentage=0.05),
    )
    plan = planner.collective_plan(
        model, get_default_sharders(), dist.GroupMember.WORLD
    )
    self.model = DistributedModelParallel(
        module=model,
        device=self.device,
        plan=plan
    )
    # path_to_sharded_weights should have 2 subdirectories - batched and sharded
    # If we need to load the weights on different device or world size, we would need to change the process
    # group accordingly. If we would want to load on 8 GPUs, the process group created above should be fine
    # to understand sharding, --print_sharding_plan flag should be used while running dlrm_main.py in
    # torcherec implementation
    if not self.debug:
        print("Loading model weights...")
        from torchsnapshot import Snapshot
        snapshot = Snapshot(path=model_path)
        snapshot.restore(app_state={"model": self.model})
        ### To understand the keys in snapshot, you can look at following code snippet.
        # d = snapshot.get_manifest()
        # for k, v in d.items():
        #     print(k, v)
    self.model.eval()
    return self