@PranavBhanot hey there! 😊 To print a confusion matrix after training your YOLOv8 model using the weights file, you can use the val mode with the --confusion-matrix argument in your command. Here's a quick example:

yolo val model=path/to/your/weights.pt data=your_dataset.yaml confusion-matrix

Make sure to replace path/to/your/weights.pt with the path to your trained weights file and your_dataset.yaml with your dataset configuration file. This will generate and display the confusion matrix for your model's performance on the validation dataset.

Hope this helps! Let us know if you have any more questions.

!yolo val model=/content/drive/MyDrive/best.pt data=/content/drive/MyDrive/Weapon Detection.v11i.yolov8/data.yaml confusion-matrix
gives this error Traceback (most recent call last):
File "/usr/local/bin/yolo", line 8, in
sys.exit(entrypoint())
File "/usr/local/lib/python3.10/dist-packages/ultralytics/cfg/init.py", line 382, in entrypoint
check_dict_alignment(full_args_dict, {a: ''})
File "/usr/local/lib/python3.10/dist-packages/ultralytics/cfg/init.py", line 203, in check_dict_alignment
raise SyntaxError(string + CLI_HELP_MSG) from e
SyntaxError: 'Detection.v11i.yolov8/data.yaml' is not a valid YOLO argument.

Arguments received: ['yolo', 'val', 'model=/content/drive/MyDrive/best.pt', 'data=/content/drive/MyDrive/Weapon', 'Detection.v11i.yolov8/data.yaml', 'confusion-matrix'].

@PranavBhanot hey there! 👋 It looks like there's an issue with the way the data path is being parsed due to spaces in your file path. When you have spaces in your file names or paths, the command line can interpret them as separate arguments.

To fix this, you can wrap your paths in quotes, but since you already did that and it didn't work due to the spaces within the path itself, you might want to try escaping the spaces with a backslash (\) or renaming your files and directories to remove spaces. However, the backslash method doesn't always work well with CLI commands, especially when paths are parsed by different shells or scripts.

A safer approach would be to use paths without spaces. For example, you could rename Weapon Detection.v11i.yolov8 to Weapon_Detection_v11i_yolov8 and then try the command again:

yolo val model='/content/drive/MyDrive/best.pt' data='/content/drive/MyDrive/Weapon_Detection_v11i_yolov8/data.yaml' confusion-matrix

This should help avoid the syntax error. Let me know if this solves the issue or if you need further assistance! 😊

You can get the confusion matrix from the object model like this:

confusion_matrix = model.trainer.validator.metrics.confusion_matrix.matrix

If you want to use a callback function that gets trainer or validator as input, you just need to modify the above calling structure.
But when a model weight is saved, it do not get its metrics or other results. It means that when it is reimported, if you want to extract the metric values (confusion matrix included) you need to run its validation process again. To run using the validation split informed in training step (val parameter informed in the model config file):

results = model.val()  # add arguments if you'd like

Results will contain some informations, including the metrics object which contain the Confusion Matrix. And you can get it just by metrics.confusion_matrix.matrix.

@luansouzasilva31 hey there! Thanks for the detailed breakdown on obtaining the confusion matrix and performing validations. Your approach is spot on! 👍

Just to add a quick note: after reimporting a trained model, indeed you do need to rerun the validation to fetch the updated metrics, including the confusion matrix. This is crucial when the analytics from previous sessions are not embedded within the saved model file. Here’s a succinct way to handle it:

from ultralytics import YOLO

# Load your trained model
model = YOLO('/content/drive/MyDrive/best.pt')

# Running validation
results = model.val(data='/content/drive/MyDrive/Weapon Detection.v11i.yolov8/data.yaml')

# Accessing the confusion matrix
confusion_matrix = results.metrics.confusion_matrix.matrix

Make sure that the paths are correctly defined and don't forget to adjust parameters according to your specific setup. Happy validating! 😊

Absolutely, you can proceed to train your best.pt model with the new 4500 images, leveraging the learning it acquired from the initial 1200 images. This process, known as "fine-tuning," allows the model to retain knowledge from the original dataset while updating its understanding based on the new data.

To ensure the initial learning is not overridden but rather enhanced with the new data, follow this approach:

yolo detect train data=new_dataset.yaml model=best.pt

In your new_dataset.yaml, ensure to include only the new 4500 images if you wish to train solely on new data. However, combining old and new data often yields a more robust model as it reinforces previous learnings and incorporates new insights. You'd do this by including paths to both the old and new images in your dataset configuration file.

Here's wishing you great success on your continued training journey! 🚀

after training for more data I got map50 0.98 and map50-95 0.70 . But when I give tongue image with no crack sometime it also deteting as crack . The model I trained on only crack images . now i want to improve it . I got best.pt and last.pt after training the model . Now i have 3100 images with crack and it is labeled and I have 400 images with no crack on tongue and not labeled . How can I train the model on only new data so that its last learninig also keep and new learning will add . Because I dont want the model will override and it will loss its last learning. Which is best practice to train on new data because if i train on whole old + new data the training time will increse and also i hvae to make more data augmentation for no crack images for data balance . So which is best practice ? is yolo provide this option to train on only new data by keeping its old learninig and old weights? Is it ok to not to label the no crack tongue images becuase it will take alot time to label and do i need to use any parameter while training on only new data like resume or pretrained ? I am new in this so please guide me in simple steps so that I can understand .

To enhance your model's accuracy with the new data without losing its previous learning, you can indeed fine-tune the model on just the new data.

For your situation with 3100 crack images (labeled) and 400 no-crack images (unlabeled), first, labeling your no-crack images would be valuable as it helps the model learn what non-cracks look like, improving its ability to differentiate. Labeling might seem time-consuming but it's a key step for improving model performance on distinguishing cracks from non-cracks.

To fine-tune your best.pt model on the new data while retaining its learning from the old data, you can use the Ultralytics YOLO CLI or Python API. Since your model was previously trained only on crack images, incorporating no-crack images as negative examples will help reduce false positives.

Here’s how you can do it using the CLI, assuming you've appended the new data to your training dataset configuration (e.g., new_data.yaml):

yolo detect train data=new_data.yaml model=best.pt

If using Python API:

from ultralytics import YOLO

# Load your model
model = YOLO('path/to/best.pt')

# Train on the new data
model.train(data='path/to/new_data.yaml')

Remember to make sure your new_data.yaml includes paths to both crack and no-crack images. It's recommended to train on a mix of old and new data for the most robust learning, but if time or resources are limited, focusing on the new data as mentioned should still offer improvement.

No additional parameters are needed to "keep" the old learning. The process of loading best.pt inherently does this, using the learned weights as a starting point for further training on new data. However, labeling your no-crack images will significantly contribute to the model's understanding and performance.

ok. To label the no crack images how can i label it ? Do i need to select whole tongue part using bouding box for no crack ? and do i need to maintain the class balance if i have crack images 3000 then do i have to make 3000 no crack images ? and for splitting the data into train and test do i need to maintain the class balance so that train and test file have equal number of both set ? what is best approach ? and i have read on the documentation of ultralytics that you can include the background images for minimising the false positive and no need to label as it will take the images as background image . So i want to detect the crack only if it is present and i want no detection if crack is not present . so can i add the no crack images without labelling as bakground image?

To label the no-crack images, you indeed can simply annotate the whole tongue part with a bounding box and label them as "no-crack" or a similar non-crack class. Regarding class balance, it's useful but not strictly necessary to have an exact 1:1 ratio of crack to no-crack images. Having a substantial number of both helps the model learn to distinguish between the two cases better, but it's okay if the numbers aren't perfectly matched.

For splitting the data into train and test sets, maintaining class balance in both sets is a good practice, ensuring the model gets exposed to, and evaluated on, a representative sample of each class.

About including no-crack images without labeling for background: yes, YOLOv8 supports this as a method to reduce false positives. You can include no-crack images in your dataset and don’t need to label them if your goal is to have the model learn to ignore these as a background. This approach can especially be helpful if you're mainly interested in detecting cracks and want the model to return no detections for images without cracks.

Make sure these no-crack "background" images are included in the training dataset path you specify in your training command, such as:

yolo detect train data=my_dataset.yaml model=best.pt

And in your my_dataset.yaml, besides paths to your labeled images (both old and new, if you decide to mix), also include paths to your unlabeled no-crack images. Ultralytics YOLOv8 processes these as background samples during training.

No special parameters are needed for training on only new data; just point your dataset config to wherever your images are. Using the model=best.pt argument effectively continues learning from where the best.pt model left off, adding to its knowledge with whatever new data you provide.

📖 For more details on configuration and training, refer to the Ultralytics YOLOv8 Documentation.

Hope this helps, and happy training! 🚀

Hey there! 👋

It looks like you're encountering issues with accessing the bounding box coordinates using the .xyxy attribute. The correct syntax in the latest versions of YOLOv8 should use the results object's boxes attribute for this. Each Result object in the results list contains a Boxes object, where you can access various properties like xyxy, xywh, etc.

Here's a quick example on how you can extract bounding box coordinates in the xyxy format:

from ultralytics import YOLO

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

# Run inference
results = model('path/to/your/image.jpg')

# Extract bounding box coordinates
boxes = results[0].boxes.xyxy  # Assuming you're interested in the first image in a batch

This should give you the bounding box coordinates you're after. If you have further questions or need more assistance, feel free to reach out! 😊

Hey there! 🌟 Changing class names in your YOLOv8 model and saving it is straightforward. You just need to modify the classes in your dataset's YAML file. Here's a quick example assuming your dataset config file is data.yaml:

# data.yaml
train: /path/to/train/images
val: /path/to/val/images
nc: 3  # number of classes
names: ['Small dog', 'Small cat', 'Small chicken']

After updating the class names, you can continue training or re-train your model with this configuration. To save the new model with updated class names, simply run your training process and it'll automatically save with these new names embedded.

Remember, the names list in data.yaml directly corresponds to the classes your model predicts. No need to change model architecture or re-export the pre-trained weights; just ensure the names in your config file match the desired output! 🐾

Hi there! 👋 It looks like you've encountered a common confusion with the label files and their location. In YOLO, label files indeed need to be in .txt format. However, the error message you're seeing relates to image files, not label files. It's saying it couldn't find any images in the specified folders with the supported extensions.

Make sure your images (.jpg, .png, etc.) are directly under yolo_data/train/images and yolo_data/val/images, not in subdirectories under these. YOLO expects this specific structure:

yolo_data
├── train
│   ├── images
│   │   ├── img1.jpg
│   │   ├── img2.jpg
│   │   └── ...
│   └── labels
│       ├── img1.txt
│       ├── img2.txt
│       └── ...
└── val
    ├── images
    │   ├── img1.jpg
    │   ├── img2.jpg
    │   └── ...
    └── labels
        ├── img1.txt
        ├── img2.txt
        └── ...

Your data.yaml should then point to the images and labels directories like so:

path: ../yolo_data
train: train/images
val: val/images

nc: 2
names: ['benign', 'malignant']

Hope this helps clear things up! If the issue persists, do let us know. Happy training! 🚀

Hello! Indeed, it's possible your model could have only 22 layers depending on its architecture. Different versions of YOLO can have varying layer counts due to their design intended for different use cases, such as speed versus accuracy trade-offs. For instance, smaller versions like YOLOv8n are designed to be more lightweight and thus have fewer layers compared to their larger counterparts.

When working with embeddings for similarity checks as you've done with randommodel(source=image6, embed=[1, 5]), you're on the right track! This function call should correctly extract embeddings from the specified layers of your model. Keep in mind, though, the effectiveness of using embeddings from certain layers for similarity can vary depending on what features those layers capture.

As for focusing more on color features or finding better ways to distinguish riders based on lighting and angle, experimenting with extracting embeddings from different layers could indeed help. Lower layers might focus more on color and texture, which could be useful if these are the main distinguishing factors. If your model isn't capturing color variations well, consider adjusting which layers you're pulling embeddings from or look into pre/post-processing techniques to emphasize color information in your images.

Let me know if this helps or if you have more questions. Happy to assist further! 🚴‍♂️ 🚴‍♀️

When I print the different layers thanks to following line of code:
for name,param in fietschecker.named_parameters():
print(name)

Some layers have more different components:
model.model.5.conv.weight
model.model.5.bn.weight
model.model.5.bn.bias
model.model.6.cv1.conv.weight
model.model.6.cv1.bn.weight
model.model.6.cv1.bn.bias
model.model.6.cv2.conv.weight
model.model.6.cv2.bn.weight
model.model.6.cv2.bn.bias
model.model.6.m.0.cv1.conv.weight
model.model.6.m.0.cv1.bn.weight
model.model.6.m.0.cv1.bn.bias
model.model.6.m.0.cv2.conv.weight
model.model.6.m.0.cv2.bn.weight
model.model.6.m.0.cv2.bn.bias
model.model.6.m.1.cv1.conv.weight
model.model.6.m.1.cv1.bn.weight
model.model.6.m.1.cv1.bn.bias
model.model.6.m.1.cv2.conv.weight
model.model.6.m.1.cv2.bn.weight
model.model.6.m.1.cv2.bn.bias

What is the meaning of "6.m.0", are these all from the sixth layer?

Hello! The notation like 6.m.0 in the layers you've mentioned refers to specific parts of the model's architecture. In YOLO models, and neural networks in general, layers are hierarchically organized, and such notations pinpoint where in the hierarchy the layer resides.

• 6 refers to the 6th major block or module in the model.
• m usually indicates a module within that block, which can contain multiple layers or operations. It's common in architectures that use blocks of layers repeated several times.
• 0, 1,... after m represent indices of specific layers or sub-modules within that module.

So, model.model.6.m.0.cv1.conv.weight would refer to the weights of the first convolutional layer (cv1) within the 0th module (m.0) of the 6th block (6) of your model.

Regarding the use of randommodel(source=image6, embed=[1, 5]), this should work for obtaining embeddings from the specified layers. It's a good approach to experimenting with which layers provide the most useful embeddings for your similarity task, especially when considering factors like lighting and angles over color.

If discrepancies in distances for the same versus different riders are observed, consider exploring layers that capture more abstract features beyond color, especially if your detection challenge involves recognizing complex patterns or objects under various conditions. Layers deeper in the network might provide embeddings that better capture the unique identifiers you're after.

Hope this helps clarify things! Let me know if you have more questions. 😊

Thank you, this makes it a bit more clear. However if I were to perform similarity based on color, is it possible with such a model that detects cyclists or is it better to train a new model specialised in recognising different colors?

@pietervhij absolutely, using your current model that detects cyclists to perform similarity analysis based on color is indeed possible. However, if color is the primary distinguishing feature you're relying on, fine-tuning your model or training a new model specialized in recognizing different colors could potentially yield better results.

For color-based similarity, ensuring the model focuses on color features can be crucial. One strategy could involve augmenting your dataset to emphasize color variation among cyclists or employing techniques that enhance color features during the training process.

You can also experiment with different layers for embeddings, as early layers might capture more color-specific features than deeper ones. Adjusting the layers from which you extract embeddings could help focus on color differentiation.

# Example of extracting embeddings from early layers
features_early = model(source=image, embed=[0, 1])  # Adjust [0, 1] based on your model structure and testing

Let's remember, though, that focusing solely on color might introduce limitations under varying lighting conditions or similar color profiles across different riders. Balancing color sensitivity with other distinguishing features could offer a more robust solution. 🎨🚴

Keep experimenting and fine-tuning according to your project's needs—best of luck with your endeavors!

thanks for the reply

i have runned the below code but i got an error

from ultralytics import YOLO

Load the pre-trained model

model =

!yolo
task=segment
mode=train
model='yolov8-cls-resnet50.yaml'
imgsz=640
data=trashcan_inst_material.yaml
epochs={8}
batch=16
name=yolov8n-resnet
exist_ok=True
amp=False

Epoch GPU_mem box_loss seg_loss cls_loss dfl_loss Instances Size
0% 0/358 [00:00<?, ?it/s]
Traceback (most recent call last):
File "/usr/local/bin/yolo", line 8, in
sys.exit(entrypoint())
File "/usr/local/lib/python3.10/dist-packages/ultralytics/cfg/init.py", line 582, in entrypoint
getattr(model, mode)(**overrides) # default args from model
File "/usr/local/lib/python3.10/dist-packages/ultralytics/engine/model.py", line 673, in train
self.trainer.train()
File "/usr/local/lib/python3.10/dist-packages/ultralytics/engine/trainer.py", line 198, in train
self._do_train(world_size)
File "/usr/local/lib/python3.10/dist-packages/ultralytics/engine/trainer.py", line 370, in _do_train
self.loss, self.loss_items = self.model(batch)
File "/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py", line 1511, in _wrapped_call_impl
return self._call_impl(*args, **kwargs)
File "/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py", line 1520, in _call_impl
return forward_call(*args, **kwargs)
File "/usr/local/lib/python3.10/dist-packages/ultralytics/nn/tasks.py", line 88, in forward
return self.loss(x, *args, **kwargs)
File "/usr/local/lib/python3.10/dist-packages/ultralytics/nn/tasks.py", line 264, in loss
self.criterion = self.init_criterion()
File "/usr/local/lib/python3.10/dist-packages/ultralytics/nn/tasks.py", line 371, in init_criterion
return v8SegmentationLoss(self)
File "/usr/local/lib/python3.10/dist-packages/ultralytics/utils/loss.py", line 256, in init
super().init(model)
File "/usr/local/lib/python3.10/dist-packages/ultralytics/utils/loss.py", line 159, in init
self.stride = m.stride # model strides
File "/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py", line 1688, in getattr
raise AttributeError(f"'{type(self).name}' object has no attribute '{name}'")
AttributeError: 'Classify' object has no attribute 'stride'

what should i do could you please help

do the yolov8-cls-resnet50.yaml works for the segmentation task

Thanks for reaching out! 😊 The yolov8-cls-resnet50.yaml file is designed primarily for classification tasks and not directly suited for segmentation tasks as is. For segmentation, you'd typically use a model structure and configuration file specifically tailored to handle segmentation tasks, which involves predicting pixel-wise class labels for the entire image, rather than just classifying one major object in the image.

If you're looking to improve your segmentation performance and are interested in integrating the EfficientDet backbone or exploring other architectures, you'd need to customize your model configuration and potentially tweak the model's code to incorporate these changes, as YOLOv8 directly does not support swapping backbones like EfficientDet out of the box.

For segmentation tasks with YOLOv8, you might want to look into available segmentation configurations or consider further customizations tailored to underwater trash detection. Unfortunately, without direct support, changing to a backbone like EfficientDet involves a good understanding of both the YOLOv8 architecture and the architecture you're aiming to integrate.

For using any .yaml file like yolov8-cls-resnet50.yaml, ensure it aligns with your task (detection, classification, segmentation) and dataset, adapting it as necessary. Then, train with:

yolo segment train data=your_dataset.yaml model=yolov8-cls-resnet50.yaml epochs=100 imgsz=640

But remember, this command is templated for segmentation tasks, and the model file should support your specific task requirements.

Keep exploring the architecture and configuration that best suits your needs, and don't hesitate to tweak and experiment! 🚀

Thanks for the reply. I was doing the detection task instead of segmentation out of the present detection models available in yolov8 , which one suits better for my project "Underwater trash detction"

please tell one which performs well in underwater derstion task

Hello! For underwater trash detection using detection models in YOLOv8, choosing the right model involves considering the conditions and characteristics of underwater images, such as light absorption and scattering.

For your specific case, I'd recommend starting with YOLOv8n or YOLOv8x, as these models offer a good balance between performance and computational efficiency, which is particularly useful in challenging underwater environments.

If your dataset includes high-resolution images or requires detecting small and diverse objects, YOLOv8x might be better due to its deeper and more complex architecture, allowing it to capture finer details. However, if resource efficiency is more critical, YOLOv8n would be a suitable choice with faster inference times.

Make sure to adjust training hyperparameters like imgsz to suit your image resolutions and consider using augmentations that simulate underwater image conditions during training for improved robustness.

yolo detect train data=your_dataset.yaml model=yolov8x.pt epochs=50 imgsz=640 batch=16

Remember, experimenting with different models and settings will help you find the best configuration for your specific scenario! 🌊🚀

Full Code if necessary (ultralytics was preinstalled, running on Colab):

from ultralytics import YOLO

!yolo task=segment mode=train epochs=100 data='/content/data.yaml' model=yolov8m-seg.pt imgsz=640
model = YOLO('/content/runs/segment/train/weights/best.pt')
model.predict(source='/content/test/images/3500_png.rf.4b9f17eb4355efb4e69c91649cf181ef.jpg', show=True, save=True, hide_labels = False, hide_conf = False, conf=0.5, iou = 0.5, save_txt=False, save_crop=False, show_boxes=False)

Hey there!

It looks like you've encountered an issue where labels and confidence levels are not being shown in your predictions, despite setting hide_labels and hide_conf to False. Based on the command you've used, everything seems correctly set up for displaying labels and confidences.

However, you've also set show_boxes=False, which might be influencing the visibility of labels and confidence scores, as they are generally tied to the display of bounding boxes. Try removing this argument or setting it to True to see if that resolves the issue:

model.predict(source='/content/test/images/3500_png.rf.4b9f17eb4355efb4e69c91649cf181ef.jpg', show=True, save=True, hide_labels=False, hide_conf=False, conf=0.5, iou=0.5, save_txt=False, save_crop=False, show_boxes=True)

If you continue facing issues, feel free to reach out again! Happy coding 😊

Hi! I did end up fixing this issue, the command I had to use was this:

model.predict(source='content/test/images/6000_png.rf.6e82bee61c3705bafa27ae6c6b8678b3.jpg', show=True, save=True, show_labels=True, show_conf=True, conf=0.5, iou=0.5, save_txt=False, save_crop=False)

I guess the yolo methods updated so hide_conf and hide_labels did not work entirely as it should. Thanks for the help!

@VisveshJ hi there! 👋

I'm glad to hear you managed to resolve the issue! 😊 Indeed, the YOLO methods have seen updates, and using show_labels=True and show_conf=True are the correct ways to ensure labels and confidence levels are displayed in your predictions. Your command looks good for getting the expected results.

Thanks for sharing your solution, and don't hesitate to come back if you have more questions or need further assistance. Happy coding with Ultralytics YOLO! 🚀

Hello Glenn,
Thank you for the clarification, that was extremely helpful.

Well I still have some more question;

1. Should train and the test datasets entirely different from each other?
2. How can deploy my model to the sets of new images to find the features I am interested in? I am working with astronomical images, which are around 5000 in numbers.

Thank you again, I appreciate your time.

Hello! Thanks for reaching out and for your kind words. 🌟

1. Train vs. Test datasets: Yes, it's generally advisable that the train and test datasets are entirely distinct from each other. This separation ensures that your model's performance evaluation on the test set reflects its ability to generalize to new, unseen data, which is crucial for understanding how well it might perform in real-world scenarios.

2. Deploying on new images: To deploy your model on a new set of astronomical images, you can use the predict mode in YOLOv8. Assuming your model is trained and ready, you'd iterate over your images and use the model to detect features of interest. Here's a code snippet to get you started:

   from ultralytics import YOLO
   import glob
   
   # Load your trained model
   model = YOLO('path/to/your/trained/model.pt')
   
   # Path to your new images
   images_path = glob.glob('path/to/your/astronomical/images/*.jpg')
   
   # Detect features in each image
   for img_path in images_path:
       results = model.predict(img_path)
       results.show()  # Or results.save(), depending on your needs

Please replace 'path/to/your/trained/model.pt' and 'path/to/your/astronomical/images/*.jpg' with your model's actual file path and the directory containing your new astronomical images.

I hope this helps, and feel free to ask if you have more questions. Good luck with your astronomical adventure! 🚀✨

Thank you very much for the help, it worked well.

Hey Glenn,
I have some more question, if you don't mind.

So did fine tuning of the pre trained model, and the results were as follows;

Accuracy: 0.70
Precision: 0.85
Recall or Completeness: 0.79
False Positive Rate (FPR): 0.14

I have doubt here, to what we should consider a good trained model. And one more thing, when I deployed this model to the rest of my datasets, the results were terrible, only a few detected featured were real. Could you help me with the same?
Thank you so much.

@Nitya476 hey there,

Thanks for reaching out with your questions! Let's dive into them:

1. Understanding Model Metrics: Your metrics show a decent starting point. Generally, a "good" model depends on your specific use case and requirements. High precision (0.85) indicates your model is reliable when it claims to have found a feature, while the recall (0.79) suggests it's quite good at finding all relevant features. However, a false positive rate (FPR) of 0.14 can be concerning depending on your needs, possibly indicating many incorrect feature detections.

2. Poor Results on the Rest of Your Datasets: This could be due to several reasons, including differences in data distribution between training/test sets and the rest, overfitting, or that the model hasn't generalized well.

A few suggestions to improve:

• Review your dataset: Ensure your training data is representative of your entire dataset. Consider augmenting your data if there's a significant difference.
• Hyperparameter tuning: Adjust learning rate, batch size, etc., considering Ultralytics documentation on training settings.
• Post-training adjustments: Use techniques like threshold adjustment for confidence and NMS to reduce false positives.

To deploy your model on your astronomical images, you can use a simple loop to run predictions, as you've likely already done following the guidance in my previous messages. Ensure your images are preprocessed similarly to how your training data was prepared.

If after trying out these suggestions you still face challenges, reviewing your training process or even the model architecture might be necessary, moving towards a structure more suited to the characteristics of your astronomical data.

I hope this helps! Keep experimenting, and don't hesitate to reach out with more questions. 🌌

Hello,

Absolutely! YOLO models learn to detect objects based on the annotations (labels) provided during training. These annotations serve as the "ground truth," indicating the correct answers the model should learn to predict.

When we perform validation (or use a test dataset), we still need these annotations to evaluate the model's predictions against the actual truth. It allows us to calculate metrics such as accuracy, precision, recall, etc., to understand how well the model is performing.

For instance, if we're validating a model trained to detect humans in images, we need to know where the humans are in the validation images (through annotations) to check if the model's predictions are correct.

To sum up, annotations in the validation/test sets enable us to measure the performance of our YOLO models objectively. It's like having an answer key to grade a test—the model makes its "guesses" (predictions), and we compare them against the annotations to see how well it did. 📊

Hope that clarifies your question! 😊

Thank you very much for the clarification.

@Nitya476 you're welcome! I'm glad the clarification helped. 😊 If you have any more questions or need further assistance with your YOLOv8 settings and configuration for different tasks and modes, feel free to reach out. Happy modeling with YOLOv8! 🚀

Hey there, it looks like there's an issue with your data.yaml file specifically related to a line that seems to be trying to execute a pip install command directly from the YAML (!pip install ultralytics). YAML files should contain structured data and not shell commands. 😊

Try removing the line:

!pip install ultralytics

from your data.yaml file. If the intention was to make sure the ultralytics package is installed, you should run this install command separately in your shell or notebook before running your training command.

After adjusting your YAML file, please try running your training command again. If you need any more help, feel free to ask!

Hello again,
I did fine tunning to. the model with the hyperparameters, and now results are even terrible;
Accuracy: 0.3272058823529412
Precision: 0.6707246376811594
Recall or Completeness: 0.38982479784366575
False Positive Rate (FPR): 0.3292753623188406

What can be done further?
Thanks

model = YOLO('yolov8n.pt')
model.tune(data='data.yaml', epochs=30, iterations=300, optimizer='AdamW', plots=False, save=False, val=False)
I am trying fine tunning of the pre-trained model, and then will try to deploy this fine tuned model to the new dataset.

Hello,

Seeing a decrease in performance metrics like accuracy, precision, recall, and an increase in False Positive Rate (FPR) after fine-tuning indicates that the hyperparameters might not be optimal for your dataset. Here are a few steps to consider:

1. Re-tune Hyperparameters: Consider adjusting hyperparameters, especially learning rate, which can significantly impact model performance.
2. Data Augmentation: Verify your augmentation strategies in data.yaml are appropriate for your dataset. Sometimes, too aggressive augmentations can harm performance.
3. Validate on Diverse Data: Ensure your validation set is representative of the data you wish to predict on. A mismatch can cause poor generalization.
4. Check Dataset Quality: Errors in labeling or unbalanced classes can affect model performance. Ensure your dataset is clean and well-labeled.

When deploying your model:

• Batch Inference: Instead of predicting image by image, consider batch processing for efficiency. Use batch with predict mode for this.
• Model Format: If performance is a concern, exporting your model to an optimized format like ONNX or TensorRT might help speed up inference without sacrificing accuracy.
• Quantization: Applying techniques like quantization can reduce model size and speed up inference, which could be beneficial for deployment.

Lastly, to track model performance numerically, consider using the validation (val) mode periodically during training to see how your model performs on unseen data. This can give you insights without having to visually inspect images.

!yolo task=detect mode=val model=runs/train/exp/weights/best.pt data=validation_data.yaml

This gives you a numeric measure of your model's performance on a validation dataset, offering insights into how well it's likely to perform in real-world scenarios.

Hope this helps, and feel free to reach out with more questions! 🌟

Thank you very much for the clarification. I appreciate your concern.

Could you guide me if the following is the correct way to fine tune the model?
model = YOLO('yolov8n.pt')
model.tune(data='data.yaml', epochs=30, iterations=300, optimizer='AdamW', plots=False, save=False, val=False)
Thankyou so much

Hi there! Your fine-tuning code snippet looks good, but let's make a minor adjustment to ensure optimal performance 😊:

model = YOLO('yolov8n.pt')
model.tune(data='data.yaml', epochs=30, optimizer='AdamW', save=True, plots=True)

Key points:

• iterations parameter isn't required; epochs is sufficient.
• Setting save=True and plots=True can help keep track of the tuning process.
• val=False isn't necessary unless you specifically want to skip validation.

Fine-tuning and deploying your model on a new dataset involves careful balance. If detection is underperforming:

• Ensure the dataset is correctly annotated.
• Consider more epochs or tweaking other hyperparameters.
• Use a validation set to monitor performance during fine-tuning.

Best of luck with your model training and deployment! 😄 Don't hesitate to reach out if you have more questions.

Hi there! 👋 You're absolutely right that the training and testing datasets should be entirely separate from each other to prevent any data leakage which could bias the model's performance evaluation.

For deploying your model on a new set of images to find specific features, especially considering your work with a large number of astronomical images, you can use the predict mode in YOLOv8. Here's a quick example of how you might do this if you've got your model trained and ready to go:

yolo detect predict model=path/to/your_model.pt source=path/to/your_images/

This command will process all images in the specified source directory, applying your model to each one to generate predictions that seek out the features you're interested in. Make sure to replace path/to/your_model.pt with the actual path to your trained model, and path/to/your_images/ with the path to the directory containing your astronomical images.

Keep innovating and exploring the cosmos through your images! 🚀 If you have any more questions or need further assistance, don't hesitate to reach out.

Thank you for the clarification.

@Nitya476 hey there!

Absolutely, ensuring your training and test datasets are entirely separate is key for an unbiased evaluation of your model's performance. 🌌 For deploying your model on a set of new images, especially considering you have about 5000 astronomical images, you can easily do this using the predict mode in YOLOv8. Here's how you might go about it:

from ultralytics import YOLO

# Assuming you've already trained your model and it's saved as "your_model.pt"
model = YOLO('path/to/your_model.pt')

# Now, let's predict a new set of images stored in "path/to/new_images/"
# This could be a directory containing all your astronomical images
results = model.predict(source='path/to/new_images/')

This will apply your model to all the images in the specified directory, making it a great way to explore those celestial features you're after. 🚀

Happy star-gazing with YOLOv8, and if you have any more questions or need further assistance, feel free to reach out!

Hello,

To use samplers for class balancing in YOLOv8, you can customize the data loading process by implementing a custom sampler in PyTorch. This involves creating a WeightedRandomSampler to ensure that each class is represented proportionally during training. Here's a brief outline of how you can achieve this:

1. Calculate Class Weights: Determine the weights for each class based on their frequency in the dataset.
2. Create a Sampler: Use torch.utils.data.WeightedRandomSampler with the calculated weights.
3. Integrate with DataLoader: Pass the sampler to the DataLoader.

Here's a simplified example:

import torch
from torch.utils.data import WeightedRandomSampler, DataLoader
from torchvision.datasets import ImageFolder
from torchvision import transforms

# Step 1: Calculate class weights
dataset = ImageFolder(root='path/to/dataset', transform=transforms.ToTensor())
class_counts = [0] * len(dataset.classes)
for _, label in dataset.samples:
    class_counts[label] += 1
class_weights = 1. / torch.tensor(class_counts, dtype=torch.float)
sample_weights = [class_weights[label] for _, label in dataset.samples]

# Step 2: Create a sampler
sampler = WeightedRandomSampler(weights=sample_weights, num_samples=len(sample_weights), replacement=True)

# Step 3: Integrate with DataLoader
dataloader = DataLoader(dataset, sampler=sampler, batch_size=16)

# Use this dataloader in your training loop

For more detailed guidance on configuring YOLOv8, please refer to the Configuration Guide.

Hello @A-tavv,

Thank you for your follow-up question! 😊

To clarify, the val=True parameter in your training script enables validation during the training process, which is why you see the validation set being used. This is a standard practice to monitor the model's performance on the validation set after each epoch.

If you want to ensure that your model is trained on the training set and validated on the validation set, your current setup is correct. The val=True parameter does not mean the model is trained on the validation set; it simply means that after each epoch, the model's performance is evaluated on the validation set.

Here’s a breakdown of your code:

results = model.train(
    data="/content/data.yaml",
    epochs=100,
    imgsz=640,
    lr0=0.001,
    weight_decay=0.0005,
    verbose=True,
    name='exp',
    val=True  # This enables validation during training
)

This configuration ensures that:

• The model is trained on the training set specified in your data.yaml file.
• After each epoch, the model's performance is validated using the validation set specified in the same data.yaml file.

If you want to disable validation during training (not recommended as it helps in monitoring overfitting and model performance), you can set val=False:

results = model.train(
    data="/content/data.yaml",
    epochs=100,
    imgsz=640,
    lr0=0.001,
    weight_decay=0.0005,
    verbose=True,
    name='exp',
    val=False  # Disables validation during training
)

However, it's generally a good practice to keep validation enabled to ensure your model is learning correctly and not overfitting to the training data.

If you have any further questions or need additional assistance, feel free to ask. We're here to help! 🚀

Thank you for clarification, the thing is it is good to monitor validation sure, but it also uses the validation set for training that’s why i was shocked at the end of the process, so now that I know about overfitting or non overfitting of the model, I will disable the Val = False to train on training data solo is this correct assumption?

Hello @A-tavv,

Thank you for your detailed follow-up! 😊

I understand your concern about the validation set being used during training. It's important to clarify that while validation is performed after each epoch to monitor the model's performance, the training itself is done exclusively on the training set. The val=True parameter simply enables this monitoring and does not mean the model is trained on the validation set.

If you disable validation by setting val=False, the model will still train on the training set, but you won't get the periodic performance metrics on the validation set, which are crucial for understanding how well your model generalizes to unseen data.

Here’s a quick breakdown of your options:

1. Training with Validation (Recommended):

   results = model.train(
       data="/content/data.yaml",
       epochs=100,
       imgsz=640,
       lr0=0.001,
       weight_decay=0.0005,
       verbose=True,
       name='exp',
       val=True  # Enables validation during training
   )

   This setup ensures that your model is trained on the training set and validated on the validation set after each epoch, providing valuable insights into overfitting and generalization.

2. Training without Validation:

   results = model.train(
       data="/content/data.yaml",
       epochs=100,
       imgsz=640,
       lr0=0.001,
       weight_decay=0.0005,
       verbose=True,
       name='exp',
       val=False  # Disables validation during training
   )

   This will train the model solely on the training set without any validation checks. Use this if you are certain about your model’s performance or if you want to save computational resources.

For optimal model performance and to avoid overfitting, it's generally a good practice to keep validation enabled. This way, you can monitor the model's progress and make necessary adjustments.

If you have any further questions or need additional assistance, feel free to ask. We're here to help! 🚀

so you are saying in this procedure the model has been trained on Training set? since the result is not good and the last result is on 604 images that are my validation set not training set please correct me if I am wrong thanks in advance.

Hello @A-tavv,

Thank you for your question and for providing the screenshot. I understand your concern regarding the training and validation process.

To clarify, during the training process, the model is indeed trained on the training set specified in your data.yaml file. The validation set is used to evaluate the model's performance after each epoch, which is why you see results related to your 604 validation images.

The numbers you see in the log (e.g., 604) correspond to the number of images in your validation set. This validation step is crucial as it helps monitor the model's performance and detect overfitting or underfitting.

If you want to ensure that the model is only trained on the training set and not evaluated on the validation set during training, you can disable validation by setting val=False in your training script. However, please note that this will prevent you from monitoring the model's performance on the validation set during training.

Here is an example of how to disable validation during training:

from ultralytics import YOLO

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

# Train the model without validation
results = model.train(
    data="/content/data.yaml",
    epochs=100,
    imgsz=640,
    lr0=0.001,
    weight_decay=0.0005,
    verbose=True,
    name='exp',
    val=False  # Disables validation during training
)

This setup will train the model solely on the training set without performing validation after each epoch.

If you are still experiencing issues or if the results are not as expected, please ensure you are using the latest versions of torch and ultralytics. You can update them using:

pip install --upgrade torch ultralytics

Additionally, if you could provide a minimum reproducible example of your code, it would help us investigate the issue further. You can refer to our Minimum Reproducible Example Guide for more details.

Feel free to reach out if you have any more questions or need further assistance. We're here to help! 😊

@umarabdullah16 hi there!

Thank you for reaching out with your issue. It sounds like you're encountering a problem where your training images are being classified as background, and you're seeing an error about no labels found in the labels.cache. Let's work through this together.

First, let's ensure a few key points:

1. Directory Structure: Verify that your directory structure is correct. It should look something like this:

   dataset/
   ├── train/
   │   ├── images/
   │   │   ├── img1.jpg
   │   │   ├── img2.jpg
   │   ├── labels/
   │   │   ├── img1.txt
   │   │   ├── img2.txt
   ├── val/
   │   ├── images/
   │   │   ├── img1.jpg
   │   │   ├── img2.jpg
   │   ├── labels/
   │   │   ├── img1.txt
   │   │   ├── img2.txt
   

2. Label Files: Ensure that each image in the train/images directory has a corresponding label file in the train/labels directory. The label files should be in the same format as the images, i.e., img1.jpg should have a img1.txt.

3. Data Configuration File: Check your data.yaml file to ensure the paths are correctly specified. It should look something like this:

   train: path/to/train/images
   val: path/to/val/images
   nc: 80  # number of classes
   names: ['class1', 'class2', ...]  # list of class names

4. Label Content: Verify that the label files are not empty and contain the correct annotations. Each line in a label file should follow the format:

   class_id x_center y_center width height
   

If everything seems correct and you're still facing issues, please provide a minimum reproducible example of your code and dataset structure. This will help us better understand the problem and provide a more accurate solution. You can refer to our guide on creating a minimum reproducible example here: Minimum Reproducible Example.

Additionally, ensure that you are using the latest versions of torch and ultralytics. You can update your packages using:

pip install --upgrade torch ultralytics

If you continue to experience issues, please share the exact error message and any relevant logs. This will help us diagnose the problem more effectively.

Looking forward to your response so we can get this resolved for you! 😊

@alifazeli00 to view the range of values for training settings, refer to the "Train Settings" section in the documentation. It provides detailed descriptions and default values for each parameter.

Some values for the "Train Settings" are not defined for their range, including both start and end points, similar to what is specified in the "Augmentation Settings" section.

Thank you for your feedback. Currently, the range of values for some "Train Settings" isn't explicitly defined like in "Augmentation Settings." We'll consider this for future updates. For now, please refer to the default values as a guideline.

@bejaouiaziz to start hyperparameter evolution for 300 generations, use the yolo evolve command with the desired parameters. This process will automatically optimize hyperparameters based on validation results. For detailed guidance, refer to the Ultralytics documentation.

@subwheel to view all validation results, ensure you set save=True in your validation command. This will save predictions for all images in your dataset. For more details, refer to the YOLOv8 Configuration Guide.

I tried save=True. But still can only see 3 batches. Or is it the problem of my code?
My code is
!yolo val split=test plots=True model=runs/detect/train4/weights/best.pt data=data_NFCT.yaml device=0 save=True

@subwheel it seems like your validation results aren't saving all images. Ensure that your dataset path in data_NFCT.yaml is correct and that the save=True argument is properly set. If the issue persists, try increasing the batch size to ensure all images are processed.