Add FAQ sections to Modes and Tasks (#14181)
Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com> Co-authored-by: UltralyticsAssistant <web@ultralytics.com> Co-authored-by: Abirami Vina <abirami.vina@gmail.com> Co-authored-by: RizwanMunawar <chr043416@gmail.com> Co-authored-by: Muhammad Rizwan Munawar <muhammadrizwanmunawar123@gmail.com>
This commit is contained in:
Glenn Jocher
GitHub
parent
e285d3d1b2
commit
6c13bea7b8
39 changed files with 2247 additions and 481 deletions
|
|
@ -99,3 +99,126 @@ Here are all supported callbacks. See callbacks [source code](https://github.com
|
|||
| ----------------- | ---------------------------------------- |
|
||||
| `on_export_start` | Triggered when the export process starts |
|
||||
| `on_export_end` | Triggered when the export process ends |
|
||||
|
||||
## FAQ
|
||||
|
||||
### What are Ultralytics callbacks and how can I use them?
|
||||
|
||||
**Ultralytics callbacks** are specialized entry points triggered during key stages of model operations like training, validation, exporting, and prediction. These callbacks allow for custom functionality at specific points in the process, enabling enhancements and modifications to the workflow. Each callback accepts a `Trainer`, `Validator`, or `Predictor` object, depending on the operation type. For detailed properties of these objects, refer to the [Reference section](../reference/cfg/__init__.md).
|
||||
|
||||
To use a callback, you can define a function and then add it to the model with the `add_callback` method. Here's an example of how to return additional information during prediction:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
|
||||
def on_predict_batch_end(predictor):
|
||||
"""Handle prediction batch end by combining results with corresponding frames; modifies predictor results."""
|
||||
_, image, _, _ = predictor.batch
|
||||
image = image if isinstance(image, list) else [image]
|
||||
predictor.results = zip(predictor.results, image)
|
||||
|
||||
|
||||
model = YOLO("yolov8n.pt")
|
||||
model.add_callback("on_predict_batch_end", on_predict_batch_end)
|
||||
for result, frame in model.predict():
|
||||
pass
|
||||
```
|
||||
|
||||
### How can I customize Ultralytics training routine using callbacks?
|
||||
|
||||
To customize your Ultralytics training routine using callbacks, you can inject your logic at specific stages of the training process. Ultralytics YOLO provides a variety of training callbacks such as `on_train_start`, `on_train_end`, and `on_train_batch_end`. These allow you to add custom metrics, processing, or logging.
|
||||
|
||||
Here's an example of how to log additional metrics at the end of each training epoch:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
|
||||
def on_train_epoch_end(trainer):
|
||||
"""Custom logic for additional metrics logging at the end of each training epoch."""
|
||||
additional_metric = compute_additional_metric(trainer)
|
||||
trainer.log({"additional_metric": additional_metric})
|
||||
|
||||
|
||||
model = YOLO("yolov8n.pt")
|
||||
model.add_callback("on_train_epoch_end", on_train_epoch_end)
|
||||
model.train(data="coco.yaml", epochs=10)
|
||||
```
|
||||
|
||||
Refer to the [Training Guide](../modes/train.md) for more details on how to effectively use training callbacks.
|
||||
|
||||
### Why should I use callbacks during validation in Ultralytics YOLO?
|
||||
|
||||
Using **callbacks during validation** in Ultralytics YOLO can enhance model evaluation by allowing custom processing, logging, or metrics calculation. Callbacks such as `on_val_start`, `on_val_batch_end`, and `on_val_end` provide entry points to inject custom logic, ensuring detailed and comprehensive validation processes.
|
||||
|
||||
For instance, you might want to log additional validation metrics or save intermediate results for further analysis. Here's an example of how to log custom metrics at the end of validation:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
|
||||
def on_val_end(validator):
|
||||
"""Log custom metrics at end of validation."""
|
||||
custom_metric = compute_custom_metric(validator)
|
||||
validator.log({"custom_metric": custom_metric})
|
||||
|
||||
|
||||
model = YOLO("yolov8n.pt")
|
||||
model.add_callback("on_val_end", on_val_end)
|
||||
model.val(data="coco.yaml")
|
||||
```
|
||||
|
||||
Check out the [Validation Guide](../modes/val.md) for further insights on incorporating callbacks into your validation process.
|
||||
|
||||
### How do I attach a custom callback for the prediction mode in Ultralytics YOLO?
|
||||
|
||||
To attach a custom callback for the **prediction mode** in Ultralytics YOLO, you define a callback function and register it with the prediction process. Common prediction callbacks include `on_predict_start`, `on_predict_batch_end`, and `on_predict_end`. These allow for modification of prediction outputs and integration of additional functionalities like data logging or result transformation.
|
||||
|
||||
Here is an example where a custom callback is used to log predictions:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
|
||||
def on_predict_end(predictor):
|
||||
"""Log predictions at the end of prediction."""
|
||||
for result in predictor.results:
|
||||
log_prediction(result)
|
||||
|
||||
|
||||
model = YOLO("yolov8n.pt")
|
||||
model.add_callback("on_predict_end", on_predict_end)
|
||||
results = model.predict(source="image.jpg")
|
||||
```
|
||||
|
||||
For more comprehensive usage, refer to the [Prediction Guide](../modes/predict.md) which includes detailed instructions and additional customization options.
|
||||
|
||||
### What are some practical examples of using callbacks in Ultralytics YOLO?
|
||||
|
||||
Ultralytics YOLO supports various practical implementations of callbacks to enhance and customize different phases like training, validation, and prediction. Some practical examples include:
|
||||
|
||||
1. **Logging Custom Metrics**: Log additional metrics at different stages, such as the end of training or validation epochs.
|
||||
2. **Data Augmentation**: Implement custom data transformations or augmentations during prediction or training batches.
|
||||
3. **Intermediate Results**: Save intermediate results such as predictions or frames for further analysis or visualization.
|
||||
|
||||
Example: Combining frames with prediction results during prediction using `on_predict_batch_end`:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
|
||||
def on_predict_batch_end(predictor):
|
||||
"""Combine prediction results with frames."""
|
||||
_, image, _, _ = predictor.batch
|
||||
image = image if isinstance(image, list) else [image]
|
||||
predictor.results = zip(predictor.results, image)
|
||||
|
||||
|
||||
model = YOLO("yolov8n.pt")
|
||||
model.add_callback("on_predict_batch_end", on_predict_batch_end)
|
||||
for result, frame in model.predict():
|
||||
pass
|
||||
```
|
||||
|
||||
Explore the [Complete Callback Reference](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/base.py) to find more options and examples.
|
||||
|
|
|
|||
|
|
@ -277,3 +277,38 @@ Effective logging, checkpointing, plotting, and file management can help you kee
|
|||
| `exist_ok` | `False` | Determines whether to overwrite an existing experiment directory if one with the same name already exists. Setting this to `True` allows overwriting, while `False` prevents it. |
|
||||
| `plots` | `False` | Controls the generation and saving of training and validation plots. Set to `True` to create plots such as loss curves, precision-recall curves, and sample predictions. Useful for visually tracking model performance over time. |
|
||||
| `save` | `False` | Enables the saving of training checkpoints and final model weights. Set to `True` to periodically save model states, allowing training to be resumed from these checkpoints or models to be deployed. |
|
||||
|
||||
## FAQ
|
||||
|
||||
### How do I improve the performance of my YOLO model during training?
|
||||
|
||||
Improving YOLO model performance involves tuning hyperparameters like batch size, learning rate, momentum, and weight decay. Adjusting augmentation settings, selecting the right optimizer, and employing techniques like early stopping or mixed precision can also help. For detailed guidance on training settings, refer to the [Train Guide](../modes/train.md).
|
||||
|
||||
### What are the key hyperparameters to consider for YOLO model accuracy?
|
||||
|
||||
Key hyperparameters affecting YOLO model accuracy include:
|
||||
|
||||
- **Batch Size (`batch`)**: Larger batch sizes can stabilize training but may require more memory.
|
||||
- **Learning Rate (`lr0`)**: Controls the step size for weight updates; smaller rates offer fine adjustments but slow convergence.
|
||||
- **Momentum (`momentum`)**: Helps accelerate gradient vectors in the right directions, dampening oscillations.
|
||||
- **Image Size (`imgsz`)**: Larger image sizes can improve accuracy but increase computational load.
|
||||
|
||||
Adjust these values based on your dataset and hardware capabilities. Explore more in the [Train Settings](#train-settings) section.
|
||||
|
||||
### How do I set the learning rate for training a YOLO model?
|
||||
|
||||
The learning rate (`lr0`) is crucial for optimization. A common starting point is `0.01` for SGD or `0.001` for Adam. It's essential to monitor training metrics and adjust if necessary. Use cosine learning rate schedulers (`cos_lr`) or warmup techniques (`warmup_epochs`, `warmup_momentum`) to dynamically modify the rate during training. Find more details in the [Train Guide](../modes/train.md).
|
||||
|
||||
### What are the default inference settings for YOLO models?
|
||||
|
||||
Default inference settings include:
|
||||
|
||||
- **Confidence Threshold (`conf=0.25`)**: Minimum confidence for detections.
|
||||
- **IoU Threshold (`iou=0.7`)**: For Non-Maximum Suppression (NMS).
|
||||
- **Image Size (`imgsz=640`)**: Resizes input images prior to inference.
|
||||
- **Device (`device=None`)**: Selects CPU or GPU for inference.
|
||||
For a comprehensive overview, visit the [Predict Settings](#predict-settings) section and the [Predict Guide](../modes/predict.md).
|
||||
|
||||
### Why should I use mixed precision training with YOLO models?
|
||||
|
||||
Mixed precision training, enabled with `amp=True`, helps reduce memory usage and can speed up training by utilizing the advantages of both FP16 and FP32. This is beneficial for modern GPUs, which support mixed precision natively, allowing more models to fit in memory and enable faster computations without significant loss in accuracy. Learn more about this in the [Train Guide](../modes/train.md).
|
||||
|
|
|
|||
|
|
@ -230,3 +230,55 @@ This will create `default_copy.yaml`, which you can then pass as `cfg=default_co
|
|||
yolo copy-cfg
|
||||
yolo cfg=default_copy.yaml imgsz=320
|
||||
```
|
||||
|
||||
## FAQ
|
||||
|
||||
### How do I use the Ultralytics YOLOv8 command line interface (CLI) for model training?
|
||||
|
||||
To train a YOLOv8 model using the CLI, you can execute a simple one-line command in the terminal. For example, to train a detection model for 10 epochs with a learning rate of 0.01, you would run:
|
||||
|
||||
```bash
|
||||
yolo train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01
|
||||
```
|
||||
|
||||
This command uses the `train` mode with specific arguments. Refer to the full list of available arguments in the [Configuration Guide](cfg.md).
|
||||
|
||||
### What tasks can I perform with the Ultralytics YOLOv8 CLI?
|
||||
|
||||
The Ultralytics YOLOv8 CLI supports a variety of tasks including detection, segmentation, classification, validation, prediction, export, and tracking. For instance:
|
||||
|
||||
- **Train a Model**: Run `yolo train data=<data.yaml> model=<model.pt> epochs=<num>`.
|
||||
- **Run Predictions**: Use `yolo predict model=<model.pt> source=<data_source> imgsz=<image_size>`.
|
||||
- **Export a Model**: Execute `yolo export model=<model.pt> format=<export_format>`.
|
||||
|
||||
Each task can be customized with various arguments. For detailed syntax and examples, see the respective sections like [Train](#train), [Predict](#predict), and [Export](#export).
|
||||
|
||||
### How can I validate the accuracy of a trained YOLOv8 model using the CLI?
|
||||
|
||||
To validate a YOLOv8 model's accuracy, use the `val` mode. For example, to validate a pretrained detection model with a batch size of 1 and image size of 640, run:
|
||||
|
||||
```bash
|
||||
yolo val model=yolov8n.pt data=coco8.yaml batch=1 imgsz=640
|
||||
```
|
||||
|
||||
This command evaluates the model on the specified dataset and provides performance metrics. For more details, refer to the [Val](#val) section.
|
||||
|
||||
### What formats can I export my YOLOv8 models to using the CLI?
|
||||
|
||||
YOLOv8 models can be exported to various formats such as ONNX, CoreML, TensorRT, and more. For instance, to export a model to ONNX format, run:
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n.pt format=onnx
|
||||
```
|
||||
|
||||
For complete details, visit the [Export](../modes/export.md) page.
|
||||
|
||||
### How do I customize YOLOv8 CLI commands to override default arguments?
|
||||
|
||||
To override default arguments in YOLOv8 CLI commands, pass them as `arg=value` pairs. For example, to train a model with custom arguments, use:
|
||||
|
||||
```bash
|
||||
yolo train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01
|
||||
```
|
||||
|
||||
For a full list of available arguments and their descriptions, refer to the [Configuration Guide](cfg.md). Ensure arguments are formatted correctly, as shown in the [Overriding default arguments](#overriding-default-arguments) section.
|
||||
|
|
|
|||
|
|
@ -93,3 +93,87 @@ To know more about Callback triggering events and entry point, checkout our [Cal
|
|||
## Other engine components
|
||||
|
||||
There are other components that can be customized similarly like `Validators` and `Predictors`. See Reference section for more information on these.
|
||||
|
||||
## FAQ
|
||||
|
||||
### How do I customize the Ultralytics YOLOv8 DetectionTrainer for specific tasks?
|
||||
|
||||
To customize the Ultralytics YOLOv8 `DetectionTrainer` for a specific task, you can override its methods to adapt to your custom model and dataloader. Start by inheriting from `DetectionTrainer` and then redefine methods like `get_model` to implement your custom functionalities. Here's an example:
|
||||
|
||||
```python
|
||||
from ultralytics.models.yolo.detect import DetectionTrainer
|
||||
|
||||
|
||||
class CustomTrainer(DetectionTrainer):
|
||||
def get_model(self, cfg, weights):
|
||||
"""Loads a custom detection model given configuration and weight files."""
|
||||
...
|
||||
|
||||
|
||||
trainer = CustomTrainer(overrides={...})
|
||||
trainer.train()
|
||||
trained_model = trainer.best # get best model
|
||||
```
|
||||
|
||||
For further customization like changing the `loss function` or adding a `callback`, you can reference our [Callbacks Guide](../usage/callbacks.md).
|
||||
|
||||
### What are the key components of the BaseTrainer in Ultralytics YOLOv8?
|
||||
|
||||
The `BaseTrainer` in Ultralytics YOLOv8 serves as the foundation for training routines and can be customized for various tasks by overriding its generic methods. Key components include:
|
||||
|
||||
- `get_model(cfg, weights)` to build the model to be trained.
|
||||
- `get_dataloader()` to build the dataloader.
|
||||
|
||||
For more details on the customization and source code, see the [`BaseTrainer` Reference](../reference/engine/trainer.md).
|
||||
|
||||
### How can I add a callback to the Ultralytics YOLOv8 DetectionTrainer?
|
||||
|
||||
You can add callbacks to monitor and modify the training process in Ultralytics YOLOv8 `DetectionTrainer`. For instance, here's how you can add a callback to log model weights after every training epoch:
|
||||
|
||||
```python
|
||||
from ultralytics.models.yolo.detect import DetectionTrainer
|
||||
|
||||
|
||||
# callback to upload model weights
|
||||
def log_model(trainer):
|
||||
"""Logs the path of the last model weight used by the trainer."""
|
||||
last_weight_path = trainer.last
|
||||
print(last_weight_path)
|
||||
|
||||
|
||||
trainer = DetectionTrainer(overrides={...})
|
||||
trainer.add_callback("on_train_epoch_end", log_model) # Adds to existing callbacks
|
||||
trainer.train()
|
||||
```
|
||||
|
||||
For further details on callback events and entry points, refer to our [Callbacks Guide](../usage/callbacks.md).
|
||||
|
||||
### Why should I use Ultralytics YOLOv8 for model training?
|
||||
|
||||
Ultralytics YOLOv8 offers a high-level abstraction on powerful engine executors, making it ideal for rapid development and customization. Key benefits include:
|
||||
|
||||
- **Ease of Use**: Both command-line and Python interfaces simplify complex tasks.
|
||||
- **Performance**: Optimized for real-time object detection and various vision AI applications.
|
||||
- **Customization**: Easily extendable for custom models, loss functions, and dataloaders.
|
||||
|
||||
Learn more about YOLOv8's capabilities by visiting [Ultralytics YOLO](https://www.ultralytics.com/yolo).
|
||||
|
||||
### Can I use the Ultralytics YOLOv8 DetectionTrainer for non-standard models?
|
||||
|
||||
Yes, Ultralytics YOLOv8 `DetectionTrainer` is highly flexible and can be customized for non-standard models. By inheriting from `DetectionTrainer`, you can overload different methods to support your specific model's needs. Here's a simple example:
|
||||
|
||||
```python
|
||||
from ultralytics.models.yolo.detect import DetectionTrainer
|
||||
|
||||
|
||||
class CustomDetectionTrainer(DetectionTrainer):
|
||||
def get_model(self, cfg, weights):
|
||||
"""Loads a custom detection model."""
|
||||
...
|
||||
|
||||
|
||||
trainer = CustomDetectionTrainer(overrides={...})
|
||||
trainer.train()
|
||||
```
|
||||
|
||||
For more comprehensive instructions and examples, review the [DetectionTrainer](../reference/engine/trainer.md) documentation.
|
||||
|
|
|
|||
|
|
@ -330,3 +330,89 @@ Explorer API can be used to explore datasets with advanced semantic, vector-simi
|
|||
You can easily customize Trainers to support custom tasks or explore R&D ideas. Learn more about Customizing `Trainers`, `Validators` and `Predictors` to suit your project needs in the Customization Section.
|
||||
|
||||
[Customization tutorials](engine.md){ .md-button }
|
||||
|
||||
## FAQ
|
||||
|
||||
### How can I integrate YOLOv8 into my Python project for object detection?
|
||||
|
||||
Integrating Ultralytics YOLOv8 into your Python projects is simple. You can load a pre-trained model or train a new model from scratch. Here's how to get started:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained YOLO model
|
||||
model = YOLO("yolov8n.pt")
|
||||
|
||||
# Perform object detection on an image
|
||||
results = model("https://ultralytics.com/images/bus.jpg")
|
||||
|
||||
# Visualize the results
|
||||
for result in results:
|
||||
result.show()
|
||||
```
|
||||
|
||||
See more detailed examples in our [Predict Mode](../modes/predict.md) section.
|
||||
|
||||
### What are the different modes available in YOLOv8?
|
||||
|
||||
Ultralytics YOLOv8 provides various modes to cater to different machine learning workflows. These include:
|
||||
|
||||
- **[Train](../modes/train.md)**: Train a model using custom datasets.
|
||||
- **[Val](../modes/val.md)**: Validate model performance on a validation set.
|
||||
- **[Predict](../modes/predict.md)**: Make predictions on new images or video streams.
|
||||
- **[Export](../modes/export.md)**: Export models to various formats like ONNX, TensorRT.
|
||||
- **[Track](../modes/track.md)**: Real-time object tracking in video streams.
|
||||
- **[Benchmark](../modes/benchmark.md)**: Benchmark model performance across different configurations.
|
||||
|
||||
Each mode is designed to provide comprehensive functionalities for different stages of model development and deployment.
|
||||
|
||||
### How do I train a custom YOLOv8 model using my dataset?
|
||||
|
||||
To train a custom YOLOv8 model, you need to specify your dataset and other hyperparameters. Here's a quick example:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load the YOLO model
|
||||
model = YOLO("yolov8n.yaml")
|
||||
|
||||
# Train the model with custom dataset
|
||||
model.train(data="path/to/your/dataset.yaml", epochs=10)
|
||||
```
|
||||
|
||||
For more details on training and hyperlinks to example usage, visit our [Train Mode](../modes/train.md) page.
|
||||
|
||||
### How do I export YOLOv8 models for deployment?
|
||||
|
||||
Exporting YOLOv8 models in a format suitable for deployment is straightforward with the `export` function. For example, you can export a model to ONNX format:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load the YOLO model
|
||||
model = YOLO("yolov8n.pt")
|
||||
|
||||
# Export the model to ONNX format
|
||||
model.export(format="onnx")
|
||||
```
|
||||
|
||||
For various export options, refer to the [Export Mode](../modes/export.md) documentation.
|
||||
|
||||
### Can I validate my YOLOv8 model on different datasets?
|
||||
|
||||
Yes, validating YOLOv8 models on different datasets is possible. After training, you can use the validation mode to evaluate the performance:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a YOLOv8 model
|
||||
model = YOLO("yolov8n.yaml")
|
||||
|
||||
# Train the model
|
||||
model.train(data="coco8.yaml", epochs=5)
|
||||
|
||||
# Validate the model on a different dataset
|
||||
model.val(data="path/to/separate/data.yaml")
|
||||
```
|
||||
|
||||
Check the [Val Mode](../modes/val.md) page for detailed examples and usage.
|
||||
|
|
|
|||
|
|
@ -568,3 +568,64 @@ make_divisible(7, 3)
|
|||
make_divisible(7, 2)
|
||||
# >>> 8
|
||||
```
|
||||
|
||||
## FAQ
|
||||
|
||||
### What utilities are included in the Ultralytics package to enhance machine learning workflows?
|
||||
|
||||
The Ultralytics package includes a variety of utilities designed to streamline and optimize machine learning workflows. Key utilities include [auto-annotation](../reference/data/annotator.md#ultralytics.data.annotator.auto_annotate) for labeling datasets, converting COCO to YOLO format with [convert_coco](../reference/data/converter.md#ultralytics.data.converter.convert_coco), compressing images, and dataset auto-splitting. These tools aim to reduce manual effort, ensure consistency, and enhance data processing efficiency.
|
||||
|
||||
### How can I use Ultralytics to auto-label my dataset?
|
||||
|
||||
If you have a pre-trained Ultralytics YOLO object detection model, you can use it with the [SAM](../models/sam.md) model to auto-annotate your dataset in segmentation format. Here's an example:
|
||||
|
||||
```python
|
||||
from ultralytics.data.annotator import auto_annotate
|
||||
|
||||
auto_annotate(
|
||||
data="path/to/new/data",
|
||||
det_model="yolov8n.pt",
|
||||
sam_model="mobile_sam.pt",
|
||||
device="cuda",
|
||||
output_dir="path/to/save_labels",
|
||||
)
|
||||
```
|
||||
|
||||
For more details, check the [auto_annotate reference section](../reference/data/annotator.md#ultralytics.data.annotator.auto_annotate).
|
||||
|
||||
### How do I convert COCO dataset annotations to YOLO format in Ultralytics?
|
||||
|
||||
To convert COCO JSON annotations into YOLO format for object detection, you can use the `convert_coco` utility. Here's a sample code snippet:
|
||||
|
||||
```python
|
||||
from ultralytics.data.converter import convert_coco
|
||||
|
||||
convert_coco(
|
||||
"../datasets/coco/annotations/",
|
||||
use_segments=False,
|
||||
use_keypoints=False,
|
||||
cls91to80=True,
|
||||
)
|
||||
```
|
||||
|
||||
For additional information, visit the [convert_coco reference page](../reference/data/converter.md#ultralytics.data.converter.convert_coco).
|
||||
|
||||
### What is the purpose of the YOLO Data Explorer in the Ultralytics package?
|
||||
|
||||
The [YOLO Explorer](../datasets/explorer/index.md) is a powerful tool introduced in the `8.1.0` update to enhance dataset understanding. It allows you to use text queries to find object instances in your dataset, making it easier to analyze and manage your data. This tool provides valuable insights into dataset composition and distribution, helping to improve model training and performance.
|
||||
|
||||
### How can I convert bounding boxes to segments in Ultralytics?
|
||||
|
||||
To convert existing bounding box data (in `x y w h` format) to segments, you can use the `yolo_bbox2segment` function. Ensure your files are organized with separate directories for images and labels.
|
||||
|
||||
```python
|
||||
from ultralytics.data.converter import yolo_bbox2segment
|
||||
|
||||
yolo_bbox2segment(
|
||||
im_dir="path/to/images",
|
||||
save_dir=None, # saved to "labels-segment" in the images directory
|
||||
sam_model="sam_b.pt",
|
||||
)
|
||||
```
|
||||
|
||||
For more information, visit the [yolo_bbox2segment reference page](../reference/data/converter.md#ultralytics.data.converter.yolo_bbox2segment).
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue