Başla

Ultralytics YOLO için Kapsamlı Eğitimler

Ultralytics YOLO kılavuzları, eğitim ve tahminden dağıtıma kadar bir görsel yapay zekâ projesinin tüm aşamalarını kapsar. PyTorch üzerine kurulu YOLO; gerçek zamanlı nesne algılama ve diğer görsel görevler için hızı ve doğruluğu bir araya getirir.

İster derin öğrenmeye yeni başlıyor ister bu konuda uzman ol, bu eğitimler bilgisayarlı görü projelerinde YOLO'yu uygulama ve optimize etme konusunda pratik rehberlik sunar.



İzle: Ultralytics YOLO26 Kılavuzlarına Genel Bakış

Kılavuzlar#

Kılavuzlar, proje aşamasına göre gruplandırılmıştır — ortam kurulumundan ve veri hazırlığından eğitime, değerlendirmeye, dağıtıma, çıkarım optimizasyonuna ve uç donanıma kadar — böylece üzerinde çalıştığın adıma doğrudan geçebilirsin.

Başla ve planla#

  • Conda Hızlı Başlangıç: Ultralytics için bir Conda ortamı kurmaya yönelik adım adım kılavuz. Ultralytics paketini Conda ile verimli şekilde nasıl yükleyip kullanmaya başlayacağını öğren.
  • Docker Hızlı Başlangıç: Ultralytics YOLO modellerini Docker ile kurmaya ve kullanmaya yönelik kapsamlı kılavuz. Docker'ı nasıl yükleyeceğini, GPU desteğini nasıl yöneteceğini ve tutarlı geliştirme ve dağıtım için YOLO modellerini yalıtılmış kapsayıcılarda nasıl çalıştıracağını öğren.
  • AzureML Hızlı Başlangıç: Ultralytics YOLO modellerini Microsoft'un Azure Makine Öğrenimi platformunda kullanmaya başla. Nesne algılama projelerini bulutta nasıl eğiteceğini, dağıtacağını ve ölçeklendireceğini öğren.
  • Modal Hızlı Başlangıç: Ultralytics YOLO26'yı Modal'ın sunucusuz bulut platformunda çalıştır; kimlik doğrulama, GPU çıkarımı ve kalıcı depolama kullanan eğitim işlerini ele al — yönetmen gereken bir altyapı yok.
  • Bir Bilgisayarlı Görü Projesinin Hedeflerini Belirleme: Bilgisayarlı görü projen için net ve ölçülebilir hedefleri etkili bir şekilde nasıl belirleyeceğini adım adım incele. İyi tanımlanmış bir problem ifadesinin önemini ve projen için nasıl bir yol haritası oluşturduğunu öğren.
  • Bir Bilgisayarlı Görü Projesinin Aşamaları: Hedef belirleme, model seçimi, veri hazırlama ve sonuçları değerlendirme dahil, bilgisayarlı görü projesinin temel aşamalarını öğren.
  • YOLO Mimarisi Açıklaması: YOLO mimarisinin YOLOv3'ten YOLO26'ya omurga, boyun ve algılama başlığı boyunca nasıl evrildiğini izle; C2f, C3k2, C2PSA attention, anchorsız ve NMS'siz tasarımı kapsar.

Verilerini hazırla#

  • Veri Toplama ve Etiketleme: Bilgisayarlı görü modellerin için yüksek kaliteli girdiler oluşturacak verileri toplamaya ve etiketlemeye yönelik araçları, teknikleri ve en iyi uygulamaları keşfet.
  • Etiketlenmiş Verileri Ön İşleme: Görüntü boyutlandırma, normalleştirme, veri kümesini bölme, veri artırma ve keşifsel veri analizi (EDA) dahil, YOLO26 ile bilgisayarlı görü için veri ön işlemeyi öğren.
  • YOLO'da Veri Artırma: Temel dönüşümlerden model sağlamlığını ve performansını iyileştirmeye yönelik gelişmiş stratejilere kadar YOLO'daki veri artırma tekniklerinin tümünü keşfet.
  • COCO'dan YOLO'ya Dönüştürme: Eğitim için COCO JSON ek açıklamalarını YOLO biçimine dönüştürmeye yönelik kapsamlı kılavuz. Sınıf kimliği eşlemesi ve yaygın dönüştürme sorunları dahil, algılama, segmentasyon ve kilit noktaları kapsar.
  • COCO JSON ile Eğitim: Özel bir veri kümesi sınıfı ve eğitici kullanarak, COCO JSON ek açıklamaları üzerinde YOLO biçimine dönüştürme yapmadan doğrudan YOLO'yu eğit.

Eğit ve ince ayar yap#

  • Yüksek Çözünürlüklü Döşeme: Tüm görüntü işleme görevlerinde sabit döşeme kullanarak yüksek çözünürlüklü görüntüler üzerinde eğitim yap, doğrula ve tahmin yürüt.
  • Model Eğitimi İçin İpuçları: Bilgisayarlı görü modellerini daha etkili eğitmek için toplu iş boyutlarını optimize etme, karma hassasiyet kullanma, önceden eğitilmiş ağırlıkları uygulama ve daha fazlasıyla ilgili ipuçlarını keşfet.
  • Özel Verilerle YOLO'ya İnce Ayar Yapma: Önceden eğitilmiş ağırlıklarla özel veri kümelerinde YOLO26'ya ince ayar yapmaya yönelik kapsamlı kılavuz; aktarım öğrenmesini, katmanları dondurmayı, optimizer seçimini, iki aşamalı eğitimi ve sorun gidermeyi kapsar.
  • YOLO26 Eğitim Tarifi: COCO üzerinde resmî YOLO26 temel kontrol noktalarını eğitmek için kullanılan hiperparametrelerin, artırma işlem hatlarının ve optimizer ayarlarının eksiksiz belgeleri; pratik ince ayar önerileri de içerir.
  • Hiperparametre Ayarı: Tuner sınıfını ve genetik evrim algoritmalarını kullanarak hiperparametrelerde ince ayar yapıp YOLO modellerini nasıl optimize edeceğini keşfet.
  • Bilgi Damıtma: Özellik tabanlı damıtma kullanarak daha büyük bir öğretmen modelden daha küçük bir öğrenci modele bilgi aktarımıyla model performansını nasıl artıracağını öğren.
  • K-Katlı Çapraz Doğrulama: K-Katlı çapraz doğrulama tekniğiyle modelin genelleme becerisini nasıl geliştireceğini öğren.
  • Eğiticiyi Özelleştirme: Özel metrikleri günlüğe kaydetmek, sınıf ağırlıklı kayıp eklemek, model kaydetmeyi özelleştirmek, omurgayı dondurmak/dondurmayı kaldırmak ve katman başına öğrenme oranları ayarlamak için YOLO eğiticisinin alt sınıfını oluşturmayı öğren.
  • Model YAML Yapılandırma Kılavuzu: Ultralytics model mimarisi tanımlarını ayrıntılı biçimde incele. YAML biçimini keşfet, modül çözümleme sistemini anla ve özel modülleri nasıl entegre edeceğini öğren.

Değerlendir ve sorunları gider#

  • YOLO Performans Metrikleri ⭐ TEMEL: YOLO modellerinin performansını değerlendirmek için kullanılan mAP, IoU ve F1 skoru gibi temel metrikleri anla. Algılama doğruluğunu ve hızını nasıl artıracağına ilişkin pratik örnekler ve ipuçları içerir.
  • Model Değerlendirme ve İnce Ayar Üzerine İçgörüler: Bilgisayarlı görü modellerini mAP ve IoU gibi metriklerle değerlendir, ardından algılama doğruluğunu artırmak için metriklerin ortaya koyduğu bulgular doğrultusunda harekete geç.
  • Model Testi: Bilgisayarlı görü modellerini daha önce görülmemiş verilerle nasıl test edeceğini, YOLO26 modellerini nasıl doğrulayacağını ve dağıtımdan önce aşırı öğrenmeyi, yetersiz öğrenmeyi ve veri sızıntısını nasıl saptayacağını öğren.
  • Yaygın YOLO Sorunları ⭐ ÖNERİLEN: Ultralytics YOLO modelleriyle çalışırken en sık karşılaşılan sorunlara yönelik pratik çözümler ve sorun giderme ipuçları.
  • Bilgisayarlı Görü Modelini Sürdürme: Doğruluğu korumak, anormallikleri fark etmek ve veri kaymasını azaltmak için bilgisayarlı görü modellerini izleme, sürdürme ve belgeleme konusundaki temel uygulamaları öğren.

Dağıt ve sun#

  • Model Dağıtım Seçenekleri: ONNX, OpenVINO ve TensorRT gibi YOLO model dağıtım biçimlerine genel bakış ve dağıtım stratejini belirlemene yardımcı olacak her birinin artıları ve eksileri.
  • Model Dağıtımı İçin En İyi Uygulamalar: Bilgisayarlı görü projelerinde modelleri verimli şekilde dağıtmaya yönelik ipuçlarını ve en iyi uygulamaları adım adım incele; optimizasyona, sorun gidermeye ve güvenliğe odaklan.
  • YOLO Dışı Modelleri Dışa Aktarma: Herhangi bir torch.nn.Module (timm, torchvision, özel) modelini TorchScript, ONNX, OpenVINO, CoreML, Core AI, TensorFlow SavedModel, PaddlePaddle, MNN, NCNN ve ExecuTorch biçimlerine dönüştürmek için Ultralytics bağımsız dışa aktarma yardımcı programlarını kullan.
  • Uçtan Uca Algılama: NMS veya NMS'siz çıkarımı seç, çıktı biçimlerini ve dışa aktarma uyumluluğunu anla.
  • Triton Inference Server Entegrasyonu: Ölçeklenebilir ve verimli derin öğrenme çıkarım dağıtımları için Ultralytics YOLO26'yı NVIDIA Triton Inference Server ile entegre et.
  • YOLO ile İş Parçacığı Güvenli Çıkarım: YOLO modelleriyle iş parçacığı güvenli biçimde çıkarım gerçekleştirme yönergeleri. İş parçacığı güvenliğinin önemini, yarış koşullarını önlemeye ve tutarlı tahminler sağlamaya yönelik en iyi uygulamaları öğren.
  • ROS Hızlı Başlangıç: Nokta bulutu ve derinlik görüntüleri de dahil olmak üzere robotik uygulamalarda gerçek zamanlı nesne algılama için YOLO'yu Robot Operating System (ROS) ile nasıl entegre edeceğini öğren.
  • Docker ile Vertex AI Dağıtımı: YOLO modellerini Docker ile kapsayıcılaştırıp Google Cloud Vertex AI üzerinde dağıtmaya yönelik basitleştirilmiş kılavuz — derleme, gönderme, otomatik ölçeklendirme ve izlemeyi kapsar.

Çıkarımı optimize et#

  • OpenVINO Gecikme ve Verim Modları: En yüksek YOLO çıkarım performansı için gecikme ve verim optimizasyonu tekniklerini öğren.
  • NVIDIA DALI GPU Ön İşleme: NVIDIA DALI kullanarak YOLO letterbox yeniden boyutlandırma, dolgu ve normalleştirme işlemlerini GPU'da çalıştırarak CPU ön işleme darboğazlarını ortadan kaldır; Triton Inference Server entegrasyonunu da kapsar.
  • Segmentasyon Nesnelerini Ayırma: Ultralytics segmentasyon modelleriyle görüntülerdeki nesneleri çıkarmak ve ayırmak için adım adım tarif.
  • Çıkarım Görüntülerini Terminalde Görüntüleme: Remote Tunnel veya SSH oturumlarını kullanırken çıkarım sonuçlarını görüntülemek için VS Code'un tümleşik terminalini kullan.

Uç ve gömülü donanım#

  • NVIDIA Jetson: YOLO modellerini NVIDIA Jetson cihazlarında dağıtmaya yönelik hızlı başlangıç kılavuzu.
  • Raspberry Pi: YOLO modellerini en yeni Raspberry Pi donanımında çalıştırmaya yönelik hızlı başlangıç eğitimi.
  • NVIDIA Jetson'da DeepStream: DeepStream ve TensorRT kullanarak YOLO modellerini NVIDIA Jetson cihazlarında dağıtmaya yönelik hızlı başlangıç kılavuzu.
  • Raspberry Pi'de Edge TPU: Google Edge TPU, Raspberry Pi üzerinde YOLO çıkarımını hızlandırır.
  • NVIDIA DGX Spark: YOLO modellerini NVIDIA DGX Spark cihazlarında dağıtmaya yönelik hızlı başlangıç kılavuzu.
  • Intel'de DL Streamer: DL Streamer ve OpenVINO™ kullanarak YOLO26 modellerini Intel Core Ultra Series 3 cihazlarında dağıtmaya yönelik hızlı başlangıç kılavuzu.

Kılavuzlarımıza katkıda bulun#

Topluluktan katkıları memnuniyetle karşılıyoruz! Ultralytics YOLO'nun kılavuzlarımızda henüz ele alınmayan belirli bir alanında uzmanlaştıysan, deneyimini paylaşmanı öneririz. Kılavuz yazmak, topluluğa katkıda bulunmanın ve belgelerimizi daha kapsamlı ve kullanıcı dostu hâle getirmemize yardımcı olmanın harika bir yoludur.

Başlamak için Pull Request (PR) açma yönergeleri için lütfen Katkıda Bulunma Kılavuzumuzu oku. Yeni bir kılavuz eklerken, proje aşamasına uyan yukarıdaki kategoriye yerleştir ve koleksiyon büyüdükçe kolayca göz atılabilir kalması için tek bir sayfa türüyle sınırla — adım adım bir eğitim, belirli bir göreve odaklanan bir nasıl yapılır kılavuzu veya bir başvuru kaynağı. Katkılarını bekliyoruz.

Sık Sorulan Sorular#

  • Ultralytics YOLO ile özel bir nesne algılama modeli eğitmek oldukça kolaydır. Önce veri kümeni doğru biçimde hazırla ve Ultralytics paketini yükle. Eğitimi başlatmak için aşağıdaki kodu kullan:

    Örnek
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")  # Önceden eğitilmiş bir YOLO modeli yükle
    model.train(data="path/to/dataset.yaml", epochs=50)  # Özel veri kümesinde eğit
  • YOLO modelinin performansını değerlendirmek, etkinliğini anlamak açısından çok önemlidir. Temel metrikler arasında Ortalama Ortalama Kesinlik (mAP), Kesişim-Birleşim (IoU) ve F1 skoru yer alır. Bu metrikler, nesne algılama görevlerinin doğruluğunu ve kesinliğini değerlendirmeye yardımcı olur. Bu metrikler ve modelini nasıl geliştireceğin hakkında daha fazla bilgi için YOLO Performans Metrikleri kılavuzumuza göz atabilirsin.

  • Ultralytics Platform, YOLO modelleri için veri kümesi açıklama ekleme, deney takibi, bulutta eğitim, dışa aktarma ve özel çıkarım uç noktalarını bir arada sunan, uçtan uca kodsuz bir çalışma alanıdır; hem yeni başlayanlar hem de profesyoneller için uygundur.

  • YOLO modeli eğitimi sırasında karşılaşılan yaygın sorunlar arasında veri biçimlendirme hataları, model mimarisi uyumsuzlukları ve yetersiz eğitim verisi bulunur. Bunları gidermek için veri kümenin doğru biçimlendirildiğinden emin ol, uyumlu model sürümlerini kontrol et ve eğitim verilerini artır. Çözümlerin kapsamlı listesi için Yaygın YOLO Sorunları kılavuzumuza bak.

  • YOLO modellerini NVIDIA Jetson ve Raspberry Pi gibi uç cihazlarda dağıtmak için modeli TensorRT veya LiteRT gibi uyumlu bir biçime dönüştürmen gerekir. Uç donanımda gerçek zamanlı nesne algılamaya başlamak için NVIDIA Jetson ve Raspberry Pi dağıtımlarına yönelik adım adım kılavuzlarımızı izle. Bu kılavuzlarda kurulum, yapılandırma ve performans optimizasyonu ele alınır.

Yorumlar30

Bir soru sor, sonuçlarını paylaş veya başka birine yardım et.

  1. safdarhamid64-cpuGitHub

    i have done everything using your docker method everything , using AI chatbots , but still i am unable to run the yolo , plzz provide me a solution that will work for every Raspberry Pi4 because its really so much frustrating

  2. tutorialsyoloGitHub

    Hi, I am trying to improve the convolutional layers in the nn module like in conv.py or block.py as novelty for my research. The location is like "ultralytics/ultralytics/nn/modules/conv.py. Could you please tell me where else i should update/call the new block which I improved? Because it gives me error when I am adding those blocks in the cfg/.yaml files for training in a custom dataset. Thank you

  3. IshfazGitHub

    Hello,

    I'm using YOLOv8 for object detection, and I have only three classes in my dataset. However, when I generate the confusion matrix after training or validation, I notice that it shows a 4x4 matrix instead of the expected 3x3.

    It seems like an extra class, possibly a "background" or "null" class, is being added automatically.

    How can I remove this extra background class so that my confusion matrix only reflects the three actual classes I have trained on?

  4. AashishThakur1321GitHub

    can you tell the path, where downloaded model weights are stored as i manually want to add the weights to the folder as i don't have internet access on server

    1. Glenn JocherUltralytics

      @AashishThakur1321 the default location where Ultralytics models are stored depends on your operating system, but it's typically within a directory in your user's home folder; you can find more specific details by checking the "Settings" section when you run from ultralytics import settings; print(settings).

      1
  5. ghostGitHub

    Hello, I am working on a project to detect different types of cells. I already have a trained model, thanks to Ultralytics! I want to increase my dataset and tried using the auto-annotate function. The function works well but annotates objects in polygons. I need annotation in rectangular bounding boxes. Can you please help with this problem? https://docs.ultralytics.com/reference/data/annotator/

    1. Glenn JocherUltralytics

      @kartmyco thank you for your message! While the auto-annotate function currently outputs polygon annotations, you can convert them to rectangular bounding boxes using tools like cvat or labelme, or you can write a custom script to approximate polygons into rectangular boxes. For details on data annotation tools, you can refer to our guide on data collection and annotation. Let us know if you have additional questions!

    2. ghostGitHub

      Hello Glenn, Thank you so much for your reply. I will try to approximate the polygons in rectangular bounding boxes.

  6. jdonzaGitHub

    I decided to make a different thread here as it is related to a different topic. But I wanted to know if you guys had documentation that went into the specifics of how the YOLO models are created. I am interested to learn more about CNN's, how they work, and how it relates to the image processing of YOLO.

    1. Glenn JocherUltralytics

      @jdonza for detailed information on how YOLO models are created and how CNNs work in relation to YOLO, please refer to our comprehensive guides at https://docs.ultralytics.com/guides/. These resources cover various aspects of YOLO, including its architecture and image processing techniques.

  7. jdonzaGitHub

    Hello,

    Are there any tutorials showing how to train a YOLOv8 model using multiple devices for faster training? I read the instructions for YOLOv5 but got a bit lost. Step by step instructions would be greatly appreciated!

    Thank you!

    1. Glenn JocherUltralytics

      @jdonza hello,

      For training YOLOv8 using multiple devices, please refer to our Multi-GPU Training guide. It provides step-by-step instructions to help you set up and run training across multiple GPUs.

      Thank you!

    2. jdonzaGitHub

      Thank you for the response! What I am still confused with is the following line of code.

      results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

      Here are a few questions I had.

      1. I have one GPU on my computer currently. If I had another device that also had the same GPU, how does YOLO know which computer is 0 and which is 1? Is there a physical connection of some sort that needs to occur?
      2. If you had a computer with multiple GPU's, the same questions arises. How does YOLO know which is 0 and which is 1?

      Overall, I am confused with the set-up steps that need to occur before simply inputting "device=[0,1]".

      Sorry if my questions appear trivial. I am a beginner and do not have much experience with network configurations like this!

      Thanks!

    3. Glenn JocherUltralytics

      @jdonza to address your questions:

      1. YOLOv8 does not support multi-device training across different computers. Each device ID (e.g., 0, 1) refers to GPUs within the same machine.
      2. For a computer with multiple GPUs, device IDs are assigned based on the order in which GPUs are detected by the system. You can verify GPU IDs using nvidia-smi.

      For more details, please refer to the Multi-GPU Training guide.

    4. jdonzaGitHub

      Was this capability eliminated? The link you provided has a drop-down section labeled "Use Multiple Machines" which appears to provide some sort of framework to accomplish this.

    5. Glenn JocherUltralytics

      @jdonza the capability for multi-machine training is not supported in YOLOv8. The "Use Multiple Machines" section in the documentation you referenced may pertain to older versions or different contexts. For multi-GPU training on a single machine, you can use the device=[0,1] argument. If you have further questions, please refer to the Multi-GPU Training guide.

    6. Glenn JocherUltralytics

      @jdonza you're welcome! For training YOLOv8 on multiple GPUs within a single machine, you can use the device=[0,1] argument. Each GPU is identified by its ID, which you can check using nvidia-smi. Multi-machine training is not supported. For more details, please refer to the Multi-GPU Training guide.

    7. Ephraim-BryskiGitHub

      While not supported in YOLOv8, I did see reference to training across multiple computers in the YOLOv5 documentation:

      (I believe this is what jdonza was referring to before). Does this allow for training across multiple computers for YOLOv5, but is no longer supported in YOLOv8? If so, would using YOLOv5 instead of v8 be recommended for this use case? Thanks!

    8. Glenn JocherUltralytics

      Training across multiple computers is supported in YOLOv5 using DistributedDataParallel, but this feature is not available in YOLOv8. If multi-machine training is essential for your use case, using YOLOv5 would be recommended. For more details, please refer to the YOLOv5 documentation.

  8. TanWeeKangGitHub

    hi, i am doing a project about food detection. the detection results were great. however, there are some overlapping bboxes for some categories of food. some input images will have this category and some will have others. how can i apply nms to retrieve only the highest conf score of the detection and remove overlapping bboxes? i run inference on my best.pt model by giving it input images

    1. Glenn JocherUltralytics(düzenlendi)

      Hi there! It's great to hear that your food detection project is yielding excellent results! 🎉

      To address the issue of overlapping bounding boxes, you can apply Non-Maximum Suppression (NMS) to retain only the highest confidence score detections and remove the overlapping ones. YOLO models typically handle NMS internally, but you can customize the NMS settings during inference to better suit your needs.

      Here's how you can do it:

      Using Python

      If you're running inference in a Python environment, you can set the conf (confidence threshold) and iou (IoU threshold for NMS) parameters when calling the predict method. Here's an example:

      from ultralytics import YOLO
      
      # Load your custom-trained model
      model = YOLO('path/to/best.pt')
      
      # Run inference with custom NMS settings
      results = model.predict(source='path/to/your/image.jpg', conf=0.25, iou=0.45)
      
      # Display results
      results[0].show()
      Using CLI

      If you're using the command line interface, you can specify these parameters directly in your command:

      yolo predict model=path/to/best.pt source='path/to/your/image.jpg' conf=0.25 iou=0.45
      Explanation
      • conf: This sets the minimum confidence threshold for detections. Detections with a confidence score below this value will be discarded.
      • iou: This sets the IoU threshold for NMS. Detections with an IoU greater than this value will be considered overlapping, and only the one with the highest confidence score will be kept.

      For more detailed information on inference and NMS settings, you can refer to the YOLO Predict Documentation.

      If you encounter any issues or need further assistance, please ensure you're using the latest versions of torch and ultralytics. If the problem persists, providing a minimum reproducible example would be very helpful. You can find guidelines on creating one here: Minimum Reproducible Example.

      Happy coding, and best of luck with your project! 🚀

    2. TanWeeKangGitHub

      because the goal for now is to remove overlapping, if i set the iou threshold on the high side, the image doesnt differ much from the original detected image, where there are many overlappings. if i set to a low iou threshold, more overlappings will be removed.

    3. TanWeeKangGitHub

      another thing is that for my food detection i have 5 classes/categories of food. under these 5 categories i have variety of food for each category, but i label and train the model on these 5 classes, for simplicity sake i did not go into detail about what kind of food is that, lets say meat we have fish, pork etc. the model see either of those and classify as meat. although they are from same classes, they might have different prices. now how can i use segmentation( maybe from opencv) to distinguish the image i used to run inference on my best.pt model to identify the difference in meat like fish, pork to have different prices?

    4. Glenn JocherUltralytics(düzenlendi)

      Hi there! Thanks for reaching out and providing detailed feedback on your experience with overlapping bounding boxes in your food detection project. It's fantastic to hear that your detection results are generally great! 🎉

      To address the issue of overlapping bounding boxes, adjusting the IoU threshold is indeed a key factor. Here’s a more refined approach to help you achieve the best balance:

      Fine-Tuning IoU Threshold
      • High IoU Threshold: Retains more overlapping boxes, which might be useful if you want to ensure that no potential detections are missed.
      • Low IoU Threshold: Removes more overlapping boxes, which can help in reducing redundancy but might risk missing some detections.
      Practical Steps
      1. Experiment with Intermediate Values: Instead of setting the IoU threshold to extremes, try intermediate values (e.g., 0.3, 0.4, 0.5) to find a sweet spot that minimizes overlaps without losing important detections.
      2. Confidence Threshold: Adjust the confidence threshold (conf) to filter out low-confidence detections, which can also help in reducing overlaps.
      Example Code

      Here’s how you can apply these settings in Python:

      from ultralytics import YOLO
      
      # Load your custom-trained model
      model = YOLO('path/to/best.pt')
      
      # Run inference with custom NMS settings
      results = model.predict(source='path/to/your/image.jpg', conf=0.25, iou=0.45)
      
      # Display results
      results[0].show()

      And using the CLI:

      yolo predict model=path/to/best.pt source='path/to/your/image.jpg' conf=0.25 iou=0.45
      Additional Resources

      For more detailed guidance on optimizing your model and handling common issues, you might find the following guides helpful:

      If you continue to experience issues, please ensure you are using the latest versions of torch and ultralytics. If the problem persists, providing a minimum reproducible example would be very helpful. You can find guidelines on creating one here: Minimum Reproducible Example.

      Feel free to reach out if you have any more questions or need further assistance. Happy coding! 🚀

    5. TanWeeKangGitHub

      another thing is that for my food detection i have 5 classes/categories of food. under these 5 categories i have variety of food for each category, but i label and train the model on these 5 classes, for simplicity sake i did not go into detail about what kind of food is that, lets say meat we have fish, pork etc. the model see either of those and classify as meat. although they are from same classes, they might have different prices. now how can i use segmentation( maybe from opencv) to distinguish the image i used to run inference on my best.pt model to identify the difference in meat like fish, pork to have different prices?

    6. Glenn JocherUltralytics

      Hi there! It's fantastic to hear about your progress with food detection using YOLO. 😊

      To distinguish between different types of food within the same category (like fish and pork under "meat"), you can leverage segmentation techniques. Here's a step-by-step approach to achieve this:

      1. Segmentation with OpenCV

      You can use OpenCV to perform image segmentation, which will help you isolate different types of food within the same category. Here's a basic example of how you might use OpenCV for segmentation:

      import cv2
      import numpy as np
      
      # Load the image
      image = cv2.imread('path/to/your/image.jpg')
      
      # Convert to grayscale
      gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
      
      # Apply GaussianBlur to reduce noise and improve contour detection
      blurred = cv2.GaussianBlur(gray, (5, 5), 0)
      
      # Use Canny edge detection
      edges = cv2.Canny(blurred, 50, 150)
      
      # Find contours
      contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
      
      # Draw contours on the original image
      cv2.drawContours(image, contours, -1, (0, 255, 0), 2)
      
      # Display the result
      cv2.imshow('Segmented Image', image)
      cv2.waitKey(0)
      cv2.destroyAllWindows()
      2. Combining YOLO Detection with Segmentation

      You can combine the bounding boxes from your YOLO model with segmentation to further classify the detected objects. Here’s a conceptual approach:

      1. Run YOLO Inference: Use your trained YOLO model to detect the general categories (e.g., meat).
      2. Apply Segmentation: Within each detected bounding box, apply segmentation to isolate different types of food.
      3. Classify Segmented Regions: Use additional classification models or heuristics to distinguish between types like fish and pork.
      3. Advanced Segmentation Techniques

      For more precise segmentation, consider using advanced models like Mask R-CNN or leveraging pre-trained segmentation models available in frameworks like PyTorch or TensorFlow.

      Example with YOLO and Segmentation

      Here’s a more integrated example combining YOLO detection with OpenCV segmentation:

      from ultralytics import YOLO
      import cv2
      
      # Load your custom-trained YOLO model
      model = YOLO('path/to/best.pt')
      
      # Run inference
      results = model.predict(source='path/to/your/image.jpg', conf=0.25, iou=0.45)
      
      # Process each detected bounding box
      for result in results:
          for box in result.boxes:
              x1, y1, x2, y2 = map(int, box.xyxy[0])
              cropped_img = result.orig_img[y1:y2, x1:x2]
      
              # Convert to grayscale and apply segmentation
              gray = cv2.cvtColor(cropped_img, cv2.COLOR_BGR2GRAY)
              blurred = cv2.GaussianBlur(gray, (5, 5), 0)
              edges = cv2.Canny(blurred, 50, 150)
              contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
              cv2.drawContours(cropped_img, contours, -1, (0, 255, 0), 2)
      
              # Display the segmented image
              cv2.imshow('Segmented Image', cropped_img)
              cv2.waitKey(0)
      
      cv2.destroyAllWindows()
      Further Reading

      For more detailed guides and advanced techniques, you might find these resources helpful:

      Feel free to experiment with these techniques and adjust the parameters to better suit your specific use case. If you have any more questions or need further assistance, don't hesitate to ask. Happy coding! 🚀

  9. thisisqiuqiuqiuGitHub

    Thank you very much for your letter. Your reply is very helpful to my experimental training. I understand how to set up the basic model training. I wish you all success in your future work. 

    ------------------ 原始邮件 ------------------ 发件人: "ultralytics/ultralytics" @.>; 发送时间: 2024年5月20日(星期一) 中午12:11 @.>; @.@.>; 主题: Re: [ultralytics/ultralytics] zh/guides/ (Discussion #12787)

    Hello! The number of epochs needed for training the YOLOv8 base model can vary depending on your specific dataset and the complexity of the task. While 500 epochs might be necessary for some scenarios to achieve optimal results, it's not a strict requirement for all cases.

    A good practice is to monitor the training process for signs of convergence, such as stable validation loss and accuracy metrics. You can start with fewer epochs, like 100 or 200, and evaluate the model's performance. If the results are not satisfactory, you can continue training for more epochs or consider adjusting other hyperparameters.

    Here's a simple example to start training with a specified number of epochs: yolo train data=coco128.yaml model=yolov8n.pt epochs=100

    Adjust the epochs value as needed based on your observations. Happy training! 😊

    — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: @.***>

    1. Glenn JocherUltralytics(düzenlendi)

      Hello! The number of epochs needed for training the YOLO base model can vary depending on your specific dataset and the complexity of the task. While 500 epochs might be necessary for some scenarios to achieve optimal results, it's not a strict requirement for all cases.

      A good practice is to monitor the training process for signs of convergence, such as stable validation loss and accuracy metrics. You can start with fewer epochs, like 100 or 200, and evaluate the model's performance. If the results are not satisfactory, you can continue training for more epochs or consider adjusting other hyperparameters.

      Here's a simple example to start training with a specified number of epochs:

      yolo train data=coco128.yaml model=yolo26n.pt epochs=100

      Adjust the epochs value as needed based on your observations. Happy training! 😊