MONAI (Medical Open Network for AI) is a PyTorch-based, open-source framework for deep learning in healthcare imaging. It provides a comprehensive suite of modular components for building, training, and deploying medical image analysis models, including segmentation, classification, detection, registration, reconstruction, and generative tasks. The architecture is library-oriented, with well-separated subpackages for transforms, networks, losses, metrics, handlers, engines, data I/O, and domain-specific applications (pathology, reconstruction, auto3dseg, federated learning). Key design patterns include composable and invertible transforms (with lazy evaluation support), a config-driven bundle system for reproducible workflows, Ignite-based training engines with reusable event handlers, and a MetaTensor data structure that carries spatial metadata through transformations. The codebase is extensively tested (over 1500 test files) and includes C++/CUDA extensions for performance-critical operations. While primarily a software library, MONAI also serves as a research platform, incorporating state-of-the-art architectures (UNETR, SwinUNETR, diffusion models, HyenaMixer) and supporting automated pipeline generation (Auto3DSeg) and federated learning. Its hybrid nature combines production-grade engineering with research-oriented flexibility.
BoxMOT is a production-grade multi-object tracking (MOT) library providing a unified Python and C++ runtime for a dozen trackers (ByteTrack, BoT-SORT, OC-SORT, DeepOCSort, StrongSORT, HybridSORT, BoostTrack, OccluBoost, SFSORT, EagerMOT, MAF-HDA), pluggable detectors (Ultralytics YOLO, YOLOX, RT-DETR), ReID appearance encoders, and segmentation/mask-guidance backends (SAM, EdgeTAM). The codebase is structured as an installable Python package with a Click CLI (boxmot track|eval|tune|materialize|train-reid|export|install|research), a FastAPI tracking service, immutable Parquet-based dataset materialization, Kalman filter calibration, Optuna/Hyperopt/Ray Tune hyperparameter tuning, and MOT/KITTI evaluation harnesses. Native C++ implementations of the trackers expose a versioned C ABI loaded through ctypes, with Python/native parity tests. Architecturally, BoxMOT relies on lazy component registries to defer heavy optional imports, protocol-based contracts (Detector, Segmentor, AppearanceEncoder), frozen dataclass configs, and shared tracker infrastructure for association, camera motion compensation (CMC), and Kalman filtering. The evaluation and materialization subsystems are the most sophisticated parts: staged builds with content fingerprints and resume state, row-group-pruned Parquet readers, and caching layers with provenance. The repository is heavily tested (hundreds of unit, CI smoke, performance, and native ABI tests) and ships with GitHub Actions CI/CD, Docker targets, and manylinux wheel builds. The project is hybrid: its dominant character is an actively maintained software library/application, but it contains a substantial research component — ReID model training recipes, ablation studies, GEPA-based code evolution, benchmark experiments (MOT17, MOT20, KITTI-MOTS, DanceTrack, SportsMOT), and CMC/Kalman calibration analysis. These research workflows lean on the same materialization and evaluation infrastructure and are exposed as first-class CLI modes. Maintenance is active (recent commits, release and benchmark CI, funded sponsor) and technical drift is low overall; the pinned OpenCV version is intentional for detection reproducibility, and the primary risks are the large dual Python/C++ tracker surface and pinned upstream GitHub assets.
Kagome is a self-contained Japanese morphological analyzer written in pure Go. It provides tokenization with part-of-speech tagging, multiple segmentation modes (normal, search, extended), and dictionaries embedded in the binary for easy deployment. The system includes a CLI tool with subcommands (tokenize, server, lattice, sentence), a RESTful API server mode, WebAssembly support for browser use, and C library API for FFI integration with languages like Python and PHP. The architecture centers around a lattice-based Viterbi algorithm for tokenization, with clean separation between tokenizer logic, dictionary handling, filtering utilities, and interface layers.
Sudachi is a professional-grade Japanese morphological analyzer implemented as a Java library and CLI tool. It performs tokenization, part-of-speech tagging, and text normalization using a plugin-based architecture with configurable input rewriting, out-of-vocabulary (OOV) handling, and lattice path rewriting. The system relies on precompiled binary dictionaries (system and user) built from CSV lexicons, and supports three segmentation modes (A, B, C) to balance between shortest and longest tokenization for different use cases. Internally, Sudachi uses a double-array trie for fast common-prefix search, memory-mapped file I/O for efficient dictionary loading, and a Viterbi-style lattice search for optimal path selection. The project includes a command-line interface, a comprehensive test suite, JMH benchmarks, and CI/CD pipelines. It is designed for embedding in larger applications (e.g., Elasticsearch via a separate plugin) and has been used in production at Works Applications.
AlbumentationsX is a production-grade Python library for fast, flexible image augmentation in deep learning and computer vision pipelines. It provides a comprehensive catalog of 70+ transforms covering pixel-level (blur, noise, color, weather effects), geometric (flip, rotate, crop, resize, distortion, perspective), dropout (coarse, grid, mask, pixel), mixing (mosaic, copy-paste, overlay), and domain adaptation (FDA, histogram matching, stain normalization). The library supports 2D and 3D data, including images, masks, bounding boxes (HBB and OBB), keypoints, and volumes, with seamless integration into PyTorch via tensor transforms. Its architecture is built on a clean inheritance hierarchy (BasicTransform → DualTransform/ImageOnlyTransform/Transform3D) with Pydantic-based parameter validation, serialization to JSON/YAML, and deterministic replay via ReplayCompose. The codebase is backed by an extensive test suite (property-based, regression, contract, and golden vector tests), ASV benchmarks, and a sophisticated CI/CD system with path-aware planning, performance budgets, and legal integrity checks. Telemetry (opt-out) collects anonymous usage statistics to guide development. While primarily a software library, it incorporates research-level transforms (e.g., PlanckianJitter, HEStain, dithering) and is used in both academic and production settings.
nnU-Net v2 is a self-configuring deep learning framework for medical image segmentation that automates preprocessing, network architecture selection, training, and inference. It ingests raw medical images in various formats (NIfTI, TIFF, DICOM via SimpleITK) and produces segmentation masks. The system is organized as a modular monolith: experiment planning extracts dataset fingerprints to determine optimal preprocessing and network topology; a preprocessing pipeline handles resampling, normalization, and cropping; training uses a configurable base trainer with many variants (including 3D/2D U-Nets, residual encoders, and transformer-based Primus architectures); inference employs sliding-window with Gaussian weighting and test-time augmentation. Key entry points are CLI commands (nnUNetv2_plan_and_preprocess, nnUNetv2_train, nnUNetv2_predict) and the programmatic nnUNetPredictor. The codebase demonstrates high craftsmanship in its checkpoint system (safetensors with backward compatibility), pluggable image I/O, and configuration management via plans files, though it carries some technical debt from legacy .pth support and a proliferation of trainer variant subclasses.
TheAnimeScripter (TAS) is a production-grade AI video enhancement toolkit specialized for anime content. It performs frame interpolation (RIFE 4.15-4.25 variants, GMFSS, DistilDRBA), super-resolution (30+ architectures via a vendored spandrel fork), restoration, frame deduplication, monocular depth estimation (Depth Anything V2/V3, Video Depth Anything, Limbo), scene-change detection, stabilization, segmentation, and object detection. It ships as a CLI tool (main.py), an Adobe After Effects plugin (src/server/aeComms.py via Socket.IO), and a standalone desktop build (build.py + tools/build_support/). The pipeline is: decode video via FFmpeg or the custom nelux library, stream frames through a FrameWindow sliding buffer, apply dedup → restore → upscale → interpolate stages, then re-encode with configurable codecs, bit depths, and BT.709/BT.2020 color spaces.
SudachiDict is a repository that provides linguistic data resources for the Sudachi Japanese tokenizer. It processes raw dictionary CSV files (sourced from UniDic and NEologd) into binary dictionary files in three editions: Small (UniDic only), Core (basic vocabulary), and Full (includes proper nouns). The repository includes automated build scripts to compile these dictionaries, packaging utilities to distribute them as Java/Maven artifacts and Python packages, and test suites to verify correctness. While it contains some application-like elements (build scripts, packaging), its primary function is data curation and distribution for NLP use cases.
MetaSeg is a Python library that packages Facebook's Segment Anything Model (SAM) into an easy-to-use interface for automatic and manual image/video segmentation. It provides high-level predictors (SegAutoMaskPredictor, SegManualMaskPredictor) that handle model loading, inference, and output visualization. The library integrates with SAHI for sliced inference and FalAI for cloud GPU execution, and includes a Gradio web application. The codebase is primarily a thin orchestration layer over the official SAM implementation, with additional utility functions for data loading, video processing, and model download. It is designed for developers who want to quickly apply SAM without deep model internals.
DART (Detect Anything in Real Time) is a training-free framework that converts SAM3 into a real-time multi-class open-vocabulary detector. In practice, the codebase is an inference-optimization and deployment framework: it exports SAM3 backbone components to ONNX/TensorRT, applies FP16/INT8 quantization, builds optimized TRT engines, and runs pipelined video inference with CUDA graphs and torch.compile. It also includes an LLM-driven interactive agent (Qwen via OpenAI-compatible API) that performs iterative segmentation through tool calls (segment_phrase, examine_each_mask, select_masks_and_return), plus video dataset handling, grounding/mask export utilities, and COCO-style evaluation scripts. The repository is a hybrid: fundamentally an application/framework for real-time detection, it carries strong research-code characteristics — calibration caches (calib/*.json), ad-hoc experiment scripts with hardcoded checkpoints (sam3.pt, backbone.onnx), and iterative debugging comments ('Previous test showed...'). The architecture centers on ONNX export of SAM3 blocks (EfficientViT backbone, text encoder, prompt encoder, mask predictor, pixel decoder), TRT engine building, and a quantization layer (dartf/quant/) with experimental plugins tightly coupled to specific ONNX graph patterns. A media production pipeline (dartf/media/) builds explainer videos with automated slide rendering and music mixing. The codebase shows signs of being an experimental workspace rather than a maintained library: hardcoded paths in evaluation configs, version-sensitive TensorRT API usage, a fragile ONNX export pipeline depending on onnxsim subprocess calls, and potential drift between ONNX-exported blocks and real backbone behavior. The 'training-free' claim is partially contradicted by the presence of distillation training code, and the package name dart-detect vs module sam3 mismatch may cause import confusion. Despite these issues, several well-isolated components — an abstract prediction-file evaluator, a TensorRT layer analysis script, and an LLM agent client — could be extracted for reuse in other vision or agent projects.
This repository contains a Keras implementation of the U-Net architecture for biomedical image segmentation, specifically trained on the ISBI challenge membrane dataset. The code provides a straightforward pipeline: data loading and augmentation (via Keras ImageDataGenerator), model definition (U-Net with symmetric encoder-decoder), training script (main.py or notebook), and inference to generate predicted segmentation masks. The dataset is bundled within the repo (30 training images and masks, plus tests). The implementation relies on an outdated Keras 1.x API (deprecated `merge` function, `Model.fit_generator`) and has no dependency pinning or environment specification, making reproducibility low. While the functional components like the data generator and U-Net architecture are reusable patterns, the codebase is academically simple and exhibits significant technical debt relative to modern deep learning frameworks. It is best suited as a reference or educational starting point rather than production use.
This repository serves as a companion to the survey paper 'Towards Open Vocabulary Learning: A Survey' published in T-PAMI 2024. It contains two markdown files: README.md and dataset.md. The README provides a curated, tabular listing of papers covering open-vocabulary object detection, segmentation, video understanding, and 3D scene understanding, along with related domains. The dataset.md lists standard benchmarks and dataset splits used across these tasks. The repository does not contain any executable code, data processing pipelines, or model implementations. It is purely a literature survey resource. While useful as a reference for researchers, it has no reusable software components and no data lineage to trace.