Init project

Dockerfile

@@ -0,0 +1,31 @@
+FROM python:3.9
+
+WORKDIR /code
+
+RUN apt-get update && apt-get install ffmpeg libsm6 libxext6  -y
+
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+RUN pip install -U openmim
+RUN mim install mmengine
+RUN mim install mmcv
+RUN mim install mmdet
+RUN mim install mmocr
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+# Switch to the "user" user
+USER user
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+
+# Copy the current directory contents into the container at $HOME/app setting the owner to the user
+COPY --chown=user . $HOME/app
+RUN ls
+
+CMD ["python", "main.py"]

main.py

@@ -0,0 +1,65 @@
+from mmdet.apis import init_detector, inference_detector
+import gradio as gr
+import cv2
+import sys
+import torch
+import numpy as np
+
+print('Loading model...')
+device = 'gpu' if torch.cuda.is_available() else 'cpu'
+
+table_det = init_detector('model/table-det/config.py',
+                          'model/table-det/model.pth', device=device)
+def get_corners(points):
+    """
+    Returns the top-left, top-right, bottom-right, and bottom-left corners
+    of a rectangle defined by a list of four points in the form of tuples.
+    """
+    # Sort points by x-coordinate
+    sorted_points = sorted(points, key=lambda p: p[0])
+    
+    # Split sorted points into left and right halves
+    left_points = sorted_points[:2]
+    right_points = sorted_points[2:]
+    
+    # Sort left and right points by y-coordinate
+    left_points = sorted(left_points, key=lambda p: p[1])
+    right_points = sorted(right_points, key=lambda p: p[1], reverse=True)
+    
+    # Return corners in order: top-left, top-right, bottom-right, bottom-left
+    return (left_points[0], right_points[0], right_points[1], left_points[1])
+
+def funct(mask_array):
+  table_images = []
+  table_bboxes = []
+  contours, hierarchy = cv2.findContours(mask_array, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+  for cnt in contours:
+    rect = cv2.minAreaRect(cnt)
+    box = cv2.boxPoints(rect)
+    epsilon = cv2.arcLength(cnt,True)
+    approx = cv2.approxPolyDP(cnt, 0.02*epsilon, True)
+    points = np.squeeze(approx)
+    if len(points) != 4:
+      points = box
+    tl, br, bl, tr = get_corners(points.tolist())
+    table_bboxes.append([tl, tr, br, bl])
+  return table_bboxes
+        
+    
+def predict(image_input):
+    results = inference_detector(table_det, image_input)
+    print(results)
+    return {'message': 'success'}
+
+def run():
+    demo = gr.Interface(
+        fn=predict,
+        inputs=gr.components.Image(),
+        outputs=gr.JSON(),
+    )
+
+    demo.launch(server_name="0.0.0.0", server_port=7860)
+
+
+if __name__ == "__main__":
+    run()

model/table-det/config.py

@@ -0,0 +1,318 @@
+model = dict(
+    type='MaskRCNN',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        pad_mask=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, 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=1,
+            bbox_coder=dict(
+                type='DeltaXYWHBBoxCoder',
+                target_means=[0.0, 0.0, 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)),
+        mask_roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32]),
+        mask_head=dict(
+            type='FCNMaskHead',
+            num_convs=4,
+            in_channels=256,
+            conv_out_channels=256,
+            num_classes=1,
+            loss_mask=dict(
+                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
+    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=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='RandomSampler',
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True),
+            mask_size=28,
+            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,
+            mask_thr_binary=0.5)))
+backend_args = None
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+    dict(type='Rotate', level=10),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+data_root = 'data/table-det-elect66/'
+metainfo = dict(classes=('Table', ), palette=[(220, 20, 60)])
+dataset_elect66 = dict(
+    type='CocoDataset',
+    data_root='data/table-det-elect66/',
+    ann_file='result.json',
+    data_prefix=dict(img=''),
+    metainfo=dict(classes=('Table', ), palette=[(220, 20, 60)]),
+    filter_cfg=dict(filter_empty_gt=True, min_size=32),
+    pipeline=[
+        dict(type='LoadImageFromFile', backend_args=None),
+        dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+        dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+        dict(type='Rotate', level=10),
+        dict(type='RandomFlip', prob=0.5),
+        dict(type='PackDetInputs')
+    ])
+dataset_vote62 = dict(
+    type='CocoDataset',
+    data_root='data/table-det-740/',
+    ann_file='train_coco.json',
+    data_prefix=dict(img=''),
+    metainfo=dict(classes=('Table', ), palette=[(220, 20, 60)]),
+    filter_cfg=dict(filter_empty_gt=True, min_size=32),
+    pipeline=[
+        dict(type='LoadImageFromFile', backend_args=None),
+        dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+        dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+        dict(type='Rotate', level=10),
+        dict(type='RandomFlip', prob=0.5),
+        dict(type='PackDetInputs')
+    ])
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    batch_sampler=dict(type='AspectRatioBatchSampler'),
+    dataset=dict(
+        type='ConcatDataset',
+        datasets=[
+            dict(
+                type='CocoDataset',
+                data_root='data/table-det-elect66/',
+                ann_file='result.json',
+                data_prefix=dict(img=''),
+                metainfo=dict(classes=('Table', ), palette=[(220, 20, 60)]),
+                filter_cfg=dict(filter_empty_gt=True, min_size=32),
+                pipeline=[
+                    dict(type='LoadImageFromFile', backend_args=None),
+                    dict(
+                        type='LoadAnnotations', with_bbox=True,
+                        with_mask=True),
+                    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+                    dict(type='Rotate', level=10),
+                    dict(type='RandomFlip', prob=0.5),
+                    dict(type='PackDetInputs')
+                ]),
+            dict(
+                type='CocoDataset',
+                data_root='data/table-det-740/',
+                ann_file='train_coco.json',
+                data_prefix=dict(img=''),
+                metainfo=dict(classes=('Table', ), palette=[(220, 20, 60)]),
+                filter_cfg=dict(filter_empty_gt=True, min_size=32),
+                pipeline=[
+                    dict(type='LoadImageFromFile', backend_args=None),
+                    dict(
+                        type='LoadAnnotations', with_bbox=True,
+                        with_mask=True),
+                    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+                    dict(type='Rotate', level=10),
+                    dict(type='RandomFlip', prob=0.5),
+                    dict(type='PackDetInputs')
+                ])
+        ]))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        data_root='data/table-det-elect66/',
+        ann_file='result.json',
+        data_prefix=dict(img=''),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+            dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                           'scale_factor'))
+        ],
+        backend_args=None,
+        metainfo=dict(classes=('Table', ), palette=[(220, 20, 60)])))
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        data_root='data/table-det-elect66/',
+        ann_file='result.json',
+        data_prefix=dict(img=''),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+            dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                           'scale_factor'))
+        ],
+        backend_args=None,
+        metainfo=dict(classes=('Table', ), palette=[(220, 20, 60)])))
+val_evaluator = dict(
+    type='CocoMetric',
+    ann_file='data/table-det-elect66/result.json',
+    metric=['bbox', 'segm'],
+    format_only=False,
+    backend_args=None)
+test_evaluator = dict(
+    type='CocoMetric',
+    ann_file='data/table-det-elect66/result.json',
+    metric=['bbox', 'segm'],
+    format_only=False,
+    backend_args=None)
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=10, val_interval=5)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=12,
+        by_epoch=True,
+        milestones=[8, 11],
+        gamma=0.1)
+]
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.005, momentum=0.9, weight_decay=0.0001))
+auto_scale_lr = dict(enable=False, base_batch_size=16)
+default_scope = 'mmdet'
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=100),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', interval=5),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='DetVisualizationHook'))
+env_cfg = dict(
+    cudnn_benchmark=False,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'))
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+    type='DetLocalVisualizer',
+    vis_backends=[dict(type='LocalVisBackend')],
+    name='visualizer')
+log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True)
+log_level = 'INFO'
+load_from = None
+resume = True
+launcher = 'none'
+work_dir = './work_dirs/vote-config'

model/table-det/model.pth

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

requirements.txt

@@ -0,0 +1,4 @@
+opencv-python
+gradio
+torch
+torchvision