MemoLib

A computer vision model library built on PyTorch, providing a unified interface for object detection, image segmentation, image classification, text recognition, and anomaly detection.

Model Status

Unified Interface

All models share a consistent API:

model.LoadWeight(path)        # Load pretrained or custom weights
model.Train(callbacks)        # Start training
model.Predict(image)          # Single inference
model.BatchPredict(images)    # Batch inference
model.Export(path, format)    # Export to ONNX / OpenVINO / TensorRT
model.StopTraining()          # Stop training gracefully

Installation

pip install memolib

Optional dependencies

# For YOLO models
pip install memolib[yolo]

# For PPLCNet models
pip install memolib[pplcnet]

# For development
pip install memolib[dev]

Quick Start

Object Detection — YOLO

from MemoLib.Model.YOLO import Yolo
from MemoLib.Model.BaseModel.eDetectionModel import eYoloDetectionModel

model = Yolo()
model.cfg.Architecture = eYoloDetectionModel.Yolo11n
model.cfg.DatasetPath  = "path/to/dataset"
model.Train(callbacks=lambda level, msg: print(f"[{level}] {msg}"))

Classification — PPLCNet

from MemoLib.Model.PPLCNet import PPLCNet
from MemoLib.Model.BaseModel.eClassificationModel import ePPLCNetModel

model = PPLCNet()
model.cfg.Architecture = ePPLCNetModel.PPLCNetx50
model.cfg.DatasetPath  = "path/to/dataset"
model.Train()

Model Export

from MemoLib.Model.BaseModel.eModelBase import eModelExportType

model.Export("weights/best.pt", eModelExportType.ONNX)
model.Export("weights/best.pt", eModelExportType.OpenVINO)
model.Export("weights/best.pt", eModelExportType.TensorRT)

Project Structure

MemoLib/
└── Model/
    ├── BaseModel/       # Abstract interface (IModel), enums, export types
    ├── YOLO/            # YOLO detection, segmentation, classification
    ├── RFDETR/          # RF-DETR detection    
    ├── DinoUperNet/     # DINO + UperNet semantic segmentation  
    ├── Efficientnet/    # EfficientNet classification 
    ├── PPLCNet/         # PPLCNet lightweight classification
    ├── SVTRV2/          # SVTR2 text recognition  
    └── Anomaly/         # Dinomaly2, INP Former  

Dataset Format

Classification — YOLO / EfficientNet / PPLCNet

ImageFolder structure (same as torchvision ImageFolder):

dataset/
├── train/
│   ├── cat/
│   │   ├── img001.jpg
│   │   └── img002.jpg
│   └── dog/
│       ├── img003.jpg
│       └── img004.jpg
└── val/
    ├── cat/
    └── dog/

Detection — YOLO (detect / segment)

YOLO label format. data.yaml is auto-generated if missing.

dataset/
├── train/
│   ├── images/
│   │   ├── img001.jpg
│   └── labels/
│       ├── img001.txt        # <class> <x_c> <y_c> <w> <h>  (normalized 0-1)
├── val/
│   ├── images/
│   └── labels/
└── data.yaml

data.yaml:

path: /path/to/dataset
nc: 2
names: [cat, dog]
train: train/images
val:   val/images

For segmentation, the label format uses polygon points:

# <class> <x1> <y1> <x2> <y2> ... <xn> <yn>  (normalized 0-1)
0 0.1 0.2 0.3 0.4 0.5 0.6

Detection — RF-DETR

Supports two formats. Auto-detected from directory structure.

COCO format (recommended — exported directly from Roboflow/CVAT):

dataset/
├── train/
│   ├── img001.jpg
│   └── _annotations.coco.json
└── val/
    ├── img002.jpg
    └── _annotations.coco.json

YOLO format (same structure as YOLO detection above):

dataset/
├── train/
│   ├── images/
│   └── labels/
├── val/
│   ├── images/
│   └── labels/
└── data.yaml

Semantic Segmentation — DinoUperNet

Mask images must be single-channel PNG where each pixel value = class index.

dataset/
├── train/
│   ├── images/
│   │   ├── img001.jpg
│   └── masks/
│       ├── img001.png        # pixel value = class index (0, 1, 2, ...)
├── val/
│   ├── images/
│   └── masks/

ReduceZeroLabel: if True, pixel value 0 is treated as background/unlabeled (ignored in loss), and class indices shift by -1. Use this for datasets like ADE20K where class 0 = unlabeled.

Requirements

• Python 3.9+
• PyTorch 2.x (CUDA 12.x recommended)
• See requirements.txt for full dependency list

License

MIT License