Görüntü Sınıflandırması

Görüntü sınıflandırması üç görevden en basiti olup, tüm bir görüntüyü önceden tanımlanmış bir dizi sınıftan birine sınıflandırmayı içerir.

Bir görüntü sınıflandırıcısının çıktısı, tek bir sınıf etiketi ve bir güvenilirlik puanıdır. Görüntü sınıflandırması, yalnızca bir görüntünün hangi sınıfa ait olduğunu bilmeniz gerektiğinde ve o sınıftaki nesnelerin nerede bulunduğunu veya tam şeklinin ne olduğunu bilmeniz gerekmediğinde kullanışlıdır.

İzle: Ultralytics YOLO Görevlerini Keşfedin: Ultralytics Platformunu Kullanarak Görüntü Sınıflandırması

Modeller

YOLO26 önceden eğitilmiş Classify modelleri burada gösterilmiştir. Detect, Segment ve Pose modelleri COCO veri kümesi üzerinde önceden eğitilmişken, Classify modelleri ImageNet veri kümesi üzerinde önceden eğitilmiştir.

Modeller, ilk kullanımda en son Ultralytics sürümünden otomatik olarak indirilir.

• acc değerleri, üzerindeki model doğruluklarıdır ImageNet veri kümesi doğrulama kümesi.
  Tekrar oluşturmak için yolo val classify data=path/to/ImageNet device=0
• Hız ImageNet val görüntülerinde ortalaması alınarak Amazon EC2 P4d örneği kullanılarak COCO val görüntülerinde ortalama alınmıştır.
  Tekrar oluşturmak için yolo val classify data=path/to/ImageNet batch=1 device=0|cpu

Eğit

YOLO26n-cls modelini MNIST160 veri kümesi üzerinde 100 epoch boyunca 64 görüntü boyutuyla eğitin. Mevcut tüm argümanların listesi için Yapılandırma sayfasına bakınız.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.yaml")  # build a new model from YAML
model = YOLO("yolo26n-cls.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n-cls.yaml").load("yolo26n-cls.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="mnist160", epochs=100, imgsz=64)

# Build a new model from YAML and start training from scratch
yolo classify train data=mnist160 model=yolo26n-cls.yaml epochs=100 imgsz=64

# Start training from a pretrained *.pt model
yolo classify train data=mnist160 model=yolo26n-cls.pt epochs=100 imgsz=64

# Build a new model from YAML, transfer pretrained weights to it and start training
yolo classify train data=mnist160 model=yolo26n-cls.yaml pretrained=yolo26n-cls.pt epochs=100 imgsz=64

import torch
import torchvision.transforms as T

from ultralytics import YOLO
from ultralytics.data.dataset import ClassificationDataset
from ultralytics.models.yolo.classify import ClassificationTrainer, ClassificationValidator


class CustomizedDataset(ClassificationDataset):
    """A customized dataset class for image classification with enhanced data augmentation transforms."""

    def __init__(self, root: str, args, augment: bool = False, prefix: str = ""):
        """Initialize a customized classification dataset with enhanced data augmentation transforms."""
        super().__init__(root, args, augment, prefix)

        # Add your custom training transforms here
        train_transforms = T.Compose(
            [
                T.Resize((args.imgsz, args.imgsz)),
                T.RandomHorizontalFlip(p=args.fliplr),
                T.RandomVerticalFlip(p=args.flipud),
                T.RandAugment(interpolation=T.InterpolationMode.BILINEAR),
                T.ColorJitter(brightness=args.hsv_v, contrast=args.hsv_v, saturation=args.hsv_s, hue=args.hsv_h),
                T.ToTensor(),
                T.Normalize(mean=torch.tensor(0), std=torch.tensor(1)),
                T.RandomErasing(p=args.erasing, inplace=True),
            ]
        )

        # Add your custom validation transforms here
        val_transforms = T.Compose(
            [
                T.Resize((args.imgsz, args.imgsz)),
                T.ToTensor(),
                T.Normalize(mean=torch.tensor(0), std=torch.tensor(1)),
            ]
        )
        self.torch_transforms = train_transforms if augment else val_transforms


class CustomizedTrainer(ClassificationTrainer):
    """A customized trainer class for YOLO classification models with enhanced dataset handling."""

    def build_dataset(self, img_path: str, mode: str = "train", batch=None):
        """Build a customized dataset for classification training and the validation during training."""
        return CustomizedDataset(root=img_path, args=self.args, augment=mode == "train", prefix=mode)


class CustomizedValidator(ClassificationValidator):
    """A customized validator class for YOLO classification models with enhanced dataset handling."""

    def build_dataset(self, img_path: str, mode: str = "train"):
        """Build a customized dataset for classification standalone validation."""
        return CustomizedDataset(root=img_path, args=self.args, augment=mode == "train", prefix=self.args.split)


model = YOLO("yolo26n-cls.pt")
model.train(data="imagenet1000", trainer=CustomizedTrainer, epochs=10, imgsz=224, batch=64)
model.val(data="imagenet1000", validator=CustomizedValidator, imgsz=224, batch=64)

Veri kümesi formatı

YOLO sınıflandırma veri kümesi formatı hakkında ayrıntılı bilgiye Veri Kümesi Kılavuzu bölümünden ulaşılabilir.

Doğrula

Eğitilmiş YOLO26n-cls modelini doğrulayın doğruluğu MNIST160 veri kümesinde. Herhangi bir argümana gerek yoktur, çünkü model eğitimini korur data ve argümanları model nitelikleri olarak saklar.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Validate the model
metrics = model.val()  # no arguments needed, dataset and settings remembered
metrics.top1  # top1 accuracy
metrics.top5  # top5 accuracy

yolo classify val model=yolo26n-cls.pt  # val official model
yolo classify val model=path/to/best.pt # val custom model

Tahmin et

Görüntüler üzerinde tahminler yürütmek için eğitilmiş bir YOLO26n-cls modeli kullanın.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Predict with the model
results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image

yolo classify predict model=yolo26n-cls.pt source='https://ultralytics.com/images/bus.jpg'  # predict with official model
yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predict with custom model

Tamamını görün predict sayfasındaki mod ayrıntıları. Tahmin et sayfasında bulabilirsiniz.

Dışa aktar

Bir YOLO26n-cls modelini ONNX, CoreML vb. gibi farklı bir formata aktarın.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom-trained model

# Export the model
model.export(format="onnx")

yolo export model=yolo26n-cls.pt format=onnx  # export official model
yolo export model=path/to/best.pt format=onnx # export custom-trained model

Mevcut YOLO26-cls dışa aktarma formatları aşağıdaki tabloda yer almaktadır. Herhangi bir formata şunu kullanarak dışa aktarabilirsiniz: format argümanı, yani format='onnx' veya format='engine'. Dışa aktarılan modeller üzerinde doğrudan tahmin veya doğrulama yapabilirsiniz, yani, yolo predict model=yolo26n-cls.onnx. Kullanım örnekleri, dışa aktarma tamamlandıktan sonra modeliniz için gösterilir.

Tamamını görün export ayrıntıları Dışa aktar sayfasında bulabilirsiniz.

SSS

Görüntü sınıflandırmasında YOLO26'nın amacı nedir?

YOLO26 modelleri, örneğin yolo26n-cls.pt, verimli görüntü sınıflandırması için tasarlanmıştır. Bir görüntünün içindeki nesnelerin konumunu veya şeklini belirlemek yerine, tüm görüntüye bir güven puanıyla birlikte tek bir sınıf etiketi atarlar. Bu, özellikle bir görüntünün belirli sınıfını bilmenin yeterli olduğu uygulamalar için kullanışlıdır.

Görüntü sınıflandırması için bir YOLO26 modeli nasıl eğitilir?

Bir YOLO26 modelini eğitmek için Python veya CLI komutlarını kullanabilirsiniz. Örneğin, bir model eğitmek için yolo26n-cls modelini 64'lük bir görüntü boyutunda 100 epoch için MNIST160 veri kümesi üzerinde eğitmek için:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="mnist160", epochs=100, imgsz=64)

yolo classify train data=mnist160 model=yolo26n-cls.pt epochs=100 imgsz=64

Daha fazla yapılandırma seçeneği için Yapılandırma sayfasını ziyaret edin.

Önceden eğitilmiş YOLO26 sınıflandırma modellerini nerede bulabilirim?

Önceden eğitilmiş YOLO26 sınıflandırma modelleri şurada bulunabilir: Modeller bölümü. Gibi modeller yolo26n-cls.pt, yolo26s-cls.pt, yolo26m-cls.pt, vb., üzerinde önceden eğitilmiştir ImageNet veri kümesi ve çeşitli görüntü sınıflandırma görevleri için kolayca indirilip kullanılabilir.

Eğitilmiş bir YOLO26 modeli farklı formatlara nasıl aktarılır?

Eğitilmiş bir YOLO26 modelini Python veya CLI komutlarını kullanarak çeşitli formatlara dışa aktarabilirsiniz. Örneğin, bir modeli ONNX formatına dışa aktarmak için:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load the trained model

# Export the model to ONNX
model.export(format="onnx")

yolo export model=yolo26n-cls.pt format=onnx # export the trained model to ONNX format

Ayrıntılı dışa aktarma seçenekleri için Dışa Aktarma sayfasına bakın.

Eğitilmiş bir YOLO26 sınıflandırma modeli nasıl doğrulanır?

Eğitilmiş bir modelin doğruluğunu MNIST160 gibi bir veri kümesinde doğrulamak için aşağıdaki Python veya CLI komutlarını kullanabilirsiniz:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load the trained model

# Validate the model
metrics = model.val()  # no arguments needed, uses the dataset and settings from training
metrics.top1  # top1 accuracy
metrics.top5  # top5 accuracy

yolo classify val model=yolo26n-cls.pt # validate the trained model

Daha fazla bilgi için Doğrulama bölümünü ziyaret edin.

📅 2 yıl önce oluşturuldu ✏️ 2 gün önce güncellendi

Yorumlar