class_docstr: Create a Unet unwrapped generator
class_docstr_tok: ["Create","a","Unet","unwrapped","generator"]
docstr: Create a unetbasedmodel from the compact options format - where the
  same convolution is given for each layer, and arguments are given
  in lists
code: def _init_from_compact_format(
      self, opt, model_type, dataset, modules_lib
  ):
      """Create a unetbasedmodel from the compact options format - where the
      same convolution is given for each layer, and arguments are given
      in lists
      """
  
      self.down_modules = nn.ModuleList()
      self.inner_modules = nn.ModuleList()
      self.up_modules = nn.ModuleList()
  
      self.save_sampling_id = opt.down_conv.get("save_sampling_id")
  
      # Factory for creating up and down modules
      factory_module_cls = self._get_factory(model_type, modules_lib)
      down_conv_cls_name = opt.down_conv.module_name
      up_conv_cls_name = (
          opt.up_conv.module_name
          if opt.get("up_conv") is not None
          else None
      )
      self._factory_module = factory_module_cls(
          down_conv_cls_name, up_conv_cls_name, modules_lib
      )  # Create the factory object
  
      # Loal module
      contains_global = (
          hasattr(opt, "innermost") and opt.innermost is not None
      )
      if contains_global:
          inners = self._create_inner_modules(
              opt.innermost, modules_lib
          )
          for inner in inners:
              self.inner_modules.append(inner)
      else:
          self.inner_modules.append(Identity())
  
      # Down modules
      for i in range(len(opt.down_conv.down_conv_nn)):
          args = self._fetch_arguments(opt.down_conv, i, "DOWN")
          conv_cls = self._get_from_kwargs(args, "conv_cls")
          down_module = conv_cls(**args)
          self._save_sampling_and_search(down_module)
          self.down_modules.append(down_module)
  
      # Up modules
      if up_conv_cls_name:
          for i in range(len(opt.up_conv.up_conv_nn)):
              args = self._fetch_arguments(opt.up_conv, i, "UP")
              conv_cls = self._get_from_kwargs(args, "conv_cls")
              up_module = conv_cls(**args)
              self._save_upsample(up_module)
              self.up_modules.append(up_module)
  
      (
          self.metric_loss_module,
          self.miner_module,
      ) = BaseModel.get_metric_loss_and_miner(
          getattr(opt, "metric_loss", None), getattr(opt, "miner", None)
      )
  
imports: from torch import nn
  from torch_geometric.nn import global_max_pool, global_mean_pool, fps, radius, knn_interpolate
  from torch.nn import Linear, ReLU, LeakyReLU, BatchNorm1d, Dropout
  from omegaconf.listconfig import ListConfig
  from omegaconf.dictconfig import DictConfig
  import logging
  import copy
  from torch_points3d.datasets.base_dataset import BaseDataset
  from torch_points3d.models.base_model import BaseModel
  from torch_points3d.core.common_modules.base_modules import Identity
  from torch_points3d.utils.config import is_list
label_desc: Use image node_id 7 for calling the UnwrappedUnetBasedModel obj's underlying member method code with example usage: obj._init_from_compact_format(opt, model_type, dataset, modules_lib) without return types