Add application file

app.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+
+from __future__ import annotations
+
+import os
+import pathlib
+import subprocess
+import tarfile
+
+import cv2
+import gradio as gr
+import numpy as np
+
+from model import AppModel
+
+DESCRIPTION = '''# MMDetection
+This is an unofficial demo for [https://github.com/open-mmlab/mmdetection](https://github.com/open-mmlab/mmdetection).
+<img id="overview" alt="overview" src="https://user-images.githubusercontent.com/12907710/137271636-56ba1cd2-b110-4812-8221-b4c120320aa9.png" />
+'''
+
+DEFAULT_MODEL_TYPE = 'detection'
+DEFAULT_MODEL_NAMES = {
+    'detection': 'YOLOX-l',
+    'instance_segmentation': 'QueryInst (R-50-FPN)',
+    'panoptic_segmentation': 'MaskFormer (R-50)',
+}
+DEFAULT_MODEL_NAME = DEFAULT_MODEL_NAMES[DEFAULT_MODEL_TYPE]
+
+
+
+def update_input_image(image: np.ndarray) -> dict:
+    if image is None:
+        return gr.Image.update(value=None)
+    scale = 1500 / max(image.shape[:2])
+    if scale < 1:
+        image = cv2.resize(image, None, fx=scale, fy=scale)
+    return gr.Image.update(value=image)
+
+
+def update_model_name(model_type: str) -> dict:
+    model_dict = getattr(AppModel, f'{model_type.upper()}_MODEL_DICT')
+    model_names = list(model_dict.keys())
+    model_name = DEFAULT_MODEL_NAMES[model_type]
+    return gr.Dropdown.update(choices=model_names, value=model_name)
+
+
+def update_visualization_score_threshold(model_type: str) -> dict:
+    return gr.Slider.update(visible=model_type != 'panoptic_segmentation')
+
+
+def update_redraw_button(model_type: str) -> dict:
+    return gr.Button.update(visible=model_type != 'panoptic_segmentation')
+
+
+def set_example_image(example: list) -> dict:
+    return gr.Image.update(value=example[0])
+
+
+model = AppModel(DEFAULT_MODEL_NAME)
+
+with gr.Blocks(css='style.css') as demo:
+    gr.Markdown(DESCRIPTION)
+
+    with gr.Row():
+        with gr.Column():
+            with gr.Row():
+                input_image = gr.Image(label='Input Image', type='numpy')
+            with gr.Group():
+                with gr.Row():
+                    model_type = gr.Radio(list(DEFAULT_MODEL_NAMES.keys()),
+                                          value=DEFAULT_MODEL_TYPE,
+                                          label='Model Type')
+                with gr.Row():
+                    model_name = gr.Dropdown(list(
+                        model.DETECTION_MODEL_DICT.keys()),
+                                             value=DEFAULT_MODEL_NAME,
+                                             label='Model')
+            with gr.Row():
+                run_button = gr.Button(value='Run')
+                prediction_results = gr.Variable()
+        with gr.Column():
+            with gr.Row():
+                visualization = gr.Image(label='Result', type='numpy')
+            with gr.Row():
+                visualization_score_threshold = gr.Slider(
+                    0,
+                    1,
+                    step=0.05,
+                    value=0.3,
+                    label='Visualization Score Threshold')
+            with gr.Row():
+                redraw_button = gr.Button(value='Redraw')
+
+    with gr.Row():
+        paths = sorted(pathlib.Path('images').rglob('*.jpg'))
+        example_images = gr.Dataset(components=[input_image],
+                                    samples=[[path.as_posix()]
+                                             for path in paths])
+
+    input_image.change(fn=update_input_image,
+                       inputs=input_image,
+                       outputs=input_image)
+
+    model_type.change(fn=update_model_name,
+                      inputs=model_type,
+                      outputs=model_name)
+    model_type.change(fn=update_visualization_score_threshold,
+                      inputs=model_type,
+                      outputs=visualization_score_threshold)
+    model_type.change(fn=update_redraw_button,
+                      inputs=model_type,
+                      outputs=redraw_button)
+
+    model_name.change(fn=model.set_model, inputs=model_name, outputs=None)
+    run_button.click(fn=model.run,
+                     inputs=[
+                         model_name,
+                         input_image,
+                         visualization_score_threshold,
+                     ],
+                     outputs=[
+                         prediction_results,
+                         visualization,
+                     ])
+    redraw_button.click(fn=model.visualize_detection_results,
+                        inputs=[
+                            input_image,
+                            prediction_results,
+                            visualization_score_threshold,
+                        ],
+                        outputs=visualization)
+    example_images.click(fn=set_example_image,
+                         inputs=example_images,
+                         outputs=input_image)
+
+demo.queue().launch(show_api=False)

configs/_base_/faster-rcnn_r50_fpn_1x_coco.py

@@ -0,0 +1,114 @@
+# model settings
+model = dict(
+    type='FasterRCNN',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_size_divisor=32),
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type='FPN',
+        in_channels=[256, 512, 1024, 2048],
+        out_channels=256,
+        num_outs=5),
+    rpn_head=dict(
+        type='RPNHead',
+        in_channels=256,
+        feat_channels=256,
+        anchor_generator=dict(
+            type='AnchorGenerator',
+            scales=[8],
+            ratios=[0.5, 1.0, 2.0],
+            strides=[4, 8, 16, 32, 64]),
+        bbox_coder=dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[.0, .0, .0, .0],
+            target_stds=[1.0, 1.0, 1.0, 1.0]),
+        loss_cls=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+        loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
+    roi_head=dict(
+        type='StandardRoIHead',
+        bbox_roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        bbox_head=dict(
+            type='Shared2FCBBoxHead',
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=80,
+            bbox_coder=dict(
+                type='DeltaXYWHBBoxCoder',
+                target_means=[0., 0., 0., 0.],
+                target_stds=[0.1, 0.1, 0.2, 0.2]),
+            reg_class_agnostic=False,
+            loss_cls=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+            loss_bbox=dict(type='L1Loss', loss_weight=1.0))),
+    # model training and testing settings
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='RandomSampler',
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False),
+            allowed_border=-1,
+            pos_weight=-1,
+            debug=False),
+        rpn_proposal=dict(
+            nms_pre=2000,
+            max_per_img=1000,
+            nms=dict(type='nms', iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.5,
+                neg_iou_thr=0.5,
+                min_pos_iou=0.5,
+                match_low_quality=False,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='RandomSampler',
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True),
+            pos_weight=-1,
+            debug=False)),
+    test_cfg=dict(
+        rpn=dict(
+            nms_pre=1000,
+            max_per_img=1000,
+            nms=dict(type='nms', iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            score_thr=0.05,
+            nms=dict(type='nms', iou_threshold=0.5),
+            max_per_img=100)
+        # soft-nms is also supported for rcnn testing
+        # e.g., nms=dict(type='soft_nms', iou_threshold=0.5, min_score=0.05)
+    ))

configs/faster-rcnn_r50_fpn_organoid_orgaquant.py

@@ -0,0 +1,83 @@
+
+# Inherit and overwrite part of the config based on this config
+_base_ = './faster-rcnn_r50_fpn_1x_coco.py'
+
+data_root = 'data/' # dataset root
+
+train_batch_size_per_gpu = 16
+train_num_workers = 1
+
+max_epochs = 105
+base_lr = 0.00001
+
+
+metainfo = {
+    'classes': ('orgaquant', ),
+    'palette': [
+        (220, 20, 60),
+    ]
+}
+
+train_dataloader = dict(
+    batch_size=train_batch_size_per_gpu,
+    num_workers=train_num_workers,
+    dataset=dict(
+        data_root=data_root,
+        metainfo=metainfo,
+        data_prefix=dict(img='train/'),
+        ann_file='train.json'))
+
+val_dataloader = dict(
+    dataset=dict(
+        data_root=data_root,
+        metainfo=metainfo,
+        data_prefix=dict(img='val/'),
+        ann_file='val.json'))
+
+test_dataloader = val_dataloader
+
+val_evaluator = dict(ann_file=data_root + 'val.json')
+
+test_evaluator = val_evaluator
+
+model = dict(
+    roi_head=dict(
+        bbox_head=dict(num_classes=1)))
+
+
+
+train_pipeline = [
+dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type = 'RandomShift', prob = 0.5),
+    dict(type = 'RandomAffine'),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackDetInputs')
+    ]
+    
+    
+# optimizer
+optim_wrapper = dict(
+    _delete_=True,
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=base_lr, weight_decay=0.05),
+    paramwise_cfg=dict(
+        norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True))
+
+default_hooks = dict(
+    checkpoint=dict(
+        interval=5,
+        max_keep_ckpts=2,  # only keep latest 2 checkpoints
+        save_best='auto'
+    ),
+    logger=dict(type='LoggerHook', interval=5))
+
+
+# load COCO pre-trained weight
+
+# load_from = './work_dirs/faster-rcnn_r50_fpn_organoid/best_coco_bbox_mAP_epoch_12.pth'
+
+
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=1)
+visualizer = dict(vis_backends=[dict(type='LocalVisBackend'),dict(type='TensorboardVisBackend')])

model.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import os
+
+import huggingface_hub
+import numpy as np
+import torch
+import torch.nn as nn
+import yaml  # type: ignore
+from mmdet.apis import inference_detector, init_detector
+
+
+
+
+
+class Model:
+
+    def __init__(self, model_name: str):
+        self.device = torch.device(
+            'cuda:0' if torch.cuda.is_available() else 'cpu')
+        self.model_name = model_name
+        self.model = self._load_model(model_name)
+
+
+    def _load_model(self, name: str) -> nn.Module:
+        dic = self.MODEL_DICT[name]
+        return init_detector('configs/_base_/faster-rcnn_r50_fpn_1x_coco.py','models/orgaquanT-pretarined.pth' , device=self.device)
+
+    def set_model(self, name: str) -> None:
+        if name == self.model_name:
+            return
+        self.model_name = name
+        self.model = self._load_model(name)
+
+    def detect_and_visualize(
+        self, image: np.ndarray, score_threshold: float
+    ) -> tuple[list[np.ndarray] | tuple[list[np.ndarray],
+                                        list[list[np.ndarray]]]
+               | dict[str, np.ndarray], np.ndarray]:
+        out = self.detect(image)
+        vis = self.visualize_detection_results(image, out, score_threshold)
+        return out, vis
+
+    def detect(
+        self, image: np.ndarray
+    ) -> list[np.ndarray] | tuple[
+            list[np.ndarray], list[list[np.ndarray]]] | dict[str, np.ndarray]:
+        out = inference_detector(self.model, image)
+        return out
+
+    def visualize_detection_results(
+            self,
+            image: np.ndarray,
+            detection_results: list[np.ndarray]
+        | tuple[list[np.ndarray], list[list[np.ndarray]]]
+        | dict[str, np.ndarray],
+            score_threshold: float = 0.3) -> np.ndarray:
+        vis = self.model.show_result(image,
+                                     detection_results,
+                                     score_thr=score_threshold,
+                                     bbox_color=None,
+                                     text_color=(200, 200, 200),
+                                     mask_color=None)
+        return vis
+
+
+class AppModel(Model):
+    def run(
+        self, model_name: str, image: np.ndarray, score_threshold: float
+    ) -> tuple[list[np.ndarray] | tuple[list[np.ndarray],
+                                        list[list[np.ndarray]]]
+               | dict[str, np.ndarray], np.ndarray]:
+        self.set_model(model_name)
+        return self.detect_and_visualize(image, score_threshold)

models/orgaquant_pretrained.pth

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

requirements.txt

@@ -0,0 +1,7 @@
+mmcv-full==1.5.2
+mmdet==2.25.0
+numpy==1.22.4
+opencv-python-headless==4.5.5.64
+openmim==0.1.5
+torch==1.11.0
+torchvision==0.12.0