रोबोफ्लो ऑब्जेक्ट डिटेक्शन एआई में उपयोग के लिए छवियों को एनोटेट करने का एक मंच है।

मैं इस प्लेटफ़ॉर्म का उपयोग C2SMR c2smr.fr के लिए करता हूं, जो समुद्री बचाव के लिए मेरा कंप्यूटर विज़न एसोसिएशन है।

इस लेख में मैं आपको दिखाता हूं कि इस प्लेटफ़ॉर्म का उपयोग कैसे करें और अपने मॉडल को पायथन के साथ कैसे प्रशिक्षित करें।

आप मेरे जीथब पर अधिक नमूना कोड पा सकते हैं: https://github.com/C2SMR/detector

मैं - डेटासेट

अपना डेटासेट बनाने के लिए, https://app.roboflow.com/ पर जाएं और अपनी छवि को एनोटेट करना शुरू करें जैसा कि निम्नलिखित छवि में दिखाया गया है।

इस उदाहरण में, मैं भविष्य की छवियों में उनकी स्थिति का अनुमान लगाने के लिए सभी तैराकों का चक्कर लगाता हूं।
एक अच्छा परिणाम प्राप्त करने के लिए, सभी तैराकों को क्रॉप करें और ऑब्जेक्ट को सही ढंग से घेरने के लिए बाउंडिंग बॉक्स को उसके ठीक बाद रखें।

इस जांच के लिए आप पहले से ही सार्वजनिक रोबोफ्लो डेटासेट का उपयोग कर सकते हैं https://univers.roboflow.com/

द्वितीय - प्रशिक्षण

प्रशिक्षण चरण के लिए, आप सीधे रोबोफ्लो का उपयोग कर सकते हैं, लेकिन तीसरी बार आपको भुगतान करना होगा, यही कारण है कि मैं आपको दिखा रहा हूं कि इसे अपने लैपटॉप के साथ कैसे करें।

पहला कदम अपना डेटासेट आयात करना है। ऐसा करने के लिए, आप रोबोफ़्लो लाइब्रेरी आयात कर सकते हैं।

pip install roboflow

एक मॉडल बनाने के लिए, आपको YOLO एल्गोरिदम का उपयोग करना होगा, जिसे आप अल्ट्रालिटिक्स लाइब्रेरी के साथ आयात कर सकते हैं।

pip install ultralytics

मेरी स्क्रिप्ट में, मैं निम्नलिखित कमांड का उपयोग करता हूं:

py train.py api-key project-workspace project-name project-version nb-epoch size_model

आपको प्राप्त करना होगा:

• एक्सेस कुंजी
• कार्यस्थान
• रोबोफ्लो परियोजना का नाम
• प्रोजेक्ट डेटासेट संस्करण
• मॉडल को प्रशिक्षित करने के लिए युगों की संख्या
• तंत्रिका नेटवर्क आकार

प्रारंभ में, प्रशिक्षण की सुविधा के लिए स्क्रिप्ट yolov8-obb.pt, प्री-वर्कआउट डेटा के साथ डिफ़ॉल्ट योलो वजन डाउनलोड करती है।

import sys
import os
import random
from roboflow import Roboflow
from ultralytics import YOLO
import yaml
import time


class Main:
    rf: Roboflow
    project: object
    dataset: object
    model: object
    results: object
    model_size: str

    def __init__(self):
        self.model_size = sys.argv[6]
        self.import_dataset()
        self.train()

    def import_dataset(self):
        self.rf = Roboflow(api_key=sys.argv[1])
        self.project = self.rf.workspace(sys.argv[2]).project(sys.argv[3])
        self.dataset = self.project.version(sys.argv[4]).download("yolov8-obb")

        with open(f'{self.dataset.location}/data.yaml', 'r') as file:
            data = yaml.safe_load(file)

        data['path'] = self.dataset.location

        with open(f'{self.dataset.location}/data.yaml', 'w') as file:
            yaml.dump(data, file, sort_keys=False)

    def train(self):
        list_of_models = ["n", "s", "m", "l", "x"]
        if self.model_size != "ALL" and self.model_size in list_of_models:

            self.model = YOLO(f"yolov8{self.model_size}-obb.pt")

            self.results = self.model.train(data=f"{self.dataset.location}/"
                                                 f"yolov8-obb.yaml",
                                            epochs=int(sys.argv[5]), imgsz=640)



        elif self.model_size == "ALL":
            for model_size in list_of_models:
                self.model = YOLO(f"yolov8{model_size}.pt")

                self.results = self.model.train(data=f"{self.dataset.location}"
                                                     f"/yolov8-obb.yaml",
                                                epochs=int(sys.argv[5]),
                                                imgsz=640)



        else:
            print("Invalid model size")



if __name__ == '__main__':
    Main()

तृतीय - प्रदर्शन

मॉडल को प्रशिक्षित करने के बाद, आपको best.py और Last.py फ़ाइलें मिलती हैं, जो वजन के अनुरूप होती हैं।

अल्ट्रालिटिक्स लाइब्रेरी के साथ, आप YOLO भी आयात कर सकते हैं और अपना वजन और फिर अपना परीक्षण वीडियो लोड कर सकते हैं।
इस उदाहरण में, मैं प्रत्येक तैराक के लिए एक आईडी प्राप्त करने के लिए ट्रैकिंग फ़ंक्शन का उपयोग कर रहा हूं।

import cv2
from ultralytics import YOLO
import sys


def main():
    cap = cv2.VideoCapture(sys.argv[1])

    model = YOLO(sys.argv[2])

    while True:
        ret, frame = cap.read()
        results = model.track(frame, persist=True)
        res_plotted = results[0].plot()
        cv2.imshow("frame", res_plotted)

        if cv2.waitKey(1) == 27:
            break

    cap.release()
    cv2.destroyAllWindows()


if __name__ == "__main__":
    main()

भविष्यवाणी का विश्लेषण करने के लिए, आप निम्नानुसार मॉडल जेसन प्राप्त कर सकते हैं।

 results = model.track(frame, persist=True)
 results_json = json.loads(results[0].tojson())