code: def load_from_mmar(
      item: Mapping | str | int,
      mmar_dir: PathLike | None = None,
      progress: bool = True,
      version: int = -1,
      map_location: Any | None = None,
      pretrained: bool = True,
      weights_only: bool = False,
      model_key: str = "model",
      api: bool = True,
      model_file: PathLike | None = None,
  ) -> Any:
      """
      Download and extract Medical Model Archive (MMAR) model weights from Nvidia Clara Train.
  
      Args:
          item: the corresponding model item from `MODEL_DESC`.
          mmar_dir: : target directory to store the MMAR, default is mmars subfolder under `torch.hub get_dir()`.
          progress: whether to display a progress bar when downloading the content.
          version: version number of the MMAR. Set it to `-1` to use `item[Keys.VERSION]`.
          map_location: pytorch API parameter for `torch.load` or `torch.jit.load`.
          pretrained: whether to load the pretrained weights after initializing a network module.
          weights_only: whether to load only the weights instead of initializing the network module and assign weights.
          model_key: a key to search in the model file or config file for the model dictionary.
              Currently this function assumes that the model dictionary has
              `{"[name|path]": "test.module", "args": {'kw': 'test'}}`.
          api: whether to query NGC API to get model infomation.
          model_file: the relative path to the model file within an MMAR.
  
      Examples::
          >>> from monai.apps import load_from_mmar
          >>> unet_model = load_from_mmar("clara_pt_prostate_mri_segmentation_1", mmar_dir=".", map_location="cpu")
          >>> print(unet_model)
  
      See Also:
          https://docs.nvidia.com/clara/
      """
      if api:
          item = {
              Keys.NAME: get_model_spec(item)[Keys.NAME]
              if isinstance(item, int)
              else f"{item}"
          }
      if not isinstance(item, Mapping):
          item = get_model_spec(item)
      model_dir = download_mmar(
          item=item,
          mmar_dir=mmar_dir,
          progress=progress,
          version=version,
          api=api,
      )
      if model_file is None:
          model_file = os.path.join("models", "model.pt")
      _model_file = model_dir / item.get(Keys.MODEL_FILE, model_file)
      logger.info(
          f'\n*** "{item.get(Keys.NAME)}" available at {model_dir}.'
      )
  
      # loading with `torch.jit.load`
      if _model_file.name.endswith(".ts"):
          if not pretrained:
              warnings.warn(
                  "Loading a ScriptModule, 'pretrained' option ignored."
              )
          if weights_only:
              warnings.warn(
                  "Loading a ScriptModule, 'weights_only' option ignored."
              )
          return torch.jit.load(_model_file, map_location=map_location)
  
      # loading with `torch.load`
      model_dict = torch.load(_model_file, map_location=map_location)
      if weights_only:
          return model_dict.get(
              model_key, model_dict
          )  # model_dict[model_key] or model_dict directly
  
      # 1. search `model_dict['train_config]` for model config spec.
      model_config = _get_val(
          dict(model_dict).get("train_conf", {}),
          key=model_key,
          default={},
      )
      if not model_config or not isinstance(model_config, Mapping):
          # 2. search json CONFIG_FILE for model config spec.
          json_path = model_dir / item.get(
              Keys.CONFIG_FILE,
              os.path.join("config", "config_train.json"),
          )
          with open(json_path) as f:
              conf_dict = json.load(f)
          conf_dict = dict(conf_dict)
          model_config = _get_val(conf_dict, key=model_key, default={})
      if not model_config:
          # 3. search `model_dict` for model config spec.
          model_config = _get_val(
              dict(model_dict), key=model_key, default={}
          )
  
      if not (model_config and isinstance(model_config, Mapping)):
          raise ValueError(
              f"Could not load model config dictionary from config: {item.get(Keys.CONFIG_FILE)}, "
              f"or from model file: {item.get(Keys.MODEL_FILE)}."
          )
  
      # parse `model_config` for model class and model parameters
      if model_config.get("name"):  # model config section is a "name"
          model_name = model_config["name"]
          model_cls = monai_nets.__dict__[model_name]
      elif model_config.get("path"):  # model config section is a "path"
          # https://docs.nvidia.com/clara/clara-train-sdk/pt/byom.html
          model_module, model_name = model_config.get(
              "path", "."
          ).rsplit(".", 1)
          model_cls, has_cls = optional_import(
              module=model_module, name=model_name
          )
          if not has_cls:
              raise ValueError(
                  f"Could not load MMAR model config {model_config.get('path', '')}, "
                  f"Please make sure MMAR's sub-folders in '{model_dir}' is on the PYTHONPATH."
                  "See also: https://docs.nvidia.com/clara/clara-train-sdk/pt/byom.html"
              )
      else:
          raise ValueError(
              f"Could not load model config {model_config}."
          )
  
      logger.info(f"*** Model: {model_cls}")
      model_kwargs = model_config.get("args", None)
      if model_kwargs:
          model_inst = model_cls(**model_kwargs)
          logger.info(f"*** Model params: {model_kwargs}")
      else:
          model_inst = model_cls()
      if pretrained:
          _, changed, unchanged = copy_model_state(
              model_inst,
              model_dict.get(model_key, model_dict),
              inplace=True,
          )
          if not (
              changed and not unchanged
          ):  # not all model_inst variables are changed
              logger.warning(
                  f"*** Loading model state -- unchanged: {len(unchanged)}, changed: {len(changed)}."
              )
      logger.info("\n---")
      doc_url = item.get(Keys.DOC) or _get_ngc_doc_url(
          item[Keys.NAME], model_prefix="nvidia:med:"
      )
      logger.info(f"For more information, please visit {doc_url}\n")
      return model_inst
  
imports: from __future__ import annotations
  import json
  import os
  import warnings
  from collections.abc import Mapping
  from pathlib import Path
  from typing import Any
  import torch
  import monai.networks.nets
  from monai.apps.utils import download_and_extract, logger
  from monai.config.type_definitions import PathLike
  from monai.networks.utils import copy_model_state
  from monai.utils.module import optional_import
  from .model_desc import MODEL_DESC
  from .model_desc import RemoteMMARKeys
label_desc: Use image node_id 6 for calling a global function with example usage: load_from_mmar(item, mmar_dir, progress, version, map_location, pretrained, weights_only, model_key, api, model_file) and returns: model_inst, torch, model_dict