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

Görüntü sınıflandırma, üç görevin en basitidir ve tüm görüntünün önceden tanımlanmış bir sınıf kümesinden birine sınıflandırılmasını 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üven puanıdır. Görüntü sınıflandırma, yalnızca bir görüntünün hangi sınıfa ait olduğunu bilmen gerektiğinde ve o sınıftaki nesnelerin nerede bulunduğunu veya tam şekillerinin ne olduğunu bilmene gerek olmadığında yararlıdır.

Modeller

YOLO26 önceden eğitilmiş Classify modelleri burada gösterilmektedir. Detect, Segment ve Pose modelleri COCO veri kümesi üzerinde önceden eğitilirken, 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, ImageNet veri kümesi doğrulama kümesi üzerindeki model doğruluklarıdır.
  yolo val classify data=path/to/ImageNet device=0 komutuyla yeniden üretebilirsin.
• Hız, bir Amazon EC2 P4d bulut sunucusu kullanılarak ImageNet doğrulama görüntüleri üzerinde ortalama olarak hesaplanmıştır.
  yolo val classify data=path/to/ImageNet batch=1 device=0|cpu komutuyla yeniden üretebilirsin.
• Params ve FLOPs değerleri, Conv ve BatchNorm katmanlarını birleştiren model.fuse() işleminden sonraki birleştirilmiş model içindir. Önceden eğitilmiş kontrol noktaları, eğitimin tüm mimarisini korur ve daha yüksek sayılar gösterebilir.

Eğit (Train)

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

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)

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şabilirsin. Sınıflandırma veri kümeleri Ultralytics Platform üzerinde de yönetilebilir ve etiketlenebilir.

Doğrula (Val)

Eğitilmiş YOLO26n-cls modelinin MNIST160 veri kümesi üzerindeki doğruluğunu doğrula. model kendi eğitim data'sını ve argümanlarını model öznitelikleri olarak koruduğu için herhangi bir argümana gerek yoktur.

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

Tahmin

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

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

predict moduna dair tüm detayları Predict sayfasında bulabilirsin.

Dışa Aktar (Export)

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

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")

Mevcut YOLO26-cls dışa aktarma formatları aşağıdaki tabloda yer almaktadır. format argümanını kullanarak, örneğin format='onnx' veya format='engine', herhangi bir formata dışa aktarabilirsin. Dışa aktarılan modeller üzerinde doğrudan tahmin yapabilir veya doğrulama gerçekleştirebilirsin, örneğin yolo predict model=yolo26n-cls.onnx. Dışa aktarma işlemi tamamlandıktan sonra kullanım örnekleri modelin için gösterilecektir.

Tam export ayrıntıları için Dışa Aktarma sayfasına bak.

SSS

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

yolo26n-cls.pt gibi YOLO26 modelleri, verimli görüntü sınıflandırma için tasarlanmıştır. Tüm görüntüye bir güven puanıyla birlikte tek bir sınıf etiketi atarlar. Bu, görüntü içindeki nesnelerin yerini veya şeklini belirlemekten ziyade görüntünün hangi sınıfa ait olduğunu bilmenin yeterli olduğu uygulamalar için özellikle yararlıdır.

Görüntü sınıflandırma için YOLO26 modelini nasıl eğitirim?

Bir YOLO26 modelini eğitmek için Python veya CLI komutlarını kullanabilirsin. Örneğin, bir yolo26n-cls modelini 64 görüntü boyutunda 100 epoch boyunca 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)

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

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

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

Eğitilmiş bir YOLO26 modelini farklı formatlara nasıl dışa aktarabilirim?

Eğitilmiş bir YOLO26 modelini Python veya CLI komutlarını kullanarak çeşitli formatlara dışa aktarabilirsin. Ö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")

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

Eğitilmiş bir YOLO26 sınıflandırma modelini nasıl doğrularım?

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

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

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