सामग्री पर जाएं

के लिए संदर्भ ultralytics/engine/results.py

नोट

यह फ़ाइल यहाँ उपलब्ध है https://github.com/ultralytics/ultralytics/बूँद/मुख्य/ultralytics/इंजन/परिणाम.py। यदि आप कोई समस्या देखते हैं तो कृपया पुल अनुरोध का योगदान करके इसे ठीक करने में मदद करें 🛠️। 🙏 धन्यवाद !



ultralytics.engine.results.BaseTensor

का रूप: SimpleClass

नींव tensor आसान हेरफेर और डिवाइस हैंडलिंग के लिए अतिरिक्त तरीकों के साथ वर्ग।

में स्रोत कोड ultralytics/engine/results.py
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 454647484950 515253545556575859 60616263
class BaseTensor(SimpleClass):
    """Base tensor class with additional methods for easy manipulation and device handling."""

    def __init__(self, data, orig_shape) -> None:
        """
        Initialize BaseTensor with data and original shape.

        Args:
            data (torch.Tensor | np.ndarray): Predictions, such as bboxes, masks and keypoints.
            orig_shape (tuple): Original shape of image.
        """
        assert isinstance(data, (torch.Tensor, np.ndarray))
        self.data = data
        self.orig_shape = orig_shape

    @property
    def shape(self):
        """Return the shape of the data tensor."""
        return self.data.shape

    def cpu(self):
        """Return a copy of the tensor on CPU memory."""
        return self if isinstance(self.data, np.ndarray) else self.__class__(self.data.cpu(), self.orig_shape)

    def numpy(self):
        """Return a copy of the tensor as a numpy array."""
        return self if isinstance(self.data, np.ndarray) else self.__class__(self.data.numpy(), self.orig_shape)

    def cuda(self):
        """Return a copy of the tensor on GPU memory."""
        return self.__class__(torch.as_tensor(self.data).cuda(), self.orig_shape)

    def to(self, *args, **kwargs):
        """Return a copy of the tensor with the specified device and dtype."""
        return self.__class__(torch.as_tensor(self.data).to(*args, **kwargs), self.orig_shape)

    def __len__(self):  # override len(results)
        """Return the length of the data tensor."""
        return len(self.data)

    def __getitem__(self, idx):
        """Return a BaseTensor with the specified index of the data tensor."""
        return self.__class__(self.data[idx], self.orig_shape)

shape property

डेटा का आकार लौटाना tensor.

__getitem__(idx)

डेटा के निर्दिष्ट सूचकांक के साथ एक BaseTensor लौटाएं tensor.

में स्रोत कोड ultralytics/engine/results.py
def __getitem__(self, idx):
    """Return a BaseTensor with the specified index of the data tensor."""
    return self.__class__(self.data[idx], self.orig_shape)

__init__(data, orig_shape)

डेटा और मूल आकार के साथ BaseTensor को प्रारंभ करें।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
data Tensor | ndarray

भविष्यवाणियां, जैसे bboxes, मास्क और कीपॉइंट।

आवश्यक
orig_shape tuple

छवि का मूल आकार।

आवश्यक
में स्रोत कोड ultralytics/engine/results.py
def __init__(self, data, orig_shape) -> None:
    """
    Initialize BaseTensor with data and original shape.

    Args:
        data (torch.Tensor | np.ndarray): Predictions, such as bboxes, masks and keypoints.
        orig_shape (tuple): Original shape of image.
    """
    assert isinstance(data, (torch.Tensor, np.ndarray))
    self.data = data
    self.orig_shape = orig_shape

__len__()

डेटा की लंबाई लौटाएं tensor.

में स्रोत कोड ultralytics/engine/results.py
def __len__(self):  # override len(results)
    """Return the length of the data tensor."""
    return len(self.data)

cpu()

की एक प्रति लौटाएं tensor CPU मेमोरी पर।

में स्रोत कोड ultralytics/engine/results.py
def cpu(self):
    """Return a copy of the tensor on CPU memory."""
    return self if isinstance(self.data, np.ndarray) else self.__class__(self.data.cpu(), self.orig_shape)

cuda()

की एक प्रति लौटाएं tensor GPU मेमोरी पर।

में स्रोत कोड ultralytics/engine/results.py
def cuda(self):
    """Return a copy of the tensor on GPU memory."""
    return self.__class__(torch.as_tensor(self.data).cuda(), self.orig_shape)

numpy()

की एक प्रति लौटाएं tensor एक सुन्न सरणी के रूप में।

में स्रोत कोड ultralytics/engine/results.py
def numpy(self):
    """Return a copy of the tensor as a numpy array."""
    return self if isinstance(self.data, np.ndarray) else self.__class__(self.data.numpy(), self.orig_shape)

to(*args, **kwargs)

की एक प्रति लौटाएं tensor निर्दिष्ट डिवाइस और dType के साथ।

में स्रोत कोड ultralytics/engine/results.py
def to(self, *args, **kwargs):
    """Return a copy of the tensor with the specified device and dtype."""
    return self.__class__(torch.as_tensor(self.data).to(*args, **kwargs), self.orig_shape)



ultralytics.engine.results.Results

का रूप: SimpleClass

अनुमान परिणामों के भंडारण और हेरफेर के लिए एक वर्ग।

विशेषताएँ:

नाम प्रकार विवरण: __________
orig_img ndarray

एक सुन्न सरणी के रूप में मूल छवि।

orig_shape tuple

मूल छवि आकृति (ऊँचाई, चौड़ाई) स्वरूप में.

boxes Boxes

डिटेक्शन बाउंडिंग बॉक्स वाली ऑब्जेक्ट।

masks Masks

डिटेक्शन मास्क युक्त वस्तु।

probs Probs

वर्गीकरण कार्यों के लिए वर्ग संभावनाओं वाली वस्तु।

keypoints Keypoints

ऑब्जेक्ट जिसमें प्रत्येक ऑब्जेक्ट के लिए पता लगाया गया कीपॉइंट है।

speed dict

प्रीप्रोसेस, अनुमान और पोस्टप्रोसेस गति का शब्दकोश (एमएस /

names dict

वर्ग के नामों का शब्दकोश।

path str

छवि फ़ाइल का पथ.

विधियाँ:

नाम विवरण: __________
update

ऑब्जेक्ट विशेषताओं को नए डिटेक्शन परिणामों के साथ अपडेट करता है।

cpu

CPU स्मृति पर सभी टेंसर के साथ परिणाम ऑब्जेक्ट की एक प्रतिलिपि देता है।

numpy

परिणाम ऑब्जेक्ट की एक प्रतिलिपि सभी टेंसर के साथ numpy सरणियों के रूप में लौटाता है।

cuda

GPU स्मृति पर सभी टेंसर के साथ परिणाम ऑब्जेक्ट की एक प्रतिलिपि देता है।

to

परिणाम ऑब्जेक्ट की एक प्रतिलिपि किसी निर्दिष्ट डिवाइस और dtype पर टेंसर के साथ लौटाता है.

new

समान छवि, पथ और नामों के साथ एक नया परिणाम ऑब्जेक्ट लौटाता है.

plot

एक इनपुट छवि पर प्लॉट का पता लगाने का परिणाम है, एक एनोटेट की गई छवि लौटाता है।

show

स्क्रीन पर एनोटेट किए गए परिणाम दिखाएं।

save

एनोटेट किए गए परिणामों को फ़ाइल में सहेजें।

verbose

प्रत्येक कार्य के लिए एक लॉग स्ट्रिंग देता है, डिटेक्शन और वर्गीकरण का विवरण देता है।

save_txt

पता लगाने के परिणामों को एक पाठ फ़ाइल में सहेजता है।

save_crop

फसली पहचान छवियों को सहेजता है।

tojson

पता लगाने के परिणामों को JSON प्रारूप में कनवर्ट करता है।

में स्रोत कोड ultralytics/engine/results.py
class Results(SimpleClass):
    """
    A class for storing and manipulating inference results.

    Attributes:
        orig_img (numpy.ndarray): Original image as a numpy array.
        orig_shape (tuple): Original image shape in (height, width) format.
        boxes (Boxes, optional): Object containing detection bounding boxes.
        masks (Masks, optional): Object containing detection masks.
        probs (Probs, optional): Object containing class probabilities for classification tasks.
        keypoints (Keypoints, optional): Object containing detected keypoints for each object.
        speed (dict): Dictionary of preprocess, inference, and postprocess speeds (ms/image).
        names (dict): Dictionary of class names.
        path (str): Path to the image file.

    Methods:
        update(boxes=None, masks=None, probs=None, obb=None): Updates object attributes with new detection results.
        cpu(): Returns a copy of the Results object with all tensors on CPU memory.
        numpy(): Returns a copy of the Results object with all tensors as numpy arrays.
        cuda(): Returns a copy of the Results object with all tensors on GPU memory.
        to(*args, **kwargs): Returns a copy of the Results object with tensors on a specified device and dtype.
        new(): Returns a new Results object with the same image, path, and names.
        plot(...): Plots detection results on an input image, returning an annotated image.
        show(): Show annotated results to screen.
        save(filename): Save annotated results to file.
        verbose(): Returns a log string for each task, detailing detections and classifications.
        save_txt(txt_file, save_conf=False): Saves detection results to a text file.
        save_crop(save_dir, file_name=Path("im.jpg")): Saves cropped detection images.
        tojson(normalize=False): Converts detection results to JSON format.
    """

    def __init__(self, orig_img, path, names, boxes=None, masks=None, probs=None, keypoints=None, obb=None) -> None:
        """
        Initialize the Results class.

        Args:
            orig_img (numpy.ndarray): The original image as a numpy array.
            path (str): The path to the image file.
            names (dict): A dictionary of class names.
            boxes (torch.tensor, optional): A 2D tensor of bounding box coordinates for each detection.
            masks (torch.tensor, optional): A 3D tensor of detection masks, where each mask is a binary image.
            probs (torch.tensor, optional): A 1D tensor of probabilities of each class for classification task.
            keypoints (torch.tensor, optional): A 2D tensor of keypoint coordinates for each detection.
            obb (torch.tensor, optional): A 2D tensor of oriented bounding box coordinates for each detection.
        """
        self.orig_img = orig_img
        self.orig_shape = orig_img.shape[:2]
        self.boxes = Boxes(boxes, self.orig_shape) if boxes is not None else None  # native size boxes
        self.masks = Masks(masks, self.orig_shape) if masks is not None else None  # native size or imgsz masks
        self.probs = Probs(probs) if probs is not None else None
        self.keypoints = Keypoints(keypoints, self.orig_shape) if keypoints is not None else None
        self.obb = OBB(obb, self.orig_shape) if obb is not None else None
        self.speed = {"preprocess": None, "inference": None, "postprocess": None}  # milliseconds per image
        self.names = names
        self.path = path
        self.save_dir = None
        self._keys = "boxes", "masks", "probs", "keypoints", "obb"

    def __getitem__(self, idx):
        """Return a Results object for the specified index."""
        return self._apply("__getitem__", idx)

    def __len__(self):
        """Return the number of detections in the Results object."""
        for k in self._keys:
            v = getattr(self, k)
            if v is not None:
                return len(v)

    def update(self, boxes=None, masks=None, probs=None, obb=None):
        """Update the boxes, masks, and probs attributes of the Results object."""
        if boxes is not None:
            self.boxes = Boxes(ops.clip_boxes(boxes, self.orig_shape), self.orig_shape)
        if masks is not None:
            self.masks = Masks(masks, self.orig_shape)
        if probs is not None:
            self.probs = probs
        if obb is not None:
            self.obb = OBB(obb, self.orig_shape)

    def _apply(self, fn, *args, **kwargs):
        """
        Applies a function to all non-empty attributes and returns a new Results object with modified attributes. This
        function is internally called by methods like .to(), .cuda(), .cpu(), etc.

        Args:
            fn (str): The name of the function to apply.
            *args: Variable length argument list to pass to the function.
            **kwargs: Arbitrary keyword arguments to pass to the function.

        Returns:
            Results: A new Results object with attributes modified by the applied function.
        """
        r = self.new()
        for k in self._keys:
            v = getattr(self, k)
            if v is not None:
                setattr(r, k, getattr(v, fn)(*args, **kwargs))
        return r

    def cpu(self):
        """Return a copy of the Results object with all tensors on CPU memory."""
        return self._apply("cpu")

    def numpy(self):
        """Return a copy of the Results object with all tensors as numpy arrays."""
        return self._apply("numpy")

    def cuda(self):
        """Return a copy of the Results object with all tensors on GPU memory."""
        return self._apply("cuda")

    def to(self, *args, **kwargs):
        """Return a copy of the Results object with tensors on the specified device and dtype."""
        return self._apply("to", *args, **kwargs)

    def new(self):
        """Return a new Results object with the same image, path, and names."""
        return Results(orig_img=self.orig_img, path=self.path, names=self.names)

    def plot(
        self,
        conf=True,
        line_width=None,
        font_size=None,
        font="Arial.ttf",
        pil=False,
        img=None,
        im_gpu=None,
        kpt_radius=5,
        kpt_line=True,
        labels=True,
        boxes=True,
        masks=True,
        probs=True,
        show=False,
        save=False,
        filename=None,
    ):
        """
        Plots the detection results on an input RGB image. Accepts a numpy array (cv2) or a PIL Image.

        Args:
            conf (bool): Whether to plot the detection confidence score.
            line_width (float, optional): The line width of the bounding boxes. If None, it is scaled to the image size.
            font_size (float, optional): The font size of the text. If None, it is scaled to the image size.
            font (str): The font to use for the text.
            pil (bool): Whether to return the image as a PIL Image.
            img (numpy.ndarray): Plot to another image. if not, plot to original image.
            im_gpu (torch.Tensor): Normalized image in gpu with shape (1, 3, 640, 640), for faster mask plotting.
            kpt_radius (int, optional): Radius of the drawn keypoints. Default is 5.
            kpt_line (bool): Whether to draw lines connecting keypoints.
            labels (bool): Whether to plot the label of bounding boxes.
            boxes (bool): Whether to plot the bounding boxes.
            masks (bool): Whether to plot the masks.
            probs (bool): Whether to plot classification probability
            show (bool): Whether to display the annotated image directly.
            save (bool): Whether to save the annotated image to `filename`.
            filename (str): Filename to save image to if save is True.

        Returns:
            (numpy.ndarray): A numpy array of the annotated image.

        Example:
            ```python
            from PIL import Image
            from ultralytics import YOLO

            model = YOLO('yolov8n.pt')
            results = model('bus.jpg')  # results list
            for r in results:
                im_array = r.plot()  # plot a BGR numpy array of predictions
                im = Image.fromarray(im_array[..., ::-1])  # RGB PIL image
                im.show()  # show image
                im.save('results.jpg')  # save image
            ```
        """
        if img is None and isinstance(self.orig_img, torch.Tensor):
            img = (self.orig_img[0].detach().permute(1, 2, 0).contiguous() * 255).to(torch.uint8).cpu().numpy()

        names = self.names
        is_obb = self.obb is not None
        pred_boxes, show_boxes = self.obb if is_obb else self.boxes, boxes
        pred_masks, show_masks = self.masks, masks
        pred_probs, show_probs = self.probs, probs
        annotator = Annotator(
            deepcopy(self.orig_img if img is None else img),
            line_width,
            font_size,
            font,
            pil or (pred_probs is not None and show_probs),  # Classify tasks default to pil=True
            example=names,
        )

        # Plot Segment results
        if pred_masks and show_masks:
            if im_gpu is None:
                img = LetterBox(pred_masks.shape[1:])(image=annotator.result())
                im_gpu = (
                    torch.as_tensor(img, dtype=torch.float16, device=pred_masks.data.device)
                    .permute(2, 0, 1)
                    .flip(0)
                    .contiguous()
                    / 255
                )
            idx = pred_boxes.cls if pred_boxes else range(len(pred_masks))
            annotator.masks(pred_masks.data, colors=[colors(x, True) for x in idx], im_gpu=im_gpu)

        # Plot Detect results
        if pred_boxes is not None and show_boxes:
            for d in reversed(pred_boxes):
                c, conf, id = int(d.cls), float(d.conf) if conf else None, None if d.id is None else int(d.id.item())
                name = ("" if id is None else f"id:{id} ") + names[c]
                label = (f"{name} {conf:.2f}" if conf else name) if labels else None
                box = d.xyxyxyxy.reshape(-1, 4, 2).squeeze() if is_obb else d.xyxy.squeeze()
                annotator.box_label(box, label, color=colors(c, True), rotated=is_obb)

        # Plot Classify results
        if pred_probs is not None and show_probs:
            text = ",\n".join(f"{names[j] if names else j} {pred_probs.data[j]:.2f}" for j in pred_probs.top5)
            x = round(self.orig_shape[0] * 0.03)
            annotator.text([x, x], text, txt_color=(255, 255, 255))  # TODO: allow setting colors

        # Plot Pose results
        if self.keypoints is not None:
            for k in reversed(self.keypoints.data):
                annotator.kpts(k, self.orig_shape, radius=kpt_radius, kpt_line=kpt_line)

        # Show results
        if show:
            annotator.show(self.path)

        # Save results
        if save:
            annotator.save(filename)

        return annotator.result()

    def show(self, *args, **kwargs):
        """Show annotated results image."""
        self.plot(show=True, *args, **kwargs)

    def save(self, filename=None, *args, **kwargs):
        """Save annotated results image."""
        if not filename:
            filename = f"results_{Path(self.path).name}"
        self.plot(save=True, filename=filename, *args, **kwargs)
        return filename

    def verbose(self):
        """Return log string for each task."""
        log_string = ""
        probs = self.probs
        boxes = self.boxes
        if len(self) == 0:
            return log_string if probs is not None else f"{log_string}(no detections), "
        if probs is not None:
            log_string += f"{', '.join(f'{self.names[j]} {probs.data[j]:.2f}' for j in probs.top5)}, "
        if boxes:
            for c in boxes.cls.unique():
                n = (boxes.cls == c).sum()  # detections per class
                log_string += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, "
        return log_string

    def save_txt(self, txt_file, save_conf=False):
        """
        Save predictions into txt file.

        Args:
            txt_file (str): txt file path.
            save_conf (bool): save confidence score or not.
        """
        is_obb = self.obb is not None
        boxes = self.obb if is_obb else self.boxes
        masks = self.masks
        probs = self.probs
        kpts = self.keypoints
        texts = []
        if probs is not None:
            # Classify
            [texts.append(f"{probs.data[j]:.2f} {self.names[j]}") for j in probs.top5]
        elif boxes:
            # Detect/segment/pose
            for j, d in enumerate(boxes):
                c, conf, id = int(d.cls), float(d.conf), None if d.id is None else int(d.id.item())
                line = (c, *(d.xyxyxyxyn.view(-1) if is_obb else d.xywhn.view(-1)))
                if masks:
                    seg = masks[j].xyn[0].copy().reshape(-1)  # reversed mask.xyn, (n,2) to (n*2)
                    line = (c, *seg)
                if kpts is not None:
                    kpt = torch.cat((kpts[j].xyn, kpts[j].conf[..., None]), 2) if kpts[j].has_visible else kpts[j].xyn
                    line += (*kpt.reshape(-1).tolist(),)
                line += (conf,) * save_conf + (() if id is None else (id,))
                texts.append(("%g " * len(line)).rstrip() % line)

        if texts:
            Path(txt_file).parent.mkdir(parents=True, exist_ok=True)  # make directory
            with open(txt_file, "a") as f:
                f.writelines(text + "\n" for text in texts)

    def save_crop(self, save_dir, file_name=Path("im.jpg")):
        """
        Save cropped predictions to `save_dir/cls/file_name.jpg`.

        Args:
            save_dir (str | pathlib.Path): Save path.
            file_name (str | pathlib.Path): File name.
        """
        if self.probs is not None:
            LOGGER.warning("WARNING ⚠️ Classify task do not support `save_crop`.")
            return
        if self.obb is not None:
            LOGGER.warning("WARNING ⚠️ OBB task do not support `save_crop`.")
            return
        for d in self.boxes:
            save_one_box(
                d.xyxy,
                self.orig_img.copy(),
                file=Path(save_dir) / self.names[int(d.cls)] / f"{Path(file_name)}.jpg",
                BGR=True,
            )

    def tojson(self, normalize=False):
        """Convert the object to JSON format."""
        if self.probs is not None:
            LOGGER.warning("Warning: Classify task do not support `tojson` yet.")
            return

        import json

        # Create list of detection dictionaries
        results = []
        data = self.boxes.data.cpu().tolist()
        h, w = self.orig_shape if normalize else (1, 1)
        for i, row in enumerate(data):  # xyxy, track_id if tracking, conf, class_id
            box = {"x1": row[0] / w, "y1": row[1] / h, "x2": row[2] / w, "y2": row[3] / h}
            conf = row[-2]
            class_id = int(row[-1])
            name = self.names[class_id]
            result = {"name": name, "class": class_id, "confidence": conf, "box": box}
            if self.boxes.is_track:
                result["track_id"] = int(row[-3])  # track ID
            if self.masks:
                x, y = self.masks.xy[i][:, 0], self.masks.xy[i][:, 1]  # numpy array
                result["segments"] = {"x": (x / w).tolist(), "y": (y / h).tolist()}
            if self.keypoints is not None:
                x, y, visible = self.keypoints[i].data[0].cpu().unbind(dim=1)  # torch Tensor
                result["keypoints"] = {"x": (x / w).tolist(), "y": (y / h).tolist(), "visible": visible.tolist()}
            results.append(result)

        # Convert detections to JSON
        return json.dumps(results, indent=2)

__getitem__(idx)

निर्दिष्ट अनुक्रमणिका के लिए परिणाम ऑब्जेक्ट लौटाएँ.

में स्रोत कोड ultralytics/engine/results.py
def __getitem__(self, idx):
    """Return a Results object for the specified index."""
    return self._apply("__getitem__", idx)

__init__(orig_img, path, names, boxes=None, masks=None, probs=None, keypoints=None, obb=None)

परिणाम वर्ग को प्रारंभ करें।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
orig_img ndarray

एक numpy सरणी के रूप में मूल छवि।

आवश्यक
path str

छवि फ़ाइल का पथ.

आवश्यक
names dict

वर्ग के नामों का एक शब्दकोश।

आवश्यक
boxes tensor

एक 2 डी tensor प्रत्येक पहचान के लिए बाउंडिंग बॉक्स निर्देशांक की।

None
masks tensor

एक 3 डी tensor डिटेक्शन मास्क की, जहां प्रत्येक मास्क एक बाइनरी इमेज है।

None
probs tensor

एक 1 डी tensor वर्गीकरण कार्य के लिए प्रत्येक वर्ग की संभावनाओं का।

None
keypoints tensor

एक 2 डी tensor प्रत्येक पहचान के लिए कीपॉइंट निर्देशांक का।

None
obb tensor

एक 2 डी tensor प्रत्येक पहचान के लिए उन्मुख बाउंडिंग बॉक्स निर्देशांक का।

None
में स्रोत कोड ultralytics/engine/results.py
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121122
def __init__(self, orig_img, path, names, boxes=None, masks=None, probs=None, keypoints=None, obb=None) -> None:
    """
    Initialize the Results class.

    Args:
        orig_img (numpy.ndarray): The original image as a numpy array.
        path (str): The path to the image file.
        names (dict): A dictionary of class names.
        boxes (torch.tensor, optional): A 2D tensor of bounding box coordinates for each detection.
        masks (torch.tensor, optional): A 3D tensor of detection masks, where each mask is a binary image.
        probs (torch.tensor, optional): A 1D tensor of probabilities of each class for classification task.
        keypoints (torch.tensor, optional): A 2D tensor of keypoint coordinates for each detection.
        obb (torch.tensor, optional): A 2D tensor of oriented bounding box coordinates for each detection.
    """
    self.orig_img = orig_img
    self.orig_shape = orig_img.shape[:2]
    self.boxes = Boxes(boxes, self.orig_shape) if boxes is not None else None  # native size boxes
    self.masks = Masks(masks, self.orig_shape) if masks is not None else None  # native size or imgsz masks
    self.probs = Probs(probs) if probs is not None else None
    self.keypoints = Keypoints(keypoints, self.orig_shape) if keypoints is not None else None
    self.obb = OBB(obb, self.orig_shape) if obb is not None else None
    self.speed = {"preprocess": None, "inference": None, "postprocess": None}  # milliseconds per image
    self.names = names
    self.path = path
    self.save_dir = None
    self._keys = "boxes", "masks", "probs", "keypoints", "obb"

__len__()

परिणाम ऑब्जेक्ट में डिटेक्शन की संख्या लौटाएं।

में स्रोत कोड ultralytics/engine/results.py
def __len__(self):
    """Return the number of detections in the Results object."""
    for k in self._keys:
        v = getattr(self, k)
        if v is not None:
            return len(v)

cpu()

CPU स्मृति पर सभी टेंसर के साथ परिणाम ऑब्जेक्ट की एक प्रतिलिपि लौटाएं।

में स्रोत कोड ultralytics/engine/results.py
def cpu(self):
    """Return a copy of the Results object with all tensors on CPU memory."""
    return self._apply("cpu")

cuda()

GPU स्मृति पर सभी टेंसर के साथ परिणाम ऑब्जेक्ट की एक प्रतिलिपि लौटाएं।

में स्रोत कोड ultralytics/engine/results.py
def cuda(self):
    """Return a copy of the Results object with all tensors on GPU memory."""
    return self._apply("cuda")

new()

समान छवि, पथ और नामों के साथ एक नया परिणाम ऑब्जेक्ट लौटाएं।

में स्रोत कोड ultralytics/engine/results.py
def new(self):
    """Return a new Results object with the same image, path, and names."""
    return Results(orig_img=self.orig_img, path=self.path, names=self.names)

numpy()

परिणाम ऑब्जेक्ट की एक प्रतिलिपि को सभी टेंसर के साथ numpy सरणियों के रूप में लौटाएं।

में स्रोत कोड ultralytics/engine/results.py
def numpy(self):
    """Return a copy of the Results object with all tensors as numpy arrays."""
    return self._apply("numpy")

plot(conf=True, line_width=None, font_size=None, font='Arial.ttf', pil=False, img=None, im_gpu=None, kpt_radius=5, kpt_line=True, labels=True, boxes=True, masks=True, probs=True, show=False, save=False, filename=None)

इनपुट RGB छवि पर पता लगाने के परिणामों को प्लॉट करता है। एक numpy सरणी (cv2) या एक PIL छवि स्वीकार करता है।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
conf bool

क्या डिटेक्शन कॉन्फिडेंस स्कोर को प्लॉट करना है।

True
line_width float

बाउंडिंग बॉक्स की लाइन चौड़ाई। यदि कोई नहीं, तो इसे छवि आकार तक बढ़ाया जाता है।

None
font_size float

पाठ का फ़ॉन्ट आकार. यदि कोई नहीं, तो इसे छवि आकार तक बढ़ाया जाता है।

None
font str

पाठ के लिए उपयोग किया जाने वाला फ़ॉन्ट.

'Arial.ttf'
pil bool

छवि को पीआईएल छवि के रूप में वापस करना है या नहीं।

False
img ndarray

किसी अन्य छवि के लिए प्लॉट करें। यदि नहीं, तो मूल छवि के लिए प्लॉट करें।

None
im_gpu Tensor

तेजी से मुखौटा साजिश रचने के लिए आकार (1, 3, 640, 640) के साथ GPU में सामान्यीकृत छवि।

None
kpt_radius int

खींचे गए कीपॉइंट्स की त्रिज्या। डिफ़ॉल्ट 5 है।

5
kpt_line bool

क्या कीपॉइंट्स को जोड़ने वाली रेखाएँ खींचनी हैं।

True
labels bool

चाहे बाउंडिंग बॉक्स के लेबल को प्लॉट करना हो।

True
boxes bool

चाहे बाउंडिंग बॉक्स की साजिश रची जाए।

True
masks bool

चाहे मास्क की साजिश रची जाए।

True
probs bool

वर्गीकरण की संभावना की साजिश रची जाए या नहीं

True
show bool

एनोटेट की गई छवि को सीधे प्रदर्शित करना है या नहीं।

False
save bool

एनोटेट की गई छवि को सहेजने के लिए या नहीं filename.

False
filename str

छवि को सहेजने के लिए फ़ाइल नाम यदि सहेजें सत्य है।

None

देता:

प्रकार विवरण: __________
ndarray

एनोटेट की गई छवि की एक सुन्न सरणी।

उदाहरण
from PIL import Image
from ultralytics import YOLO

model = YOLO('yolov8n.pt')
results = model('bus.jpg')  # results list
for r in results:
    im_array = r.plot()  # plot a BGR numpy array of predictions
    im = Image.fromarray(im_array[..., ::-1])  # RGB PIL image
    im.show()  # show image
    im.save('results.jpg')  # save image
में स्रोत कोड ultralytics/engine/results.py
def plot(
    self,
    conf=True,
    line_width=None,
    font_size=None,
    font="Arial.ttf",
    pil=False,
    img=None,
    im_gpu=None,
    kpt_radius=5,
    kpt_line=True,
    labels=True,
    boxes=True,
    masks=True,
    probs=True,
    show=False,
    save=False,
    filename=None,
):
    """
    Plots the detection results on an input RGB image. Accepts a numpy array (cv2) or a PIL Image.

    Args:
        conf (bool): Whether to plot the detection confidence score.
        line_width (float, optional): The line width of the bounding boxes. If None, it is scaled to the image size.
        font_size (float, optional): The font size of the text. If None, it is scaled to the image size.
        font (str): The font to use for the text.
        pil (bool): Whether to return the image as a PIL Image.
        img (numpy.ndarray): Plot to another image. if not, plot to original image.
        im_gpu (torch.Tensor): Normalized image in gpu with shape (1, 3, 640, 640), for faster mask plotting.
        kpt_radius (int, optional): Radius of the drawn keypoints. Default is 5.
        kpt_line (bool): Whether to draw lines connecting keypoints.
        labels (bool): Whether to plot the label of bounding boxes.
        boxes (bool): Whether to plot the bounding boxes.
        masks (bool): Whether to plot the masks.
        probs (bool): Whether to plot classification probability
        show (bool): Whether to display the annotated image directly.
        save (bool): Whether to save the annotated image to `filename`.
        filename (str): Filename to save image to if save is True.

    Returns:
        (numpy.ndarray): A numpy array of the annotated image.

    Example:
        ```python
        from PIL import Image
        from ultralytics import YOLO

        model = YOLO('yolov8n.pt')
        results = model('bus.jpg')  # results list
        for r in results:
            im_array = r.plot()  # plot a BGR numpy array of predictions
            im = Image.fromarray(im_array[..., ::-1])  # RGB PIL image
            im.show()  # show image
            im.save('results.jpg')  # save image
        ```
    """
    if img is None and isinstance(self.orig_img, torch.Tensor):
        img = (self.orig_img[0].detach().permute(1, 2, 0).contiguous() * 255).to(torch.uint8).cpu().numpy()

    names = self.names
    is_obb = self.obb is not None
    pred_boxes, show_boxes = self.obb if is_obb else self.boxes, boxes
    pred_masks, show_masks = self.masks, masks
    pred_probs, show_probs = self.probs, probs
    annotator = Annotator(
        deepcopy(self.orig_img if img is None else img),
        line_width,
        font_size,
        font,
        pil or (pred_probs is not None and show_probs),  # Classify tasks default to pil=True
        example=names,
    )

    # Plot Segment results
    if pred_masks and show_masks:
        if im_gpu is None:
            img = LetterBox(pred_masks.shape[1:])(image=annotator.result())
            im_gpu = (
                torch.as_tensor(img, dtype=torch.float16, device=pred_masks.data.device)
                .permute(2, 0, 1)
                .flip(0)
                .contiguous()
                / 255
            )
        idx = pred_boxes.cls if pred_boxes else range(len(pred_masks))
        annotator.masks(pred_masks.data, colors=[colors(x, True) for x in idx], im_gpu=im_gpu)

    # Plot Detect results
    if pred_boxes is not None and show_boxes:
        for d in reversed(pred_boxes):
            c, conf, id = int(d.cls), float(d.conf) if conf else None, None if d.id is None else int(d.id.item())
            name = ("" if id is None else f"id:{id} ") + names[c]
            label = (f"{name} {conf:.2f}" if conf else name) if labels else None
            box = d.xyxyxyxy.reshape(-1, 4, 2).squeeze() if is_obb else d.xyxy.squeeze()
            annotator.box_label(box, label, color=colors(c, True), rotated=is_obb)

    # Plot Classify results
    if pred_probs is not None and show_probs:
        text = ",\n".join(f"{names[j] if names else j} {pred_probs.data[j]:.2f}" for j in pred_probs.top5)
        x = round(self.orig_shape[0] * 0.03)
        annotator.text([x, x], text, txt_color=(255, 255, 255))  # TODO: allow setting colors

    # Plot Pose results
    if self.keypoints is not None:
        for k in reversed(self.keypoints.data):
            annotator.kpts(k, self.orig_shape, radius=kpt_radius, kpt_line=kpt_line)

    # Show results
    if show:
        annotator.show(self.path)

    # Save results
    if save:
        annotator.save(filename)

    return annotator.result()

save(filename=None, *args, **kwargs)

एनोटेट किए गए परिणाम छवि सहेजें।

में स्रोत कोड ultralytics/engine/results.py
308 309 310 311 312313
def save(self, filename=None, *args, **kwargs):
    """Save annotated results image."""
    if not filename:
        filename = f"results_{Path(self.path).name}"
    self.plot(save=True, filename=filename, *args, **kwargs)
    return filename

save_crop(save_dir, file_name=Path('im.jpg'))

फसली पूर्वानुमानों को इन पर सहेजें save_dir/cls/file_name.jpg.

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
save_dir str | Path

रास्ता बचाओ।

आवश्यक
file_name str | Path

फ़ाइल का नाम.

Path('im.jpg')
में स्रोत कोड ultralytics/engine/results.py
366 367 368 369 370 371 372 373 374 375 376 377 378379380 381 382 383 384 385 386
def save_crop(self, save_dir, file_name=Path("im.jpg")):
    """
    Save cropped predictions to `save_dir/cls/file_name.jpg`.

    Args:
        save_dir (str | pathlib.Path): Save path.
        file_name (str | pathlib.Path): File name.
    """
    if self.probs is not None:
        LOGGER.warning("WARNING ⚠️ Classify task do not support `save_crop`.")
        return
    if self.obb is not None:
        LOGGER.warning("WARNING ⚠️ OBB task do not support `save_crop`.")
        return
    for d in self.boxes:
        save_one_box(
            d.xyxy,
            self.orig_img.copy(),
            file=Path(save_dir) / self.names[int(d.cls)] / f"{Path(file_name)}.jpg",
            BGR=True,
        )

save_txt(txt_file, save_conf=False)

txt फ़ाइल में भविष्यवाणियों सहेजें.

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
txt_file str

txt फ़ाइल पथ।

आवश्यक
save_conf bool

कॉन्फिडेंस स्कोर सेव करें या नहीं।

False
में स्रोत कोड ultralytics/engine/results.py
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349350 351 352 353 354 355 356 357 358 359360 361 362363 364
def save_txt(self, txt_file, save_conf=False):
    """
    Save predictions into txt file.

    Args:
        txt_file (str): txt file path.
        save_conf (bool): save confidence score or not.
    """
    is_obb = self.obb is not None
    boxes = self.obb if is_obb else self.boxes
    masks = self.masks
    probs = self.probs
    kpts = self.keypoints
    texts = []
    if probs is not None:
        # Classify
        [texts.append(f"{probs.data[j]:.2f} {self.names[j]}") for j in probs.top5]
    elif boxes:
        # Detect/segment/pose
        for j, d in enumerate(boxes):
            c, conf, id = int(d.cls), float(d.conf), None if d.id is None else int(d.id.item())
            line = (c, *(d.xyxyxyxyn.view(-1) if is_obb else d.xywhn.view(-1)))
            if masks:
                seg = masks[j].xyn[0].copy().reshape(-1)  # reversed mask.xyn, (n,2) to (n*2)
                line = (c, *seg)
            if kpts is not None:
                kpt = torch.cat((kpts[j].xyn, kpts[j].conf[..., None]), 2) if kpts[j].has_visible else kpts[j].xyn
                line += (*kpt.reshape(-1).tolist(),)
            line += (conf,) * save_conf + (() if id is None else (id,))
            texts.append(("%g " * len(line)).rstrip() % line)

    if texts:
        Path(txt_file).parent.mkdir(parents=True, exist_ok=True)  # make directory
        with open(txt_file, "a") as f:
            f.writelines(text + "\n" for text in texts)

show(*args, **kwargs)

एनोटेट किए गए परिणाम छवि दिखाएं।

में स्रोत कोड ultralytics/engine/results.py
def show(self, *args, **kwargs):
    """Show annotated results image."""
    self.plot(show=True, *args, **kwargs)

to(*args, **kwargs)

निर्दिष्ट डिवाइस और dtype पर टेंसर के साथ परिणाम ऑब्जेक्ट की एक प्रति लौटाएं।

में स्रोत कोड ultralytics/engine/results.py
def to(self, *args, **kwargs):
    """Return a copy of the Results object with tensors on the specified device and dtype."""
    return self._apply("to", *args, **kwargs)

tojson(normalize=False)

ऑब्जेक्ट को JSON प्रारूप में कनवर्ट करें।

में स्रोत कोड ultralytics/engine/results.py
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408409 410 411 412 413 414 415416417
def tojson(self, normalize=False):
    """Convert the object to JSON format."""
    if self.probs is not None:
        LOGGER.warning("Warning: Classify task do not support `tojson` yet.")
        return

    import json

    # Create list of detection dictionaries
    results = []
    data = self.boxes.data.cpu().tolist()
    h, w = self.orig_shape if normalize else (1, 1)
    for i, row in enumerate(data):  # xyxy, track_id if tracking, conf, class_id
        box = {"x1": row[0] / w, "y1": row[1] / h, "x2": row[2] / w, "y2": row[3] / h}
        conf = row[-2]
        class_id = int(row[-1])
        name = self.names[class_id]
        result = {"name": name, "class": class_id, "confidence": conf, "box": box}
        if self.boxes.is_track:
            result["track_id"] = int(row[-3])  # track ID
        if self.masks:
            x, y = self.masks.xy[i][:, 0], self.masks.xy[i][:, 1]  # numpy array
            result["segments"] = {"x": (x / w).tolist(), "y": (y / h).tolist()}
        if self.keypoints is not None:
            x, y, visible = self.keypoints[i].data[0].cpu().unbind(dim=1)  # torch Tensor
            result["keypoints"] = {"x": (x / w).tolist(), "y": (y / h).tolist(), "visible": visible.tolist()}
        results.append(result)

    # Convert detections to JSON
    return json.dumps(results, indent=2)

update(boxes=None, masks=None, probs=None, obb=None)

परिणाम ऑब्जेक्ट के बॉक्स, मास्क और जांच विशेषताओं को अपडेट करें।

में स्रोत कोड ultralytics/engine/results.py
135 136 137 138 139 140 141 142 143 144
def update(self, boxes=None, masks=None, probs=None, obb=None):
    """Update the boxes, masks, and probs attributes of the Results object."""
    if boxes is not None:
        self.boxes = Boxes(ops.clip_boxes(boxes, self.orig_shape), self.orig_shape)
    if masks is not None:
        self.masks = Masks(masks, self.orig_shape)
    if probs is not None:
        self.probs = probs
    if obb is not None:
        self.obb = OBB(obb, self.orig_shape)

verbose()

प्रत्येक कार्य के लिए लॉग स्ट्रिंग लौटाएं।

में स्रोत कोड ultralytics/engine/results.py
315 316 317 318 319320 321 322 323 324 325 326 327 328
def verbose(self):
    """Return log string for each task."""
    log_string = ""
    probs = self.probs
    boxes = self.boxes
    if len(self) == 0:
        return log_string if probs is not None else f"{log_string}(no detections), "
    if probs is not None:
        log_string += f"{', '.join(f'{self.names[j]} {probs.data[j]:.2f}' for j in probs.top5)}, "
    if boxes:
        for c in boxes.cls.unique():
            n = (boxes.cls == c).sum()  # detections per class
            log_string += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, "
    return log_string



ultralytics.engine.results.Boxes

का रूप: BaseTensor

डिटेक्शन बॉक्स का प्रबंधन करता है, बॉक्स निर्देशांक, आत्मविश्वास स्कोर, कक्षा की आसान पहुंच और हेरफेर प्रदान करता है पहचानकर्ता, और वैकल्पिक ट्रैकिंग आईडी। बॉक्स निर्देशांक के लिए कई प्रारूपों का समर्थन करता है, जिसमें पूर्ण और दोनों शामिल हैं सामान्यीकृत रूप।

विशेषताएँ:

नाम प्रकार विवरण: __________
data Tensor

कच्चा tensor जिसमें डिटेक्शन बॉक्स और उनके संबंधित डेटा शामिल हैं।

orig_shape tuple

मूल छवि आकार एक टपल (ऊंचाई, चौड़ाई) के रूप में, सामान्यीकरण के लिए उपयोग किया जाता है।

is_track bool

इंगित करता है कि ट्रैकिंग आईडी बॉक्स डेटा में शामिल हैं या नहीं.

गुण

xyxy (torch.Tensor | numpy.ndarray): [x1, y1, x2, y2] प्रारूप में बॉक्स। कॉन्फ (torch.Tensor | numpy.ndarray): प्रत्येक बॉक्स के लिए आत्मविश्वास स्कोर। सीएलएस (torch.Tensor | numpy.ndarray): प्रत्येक बॉक्स के लिए क्लास लेबल। आईडी (torch.Tensor | numpy.ndarray, वैकल्पिक): प्रत्येक बॉक्स के लिए ट्रैकिंग आईडी, यदि उपलब्ध हो। xywh (torch.Tensor | numpy.ndarray): [x, y, चौड़ाई, ऊंचाई] प्रारूप में बॉक्स, मांग पर गणना की जाती है। xyxyn (torch.Tensor | numpy.ndarray): सामान्यीकृत [x1, y1, x2, y2] बक्से, orig_shape. xywhn (torch.Tensor | numpy.ndarray): सामान्यीकृत [x, y, चौड़ाई, ऊंचाई] बक्से, सापेक्ष orig_shape.

विधियाँ:

नाम विवरण: __________
cpu

बक्से को CPU स्मृति में ले जाता है।

numpy

बक्सों को एक numpy सरणी स्वरूप में कनवर्ट करता है.

cuda

बॉक्स को CUDA (GPU) स्मृति में ले जाता है।

to

बक्सों को निर्दिष्ट डिवाइस पर ले जाता है।

में स्रोत कोड ultralytics/engine/results.py
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498499500 501 502 503 504 505506507
class Boxes(BaseTensor):
    """
    Manages detection boxes, providing easy access and manipulation of box coordinates, confidence scores, class
    identifiers, and optional tracking IDs. Supports multiple formats for box coordinates, including both absolute and
    normalized forms.

    Attributes:
        data (torch.Tensor): The raw tensor containing detection boxes and their associated data.
        orig_shape (tuple): The original image size as a tuple (height, width), used for normalization.
        is_track (bool): Indicates whether tracking IDs are included in the box data.

    Properties:
        xyxy (torch.Tensor | numpy.ndarray): Boxes in [x1, y1, x2, y2] format.
        conf (torch.Tensor | numpy.ndarray): Confidence scores for each box.
        cls (torch.Tensor | numpy.ndarray): Class labels for each box.
        id (torch.Tensor | numpy.ndarray, optional): Tracking IDs for each box, if available.
        xywh (torch.Tensor | numpy.ndarray): Boxes in [x, y, width, height] format, calculated on demand.
        xyxyn (torch.Tensor | numpy.ndarray): Normalized [x1, y1, x2, y2] boxes, relative to `orig_shape`.
        xywhn (torch.Tensor | numpy.ndarray): Normalized [x, y, width, height] boxes, relative to `orig_shape`.

    Methods:
        cpu(): Moves the boxes to CPU memory.
        numpy(): Converts the boxes to a numpy array format.
        cuda(): Moves the boxes to CUDA (GPU) memory.
        to(device, dtype=None): Moves the boxes to the specified device.
    """

    def __init__(self, boxes, orig_shape) -> None:
        """
        Initialize the Boxes class.

        Args:
            boxes (torch.Tensor | numpy.ndarray): A tensor or numpy array containing the detection boxes, with
                shape (num_boxes, 6) or (num_boxes, 7). The last two columns contain confidence and class values.
                If present, the third last column contains track IDs.
            orig_shape (tuple): Original image size, in the format (height, width).
        """
        if boxes.ndim == 1:
            boxes = boxes[None, :]
        n = boxes.shape[-1]
        assert n in (6, 7), f"expected 6 or 7 values but got {n}"  # xyxy, track_id, conf, cls
        super().__init__(boxes, orig_shape)
        self.is_track = n == 7
        self.orig_shape = orig_shape

    @property
    def xyxy(self):
        """Return the boxes in xyxy format."""
        return self.data[:, :4]

    @property
    def conf(self):
        """Return the confidence values of the boxes."""
        return self.data[:, -2]

    @property
    def cls(self):
        """Return the class values of the boxes."""
        return self.data[:, -1]

    @property
    def id(self):
        """Return the track IDs of the boxes (if available)."""
        return self.data[:, -3] if self.is_track else None

    @property
    @lru_cache(maxsize=2)  # maxsize 1 should suffice
    def xywh(self):
        """Return the boxes in xywh format."""
        return ops.xyxy2xywh(self.xyxy)

    @property
    @lru_cache(maxsize=2)
    def xyxyn(self):
        """Return the boxes in xyxy format normalized by original image size."""
        xyxy = self.xyxy.clone() if isinstance(self.xyxy, torch.Tensor) else np.copy(self.xyxy)
        xyxy[..., [0, 2]] /= self.orig_shape[1]
        xyxy[..., [1, 3]] /= self.orig_shape[0]
        return xyxy

    @property
    @lru_cache(maxsize=2)
    def xywhn(self):
        """Return the boxes in xywh format normalized by original image size."""
        xywh = ops.xyxy2xywh(self.xyxy)
        xywh[..., [0, 2]] /= self.orig_shape[1]
        xywh[..., [1, 3]] /= self.orig_shape[0]
        return xywh

cls property

बक्सों के वर्ग मान लौटाएं।

conf property

बक्से के विश्वास मूल्यों को वापस करें।

id property

बॉक्स की ट्रैक आईडी लौटाएं (यदि उपलब्ध हो)।

xywh cached property

बक्सों को xywh प्रारूप में लौटाएं।

xywhn cached property

मूल छवि आकार द्वारा सामान्यीकृत xywh प्रारूप में बक्से लौटाएं।

xyxy property

बक्सों को xyxy स्वरूप में लौटाएं।

xyxyn cached property

मूल छवि आकार द्वारा सामान्यीकृत xyxy प्रारूप में बक्से लौटाएं।

__init__(boxes, orig_shape)

Boxes क्लास को इनिशियलाइज़ करें।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
boxes Tensor | ndarray

एक tensor या सुन्न सरणी जिसमें डिटेक्शन बॉक्स होते हैं, के साथ आकार (num_boxes, 6) या (num_boxes, 7)। अंतिम दो स्तंभों में आत्मविश्वास और वर्ग मान होते हैं। यदि मौजूद है, तो तीसरे अंतिम स्तंभ में ट्रैक आईडी हैं।

आवश्यक
orig_shape tuple

मूल छवि आकार, प्रारूप में (ऊंचाई, चौड़ाई)।

आवश्यक
में स्रोत कोड ultralytics/engine/results.py
447 448 449 450 451 452 453 454 455 456 457 458 459 460461462 463
def __init__(self, boxes, orig_shape) -> None:
    """
    Initialize the Boxes class.

    Args:
        boxes (torch.Tensor | numpy.ndarray): A tensor or numpy array containing the detection boxes, with
            shape (num_boxes, 6) or (num_boxes, 7). The last two columns contain confidence and class values.
            If present, the third last column contains track IDs.
        orig_shape (tuple): Original image size, in the format (height, width).
    """
    if boxes.ndim == 1:
        boxes = boxes[None, :]
    n = boxes.shape[-1]
    assert n in (6, 7), f"expected 6 or 7 values but got {n}"  # xyxy, track_id, conf, cls
    super().__init__(boxes, orig_shape)
    self.is_track = n == 7
    self.orig_shape = orig_shape



ultralytics.engine.results.Masks

का रूप: BaseTensor

डिटेक्शन मास्क के भंडारण और हेरफेर के लिए एक वर्ग।

विशेषताएँ:

नाम प्रकार विवरण: __________
xy list

पिक्सेल निर्देशांक में खंडों की एक सूची।

xyn list

सामान्यीकृत खंडों की एक सूची।

विधियाँ:

नाम विवरण: __________
cpu

मास्क लौटाता है tensor CPU मेमोरी पर।

numpy

मास्क लौटाता है tensor एक सुन्न सरणी के रूप में।

cuda

मास्क लौटाता है tensor GPU मेमोरी पर।

to

मास्क लौटाता है tensor निर्दिष्ट डिवाइस और dType के साथ।

में स्रोत कोड ultralytics/engine/results.py
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540541 542 543 544 545 546 547
class Masks(BaseTensor):
    """
    A class for storing and manipulating detection masks.

    Attributes:
        xy (list): A list of segments in pixel coordinates.
        xyn (list): A list of normalized segments.

    Methods:
        cpu(): Returns the masks tensor on CPU memory.
        numpy(): Returns the masks tensor as a numpy array.
        cuda(): Returns the masks tensor on GPU memory.
        to(device, dtype): Returns the masks tensor with the specified device and dtype.
    """

    def __init__(self, masks, orig_shape) -> None:
        """Initialize the Masks class with the given masks tensor and original image shape."""
        if masks.ndim == 2:
            masks = masks[None, :]
        super().__init__(masks, orig_shape)

    @property
    @lru_cache(maxsize=1)
    def xyn(self):
        """Return normalized segments."""
        return [
            ops.scale_coords(self.data.shape[1:], x, self.orig_shape, normalize=True)
            for x in ops.masks2segments(self.data)
        ]

    @property
    @lru_cache(maxsize=1)
    def xy(self):
        """Return segments in pixel coordinates."""
        return [
            ops.scale_coords(self.data.shape[1:], x, self.orig_shape, normalize=False)
            for x in ops.masks2segments(self.data)
        ]

xy cached property

पिक्सेल निर्देशांक में सेगमेंट लौटाएं.

xyn cached property

सामान्यीकृत खंड लौटाएं।

__init__(masks, orig_shape)

दिए गए मास्क के साथ मास्क वर्ग को प्रारंभ करें tensor और मूल छवि आकार।

में स्रोत कोड ultralytics/engine/results.py
525 526 527 528 529
def __init__(self, masks, orig_shape) -> None:
    """Initialize the Masks class with the given masks tensor and original image shape."""
    if masks.ndim == 2:
        masks = masks[None, :]
    super().__init__(masks, orig_shape)



ultralytics.engine.results.Keypoints

का रूप: BaseTensor

पता लगाने वाले कीपॉइंट्स को स्टोर करने और हेरफेर करने के लिए एक क्लास।

विशेषताएँ:

नाम प्रकार विवरण: __________
xy Tensor

प्रत्येक पहचान के लिए x, y निर्देशांक वाले मुख्य बिंदुओं का एक संग्रह।

xyn Tensor

सीमा में निर्देशांक के साथ xy का एक सामान्यीकृत संस्करण [0, 1]।

conf Tensor

यदि उपलब्ध हो तो मुख्य बिंदुओं से जुड़े विश्वास मान, अन्यथा कोई नहीं।

विधियाँ:

नाम विवरण: __________
cpu

मुख्य बिंदुओं की एक प्रतिलिपि लौटाता है tensor CPU मेमोरी पर।

numpy

मुख्य बिंदुओं की एक प्रतिलिपि लौटाता है tensor एक सुन्न सरणी के रूप में।

cuda

मुख्य बिंदुओं की एक प्रतिलिपि लौटाता है tensor GPU मेमोरी पर।

to

मुख्य बिंदुओं की एक प्रतिलिपि लौटाता है tensor निर्दिष्ट डिवाइस और dType के साथ।

में स्रोत कोड ultralytics/engine/results.py
550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580581 582 583 584 585 586 587 588 589590 591 592 593 594 595596
class Keypoints(BaseTensor):
    """
    A class for storing and manipulating detection keypoints.

    Attributes:
        xy (torch.Tensor): A collection of keypoints containing x, y coordinates for each detection.
        xyn (torch.Tensor): A normalized version of xy with coordinates in the range [0, 1].
        conf (torch.Tensor): Confidence values associated with keypoints if available, otherwise None.

    Methods:
        cpu(): Returns a copy of the keypoints tensor on CPU memory.
        numpy(): Returns a copy of the keypoints tensor as a numpy array.
        cuda(): Returns a copy of the keypoints tensor on GPU memory.
        to(device, dtype): Returns a copy of the keypoints tensor with the specified device and dtype.
    """

    @smart_inference_mode()  # avoid keypoints < conf in-place error
    def __init__(self, keypoints, orig_shape) -> None:
        """Initializes the Keypoints object with detection keypoints and original image size."""
        if keypoints.ndim == 2:
            keypoints = keypoints[None, :]
        if keypoints.shape[2] == 3:  # x, y, conf
            mask = keypoints[..., 2] < 0.5  # points with conf < 0.5 (not visible)
            keypoints[..., :2][mask] = 0
        super().__init__(keypoints, orig_shape)
        self.has_visible = self.data.shape[-1] == 3

    @property
    @lru_cache(maxsize=1)
    def xy(self):
        """Returns x, y coordinates of keypoints."""
        return self.data[..., :2]

    @property
    @lru_cache(maxsize=1)
    def xyn(self):
        """Returns normalized x, y coordinates of keypoints."""
        xy = self.xy.clone() if isinstance(self.xy, torch.Tensor) else np.copy(self.xy)
        xy[..., 0] /= self.orig_shape[1]
        xy[..., 1] /= self.orig_shape[0]
        return xy

    @property
    @lru_cache(maxsize=1)
    def conf(self):
        """Returns confidence values of keypoints if available, else None."""
        return self.data[..., 2] if self.has_visible else None

conf cached property

यदि उपलब्ध हो तो मुख्य बिंदुओं के विश्वास मान लौटाता है, अन्यथा कोई नहीं।

xy cached property

मुख्य बिंदुओं के x, y निर्देशांक लौटाता है.

xyn cached property

सामान्यीकृत x, y मुख्य बिंदुओं के निर्देशांक देता है।

__init__(keypoints, orig_shape)

Keypoints ऑब्जेक्ट को डिटेक्शन कीपॉइंट और मूल छवि आकार के साथ इनिशियलाइज़ करता है।

में स्रोत कोड ultralytics/engine/results.py
566 567 568 569 570 571 572 573 574 575
@smart_inference_mode()  # avoid keypoints < conf in-place error
def __init__(self, keypoints, orig_shape) -> None:
    """Initializes the Keypoints object with detection keypoints and original image size."""
    if keypoints.ndim == 2:
        keypoints = keypoints[None, :]
    if keypoints.shape[2] == 3:  # x, y, conf
        mask = keypoints[..., 2] < 0.5  # points with conf < 0.5 (not visible)
        keypoints[..., :2][mask] = 0
    super().__init__(keypoints, orig_shape)
    self.has_visible = self.data.shape[-1] == 3



ultralytics.engine.results.Probs

का रूप: BaseTensor

वर्गीकरण भविष्यवाणियों के भंडारण और हेरफेर के लिए एक वर्ग।

विशेषताएँ:

नाम प्रकार विवरण: __________
top1 int

शीर्ष 1 वर्ग का सूचकांक।

top5 list[int]

शीर्ष 5 वर्गों के सूचकांक।

top1conf Tensor

शीर्ष 1 वर्ग का आत्मविश्वास।

top5conf Tensor

शीर्ष 5 वर्गों का विश्वास।

विधियाँ:

नाम विवरण: __________
cpu

जांच की एक प्रति लौटाता है tensor CPU मेमोरी पर।

numpy

जांच की एक प्रति लौटाता है tensor एक सुन्न सरणी के रूप में।

cuda

जांच की एक प्रति लौटाता है tensor GPU मेमोरी पर।

to

जांच की एक प्रति लौटाता है tensor निर्दिष्ट डिवाइस और dType के साथ।

में स्रोत कोड ultralytics/engine/results.py
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618619 620 621 622 623 624 625 626 627 628 629630631 632 633 634 635 636 637 638639 640 641 642
class Probs(BaseTensor):
    """
    A class for storing and manipulating classification predictions.

    Attributes:
        top1 (int): Index of the top 1 class.
        top5 (list[int]): Indices of the top 5 classes.
        top1conf (torch.Tensor): Confidence of the top 1 class.
        top5conf (torch.Tensor): Confidences of the top 5 classes.

    Methods:
        cpu(): Returns a copy of the probs tensor on CPU memory.
        numpy(): Returns a copy of the probs tensor as a numpy array.
        cuda(): Returns a copy of the probs tensor on GPU memory.
        to(): Returns a copy of the probs tensor with the specified device and dtype.
    """

    def __init__(self, probs, orig_shape=None) -> None:
        """Initialize the Probs class with classification probabilities and optional original shape of the image."""
        super().__init__(probs, orig_shape)

    @property
    @lru_cache(maxsize=1)
    def top1(self):
        """Return the index of top 1."""
        return int(self.data.argmax())

    @property
    @lru_cache(maxsize=1)
    def top5(self):
        """Return the indices of top 5."""
        return (-self.data).argsort(0)[:5].tolist()  # this way works with both torch and numpy.

    @property
    @lru_cache(maxsize=1)
    def top1conf(self):
        """Return the confidence of top 1."""
        return self.data[self.top1]

    @property
    @lru_cache(maxsize=1)
    def top5conf(self):
        """Return the confidences of top 5."""
        return self.data[self.top5]

top1 cached property

शीर्ष 1 का सूचकांक लौटाएं।

top1conf cached property

शीर्ष 1 का विश्वास लौटाएं।

top5 cached property

शीर्ष 5 के सूचकांकों को लौटाएं।

top5conf cached property

शीर्ष 5 के आत्मविश्वास को लौटाएं।

__init__(probs, orig_shape=None)

वर्गीकरण संभावनाओं और छवि के वैकल्पिक मूल आकार के साथ प्रोब्स वर्ग को प्रारंभ करें।

में स्रोत कोड ultralytics/engine/results.py
def __init__(self, probs, orig_shape=None) -> None:
    """Initialize the Probs class with classification probabilities and optional original shape of the image."""
    super().__init__(probs, orig_shape)



ultralytics.engine.results.OBB

का रूप: BaseTensor

ओरिएंटेड बाउंडिंग बॉक्स (OBB) के भंडारण और हेरफेर के लिए एक वर्ग।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
boxes Tensor | ndarray

एक tensor या सुन्न सरणी जिसमें डिटेक्शन बॉक्स होते हैं, आकार के साथ (num_boxes, 7) या (num_boxes, 8)। अंतिम दो स्तंभों में आत्मविश्वास और वर्ग मान होते हैं। यदि मौजूद है, तो तीसरे अंतिम कॉलम में ट्रैक आईडी होते हैं, और बाईं ओर से पांचवें कॉलम में रोटेशन होता है।

आवश्यक
orig_shape tuple

मूल छवि आकार, प्रारूप में (ऊंचाई, चौड़ाई)।

आवश्यक

विशेषताएँ:

नाम प्रकार विवरण: __________
xywhr Tensor | ndarray

[x_center, y_center, चौड़ाई, ऊंचाई, रोटेशन] प्रारूप में बॉक्स।

conf Tensor | ndarray

बक्से के आत्मविश्वास मूल्य।

cls Tensor | ndarray

बक्सों के वर्ग मान।

id Tensor | ndarray

बॉक्स की ट्रैक आईडी (यदि उपलब्ध हो)।

xyxyxyxyn Tensor | ndarray

xyxyxyxy प्रारूप में घुमाए गए बक्से मूल छवि आकार द्वारा सामान्यीकृत होते हैं।

xyxyxyxy Tensor | ndarray

xyxyxyxy प्रारूप में घुमाए गए बक्से।

xyxy Tensor | ndarray

क्षैतिज बक्से xyxyxyxy स्वरूप में.

data Tensor

कच्चा ओ.बी.बी. tensor (उपनाम के लिए boxes).

विधियाँ:

नाम विवरण: __________
cpu

ऑब्जेक्ट CPU स्मृति में ले जाएँ।

numpy

ऑब्जेक्ट को एक numpy सरणी में कनवर्ट करें।

cuda

ऑब्जेक्ट को CUDA स्मृति में ले जाएँ।

to

ऑब्जेक्ट को निर्दिष्ट डिवाइस पर ले जाएँ।

में स्रोत कोड ultralytics/engine/results.py
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670671 672 673 674 675676677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727728729 730
class OBB(BaseTensor):
    """
    A class for storing and manipulating Oriented Bounding Boxes (OBB).

    Args:
        boxes (torch.Tensor | numpy.ndarray): A tensor or numpy array containing the detection boxes,
            with shape (num_boxes, 7) or (num_boxes, 8). The last two columns contain confidence and class values.
            If present, the third last column contains track IDs, and the fifth column from the left contains rotation.
        orig_shape (tuple): Original image size, in the format (height, width).

    Attributes:
        xywhr (torch.Tensor | numpy.ndarray): The boxes in [x_center, y_center, width, height, rotation] format.
        conf (torch.Tensor | numpy.ndarray): The confidence values of the boxes.
        cls (torch.Tensor | numpy.ndarray): The class values of the boxes.
        id (torch.Tensor | numpy.ndarray): The track IDs of the boxes (if available).
        xyxyxyxyn (torch.Tensor | numpy.ndarray): The rotated boxes in xyxyxyxy format normalized by orig image size.
        xyxyxyxy (torch.Tensor | numpy.ndarray): The rotated boxes in xyxyxyxy format.
        xyxy (torch.Tensor | numpy.ndarray): The horizontal boxes in xyxyxyxy format.
        data (torch.Tensor): The raw OBB tensor (alias for `boxes`).

    Methods:
        cpu(): Move the object to CPU memory.
        numpy(): Convert the object to a numpy array.
        cuda(): Move the object to CUDA memory.
        to(*args, **kwargs): Move the object to the specified device.
    """

    def __init__(self, boxes, orig_shape) -> None:
        """Initialize the Boxes class."""
        if boxes.ndim == 1:
            boxes = boxes[None, :]
        n = boxes.shape[-1]
        assert n in (7, 8), f"expected 7 or 8 values but got {n}"  # xywh, rotation, track_id, conf, cls
        super().__init__(boxes, orig_shape)
        self.is_track = n == 8
        self.orig_shape = orig_shape

    @property
    def xywhr(self):
        """Return the rotated boxes in xywhr format."""
        return self.data[:, :5]

    @property
    def conf(self):
        """Return the confidence values of the boxes."""
        return self.data[:, -2]

    @property
    def cls(self):
        """Return the class values of the boxes."""
        return self.data[:, -1]

    @property
    def id(self):
        """Return the track IDs of the boxes (if available)."""
        return self.data[:, -3] if self.is_track else None

    @property
    @lru_cache(maxsize=2)
    def xyxyxyxy(self):
        """Return the boxes in xyxyxyxy format, (N, 4, 2)."""
        return ops.xywhr2xyxyxyxy(self.xywhr)

    @property
    @lru_cache(maxsize=2)
    def xyxyxyxyn(self):
        """Return the boxes in xyxyxyxy format, (N, 4, 2)."""
        xyxyxyxyn = self.xyxyxyxy.clone() if isinstance(self.xyxyxyxy, torch.Tensor) else np.copy(self.xyxyxyxy)
        xyxyxyxyn[..., 0] /= self.orig_shape[1]
        xyxyxyxyn[..., 1] /= self.orig_shape[0]
        return xyxyxyxyn

    @property
    @lru_cache(maxsize=2)
    def xyxy(self):
        """
        Return the horizontal boxes in xyxy format, (N, 4).

        Accepts both torch and numpy boxes.
        """
        x1 = self.xyxyxyxy[..., 0].min(1).values
        x2 = self.xyxyxyxy[..., 0].max(1).values
        y1 = self.xyxyxyxy[..., 1].min(1).values
        y2 = self.xyxyxyxy[..., 1].max(1).values
        xyxy = [x1, y1, x2, y2]
        return np.stack(xyxy, axis=-1) if isinstance(self.data, np.ndarray) else torch.stack(xyxy, dim=-1)

cls property

बक्सों के वर्ग मान लौटाएं।

conf property

बक्से के विश्वास मूल्यों को वापस करें।

id property

बॉक्स की ट्रैक आईडी लौटाएं (यदि उपलब्ध हो)।

xywhr property

घुमाए गए बक्से को xywhr प्रारूप में लौटाएं।

xyxy cached property

क्षैतिज बक्से को xyxy प्रारूप में लौटाएं, (N, 4)।

दोनों को स्वीकार करता है torch और सुन्न बक्से।

xyxyxyxy cached property

बक्सों को xyxyxyxy स्वरूप, (N, 4, 2) में लौटाएँ.

xyxyxyxyn cached property

बक्सों को xyxyxyxy स्वरूप, (N, 4, 2) में लौटाएँ.

__init__(boxes, orig_shape)

Boxes क्लास को इनिशियलाइज़ करें।

में स्रोत कोड ultralytics/engine/results.py
672 673 674 675 676 677 678 679680
def __init__(self, boxes, orig_shape) -> None:
    """Initialize the Boxes class."""
    if boxes.ndim == 1:
        boxes = boxes[None, :]
    n = boxes.shape[-1]
    assert n in (7, 8), f"expected 7 or 8 values but got {n}"  # xywh, rotation, track_id, conf, cls
    super().__init__(boxes, orig_shape)
    self.is_track = n == 8
    self.orig_shape = orig_shape





2023-11-12 बनाया गया, अपडेट किया गया 2024-01-05
लेखक: ग्लेन-जोचर (4), लाफिंग-क्यू (1)