Upload 8 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* 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
+master_tmp.png filter=lfs diff=lfs merge=lfs -text
+to_score_planogram_tmp.png filter=lfs diff=lfs merge=lfs -text

app (1).py

@@ -0,0 +1,296 @@
+# https://planogram-compliance.herokuapp.com/
+# https://dashboard.heroku.com/apps/planogram-compliance/deploy/heroku-git
+
+# https://medium.com/@mohcufe/how-to-deploy-your-trained-pytorch-model-on-heroku-ff4b73085ddd\
+# https://stackoverflow.com/questions/51730880/where-do-i-get-a-cpu-only-version-of-pytorch
+# https://blog.jcharistech.com/2020/02/26/how-to-deploy-a-face-detection-streamlit-app-on-heroku/
+# https://towardsdatascience.com/a-quick-tutorial-on-how-to-deploy-your-streamlit-app-to-heroku-
+# https://www.analyticsvidhya.com/blog/2021/06/deploy-your-ml-dl-streamlit-application-on-heroku/
+# https://gist.github.com/jeremyjordan/6b506257509e8ba673f145baa568a1ea
+
+import json
+
+# https://www.r-bloggers.com/2020/12/creating-a-streamlit-web-app-building-with-docker-github-actions-and-hosting-on-heroku/
+# https://devcenter.heroku.com/articles/container-registry-and-runtime
+# from yolo_inference_util import run_yolo_v5
+import os
+from tempfile import NamedTemporaryFile
+
+import cv2
+import numpy as np
+import pandas as pd
+import streamlit as st
+
+# import matplotlib.pyplot as plt
+from app_utils import annotate_planogram_compliance, bucket_sort, do_sorting, xml_to_csv
+from inference import run
+
+# from utils.plots import Annotator, colors
+# from utils.general import scale_coords
+
+app_formal_name = "Planogram Compliance"
+
+FILE_UPLOAD_DIR = "tmp"
+
+os.makedirs(FILE_UPLOAD_DIR, exist_ok=True)
+# Start the app in wide-mode
+st.set_page_config(
+    layout="wide",
+    page_title=app_formal_name,
+)
+# https://github.com/streamlit/streamlit/issues/1361
+uploaded_file = st.file_uploader(
+    "Choose a planogram image to score",
+    type=["jpg", "JPEG", "PNG", "JPG", "jpeg"],
+)
+uploaded_master_planogram_file = st.file_uploader(
+    "Upload a master planogram", type=["jpg", "JPEG", "PNG", "JPG", "jpeg"]
+)
+annotation_file = st.file_uploader("upload master polanogram", type=["xml"])
+temp_file = NamedTemporaryFile(delete=False)
+
+target_names = [
+    "Bottle,100PLUS ACTIVE 1.5L",
+    "Bottle,100PLUS ACTIVE 500ML",
+    "Bottle,100PLUS LEMON LIME 1.5L",
+    "Bottle,100PLUS ORANGE 500ML",
+    "Bottle,100PLUS ORIGINAL 1.5L",
+    "Bottle,100PLUS TANGY ORANGE 1.5L",
+    "Bottle,100PLUS ZERO 1.5L",
+    "Bottle,100PLUS ZERO 500ML",
+    "Packet,F:M MAGNOLIA CHOC 1L",
+    "Bottle,F&N GINGER ADE 1.5L",
+    "Bottle,F&N GRAPE 1.5L",
+    "Bottle,F&N ICE CREAM SODA 1.5L",
+    "Bottle,F&N LYCHEE PEAR 1.5L",
+    "Bottle,F&N ORANGE 1.5L",
+    "Bottle,F&N PINEAPPLE PET 1.5L",
+    "Bottle,F&N SARSI 1.5L",
+    "Bottle,F&N SS ICE LEM TEA RS 500ML",
+    "Bottle,F&N SS ICE LEMON TEA RS 1.5L",
+    "Bottle,F&N SS ICE LEMON TEA 1.5L",
+    "Bottle,F&N SS ICE LEMON TEA 500ML",
+    "Bottle,F&N SS ICE PEACH TEA 1.5L",
+    "Bottle,SS ICE LEMON GT 1.48L",
+    "Bottle,SS WHITE CHRYS TEA 1.48L",
+    "Packet,FARMHOUSE FRESH MILK 1L FNDM",
+    "Packet,FARMHOUSE PLAIN LF 1L",
+    "Packet,PURA FRESH MILK 1L FS",
+    "Packet,NUTRISOY REG NO SUGAR ADDED 1L",
+    "Packet,NUTRISOY PLAIN 475ML",
+    "Packet,NUTRISOY PLAIN 1L",
+    "Packet,NUTRISOY OMEGA RD SUGAR 1L",
+    "Packet,NUTRISOY OMEGA NSA 1L",
+    "Packet,NUTRISOY ALMOND 1L",
+    "Packet,MAGNOLIA FRESH MILK 1L FNDM",
+    "Packet,FM MAG FC PLAIN 200ML",
+    "Packet,MAG OMEGA PLUS PLAIN 200ML",
+    "Packet,MAG KURMA MILK 500ML",
+    "Packet,MAG KURMA MILK 1L",
+    "Packet,MAG CHOCOLATE FC 500ML",
+    "Packet,MAG BROWN SUGAR SS MILK 1L",
+    "Packet,FM MAG LFHC PLN 500ML",
+    "Packet,FM MAG LFHC OAT 500ML",
+    "Packet,FM MAG LFHC OAT 1L",
+    "Packet,FM MAG FC PLAIN 500ML",
+    "Void,PARTIAL VOID",
+    "Void,FULL VOID",
+    "Bottle,F&N SS ICE LEM TEA 500ML",
+]
+
+run_app = st.button("Run the compliance check")
+if run_app and uploaded_file is not None:
+    # Convert the file to an opencv image.
+    file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+    temp_file.write(uploaded_file.getvalue())
+    uploaded_img = cv2.imdecode(file_bytes, 1)
+    cv2.imwrite("tmp/to_score_planogram_tmp.png", uploaded_img)
+
+    # if uploaded_master_planogram_file is None:
+    #     master = cv2.imread('./sample_master_planogram.jpeg')
+
+    names_dict = {name: id for id, name in enumerate(target_names)}
+
+    sorted_xml_df = None
+    # https://discuss.streamlit.io/t/unable-to-read-files-using-standard-file-uploader/2258/2
+    if uploaded_master_planogram_file and annotation_file:
+        file_bytes = np.asarray(
+            bytearray(uploaded_master_planogram_file.read()), dtype=np.uint8
+        )
+        master = cv2.imdecode(file_bytes, 1)
+        cv2.imwrite("tmp/master_tmp.png", master)
+        # cv2.imwrite("tmp_uploaded_master_planogram_img.png", master)
+        # xml = annotation_file.read()
+        # tmp_xml ="tmp_xml_annotation.xml"
+        # with open(tmp_xml ,'w',encoding='utf-8') as f:
+        #      xml = f.write(xml)
+        xml_df = xml_to_csv(annotation_file)
+        xml_df["cls"] = xml_df["cls"].map(names_dict)
+        sorted_xml_df = do_sorting(xml_df)
+        sorted_xml_df.line_number.value_counts()
+
+        line_data = sorted_xml_df.line_number.value_counts()
+        n_rows = int(len(line_data))
+        n_cols = int(max(line_data))
+        master_table = np.zeros((n_rows, n_cols)) + 101
+        master_annotations = []
+        for i, row in sorted_xml_df.groupby("line_number"):
+            # print(f"Adding products in the row {i} to the detected planogram", row.cls.tolist())
+            products = row.cls.tolist()
+            master_table[int(i - 1), 0 : len(products)] = products
+            annotations = [
+                (int(k), int(v))
+                for k, v in list(
+                    zip(row.cls.unique(), row.cls.value_counts().tolist())
+                )
+            ]
+            master_annotations.append(annotations)
+        master_table.shape
+        # print("Annoatated planogram")
+        # print(np.matrix(master_table))
+
+    elif uploaded_master_planogram_file:
+        print(
+            "Finding the amster annotations with the YOLOv5 model predictions"
+        )
+        file_bytes = np.asarray(
+            bytearray(uploaded_master_planogram_file.read()), dtype=np.uint8
+        )
+        master = cv2.imdecode(file_bytes, 1)
+        cv2.imwrite("tmp/master_tmp.png", master)
+        master_results = run(
+            weights="base_line_best_model_exp5.pt",
+            source="tmp/master_tmp.png",
+            imgsz=[640, 640],
+            conf_thres=0.6,
+            iou_thres=0.6,
+        )
+
+        bb_df = pd.DataFrame(
+            master_results[0][1].tolist(),
+            columns=["xmin", "ymin", "xmax", "ymax", "conf", "cls"],
+        )
+        sorted_df = do_sorting(bb_df)
+
+        n_rows = int(sorted_df.line_number.max())
+        n_cols = int(
+            sorted_df.groupby("line_number")
+            .size()
+            .reset_index(name="counts")["counts"]
+            .max()
+        )
+        non_null_product = 101
+        print("master size", n_rows, n_cols)
+        master_annotations = []
+        master_table = np.zeros((int(n_rows), int(n_cols))) + non_null_product
+        for i, row in sorted_df.groupby("line_number"):
+            # print(f"Adding products in the row {i} to the detected planogram", row.cls.tolist())
+            products = row.cls.tolist()
+            col_len = min(len(products), n_cols)
+            print("col size: ", col_len)
+            print("row size: ", i - 1)
+            if n_rows <= (i - 1):
+                print("more rows than expected in the predictions")
+                break
+            master_table[int(i - 1), 0:col_len] = products[:col_len]
+            annotations = [
+                (int(k), int(v))
+                for k, v in list(
+                    zip(row.cls.unique(), row.cls.value_counts().tolist())
+                )
+            ]
+            master_annotations.append(annotations)
+    else:
+        master = cv2.imread("./sample_master_planogram.jpeg")
+        n_rows = 3
+        n_cols = 16
+        master_table = np.zeros((n_rows, n_cols)) + 101
+        master_annotations = [
+            [(32, 12), (8, 4)],
+            [(36, 1), (41, 6), (50, 4), (51, 3), (52, 2)],
+            [(23, 5), (24, 6), (54, 5)],
+        ]
+
+        for i, row in enumerate(master_annotations):
+            idx = 0
+            for product, count in row:
+                master_table[i, idx : idx + count] = product
+                idx = idx + count
+    # Now do something with the image! For example, let's display it:
+    # st.image(opencv_image, channels="BGR")
+
+    # uploaded_img = '/content/drive/My Drive/0.CV/0.Planogram_Compliance/planogram_data/images/test/IMG_5718.jpg'
+    result_list = run(
+        weights="base_line_best_model_exp5.pt",
+        source="tmp/to_score_planogram_tmp.png",
+        imgsz=[640, 640],
+        conf_thres=0.6,
+        iou_thres=0.6,
+    )
+
+    bb_df = pd.DataFrame(
+        result_list[0][1].tolist(),
+        columns=["xmin", "ymin", "xmax", "ymax", "conf", "cls"],
+    )
+    sorted_df = do_sorting(bb_df)
+
+    non_null_product = 101
+    print("master size", n_rows, n_cols)
+    detected_table = np.zeros((n_rows, n_cols)) + non_null_product
+    for i, row in sorted_df.groupby("line_number"):
+        # print(f"Adding products in the row {i} to the detected planogram", row.cls.tolist())
+        products = row.cls.tolist()
+        col_len = min(len(products), n_cols)
+        print("col size: ", col_len)
+        print("row size: ", i - 1)
+        if n_rows <= (i - 1):
+            print("more rows than expected in the predictions")
+            break
+        detected_table[int(i - 1), 0:col_len] = products[:col_len]
+
+    # score = (master_table == detected_table).sum() / (master_table != non_null_product).sum()
+    correct_matches = (
+        np.ma.masked_equal(master_table, non_null_product) == detected_table
+    ).sum()
+    total_products = (master_table != non_null_product).sum()
+    score = correct_matches / total_products
+    # if sorted_xml_df is not None:
+    #     annotate_df = sorted_xml_df[["xmin","ymin", "xmax", "ymax", "line_number","cls"]].astype(int)
+    # else:
+    annotate_df = sorted_df[
+        ["xmin", "ymin", "xmax", "ymax", "line_number", "cls"]
+    ].astype(int)
+
+    mask = master_table != non_null_product
+    m_detected_table = np.ma.masked_array(master_table, mask=mask)
+    m_annotated_table = np.ma.masked_array(detected_table, mask=mask)
+
+    #  wrong_indexes = np.ravel_multi_index(master_table*mask != detected_table*mask, master_table.shape)
+    wrong_indexes = np.where(master_table != detected_table)
+    correct_indexes = np.where(master_table == detected_table)
+    annotated_planogram = annotate_planogram_compliance(
+        uploaded_img, annotate_df, correct_indexes, wrong_indexes, target_names
+    )
+    st.title("Target Products")
+    st.write(json.dumps(target_names))
+    st.title("The master planogram annotation")
+    st.write(
+        "The annotations are based on the index of products from Target products list "
+    )
+    st.write(json.dumps(master_annotations))
+
+    # https://github.com/streamlit/streamlit/issues/888
+    st.image(
+        [master, annotated_planogram, result_list[0][0]],
+        width=512,
+        caption=[
+            "Master planogram",
+            "Planogram Compliance",
+            "Planogram Predictions",
+        ],
+        channels="BGR",
+    )
+    # st.image([master, annotated_planogram], width=512, caption=["Master planogram",  "Planogram Compliance"],  channels="BGR")
+    st.title("Planogram Compiance score")
+    # st.write(f"{correct_matches} / {total_products}")
+    st.write(score)

app_utils.py

@@ -0,0 +1,196 @@
+import glob
+import json
+import os
+import xml.etree.ElementTree as ET
+
+import cv2
+
+# from sklearn.externals import joblib
+import joblib
+import numpy as np
+import pandas as pd
+
+# from .variables import old_ocr_req_cols
+# from .skew_correction import  PageSkewWraper
+
+const_HW = 1.294117647
+const_W = 600
+# https://www.forbes.com/sites/forbestechcouncil/2020/06/02/leveraging-technologies-to-align-realograms-and-planograms-for-grocery/?sh=506b8b78e86c
+
+
+# https://stackoverflow.com/questions/39403183/python-opencv-sorting-contours
+# http://devdoc.net/linux/OpenCV-3.2.0/da/d0c/tutorial_bounding_rects_circles.html
+# https://stackoverflow.com/questions/10297713/find-contour-of-the-set-of-points-in-opencv
+# https://stackoverflow.com/questions/16538774/dealing-with-contours-and-bounding-rectangle-in-opencv-2-4-python-2-7
+# https://stackoverflow.com/questions/50308055/creating-bounding-boxes-for-contours
+# https://stackoverflow.com/questions/57296398/how-can-i-get-better-results-of-bounding-box-using-find-contours-of-opencv
+# http://amroamroamro.github.io/mexopencv/opencv/generalContours_demo1.html
+# https://gist.github.com/bigsnarfdude/d811e31ee17495f82f10db12651ae82d
+# http://man.hubwiz.com/docset/OpenCV.docset/Contents/Resources/Documents/da/d0c/tutorial_bounding_rects_circles.html
+# https://www.analyticsvidhya.com/blog/2021/05/document-layout-detection-and-ocr-with-detectron2/
+# https://colab.research.google.com/drive/1m6gaQF6Q4M0IaSjoo_4jWllKJjK-i6fw?usp=sharing#scrollTo=lEyl3wYKHAe1
+# https://stackoverflow.com/questions/39403183/python-opencv-sorting-contours
+# https://docs.opencv.org/2.4/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/bounding_rects_circles.html
+# https://www.pyimagesearch.com/2016/03/21/ordering-coordinates-clockwise-with-python-and-opencv/
+
+
+def bucket_sort(df, colmn, ymax_col="ymax", ymin_col="ymin"):
+    df["line_number"] = 0
+    colmn.append("line_number")
+    array_value = df[colmn].values
+    start_index = Line_counter = counter = 0
+    ymax, ymin, line_no = (
+        colmn.index(ymax_col),
+        colmn.index(ymin_col),
+        colmn.index("line_number"),
+    )
+    while counter < len(array_value):
+        current_ymax = array_value[start_index][ymax]
+        for next_index in range(start_index, len(array_value)):
+            counter += 1
+
+            next_ymin = array_value[next_index][ymin]
+            next_ymax = array_value[next_index][ymax]
+            if current_ymax > next_ymin:
+
+                array_value[next_index][line_no] = Line_counter + 1
+            #                 if current_ymax < next_ymax:
+
+            #                     current_ymax = next_ymax
+            else:
+                counter -= 1
+                break
+        # print(counter, len(array_value), start_index)
+        start_index = counter
+        Line_counter += 1
+    return pd.DataFrame(array_value, columns=colmn)
+
+
+def do_sorting(df):
+    df.sort_values(["ymin", "xmin"], ascending=True, inplace=True)
+    df["idx"] = df.index
+    if "line_number" in df.columns:
+        print("line number removed")
+        df.drop("line_number", axis=1, inplace=True)
+    req_colns = ["xmin", "ymin", "xmax", "ymax", "idx"]
+    temp_df = df.copy()
+    temp = bucket_sort(temp_df.copy(), req_colns)
+    df = df.merge(temp[["idx", "line_number"]], on="idx")
+    df.sort_values(["line_number", "xmin"], ascending=True, inplace=True)
+    df = df.reset_index(drop=True)
+    df = df.reset_index(drop=True)
+    return df
+
+
+def xml_to_csv(xml_file):
+    # https://gist.github.com/rotemtam/88d9a4efae243fc77ed4a0f9917c8f6c
+    xml_list = []
+    # for xml_file in glob.glob(path + '/*.xml'):
+    # https://discuss.streamlit.io/t/unable-to-read-files-using-standard-file-uploader/2258/2
+    tree = ET.parse(xml_file)
+    root = tree.getroot()
+    for member in root.findall("object"):
+        bbx = member.find("bndbox")
+        xmin = int(bbx.find("xmin").text)
+        ymin = int(bbx.find("ymin").text)
+        xmax = int(bbx.find("xmax").text)
+        ymax = int(bbx.find("ymax").text)
+        label = member.find("name").text
+
+        value = (
+            root.find("filename").text,
+            int(root.find("size")[0].text),
+            int(root.find("size")[1].text),
+            label,
+            xmin,
+            ymin,
+            xmax,
+            ymax,
+        )
+        xml_list.append(value)
+    column_name = [
+        "filename",
+        "width",
+        "height",
+        "cls",
+        "xmin",
+        "ymin",
+        "xmax",
+        "ymax",
+    ]
+    xml_df = pd.DataFrame(xml_list, columns=column_name)
+    return xml_df
+
+
+# def annotate_planogram_compliance(img0, sorted_xml_df, wrong_indexes, target_names):
+#     # annotator = Annotator(img0, line_width=3, pil=True)
+#     det = sorted_xml_df[['xmin', 'ymin', 'xmax', 'ymax','cls']].values
+#     # det[:, :4] = scale_coords((640, 640), det[:, :4], img0.shape).round()
+#     for i, (*xyxy, cls) in enumerate(det):
+
+#         c = int(cls)  # integer class
+
+#         if i in wrong_indexes:
+#             # print(xyxy, "Wrong detection", (255, 0, 0))
+#             label =  "Wrong detection"
+#             color = (0,0,255)
+#         else:
+#             # print(xyxy, label, (0, 255, 0))
+#             label = f'{target_names[c]}'
+#             color = (0,255, 0)
+#         org = (int(xyxy[0]), int(xyxy[1]) )
+#         top_left = org
+#         bottom_right = (int(xyxy[2]), int(xyxy[3]))
+#         # print("#"*50)
+#         # print(f"Anooatting cv2 rectangle with shape: { img0.shape}, top left: { top_left}, bottom right: { bottom_right} , color : { color },  thickness: {3}, cv2.LINE_8")
+#         # print("#"*50)
+#         cv2.rectangle(img0, top_left, bottom_right , color,  3, cv2.LINE_8)
+
+#         cv2.putText(img0, label, tuple(org), cv2. FONT_HERSHEY_SIMPLEX  , 0.5, color)
+
+#     return img0
+
+
+def annotate_planogram_compliance(
+    img0, sorted_df, correct_indexes, wrong_indexes, target_names
+):
+    # annotator = Annotator(img0, line_width=3, pil=True)
+    det = sorted_df[["xmin", "ymin", "xmax", "ymax", "cls"]].values
+    # det[:, :4] = scale_coords((640, 640), det[:, :4], img0.shape).round()
+    for x, y in zip(*correct_indexes):
+        try:
+            row = sorted_df[sorted_df["line_number"] == x + 1].iloc[y]
+            xyxy = row[["xmin", "ymin", "xmax", "ymax"]].values
+            label = f'{target_names[row["cls"]]}'
+            color = (0, 255, 0)
+            # org = (int(xyxy[0]), int(xyxy[1]) )
+            top_left = (int(row["xmin"]), int(row["ymin"]))
+            bottom_right = (int(row["xmax"]), int(row["ymax"]))
+            cv2.rectangle(img0, top_left, bottom_right, color, 3, cv2.LINE_8)
+
+            cv2.putText(
+                img0, label, top_left, cv2.FONT_HERSHEY_SIMPLEX, 0.5, color
+            )
+        except Exception as e:
+            print("Error: " + str(e))
+            continue
+
+    for x, y in zip(*wrong_indexes):
+        try:
+            row = sorted_df[sorted_df["line_number"] == x + 1].iloc[y]
+            xyxy = row[["xmin", "ymin", "xmax", "ymax"]].values
+            label = f'{target_names[row["cls"]]}'
+            color = (0, 0, 255)
+            # org = (int(xyxy[0]), int(xyxy[1]) )
+            top_left = (row["xmin"], row["ymin"])
+            bottom_right = (row["xmax"], row["ymax"])
+            cv2.rectangle(img0, top_left, bottom_right, color, 3, cv2.LINE_8)
+
+            cv2.putText(
+                img0, label, top_left, cv2.FONT_HERSHEY_SIMPLEX, 0.5, color
+            )
+        except Exception as e:
+            print("Error: " + str(e))
+            continue
+
+    return img0

base_line_best_model_exp5.pt

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

best_sku_model.pt

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

inference.py

@@ -0,0 +1,226 @@
+# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
+"""
+Run YOLOv5 detection inference on images, videos, directories, globs, YouTube, webcam, streams, etc.
+
+Usage - sources:
+    $ python detect.py --weights yolov5s.pt --source 0                               # webcam
+                                                     img.jpg                         # image
+                                                     vid.mp4                         # video
+                                                     screen                          # screenshot
+                                                     path/                           # directory
+                                                     list.txt                        # list of images
+                                                     list.streams                    # list of streams
+                                                     'path/*.jpg'                    # glob
+                                                     'https://youtu.be/Zgi9g1ksQHc'  # YouTube
+                                                     'rtsp://example.com/media.mp4'  # RTSP, RTMP, HTTP stream
+
+Usage - formats:
+    $ python detect.py --weights yolov5s.pt                 # PyTorch
+                                 yolov5s.torchscript        # TorchScript
+                                 yolov5s.onnx               # ONNX Runtime or OpenCV DNN with --dnn
+                                 yolov5s_openvino_model     # OpenVINO
+                                 yolov5s.engine             # TensorRT
+                                 yolov5s.mlmodel            # CoreML (macOS-only)
+                                 yolov5s_saved_model        # TensorFlow SavedModel
+                                 yolov5s.pb                 # TensorFlow GraphDef
+                                 yolov5s.tflite             # TensorFlow Lite
+                                 yolov5s_edgetpu.tflite     # TensorFlow Edge TPU
+                                 yolov5s_paddle_model       # PaddlePaddle
+"""
+
+import argparse
+import os
+import platform
+import sys
+from pathlib import Path
+
+import torch
+
+FILE = Path(__file__).resolve()
+ROOT = FILE.parents[0]  # YOLOv5 root directory
+if str(ROOT) not in sys.path:
+    sys.path.append(str(ROOT))  # add ROOT to PATH
+ROOT = Path(os.path.relpath(ROOT, Path.cwd()))  # relative
+
+from models.common import DetectMultiBackend
+from utils.dataloaders import (
+    IMG_FORMATS,
+    VID_FORMATS,
+    LoadImages,
+    LoadScreenshots,
+    LoadStreams,
+)
+from utils.general import (
+    LOGGER,
+    Profile,
+    check_file,
+    check_img_size,
+    check_imshow,
+    check_requirements,
+    colorstr,
+    cv2,
+    increment_path,
+    non_max_suppression,
+    print_args,
+    scale_boxes,
+    strip_optimizer,
+    xyxy2xywh,
+)
+from utils.plots import Annotator, colors, save_one_box
+from utils.torch_utils import select_device, smart_inference_mode
+
+
+@smart_inference_mode()
+def run(
+    weights=ROOT / "yolov5s.pt",  # model path or triton URL
+    source=ROOT / "data/images",  # file/dir/URL/glob/screen/0(webcam)
+    data=ROOT / "data/coco128.yaml",  # dataset.yaml path
+    imgsz=(640, 640),  # inference size (height, width)
+    conf_thres=0.25,  # confidence threshold
+    iou_thres=0.45,  # NMS IOU threshold
+    max_det=1000,  # maximum detections per image
+    device="",  # cuda device, i.e. 0 or 0,1,2,3 or cpu
+    view_img=False,  # show results
+    save_txt=False,  # save results to *.txt
+    save_conf=False,  # save confidences in --save-txt labels
+    save_crop=False,  # save cropped prediction boxes
+    nosave=False,  # do not save images/videos
+    classes=None,  # filter by class: --class 0, or --class 0 2 3
+    agnostic_nms=False,  # class-agnostic NMS
+    augment=False,  # augmented inference
+    visualize=False,  # visualize features
+    update=False,  # update all models
+    project=ROOT / "runs/detect",  # save results to project/name
+    name="exp",  # save results to project/name
+    exist_ok=False,  # existing project/name ok, do not increment
+    line_thickness=3,  # bounding box thickness (pixels)
+    hide_labels=False,  # hide labels
+    hide_conf=False,  # hide confidences
+    half=False,  # use FP16 half-precision inference
+    dnn=False,  # use OpenCV DNN for ONNX inference
+    vid_stride=1,  # video frame-rate stride
+):
+    source = str(source)
+    save_img = not nosave and not source.endswith(
+        ".txt"
+    )  # save inference images
+    is_file = Path(source).suffix[1:] in (IMG_FORMATS + VID_FORMATS)
+    is_url = source.lower().startswith(
+        ("rtsp://", "rtmp://", "http://", "https://")
+    )
+    webcam = (
+        source.isnumeric()
+        or source.endswith(".streams")
+        or (is_url and not is_file)
+    )
+    screenshot = source.lower().startswith("screen")
+    if is_url and is_file:
+        source = check_file(source)  # download
+
+    # Directories
+    save_dir = increment_path(
+        Path(project) / name, exist_ok=exist_ok
+    )  # increment run
+    (save_dir / "labels" if save_txt else save_dir).mkdir(
+        parents=True, exist_ok=True
+    )  # make dir
+
+    # Load model
+    device = select_device(device)
+    model = DetectMultiBackend(
+        weights, device=device, dnn=dnn, data=data, fp16=half
+    )
+    stride, names, pt = model.stride, model.names, model.pt
+    imgsz = check_img_size(imgsz, s=stride)  # check image size
+
+    # Dataloader
+    bs = 1  # batch_size
+    if webcam:
+        view_img = check_imshow(warn=True)
+        dataset = LoadStreams(
+            source,
+            img_size=imgsz,
+            stride=stride,
+            auto=pt,
+            vid_stride=vid_stride,
+        )
+        bs = len(dataset)
+    elif screenshot:
+        dataset = LoadScreenshots(
+            source, img_size=imgsz, stride=stride, auto=pt
+        )
+    else:
+        dataset = LoadImages(
+            source,
+            img_size=imgsz,
+            stride=stride,
+            auto=pt,
+            vid_stride=vid_stride,
+        )
+    vid_path, vid_writer = [None] * bs, [None] * bs
+
+    # Run inference
+    model.warmup(imgsz=(1 if pt or model.triton else bs, 3, *imgsz))  # warmup
+    seen, windows, dt = 0, [], (Profile(), Profile(), Profile())
+    for path, im, im0s, vid_cap, s in dataset:
+        with dt[0]:
+            im = torch.from_numpy(im).to(model.device)
+            im = im.half() if model.fp16 else im.float()  # uint8 to fp16/32
+            im /= 255  # 0 - 255 to 0.0 - 1.0
+            if len(im.shape) == 3:
+                im = im[None]  # expand for batch dim
+
+        # Inference
+        with dt[1]:
+            visualize = (
+                increment_path(save_dir / Path(path).stem, mkdir=True)
+                if visualize
+                else False
+            )
+            pred = model(im, augment=augment, visualize=visualize)
+
+        # NMS
+        with dt[2]:
+            pred = non_max_suppression(
+                pred,
+                conf_thres,
+                iou_thres,
+                classes,
+                agnostic_nms,
+                max_det=max_det,
+            )
+
+        # Second-stage classifier (optional)
+        # pred = utils.general.apply_classifier(pred, classifier_model, im, im0s)
+
+        # Process predictions
+        for i, det in enumerate(pred):  # per image
+            seen += 1
+            if webcam:  # batch_size >= 1
+                p, im0, frame = path[i], im0s[i].copy(), dataset.count
+                s += f"{i}: "
+            else:
+                p, im0, frame = path, im0s.copy(), getattr(dataset, "frame", 0)
+
+            p = Path(p)  # to Path
+            save_path = str(save_dir / p.name)  # im.jpg
+            txt_path = str(save_dir / "labels" / p.stem) + (
+                "" if dataset.mode == "image" else f"_{frame}"
+            )  # im.txt
+            s += "%gx%g " % im.shape[2:]  # print string
+            gn = torch.tensor(im0.shape)[
+                [1, 0, 1, 0]
+            ]  # normalization gain whwh
+            imc = im0.copy() if save_crop else im0  # for save_crop
+            annotator = Annotator(
+                im0, line_width=line_thickness, example=str(names)
+            )
+            results = []
+            if len(det):
+                # Rescale boxes from img_size to im0 size
+                det[:, :4] = scale_boxes(
+                    im.shape[2:], det[:, :4], im0.shape
+                ).round()
+                results.append((path, det))
+
+    return results

requirements (1).txt

@@ -0,0 +1,40 @@
+
+# pip install -r requirements.txt
+# Base ----------------------------------------
+seaborn
+ipython
+psutil
+matplotlib>=3.2.2
+numpy>=1.18.5
+opencv-python==4.7.0.68
+Pillow>=7.1.2
+PyYAML>=5.3.1
+requests>=2.23.0
+scipy>=1.4.1
+torch>=1.7.0
+torchvision>=0.8.1
+tqdm>=4.41.0
+joblib
+# Logging -------------------------------------
+#tensorboard>=2.4.1
+#wandb
+
+# Plotting ------------------------------------
+pandas>=1.1.4
+#seaborn>=0.11.0
+
+# Export --------------------------------------
+# coremltools>=4.1  # CoreML export
+# onnx>=1.9.0  # ONNX export
+# onnx-simplifier>=0.3.6  # ONNX simplifier
+# scikit-learn==0.19.2  # CoreML quantization
+# tensorflow>=2.4.1  # TFLite export
+# tensorflowjs>=3.9.0  # TF.js export
+# openvino-dev  # OpenVINO export
+
+# Extras --------------------------------------
+# albumentations>=1.0.3
+# Cython  # for pycocotools https://github.com/cocodataset/cocoapi/issues/172
+# pycocotools>=2.0  # COCO mAP
+# roboflow
+#thop  # FLOPs computation