add

.dockerignore

@@ -0,0 +1,4 @@
+venv/
+sample/
+__pycache__/
+.vscode/

.gitignore

@@ -0,0 +1,6 @@
+venv/
+__pycache__/
+.vscode/
+sample/*
+
+weight/*.onnx

Dockerfile

@@ -0,0 +1,23 @@
+# Use an official Python runtime as a parent image
+FROM python:3.11.1
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install necessary system dependencies for OpenCV
+RUN apt-get update && \
+    apt-get install -y libgl1-mesa-glx libglib2.0-0
+
+# Copy the current directory contents into the container at /app
+COPY . /app
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Make port available to the world outside this container
+EXPOSE 8001
+
+# Run your FastAPI app
+CMD ["python", "api.py"]
+# CMD ["streamlit", "run", "app.py"]
+

README.md

@@ -0,0 +1,80 @@
+# Project Name
+🌟Image Object Detection🌟
+
+## Description
+This is a FastAPI-based web service that accepts an image upload and performs object detection on the image using a pre-trained model Yolov5m. It returns the annotated image with the detected objects.
+
+## Table of Contents
+- [Installation](#installation)
+- [Features](#features)
+- [Usage](#usage)
+- [Configuration](#configuration)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation
+1. Clone the repository: 
+```bash
+git clone https://github.com/Codelinhtinh/Exercises-AIO.git
+```
+2. Install project dependencies:
+```bash
+pip install -r requirements.txt
+```
+## Features
+✨This code is a FastAPI application that provides an API endpoint for performing predictions on uploaded images.
+
+✨ It uses a pre-trained model to detect objects in images. 
+
+✨ Uploaded images are processed and resized to a specific image size defined in the CFG class. 
+
+✨ The final results are visualized on the original image using the visualize function.
+
+✨The processed and visualized image is saved to a temporary file and returned as a response to the API request.
+## Usage
+1. Run the FastAPI server in makefile:
+```bash
+uvicorn api:api --port 8000
+```
+
+2. Open your browser and navigate to `http://localhost:8000/docs` to check prediction.
+![Alt Text](sample\api.gif)
+
+3. Start the streamlit app in makefile:
+```bash
+streamlit run app.py
+```
+4. Import image and wait:
+![Alt Text](sample\Usage.gif)
+
+## Configuration
+You can modify the configuration parameters of the model by updating the CFG class in the configs.py file. The available configuration options are:
+
+**image_size**: The size of the input image for prediction.
+
+**conf_thres**: The confidence threshold for object detection.
+
+**iou_thres**: The IoU (Intersection over Union) threshold for non-maximum suppression.
+
+Feel free to adjust these parameters according to your requirements.
+
+
+## Contributing
+🤝 Contributions are welcome! Please follow these guidelines when contributing to the project:
+1. Fork the repository.
+2. Create a new branch: 
+```bash
+git checkout -b feature/your-feature
+```
+3. Commit your changes: 
+```bash
+git commit -m 'Add your feature'
+```
+4. Push to the branch: 
+```bash
+git push origin feature/your-feature
+```
+5. Create a pull request.
+
+## License
+📝 This project is open source

api.py

@@ -0,0 +1,54 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from PIL import Image
+from io import BytesIO
+import cv2
+import numpy as np
+from main import *
+from utils import load_session
+from preprocess import resize_and_pad
+from fastapi.responses import FileResponse
+import tempfile
+import json
+
+api = FastAPI()
+
+class CFG:
+    image_size = IMAGE_SIZE
+    conf_thres = 0.01
+    iou_thres = 0.1
+
+cfg = CFG()
+session = load_session(PATH_MODEL)
+
+@api.get("/")
+def read_root():
+    return {"message": "Hello World"}
+
+@api.post("/predict/")
+async def predict(file: UploadFile):
+    # Read and process the uploaded image
+    contents = await file.read()
+    image = Image.open(BytesIO(contents))
+    image = image.copy()
+    # Convert the PIL Image to a NumPy array
+    image_cv = np.array(image)
+    image_cv_2 = image_cv.copy()
+    image, ratio, (padd_left, padd_top) = resize_and_pad(image_cv, new_shape=cfg.image_size)
+    img_norm = normalization_input(image)
+    pred = infer(session, img_norm)
+    pred = postprocess(pred)[0]
+    paddings = np.array([padd_left, padd_top, padd_left, padd_top])
+    pred[:,:4] = (pred[:,:4] - paddings) / ratio
+    image_cv = cv2.cvtColor(image_cv, cv2.COLOR_BGR2RGB)
+    image = Image.fromarray(image_cv)
+    image_cv_2 =Image.fromarray(image_cv_2) 
+    image = visualize(image_cv_2, pred)
+    # Save the processed and visualized image to a temporary file
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as temp_file:
+        image.save(temp_file, format="JPEG")
+        temp_file_path = temp_file.name
+    return FileResponse(temp_file_path, media_type="image/jpeg")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(api, host="0.0.0.0", port=8001)

app.py

@@ -0,0 +1,26 @@
+import streamlit as st
+import requests
+
+# Streamlit UI
+st.title("Object Detection with FastAPI and Streamlit")
+
+uploaded_file = st.file_uploader("Choose an image...", type="jpg")
+
+if uploaded_file is not None:
+    # Display the uploaded image
+    st.image(uploaded_file, caption="Uploaded Image.", use_column_width=True)
+
+    # Make a prediction using FastAPI endpoint
+    if st.button("Predict"):
+        # Define the FastAPI endpoint URL
+        api_url = "http://localhost:8001/predict/"
+
+        # Make a POST request to the FastAPI endpoint
+        files = {"file": ("image.jpg", uploaded_file, "image/jpeg")}
+        response = requests.post(api_url, files=files)
+
+        if response.status_code == 200:
+            # Display the predicted image
+            st.image(response.content, caption="Predicted Image.", use_column_width=True)
+        else:
+            st.error(f"Error: {response.status_code}. Failed to make a prediction.")

configs.py

@@ -0,0 +1,19 @@
+IDX2TAGs = {
+  0: "bicycle",
+  1: "bus",
+  2: "car",
+  3: "motorbike",
+  4: "person"
+}
+
+IDX2COLORs = {
+  0: "#FF5733",
+  1: "#6E0DD0",
+  2: "#B2B200",
+  3: "#009DFF",
+  4: "#FF33A8"
+}
+
+IMAGE_SIZE = (448, 448)
+
+PATH_MODEL = "weight/best_m.onnx"

docker-compose.yml

@@ -0,0 +1,16 @@
+version: '3'
+services:
+  fastapi:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "8001:8001"
+    command: 
+      - "uvicorn"
+      - "api:api"
+      - "--reload"
+      - "--port=8001"
+      - "--host=0.0.0.0"
+    volumes:
+      - .:/app  # Replace with the path to your local code

main.py

@@ -0,0 +1,43 @@
+from utils import *
+from preprocess import *
+from postprocess import *
+from PIL import Image, ImageDraw, ImageFont
+from configs import *
+
+def prediction(session, image, cfg):
+    image, ratio, (padd_left, padd_top) = resize_and_pad(image, new_shape=cfg.image_size)
+    img_norm = normalization_input(image)
+    pred = infer(session, img_norm)
+    pred = postprocess(pred, cfg.conf_thres, cfg.iou_thres)[0]
+    paddings = np.array([padd_left, padd_top, padd_left, padd_top])
+    pred[:,:4] = (pred[:,:4] - paddings) / ratio
+    return pred
+
+# Modify the visualize function to use the ImageFont module
+def visualize(image, pred):
+    img_ = image.copy()
+    drawer = ImageDraw.Draw(img_)
+
+    # Create a dictionary to store the count of each object
+    object_counts = {}
+    for p in pred:
+        x1, y1, x2, y2, _, id = p
+        id = int(id)
+
+        # Increment the count of the object
+        if id not in object_counts:
+            object_counts[id] = 0
+        object_counts[id] += 1
+
+        # Draw the rectangle and label the object
+        drawer.rectangle((x1, y1, x2, y2), outline=IDX2COLORs[id], width=3)
+        # drawer.text((x2 + 5, y1), IDX2TAGs[id], fill=IDX2COLORs[id], font=ImageFont.truetype("arial.ttf", 16))
+
+    # Add a legend to the image
+    # drawer.text((0, 0), "", fill="#FFFFFF", font=ImageFont.truetype("arial.ttf", 16))
+    # for id, count in object_counts.items():
+    #     drawer.text((0, 20 + 20 * id), f"{IDX2TAGs[id]}: {count}", fill=IDX2COLORs[id], font=ImageFont.truetype("arial.ttf", 16))
+
+    return img_
+
+

postprocess.py

@@ -0,0 +1,93 @@
+import numpy as np
+
+def convert_xywh_to_xyxy(bbox_array: np.array) -> np.array:
+    converted_boxes = np.zeros_like(bbox_array)
+    converted_boxes[:, 0] = bbox_array[:, 0] - bbox_array[:, 2] / 2  # x1 (top-left x)
+    converted_boxes[:, 1] = bbox_array[:, 1] - bbox_array[:, 3] / 2  # y1 (top-left y)
+    converted_boxes[:, 2] = bbox_array[:, 0] + bbox_array[:, 2] / 2  # x2 (bottom-right x)
+    converted_boxes[:, 3] = bbox_array[:, 1] + bbox_array[:, 3] / 2  # y2 (bottom-right y)
+
+    return converted_boxes
+
+
+def calculate_iou(box1: np.array, box2: np.array) -> float:
+    x1_1, y1_1, x2_1, y2_1 = box1
+    x1_2, y1_2, x2_2, y2_2 = box2
+    # Calculate the coordinates of the intersection rectangle
+    x1_i = max(x1_1, x1_2)
+    y1_i = max(y1_1, y1_2)
+    x2_i = min(x2_1, x2_2)
+    y2_i = min(y2_1, y2_2)
+
+    # Calculate the area of intersection rectangle
+    intersection_area = max(0, x2_i - x1_i + 1) * max(0, y2_i - y1_i + 1)
+
+    # Calculate the area of both input rectangles
+    area1 = (x2_1 - x1_1 + 1) * (y2_1 - y1_1 + 1)
+    area2 = (x2_2 - x1_2 + 1) * (y2_2 - y1_2 + 1)
+
+    # Calculate IoU
+    iou = intersection_area / float(area1 + area2 - intersection_area)
+
+    return iou
+
+def nms(bboxes: np.array, scores: np.array, iou_threshold: float) -> np.array:
+    selected_indices = []
+
+    # Sort bounding boxes by decreasing confidence scores
+    sorted_indices = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)
+
+    while len(sorted_indices) > 0:
+        current_index = sorted_indices[0]
+        selected_indices.append(current_index)
+
+        # Remove the current box from the sorted list
+        sorted_indices.pop(0)
+
+        indices_to_remove = []
+        for index in sorted_indices:
+            iou = calculate_iou(bboxes[current_index], bboxes[index])
+            if iou >= iou_threshold:
+                indices_to_remove.append(index)
+
+        # Remove overlapping boxes from the sorted list
+        sorted_indices = [i for i in sorted_indices if i not in indices_to_remove]
+
+    return selected_indices
+
+def postprocess(prediction: np.array, conf_thres: float=0.15, iou_thres: float=0.45, max_det: int=300) -> np.array:
+    bs = prediction.shape[0]  # batch size
+    xc = prediction[..., 4] > conf_thres  # candidates
+    max_nms = 300  # maximum number of boxes into NMS
+    max_wh = 7680
+    output = [None] * bs
+
+    for xi, x in enumerate(prediction):
+        x = x[xc[xi]]
+        if len(x) == 0:
+            continue
+        x[:, 5:] *= x[:, 4:5]
+        # Define xywh2xyxy_numpy function or import it
+        box = convert_xywh_to_xyxy(x[:, :4])
+
+        # Detections matrix nx6 (xyxy, conf, cls)
+        conf = x[:, 5:].max(1)
+        max_conf_indices = x[:, 5:].argmax(1)
+        x = np.column_stack((box, conf, max_conf_indices.astype(float)))[conf > conf_thres]
+
+        n = len(x)
+        if n == 0:
+            continue
+        elif n > max_nms:
+            sorted_indices = np.argsort(-x[:, 4])
+            x = x[sorted_indices[:max_nms]]
+
+        # Batched NMS
+        c = x[:, 5:6] * max_wh  # You should compute max_wh based on image dimensions
+        boxes, scores = x[:, :4] + c, x[:, 4]
+        # Define nms_boxes_numpy function or import it
+        i = nms(boxes, scores, iou_thres)
+        if len(i) > max_det:
+            i = i[:max_det]
+        output[xi] = x[i]
+    return output

preprocess.py

@@ -0,0 +1,39 @@
+from typing import Tuple
+import cv2
+import numpy as np
+
+def resize_and_pad(image: np.array, 
+                   new_shape: Tuple[int, int], 
+                   padding_color: Tuple[int] = (144, 144, 144)
+                   ) -> np.array:
+    h_org, w_org = image.shape[:2]
+    w_new, h_new = new_shape
+    padd_left, padd_right, padd_top, padd_bottom = 0, 0, 0, 0
+
+    #Padding left to right
+    if h_org >= w_org:
+        img_resize = cv2.resize(image, (int(w_org*h_new/h_org), h_new))
+        h, w = img_resize.shape[:2]
+        padd_left = (w_new-w)//2
+        padd_right =  w_new - w - padd_left
+        ratio = h_new/h_org
+
+    #Padding top to bottom
+    if h_org < w_org:
+        img_resize = cv2.resize(image, (w_new, int(h_org*w_new/w_org)))
+        h, w = img_resize.shape[:2]
+        padd_top = (h_new-h)//2
+        padd_bottom =  h_new - h - padd_top
+        ratio = w_new/w_org
+    
+    image = cv2.copyMakeBorder(img_resize, padd_top, padd_bottom, padd_left, padd_right, cv2.BORDER_CONSTANT,None,value=padding_color)
+    
+    return image, ratio, (padd_left, padd_top)
+
+def normalization_input(image:  np.array) ->  np.array:
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) #BGR to RGB
+    img = image.transpose((2, 0, 1)) # HWC to CHW
+    img = np.ascontiguousarray(img).astype(np.float32)
+    img /=255.0
+    img = img[np.newaxis, ...]
+    return img

utils.py

@@ -0,0 +1,17 @@
+import onnxruntime as ort
+import numpy as np
+
+def load_session(path: str) -> ort.InferenceSession:
+    providers = ['CPUExecutionProvider']
+    session = ort.InferenceSession(path, providers=providers)   
+    return session
+
+def infer(inference_session: ort.InferenceSession, input_data: np.array) -> np.array:
+    input_name = inference_session.get_inputs()[0].name
+    output_name = inference_session.get_outputs()[0].name
+    inference_inputs = {input_name: input_data}
+    outputs = inference_session.run(
+        [output_name], 
+        inference_inputs
+        )
+    return outputs[0]