[update]add main

.gitignore

@@ -0,0 +1,10 @@
+
+.git/
+.idea/
+
+cache/
+flagged/
+gradio_cached_examples/
+hub_datasets/
+
+**/__pycache__/

README.md

@@ -4,8 +4,8 @@ emoji: 🐨
 colorFrom: pink
 colorTo: purple
 sdk: gradio
-sdk_version: 3.45.2
-app_file: app.py
+sdk_version: 3.38.0
+app_file: main.py
 pinned: false
 ---
 

examples/detr_cppe5/step_2_train_model.py

@@ -0,0 +1,271 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+reference:
+https://huggingface.co/docs/transformers/tasks/object_detection
+
+pip install -q datasets transformers evaluate timm albumentations
+
+"""
+from dataclasses import dataclass, field
+import os
+from pathlib import Path
+import re
+from typing import Dict, List
+
+# from project_settings import project_path
+# project_path = os.path.abspath(os.path.dirname(__file__))
+project_path = os.path.abspath("./")
+project_path = Path(project_path)
+
+hf_hub_cache = (project_path / "cache/huggingface/hub").as_posix()
+
+os.environ["HUGGINGFACE_HUB_CACHE"] = hf_hub_cache
+
+import albumentations
+from datasets import load_dataset
+import huggingface_hub
+import numpy as np
+from PIL import Image, ImageDraw
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+from transformers import HfArgumentParser
+from transformers.models.auto.processing_auto import AutoImageProcessor
+from transformers.models.auto.modeling_auto import AutoModelForObjectDetection
+from transformers import TrainingArguments
+from transformers import Trainer
+
+
+@dataclass
+class ScriptArguments:
+    # dataset
+    dataset_path: str = field(default="qgyd2021/cppe-5")
+    dataset_name: str = field(default=None)
+    dataset_cache_dir: str = field(default=(project_path / "hub_datasets").as_posix())
+    # dataset_cache_dir: str = field(default="hub_datasets")
+
+    # model
+    pretrained_model_name_or_path: str = field(default="facebook/detr-resnet-50")
+
+    # training_args
+    output_dir: str = field(default="output_dir")
+    per_device_train_batch_size: int = field(default=8)
+    gradient_accumulation_steps: int = field(default=4)
+    num_train_epochs: float = field(default=20)
+    fp16: bool = field(default=True)
+    save_steps: int = field(default=200)
+    logging_steps: int = field(default=50)
+    learning_rate: float = field(default=1e-5)
+    weight_decay: float = field(default=1e-4)
+    save_total_limit: int = field(default=2)
+    remove_unused_columns: bool = field(default=False)
+    report_to: str = field(default="tensorboard")
+    push_to_hub: bool = field(default=True)
+    hub_model_id: str = field(default="detr_cppe5_object_detection")
+    hub_strategy: str = field(default="every_save")
+
+    # hf_token
+    hf_token: str = field(default="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")
+
+
+def get_args():
+    parser = HfArgumentParser(ScriptArguments)
+    args = parser.parse_args_into_dataclasses(return_remaining_strings=True)[0]
+    return args
+
+
+def show_first_image(example: dict, index_to_label: Dict[int, str]):
+    image: Image = example["image"]
+    annotations = example["objects"]
+
+    draw = ImageDraw.Draw(image)
+
+    for i in range(len(annotations["id"])):
+        box = annotations["bbox"][i - 1]
+        class_idx = annotations["category"][i - 1]
+        x, y, w, h = tuple(box)
+        draw.rectangle((x, y, x + w, y + h), outline="red", width=1)
+        draw.text((x, y), index_to_label[class_idx], fill="white")
+    return image
+
+
+def formatted_annotations(image_id, category, area, bbox):
+    annotations = []
+    for i in range(0, len(category)):
+        new_ann = {
+            "image_id": image_id,
+            "category_id": category[i],
+            "isCrowd": 0,
+            "area": area[i],
+            "bbox": list(bbox[i]),
+        }
+        annotations.append(new_ann)
+
+    return annotations
+
+
+def train_model(local_rank, world_size, args):
+    os.environ["RANK"] = f"{local_rank}"
+    os.environ["LOCAL_RANK"] = f"{local_rank}"
+    os.environ["WORLD_SIZE"] = f"{world_size}"
+    os.environ["MASTER_ADDR"] = "localhost"
+    os.environ["MASTER_PORT"] = "12355"
+
+    huggingface_hub.login(token=args.hf_token)
+
+    # dataset
+    dataset_dict = load_dataset(
+        path=args.dataset_path,
+        cache_dir=args.dataset_cache_dir
+    )
+    train_dataset = dataset_dict["train"]
+
+    remove_idx = [590, 821, 822, 875, 876, 878, 879]
+    keep = [i for i in range(len(train_dataset)) if i not in remove_idx]
+    train_dataset = train_dataset.select(keep)
+
+    categories = ["Coverall", "Face_Shield", "Gloves", "Goggles", "Mask"]
+    index_to_label = {index: x for index, x in enumerate(categories, start=0)}
+    label_to_index = {v: k for k, v in index_to_label.items()}
+
+    # first_example = train_dataset[0]
+    # image: Image = show_first_image(example=first_example, index_to_label=index_to_label)
+    # image.show()
+
+    image_processor = AutoImageProcessor.from_pretrained(args.pretrained_model_name_or_path)
+
+    transform = albumentations.Compose(
+        [
+            albumentations.Resize(480, 480),
+            albumentations.HorizontalFlip(p=1.0),
+            albumentations.RandomBrightnessContrast(p=1.0),
+        ],
+        bbox_params=albumentations.BboxParams(format="coco", label_fields=["category"]),
+    )
+
+    # transforming a batch
+    def transform_aug_annotation(examples):
+        image_ids = examples["image_id"]
+        images, bboxes, area, categories = [], [], [], []
+        for image, objects in zip(examples["image"], examples["objects"]):
+            image = np.array(image.convert("RGB"))[:, :, ::-1]
+            out = transform.__call__(image=image, bboxes=objects["bbox"], category=objects["category"])
+
+            area.append(objects["area"])
+            images.append(out["image"])
+            bboxes.append(out["bboxes"])
+            categories.append(out["category"])
+
+        targets = [
+            {"image_id": id_, "annotations": formatted_annotations(id_, cat_, ar_, box_)}
+            for id_, cat_, ar_, box_ in zip(image_ids, categories, area, bboxes)
+        ]
+
+        return image_processor.__call__(images=images, annotations=targets, return_tensors="pt")
+
+    train_dataset = train_dataset.with_transform(transform_aug_annotation)
+
+    def collate_fn(batch):
+        pixel_values = [item["pixel_values"] for item in batch]
+        encoding = image_processor.pad(pixel_values, return_tensors="pt")
+        labels = [item["labels"] for item in batch]
+        batch = {
+            "pixel_values": encoding["pixel_values"],
+            "pixel_mask": encoding["pixel_mask"],
+            "labels": labels
+        }
+        return batch
+
+    model = AutoModelForObjectDetection.from_pretrained(
+        args.pretrained_model_name_or_path,
+        id2label=index_to_label,
+        label2id=label_to_index,
+        ignore_mismatched_sizes=True,
+    )
+
+    training_args = TrainingArguments(
+        output_dir=args.output_dir,
+        per_device_train_batch_size=args.per_device_train_batch_size,
+        num_train_epochs=args.num_train_epochs,
+        fp16=args.fp16,
+        save_steps=args.save_steps,
+        logging_steps=args.logging_steps,
+        learning_rate=args.learning_rate,
+        weight_decay=args.weight_decay,
+        save_total_limit=args.save_total_limit,
+        remove_unused_columns=args.remove_unused_columns,
+        report_to=args.report_to,
+        push_to_hub=args.push_to_hub,
+        hub_model_id=args.hub_model_id,
+        hub_strategy=args.hub_strategy,
+        local_rank=local_rank,
+        ddp_backend="nccl",
+        # fsdp="auto_wrap",
+    )
+    print(training_args)
+
+    partial_state_str = f"""
+    distributed_type: {training_args.distributed_state.distributed_type}
+    local_process_index: {training_args.distributed_state.local_process_index}
+    num_processes: {training_args.distributed_state.num_processes}
+    process_index: {training_args.distributed_state.process_index}
+    device: {training_args.distributed_state.device}
+    """
+    partial_state_str = re.sub(r"[\u0020]{4,}", "", partial_state_str)
+    print(partial_state_str)
+
+    environ = f"""
+    RANK: {os.environ.get("RANK", -1)}
+    WORLD_SIZE: {os.environ.get("WORLD_SIZE", -1)}
+    LOCAL_RANK: {os.environ.get("LOCAL_RANK", -1)}
+    """
+    environ = re.sub(r"[\u0020]{4,}", "", environ)
+    print(environ)
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        data_collator=collate_fn,
+        train_dataset=train_dataset,
+        tokenizer=image_processor,
+    )
+    trainer.train()
+    trainer.push_to_hub()
+    return
+
+
+def single_gpu_train():
+    args = get_args()
+
+    train_model(0, 1, args)
+
+    return
+
+
+def train_on_kaggle_notebook():
+    """
+    train on kaggle notebook with GPU T4 x2
+
+    from shutil import copyfile
+    copyfile(src = "../input/tempdataset/step_2_train_model.py", dst = "../working/step_2_train_model.py")
+
+    import step_2_train_model
+    step_2_train_model.train_on_kaggle_notebook()
+
+    """
+    args = get_args()
+
+    world_size = torch.cuda.device_count()
+    print("world_size: {}".format(world_size))
+
+    mp.spawn(train_model,
+             args=(world_size, args),
+             nprocs=world_size,
+             join=True)
+
+    return
+
+
+if __name__ == '__main__':
+    single_gpu_train()

examples/detr_cppe5/step_3_test_model.py

@@ -0,0 +1,184 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+reference:
+https://huggingface.co/spaces/nickmuchi/license-plate-detection-with-YOLOS
+https://huggingface.co/docs/transformers/tasks/object_detection
+"""
+import argparse
+import io
+import os
+from typing import Dict
+
+from project_settings import project_path
+
+hf_hub_cache = (project_path / "cache/huggingface/hub").as_posix()
+
+os.environ["HUGGINGFACE_HUB_CACHE"] = hf_hub_cache
+
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+import requests
+import torch
+from transformers.models.auto.processing_auto import AutoImageProcessor
+from transformers.models.auto.feature_extraction_auto import AutoFeatureExtractor
+from transformers.models.auto.modeling_auto import AutoModelForObjectDetection
+import validators
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        default="qgyd2021/detr_cppe5_object_detection",
+        # default=(project_path / "trained_models/detr_cppe5_object_detection").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--image_url_or_path",
+        default="https://i.imgur.com/2lnWoly.jpg",
+        type=str
+    )
+    parser.add_argument(
+        "--threshold",
+        default=0.24,
+        type=float
+    )
+    # 0.5, 0.6, 0.7
+    parser.add_argument("--iou_threshold", default=0.6, type=float)
+    args = parser.parse_args()
+    return args
+
+
+# colors for visualization
+COLORS = [
+    [0.000, 0.447, 0.741],
+    [0.850, 0.325, 0.098],
+    [0.929, 0.694, 0.125],
+    [0.494, 0.184, 0.556],
+    [0.466, 0.674, 0.188],
+    [0.301, 0.745, 0.933]
+]
+
+
+def get_original_image(url_input):
+    if validators.url(url_input):
+        image = Image.open(requests.get(url_input, stream=True).raw)
+        return image
+
+
+def figure2image(fig):
+    buf = io.BytesIO()
+    fig.savefig(buf)
+    buf.seek(0)
+    pil_image = Image.open(buf)
+    base_width = 750
+    width_percent = base_width / float(pil_image.size[0])
+    height_size = (float(pil_image.size[1]) * float(width_percent))
+    height_size = int(height_size)
+    pil_image = pil_image.resize((base_width, height_size), Image.Resampling.LANCZOS)
+    return pil_image
+
+
+def non_max_suppression(boxes, scores, threshold):
+    """Apply non-maximum suppression at test time to avoid detecting too many
+    overlapping bounding boxes for a given object.
+    Args:
+        boxes: array of [xmin, ymin, xmax, ymax]
+        scores: array of scores associated with each box.
+        threshold: IoU threshold
+    Return:
+        keep: indices of the boxes to keep
+    """
+    x1 = boxes[:, 0]
+    y1 = boxes[:, 1]
+    x2 = boxes[:, 2]
+    y2 = boxes[:, 3]
+
+    areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+    order = scores.argsort()[::-1]  # get boxes with more confidence first
+
+    keep = []
+    while order.size > 0:
+        i = order[0]  # pick max confidence box
+        keep.append(i)
+
+        xx1 = np.maximum(x1[i], x1[order[1:]])
+        yy1 = np.maximum(y1[i], y1[order[1:]])
+        xx2 = np.minimum(x2[i], x2[order[1:]])
+        yy2 = np.minimum(y2[i], y2[order[1:]])
+
+        w = np.maximum(0.0, xx2 - xx1 + 1)  # maximum width
+        h = np.maximum(0.0, yy2 - yy1 + 1)  # maximum height
+        inter = w * h
+
+        ovr = inter / (areas[i] + areas[order[1:]] - inter)
+        inds = np.where(ovr <= threshold)[0]
+        order = order[inds + 1]
+
+    return keep
+
+
+def draw_boxes(image, boxes, scores, labels, threshold: float, idx_to_label: Dict[int, str] = None):
+    plt.figure(figsize=(50, 50))
+    plt.imshow(image)
+
+    if idx_to_label is not None:
+        labels = [idx_to_label[x] for x in labels]
+
+    axis = plt.gca()
+    colors = COLORS * len(boxes)
+    for score, (xmin, ymin, xmax, ymax), label, color in zip(scores, boxes, labels, colors):
+        if score < threshold:
+            continue
+        axis.add_patch(plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, fill=False, color=color, linewidth=10))
+        axis.text(xmin, ymin, f"{label}: {score:0.2f}", fontsize=60, bbox=dict(facecolor="yellow", alpha=0.8))
+    plt.axis("off")
+
+    return figure2image(plt.gcf())
+
+
+def main():
+    args = get_args()
+
+    feature_extractor = AutoFeatureExtractor.from_pretrained(args.pretrained_model_name_or_path)
+    model = AutoModelForObjectDetection.from_pretrained(args.pretrained_model_name_or_path)
+    image_processor = AutoImageProcessor.from_pretrained(args.pretrained_model_name_or_path)
+
+    # image
+    image = get_original_image(args.image_url_or_path)
+    image_size = torch.tensor([tuple(reversed(image.size))])
+
+    # infer
+    # inputs = feature_extractor(images=image, return_tensors="pt")
+    inputs = image_processor(images=image, return_tensors="pt")
+    outputs = model.forward(**inputs)
+
+    processed_outputs = image_processor.post_process_object_detection(
+        outputs, threshold=args.threshold, target_sizes=image_size)
+    # processed_outputs = feature_extractor.post_process(outputs, target_sizes=image_size)
+    processed_outputs = processed_outputs[0]
+
+    # draw box
+    boxes = processed_outputs["boxes"].detach().numpy()
+    scores = processed_outputs["scores"].detach().numpy()
+    labels = processed_outputs["labels"].detach().numpy()
+
+    keep = non_max_suppression(boxes, scores, threshold=args.iou_threshold)
+    boxes = boxes[keep]
+    scores = scores[keep]
+    labels = labels[keep]
+
+    viz_image: Image = draw_boxes(
+        image, boxes, scores, labels,
+        threshold=args.threshold,
+        idx_to_label=model.config.id2label
+    )
+    viz_image.show()
+
+    return
+
+
+if __name__ == '__main__':
+    main()

main.py

@@ -0,0 +1,268 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import io
+import json
+import os
+import re
+from typing import Dict, List
+
+from project_settings import project_path
+
+os.environ["HUGGINGFACE_HUB_CACHE"] = (project_path / "cache/huggingface/hub").as_posix()
+
+import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+import requests
+import torch
+from transformers.models.auto.processing_auto import AutoImageProcessor
+from transformers.models.auto.feature_extraction_auto import AutoFeatureExtractor
+from transformers.models.auto.modeling_auto import AutoModelForObjectDetection
+import validators
+
+from project_settings import project_path
+
+
+# colors for visualization
+COLORS = [
+    [0.000, 0.447, 0.741],
+    [0.850, 0.325, 0.098],
+    [0.929, 0.694, 0.125],
+    [0.494, 0.184, 0.556],
+    [0.466, 0.674, 0.188],
+    [0.301, 0.745, 0.933]
+]
+
+
+def get_original_image(url_input):
+    if validators.url(url_input):
+        image = Image.open(requests.get(url_input, stream=True).raw)
+        return image
+
+
+def figure2image(fig):
+    buf = io.BytesIO()
+    fig.savefig(buf)
+    buf.seek(0)
+    pil_image = Image.open(buf)
+    base_width = 750
+    width_percent = base_width / float(pil_image.size[0])
+    height_size = (float(pil_image.size[1]) * float(width_percent))
+    height_size = int(height_size)
+    pil_image = pil_image.resize((base_width, height_size), Image.Resampling.LANCZOS)
+    return pil_image
+
+
+def non_max_suppression(boxes, scores, threshold):
+    """Apply non-maximum suppression at test time to avoid detecting too many
+    overlapping bounding boxes for a given object.
+    Args:
+        boxes: array of [xmin, ymin, xmax, ymax]
+        scores: array of scores associated with each box.
+        threshold: IoU threshold
+    Return:
+        keep: indices of the boxes to keep
+    """
+    x1 = boxes[:, 0]
+    y1 = boxes[:, 1]
+    x2 = boxes[:, 2]
+    y2 = boxes[:, 3]
+
+    areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+    order = scores.argsort()[::-1]  # get boxes with more confidence first
+
+    keep = []
+    while order.size > 0:
+        i = order[0]  # pick max confidence box
+        keep.append(i)
+
+        xx1 = np.maximum(x1[i], x1[order[1:]])
+        yy1 = np.maximum(y1[i], y1[order[1:]])
+        xx2 = np.minimum(x2[i], x2[order[1:]])
+        yy2 = np.minimum(y2[i], y2[order[1:]])
+
+        w = np.maximum(0.0, xx2 - xx1 + 1)  # maximum width
+        h = np.maximum(0.0, yy2 - yy1 + 1)  # maximum height
+        inter = w * h
+
+        ovr = inter / (areas[i] + areas[order[1:]] - inter)
+        inds = np.where(ovr <= threshold)[0]
+        order = order[inds + 1]
+
+    return keep
+
+
+def draw_boxes(image, boxes, scores, labels, threshold: float,
+               idx_to_label: Dict[int, str] = None, labels_to_show: str = None):
+    if isinstance(labels_to_show, str):
+        if len(labels_to_show.strip()) == 0:
+            labels_to_show = None
+        else:
+            labels_to_show = labels_to_show.split(",")
+            labels_to_show = [label.strip().lower() for label in labels_to_show]
+            labels_to_show = None if len(labels_to_show) == 0 else labels_to_show
+
+    plt.figure(figsize=(50, 50))
+    plt.imshow(image)
+
+    if idx_to_label is not None:
+        labels = [idx_to_label[x] for x in labels]
+
+    axis = plt.gca()
+    colors = COLORS * len(boxes)
+    for score, (xmin, ymin, xmax, ymax), label, color in zip(scores, boxes, labels, colors):
+        if labels_to_show is not None and label.lower() not in labels_to_show:
+            continue
+        if score < threshold:
+            continue
+        axis.add_patch(plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, fill=False, color=color, linewidth=10))
+        axis.text(xmin, ymin, f"{label}: {score:0.2f}", fontsize=60, bbox=dict(facecolor="yellow", alpha=0.8))
+    plt.axis("off")
+
+    return figure2image(plt.gcf())
+
+
+def detr_object_detection(url_input: str,
+                          image_input: Image,
+                          pretrained_model_name_or_path: str = "qgyd2021/detr_cppe5_object_detection",
+                          threshold: float = 0.5,
+                          iou_threshold: float = 0.5,
+                          labels_to_show: str = None,
+                          ):
+    # feature_extractor = AutoFeatureExtractor.from_pretrained(pretrained_model_name_or_path)
+    model = AutoModelForObjectDetection.from_pretrained(pretrained_model_name_or_path)
+    image_processor = AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)
+
+    # image
+    if validators.url(url_input):
+        image = get_original_image(url_input)
+    elif image_input:
+        image = image_input
+    else:
+        raise AssertionError("at least one `url_input` and `image_input`")
+    image_size = torch.tensor([tuple(reversed(image.size))])
+
+    # infer
+    # inputs = feature_extractor(images=image, return_tensors="pt")
+    inputs = image_processor(images=image, return_tensors="pt")
+    outputs = model.forward(**inputs)
+
+    processed_outputs = image_processor.post_process_object_detection(
+        outputs, threshold=threshold, target_sizes=image_size)
+    # processed_outputs = feature_extractor.post_process(outputs, target_sizes=image_size)
+    processed_outputs = processed_outputs[0]
+
+    # draw box
+    boxes = processed_outputs["boxes"].detach().numpy()
+    scores = processed_outputs["scores"].detach().numpy()
+    labels = processed_outputs["labels"].detach().numpy()
+
+    keep = non_max_suppression(boxes, scores, threshold=iou_threshold)
+    boxes = boxes[keep]
+    scores = scores[keep]
+    labels = labels[keep]
+
+    viz_image: Image = draw_boxes(
+        image, boxes, scores, labels,
+        threshold=threshold,
+        idx_to_label=model.config.id2label,
+        labels_to_show=labels_to_show
+    )
+    return viz_image
+
+
+def main():
+
+    title = "## Detr Cppe5 Object Detection"
+
+    description = """
+    reference:
+    https://huggingface.co/docs/transformers/tasks/object_detection
+    
+    """
+
+    example_urls = [
+        *[
+            [
+                "https://huggingface.co/datasets/qgyd2021/cppe-5/resolve/main/data/images/{}.png".format(idx),
+                "qgyd2021/detr_cppe5_object_detection",
+                0.25, 0.6, None
+            ] for idx in range(1001, 1030)
+        ]
+    ]
+
+    example_images = [
+        [
+            "data/2lnWoly.jpg",
+            "qgyd2021/detr_cppe5_object_detection",
+            0.25, 0.6, None
+        ]
+    ]
+
+    with gr.Blocks() as blocks:
+        gr.Markdown(value=title)
+        gr.Markdown(value=description)
+
+        model_name = gr.components.Dropdown(
+            choices=[
+                "qgyd2021/detr_cppe5_object_detection",
+            ],
+            value="qgyd2021/detr_cppe5_object_detection",
+            label="model_name",
+        )
+        threshold_slider = gr.components.Slider(
+            minimum=0, maximum=1.0,
+            step=0.01, value=0.5,
+            label="Threshold"
+        )
+        iou_threshold_slider = gr.components.Slider(
+            minimum=0, maximum=1.0,
+            step=0.1, value=0.5,
+            label="IOU Threshold"
+        )
+        classes_to_detect = gr.Textbox(placeholder="e.g. person, truck (split by , comma).",
+                                       label="labels to show")
+
+        with gr.Tabs():
+            with gr.TabItem("Image URL"):
+                with gr.Row():
+                    with gr.Column():
+                        url_input = gr.Textbox(lines=1, label="Enter valid image URL here..")
+                        original_image = gr.Image()
+                        url_input.change(get_original_image, url_input, original_image)
+                    with gr.Column():
+                        img_output_from_url = gr.Image()
+
+                with gr.Row():
+                    gr.Examples(examples=example_urls,
+                                inputs=[url_input, model_name, threshold_slider, iou_threshold_slider],
+                                examples_per_page=5,
+                                )
+
+                url_but = gr.Button("Detect")
+
+            with gr.TabItem("Image Upload"):
+                with gr.Row():
+                    img_input = gr.Image(type="pil")
+                    img_output_from_upload = gr.Image()
+
+                with gr.Row():
+                    gr.Examples(examples=example_images,
+                                inputs=[img_input, model_name, threshold_slider, iou_threshold_slider],
+                                examples_per_page=5,
+                                )
+
+                img_but = gr.Button("Detect")
+
+            inputs = [url_input, img_input, model_name, threshold_slider, iou_threshold_slider, classes_to_detect]
+            url_but.click(detr_object_detection, inputs=inputs, outputs=[img_output_from_url], queue=True)
+            img_but.click(detr_object_detection, inputs=inputs, outputs=[img_output_from_upload], queue=True)
+
+    blocks.queue().launch()
+    return
+
+
+if __name__ == '__main__':
+    main()

project_settings.py

@@ -0,0 +1,12 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+from pathlib import Path
+
+
+project_path = os.path.abspath(os.path.dirname(__file__))
+project_path = Path(project_path)
+
+
+if __name__ == '__main__':
+    pass

requirements.txt

@@ -0,0 +1,6 @@
+gradio==3.38.0
+transformers==4.30.2
+torch==1.13.1
+validators==0.22.0
+albumentations==1.3.1
+timm==0.9.7