Пользовательские модели¶

├── coco_categories.json
├── model_info.json
├── model.py
├── weights.pt
└── custom_modules/       # Опциональная директория со вспомогательным кодом
    ├── __init__.py       # (Рекомендуется) Для упрощения импорта
    ├── nms.py           # Пользовательская реализация Non-Maximum Suppression
    └── utils.py         # Вспомогательные утилиты (постобработка, аннотации и т.д.)

weights_h{height}_w{width}_b{batch}_c{channels}_onnx{onnx_version}_{precision}.onnx

weights_h{height}_w{width}_b{batch}_cc{compute_capability}_cuda{cuda_version}_trt{tensorrt_version}_{precision}.engine

├── weights_tf
│   ├── assets  # (Опционально) Дополнительные ресурсы, используемые графом
│   ├── fingerprint.pb  # (Опционально) Фингерпринт для контроля версий
│   ├── saved_model.pb  # Основной файл графа модели и метаданных
│   └── variables   # Директория с обученными весами модели
│       ├── variables.data-00000-of-00001   # Файл с данными весов
│       └── variables.index     # Индексный файл для отображения тензоров

artifacts/
├── __init__.py                # ОБЯЗАТЕЛЬНО: обозначает директорию модели как Python-пакет (может быть пустым)
├── model.py                   # Основной модуль модели
├── coco_categories.json
├── model_info.json
├── custom_modules/            # Рекомендуемая директория для вспомогательного кода
│   ├── __init__.py            # ОБЯЗАТЕЛЬНО
│   ├── nms.py                 # Пользовательская реализация Non-Maximum Suppression
│   ├── utils.py               # Вспомогательные утилиты (постобработка, аннотации и т.д.)
│   └── ...
└── weights*.*

# КОРРЕКТНО
from .custom_modules import nms, utils
from .custom_modules.yolo_utils import letterbox

# НЕКОРРЕКТНО
from custom_modules import nms, utils
import custom_modules.yolo_utils

# КОРРЕКТНО
from .utils import some_function

# НЕКОРРЕКТНО
from custom_modules.utils import some_function

class Model(CustomModelProtocol[Classification]):
    input_names = ["input"]
    output_names = ["logits"]

    def __init__(self, **model_attributes: AllowedModelAttributeValue) -> None:
        """
        Инициализирует модель ResNet18 из torchvision с заданными параметрами.

        Аргументы:
            **model_attributes: Словарь с возможными ключами:
                - 'conf_thres' (float): Порог уверенности для детекций.

            Параметры model_attributes могут поступать либо из пользовательского интерфейса Node-RED,
            либо из файла model_info.json (если model_attributes не передан или пуст).
        """
        self.conf_thres: float = model_attributes["conf_thres"]

        self.img_size = 224
        self.imagenet_mean = [0.485, 0.456, 0.406]
        self.imagenet_std  = [0.229, 0.224, 0.225]

    def preprocess(self, data: np.ndarray) -> Mapping[str, torch.Tensor]:
        img_rgb = cv2.cvtColor(data, cv2.COLOR_BGR2RGB)
        t = torch.from_numpy(img_rgb).permute(2, 0, 1).float() / 255.0  # (3,H,W), [0..1]
        t = TF.resize(t, 256, interpolation=transforms.InterpolationMode.BILINEAR)     # короткая сторона -> 256
        t = TF.center_crop(t, [self.img_size, self.img_size])                         # 224x224
        t = TF.normalize(t, mean=self.imagenet_mean, std=self.imagenet_std)
        return {self.input_names[0]: t.unsqueeze(0)}

    def postprocess(self, outputs: Mapping[str, torch.Tensor], categories: Sequence[str]) -> Classification:
        if self.output_names != list(outputs.keys()):
            raise ValueError("Output names mismatch")

        for name, tensor in outputs.items():
            if tensor.ndim == 1:
                tensor = tensor.unsqueeze(0)
            score, class_id = torch.max(F.softmax(tensor, dim=1), dim=1)

            return Classification(
                label=categories[int(class_id.item())],
                score=float(score.item()),
            )

{
    "model_type": "custom_model",
    "model_attributes": {
        "conf_thres": {
            "type": "float",
            "default": 0.4,
            "ru_name": "Порог уверенности"
        },
        "iou_thres": {
            "type": "float",
            "default": 0.45
        }
    },
    "deploy_profile": {
        "default_profile": "inline_cuda_trt_fp16",
        "profiles": [
            "inline_cuda_trt_fp16"
        ]
    },
    "task_type": "image_detection",
    "model_name": "custom_yolov7tiny_coco",
    "model_version": "2",
    "img_size": {
        "height": 640,
        "width": 640
    },
    "weights_path": "weights*.*",
    "categories_path": "coco_categories.json"
}

{
    "categories": [
        {
            "supercategory": "person",
            "id": 1,
            "name": "person",
            "is_violation": false,
            "is_primary": true,
            "exclude": false,
            "threshold": 0.65,
            "color": [0, 255, 0],
            "keypoints": [],
            "skeleton": [],
            "skeleton_color": [],
            "ru_name": "Человек",
            "full_ru_name": "Человек в кузове"
        }
    ]
}

{
    "img_size": {
        "height": 640,    // Фиксированная высота
        "width": 640      // Фиксированная ширина
    }
}

http://адрес_сервера/administrating/inference-packages

# Тип для возможных значений атрибутов модели
type AllowedModelAttributeValue = int | float | str | bool | None


class CustomModelProtocol[T_co: NamedTuple](Protocol):
    """
    Протокол `CustomModelProtocol` описывает интерфейс, который должна реализовать
    пользовательская модель onnx, tensorflow, tensorrt для интеграции с библиотекой.

    Атрибуты:
        input_names (Sequence[str]): Список имён входных тензоров, ожидаемых моделью.
        output_names (Sequence[str]): Список имён выходных тензоров, которые возвращает модель.

    Методы:
        __init__(**model_attributes: AllowedModelAttributeValue):
            Конструктор пользовательской модели.
            При инициализации в него автоматически передаётся набор параметров `model_attributes`,
            полученных либо из пользовательского интерфейса Node-RED, либо из файла `model_info.json`,
            если параметры явно не заданы.
            Каждый параметр должен соответствовать допустимым типам, описанным в `AllowedModelAttributeValue`.

        preprocess(data: NDArray | Sequence[NDArray]) -> Mapping[str, NDArray | torch.Tensor]:
            Выполняет предобработку исходного изображения или массива данных перед подачей в модель.
            На выходе должен вернуть словарь, где ключи соответствуют `input_names`, а значения —
            подготовленные входные тензоры в формате NumPy или PyTorch.
            По-умолчанию тензоры должны быть расположены на устройстве CPU. В обратном случае, могут
            возникать проблемы при использовании CPU модели вместо GPU.

        postprocess(outputs: Mapping[str, torch.Tensor], categories: Sequence[str]) -> T_co:
            Выполняет постобработку результатов работы модели.
            Аргумент `outputs` — словарь, где ключи соответствуют `output_names`, а значения —
            выходные тензоры модели в формате PyTorch.
            Аргумент `categories` — набор доступных классов/меток.
            Метод должен вернуть результат типа `T_co` (например, NamedTuple или другую согласованную структуру данных),
            содержащий итоговые детекции или предсказания.
    """

    input_names: Sequence[str]
    output_names: Sequence[str]

    def __init__(self, **model_attributes: AllowedModelAttributeValue) -> None: ...
    def preprocess(self, data: "NDArray | Sequence[NDArray]") -> "Mapping[str, NDArray | torch.Tensor]": ...
    def postprocess(self, outputs: "Mapping[str, torch.Tensor]", categories: Sequence[str]) -> T_co: ...

class CustomTorchModelProtocol[T_co: NamedTuple](CustomModelProtocol[T_co], Protocol):
    """
    Протокол `CustomTorchModelProtocol` расширяет базовый `CustomModelProtocol`
    и описывает интерфейс пользовательской модели, реализованной с использованием PyTorch.

    Дополнительно к методам и атрибутам базового протокола, модель должна
    предоставлять метод `build_torch_model` для инициализации и загрузки
    архитектуры модели в формате PyTorch.

    Методы:
        build_torch_model(artifacts_path: Path, device: str) -> torch.nn.Module:
            Создаёт и возвращает экземпляр PyTorch-модели, готовой к выполнению инференса.
            Аргументы:
                artifacts_path (Path): Путь к директории с весами модели в формате PyTorch.
                device (str): Устройство, на которое будет загружена модель (например, "cuda:0" или "cpu").
            Возвращает:
                torch.nn.Module: Инициализированная модель PyTorch, готовая к запуску.

        postprocess_torch(outputs: Any, categories: Sequence[str]) -> T_co:
            Выполняет постобработку результатов работы PyTorch-модели модели.
            Аргумент `outputs` — результат инференса модели.
            Аргумент `categories` — набор доступных классов/меток.
            Метод должен вернуть результат типа `T_co` (например, NamedTuple или другую согласованную структуру данных),
            содержащий итоговые детекции или предсказания.
    """

    def build_torch_model(self, artifacts_path: "Path", device: str) -> "torch.nn.Module": ...
    def postprocess_torch(self, outputs: Any, categories: Sequence[str]) -> T_co: ...

├── coco_categories.json    # JSON-файл с описанием категорий
├── model_info.json         # JSON-файл с метаданными и параметрами модели
├── model.py                # Python-модуль, содержащий код для инициализации и работы модели.
├── weights_h224_w224_b1_c3_onnx1.17.0_fp16.onnx                # сконвертированные веса ONNX в fp16
├── weights_h224_w224_b1_c3_onnx1.17.0_fp32.onnx                # сконвертированные веса ONNX в fp32
├── weights_h224_w224_b1_cc8.6_cuda11.8_trt8.6.1_fp16.engine    # сконвертированные веса TensorRT для целевой GPU архитектуры в fp16
├── weights_h224_w224_b1_cc8.6_cuda11.8_trt8.6.1_fp32.engine    # сконвертированные веса TensorRT для целевой GPU архитектуры в fp32
└── weights.pt              # веса модели для PyTorch

from pathlib import Path
from collections.abc import Sequence, Mapping

import cv2
from numpy.typing import NDArray
import torch
import torch.nn.functional as F
import torchvision.transforms.functional as TF
from torchvision.models import resnet18
from torchvision import transforms
from vlmodels_types import Classification
from vlmodels_types.protocol.custom_model_protocol import AllowedModelAttributeValue, CustomTorchModelProtocol


class Model(CustomTorchModelProtocol[Classification]):
    input_names = ["input"]
    output_names = ["logits"]

    def __init__(self, **model_attributes: AllowedModelAttributeValue) -> None:
        """
        Инициализирует модель ResNet18 из torchvision с заданными параметрами.

        Аргументы:
            **model_attributes: Словарь с возможными ключами:
                - 'conf_thres' (float): Порог уверенности для детекций.

            Параметры model_attributes могут поступать либо из пользовательского интерфейса Node-RED,
            либо из файла model_info.json (если model_attributes не передан или пуст).
        """
        self.conf_thres: float = model_attributes["conf_thres"]

        self.img_size = 224
        self.imagenet_mean = [0.485, 0.456, 0.406]
        self.imagenet_std  = [0.229, 0.224, 0.225]

    # ==== Доп. метод для torch-бэкенда (опционально) ====
    def build_torch_model(self, artifacts_path: Path, device: str) -> torch.nn.Module:
        model = resnet18(weights=None)
        checkpoint = torch.load(artifacts_path / "weights.pt")  # не используем map_location
        model.load_state_dict(checkpoint)
        model.to(device)
        model.eval()
        return model

    def preprocess(self, data: NDArray) -> Mapping[str, torch.Tensor]:
        img_rgb = cv2.cvtColor(data, cv2.COLOR_BGR2RGB)
        t = torch.from_numpy(img_rgb).permute(2, 0, 1).float() / 255.0  # (3,H,W), [0..1]
        t = TF.resize(t, 256, interpolation=transforms.InterpolationMode.BILINEAR)     # короткая сторона -> 256
        t = TF.center_crop(t, [self.img_size, self.img_size])                         # 224x224
        t = TF.normalize(t, mean=self.imagenet_mean, std=self.imagenet_std)
        return {self.input_names[0]: t.unsqueeze(0)}

    def postprocess(self, outputs: Mapping[str, torch.Tensor], categories: Sequence[str]) -> Classification:
        if self.output_names != list(outputs.keys()):
            raise ValueError("Output names mismatch")

        for name, tensor in outputs.items():
            if tensor.ndim == 1:
                tensor = tensor.unsqueeze(0)
            score, class_id = torch.max(F.softmax(tensor, dim=1), dim=1)

            return Classification(
                label=categories[int(class_id.item())],
                score=float(score.item()),
            )

    def postprocess_torch(self, outputs: torch.Tensor, categories: Sequence[str]) -> Classification:
        if outputs.ndim == 1:
            outputs = outputs.unsqueeze(0)
        score, class_id = torch.max(F.softmax(outputs, dim=1), dim=1)

        return Classification(
            label=categories[int(class_id.item())],
            score=float(score.item()),
        )

{
    "model_type": "custom_model",
    "model_attributes": {
        "conf_thres": {
            "type": "float",
            "default": 0.4,
            "ru_name": "Порог уверенности"
        }
    },
    "deploy_profile": {
        "default_profile": "inline_cuda_trt_fp16",
        "profiles": [
            "inline_cuda_trt_fp16",
            "inline_cuda_trt_fp32",
            "inline_cuda_onnx_fp32",
            "inline_cpu_onnx_fp32",
            "inline_cuda_torch_fp32",
            "inline_cpu_torch_fp32"
        ]
    },
    "task_type": "image_classification",
    "model_name": "custom_resnet18_imagenet",
    "model_version": "1",
    "img_size": {
        "height": 224,
        "width": 224
    },
    "weights_path": "weights*.*",
    "categories_path": "coco_categories.json"
}

├── coco_categories.json    # JSON-файл с описанием категорий
├── custom_modules          # Опциональная директория со вспомогательным кодом
│   ├── autoanchor.py           # https://github.com/WongKinYiu/yolov7/blob/main/utils/autoanchor.py
│   ├── common.py               # https://github.com/WongKinYiu/yolov7/blob/main/models/common.py
│   ├── datasets.py             # https://github.com/WongKinYiu/yolov7/blob/main/utils/datasets.py
│   ├── experimental.py         # https://github.com/WongKinYiu/yolov7/blob/main/models/experimental.py
│   ├── general.py              # https://github.com/WongKinYiu/yolov7/blob/main/utils/general.py
│   ├── __init__.py
│   ├── loss.py                 # https://github.com/WongKinYiu/yolov7/blob/main/utils/loss.py
│   ├── torch_utils.py          # https://github.com/WongKinYiu/yolov7/blob/main/utils/torch_utils.py
│   ├── yolo.py                 # https://github.com/WongKinYiu/yolov7/blob/main/models/yolo.py
│   └── yolo_utils.py           # вспомогательный файл для реализации letterbox, non_max_suppression, scale_coords
├── model_info.json         # JSON-файл с метаданными и параметрами модели
├── model.py                # Python-модуль, содержащий код для инициализации и работы модели
├── weights_h640_w640_b1_c3_onnx1.17.0_fp32.onnx                # сконвертированные веса ONNX в fp32
├── weights_h640_w640_b1_cc8.6_cuda11.8_trt8.6.1_fp16.engine    # сконвертированные веса TensorRT для целевой GPU архитектуры в fp16
├── weights_h640_w640_b1_cc8.6_cuda11.8_trt8.6.1_fp32.engine    # сконвертированные веса TensorRT для целевой GPU архитектуры в fp32
├── weights.pt              # веса модели для PyTorch
└── weights_tf.tar          # веса модели для Tensorflow

from pathlib import Path
from collections.abc import Sequence, Mapping

from numpy.typing import NDArray
import torch

# модуль с вспомогательными функциями находится на одном уровне с моделью
from .custom_modules.yolo_utils import letterbox, non_max_suppression, scale_coords
from .custom_modules.experimental import attempt_load

from vlmodels_types import CustomTorchModelProtocol, Detections
from vlmodels_types.protocol.custom_model_protocol import AllowedModelAttributeValue


class Model(CustomTorchModelProtocol[Detections]):
    input_names = ["images"]
    output_names = ["output"]

    def __init__(self, **model_attributes: AllowedModelAttributeValue) -> None:
        """
        Инициализирует модель с заданными параметрами.

        Аргументы:
            **model_attributes: Словарь с возможными ключами:
                - 'iou_thres' (float): Порог Intersection over Union для non-max suppression.
                - 'conf_thres' (float): Порог уверенности для детекций.

            Параметры model_attributes могут поступать либо из пользовательского интерфейса Node-RED,
            либо из файла model_info.json (если model_attributes не передан или пуст).

        Атрибуты:
            height (int): Высота изображения в пикселях входного изображения.
            width (int): Ширина изображения в пикселях входного изображения.
            iou_thres (float): Порог IoU для non-max suppression.
            conf_thres (float): Порог уверенности для детекций.
            current_img_size (tuple[int, int] | None): Текущий размер изображения в формате (height, width).
        """
        self.iou_thres: float = model_attributes["iou_thres"]
        self.conf_thres: float = model_attributes["conf_thres"]

        self.height: int = 640
        self.width: int = 640
        self.current_img_size: tuple[int, int] | None = None    # (height, width)

    # ==== Доп. метод для torch-бэкенда (опционально) ====
    def build_torch_model(self, artifacts_path: Path, device: str) -> torch.nn.Module:
        model = attempt_load(artifacts_path / "weights.pt") # не используем map_location
        model.to(device)
        model.eval()
        return model

    def preprocess(self, data: NDArray) -> Mapping[str, torch.Tensor]:
        self.current_img_size = (data.shape[0], data.shape[1])
        image, _, _ = letterbox(data, (self.height, self.width), auto=False)
        tensor = torch.from_numpy(image)
        tensor = (tensor.permute(2, 0, 1).flip(0).unsqueeze(0) / 255).contiguous()
        return {self.input_names[0]: tensor}

    def postprocess(self, outputs: Mapping[str, torch.Tensor], categories: Sequence[str]) -> Detections:
        if self.output_names != list(outputs.keys()):
            raise ValueError("Output names mismatch")

        for name, tensor in outputs.items():
            pred = non_max_suppression(tensor, self.conf_thres, self.iou_thres)[0]
            pred[:, :4] = scale_coords(
                (self.height, self.width),
                pred[:, :4],
                (self.current_img_size[0], self.current_img_size[1]),
            ).round()

            bboxes = pred[:, :4].cpu().numpy().astype(int)
            labels = tuple(map(lambda x: categories[int(x)], pred[:, 5].cpu().numpy()))
            scores = pred[:, 4].cpu().numpy()
            return Detections(bboxes, labels, scores)

    def postprocess_torch(self, outputs: torch.Tensor, categories: Sequence[str]) -> Detections:
        pred = non_max_suppression(outputs, self.conf_thres, self.iou_thres)[0]
        pred[:, :4] = scale_coords(
            (self.height, self.width),
            pred[:, :4],
            (self.current_img_size[0], self.current_img_size[1]),
        ).round()

        bboxes = pred[:, :4].cpu().numpy().astype(int)
        labels = tuple(map(lambda x: categories[int(x)], pred[:, 5].cpu().numpy()))
        scores = pred[:, 4].cpu().numpy()
        return Detections(bboxes, labels, scores)

{
    "model_type": "custom_model",
    "model_attributes": {
        "conf_thres": {
            "type": "float",
            "default": 0.4,
            "ru_name": "Порог уверенности"
        },
        "iou_thres": {
            "type": "float",
            "default": 0.45,
            "ru_name": "Порог IoU"
        }
    },
    "deploy_profile": {
        "default_profile": "inline_cuda_trt_fp16",
        "profiles": [
            "inline_cuda_trt_fp16",
            "inline_cuda_trt_fp32",
            "inline_cuda_onnx_fp32",
            "inline_cpu_onnx_fp32",
            "inline_cuda_torch_fp32",
            "inline_cuda_torch_fp16",
            "inline_cpu_torch_fp32",
            "inline_cpu_torch_fp16",
            "inline_cuda_tf_fp32",
            "inline_cpu_tf_fp32"
        ]
    },
    "task_type": "image_detection",
    "model_name": "custom_yolov7tiny_coco",
    "model_version": "2",
    "img_size": {
        "height": 640,
        "width": 640
    },
    "weights_path": "weights*.*",
    "categories_path": "coco_categories.json"
}

├── coco_categories.json            # JSON-файл с описанием категорий
├── model_info.json                 # JSON-файл с метаданными и параметрами модели
├── model.py                        # Python-модуль, содержащий код для инициализации и работы модели
├── weights.pt                      # веса модели maskrcnn
└── weights_resnet50-0676ba61.pth   # веса модели для backbone resnet50

from collections.abc import Sequence, Mapping
from pathlib import Path

from numpy.typing import NDArray
import numpy as np
import torch
from PIL import Image
from torchvision.models.detection import maskrcnn_resnet50_fpn, MaskRCNN_ResNet50_FPN_Weights
from vlmodels_types import Detections
from vlmodels_types.protocol.custom_model_protocol import AllowedModelAttributeValue, CustomTorchModelProtocol


class Model(CustomTorchModelProtocol[Detections]):
    input_names = ["images"]
    output_names = ["boxes", "labels", "scores", "masks"]

    def __init__(self, **model_attributes: AllowedModelAttributeValue) -> None:
        """
        Инициализирует модель MaskRCNN из torchvision с заданными параметрами.

        Аргументы:
            **model_attributes: Словарь с возможными ключами:
                - 'iou_thres' (float): Порог Intersection over Union для non-max suppression.
                - 'conf_thres' (float): Порог уверенности для детекций.

            Параметры model_attributes могут поступать либо из пользовательского интерфейса Node-RED,
            либо из файла model_info.json (если model_attributes не передан или пуст).
        """
        self.iou_thres: float = model_attributes["iou_thres"]
        self.conf_thres: float = model_attributes["conf_thres"]

        weights = MaskRCNN_ResNet50_FPN_Weights.DEFAULT
        self.preprocess_func = weights.transforms()

    # ==== Доп. метод для torch-бэкенда (опционально) ====
    def build_torch_model(self, artifacts_path: Path, device: str) -> torch.nn.Module:
        model = maskrcnn_resnet50_fpn(
            weights=None,
            weights_backbone=None,
            box_score_thresh=self.conf_thres,
            box_nms_thresh=self.iou_thres
        )

        # Загружаем веса backbone (ResNet50)
        backbone_state_dict = torch.load(artifacts_path / "weights_resnet50-0676ba61.pth")  # не используем map_location
        # Удаляем ключи, связанные с FC слоем
        keys_to_remove = [k for k in backbone_state_dict.keys() if k.startswith('fc.')]
        for key in keys_to_remove:
            backbone_state_dict.pop(key)

        checkpoint = torch.load(artifacts_path / "weights.pt")  # не используем map_location

        # Загружаем веса в модель
        model.backbone.load_state_dict(backbone_state_dict, strict=False)
        model.load_state_dict(checkpoint, strict=False)

        model.to(device)
        model.eval()
        return model

    def preprocess(self, data: NDArray) -> Mapping[str, torch.Tensor]:
        img = self.preprocess_func(Image.fromarray(data))
        return {self.input_names[0]: img.unsqueeze(0).cpu()}

    def postprocess_torch(self, outputs: torch.Tensor, categories: Sequence[str]) -> Detections:
        for out in outputs:
            # Избавиться от канала в каждой маске
            boxes = out["boxes"].cpu().numpy().astype(int)
            masks = np.squeeze(out["masks"].cpu().numpy(), axis=1)  # [N, 1, H, W] -> [N, H, W]
            # Применяем порог
            binary_masks = (masks > self.conf_thres).astype(np.uint8) * 255.0
            # Обрезаем маски
            binary_masks = [bin_mask[y1:y2, x1:x2] for bin_mask, (x1,y1,x2,y2) in zip(binary_masks, boxes, strict=True)]
            return Detections(
                boxes=boxes,
                labels=tuple(map(lambda x: categories[int(x)], out["labels"].cpu().numpy())),
                scores=out["scores"].cpu().numpy(),
                masks=binary_masks,
            )

Данный метод представляет собой унифицированный интерфейс, который 
система использует для взаимодействия с пользовательской моделью 
независимо от бэкенда (ONNX, Torch, TensorRT, TensorFlow).

Этапы выполнения:
1. **Препроцессинг**: Система вызывает метод `preprocess()` пользовательской модели,
   передавая входное изображение. Пользовательская модель отвечает за преобразование
   данных в формат, ожидаемый конкретным бэкендом (нормализация, ресайз, преобразование
   в тензор и т.п.).

2. **Инференс**: Подготовленные данные передаются во внутренний метод `forward()`
   выбранного бэкенда, который выполняет предсказание на акселераторе (GPU/CPU).

3. **Постпроцессинг**: Система автоматически передает raw output от модели и 
   дополнительные параметры (категории) в метод `postprocess()`
   пользовательской модели для формирования финального результата.

:param image: NDArray
    Входное изображение в формате numpy array. Система гарантирует корректность
    типа и формы данных перед передачей в модель.

:return: T_co
    Итоговый объект с результатами предсказания. Тип возвращаемого значения 
    определяется пользовательской моделью в Generic параметре T_co (обычно 
    это NamedTuple с четко описанной структурой).

Важно: Разработчику не нужно беспокоиться о передаче аргументов в методы - система 
автоматически обеспечивает передачу всех необходимых параметров:
- `categories` загружаются из coco_categories.json
- `outputs` содержат raw tensors непосредственно от inference движка
"""
# Этап 1: Пользовательский препроцессинг
inputs: Mapping[str, NDArray | torch.Tensor] = self.custom_model_instance.preprocess(image)

# Этап 2: Нативный инференс выбранного бэкенда
outputs: Mapping[str, torch.Tensor] = self.forward(inputs)

# Этап 3: Пользовательский постпроцессинг с автоматической передачей аргументов
return self.custom_model_instance.postprocess(
    outputs=outputs,
    categories=self.labels  # Автоматически загружается системой
)