Skip to content

ov

Type Aliases:

Classes:

  • OV –

    Base OpenVINO backend configuration.

  • OVConfig –
  • OV_CPU –

    OpenVINO CPU backend.

  • OV_GPU –

    OpenVINO GPU backend.

  • OV_NPU –

    OpenVINO NPU backend for Intel neural processing units.

Shape 

Shape = tuple[int, int]

OV dataclass 

OV(*, custom_config: Mapping[str, Any] = dict[str, Any]())

Bases: Backend

Base OpenVINO backend configuration.

Methods:

  • autoselect –

    Try to select the best backend for the current system.

  • get_args –

    Return backend plugin arguments derived from this configuration.

  • inference –

    Run inference with this backend.

Attributes:

config property 

config: Mapping[str, Any]

custom_config class-attribute instance-attribute 

custom_config: Mapping[str, Any] = field(default_factory=dict[str, Any])

Extra OpenVINO runtime configuration keys merged into the device configuration passed to core.ov.Model.

https://docs.openvino.ai/2026/api/c_cpp_api/group__ov__runtime__cpu__prop__cpp__api.html https://docs.openvino.ai/2026/api/c_cpp_api/group__ov__runtime__cpp__prop__api.html

device class-attribute 

device: str

flexible_output_prop class-attribute 

flexible_output_prop: str = 'MlrtFlexible'

plugin class-attribute instance-attribute 

plugin = core.lazy.ov

autoselect staticmethod 

autoselect(device_id: int = 0, **kwargs: Any) -> Backend

Try to select the best backend for the current system.

Parameters:

  • device_id

    (int, default: 0 ) –

    The GPU device id.

  • **kwargs

    (Any, default: {} ) –

    Additional arguments to pass to the backend.

Returns:

  • Backend –

    The selected backend.

Source code in vsscale/mlrt/backend/base.py 
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
@staticmethod
def autoselect(device_id: int = 0, **kwargs: Any) -> Backend:
    """
    Try to select the best backend for the current system.

    Args:
        device_id: The GPU device id.
        **kwargs: Additional arguments to pass to the backend.

    Returns:
        The selected backend.
    """

    gpu = get_gpu(device_id)
    vendor = None if not gpu else str(gpu.vendor).strip()

    match vendor:
        # Windows & Linux
        case "NVIDIA Corporation":
            if hasattr(core, "trt"):
                backend = UserBackend.TRT
            elif hasattr(core, "trt_rtx"):
                backend = UserBackend.TRT_RTX
            elif platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "ort"):
                backend = UserBackend.ORT_CUDA
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN
            else:
                backend = UserBackend.OV_CPU
        # Windows & Linux
        case "Advanced Micro Devices, Inc.":
            if platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "migx"):
                backend = UserBackend.MIGX
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            else:
                backend = UserBackend.OV_CPU
        # Windows & Linux
        case "Intel(R) Corporation":
            if hasattr(core, "ov"):
                backend = UserBackend.OV_GPU
            elif platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            else:
                backend = UserBackend.OV_CPU
        # macOS ARM64 & x86_64
        case "Apple":
            if hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            elif hasattr(core, "ort"):
                backend = UserBackend.ORT_COREML
            else:
                backend = UserBackend.OV_CPU
        case _:
            backend = UserBackend.OV_CPU

    del gpu

    if hasattr(backend, "device_id"):
        kwargs["device_id"] = device_id

    return backend(**kwargs)

get_args 

get_args(clips: VideoNode | Sequence[VideoNode]) -> dict[str, Any]

Return backend plugin arguments derived from this configuration.

Source code in vsscale/mlrt/backend/ov.py 
68
69
def get_args(self, clips: vs.VideoNode | Sequence[vs.VideoNode]) -> dict[str, Any]:
    return {"device": self.device, "fp16": False, "config": OVConfig(self.config)}

inference 

inference(
    clips: VideoNode | Sequence[VideoNode],
    network_path: str | PathLike[str],
    /,
    overlap: tuple[int, int],
    tilesize: tuple[int, int],
    *,
    flexible: bool = False,
    **kwargs: Any,
) -> VideoNode | list[VideoNode]

Run inference with this backend.

Parameters:

  • clips

    (VideoNode | Sequence[VideoNode]) –

    Input clip or clips passed to the backend model.

  • network_path

    (str | PathLike[str]) –

    Path to the model file or backend artifact.

  • overlap

    (tuple[int, int]) –

    Horizontal and vertical tile overlap in pixels.

  • tilesize

    (tuple[int, int]) –

    Horizontal and vertical tile size in pixels.

  • flexible

    (bool, default: False ) –

    Return each flexible output plane as a separate clip.

  • **kwargs

    (Any, default: {} ) –

    Additional backend plugin arguments forwarded unchanged.

Returns:

  • VideoNode | list[VideoNode] –

    A single output clip, or a list of output clips when flexible is enabled.

Source code in vsscale/mlrt/backend/ov.py 
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
@copy_signature(Backend.inference)
def inference(
    self,
    clips: vs.VideoNode | Sequence[vs.VideoNode],
    network_path: str | os.PathLike[str],
    /,
    overlap: tuple[int, int],
    tilesize: tuple[int, int],
    *,
    flexible: bool = False,
    **kwargs: Any,
) -> vs.VideoNode | list[vs.VideoNode]:
    UnsupportedSampleTypeError.check(clips, vs.FLOAT, self.__class__)

    clips = to_arr(clips)
    bitdepth = max(c.format.bits_per_sample for c in clips)

    res = super().inference(
        # OV Plugin only accepts fp32
        [depth(c, 32) for c in clips],
        network_path,
        overlap,
        tilesize,
        flexible=flexible,
        **kwargs,
    )

    return (
        depth(res, bitdepth, sample_type=vs.FLOAT)
        if isinstance(res, vs.VideoNode)
        else [depth(r, bitdepth, sample_type=vs.FLOAT) for r in res]
    )

OVConfig 

OVConfig(config: Mapping[str, Any])

Methods:

Attributes:

Source code in vsscale/mlrt/backend/ov.py 
150
151
def __init__(self, config: Mapping[str, Any]) -> None:
    self.config = config

config instance-attribute 

config = config

__call__ 

__call__() -> Mapping[str, Any]
Source code in vsscale/mlrt/backend/ov.py 
153
154
def __call__(self) -> Mapping[str, Any]:
    return self.config

OV_CPU dataclass 

OV_CPU(
    *,
    custom_config: Mapping[str, Any] = dict[str, Any](),
    num_streams: int = 1,
    num_threads: int = 0,
    bind_thread: bool = True,
    fp16: bool | None = None,
    bf16: bool | None = None,
    fp16_blacklist_ops: Collection[str] | None = None,
)

Bases: OV

OpenVINO CPU backend.

Methods:

  • autoselect –

    Try to select the best backend for the current system.

  • get_args –

    Return backend plugin arguments derived from this configuration.

  • inference –

    Run inference with this backend.

Attributes:

bf16 class-attribute instance-attribute 

bf16: bool | None = None

Request BF16 inference precision. Default to False.

bind_thread class-attribute instance-attribute 

bind_thread: bool = True

Enable OpenVINO CPU thread pinning.

config property 

config: Mapping[str, Any]

custom_config class-attribute instance-attribute 

custom_config: Mapping[str, Any] = field(default_factory=dict[str, Any])

Extra OpenVINO runtime configuration keys merged into the device configuration passed to core.ov.Model.

https://docs.openvino.ai/2026/api/c_cpp_api/group__ov__runtime__cpu__prop__cpp__api.html https://docs.openvino.ai/2026/api/c_cpp_api/group__ov__runtime__cpp__prop__api.html

device class-attribute instance-attribute 

device = 'CPU'

flexible_output_prop class-attribute 

flexible_output_prop: str = 'MlrtFlexible'

fp16 class-attribute instance-attribute 

fp16: bool | None = None

Request FP16 inference precision. Default to True.

fp16_blacklist_ops class-attribute instance-attribute 

fp16_blacklist_ops: Collection[str] | None = None

ONNX node or op names to keep in FP32 during FP16 conversion.

num_streams class-attribute instance-attribute 

num_streams: int = 1

Number of OpenVINO inference streams.

num_threads class-attribute instance-attribute 

num_threads: int = 0

Maximum CPU inference threads. 0 lets OpenVINO choose.

plugin class-attribute instance-attribute 

plugin = core.lazy.ov

autoselect staticmethod 

autoselect(device_id: int = 0, **kwargs: Any) -> Backend

Try to select the best backend for the current system.

Parameters:

  • device_id

    (int, default: 0 ) –

    The GPU device id.

  • **kwargs

    (Any, default: {} ) –

    Additional arguments to pass to the backend.

Returns:

  • Backend –

    The selected backend.

Source code in vsscale/mlrt/backend/base.py 
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
@staticmethod
def autoselect(device_id: int = 0, **kwargs: Any) -> Backend:
    """
    Try to select the best backend for the current system.

    Args:
        device_id: The GPU device id.
        **kwargs: Additional arguments to pass to the backend.

    Returns:
        The selected backend.
    """

    gpu = get_gpu(device_id)
    vendor = None if not gpu else str(gpu.vendor).strip()

    match vendor:
        # Windows & Linux
        case "NVIDIA Corporation":
            if hasattr(core, "trt"):
                backend = UserBackend.TRT
            elif hasattr(core, "trt_rtx"):
                backend = UserBackend.TRT_RTX
            elif platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "ort"):
                backend = UserBackend.ORT_CUDA
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN
            else:
                backend = UserBackend.OV_CPU
        # Windows & Linux
        case "Advanced Micro Devices, Inc.":
            if platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "migx"):
                backend = UserBackend.MIGX
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            else:
                backend = UserBackend.OV_CPU
        # Windows & Linux
        case "Intel(R) Corporation":
            if hasattr(core, "ov"):
                backend = UserBackend.OV_GPU
            elif platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            else:
                backend = UserBackend.OV_CPU
        # macOS ARM64 & x86_64
        case "Apple":
            if hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            elif hasattr(core, "ort"):
                backend = UserBackend.ORT_COREML
            else:
                backend = UserBackend.OV_CPU
        case _:
            backend = UserBackend.OV_CPU

    del gpu

    if hasattr(backend, "device_id"):
        kwargs["device_id"] = device_id

    return backend(**kwargs)

get_args 

get_args(clips: VideoNode | Sequence[VideoNode]) -> dict[str, Any]

Return backend plugin arguments derived from this configuration.

Source code in vsscale/mlrt/backend/ov.py 
68
69
def get_args(self, clips: vs.VideoNode | Sequence[vs.VideoNode]) -> dict[str, Any]:
    return {"device": self.device, "fp16": False, "config": OVConfig(self.config)}

inference 

inference(
    clips: VideoNode | Sequence[VideoNode],
    network_path: str | PathLike[str],
    /,
    overlap: tuple[int, int],
    tilesize: tuple[int, int],
    *,
    flexible: bool = False,
    **kwargs: Any,
) -> VideoNode | list[VideoNode]

Run inference with this backend.

Parameters:

  • clips

    (VideoNode | Sequence[VideoNode]) –

    Input clip or clips passed to the backend model.

  • network_path

    (str | PathLike[str]) –

    Path to the model file or backend artifact.

  • overlap

    (tuple[int, int]) –

    Horizontal and vertical tile overlap in pixels.

  • tilesize

    (tuple[int, int]) –

    Horizontal and vertical tile size in pixels.

  • flexible

    (bool, default: False ) –

    Return each flexible output plane as a separate clip.

  • **kwargs

    (Any, default: {} ) –

    Additional backend plugin arguments forwarded unchanged.

Returns:

  • VideoNode | list[VideoNode] –

    A single output clip, or a list of output clips when flexible is enabled.

Source code in vsscale/mlrt/backend/ov.py 
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
@copy_signature(Backend.inference)
def inference(
    self,
    clips: vs.VideoNode | Sequence[vs.VideoNode],
    network_path: str | os.PathLike[str],
    /,
    overlap: tuple[int, int],
    tilesize: tuple[int, int],
    *,
    flexible: bool = False,
    **kwargs: Any,
) -> vs.VideoNode | list[vs.VideoNode]:
    UnsupportedSampleTypeError.check(clips, vs.FLOAT, self.__class__)

    clips = to_arr(clips)
    bitdepth = max(c.format.bits_per_sample for c in clips)

    res = super().inference(
        # OV Plugin only accepts fp32
        [depth(c, 32) for c in clips],
        network_path,
        overlap,
        tilesize,
        flexible=flexible,
        **kwargs,
    )

    return (
        depth(res, bitdepth, sample_type=vs.FLOAT)
        if isinstance(res, vs.VideoNode)
        else [depth(r, bitdepth, sample_type=vs.FLOAT) for r in res]
    )

OV_GPU dataclass 

OV_GPU(
    *,
    custom_config: Mapping[str, Any] = dict[str, Any](),
    device_id: int = 0,
    num_streams: int = 1,
    fp16: bool = True,
    fp16_blacklist_ops: Collection[str] | None = None,
)

Bases: OV

OpenVINO GPU backend.

Methods:

  • autoselect –

    Try to select the best backend for the current system.

  • get_args –

    Return backend plugin arguments derived from this configuration.

  • inference –

    Run inference with this backend.

Attributes:

config property 

config: dict[str, Any]

custom_config class-attribute instance-attribute 

custom_config: Mapping[str, Any] = field(default_factory=dict[str, Any])

Extra OpenVINO runtime configuration keys merged into the device configuration passed to core.ov.Model.

https://docs.openvino.ai/2026/api/c_cpp_api/group__ov__runtime__cpu__prop__cpp__api.html https://docs.openvino.ai/2026/api/c_cpp_api/group__ov__runtime__cpp__prop__api.html

device class-attribute instance-attribute 

device = 'GPU'

device_id class-attribute instance-attribute 

device_id: int = 0

OpenVINO GPU device index.

flexible_output_prop class-attribute 

flexible_output_prop: str = 'MlrtFlexible'

fp16 class-attribute instance-attribute 

fp16: bool = True

Request FP16 inference precision.

fp16_blacklist_ops class-attribute instance-attribute 

fp16_blacklist_ops: Collection[str] | None = None

ONNX node or op names to keep in FP32 during FP16 conversion.

num_streams class-attribute instance-attribute 

num_streams: int = 1

Number of OpenVINO inference streams.

plugin class-attribute instance-attribute 

plugin = core.lazy.ov

autoselect staticmethod 

autoselect(device_id: int = 0, **kwargs: Any) -> Backend

Try to select the best backend for the current system.

Parameters:

  • device_id

    (int, default: 0 ) –

    The GPU device id.

  • **kwargs

    (Any, default: {} ) –

    Additional arguments to pass to the backend.

Returns:

  • Backend –

    The selected backend.

Source code in vsscale/mlrt/backend/base.py 
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
@staticmethod
def autoselect(device_id: int = 0, **kwargs: Any) -> Backend:
    """
    Try to select the best backend for the current system.

    Args:
        device_id: The GPU device id.
        **kwargs: Additional arguments to pass to the backend.

    Returns:
        The selected backend.
    """

    gpu = get_gpu(device_id)
    vendor = None if not gpu else str(gpu.vendor).strip()

    match vendor:
        # Windows & Linux
        case "NVIDIA Corporation":
            if hasattr(core, "trt"):
                backend = UserBackend.TRT
            elif hasattr(core, "trt_rtx"):
                backend = UserBackend.TRT_RTX
            elif platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "ort"):
                backend = UserBackend.ORT_CUDA
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN
            else:
                backend = UserBackend.OV_CPU
        # Windows & Linux
        case "Advanced Micro Devices, Inc.":
            if platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "migx"):
                backend = UserBackend.MIGX
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            else:
                backend = UserBackend.OV_CPU
        # Windows & Linux
        case "Intel(R) Corporation":
            if hasattr(core, "ov"):
                backend = UserBackend.OV_GPU
            elif platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            else:
                backend = UserBackend.OV_CPU
        # macOS ARM64 & x86_64
        case "Apple":
            if hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            elif hasattr(core, "ort"):
                backend = UserBackend.ORT_COREML
            else:
                backend = UserBackend.OV_CPU
        case _:
            backend = UserBackend.OV_CPU

    del gpu

    if hasattr(backend, "device_id"):
        kwargs["device_id"] = device_id

    return backend(**kwargs)

get_args 

get_args(clips: VideoNode | Sequence[VideoNode]) -> dict[str, Any]

Return backend plugin arguments derived from this configuration.

Source code in vsscale/mlrt/backend/ov.py 
136
137
def get_args(self, clips: vs.VideoNode | Sequence[vs.VideoNode]) -> dict[str, Any]:
    return super().get_args(clips) | {"device": f"{self.device}.{self.device_id}"}

inference 

inference(
    clips: VideoNode | Sequence[VideoNode],
    network_path: str | PathLike[str],
    /,
    overlap: tuple[int, int],
    tilesize: tuple[int, int],
    *,
    flexible: bool = False,
    **kwargs: Any,
) -> VideoNode | list[VideoNode]

Run inference with this backend.

Parameters:

  • clips

    (VideoNode | Sequence[VideoNode]) –

    Input clip or clips passed to the backend model.

  • network_path

    (str | PathLike[str]) –

    Path to the model file or backend artifact.

  • overlap

    (tuple[int, int]) –

    Horizontal and vertical tile overlap in pixels.

  • tilesize

    (tuple[int, int]) –

    Horizontal and vertical tile size in pixels.

  • flexible

    (bool, default: False ) –

    Return each flexible output plane as a separate clip.

  • **kwargs

    (Any, default: {} ) –

    Additional backend plugin arguments forwarded unchanged.

Returns:

  • VideoNode | list[VideoNode] –

    A single output clip, or a list of output clips when flexible is enabled.

Source code in vsscale/mlrt/backend/ov.py 
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
@copy_signature(Backend.inference)
def inference(
    self,
    clips: vs.VideoNode | Sequence[vs.VideoNode],
    network_path: str | os.PathLike[str],
    /,
    overlap: tuple[int, int],
    tilesize: tuple[int, int],
    *,
    flexible: bool = False,
    **kwargs: Any,
) -> vs.VideoNode | list[vs.VideoNode]:
    UnsupportedSampleTypeError.check(clips, vs.FLOAT, self.__class__)

    clips = to_arr(clips)
    bitdepth = max(c.format.bits_per_sample for c in clips)

    res = super().inference(
        # OV Plugin only accepts fp32
        [depth(c, 32) for c in clips],
        network_path,
        overlap,
        tilesize,
        flexible=flexible,
        **kwargs,
    )

    return (
        depth(res, bitdepth, sample_type=vs.FLOAT)
        if isinstance(res, vs.VideoNode)
        else [depth(r, bitdepth, sample_type=vs.FLOAT) for r in res]
    )

OV_NPU dataclass 

OV_NPU(
    *,
    custom_config: Mapping[str, Any] = dict[str, Any](),
    fp16: Literal[True] = True,
)

Bases: OV

OpenVINO NPU backend for Intel neural processing units.

Methods:

  • autoselect –

    Try to select the best backend for the current system.

  • get_args –

    Return backend plugin arguments derived from this configuration.

  • inference –

    Run inference with this backend.

Attributes:

config property 

config: Mapping[str, Any]

custom_config class-attribute instance-attribute 

custom_config: Mapping[str, Any] = field(default_factory=dict[str, Any])

Extra OpenVINO runtime configuration keys merged into the device configuration passed to core.ov.Model.

https://docs.openvino.ai/2026/api/c_cpp_api/group__ov__runtime__cpu__prop__cpp__api.html https://docs.openvino.ai/2026/api/c_cpp_api/group__ov__runtime__cpp__prop__api.html

device class-attribute instance-attribute 

device = 'NPU'

flexible_output_prop class-attribute 

flexible_output_prop: str = 'MlrtFlexible'

fp16 class-attribute instance-attribute 

fp16: Literal[True] = True

plugin class-attribute instance-attribute 

plugin = core.lazy.ov

autoselect staticmethod 

autoselect(device_id: int = 0, **kwargs: Any) -> Backend

Try to select the best backend for the current system.

Parameters:

  • device_id

    (int, default: 0 ) –

    The GPU device id.

  • **kwargs

    (Any, default: {} ) –

    Additional arguments to pass to the backend.

Returns:

  • Backend –

    The selected backend.

Source code in vsscale/mlrt/backend/base.py 
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
@staticmethod
def autoselect(device_id: int = 0, **kwargs: Any) -> Backend:
    """
    Try to select the best backend for the current system.

    Args:
        device_id: The GPU device id.
        **kwargs: Additional arguments to pass to the backend.

    Returns:
        The selected backend.
    """

    gpu = get_gpu(device_id)
    vendor = None if not gpu else str(gpu.vendor).strip()

    match vendor:
        # Windows & Linux
        case "NVIDIA Corporation":
            if hasattr(core, "trt"):
                backend = UserBackend.TRT
            elif hasattr(core, "trt_rtx"):
                backend = UserBackend.TRT_RTX
            elif platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "ort"):
                backend = UserBackend.ORT_CUDA
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN
            else:
                backend = UserBackend.OV_CPU
        # Windows & Linux
        case "Advanced Micro Devices, Inc.":
            if platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "migx"):
                backend = UserBackend.MIGX
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            else:
                backend = UserBackend.OV_CPU
        # Windows & Linux
        case "Intel(R) Corporation":
            if hasattr(core, "ov"):
                backend = UserBackend.OV_GPU
            elif platform.system().lower() == "windows" and hasattr(core, "ort"):
                backend = UserBackend.ORT_DML
            elif hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            else:
                backend = UserBackend.OV_CPU
        # macOS ARM64 & x86_64
        case "Apple":
            if hasattr(core, "ncnn"):
                backend = UserBackend.NCNN_VK
            elif hasattr(core, "ort"):
                backend = UserBackend.ORT_COREML
            else:
                backend = UserBackend.OV_CPU
        case _:
            backend = UserBackend.OV_CPU

    del gpu

    if hasattr(backend, "device_id"):
        kwargs["device_id"] = device_id

    return backend(**kwargs)

get_args 

get_args(clips: VideoNode | Sequence[VideoNode]) -> dict[str, Any]

Return backend plugin arguments derived from this configuration.

Source code in vsscale/mlrt/backend/ov.py 
68
69
def get_args(self, clips: vs.VideoNode | Sequence[vs.VideoNode]) -> dict[str, Any]:
    return {"device": self.device, "fp16": False, "config": OVConfig(self.config)}

inference 

inference(
    clips: VideoNode | Sequence[VideoNode],
    network_path: str | PathLike[str],
    /,
    overlap: tuple[int, int],
    tilesize: tuple[int, int],
    *,
    flexible: bool = False,
    **kwargs: Any,
) -> VideoNode | list[VideoNode]

Run inference with this backend.

Parameters:

  • clips

    (VideoNode | Sequence[VideoNode]) –

    Input clip or clips passed to the backend model.

  • network_path

    (str | PathLike[str]) –

    Path to the model file or backend artifact.

  • overlap

    (tuple[int, int]) –

    Horizontal and vertical tile overlap in pixels.

  • tilesize

    (tuple[int, int]) –

    Horizontal and vertical tile size in pixels.

  • flexible

    (bool, default: False ) –

    Return each flexible output plane as a separate clip.

  • **kwargs

    (Any, default: {} ) –

    Additional backend plugin arguments forwarded unchanged.

Returns:

  • VideoNode | list[VideoNode] –

    A single output clip, or a list of output clips when flexible is enabled.

Source code in vsscale/mlrt/backend/ov.py 
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
@copy_signature(Backend.inference)
def inference(
    self,
    clips: vs.VideoNode | Sequence[vs.VideoNode],
    network_path: str | os.PathLike[str],
    /,
    overlap: tuple[int, int],
    tilesize: tuple[int, int],
    *,
    flexible: bool = False,
    **kwargs: Any,
) -> vs.VideoNode | list[vs.VideoNode]:
    UnsupportedSampleTypeError.check(clips, vs.FLOAT, self.__class__)

    clips = to_arr(clips)
    bitdepth = max(c.format.bits_per_sample for c in clips)

    res = super().inference(
        # OV Plugin only accepts fp32
        [depth(c, 32) for c in clips],
        network_path,
        overlap,
        tilesize,
        flexible=flexible,
        **kwargs,
    )

    return (
        depth(res, bitdepth, sample_type=vs.FLOAT)
        if isinstance(res, vs.VideoNode)
        else [depth(r, bitdepth, sample_type=vs.FLOAT) for r in res]
    )