fix broken git history

.dockerignore

@@ -0,0 +1,8 @@
+**/test.*
+**/.vscode
+**/__pycache__
+**/.env
+app/firebase_config.json
+demo
+**/*.mp4
+**/*.jpg

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text

.github/workflows/deploy.yml

@@ -0,0 +1,20 @@
+name: Deploy On Hugging Face
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push https://phuochungus:$HF_TOKEN@huggingface.co/spaces/phuochungus/RTMDet_PRODUCTION main

.gitignore

@@ -0,0 +1,8 @@
+**/test.*
+**/.vscode
+**/__pycache__
+**/.env
+app/firebase_config.json
+demo
+**/*.mp4
+**/*.jpg

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.8
+
+#CREATE A USER
+RUN useradd -m -u 1000 user
+
+RUN apt-get update && apt-get install -y libgl1 ffmpeg
+
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+RUN pip install --no-cache-dir --upgrade pip
+
+#COPY SOURCE CODE
+WORKDIR ${HOME}/app
+
+COPY --chown=user . .
+
+RUN pip install -r ./app/requirements.txt
+
+COPY ./libs/image.py /home/user/.local/lib/python3.8/site-packages/mmcv/visualization/image.py
+
+EXPOSE 3000
+
+CMD [ "uvicorn", "app.main:app", "--host" ,"0.0.0.0" ,"--port", "3000"]

README.md

@@ -0,0 +1,18 @@
+---
+title: Rtmdet
+emoji: 🐠
+colorFrom: yellow
+colorTo: pink
+sdk: docker
+pinned: false
+app_port: 3000
+---
+
+HOW TO RUN:
+open compose.yaml file and mannually change environment variables
+bash
+```
+docker compose up -d
+```
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/__init__.py

@@ -0,0 +1,28 @@
+import os
+from dotenv import load_dotenv
+from mmdeploy_runtime import Detector
+from supabase import create_client, Client
+from firebase_admin import credentials, initialize_app
+import json
+
+import logging
+
+logger = logging.getLogger("uvicorn")
+logger.setLevel(logging.INFO)
+
+
+load_dotenv()
+
+model_path = "./model"
+detector = Detector(model_path=model_path, device_name="cpu", device_id=0)
+
+url: str = os.environ.get("SUPABASE_URL")
+key: str = os.environ.get("SUPABASE_KEY")
+supabase: Client = create_client(url, key)
+
+
+firebase_app = initialize_app(
+    credential=credentials.Certificate(
+        json.loads(os.environ.get("FIREBASE_CREDENTIALS"))
+    )
+)

app/constants.py

@@ -0,0 +1,168 @@
+colors = [
+    (255, 0, 0),
+    (0, 255, 0),
+    (0, 0, 255),
+    (255, 255, 0),
+    (255, 0, 255),
+    (0, 255, 255),
+    (128, 0, 0),
+    (0, 128, 0),
+    (0, 0, 128),
+    (128, 128, 0),
+    (128, 0, 128),
+    (0, 128, 128),
+    (165, 42, 42),
+    (210, 105, 30),
+    (218, 165, 32),
+    (139, 69, 19),
+    (244, 164, 96),
+    (255, 99, 71),
+    (255, 127, 80),
+    (255, 69, 0),
+    (255, 140, 0),
+    (255, 215, 0),
+    (218, 112, 214),
+    (255, 182, 193),
+    (255, 192, 203),
+    (255, 20, 147),
+    (199, 21, 133),
+    (255, 105, 180),
+    (255, 0, 255),
+    (255, 250, 205),
+    (250, 128, 114),
+    (255, 99, 71),
+    (255, 69, 0),
+    (255, 140, 0),
+    (255, 215, 0),
+    (255, 223, 0),
+    (255, 182, 193),
+    (255, 192, 203),
+    (255, 20, 147),
+    (199, 21, 133),
+    (255, 105, 180),
+    (255, 0, 255),
+    (255, 250, 205),
+    (250, 128, 114),
+    (255, 99, 71),
+    (255, 69, 0),
+    (255, 140, 0),
+    (255, 215, 0),
+    (173, 255, 47),
+    (154, 205, 50),
+    (85, 107, 47),
+    (144, 238, 144),
+    (0, 128, 0),
+    (0, 255, 0),
+    (50, 205, 50),
+    (0, 250, 154),
+    (0, 255, 127),
+    (0, 128, 128),
+    (0, 139, 139),
+    (0, 206, 209),
+    (70, 130, 180),
+    (100, 149, 237),
+    (0, 0, 128),
+    (0, 0, 139),
+    (0, 0, 205),
+    (0, 0, 255),
+    (0, 191, 255),
+    (30, 144, 255),
+    (135, 206, 235),
+    (173, 216, 230),
+    (175, 238, 238),
+    (240, 248, 255),
+    (240, 255, 240),
+    (245, 245, 220),
+    (255, 228, 196),
+    (255, 235, 205),
+    (255, 239, 219),
+    (255, 245, 238),
+    (245, 222, 179),
+    (255, 248, 220),
+    (255, 250, 240),
+    (250, 250, 210),
+    (253, 245, 230),
+]
+
+classNames = [
+    "person",
+    "bicycle",
+    "car",
+    "motorcycle",
+    "airplane",
+    "bus",
+    "train",
+    "truck",
+    "boat",
+    "traffic light",
+    "fire hydrant",
+    "stop sign",
+    "parking meter",
+    "bench",
+    "bird",
+    "cat",
+    "dog",
+    "horse",
+    "sheep",
+    "cow",
+    "elephant",
+    "bear",
+    "zebra",
+    "giraffe",
+    "backpack",
+    "umbrella",
+    "handbag",
+    "tie",
+    "suitcase",
+    "frisbee",
+    "skis",
+    "snowboard",
+    "sports ball",
+    "kite",
+    "baseball bat",
+    "baseball glove",
+    "skateboard",
+    "surfboard",
+    "tennis racket",
+    "bottle",
+    "wine glass",
+    "cup",
+    "fork",
+    "knife",
+    "spoon",
+    "bowl",
+    "banana",
+    "apple",
+    "sandwich",
+    "orange",
+    "broccoli",
+    "carrot",
+    "hot dog",
+    "pizza",
+    "donut",
+    "cake",
+    "chair",
+    "couch",
+    "potted plant",
+    "bed",
+    "dining table",
+    "toilet",
+    "tv",
+    "laptop",
+    "mouse",
+    "remote",
+    "keyboard",
+    "cell phone",
+    "microwave",
+    "oven",
+    "toaster",
+    "sink",
+    "refrigerator",
+    "book",
+    "clock",
+    "vase",
+    "scissors",
+    "teddy bear",
+    "hair drier",
+    "toothbrush",
+]

app/dependencies.py

@@ -0,0 +1,31 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from jwt import InvalidTokenError
+from app import logger
+from firebase_admin import auth
+
+security = HTTPBearer()
+
+
+async def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = auth.verify_id_token(credentials.credentials)
+    except InvalidTokenError as e:
+        logger.info(e)
+        raise credentials_exception
+    except ValueError as e:
+        logger.info(e)
+        raise credentials_exception
+    except Exception as e:
+        logger.info(e)
+        print(e)
+        raise credentials_exception
+
+    return payload

app/main.py

@@ -0,0 +1,26 @@
+from typing_extensions import Annotated
+from fastapi import Depends, FastAPI
+
+from app.dependencies import get_current_user
+from .routers import image, video
+
+
+app = FastAPI()
+
+app.include_router(image.router)
+app.include_router(video.router)
+
+
+@app.get("/me")
+def getProfile(current_user: Annotated[any, Depends(get_current_user)]):
+    return current_user
+
+
+@app.post("/login")
+def login(email: str, password: str):
+    return "not implemented yet"
+
+
+@app.get("/")
+def hello():
+    return "Hello World!"

app/requirements.txt

@@ -0,0 +1,12 @@
+aiofiles==23.2.1
+fastapi==0.103.1
+mmcv==2.0.1
+mmdeploy_runtime==1.2.0
+numpy==1.24.4
+opencv_python==4.8.0.76
+python-dotenv==1.0.0
+Requests==2.31.0
+supabase==1.0.4
+uvicorn==0.23.2
+python-multipart==0.0.6
+firebase_admin==6.2.0

app/routers/image.py

@@ -0,0 +1,68 @@
+from fastapi import APIRouter, File, Response, WebSocket, WebSocketDisconnect
+import mmcv
+import cv2
+import numpy as np
+from app.constants import classNames, colors
+from app import detector
+
+
+router = APIRouter(prefix="/image")
+
+
+@router.post("")
+async def handleImageRequest(
+    file: bytes = File(...),
+    threshold: float = 0.3,
+    raw: bool = False,
+):
+    img = mmcv.imfrombytes(file, cv2.IMREAD_COLOR)
+    if raw:
+        bboxes, labels = inferenceImage(img, threshold, raw)
+        return {"bboxes": bboxes.tolist(), "labels": labels.tolist()}
+
+    img = inferenceImage(img, threshold, raw)
+    ret, jpeg = cv2.imencode(".jpg", img)
+
+    if not ret:
+        return Response(content="Failed to encode image", status_code=500)
+    jpeg_bytes: bytes = jpeg.tobytes()
+
+    return Response(content=jpeg_bytes, media_type="image/jpeg")
+
+
+def inferenceImage(img, threshold: float, isRaw: bool = False):
+    bboxes, labels, _ = detector(img)
+    if isRaw:
+        removeIndexs = []
+        for i, bbox in enumerate(bboxes):
+            if bbox[4] < threshold:
+                removeIndexs.append(i)
+
+        bboxes = np.delete(bboxes, removeIndexs, axis=0)
+        labels = np.delete(labels, removeIndexs)
+
+        return bboxes, labels
+    return mmcv.imshow_det_bboxes(
+        img=img,
+        bboxes=bboxes,
+        labels=labels,
+        class_names=classNames,
+        show=False,
+        colors=colors,
+        score_thr=threshold,
+    )
+
+
+@router.websocket("/")
+async def websocketEndpoint(websocket: WebSocket, threshold: float = 0.3):
+    await websocket.accept()
+    try:
+        while True:
+            data = await websocket.receive_bytes()
+            img = mmcv.imfrombytes(data, cv2.IMREAD_COLOR)
+            bboxes, labels = inferenceImage(img, threshold, True)
+            await websocket.send_json(
+                {"bboxes": bboxes.tolist(), "labels": labels.tolist()}
+            )
+    except WebSocketDisconnect:
+        pass

app/routers/video.py

@@ -0,0 +1,151 @@
+import asyncio
+import json
+from multiprocessing import Process
+import os
+import re
+import shutil
+import time
+import aiofiles
+import cv2
+from fastapi import (
+    APIRouter,
+    Depends,
+    HTTPException,
+    UploadFile,
+    BackgroundTasks,
+    status,
+)
+import requests
+from app import supabase
+from app.dependencies import get_current_user
+from app.routers.image import inferenceImage
+
+router = APIRouter(prefix="/video")
+
+
+@router.post("/{artifactId}")
+async def handleVideoRequest(
+    artifactId: str,
+    file: UploadFile,
+    background_tasks: BackgroundTasks,
+    threshold: float = 0.3,
+    user=Depends(get_current_user),
+):
+    if re.search("^video\/", file.content_type) is None:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="File must be video",
+        )
+
+    try:
+        id = str(now())
+        os.mkdir(id)
+        async with aiofiles.open(os.path.join(id, "input.mp4"), "wb") as out_file:
+            while content := await file.read(1024):
+                await out_file.write(content)
+        background_tasks.add_task(inferenceVideo, artifactId, id, threshold)
+        return id + ".mp4"
+    except ValueError as err:
+        print(err)
+        print("Error processing video")
+        shutil.rmtree(id)
+
+
+def now():
+    return round(time.time() * 1000)
+
+
+async def inferenceVideo(artifactId: str, inputDir: str, threshold: float):
+    try:
+        Process(updateArtifact(artifactId, {"status": "processing"})).start()
+        cap = cv2.VideoCapture(
+            filename=os.path.join(inputDir, "input.mp4"), apiPreference=cv2.CAP_FFMPEG
+        )
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        size = (
+            int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
+            int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)),
+        )
+        result = cv2.VideoWriter(
+            filename=os.path.join(inputDir, "out.mp4"),
+            fourcc=cv2.VideoWriter_fourcc(*"mp4v"),
+            fps=fps,
+            frameSize=size,
+        )
+
+        isFirstFrame = True
+        thumbnail = None
+        while cap.isOpened():
+            res, frame = cap.read()
+            if isFirstFrame:
+                isFirstFrame = False
+                thumbnail = frame
+
+            if res == False:
+                break
+
+            resFram = inferenceImage(frame, threshold)
+            result.write(resFram)
+
+        cap.release()
+        result.release()
+
+        def createThumbnail(thumbnail):
+            thumbnail = cv2.resize(
+                src=thumbnail, dsize=(160, 160), interpolation=cv2.INTER_AREA
+            )
+            cv2.imwrite(os.path.join(inputDir, "thumbnail.jpg"), thumbnail)
+
+        createThumbnail(thumbnail)
+
+        async def uploadVideo():
+            async with aiofiles.open(os.path.join(inputDir, "out.mp4"), "rb") as f:
+                supabase.storage.from_("video").upload(
+                    inputDir + ".mp4", await f.read(), {"content-type": "video/mp4"}
+                )
+
+        async def uploadThumbnail():
+            async with aiofiles.open(
+                os.path.join(inputDir, "thumbnail.jpg"), "rb"
+            ) as f:
+                supabase.storage.from_("thumbnail").upload(
+                    inputDir + ".jpg", await f.read(), {"content-type": "image/jpeg"}
+                )
+
+        try:
+            n = now()
+            _, _ = await asyncio.gather(uploadVideo(), uploadThumbnail())
+            print(now() - n)
+        except Exception as e:
+            print(e)
+
+        updateArtifact(
+            artifactId,
+            {
+                "status": "success",
+                "path": "https://hdfxssmjuydwfwarxnfe.supabase.co/storage/v1/object/public/video/"
+                + inputDir
+                + ".mp4",
+                "thumbnailURL": "https://hdfxssmjuydwfwarxnfe.supabase.co/storage/v1/object/public/thumbnail/"
+                + inputDir
+                + ".jpg",
+            },
+        )
+    except:
+        Process(
+            updateArtifact(
+                artifactId,
+                {
+                    "status": "fail",
+                },
+            )
+        ).start()
+    finally:
+        shutil.rmtree(inputDir)
+
+
+def updateArtifact(artifactId: str, body):
+    url = "https://firebasetot.onrender.com/artifacts/" + artifactId
+    payload = json.dumps(body)
+    headers = {"Content-Type": "application/json"}
+    requests.request("PATCH", url, headers=headers, data=payload)

compose.yaml

@@ -0,0 +1,10 @@
+services:
+    app:
+        build: .
+        image: phuochungus/rtmdet
+        ports:
+            - "3000:3000"
+        environment:
+            - SUPABASE_URL=your-supabase-url
+            - SUPABASE_KEY=your-supabase-key
+            - FIREBASE_CREDENTIALS=your-firebase-credentials

libs/image.py

@@ -0,0 +1,170 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+from typing import List, Optional, Union
+
+import cv2
+import numpy as np
+
+from mmcv.image import imread, imwrite
+from .color import Color, color_val
+
+# a type alias declares the optional types of color argument
+ColorType = Union[Color, str, tuple, int, np.ndarray]
+
+
+def imshow(img: Union[str, np.ndarray], win_name: str = "", wait_time: int = 0):
+    """Show an image.
+
+    Args:
+        img (str or ndarray): The image to be displayed.
+        win_name (str): The window name.
+        wait_time (int): Value of waitKey param.
+    """
+    cv2.imshow(win_name, imread(img))
+    if wait_time == 0:  # prevent from hanging if windows was closed
+        while True:
+            ret = cv2.waitKey(1)
+
+            closed = cv2.getWindowProperty(win_name, cv2.WND_PROP_VISIBLE) < 1
+            # if user closed window or if some key pressed
+            if closed or ret != -1:
+                break
+    else:
+        ret = cv2.waitKey(wait_time)
+
+
+def imshow_bboxes(
+    img: Union[str, np.ndarray],
+    bboxes: Union[list, np.ndarray],
+    colors: ColorType = "green",
+    top_k: int = -1,
+    thickness: int = 1,
+    show: bool = True,
+    win_name: str = "",
+    wait_time: int = 0,
+    out_file: Optional[str] = None,
+):
+    """Draw bboxes on an image.
+
+    Args:
+        img (str or ndarray): The image to be displayed.
+        bboxes (list or ndarray): A list of ndarray of shape (k, 4).
+        colors (Color or str or tuple or int or ndarray): A list of colors.
+        top_k (int): Plot the first k bboxes only if set positive.
+        thickness (int): Thickness of lines.
+        show (bool): Whether to show the image.
+        win_name (str): The window name.
+        wait_time (int): Value of waitKey param.
+        out_file (str, optional): The filename to write the image.
+
+    Returns:
+        ndarray: The image with bboxes drawn on it.
+    """
+    img = imread(img)
+    img = np.ascontiguousarray(img)
+
+    if isinstance(bboxes, np.ndarray):
+        bboxes = [bboxes]
+    if not isinstance(colors, list):
+        colors = [colors for _ in range(len(bboxes))]
+    colors = [color_val(c) for c in colors]
+    assert len(bboxes) == len(colors)
+
+    for i, _bboxes in enumerate(bboxes):
+        _bboxes = _bboxes.astype(np.int32)
+        if top_k <= 0:
+            _top_k = _bboxes.shape[0]
+        else:
+            _top_k = min(top_k, _bboxes.shape[0])
+        for j in range(_top_k):
+            left_top = (_bboxes[j, 0], _bboxes[j, 1])
+            right_bottom = (_bboxes[j, 2], _bboxes[j, 3])
+            cv2.rectangle(img, left_top, right_bottom, colors[i], thickness=thickness)
+
+    if show:
+        imshow(img, win_name, wait_time)
+    if out_file is not None:
+        imwrite(img, out_file)
+    return img
+
+
+def imshow_det_bboxes(
+    img: Union[str, np.ndarray],
+    bboxes: np.ndarray,
+    labels: np.ndarray,
+    class_names: List[str] = None,
+    score_thr: float = 0,
+    bbox_color: ColorType = "green",
+    text_color: ColorType = "green",
+    thickness: int = 1,
+    font_scale: float = 1,
+    show: bool = True,
+    win_name: str = "",
+    wait_time: int = 0,
+    out_file: Optional[str] = None,
+    colors: np.ndarray = None,
+):
+    """Draw bboxes and class labels (with scores) on an image.
+
+    Args:
+        img (str or ndarray): The image to be displayed.
+        bboxes (ndarray): Bounding boxes (with scores), shaped (n, 4) or
+            (n, 5).
+        labels (ndarray): Labels of bboxes.
+        class_names (list[str]): Names of each classes.
+        score_thr (float): Minimum score of bboxes to be shown.
+        bbox_color (Color or str or tuple or int or ndarray): Color
+            of bbox lines.
+        text_color (Color or str or tuple or int or ndarray): Color
+            of texts.
+        thickness (int): Thickness of lines.
+        font_scale (float): Font scales of texts.
+        show (bool): Whether to show the image.
+        win_name (str): The window name.
+        wait_time (int): Value of waitKey param.
+        out_file (str or None): The filename to write the image.
+        colors (array of tuple RGB int): the color of bbox and label of each class
+
+    Returns:
+        ndarray: The image with bboxes drawn on it.
+    """
+    assert bboxes.ndim == 2
+    assert labels.ndim == 1
+    assert bboxes.shape[0] == labels.shape[0]
+    assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5
+    img = imread(img)
+    
+    if score_thr > 0:
+        assert bboxes.shape[1] == 5
+        scores = bboxes[:, -1]
+        inds = scores > score_thr
+        bboxes = bboxes[inds, :]
+        labels = labels[inds]
+
+    bbox_color = color_val(bbox_color)
+    text_color = color_val(text_color)
+
+    for bbox, label in zip(bboxes, labels):
+        bbox_int = bbox.astype(np.int32)
+        left_top = (bbox_int[0], bbox_int[1])
+        right_bottom = (bbox_int[2], bbox_int[3])
+        if colors is not None:
+            bbox_color = text_color = color_val(colors[label])
+        cv2.rectangle(img, left_top, right_bottom, bbox_color, thickness=thickness)
+        label_text = class_names[label] if class_names is not None else f"cls {label}"
+        if len(bbox) > 4:
+            label_text += f"|{bbox[-1]:.02f}"
+        cv2.putText(
+            img,
+            label_text,
+            (bbox_int[0], bbox_int[1] - 2),
+            cv2.FONT_HERSHEY_TRIPLEX,
+            font_scale,
+            text_color,
+            4
+        )
+
+    if show:
+        imshow(img, win_name, wait_time)
+    if out_file is not None:
+        imwrite(img, out_file)
+    return img

model/deploy.json

@@ -0,0 +1,16 @@
+{
+    "version": "1.2.0",
+    "task": "Detector",
+    "models": [
+        {
+            "name": "rtmdet",
+            "net": "end2end.onnx",
+            "weights": "",
+            "backend": "onnxruntime",
+            "precision": "FP32",
+            "batch_size": 1,
+            "dynamic_shape": true
+        }
+    ],
+    "customs": []
+}

model/detail.json

@@ -0,0 +1,68 @@
+{
+    "version": "1.2.0",
+    "codebase": {
+        "task": "ObjectDetection",
+        "codebase": "mmdet",
+        "version": "3.1.0",
+        "pth": "rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth",
+        "config": "rtmdet_tiny_8xb32-300e_coco.py"
+    },
+    "codebase_config": {
+        "type": "mmdet",
+        "task": "ObjectDetection",
+        "model_type": "end2end",
+        "post_processing": {
+            "score_threshold": 0.05,
+            "confidence_threshold": 0.005,
+            "iou_threshold": 0.5,
+            "max_output_boxes_per_class": 200,
+            "pre_top_k": 5000,
+            "keep_top_k": 100,
+            "background_label_id": -1
+        }
+    },
+    "onnx_config": {
+        "type": "onnx",
+        "export_params": true,
+        "keep_initializers_as_inputs": false,
+        "opset_version": 11,
+        "save_file": "end2end.onnx",
+        "input_names": [
+            "input"
+        ],
+        "output_names": [
+            "dets",
+            "labels"
+        ],
+        "input_shape": null,
+        "optimize": true,
+        "dynamic_axes": {
+            "input": {
+                "0": "batch",
+                "2": "height",
+                "3": "width"
+            },
+            "dets": {
+                "0": "batch",
+                "1": "num_dets"
+            },
+            "labels": {
+                "0": "batch",
+                "1": "num_dets"
+            }
+        }
+    },
+    "backend_config": {
+        "type": "onnxruntime",
+        "precision": "fp16",
+        "common_config": {
+            "min_positive_val": 1e-07,
+            "max_finite_val": 10000.0,
+            "keep_io_types": false,
+            "disable_shape_infer": false,
+            "op_block_list": null,
+            "node_block_list": null
+        }
+    },
+    "calib_config": {}
+}

model/end2end.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0efff65be17a13541a3b93d6b0cde60ed37f996c4f2d57aa38071e48117f217
+size 22245735

model/pipeline.json

@@ -0,0 +1,132 @@
+{
+    "pipeline": {
+        "input": [
+            "img"
+        ],
+        "output": [
+            "post_output"
+        ],
+        "tasks": [
+            {
+                "type": "Task",
+                "module": "Transform",
+                "name": "Preprocess",
+                "input": [
+                    "img"
+                ],
+                "output": [
+                    "prep_output"
+                ],
+                "transforms": [
+                    {
+                        "type": "LoadImageFromFile",
+                        "backend_args": null
+                    },
+                    {
+                        "type": "Resize",
+                        "keep_ratio": true,
+                        "size": [
+                            640,
+                            640
+                        ]
+                    },
+                    {
+                        "type": "Pad",
+                        "size": [
+                            640,
+                            640
+                        ],
+                        "pad_val": {
+                            "img": [
+                                114,
+                                114,
+                                114
+                            ]
+                        }
+                    },
+                    {
+                        "type": "Normalize",
+                        "to_rgb": false,
+                        "mean": [
+                            103.53,
+                            116.28,
+                            123.675
+                        ],
+                        "std": [
+                            57.375,
+                            57.12,
+                            58.395
+                        ]
+                    },
+                    {
+                        "type": "Pad",
+                        "size_divisor": 1
+                    },
+                    {
+                        "type": "DefaultFormatBundle"
+                    },
+                    {
+                        "type": "Collect",
+                        "meta_keys": [
+                            "img_path",
+                            "flip",
+                            "ori_filename",
+                            "pad_param",
+                            "pad_shape",
+                            "scale_factor",
+                            "valid_ratio",
+                            "flip_direction",
+                            "img_norm_cfg",
+                            "img_id",
+                            "img_shape",
+                            "ori_shape",
+                            "filename"
+                        ],
+                        "keys": [
+                            "img"
+                        ]
+                    }
+                ]
+            },
+            {
+                "name": "rtmdet",
+                "type": "Task",
+                "module": "Net",
+                "is_batched": true,
+                "input": [
+                    "prep_output"
+                ],
+                "output": [
+                    "infer_output"
+                ],
+                "input_map": {
+                    "img": "input"
+                },
+                "output_map": {}
+            },
+            {
+                "type": "Task",
+                "module": "mmdet",
+                "name": "postprocess",
+                "component": "ResizeBBox",
+                "params": {
+                    "nms_pre": 1000,
+                    "min_bbox_size": 0,
+                    "score_thr": 0.3,
+                    "nms": {
+                        "type": "nms",
+                        "iou_threshold": 0.65
+                    },
+                    "max_per_img": 100
+                },
+                "output": [
+                    "post_output"
+                ],
+                "input": [
+                    "prep_output",
+                    "infer_output"
+                ]
+            }
+        ]
+    }
+}