From a05adf85a67f67e9efbf66df00cc33be0a46e962 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 04:54:22 +0530 Subject: [PATCH 1/9] Add files via upload --- app (3).py | 22 ++++++++++++++++++++++ chat (1).py | 26 ++++++++++++++++++++++++++ config (1).py | 2 ++ 3 files changed, 50 insertions(+) create mode 100644 app (3).py create mode 100644 chat (1).py create mode 100644 config (1).py diff --git a/app (3).py b/app (3).py new file mode 100644 index 000000000..5cefc3787 --- /dev/null +++ b/app (3).py @@ -0,0 +1,22 @@ +from flask import Flask, render_template, request, jsonify +from chat import chatbot + +app = Flask(__name__) + + +@app.route("/") +def hello(): + return render_template('chat.html') + +@app.route("/ask", methods=['POST']) +def ask(): + + message = str(request.form['messageText']) + + bot_response = chatbot(message) + + return jsonify({'status':'OK','answer':bot_response}) + + +if __name__ == "__main__": + app.run() diff --git a/chat (1).py b/chat (1).py new file mode 100644 index 000000000..72e4ec82c --- /dev/null +++ b/chat (1).py @@ -0,0 +1,26 @@ +from peft import AutoPeftModelForCausalLM +from transformers import GenerationConfig +from transformers import AutoTokenizer +import torch +tokenizer = AutoTokenizer.from_pretrained("Vasanth/mistral-finetuned-alpaca") + +model = AutoPeftModelForCausalLM.from_pretrained( + "Vasanth/mistral-finetuned-alpaca", + low_cpu_mem_usage=True, + return_dict=True, + torch_dtype=torch.float16, + device_map="cuda") + +generation_config = GenerationConfig( + do_sample=True, + top_k=1, + temperature=0.1, + max_new_tokens=100, + pad_token_id=tokenizer.eos_token_id +) + +def chatbot(message): + input_str = "###Human: " + message + " ###Assistant: " + inputs = tokenizer(input_str, return_tensors="pt").to("cuda") + outputs = model.generate(**inputs, generation_config=generation_config) + return tokenizer.decode(outputs[0], skip_special_tokens=True).replace(input_str, '') \ No newline at end of file diff --git a/config (1).py b/config (1).py new file mode 100644 index 000000000..9a835b3b5 --- /dev/null +++ b/config (1).py @@ -0,0 +1,2 @@ +##OPEN API STUFF +OPENAI_API_KEY = "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" From bacc6563ce1cde1fd3da7819a6757718cea8ba11 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:14:33 +0530 Subject: [PATCH 2/9] Create obj det --- Object Detection using COCO dataset with YOLO_v5 model/obj det | 1 + 1 file changed, 1 insertion(+) create mode 100644 Object Detection using COCO dataset with YOLO_v5 model/obj det diff --git a/Object Detection using COCO dataset with YOLO_v5 model/obj det b/Object Detection using COCO dataset with YOLO_v5 model/obj det new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/Object Detection using COCO dataset with YOLO_v5 model/obj det @@ -0,0 +1 @@ + From 2702a5c18dd64db9f99eda076052d9a513c4e46d Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:14:58 +0530 Subject: [PATCH 3/9] Add files via upload --- .../README (30).md | 26 + .../Untitled45 (4).ipynb | 603 ++++++++++++++++++ .../gitignore (8).txt | 38 ++ .../ob_det (1).jpeg | Bin 0 -> 8860 bytes .../requirements (11).txt | 16 + 5 files changed, 683 insertions(+) create mode 100644 Object Detection using COCO dataset with YOLO_v5 model/README (30).md create mode 100644 Object Detection using COCO dataset with YOLO_v5 model/Untitled45 (4).ipynb create mode 100644 Object Detection using COCO dataset with YOLO_v5 model/gitignore (8).txt create mode 100644 Object Detection using COCO dataset with YOLO_v5 model/ob_det (1).jpeg create mode 100644 Object Detection using COCO dataset with YOLO_v5 model/requirements (11).txt diff --git a/Object Detection using COCO dataset with YOLO_v5 model/README (30).md b/Object Detection using COCO dataset with YOLO_v5 model/README (30).md new file mode 100644 index 000000000..a9604e8b8 --- /dev/null +++ b/Object Detection using COCO dataset with YOLO_v5 model/README (30).md @@ -0,0 +1,26 @@ +# Project Title: Object Detection with YOLOv5 + +Project Description: +-------------------- +This project implements an object detection system using the YOLOv5 (You Only Look Once) model. YOLOv5 is a state-of-the-art, real-time object detection algorithm that is both fast and accurate. This system can detect multiple objects in images or video streams and can be further fine-tuned for custom datasets. It includes training the YOLOv5 model, evaluating it on a test dataset, and running real-time inference. + +Features: +--------- +Real-time object detection on images and video streams. +Training the YOLOv5 model on custom datasets. +Evaluation using key metrics such as Precision, Recall, Intersection over Union (IoU), and Mean Average Precision (mAP). +Deployment for detecting objects in images and video streams (GPU requirements for this case is much preferrable) +Model robustness testing with image augmentations. + +Requirements: +-------------- +Python 3.7+ +PyTorch 1.7+ +YOLOv5 (via the ultralytics/yolov5 repository) +Common libraries: +numpy +opencv-python +torch +pillow +matplotlib +albumentations diff --git a/Object Detection using COCO dataset with YOLO_v5 model/Untitled45 (4).ipynb b/Object Detection using COCO dataset with YOLO_v5 model/Untitled45 (4).ipynb new file mode 100644 index 000000000..1dde98f39 --- /dev/null +++ b/Object Detection using COCO dataset with YOLO_v5 model/Untitled45 (4).ipynb @@ -0,0 +1,603 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OFO2T6koBBIj", + "outputId": "5c861300-5262-40ff-e19a-a5a29c560da4" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "fatal: destination path 'yolov5' already exists and is not an empty directory.\n", + "/content/yolov5\n", + "Requirement already satisfied: gitpython>=3.1.30 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 5)) (3.1.43)\n", + "Requirement already satisfied: matplotlib>=3.3 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 6)) (3.7.1)\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 7)) (1.26.4)\n", + "Requirement already satisfied: opencv-python>=4.1.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 8)) (4.10.0.84)\n", + "Requirement already satisfied: pillow>=10.3.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 9)) (10.4.0)\n", + "Requirement already satisfied: psutil in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 10)) (5.9.5)\n", + "Requirement already satisfied: PyYAML>=5.3.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 11)) (6.0.2)\n", + "Requirement already satisfied: requests>=2.32.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 12)) (2.32.3)\n", + "Requirement already satisfied: scipy>=1.4.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 13)) (1.13.1)\n", + "Requirement already satisfied: thop>=0.1.1 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 14)) (0.1.1.post2209072238)\n", + "Requirement already satisfied: torch>=1.8.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 15)) (2.4.0+cu121)\n", + "Requirement already satisfied: torchvision>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 16)) (0.19.0+cu121)\n", + "Requirement already satisfied: tqdm>=4.64.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 17)) (4.66.5)\n", + "Requirement already satisfied: ultralytics>=8.2.34 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 18)) (8.2.94)\n", + "Requirement already satisfied: pandas>=1.1.4 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 27)) (2.1.4)\n", + "Requirement already satisfied: seaborn>=0.11.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 28)) (0.13.1)\n", + "Requirement already satisfied: setuptools>=70.0.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 42)) (71.0.4)\n", + "Requirement already satisfied: gitdb<5,>=4.0.1 in /usr/local/lib/python3.10/dist-packages (from gitpython>=3.1.30->-r requirements.txt (line 5)) (4.0.11)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3->-r requirements.txt (line 6)) (1.3.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3->-r requirements.txt (line 6)) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3->-r requirements.txt (line 6)) (4.53.1)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3->-r requirements.txt (line 6)) (1.4.7)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3->-r requirements.txt (line 6)) (24.1)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3->-r requirements.txt (line 6)) (3.1.4)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3->-r requirements.txt (line 6)) (2.8.2)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.0->-r requirements.txt (line 12)) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.0->-r requirements.txt (line 12)) (3.8)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.0->-r requirements.txt (line 12)) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.0->-r requirements.txt (line 12)) (2024.8.30)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.0->-r requirements.txt (line 15)) (3.16.0)\n", + "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.0->-r requirements.txt (line 15)) (4.12.2)\n", + "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.0->-r requirements.txt (line 15)) (1.13.2)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.0->-r requirements.txt (line 15)) (3.3)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.0->-r requirements.txt (line 15)) (3.1.4)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.0->-r requirements.txt (line 15)) (2024.6.1)\n", + "Requirement already satisfied: py-cpuinfo in /usr/local/lib/python3.10/dist-packages (from ultralytics>=8.2.34->-r requirements.txt (line 18)) (9.0.0)\n", + "Requirement already satisfied: ultralytics-thop>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from ultralytics>=8.2.34->-r requirements.txt (line 18)) (2.0.6)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.1.4->-r requirements.txt (line 27)) (2024.2)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.1.4->-r requirements.txt (line 27)) (2024.1)\n", + "Requirement already satisfied: smmap<6,>=3.0.1 in /usr/local/lib/python3.10/dist-packages (from gitdb<5,>=4.0.1->gitpython>=3.1.30->-r requirements.txt (line 5)) (5.0.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib>=3.3->-r requirements.txt (line 6)) (1.16.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.8.0->-r requirements.txt (line 15)) (2.1.5)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=1.8.0->-r requirements.txt (line 15)) (1.3.0)\n" + ] + } + ], + "source": [ + "!git clone https://github.com/ultralytics/yolov5\n", + "\n", + "%cd yolov5\n", + "\n", + "!pip install -r requirements.txt\n" + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import cv2\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)\n", + "\n", + "model.eval()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jcqGoV8gCahr", + "outputId": "c8863082-5fb6-4aee-ccf0-f76331dfedbc" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/torch/hub.py:295: UserWarning: You are about to download and run code from an untrusted repository. In a future release, this won't be allowed. To add the repository to your trusted list, change the command to {calling_fn}(..., trust_repo=False) and a command prompt will appear asking for an explicit confirmation of trust, or load(..., trust_repo=True), which will assume that the prompt is to be answered with 'yes'. You can also use load(..., trust_repo='check') which will only prompt for confirmation if the repo is not already trusted. This will eventually be the default behaviour\n", + " warnings.warn(\n", + "Downloading: \"https://github.com/ultralytics/yolov5/zipball/master\" to /root/.cache/torch/hub/master.zip\n", + "YOLOv5 🚀 2024-9-16 Python-3.10.12 torch-2.4.0+cu121 CUDA:0 (Tesla T4, 15102MiB)\n", + "\n", + "Downloading https://github.com/ultralytics/yolov5/releases/download/v7.0/yolov5s.pt to yolov5s.pt...\n", + "100%|██████████| 14.1M/14.1M [00:00<00:00, 38.7MB/s]\n", + "\n", + "Fusing layers... \n", + "YOLOv5s summary: 213 layers, 7225885 parameters, 0 gradients, 16.4 GFLOPs\n", + "Adding AutoShape... \n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "AutoShape(\n", + " (model): DetectMultiBackend(\n", + " (model): DetectionModel(\n", + " (model): Sequential(\n", + " (0): Conv(\n", + " (conv): Conv2d(3, 32, kernel_size=(6, 6), stride=(2, 2), padding=(2, 2))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (1): Conv(\n", + " (conv): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (2): C3(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv3): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): Sequential(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (3): Conv(\n", + " (conv): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (4): C3(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv3): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): Sequential(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (5): Conv(\n", + " (conv): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (6): C3(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv3): Conv(\n", + " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): Sequential(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " (2): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (7): Conv(\n", + " (conv): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (8): C3(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv3): Conv(\n", + " (conv): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): Sequential(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (9): SPPF(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): MaxPool2d(kernel_size=5, stride=1, padding=2, dilation=1, ceil_mode=False)\n", + " )\n", + " (10): Conv(\n", + " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (11): Upsample(scale_factor=2.0, mode='nearest')\n", + " (12): Concat()\n", + " (13): C3(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv3): Conv(\n", + " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): Sequential(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (14): Conv(\n", + " (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (15): Upsample(scale_factor=2.0, mode='nearest')\n", + " (16): Concat()\n", + " (17): C3(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv3): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): Sequential(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (18): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (19): Concat()\n", + " (20): C3(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv3): Conv(\n", + " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): Sequential(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (21): Conv(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (22): Concat()\n", + " (23): C3(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv3): Conv(\n", + " (conv): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): Sequential(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (24): Detect(\n", + " (m): ModuleList(\n", + " (0): Conv2d(128, 255, kernel_size=(1, 1), stride=(1, 1))\n", + " (1): Conv2d(256, 255, kernel_size=(1, 1), stride=(1, 1))\n", + " (2): Conv2d(512, 255, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " )\n", + " )\n", + " )\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 2 + } + ] + }, + { + "cell_type": "code", + "source": [ + "def preprocess_image(image_path):\n", + "\n", + " img = cv2.imread(image_path)\n", + "\n", + " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + "\n", + " return img\n" + ], + "metadata": { + "id": "Jh80XUG5Cae8" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def detect_objects(image):\n", + "\n", + " results = model(image)\n", + "\n", + " return results\n", + "\n", + "\n", + "image_path = '/content/ob_det.jpeg'\n", + "image = preprocess_image(image_path)\n", + "\n", + "\n", + "results = detect_objects(image)\n", + "\n", + "results.print()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6yqicSIaCacf", + "outputId": "8d154e56-2508-49fb-c317-1e81feac75bf" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/root/.cache/torch/hub/ultralytics_yolov5_master/models/common.py:892: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n", + " with amp.autocast(autocast):\n", + "WARNING ⚠️ NMS time limit 0.550s exceeded\n", + "image 1/1: 138x366 1 potted plant, 1 tv, 1 keyboard, 1 cell phone, 1 vase\n", + "Speed: 9.6ms pre-process, 102.5ms inference, 784.4ms NMS per image at shape (1, 3, 256, 640)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "results.show()\n", + "\n", + "results.save('path_to_save_result_image')\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 172 + }, + "id": "XuLWldaQCaZt", + "outputId": "8a4e9c83-ad92-4c65-c4db-8b678843c880" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n", + "image/jpeg": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Saved 1 image to \u001b[1mruns/detect/exp\u001b[0m\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import cv2\n", + "import csv\n", + "from collections import Counter\n", + "\n", + "\n", + "model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)\n", + "\n", + "def detect_video(video_path=None):\n", + " cap = cv2.VideoCapture(0 if video_path is None else video_path)\n", + "\n", + " while cap.isOpened():\n", + " ret, frame = cap.read()\n", + " if not ret:\n", + " break\n", + "\n", + " results = model(frame)\n", + " labels = results.xyxyn[0][:, -1].cpu().numpy()\n", + " label_counts = Counter(labels)\n", + " print(label_counts)\n", + "\n", + "\n", + " if 'person' in [model.names[int(label)] for label in labels]:\n", + " print(\"ALERT: Person detected!\")\n", + "\n", + "\n", + " cv2.imshow('YOLOv5 Object Detection', np.squeeze(results.render()))\n", + " if cv2.waitKey(1) & 0xFF == ord('q'):\n", + " break\n", + "\n", + " cap.release()\n", + " cv2.destroyAllWindows()\n", + "\n", + "\n", + "detect_video()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Qu7jXZ93ET1W", + "outputId": "c4d311fa-1c92-4318-b061-eb2f3ecc237e" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Using cache found in /root/.cache/torch/hub/ultralytics_yolov5_master\n", + "YOLOv5 🚀 2024-9-16 Python-3.10.12 torch-2.4.0+cu121 CUDA:0 (Tesla T4, 15102MiB)\n", + "\n", + "Fusing layers... \n", + "YOLOv5s summary: 213 layers, 7225885 parameters, 0 gradients, 16.4 GFLOPs\n", + "Adding AutoShape... \n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/Object Detection using COCO dataset with YOLO_v5 model/gitignore (8).txt b/Object Detection using COCO dataset with YOLO_v5 model/gitignore (8).txt new file mode 100644 index 000000000..33ea175b9 --- /dev/null +++ b/Object Detection using COCO dataset with YOLO_v5 model/gitignore (8).txt @@ -0,0 +1,38 @@ +__pycache__/ +*.py[cod] +*.so + +.ipynb_checkpoints/ + +# Python virtual environments +env/ +venv/ + +# YOLOv5 Weights +*.pt +runs/ +weights/ + + +*.log + + +*.o +*.a +*.out +*.exe + +# Data files +data/ +*.csv +*.json + +# System files +.DS_Store +Thumbs.db + +# PyCharm/IDEA +.idea/ + +# Visual Studio Code +.vscode/ diff --git a/Object Detection using COCO dataset with YOLO_v5 model/ob_det (1).jpeg b/Object Detection using COCO dataset with YOLO_v5 model/ob_det (1).jpeg new file mode 100644 index 0000000000000000000000000000000000000000..29a8581b4525b061b7d5c657ba1c5c6b100d4d87 GIT binary patch literal 8860 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.7.0 +torchvision>=0.8.0 +matplotlib>=3.2.2 +numpy>=1.18.5 +opencv-python>=4.1.2 +pillow>=7.1.2 +PyYAML>=5.3.1 +tqdm>=4.64.0 +scipy>=1.4.1 +tensorboard>=2.4.1 +seaborn>=0.11.0 +pandas>=1.1.4 +albumentations>=0.5.2 +ipython>=7.16.1 +jupyterlab>=2.1.5 +requests>=2.23.0 From 2e47e5458dc5f821111052b260245ec920072396 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:15:24 +0530 Subject: [PATCH 4/9] Delete Object Detection using COCO dataset with YOLO_v5 model/obj det --- Object Detection using COCO dataset with YOLO_v5 model/obj det | 1 - 1 file changed, 1 deletion(-) delete mode 100644 Object Detection using COCO dataset with YOLO_v5 model/obj det diff --git a/Object Detection using COCO dataset with YOLO_v5 model/obj det b/Object Detection using COCO dataset with YOLO_v5 model/obj det deleted file mode 100644 index 8b1378917..000000000 --- a/Object Detection using COCO dataset with YOLO_v5 model/obj det +++ /dev/null @@ -1 +0,0 @@ - From e6a30700ce1317e5b7510094491a7df8bb1c79be Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:15:43 +0530 Subject: [PATCH 5/9] Rename README (30).md to README.md for convenience --- .../{README (30).md => README.md} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Object Detection using COCO dataset with YOLO_v5 model/{README (30).md => README.md} (100%) diff --git a/Object Detection using COCO dataset with YOLO_v5 model/README (30).md b/Object Detection using COCO dataset with YOLO_v5 model/README.md similarity index 100% rename from Object Detection using COCO dataset with YOLO_v5 model/README (30).md rename to Object Detection using COCO dataset with YOLO_v5 model/README.md From 3725d746b1235a29b7baf7d1430554d5cb008348 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:16:21 +0530 Subject: [PATCH 6/9] Rename Untitled45 (4).ipynb to Object Detection with COCO dataset using YOLO_v5.ipynb for convenience --- ...b => Object Detection with COCO dataset using YOLO_v5.ipynb} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename Object Detection using COCO dataset with YOLO_v5 model/{Untitled45 (4).ipynb => Object Detection with COCO dataset using YOLO_v5.ipynb} (99%) diff --git a/Object Detection using COCO dataset with YOLO_v5 model/Untitled45 (4).ipynb b/Object Detection using COCO dataset with YOLO_v5 model/Object Detection with COCO dataset using YOLO_v5.ipynb similarity index 99% rename from Object Detection using COCO dataset with YOLO_v5 model/Untitled45 (4).ipynb rename to Object Detection using COCO dataset with YOLO_v5 model/Object Detection with COCO dataset using YOLO_v5.ipynb index 1dde98f39..f6440e943 100644 --- a/Object Detection using COCO dataset with YOLO_v5 model/Untitled45 (4).ipynb +++ b/Object Detection using COCO dataset with YOLO_v5 model/Object Detection with COCO dataset using YOLO_v5.ipynb @@ -600,4 +600,4 @@ ] } ] -} \ No newline at end of file +} From a460738043284e4805ac479736b2bdecc0728b2d Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:16:59 +0530 Subject: [PATCH 7/9] Rename gitignore (8).txt to gitignore.txt for convenience --- .../{gitignore (8).txt => gitignore.txt} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Object Detection using COCO dataset with YOLO_v5 model/{gitignore (8).txt => gitignore.txt} (100%) diff --git a/Object Detection using COCO dataset with YOLO_v5 model/gitignore (8).txt b/Object Detection using COCO dataset with YOLO_v5 model/gitignore.txt similarity index 100% rename from Object Detection using COCO dataset with YOLO_v5 model/gitignore (8).txt rename to Object Detection using COCO dataset with YOLO_v5 model/gitignore.txt From 164ba59997c8e6c5c8435b86d580251a10262c27 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:17:21 +0530 Subject: [PATCH 8/9] Rename requirements (11).txt to requirements.txt --- .../{requirements (11).txt => requirements.txt} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Object Detection using COCO dataset with YOLO_v5 model/{requirements (11).txt => requirements.txt} (100%) diff --git a/Object Detection using COCO dataset with YOLO_v5 model/requirements (11).txt b/Object Detection using COCO dataset with YOLO_v5 model/requirements.txt similarity index 100% rename from Object Detection using COCO dataset with YOLO_v5 model/requirements (11).txt rename to Object Detection using COCO dataset with YOLO_v5 model/requirements.txt From b50b05119cd0f55605442481d7b9fd05cd760e43 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 15:07:18 +0530 Subject: [PATCH 9/9] Update README.md --- .../README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/Object Detection using COCO dataset with YOLO_v5 model/README.md b/Object Detection using COCO dataset with YOLO_v5 model/README.md index a9604e8b8..9b2687679 100644 --- a/Object Detection using COCO dataset with YOLO_v5 model/README.md +++ b/Object Detection using COCO dataset with YOLO_v5 model/README.md @@ -24,3 +24,9 @@ torch pillow matplotlib albumentations + +Result Demo: +------------- + +![result-demo-obj-det](https://github.com/user-attachments/assets/0c5020e1-d3e7-4789-a16a-16b44f1b85af) +