Skip to content

Inplace Optimize

model_navigator.optimize 

optimize(func, dataloader, config=None, status_path=None)

Optimize all registered modules.

Parameters:

Source code in model_navigator/inplace/__init__.py 
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def optimize(
    func: Callable,
    dataloader: Sequence[Tuple[int, Any]],
    config: Optional[OptimizeConfig] = None,
    status_path: Optional[Union[pathlib.Path, str]] = None,
) -> None:
    """Optimize all registered modules.

    Args:
        func: Function to optimize.
        dataloader: List of tuples with batch size and input.
        config: Optimize config.
        status_path: Path to store the optimization status.
    """
    if config is None:
        config = OptimizeConfig()

    for module in module_registry.values():
        # set main config if user did not provide one for a module
        if module.optimize_config is None:
            module.optimize_config = config
        module.load_recorded()

    for input_ in dataloader:
        _, sample = input_  # unpack batch_size and sample
        if not isinstance(sample, tuple):
            sample = (sample,)
        if not isinstance(sample[-1], dict):
            sample = (*sample, {})
        *args, kwargs = sample
        func(*args, **kwargs)

    module_registry.optimize()
    _build_optimize_status(status_path)

model_navigator.OptimizeConfig dataclass 

OptimizeConfig(sample_count=DEFAULT_SAMPLE_COUNT, batching=True, input_names=None, output_names=None, target_formats=None, target_device=DeviceKind.CUDA, runners=None, optimization_profile=None, workspace=None, verbose=False, debug=False, verify_func=None, custom_configs=None)

Configuration for inplace Optimize.

Parameters:

  • sample_count (int, default: DEFAULT_SAMPLE_COUNT ) –

    Limits how many samples will be used from dataloader

  • batching (Optional[bool], default: True ) –

    Enable or disable batching on first (index 0) dimension of the model

  • input_names (Optional[Tuple[str, ...]], default: None ) –

    Model input names

  • output_names (Optional[Tuple[str, ...]], default: None ) –

    Model output names

  • target_formats (Optional[Tuple[Union[str, Format], ...]], default: None ) –

    Target model formats for optimize process

  • target_device (Optional[DeviceKind], default: CUDA ) –

    Target device for optimize process, default is CUDA

  • runners (Optional[Tuple[Union[str, Type[NavigatorRunner]], ...]], default: None ) –

    Use only runners provided as parameter

  • optimization_profile (Optional[OptimizationProfile], default: None ) –

    Optimization profile for conversion and profiling

  • workspace (Optional[Path], default: None ) –

    Workspace where packages will be extracted

  • verbose (Optional[bool], default: False ) –

    Enable verbose logging

  • debug (Optional[bool], default: False ) –

    Enable debug logging from commands

  • verify_func (Optional[VerifyFunction], default: None ) –

    Function for additional model verification

  • custom_configs (Optional[Sequence[CustomConfig]], default: None ) –

    Sequence of CustomConfigs used to control produced artifacts

clone 

clone()

Clone the current OptimizeConfig using deepcopy.

Source code in model_navigator/inplace/config.py 
127
128
129
def clone(self) -> "OptimizeConfig":
    """Clone the current OptimizeConfig using deepcopy."""
    return copy.deepcopy(self)

to_dict 

to_dict()

Convert OptimizeConfig to dictionary.

Source code in model_navigator/inplace/config.py 
119
120
121
122
123
124
125
def to_dict(self) -> Dict[str, Any]:
    """Convert OptimizeConfig to dictionary."""
    config_dict = {}
    for field in dataclasses.fields(self):
        value = getattr(self, field.name)
        config_dict[field.name] = value
    return config_dict

model_navigator.load_optimized 

load_optimized()

Load optimized modules.

Source code in model_navigator/inplace/__init__.py 
44
45
46
47
def load_optimized():
    """Load optimized modules."""
    for module in module_registry.values():
        module.load_optimized()