OpenViSTAI · Agents · Blockchain · Crypto
Submit a project
Menu
AI Infrastructure & Serving

Deepdetect

DeepDetect is a C++ deep-learning runtime that provides a Python command-line tool and a REST server for training models and running inference.

Explore the practical guide ↓

Independent OpenViST project profile, based on linked sources.

Deepdetect — OpenViST project profile in AI Infrastructure & Serving.
OpenViST project illustration. See the linked sources for product details.
Understand the project

Practical overview

When it fits

Use the wheel and CLI for local training, in-process inference and automation; choose the server when clients need a persistent REST endpoint or asynchronous jobs over HTTP.

Who it is for

  • Developers building repeatable model-training and inference workflows from Python environments.
  • Teams that need a long-running REST service for remote clients or asynchronous model jobs.
  • Practitioners using Torch workflows or TensorRT for inference with exported or compatible models.

Documented uses

  • Train models and run predictions from the CLI or REST API.
  • Create model services backed by local filesystem repositories.
  • Monitor asynchronous training jobs and organize model files.
  • Return model-specific prediction outputs such as classes, scores, boxes or segmentation masks.
Before you choose

Requirements & limits

  • The Python wheel offers CPU and GPU variants; select one because they are mutually exclusive in the same environment.
  • Torch is the primary backend for training and inference; TensorRT is available for optimized inference with exported or compatible models.
  • The packaged CLI profiles focus on YOLOX and SegFormer, while the broader Torch API supports additional model and data workflows.
  • Docker is documented for containerized serving, while source builds are available for custom C++ builds, server options, TensorRT support or local development.

Check current requirements in the official documentation. Source-based guidance does not mean OpenViST has run or independently tested this project.

Source-based practical guide

Install the Python wheel and inspect CLI workflows

Set up the DeepDetect CLI in a Python environment and inspect available model profiles and options.

Before you start

  • A Python environment.
  • Choose either deepdetect-cpu or deepdetect-gpu; they are mutually exclusive in the same environment.

Steps

  1. Install one wheel variant using the documented package index; choose the GPU package for a CUDA-enabled environment.

  2. Run deepdetect inspect models to inspect packaged profiles.

  3. Use deepdetect train yolox --help or deepdetect infer segformer --help to inspect command options.

Expected outcome

The Python environment contains the DeepDetect runtime and CLI, and the profile and command options can be inspected.

Guide limitations

  • Installing the wheel and inspecting options does not configure a real dataset or run a model workflow.
  • CPU and GPU wheel variants cannot be installed together in the same environment.
Documentation 1 ↗
Source-based practical guide

Prepare and run the documented YOLOX quickstart

Use the documented fixture-based example to train a small YOLOX model and request inference on its sample image.

Before you start

  • A Python environment with the DeepDetect wheel installed.
  • Visdom installed and its server started in a second terminal.
  • The repository checkout, including the quickstart preparation script.

Steps

  1. Install Visdom with the command below and start it with the command below.

    Documented command
    python -m pip install visdom
    Documented command
    python -m visdom.server -port 8097

  2. Run the command below.

    Documented command
    python bindings/python/scripts/prepare_cli_yolox_quickstart.py --output /tmp/deepdetect-yolox-quickstart --force

  3. Train using deepdetect train yolox --config /tmp/deepdetect-yolox-quickstart/yolox-quickstart.yaml --terminal live.

  4. Pass the sample-image path printed by the preparation script to deepdetect infer yolox, using the same config and the documented visualization and output options.

Expected outcome

The example trains a small YOLOX run and writes an inference visualization to the specified output path.

Guide limitations

  • This is a small fixture-based example; real runs require replacing dataset, weight and repository paths as appropriate.
  • For the documented CUDA variant, use the GPU wheel and add --gpu to both training and inference commands.
Documentation 1 ↗
COMPARE OPTIONS

Compare options for Model inference and serving

These projects document a common task and share a project role. This is a source-based comparison, not an execution benchmark or a guarantee of interchangeability.

ProjectDocumented purposePlatformAccess and requirements
DeepdetectTrain models and run predictions from the CLI or REST API.CLI, Self-hosted, Server
MorphingdbImport a libtorch model and create predictions from values in a PostgreSQL table.Docker, Linux, Self-hosted, ServerThe README documents a Docker image and a build-from-repository option, followed by connecting to PostgreSQL and enabling the pgdl extension.
Gateway — pyadavSend chat-completion requests to a provider through a common server endpoint.ServerThe repository is public and identifies the project as Apache-2.0 licensed. README installation instructions include binaries, platform package managers and Docker.
Evidence and transparency

Sources & review

Official repository ↗
Source record details
Source availability
Active
Sources checked
16 October 2026
Original website title
jolibrain/deepdetect · Official homepage title · retained in its source language
How we review sourcesSuggest a correction