Hyperparameter Tuning with Ray Tune and YOLOv8 - Ultralytics YOLOv8 Docs

[giscus[bot]]

Hyperparameter Tuning with Ray Tune and YOLOv8 - Ultralytics YOLOv8 Docs

Discover how to integrate hyperparameter tuning with Ray Tune and Ultralytics YOLOv8. Speed up the tuning process and optimize your model's performance.

https://docs.ultralytics.com/usage/hyperparameter_tuning/?h=hyper

[sam-a-d]

If I define space as "space={"lr0": tune.uniform(1e-5, 1e-1)}", then what will be the values of the other parameters i.e., imgsz, batch? Does the tuner uses default values for them?

Thank you.

[AyushExel]

The value of other parameter will be the ones in the default config file https://docs.ultralytics.com/usage/cfg/

[sam-a-d]

Oh, got it! Thanks.

[pderrenger]

@Samad-sust you're welcome! If you have any more questions or need further assistance, feel free to ask. Good luck with your hyperparameter tuning! 👍

[noorraghib12]

Hi, how should I resize my images for training in yolov8 while generating in roboflow ? do I keep the aspect ratio correct ? Or just go with 640 x640 as recommended in yolov5 docs or should I just let the ultralytics module do the resizing during training and just keep my images and annotations as is in the originally annotated image ?

[sss777999]

Hi, you can choose any size you want for image in imgsz param when train, as for annotations you need to normalize it or them will not be correct after resize!

[pderrenger]

@sss777999 hello! When preparing your images for training with YOLOv8, it's generally recommended to maintain the aspect ratio to prevent distortion of the image content. However, YOLOv8 is quite flexible and can handle various image sizes.

If you're using Roboflow to preprocess your images, you can resize them to a square format like 640x640, which is a common input size for YOLO models. Roboflow can also handle aspect ratio correction by padding the images to maintain the original aspect ratio.

Alternatively, you can let the Ultralytics YOLOv8 module handle the resizing during training by specifying the imgsz parameter. The module will automatically resize the images while maintaining the aspect ratio using letterboxing (adding padding).

For annotations, it's important that they are normalized relative to the image width and height, as YOLOv8 expects annotations in this format. If you're using Roboflow, it can take care of this normalization for you.

In summary, you have the flexibility to resize images before training or let the YOLOv8 module do it during training. Just ensure that your annotations are correctly normalized if you're resizing beforehand. 😊👍

[JeanN00B]

I am tuning my model, but when I apply this config in google colab environment, it throws me this Error: (autoscaler +35m28s) Error: No available node types can fulfill resource request {'GPU': 1.0, 'CPU': 8.0}. But I did not even selected the ammount of CPUs in any part of the code, but the ray tune library detects that the colab has 1 GPU and 2 CPUs. How can I fix this? I tried to use the "resource_per_trial" but it is not compatible with the model.tune()... Any help will be appreciated :c.

[sam-a-d]

If you visit model.py in ultralytics, you can see the following line where they defined the resources themselves, the code is

trainable_with_resources = tune.with_resources(_tune, {'cpu': 8, 'gpu': gpu_per_trial if gpu_per_trial else 0})

so yo can override the no of cpu in your own going to the main method as this method does not get cpu values as a parameter.

[JeanN00B]

Thanks man! everything works fine now :,D

[pderrenger]

@JeanN00B i'm glad to hear that everything is working fine now! 😄 If you have any more questions or need further assistance with YOLOv8, don't hesitate to reach out. Happy modeling and best of luck with your project! 🚀

[sam-a-d]

How to check the best set of hyperparameters from model.tune(), because the result only gives the calculated metrics such as mAP, loss etc. Is there any method to display the hyperparameters for a result to be caused. Most probably ray has a method something like get_best_config()

[sss777999]

check args.yaml in dirrectory with best trial

[xsellart1]

I think you can do:
result = model.tune()
print(result.get_best_result(metric = 'metrics/mAP50(B)', mode = 'max'))

[pderrenger]

@xsellart1 the model.tune() method in YOLOv8 indeed performs hyperparameter optimization and returns the tuning results, including metrics like mAP and loss. To retrieve the best hyperparameter configuration from these results, you can use the get_best_result() method from the Ray Tune library, which is typically used alongside YOLOv8 for hyperparameter tuning.

However, in YOLOv8, the best hyperparameters are automatically saved in an args.yaml file within the directory of the best trial. You can find this file by navigating to the directory corresponding to the best trial's results. This args.yaml file contains the hyperparameters that led to the best performance during the tuning process.

If you're using Ray Tune's API directly, you can indeed use get_best_config() or similar methods provided by Ray Tune to extract the best hyperparameters. But within the context of YOLOv8's tuning process, you should refer to the saved args.yaml file for this information.

If you have any further questions or need assistance with specific parts of the tuning process, feel free to refer to the Ultralytics documentation or ask for help! 😊

[sss777999]

Hello, i'm using 4 gpu's for tune, but dont understand is it parallel tuning, or not. Seems them are loaded after each other, despite the fact that four trials work, as it shown.

model = YOLO("my_model.pt")
result = model.tune(data="....yaml", space={
"lr0": tune.uniform(1e-5, 1e-1),
"optimizer": "Adam",
"weight_decay": tune.uniform(0.0, 0.001),
"warmup_epochs": tune.uniform(0.0, 5.0),
"box": tune.uniform(0.02, 0.2),
"cls": tune.uniform(0.2, 4.0)},
train_args={"epochs": 100},
gpu_per_trial=1, # if 1 have 4 running trials, but is it parallel learning?
max_samples=100)

[sss777999]

resolved

[john09282922]

Hi, How did u type in tune() ? I cant work for it.

[pderrenger]

@john09282922 hello! To use the tune() function with YOLOv8, you'll need to ensure that you have the correct setup, including the necessary dependencies installed, such as Ray Tune. The tune() function is designed to help you find the best hyperparameters for your model by running multiple trials.

Here's a basic example of how to use tune() with YOLOv8:

from ultralytics import YOLO
from ray import tune

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

# Define the hyperparameter search space
space = {
    "lr0": tune.uniform(1e-5, 1e-1),
    "weight_decay": tune.uniform(0.0, 0.001),
    "warmup_epochs": tune.uniform(0.0, 5.0),
    "box": tune.uniform(0.02, 0.2),
    "cls": tune.uniform(0.2, 4.0)
}

# Define additional training arguments
train_args = {"epochs": 100}

# Start the hyperparameter tuning process
result = model.tune(
    data="path/to/your/data.yaml",
    space=space,
    train_args=train_args,
    gpu_per_trial=1,
    max_samples=100
)

Make sure that the paths to your model and data files are correct. The gpu_per_trial parameter specifies how many GPUs to use per trial. If you have 4 GPUs and set gpu_per_trial=1, you can run 4 trials in parallel, each on a separate GPU.

If you encounter any issues, please refer to the Ultralytics YOLOv8 documentation for more detailed instructions and troubleshooting tips. If you need further assistance, don't hesitate to ask!

[sss777999]

And have somne problem with tune(), how to resolve this issue?

(_tune pid=37800) E0521 07:39:32.533525975 95064 thread_pool.cc:253] Waiting for thread pool to idle before forking [repeated 8x across cluster]

[sss777999]

resolved

[fahmiraouin4366]

I downloaded Ultralytics using << pip install -U ultralytics "ray[tune]" >>
The program reported an error 'AttributeError: 'YOLO' object has no attribute 'tune'
Can you please tell me how to implement the tune function in YOLOv8?

[Clemens-E]

@sss777999 you should really write down your solution instead of "resolved", anyone else having the problem will have no idea what causes it or how to fix it.

[joejep]

Please How can i output or display the bounding box, class probabilities

[pderrenger]

@eiyike123 to output or display the bounding box and class probabilities using Ultralytics YOLOv8, you can follow these steps in Python:

1. Load your YOLOv8 model with a pretrained weight file.
2. Perform inference on your image or video source.
3. Access the Results object to get the bounding boxes and class probabilities.
4. Use the plot() method to visualize the results with bounding boxes and class probabilities on the image.

Here's an example in Python:

from ultralytics import YOLO

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

# Perform inference on an image
results = model('path/to/your/image.jpg')

# Access bounding boxes and class probabilities
for result in results:
    boxes = result.boxes.xyxy  # Bounding boxes in xyxy format
    confs = result.boxes.conf  # Confidence scores
    classes = result.boxes.cls  # Class IDs

    # Print bounding box coordinates, confidence scores, and class IDs
    for box, conf, cls in zip(boxes, confs, classes):
        print(f'Bounding Box: {box}, Confidence: {conf}, Class ID: {cls}')

# Visualize and display the results with bounding boxes and class probabilities
annotated_image = results[0].plot(show_labels=True, show_conf=True)

This code snippet will print the bounding box coordinates, confidence scores, and class IDs to the console. It will also visualize the results on the image, showing the bounding boxes and class probabilities. If you want to save the visualized image, you can use the save argument in the plot() method or use the cv2.imwrite() function if you're working with OpenCV.

[scraus]

Is it required to pass the number of epochs in the train_args parameter? If so, is it possible for Ray tune to suggest us with the best number of epoch to go for?

[pderrenger]

@scraus when using Ray Tune with YOLOv8 for hyperparameter optimization, it's not strictly necessary to pass the number of epochs in the train_args parameter. The number of epochs is a hyperparameter that you can choose to optimize or set to a fixed value based on your training strategy and computational resources.

If you decide to include the number of epochs as a hyperparameter for Ray Tune to optimize, you can define a search space for it, and Ray Tune will explore different values within this space to find the best number of epochs for your model. However, keep in mind that training for more epochs will generally require more time and computational resources.

To include the number of epochs in the Ray Tune search space, you can define it similarly to other hyperparameters in your configuration. Here's an example of how you might set up a search space that includes the number of epochs:

from ray import tune

# Define the search space for hyperparameters, including the number of epochs
config = {
    "epochs": tune.choice([5, 10, 20, 30]),  # Example choices for the number of epochs
    "lr0": tune.loguniform(1e-4, 1e-1),      # Learning rate
    "momentum": tune.uniform(0.8, 0.95),     # Momentum
    # Add other hyperparameters here
}

# Start the hyperparameter tuning run with Ray Tune
tune.run(
    train_func,  # Your training function
    config=config,
    num_samples=10,  # Number of times to sample from the hyperparameter space
    resources_per_trial={"cpu": 8, "gpu": 1},  # Resources for each trial
    # Additional Ray Tune options here
)

In this example, Ray Tune will evaluate the model with 5, 10, 20, or 30 epochs, along with other hyperparameters, to find the best combination. The num_samples parameter determines how many different configurations will be tested.

Remember to monitor the performance metrics closely to determine if additional epochs are leading to overfitting or if they are beneficial for your model's generalization.

[fahmiraouin4366]

I downloaded Ultralytics using << pip install -U ultralytics "ray[tune]" >>
The program reported an error 'AttributeError: 'YOLO' object has no attribute 'tune'
Can you please tell me how to implement the tune function in YOLOv8?

[glenn-jocher]

@fahmiraouin4366 the tune function is a recent addition to the YOLO class, you likely need to update your ultralytics package to the latest version to be able to use it:

pip install -U ultralytics
```

For detailed instructions and examples, please refer to the [Ultralytics YOLOv8 documentation on hyperparameter tuning](https://docs.ultralytics.com/usage/hyperparameter_tuning/). If you encounter any issues or need further assistance, feel free to raise an issue on the [Ultralytics YOLOv8 GitHub repository](https://github.com/ultralytics/ultralytics/issues), and the community will be happy to help! 🚀

[JeanN00B]

I was looking in the ray tune documentation, and I saw that the assignment of the hyperparameters are random by default, but it is possible to use an bayesian optimization algorithm that is implemented in the ray tune. How can I change the default "search_alg" to use bayesian optimization with embedded implementation with YOLOv8?

[glenn-jocher]

@JeanN00B to use Bayesian Optimization with Ray Tune in YOLOv8, you'll need to modify the hyperparameter tuning script to specify the BayesOptSearch algorithm as the search_alg. Here's a concise example of how you can do this:

1. First, ensure you have Ray Tune installed:

   pip install 'ray[tune]'

2. Import the necessary classes from Ray Tune:

   from ray import tune
   from ray.tune.suggest.bayesopt import BayesOptSearch

3. Set up the Bayesian Optimization search algorithm:

   bayesopt = BayesOptSearch()

4. Pass the bayesopt object to the tune.run() function:

   analysis = tune.run(
       train_yolov8,  # Replace with your training function
       config=config,  # Replace with your config dict
       search_alg=bayesopt,
       num_samples=10,  # Number of hyperparameter sets to try
       stop={"training_iteration": 100},  # Stopping criteria
       # ... other parameters
   )

5. Run your script, and Ray Tune will use Bayesian Optimization for hyperparameter tuning.

Make sure to replace train_yolov8 with your actual training function and config with your configuration dictionary containing the hyperparameter search space.

For more detailed guidance, please refer to the Ray Tune documentation and the Ultralytics YOLOv8 documentation.

[heilrahc]

Hi, I want to get the features from an arbitrary layer of the classification model. How can I do that?

[pderrenger]

@heilrahc we don't have a simple way to extract features from an arbitrary layer, but you can get feature vectors, or "embeddings" for the model as a whole using the model.embed() method.

Here's a concise example of how to do this in Python:

from ultralytics import YOLO
import torch

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

# Prepare your image or batch of images
images = torch.randn(1, 3, 640, 640)  # Example input tensor

# Get feature vectors
features = model.embed(images)

Make sure to replace 'path/to/your/classification-model.pt' with the actual path to your model.

If you need further assistance, feel free to ask! 🚀

[Rasantis]

How to insert Yolo V8 in this existing code ?I need it to detect the cars and assign an ID to each one... my code to be integrated... help please..

import cv2
import easyocr
import threading
import re
from openpyxl import load_workbook, Workbook
from openpyxl.utils import get_column_letter
from openpyxl.styles import Alignment
import datetime
import time

harcascade = "model/haarcascade_russian_plate_number.xml"
previous_plate_content = ""
count = 0

Captura de vídeo

cap = cv2.VideoCapture("vd_garagem.mp4")
cap.set(3, 640) # largura
cap.set(4, 480) # altura

min_area = 500

reader = easyocr.Reader(['en'], gpu=False) # Defina os idiomas que deseja reconhecer

def process_frame():
global previous_plate_content, count

# Criação do arquivo Excel
wb = Workbook()
sheet = wb.active
sheet["A1"] = "Placa"
sheet["B1"] = "Horário de Entrada"

fps_start_time = time.time()
fps_counter = 0

while cap.isOpened():
    success, img = cap.read()

    if not success:
        break

    plate_cascade = cv2.CascadeClassifier(harcascade)
    img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    plates = plate_cascade.detectMultiScale(img_gray, 1.1, 4)

    # Encontre a placa com a maior área
    max_area = 0
    max_plate = None

    for (x, y, w, h) in plates:
        area = w * h

        if area > min_area and area > max_area:
            max_area = area
            max_plate = (x, y, w, h)

    if max_plate is not None:
        x, y, w, h = max_plate

        cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
        cv2.putText(img, "Placa", (x, y - 5), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (255, 0, 255), 2)

        img_roi = img[y: y + h, x: x + w]

        try:
            result = reader.readtext(img_roi, detail=0)

            if result and result[0] != previous_plate_content:
                plate_content = result[0]

                pattern1 = r"^[A-Z]{3}\s\d{4}$"
                pattern2 = r"^[A-Z]{3}\d[A-Z]\d{2}$"

                match1 = re.match(pattern1, plate_content)
                match2 = re.match(pattern2, plate_content)

                if match1 or match2:
                    print("Placa reconhecida:", plate_content)
                    previous_plate_content = plate_content

                    count += 1
                    sheet["A" + str(count + 1)] = plate_content
                    sheet["B" + str(count + 1)] = datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")
                    sheet["A" + str(count + 1)].alignment = Alignment(horizontal="center")
                    sheet["B" + str(count + 1)].alignment = Alignment(horizontal="center")

                    # Salvando o arquivo Excel a cada nova placa reconhecida
                    try:
                        wb.save("registros_placas.xlsx")
                    except Exception as e:
                        print("Erro ao salvar o arquivo Excel:", e)

        except Exception as e:
            print("Erro ao ler a placa:", e)

    cv2.namedWindow("Resultado", cv2.WINDOW_NORMAL)
    cv2.resizeWindow("Resultado", 800, 600)
    cv2.imshow("Resultado", img)

    if cv2.waitKey(1) == ord('s'):
        cv2.rectangle(img, (0, 200), (640, 300), (0, 255, 0), cv2.FILLED)
        cv2.putText(img, "Placa Salva", (150, 265), cv2.FONT_HERSHEY_COMPLEX_SMALL, 2, (0, 0, 255), 2)
        cv2.imshow("Resultado", img)
        cv2.waitKey(500)

    # fps_counter += 1
    # if time.time() - fps_start_time >= 1:
    #     print("FPS:", fps_counter)
    #     fps_counter = 0
    #     fps_start_time = time.time()

cap.release()

frame_thread = threading.Thread(target=process_frame)
frame_thread.start()
frame_thread.join()

[pderrenger]

@Rasantis to integrate YOLOv8 for car detection and tracking in your existing code, you'll need to replace the Haar cascade section with YOLOv8's detection and tracking capabilities. Here's a modified version of your code that uses YOLOv8 for car detection and assigns an ID to each car:

import cv2
import easyocr
import threading
from openpyxl import load_workbook, Workbook
from openpyxl.styles import Alignment
import datetime
import time
from ultralytics import YOLO  # Import YOLOv8

# Load YOLOv8 model for car detection
model = YOLO('yolov8n.pt')  # Use the appropriate model file

# Video capture
cap = cv2.VideoCapture("vd_garagem.mp4")
cap.set(3, 640)  # Width
cap.set(4, 480)  # Height

# Initialize EasyOCR reader
reader = easyocr.Reader(['en'], gpu=False)

# Initialize Excel workbook
wb = Workbook()
sheet = wb.active
sheet["A1"] = "Plate"
sheet["B1"] = "Entry Time"
count = 0

def process_frame():
    global count
    fps_start_time = time.time()
    fps_counter = 0

    while cap.isOpened():
        success, img = cap.read()
        if not success:
            break

        # Run YOLOv8 model for car detection and tracking
        results = model.track(img, show=False)  # Set show=True to visualize tracking

        # Process results
        for result in results:
            for box in result.boxes:
                x1, y1, x2, y2 = map(int, box.xyxy)
                cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(img, f"Car ID: {box.id}", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 0), 2)

                # License plate recognition (optional)
                # img_roi = img[y1: y2, x1: x2]
                # result = reader.readtext(img_roi, detail=0)
                # # Process license plate text...

        cv2.imshow("Result", img)
        if cv2.waitKey(1) == ord('q'):
            break

        # FPS calculation (optional)
        # fps_counter += 1
        # if time.time() - fps_start_time >= 1:
        #     print("FPS:", fps_counter)
        #     fps_counter = 0
        #     fps_start_time = time.time()

    cap.release()
    cv2.destroyAllWindows()

# Start processing frames in a separate thread
frame_thread = threading.Thread(target=process_frame)
frame_thread.start()
frame_thread.join()

Please note the following changes:

• The Haar cascade section is removed, and YOLOv8 is used for car detection and tracking.
• The model.track() function is used to perform object tracking, which assigns a unique ID to each detected car.
• The license plate recognition section is commented out, as it's optional and depends on whether you want to combine YOLOv8 detection with EasyOCR for plate recognition.
• The FPS calculation section is commented out but can be included if needed.

Make sure to install the ultralytics package and download the appropriate YOLOv8 model file before running this code. Adjust the model instantiation line to use the correct model file for car detection.

[priyakanabar-crest]

Hello, I have detected the cow using YOLOV8, now i want to store the image and the unique features of cow from which it is detected , so that next time if i have image of same cow , i can identify it based on stored results earlier, is there any way i can do that ? please provide your views

Thank you

[pderrenger]

@priyakanabar-crest to achieve this, you would typically need a feature extraction and comparison mechanism. YOLOv8 can detect objects and provide bounding boxes, but for individual identification and feature storage, you might need additional steps. Here's a high-level approach:

1. Detection: Use YOLOv8 to detect cows in images and obtain bounding boxes.
2. Feature Extraction: Extract features from the detected cow regions. This could be done using a separate model trained for feature extraction, such as a siamese network or a pre-trained model on a similar task.
3. Feature Storage: Store the extracted features in a database. You can use the features as a unique identifier for each cow.
4. Identification: For a new image, after detecting the cow, extract features using the same method and compare them with the stored features to find the best match.

YOLOv8 does not natively support feature extraction for re-identification. However, you can export the detected regions using YOLOv8 and then use another model or method for feature extraction. Here's an example of how you might do this with YOLOv8:

from ultralytics import YOLO
import cv2

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

# Detect objects in an image
results = model('cow_image.jpg')

# Select result for image index 0
result = results[0]

# Extract bounding boxes for cows
cow_boxes = [box.xyxy for box in result.boxes if result.names[box.cls] == 'cow']

# Crop and save cow images
for i, box in enumerate(cow_boxes):
    crop = result.orig_img[int(box[1]):int(box[3]), int(box[0]):int(box[2])]
    cv2.imwrite(f'cow_{i}.jpg', crop)

    # Here you would pass 'crop' to your feature extraction model and save the features

For the feature extraction and comparison part, you would need to implement or use an existing solution tailored to your specific needs. This could involve deep learning models that are trained to extract and compare features from images of cows. Once you have the features, you can use various similarity metrics (e.g., cosine similarity) to compare them and identify if the cow has been seen before.

Remember to train your feature extraction model on a dataset representative of the cows you want to identify, and ensure that the features are robust enough to handle variations in pose, lighting, and occlusions.

[danielzhangau]

Hi there, I am running the hyperparameter tuning by using the following command:

model = YOLO("yolov8n.pt")
results = model.tune(
    data="./ultralytics/datasets/xxx.yaml",
    gpu_per_trial=2,
)

1. How long it will take to finish and where can I get the final result?
2. I am training a xlarge model, but apparently tuning for xlarge model will take ages. What is the drawbacks of using nano tuned hyperparameters to training xlarge model?

[pderrenger]

@danielzhangau 1. The duration of hyperparameter tuning with Ray Tune can vary significantly based on several factors, including the size and complexity of your model, the size of your dataset, the range and number of hyperparameters being tuned, and the computational resources available (e.g., the number of GPUs). Once the tuning process is complete, you can find the final results in the results object returned by the model.tune() method. Additionally, Ray Tune typically saves detailed logs and checkpoints in a directory (often named ray_results/) in your current working directory, which you can review for comprehensive results and to identify the best hyperparameters.

2. Using nano-tuned hyperparameters for training an xlarge model could potentially lead to suboptimal performance. The nano model has a different architecture and capacity compared to the xlarge model, which means the optimal hyperparameters for one may not be the best for the other. The drawbacks could include slower convergence, lower accuracy, or overfitting/underfitting issues. It's generally recommended to perform hyperparameter tuning on the same model architecture that you plan to use for your final training to ensure the best possible performance. However, if computational resources are a constraint, starting with nano-tuned hyperparameters can provide a reasonable baseline, which you can then refine for the xlarge model as needed.

[akashAD98]

raytune is not working for yolovm,l,x models, only n & s model is working, always getting the

ValueError: The actor ImplicitFunc is too large (209 MiB > FUNCTION_SIZE_ERROR_THRESHOLD=95 MiB). Check that its definition is not implicitly capturing a large array or other object in scope. Tip: use ray.put() to put large objects in the Ray object store.

no matter how small or big data, its falling for this m,x,l model

[pderrenger]

@akashAD98 it seems you're encountering an issue with Ray Tune's actor size when trying to perform hyperparameter tuning on larger YOLOv8 models like m, x, and l. This error typically occurs when the object being passed to the Ray actor is too large, exceeding the default threshold.

Here are a few steps you can take to address this issue:

1. Reduce the size of the model: If possible, try using a smaller model variant that requires less memory.

2. Increase Ray's size threshold: You can increase the FUNCTION_SIZE_ERROR_THRESHOLD to allow larger objects. However, this is not recommended as it may lead to performance issues or out-of-memory errors.

3. Optimize your code: Ensure that you're not unintentionally capturing large objects in the scope of the function that's being parallelized by Ray Tune. Use ray.put() to store large objects in Ray's object store explicitly.

4. Use a smaller dataset: If you're using a large dataset for tuning, consider using a subset to reduce the memory footprint.

5. Check Ray Tune's documentation: For advanced usage, you may find additional optimization techniques in the Ray Tune documentation.

6. Seek support from Ray community: If the issue persists, consider reaching out to the Ray community or checking their GitHub issues for similar problems and potential solutions.

Remember that YOLOv8's larger models (m, x, l) inherently require more memory, so you may need to adjust your tuning setup accordingly. If you're still having trouble, please provide more details about your setup, and we can look into this further.

[sarar1997]

Hi, How we can set the YOLO saves the best precision model ? lets say I am not interested in mAP50 or mAp50-95, How can I save the best precision ?
Thank you

[glenn-jocher]

@sarar1997 to save the best precision model during training, you can modify the save_best argument in the training configuration to target the precision metric. However, YOLOv8 does not directly support saving the best model based on precision alone out-of-the-box.

Precision is typically calculated during the validation phase, and YOLOv8 saves the best model based on mAP (mean Average Precision) by default. If you want to save models based on precision, you would need to customize the validation and checkpoint saving code to calculate precision and use it as the criterion for saving the best model.

Here's a general outline of the steps you would need to take:

1. Modify the Validation Code: Adjust the validation code to calculate precision for your dataset. Precision is the ratio of true positive detections to the sum of true positive and false positive detections.

2. Customize Checkpoint Saving: Change the checkpoint saving logic to compare the current precision with the best precision seen so far. If the current precision is higher, save the current model as the best model.

3. Run Training: Start the training process with your custom code changes.

Please note that these changes require a good understanding of the YOLOv8 codebase and might involve a fair amount of coding. If you're not comfortable making these changes yourself, you might consider using the default mAP-based model saving or seeking help from someone with experience in modifying deep learning training pipelines.

For further assistance, you can always reach out to the Ultralytics team or the community on GitHub. 🚀

[Hijaaaz]

Hi anybody on still here

[glenn-jocher]

@Hijaaaz hi there! We're here to help with any Ultralytics-related questions you have. Feel free to ask about our YOLO models, training, inference, or documentation and we'll do our best to assist. 😊