Python

model_navigator.api.python

Python optimize API.

optimize(model, dataloader, sample_count=DEFAULT_SAMPLE_COUNT, batching=True, target_device=DeviceKind.CPU, runners=None, profiler_config=None, workspace=None, verbose=False, debug=False, verify_func=None, custom_configs=None)

Entrypoint for Python model optimize.

Perform correctness testing, profiling and model verification.

Parameters:

Name	Type	Description	Default
model	Callable	Model inference function	required
dataloader	SizedDataLoader	Sized iterable with data that will be feed to the model	required
sample_count	int	Limits how many samples will be used from dataloader	DEFAULT_SAMPLE_COUNT
batching	Optional[bool]	Enable or disable batching on first (index 0) dimension of the model	True
target_device	Optional[DeviceKind]	Target device for optimize process, default is CPU	DeviceKind.CPU
runners	Optional[Union[Union[str, Type[NavigatorRunner]], Tuple[Union[str, Type[NavigatorRunner]], ...]]]	Use only runners provided as paramter	None
profiler_config	Optional[ProfilerConfig]	Profiling config	None
workspace	Optional[Path]	Workspace where packages will be extracted	None
verbose	bool	Enable verbose logging	False
debug	bool	Enable debug logging from commands	False
verify_func	Optional[VerifyFunction]	Function for additional model verifcation	None
custom_configs	Optional[Sequence[CustomConfig]]	Sequence of CustomConfigs used to control produced artifacts	None

Returns:

Type	Description
Package	Package descriptor representing created package.

Source code in model_navigator/api/python.py

def optimize(
    model: Callable,
    dataloader: SizedDataLoader,
    sample_count: int = DEFAULT_SAMPLE_COUNT,
    batching: Optional[bool] = True,
    target_device: Optional[DeviceKind] = DeviceKind.CPU,
    runners: Optional[Union[Union[str, Type[NavigatorRunner]], Tuple[Union[str, Type[NavigatorRunner]], ...]]] = None,
    profiler_config: Optional[ProfilerConfig] = None,
    workspace: Optional[Path] = None,
    verbose: bool = False,
    debug: bool = False,
    verify_func: Optional[VerifyFunction] = None,
    custom_configs: Optional[Sequence[CustomConfig]] = None,
) -> Package:
    """Entrypoint for Python model optimize.

    Perform correctness testing, profiling and model verification.

    Args:
        model: Model inference function
        dataloader: Sized iterable with data that will be feed to the model
        sample_count: Limits how many samples will be used from dataloader
        batching: Enable or disable batching on first (index 0) dimension of the model
        target_device: Target device for optimize process, default is CPU
        runners: Use only runners provided as paramter
        profiler_config: Profiling config
        workspace: Workspace where packages will be extracted
        verbose: Enable verbose logging
        debug: Enable debug logging from commands
        verify_func: Function for additional model verifcation
        custom_configs: Sequence of CustomConfigs used to control produced artifacts

    Returns:
        Package descriptor representing created package.
    """
    if isinstance(model, str):
        model = Path(model)
    if workspace is None:
        workspace = get_default_workspace()

    sample = next(iter(dataloader))
    forward_kw_names = tuple(sample.keys()) if isinstance(sample, Mapping) else None

    if runners is None:
        runners = default_runners(device_kind=target_device)

    if profiler_config is None:
        profiler_config = ProfilerConfig()

    runner_names = enums.parse(runners, lambda runner: runner if isinstance(runner, str) else runner.name())

    target_formats = DEFAULT_NONE_FRAMEWORK_TARGET_FORMATS
    config = CommonConfig(
        Framework.NONE,
        model=model,
        dataloader=dataloader,
        forward_kw_names=forward_kw_names,
        workspace=workspace,
        target_formats=target_formats,
        target_device=target_device,
        sample_count=sample_count,
        batch_dim=0 if batching else None,
        runner_names=runner_names,
        profiler_config=profiler_config,
        verbose=verbose,
        debug=debug,
        verify_func=verify_func,
        custom_configs=map_custom_configs(custom_configs=custom_configs),
    )

    models_config = ModelConfigBuilder.generate_model_config(
        framework=Framework.NONE,
        target_formats=target_formats,
        custom_configs=[],
    )

    builders = [preprocessing_builder, correctness_builder]
    if profiler_config.run_profiling:
        builders.append(profiling_builder)
    builders.append(verify_builder)

    package = PipelineManager.run(
        pipeline_builders=builders,
        config=config,
        models_config=models_config,
    )

    return package