के साथ मॉडल भविष्यवाणी Ultralytics YOLO

परिचय

मशीन लर्निंग और कंप्यूटर दृष्टि की दुनिया में, दृश्य डेटा से समझ बनाने की प्रक्रिया को 'अनुमान' या 'भविष्यवाणी' कहा जाता है। Ultralytics YOLOv8 एक शक्तिशाली सुविधा प्रदान करता है जिसे पूर्वानुमान मोड के रूप में जाना जाता है जो डेटा स्रोतों की एक विस्तृत श्रृंखला पर उच्च-प्रदर्शन, वास्तविक समय अनुमान के अनुरूप है।

सतर्कता: आउटपुट को कैसे निकालें Ultralytics YOLOv8 कस्टम परियोजनाओं के लिए मॉडल।

वास्तविक दुनिया के अनुप्रयोग

निर्माण	खेल-कूद	सुरक्षा
वाहन स्पेयर पार्ट्स का पता लगाना	फुटबॉल प्लेयर डिटेक्शन	पीपल फॉल डिटेक्शन

क्यों उपयोग करें Ultralytics YOLO अनुमान के लिए?

यहां बताया गया है कि आपको क्यों विचार करना चाहिए YOLOv8आपकी विभिन्न अनुमान आवश्यकताओं के लिए भविष्यवाणी मोड:

• बहुमुखी प्रतिभा: छवियों, वीडियो और यहां तक कि लाइव स्ट्रीम पर अनुमान लगाने में सक्षम।
• प्रदर्शन: सटीकता का त्याग किए बिना वास्तविक समय, उच्च गति प्रसंस्करण के लिए इंजीनियर।
• उपयोग में आसानी: अंतर्ज्ञानी Python और CLI तेजी से तैनाती और परीक्षण के लिए इंटरफेस।
• अत्यधिक अनुकूलन: आपकी विशिष्ट आवश्यकताओं के अनुसार मॉडल के अनुमान व्यवहार को ट्यून करने के लिए विभिन्न सेटिंग्स और पैरामीटर।

भविष्यवाणी मोड की मुख्य विशेषताएं

YOLOv8भविष्यवाणी मोड मजबूत और बहुमुखी होने के लिए डिज़ाइन किया गया है, विशेषता:

• एकाधिक डेटा स्रोत संगतता: चाहे आपका डेटा व्यक्तिगत छवियों, छवियों, वीडियो फ़ाइलों या रीयल-टाइम वीडियो स्ट्रीम के संग्रह के रूप में हो, भविष्यवाणी मोड ने आपको कवर किया है।
• स्ट्रीमिंग मोड: की मेमोरी-कुशल जनरेटर उत्पन्न करने के लिए स्ट्रीमिंग सुविधा का उपयोग करें Results वस्तुएं। सेटिंग करके इसे सक्षम करें stream=True भविष्यवक्ता की कॉल विधि में।
• बैच प्रोसेसिंग: एक ही बैच में कई छवियों या वीडियो फ़्रेमों को संसाधित करने की क्षमता, अनुमान समय को और तेज करती है।
• एकीकरण के अनुकूल: मौजूदा डेटा पाइपलाइनों और अन्य सॉफ़्टवेयर घटकों के साथ आसानी से एकीकृत करें, इसके लचीले एपीआई के लिए धन्यवाद।

Ultralytics YOLO मॉडल या तो एक लौटाते हैं Python की सूची Results ऑब्जेक्ट्स, या एक मेमोरी-कुशल Python का जनरेटर Results वस्तुओं जब stream=True अनुमान के दौरान मॉडल को पारित किया जाता है:

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.pt')  # pretrained YOLOv8n model

# Run batched inference on a list of images
results = model(['im1.jpg', 'im2.jpg'])  # return a list of Results objects

# Process results list
for result in results:
    boxes = result.boxes  # Boxes object for bounding box outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs
    obb = result.obb  # Oriented boxes object for OBB outputs
    result.show()  # display to screen
    result.save(filename='result.jpg')  # save to disk

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.pt')  # pretrained YOLOv8n model

# Run batched inference on a list of images
results = model(['im1.jpg', 'im2.jpg'], stream=True)  # return a generator of Results objects

# Process results generator
for result in results:
    boxes = result.boxes  # Boxes object for bounding box outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs
    obb = result.obb  # Oriented boxes object for OBB outputs
    result.show()  # display to screen
    result.save(filename='result.jpg')  # save to disk

अनुमान स्रोत

YOLOv8 अनुमान के लिए विभिन्न प्रकार के इनपुट स्रोतों को संसाधित कर सकते हैं, जैसा कि नीचे दी गई तालिका में दिखाया गया है। स्रोतों में स्थिर चित्र, वीडियो स्ट्रीम और विभिन्न डेटा प्रारूप शामिल हैं। तालिका यह भी इंगित करती है कि तर्क के साथ स्ट्रीमिंग मोड में प्रत्येक स्रोत का उपयोग किया जा सकता है या नहीं stream=True ✅ स्ट्रीमिंग मोड वीडियो या लाइव स्ट्रीम को संसाधित करने के लिए फायदेमंद है क्योंकि यह सभी फ़्रेमों को मेमोरी में लोड करने के बजाय परिणामों का जनरेटर बनाता है।

नीचे प्रत्येक स्रोत प्रकार का उपयोग करने के लिए कोड उदाहरण दिए गए हैं:

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Define path to the image file
source = 'path/to/image.jpg'

# Run inference on the source
results = model(source)  # list of Results objects

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Define current screenshot as source
source = 'screen'

# Run inference on the source
results = model(source)  # list of Results objects

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Define remote image or video URL
source = 'https://ultralytics.com/images/bus.jpg'

# Run inference on the source
results = model(source)  # list of Results objects

from PIL import Image
from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Open an image using PIL
source = Image.open('path/to/image.jpg')

# Run inference on the source
results = model(source)  # list of Results objects

import cv2
from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Read an image using OpenCV
source = cv2.imread('path/to/image.jpg')

# Run inference on the source
results = model(source)  # list of Results objects

import numpy as np
from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Create a random numpy array of HWC shape (640, 640, 3) with values in range [0, 255] and type uint8
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8')

# Run inference on the source
results = model(source)  # list of Results objects

import torch
from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Create a random torch tensor of BCHW shape (1, 3, 640, 640) with values in range [0, 1] and type float32
source = torch.rand(1, 3, 640, 640, dtype=torch.float32)

# Run inference on the source
results = model(source)  # list of Results objects

import torch
from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Define a path to a CSV file with images, URLs, videos and directories
source = 'path/to/file.csv'

# Run inference on the source
results = model(source)  # list of Results objects

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Define path to video file
source = 'path/to/video.mp4'

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Define path to directory containing images and videos for inference
source = 'path/to/dir'

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Define a glob search for all JPG files in a directory
source = 'path/to/dir/*.jpg'

# OR define a recursive glob search for all JPG files including subdirectories
source = 'path/to/dir/**/*.jpg'

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Define source as YouTube video URL
source = 'https://youtu.be/LNwODJXcvt4'

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Single stream with batch-size 1 inference
source = 'rtsp://example.com/media.mp4'  # RTSP, RTMP, TCP or IP streaming address

# Multiple streams with batched inference (i.e. batch-size 8 for 8 streams)
source = 'path/to/list.streams'  # *.streams text file with one streaming address per row

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

अनुमान तर्क

model.predict() कई तर्क स्वीकार करता है जिन्हें डिफ़ॉल्ट को ओवरराइड करने के लिए अनुमान समय पर पारित किया जा सकता है:

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Run inference on 'bus.jpg' with arguments
model.predict('bus.jpg', save=True, imgsz=320, conf=0.5)

अनुमान तर्क:

विज़ुअलाइज़ेशन तर्क:

छवि और वीडियो प्रारूप

YOLOv8 विभिन्न छवि और वीडियो प्रारूपों का समर्थन करता है, जैसा कि में निर्दिष्ट है ultralytics/data/utils.py का उपयोग करें। मान्य प्रत्ययों और उदाहरण पूर्वानुमान आदेशों के लिए नीचे दी गई तालिकाएँ देखें।

छवियां

नीचे दी गई तालिका में मान्य है Ultralytics छवि प्रारूप।

वीडियो

नीचे दी गई तालिका में मान्य है Ultralytics वीडियो प्रारूप।

परिणामों के साथ कार्य करना

सब Ultralytics predict() कॉल की एक सूची लौटाएगा Results वस्तुएं:

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Run inference on an image
results = model('bus.jpg')  # list of 1 Results object
results = model(['bus.jpg', 'zidane.jpg'])  # list of 2 Results objects

Results ऑब्जेक्ट्स में निम्नलिखित विशेषताएँ हैं:

Results ऑब्जेक्ट्स में निम्न विधियाँ हैं:

अधिक जानकारी के लिए देखें Results कक्षा प्रलेखन.

बक्से

Boxes ऑब्जेक्ट का उपयोग बाउंडिंग बॉक्स को विभिन्न स्वरूपों में अनुक्रमित, हेरफेर और परिवर्तित करने के लिए किया जा सकता है।

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.boxes)  # print the Boxes object containing the detection bounding boxes

यहाँ के लिए एक तालिका है Boxes वर्ग के तरीके और गुण, उनके नाम, प्रकार और विवरण सहित:

अधिक जानकारी के लिए देखें Boxes कक्षा प्रलेखन.

मास्क

Masks ऑब्जेक्ट का उपयोग किया जा सकता है, अनुक्रमित, हेरफेर और मास्क को खंडों में परिवर्तित किया जा सकता है।

from ultralytics import YOLO

# Load a pretrained YOLOv8n-seg Segment model
model = YOLO('yolov8n-seg.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.masks)  # print the Masks object containing the detected instance masks

यहाँ के लिए एक तालिका है Masks वर्ग के तरीके और गुण, उनके नाम, प्रकार और विवरण सहित:

अधिक जानकारी के लिए देखें Masks कक्षा प्रलेखन.

प्रमुख बिंदु

Keypoints ऑब्जेक्ट का उपयोग निर्देशांक को अनुक्रमित, हेरफेर और सामान्य किया जा सकता है।

from ultralytics import YOLO

# Load a pretrained YOLOv8n-pose Pose model
model = YOLO('yolov8n-pose.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.keypoints)  # print the Keypoints object containing the detected keypoints

यहाँ के लिए एक तालिका है Keypoints वर्ग के तरीके और गुण, उनके नाम, प्रकार और विवरण सहित:

अधिक जानकारी के लिए देखें Keypoints कक्षा प्रलेखन.

संभावना

Probs ऑब्जेक्ट का उपयोग सूचकांक किया जा सकता है, प्राप्त करें top1 और top5 सूचकांक और वर्गीकरण के स्कोर।

from ultralytics import YOLO

# Load a pretrained YOLOv8n-cls Classify model
model = YOLO('yolov8n-cls.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.probs)  # print the Probs object containing the detected class probabilities

यहां विधियों और गुणों को सारांशित करने वाली एक तालिका दी गई है Probs कक्षा:

अधिक जानकारी के लिए देखें Probs कक्षा प्रलेखन.

ओबीबी

OBB ऑब्जेक्ट का उपयोग ओरिएंटेड बाउंडिंग बॉक्स को विभिन्न स्वरूपों में अनुक्रमित, हेरफेर और परिवर्तित करने के लिए किया जा सकता है।

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n-obb.pt')

# Run inference on an image
results = model('bus.jpg')  # results list

# View results
for r in results:
    print(r.obb)  # print the OBB object containing the oriented detection bounding boxes

यहाँ के लिए एक तालिका है OBB वर्ग के तरीके और गुण, उनके नाम, प्रकार और विवरण सहित:

अधिक जानकारी के लिए देखें OBB कक्षा प्रलेखन.

प्लॉटिंग परिणाम

वही plot() विधि में Results ऑब्जेक्ट्स मूल छवि पर पता लगाए गए ऑब्जेक्ट्स (जैसे बाउंडिंग बॉक्स, मास्क, कीपॉइंट्स और संभावनाओं) को ओवरले करके भविष्यवाणियों के विज़ुअलाइज़ेशन की सुविधा प्रदान करते हैं। यह विधि एनोटेट की गई छवि को NumPy सरणी के रूप में लौटाती है, जिससे आसान प्रदर्शन या बचत की अनुमति मिलती है।

from PIL import Image
from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.pt')

# Run inference on 'bus.jpg'
results = model(['bus.jpg', 'zidane.jpg'])  # results list

# Visualize the results
for i, r in enumerate(results):
    # Plot results image
    im_bgr = r.plot()  # BGR-order numpy array
    im_rgb = Image.fromarray(im_bgr[..., ::-1])  # RGB-order PIL image

    # Show results to screen (in supported environments)
    r.show()

    # Save results to disk
    r.save(filename=f'results{i}.jpg')

plot() विधि पैरामीटर

वही plot() विधि आउटपुट को अनुकूलित करने के लिए विभिन्न तर्कों का समर्थन करती है:

थ्रेड-सुरक्षित अनुमान

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

उपयोग करते समय YOLO मॉडल एक बहु-थ्रेडेड एप्लिकेशन में, प्रत्येक थ्रेड के लिए अलग-अलग मॉडल ऑब्जेक्ट्स को तत्काल करना या संघर्षों को रोकने के लिए थ्रेड-लोकल स्टोरेज को नियोजित करना महत्वपूर्ण है:

from ultralytics import YOLO
from threading import Thread

def thread_safe_predict(image_path):
    """Performs thread-safe prediction on an image using a locally instantiated YOLO model."""
    local_model = YOLO("yolov8n.pt")
    results = local_model.predict(image_path)
    # Process results


# Starting threads that each have their own model instance
Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

के साथ धागा-सुरक्षित अनुमान पर गहराई से देखने के लिए YOLO मॉडल और चरण-दर-चरण निर्देश, कृपया हमारे YOLO थ्रेड-सुरक्षित अनुमान गाइड। यह मार्गदर्शिका आपको सामान्य नुकसान से बचने के लिए सभी आवश्यक जानकारी प्रदान करेगी और यह सुनिश्चित करेगी कि आपका बहु-थ्रेडेड अनुमान सुचारू रूप से चले।

स्ट्रीमिंग स्रोत for-छल्‍ला

यहाँ एक है Python ओपनसीवी का उपयोग करने वाली स्क्रिप्ट (cv2) और YOLOv8 वीडियो फ्रेम पर अनुमान चलाने के लिए। यह स्क्रिप्ट मानती है कि आपने पहले ही आवश्यक पैकेज स्थापित कर लिए हैं (opencv-python और ultralytics).

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('yolov8n.pt')

# Open the video file
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLOv8 inference on the frame
        results = model(frame)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLOv8 Inference", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

यह स्क्रिप्ट वीडियो के प्रत्येक फ्रेम पर भविष्यवाणियां चलाएगी, परिणामों की कल्पना करेगी और उन्हें एक विंडो में प्रदर्शित करेगी। लूप को 'q' दबाकर बाहर निकाला जा सकता है।

टिप्पणियाँ