RF-DETR

https://rfdetr.roboflow.com/1.3.0
Admin
RF-DETR is a real-time, transformer-based object detection and instance segmentation model...
Tokens:35,402
Snippets:252
Trust Score:10
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install RF-DETR from source with uv

Source: https://rfdetr.roboflow.com/1.3.0

Clone the repository, set up a uv virtual environment, and install RF-DETR in editable mode using uv pip.

```bash
# clone repository and navigate to root directory
git clone --depth 1 -b develop https://github.com/roboflow/rf-detr.git
cd rf-detr

# setup python environment and activate it
uv venv
source .venv/bin/activate

# installation
uv pip install -r pyproject.toml -e . --all-extras

```

--------------------------------

### Install RF-DETR with uv pip

Source: https://rfdetr.roboflow.com/1.3.0

Install the rfdetr package using uv pip.

```bash
uv pip install rfdetr

```

--------------------------------

### Install RF-DETR with Metrics Support

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Install the necessary packages for RF-DETR with metrics logging capabilities, including TensorBoard and Weights & Biases.

```bash
pip install "rfdetr[metrics]"
```

--------------------------------

### Install RF-DETR with pip

Source: https://rfdetr.roboflow.com/1.3.0

Install the rfdetr package using pip. This is the recommended installation method.

```bash
pip install rfdetr

```

--------------------------------

### Install ONNX Export Extension

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Install the necessary extension for exporting RF-DETR models to the ONNX format.

```bash
pip install rfdetr[onnxexport]
```

--------------------------------

### Install RF-DETR from source with venv

Source: https://rfdetr.roboflow.com/1.3.0

Clone the repository, set up a virtual environment, and install RF-DETR in editable mode using pip.

```bash
# clone repository and navigate to root directory
git clone --depth 1 -b develop https://github.com/roboflow/rf-detr.git
cd rf-detr

# setup python environment and activate it
python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip

# installation
pip install -e "."

```

--------------------------------

### Run TensorBoard Locally

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Start a TensorBoard server locally to visualize training logs. Navigate to your project directory and specify the log directory.

```bash
tensorboard --logdir <OUTPUT_DIR>
```

--------------------------------

### RF-DETR Dataset Structure Example

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Illustrates the expected directory structure for a dataset intended for RF-DETR training, adhering to the COCO format.

```text
dataset/
├── train/
│   ├── _annotations.coco.json
│   ├── image1.jpg
│   ├── image2.jpg
│   └── ... (other image files)
├── valid/
│   ├── _annotations.coco.json
│   ├── image1.jpg
│   ├── image2.jpg
│   └── ... (other image files)
└── test/
    ├── _annotations.coco.json
    ├── image1.jpg
    ├── image2.jpg
    └── ... (other image files)

```

--------------------------------

### RFDETR Class Initialization

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

Initializes the RFDETR model, handling configuration, pre-trained weights, and model setup. It prepares the model for training or inference.

```python
class RFDETR:
    """
    The base RF-DETR class implements the core methods for training RF-DETR models,
    running inference on the models, optimising models, and uploading trained
    models for deployment.
    """
    means = [0.485, 0.456, 0.406]
    stds = [0.229, 0.224, 0.225]
    size = None

    def __init__(self, **kwargs):
        self.model_config = self.get_model_config(**kwargs)
        self.maybe_download_pretrain_weights()
        self.model = self.get_model(self.model_config)
        self.callbacks = defaultdict(list)

        self.model.inference_model = None
        self._is_optimized_for_inference = False
        self._has_warned_about_not_being_optimized_for_inference = False
        self._optimized_has_been_compiled = False
        self._optimized_batch_size = None
        self._optimized_resolution = None
        self._optimized_dtype = None
```

--------------------------------

### Batch Inference with Multiple Images

Source: https://rfdetr.roboflow.com/1.3.0/learn/run/detection

This snippet demonstrates how to load multiple images from URLs, perform batch inference using the RFDETR model, and then annotate and display each resulting image with its detections. Ensure you have the necessary libraries installed (supervision, Pillow, requests, rfdetr).

```python
import io
import requests
import supervision as sv
from PIL import Image
from rfdetr import RFDETRBase
from rfdetr.util.coco_classes import COCO_CLASSES

model = RFDETRBase()

urls = [
    "https://media.roboflow.com/notebooks/examples/dog-2.jpeg",
    "https://media.roboflow.com/notebooks/examples/dog-3.jpeg"
]

images = [Image.open(io.BytesIO(requests.get(url).content)) for url in urls]

detections_list = model.predict(images, threshold=0.5)

for image, detections in zip(images, detections_list):
    labels = [
        f"{COCO_CLASSES[class_id]} {confidence:.2f}"
        for class_id, confidence
        in zip(detections.class_id, detections.confidence)
    ]

    annotated_image = image.copy()
    annotated_image = sv.BoxAnnotator().annotate(annotated_image, detections)
    annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections, labels)

    sv.plot_image(annotated_image)

```

--------------------------------

### Run RF-DETR on an Image

Source: https://rfdetr.roboflow.com/1.3.0/learn/run/segmentation

Infers instance segmentation on a single image using a specified RF-DETR model. Ensure the 'inference' and 'supervision' libraries are installed. The model is loaded using `get_model` and predictions are processed with `sv.Detections.from_inference`.

```python
import os
import supervision as sv
from inference import get_model
from PIL import Image
from io import BytesIO
import requests

url = "https://media.roboflow.com/dog.jpeg"
image = Image.open(BytesIO(requests.get(url).content))

model = get_model("rfdetr-seg-preview")

predictions = model.infer(image, confidence=0.5)[0]

detecti ons = sv.Detections.from_inference(predictions)

labels = [prediction.class_name for prediction in predictions.predictions]

annotated_image = image.copy()
annotated_image = sv.MaskAnnotator(color=sv.ColorPalette.ROBOFLOW).annotate(annotated_image, detections)
annotated_image = sv.LabelAnnotator(color=sv.ColorPalette.ROBOFLOW).annotate(annotated_image, detections, labels)

sv.plot_image(annotated_image)

```

--------------------------------

### Training Configuration and Callbacks

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

This snippet shows how to set up training configurations, including dataset handling, model reinitialization, and integrating various callbacks like metrics logging (TensorBoard, Weights & Biases) and early stopping.

```python
                num_classes = len(anns["categories"])
                class_names = [c["name"] for c in anns["categories"] if c["supercategory"] != "none"]
                self.model.class_names = class_names
        elif config.dataset_file == "coco":
            class_names = COCO_CLASSES
            num_classes = 90
        else:
            raise ValueError(f"Invalid dataset file: {config.dataset_file}")

        if self.model_config.num_classes != num_classes:
            self.model.reinitialize_detection_head(num_classes)

        train_config = config.dict()
        model_config = self.model_config.dict()
        model_config.pop("num_classes")
        if "class_names" in model_config:
            model_config.pop("class_names")

        if "class_names" in train_config and train_config["class_names"] is None:
            train_config["class_names"] = class_names

        for k, v in train_config.items():
            if k in model_config:
                model_config.pop(k)
            if k in kwargs:
                kwargs.pop(k)

        all_kwargs = {**model_config, **train_config, **kwargs, "num_classes": num_classes}

        metrics_plot_sink = MetricsPlotSink(output_dir=config.output_dir)
        self.callbacks["on_fit_epoch_end"].append(metrics_plot_sink.update)
        self.callbacks["on_train_end"].append(metrics_plot_sink.save)

        if config.tensorboard:
            metrics_tensor_board_sink = MetricsTensorBoardSink(output_dir=config.output_dir)
            self.callbacks["on_fit_epoch_end"].append(metrics_tensor_board_sink.update)
            self.callbacks["on_train_end"].append(metrics_tensor_board_sink.close)

        if config.wandb:
            metrics_wandb_sink = MetricsWandBSink(
                output_dir=config.output_dir,
                project=config.project,
                run=config.run,
                config=config.model_dump()
            )
            self.callbacks["on_fit_epoch_end"].append(metrics_wandb_sink.update)
            self.callbacks["on_train_end"].append(metrics_wandb_sink.close)

        if config.early_stopping:
            from rfdetr.util.early_stopping import EarlyStoppingCallback
            early_stopping_callback = EarlyStoppingCallback(
                model=self.model,
                patience=config.early_stopping_patience,
                min_delta=config.early_stopping_min_delta,
                use_ema=config.early_stopping_use_ema,
                segmentation_head=config.segmentation_head
            )
            self.callbacks["on_fit_epoch_end"].append(early_stopping_callback.update)

        self.model.train(
            **all_kwargs,
            callbacks=self.callbacks,
        )
```

--------------------------------

### RFDETRNano.get_model

Source: https://rfdetr.roboflow.com/1.3.0/reference/nano

Get the RF-DETR Nano model.

```APIDOC
## RFDETRNano.get_model

### Description
Get the RF-DETR Nano model.
```

--------------------------------

### get_model_config

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

Gets the configuration for the RF-DETR model. This function provides access to the model's architecture and training parameters.

```APIDOC
## get_model_config

### Description
Gets the configuration for the RF-DETR model.
```

--------------------------------

### `train(**kwargs)`

Source: https://rfdetr.roboflow.com/1.3.0/reference/seg_preview

This method initiates the training process for an RF-DETR model. It takes arbitrary keyword arguments to configure the training process.

```APIDOC
## `train(**kwargs)`

### Description
Train an RF-DETR model.

### Method
Python method call

### Signature
`train(self, **kwargs)`

### Parameters
`**kwargs`: Arbitrary keyword arguments to configure the training process.

### Usage
This method is called on an RF-DETR model instance to start training. Configuration details are passed via keyword arguments.
```

--------------------------------

### get_train_config

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

Gets the training configuration for the RF-DETR model. This function returns the parameters used during the model's training process.

```APIDOC
## get_train_config

### Description
Gets the training configuration for the RF-DETR model.
```

--------------------------------

### Retrieve Model Configuration

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

Use this function to get the configuration parameters for the RFDetr model. It accepts keyword arguments to customize the configuration.

```python
def get_model_config(self, **kwargs):
    """
    Retrieve the configuration parameters used by the model.
    """
    return ModelConfig(**kwargs)
```

--------------------------------

### Log in to Weights & Biases

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Authenticate with Weights & Biases to enable cloud-based tracking of training metrics. Retrieve your API key from wandb.ai/authorize.

```bash
wandb login
```

--------------------------------

### Train RF-DETR Model

Source: https://rfdetr.roboflow.com/1.3.0/reference/seg_preview

Use this method to initiate the training process for an RF-DETR model. It retrieves the training configuration and then proceeds with training based on that configuration.

```python
def train(self, **kwargs):
    """
    Train an RF-DETR model.
    """
    config = self.get_train_config(**kwargs)
    self.train_from_config(config, **kwargs)
```

--------------------------------

### Run TensorBoard in Google Colab

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Enable and launch TensorBoard within a Google Colab environment by loading the extension and specifying the log directory.

```python
%load_ext tensorboard
%tensorboard --logdir <OUTPUT_DIR>
```

--------------------------------

### Enable Weights & Biases Logging

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Activate Weights & Biases logging during model training by setting `wandb=True` and providing project and run names in the `.train()` method.

```python
from rfdetr import RFDETRBase

model = RFDETRBase()

model.train(
    dataset_dir=<DATASET_PATH>,
    epochs=100,
    batch_size=4,
    grad_accum_steps=4,
    lr=1e-4,
    output_dir=<OUTPUT_PATH>,
    wandb=True,
    project=<PROJECT_NAME>,
    run=<RUN_NAME>
)
```

--------------------------------

### Get Class Names from Model

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

This property retrieves the class names supported by the loaded model. It returns a dictionary mapping class IDs to class names, defaulting to COCO_CLASSES if model class names are not available.

```python
    # Get class_names from the model
    @property
    def class_names(self):
        """
        Retrieve the class names supported by the loaded model.

        Returns:
            dict: A dictionary mapping class IDs to class names. The keys are integers starting from
        """
        if hasattr(self.model, 'class_names') and self.model.class_names:
            return {i+1: name for i, name in enumerate(self.model.class_names)}

        return COCO_CLASSES
```

--------------------------------

### Resume Training for Object Detection

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Use this snippet to resume training for object detection models from a saved checkpoint. Ensure the `resume` argument points to a valid checkpoint file.

```python
from rfdetr import RFDETRBase

model = RFDETRBase()

model.train(
    dataset_dir=<DATASET_PATH>,
    epochs=100,
    batch_size=4,
    grad_accum_steps=4,
    lr=1e-4,
    output_dir=<OUTPUT_PATH>,
    resume=<CHECKPOINT_PATH>
)

```

--------------------------------

### Resume Training for Image Segmentation

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Use this snippet to resume training for image segmentation models from a saved checkpoint. Ensure the `resume` argument points to a valid checkpoint file.

```python
from rfdetr import RFDETRSegPreview

model = RFDETRSegPreview()

model.train(
    dataset_dir=<DATASET_PATH>,
    epochs=100,
    batch_size=4,
    grad_accum_steps=4,
    lr=1e-4,
    output_dir=<OUTPUT_PATH>,
    resume=<CHECKPOINT_PATH>
)

```

--------------------------------

### Multi-GPU Training Command

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Launch training across multiple GPUs using PyTorch's Distributed Data Parallel. Adjust `--nproc_per_node` to match your GPU count.

```bash
python -m torch.distributed.launch --nproc_per_node=8 --use_env main.py

```

--------------------------------

### Enable TensorBoard Logging

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Activate TensorBoard logging during model training by setting the `tensorboard` parameter to `True` in the `.train()` method.

```python
from rfdetr import RFDETRBase

model = RFDETRBase()

model.train(
    dataset_dir=<DATASET_PATH>,
    epochs=100,
    batch_size=4,
    grad_accum_steps=4,
    lr=1e-4,
    output_dir=<OUTPUT_PATH>,
    tensorboard=True
)
```

--------------------------------

### Download Pre-trained Weights

Source: https://rfdetr.roboflow.com/1.3.0/reference/seg_preview

Downloads pre-trained weights for the model if they are not already present locally.

```python
def maybe_download_pretrain_weights(self):
    """
    Download pre-trained weights if they are not already downloaded.
    """
    download_pretrain_weights(self.model_config.pretrain_weights)
```

--------------------------------

### Run RF-DETR on Webcam Stream

Source: https://rfdetr.roboflow.com/1.3.0/learn/run/segmentation

Performs real-time instance segmentation on a webcam feed. Uses OpenCV for video capture and displays annotated frames. Press 'q' to exit the stream.

```python
import cv2
import supervision as sv
from rfdetr import RFDETRBase
from rfdetr.util.coco_classes import COCO_CLASSES

model = RFDETRBase()

cap = cv2.VideoCapture(0)
while True:
    success, frame = cap.read()
    if not success:
        break

    detections = model.predict(frame[:, :, ::-1], threshold=0.5)

    labels = [
        f"{COCO_CLASSES[class_id]} {confidence:.2f}"
        for class_id, confidence
        in zip(detections.class_id, detections.confidence)
    ]

    annotated_frame = frame.copy()
    annotated_frame = sv.MaskAnnotator().annotate(annotated_frame, detections)
    annotated_frame = sv.LabelAnnotator().annotate(annotated_frame, detections, labels)

    cv2.imshow("Webcam", annotated_frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

```

--------------------------------

### Retrieve Model Instance

Source: https://rfdetr.roboflow.com/1.3.0/reference/seg_preview

Retrieves a model instance based on the provided configuration object.

```python
def get_model(self, config: ModelConfig):
    """
    Retrieve a model instance based on the provided configuration.
    """
    return Model(**config.dict())
```

--------------------------------

### get_model

Source: https://rfdetr.roboflow.com/1.3.0/reference/seg_preview

Retrieves a model instance based on the provided configuration object.

```APIDOC
## get_model(config: ModelConfig)

### Description
Retrieve a model instance based on the provided configuration.

### Method
POST (implied by model instantiation)

### Endpoint
`/model` (conceptual, as this is an SDK method)

### Parameters
#### Path Parameters
None.

#### Query Parameters
None.

#### Request Body
- **config** (ModelConfig) - Required - The configuration object used to instantiate the model.
```

--------------------------------

### Deploy RF-DETR Model to Roboflow

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

This snippet shows how to deploy an RF-DETR model to a Roboflow workspace. It handles API key retrieval, temporary file creation for model weights, and the actual deployment to a specified project version. Ensure the ROBOFLOW_API_KEY environment variable is set or provide the api_key directly.

```python
from roboflow import Roboflow
import shutil
import os
import torch

# Assuming 'self' refers to an object with 'model' and 'args' attributes
# and that 'self.model.model.state_dict()' and 'self.model.args' are accessible.
# This is a conceptual example based on the provided context.

# Placeholder for the actual class or function context
class RFDetrModel:
    def __init__(self, model, args):
        self.model = model
        self.args = args

    def deploy_to_roboflow(self, workspace: str, project_id: str, version: int, api_key: str = None, size: str = None, model_name: str = None):
        """
        Deploys the RF-DETR model to Roboflow.

        Args:
            workspace (str): The name of the Roboflow workspace to deploy to.
            project_id (str): The ID of the Roboflow project.
            version (int): The version of the Roboflow project.
            api_key (str, optional): Your Roboflow API key. If not provided,
                it will be read from the environment variable `ROBOFLOW_API_KEY`.
            size (str, optional): The size of the model to deploy. If not provided,
                it will default to the size of the model being trained (e.g., "rfdetr-base", "rfdetr-large", etc.).
            model_name (str, optional): The name you want to give the uploaded model.
            If not provided, it will default to "<size>-uploaded".
        Raises:
            ValueError: If the `api_key` is not provided and not found in the environment
                variable `ROBOFLOW_API_KEY`, or if the `size` is not set for custom architectures.
        """
        if api_key is None:
            api_key = os.getenv("ROBOFLOW_API_KEY")
            if api_key is None:
                raise ValueError("Set api_key=<KEY> in deploy_to_roboflow or export ROBOFLOW_API_KEY=<KEY>")


        rf = Roboflow(api_key=api_key)
        workspace_obj = rf.workspace(workspace)

        if self.args.size is None and size is None:
            raise ValueError("Must set size for custom architectures")

        effective_size = size or self.args.size
        tmp_out_dir = ".roboflow_temp_upload"
        os.makedirs(tmp_out_dir, exist_ok=True)
        outpath = os.path.join(tmp_out_dir, "weights.pt")
        torch.save(
            {
                "model": self.model.state_dict(),
                "args": self.args
            }, outpath
        )
        project = workspace_obj.project(project_id)
        version_obj = project.version(version)
        version_obj.deploy(
            model_type=effective_size,
            model_path=tmp_out_dir,
            filename="weights.pt"
        )
        shutil.rmtree(tmp_out_dir)

# Example Usage (conceptual):
# Assuming you have a trained model and its arguments:
# trained_model = ... # Your trained PyTorch model
# model_args = ... # Your model arguments object
# rfdetr_instance = RFDetrModel(model=trained_model, args=model_args)
# rfdetr_instance.deploy_to_roboflow(
#     workspace="your-workspace-name",
#     project_id="your-project-id",
#     version=1, # or the specific version number
#     api_key="your-roboflow-api-key",
#     size="rfdetr-base" # or other size like "rfdetr-large"
# )
```

--------------------------------

### Perform Inference and Post-process Detections

Source: https://rfdetr.roboflow.com/1.3.0/reference/small

This snippet shows the core logic for running inference on a batch of images, processing the model's raw predictions, and formatting them into a list of `sv.Detections` objects. It handles both optimized and standard inference modes, applies a confidence threshold, and extracts bounding boxes, class IDs, confidence scores, and optionally masks.

```python
with torch.inference_mode():
            if self._is_optimized_for_inference:
                predictions = self.model.inference_model(batch_tensor.to(dtype=self._optimized_dtype))
            else:
                predictions = self.model.model(batch_tensor)
            if isinstance(predictions, tuple):
                predictions = {
                    "pred_logits": predictions[1],
                    "pred_boxes": predictions[0],
                    "pred_masks": predictions[2]
                }
            target_sizes = torch.tensor(orig_sizes, device=self.model.device)
            results = self.model.postprocess(predictions, target_sizes=target_sizes)

detections_list = []
for result in results:
            scores = result["scores"]
            labels = result["labels"]
            boxes = result["boxes"]

            keep = scores > threshold
            scores = scores[keep]
            labels = labels[keep]
            boxes = boxes[keep]

            if "masks" in result:
                masks = result["masks"]
                masks = masks[keep]

                detections = sv.Detections(
                    xyxy=boxes.float().cpu().numpy(),
                    confidence=scores.float().cpu().numpy(),
                    class_id=labels.cpu().numpy(),
                    mask=masks.squeeze(1).cpu().numpy(),
                )
            else:
                detections = sv.Detections(
                    xyxy=boxes.float().cpu().numpy(),
                    confidence=scores.float().cpu().numpy(),
                    class_id=labels.cpu().numpy(),
                )

            detections_list.append(detections)

    return detections_list if len(detections_list) > 1 else detections_list[0]
```

--------------------------------

### deploy_to_roboflow

Source: https://rfdetr.roboflow.com/1.3.0/reference/large

Deploys the trained RF-DETR model to Roboflow, creating a Serverless API for inference and allowing download of weights for on-device deployment.

```APIDOC
## deploy_to_roboflow

### Description
Deploy the trained RF-DETR model to Roboflow. This action creates a Serverless API for inference and allows downloading weights for use in Roboflow Workflows and on-device deployment.

### Method
`deploy_to_roboflow(self, workspace: str, project_id: str, version: str, api_key: str = None, size: str = None)`

### Parameters
#### Path Parameters
- **workspace** (str) - Required - The name of the Roboflow workspace to deploy to.
- **project_id** (str) - Required - The ID of the project to which the model will be deployed.
- **version** (str) - Required - The version of the project to deploy.

#### Optional Parameters
- **api_key** (str) - Optional - Your Roboflow API key. If not provided, it will be read from the environment variable `ROBOFLOW_API_KEY`.
- **size** (str) - Optional - The size of the model to deploy. Defaults to the size of the model being trained (e.g., "rfdetr-base", "rfdetr-large").
- **model_name** (str) - Optional - The name you want to give the uploaded model. Defaults to "<size>-uploaded".

### Raises
- `ValueError`: If the `api_key` is not provided and not found in the environment variable `ROBOFLOW_API_KEY`, or if the `size` is not set for custom architectures.
```

--------------------------------

### Deploy RF-DETR Model to Roboflow

Source: https://rfdetr.roboflow.com/1.3.0/reference/nano

Deploys a trained RF-DETR model to Roboflow, creating a serverless API or downloadable weights. Requires workspace, project ID, and version. API key can be provided or read from environment variable.

```python
def deploy_to_roboflow(self, workspace: str, project_id: str, version: str, api_key: str = None, size: str = None):
    """
    Deploy the trained RF-DETR model to Roboflow.

    Deploying with Roboflow will create a Serverless API to which you can make requests.

    You can also download weights into a Roboflow Inference deployment for use in Roboflow Workflows and on-device deployment.

    Args:
        workspace (str): The name of the Roboflow workspace to deploy to.
        project_ids (List[str]): A list of project IDs to which the model will be deployed
        api_key (str, optional): Your Roboflow API key. If not provided,
            it will be read from the environment variable `ROBOFLOW_API_KEY`.
        size (str, optional): The size of the model to deploy. If not provided,
            it will default to the size of the model being trained (e.g., "rfdetr-base", "rfdetr-large", etc.).
        model_name (str, optional): The name you want to give the uploaded model.
        If not provided, it will default to "<size>-uploaded".
    Raises:
        ValueError: If the `api_key` is not provided and not found in the environment
            variable `ROBOFLOW_API_KEY`, or if the `size` is not set for custom architectures.
    """
    from roboflow import Roboflow
    import shutil
    if api_key is None:
        api_key = os.getenv("ROBOFLOW_API_KEY")
        if api_key is None:
            raise ValueError("Set api_key=<KEY> in deploy_to_roboflow or export ROBOFLOW_API_KEY=<KEY>")


    rf = Roboflow(api_key=api_key)
    workspace = rf.workspace(workspace)

    if self.size is None and size is None:
        raise ValueError("Must set size for custom architectures")

    size = self.size or size
    tmp_out_dir = ".roboflow_temp_upload"
    os.makedirs(tmp_out_dir, exist_ok=True)
    outpath = os.path.join(tmp_out_dir, "weights.pt")
    torch.save(
        {
            "model": self.model.model.state_dict(),
            "args": self.model.args
        }, outpath
    )
    project = workspace.project(project_id)
    version = project.version(version)
    version.deploy(
        model_type=size,
        model_path=tmp_out_dir,
        filename="weights.pt"
    )
    shutil.rmtree(tmp_out_dir)
```

--------------------------------

### RFDETRNano.maybe_download_pretrain_weights

Source: https://rfdetr.roboflow.com/1.3.0/reference/nano

Conditionally download pre-trained weights for the RF-DETR Nano model.

```APIDOC
## RFDETRNano.maybe_download_pretrain_weights

### Description
Conditionally download pre-trained weights for the RF-DETR Nano model.
```

--------------------------------

### Perform Inference and Post-process Detections

Source: https://rfdetr.roboflow.com/1.3.0/reference/large

This snippet shows the core logic for running inference on a batch of images using the RFDetr model and post-processing the raw predictions into a structured detections format. It handles both optimized and non-optimized inference paths and includes mask generation if available.

```python
with torch.inference_mode():
        if self._is_optimized_for_inference:
            predictions = self.model.inference_model(batch_tensor.to(dtype=self._optimized_dtype))
        else:
            predictions = self.model.model(batch_tensor)
        if isinstance(predictions, tuple):
            predictions = {
                "pred_logits": predictions[1],
                "pred_boxes": predictions[0],
                "pred_masks": predictions[2]
            }
        target_sizes = torch.tensor(orig_sizes, device=self.model.device)
        results = self.model.postprocess(predictions, target_sizes=target_sizes)

    detections_list = []
    for result in results:
        scores = result["scores"]
        labels = result["labels"]
        boxes = result["boxes"]

        keep = scores > threshold
        scores = scores[keep]
        labels = labels[keep]
        boxes = boxes[keep]

        if "masks" in result:
            masks = result["masks"]
            masks = masks[keep]

            detections = sv.Detections(
                xyxy=boxes.float().cpu().numpy(),
                confidence=scores.float().cpu().numpy(),
                class_id=labels.cpu().numpy(),
                mask=masks.squeeze(1).cpu().numpy(),
            )
        else:
            detections = sv.Detections(
                xyxy=boxes.float().cpu().numpy(),
                confidence=scores.float().cpu().numpy(),
                class_id=labels.cpu().numpy(),
            )

        detections_list.append(detections)

    return detections_list if len(detections_list) > 1 else detections_list[0]
```

--------------------------------

### deploy_to_roboflow

Source: https://rfdetr.roboflow.com/1.3.0/reference/seg_preview

Deploys the trained RF-DETR model to Roboflow, creating a Serverless API. It allows for downloading weights for use in Roboflow Workflows and on-device deployment.

```APIDOC
## deploy_to_roboflow(workspace: str, project_id: str, version: str, api_key: str = None, size: str = None)

### Description
Deploy the trained RF-DETR model to Roboflow. Deploying with Roboflow will create a Serverless API to which you can make requests. You can also download weights into a Roboflow Inference deployment for use in Roboflow Workflows and on-device deployment.

### Method
POST (implied by deployment action)

### Endpoint
`/deploy` (conceptual, as this is an SDK method)

### Parameters
#### Path Parameters
- **workspace** (str) - Required - The name of the Roboflow workspace to deploy to.
- **project_id** (str) - Required - The ID of the Roboflow project to deploy to.
- **version** (str) - Required - The version of the Roboflow project to deploy.

#### Query Parameters
None explicitly documented.

#### Request Body
None explicitly documented for the SDK method itself, but the method handles model file uploads.

#### Optional Parameters
- **api_key** (str) - Optional - Your Roboflow API key. If not provided, it will be read from the environment variable `ROBOFLOW_API_KEY`.
- **size** (str) - Optional - The size of the model to deploy. If not provided, it will default to the size of the model being trained (e.g., "rfdetr-base", "rfdetr-large", etc.).
- **model_name** (str) - Optional - The name you want to give the uploaded model. If not provided, it will default to "<size>-uploaded".

### Raises
- ValueError: If the `api_key` is not provided and not found in the environment variable `ROBOFLOW_API_KEY`, or if the `size` is not set for custom architectures.

### Response
No specific response schema documented for the SDK method, but implies successful deployment or raises an error.
```

--------------------------------

### Run RF-DETR on a Webcam Stream

Source: https://rfdetr.roboflow.com/1.3.0/learn/run/detection

Performs real-time object detection on a webcam feed. Uses OpenCV for video capture and display. Press 'q' to exit the stream.

```python
import cv2
import supervision as sv
from rfdetr import RFDETRBase
from rfdetr.util.coco_classes import COCO_CLASSES

model = RFDETRBase()

cap = cv2.VideoCapture(0)
while True:
    success, frame = cap.read()
    if not success:
        break

    detections = model.predict(frame[:, :, ::-1], threshold=0.5)

    labels = [
        f"{COCO_CLASSES[class_id]} {confidence:.2f}"
        for class_id, confidence
        in zip(detections.class_id, detections.confidence)
    ]

    annotated_frame = frame.copy()
    annotated_frame = sv.BoxAnnotator().annotate(annotated_frame, detections)
    annotated_frame = sv.LabelAnnotator().annotate(annotated_frame, detections, labels)

    cv2.imshow("Webcam", annotated_frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()


```

--------------------------------

### Deploy RFDETR Segmentation Preview Model to Roboflow

Source: https://rfdetr.roboflow.com/1.3.0/learn/deploy

Use this snippet to deploy an image segmentation RFDETR Segmentation Preview model to Roboflow. Provide your pretrain weights directory, workspace, project ID, and API key.

```python
from rfdetr import RFDETRSegPreview

x = RFDETRSegPreview(pretrain_weights="<path/to/pretrain/weights/dir>")
x.deploy_to_roboflow(
  workspace="<your-workspace>",
  project_id="<your-project-id>",
  version=1,
  api_key="<YOUR_API_KEY>"
)

```

--------------------------------

### Deploy RF-DETR Model to Roboflow

Source: https://rfdetr.roboflow.com/1.3.0/reference/seg_preview

Deploys a trained RF-DETR model to Roboflow, creating a serverless API. Requires workspace, project ID, and version. API key can be provided or read from environment variable. Model size must be specified for custom architectures.

```python
import os
import shutil
import torch
from roboflow import Roboflow

def deploy_to_roboflow(self, workspace: str, project_id: str, version: str, api_key: str = None, size: str = None):
    """
    Deploy the trained RF-DETR model to Roboflow.

    Deploying with Roboflow will create a Serverless API to which you can make requests.

    You can also download weights into a Roboflow Inference deployment for use in Roboflow Workflows and on-device deployment.

    Args:
        workspace (str): The name of the Roboflow workspace to deploy to.
        project_ids (List[str]): A list of project IDs to which the model will be deployed
        api_key (str, optional): Your Roboflow API key. If not provided,
            it will be read from the environment variable `ROBOFLOW_API_KEY`.
        size (str, optional): The size of the model to deploy. If not provided,
            it will default to the size of the model being trained (e.g., "rfdetr-base", "rfdetr-large", etc.).
        model_name (str, optional): The name you want to give the uploaded model.
        If not provided, it will default to "<size>-uploaded".
    Raises:
        ValueError: If the `api_key` is not provided and not found in the environment
            variable `ROBOFLOW_API_KEY`, or if the `size` is not set for custom architectures.
    """
    
    if api_key is None:
        api_key = os.getenv("ROBOFLOW_API_KEY")
        if api_key is None:
            raise ValueError("Set api_key=<KEY> in deploy_to_roboflow or export ROBOFLOW_API_KEY=<KEY>")


    rf = Roboflow(api_key=api_key)
    workspace = rf.workspace(workspace)

    if self.size is None and size is None:
        raise ValueError("Must set size for custom architectures")

    size = self.size or size
    tmp_out_dir = ".roboflow_temp_upload"
    os.makedirs(tmp_out_dir, exist_ok=True)
    outpath = os.path.join(tmp_out_dir, "weights.pt")
    torch.save(
        {
            "model": self.model.model.state_dict(),
            "args": self.model.args
        }, outpath
    )
    project = workspace.project(project_id)
    version = project.version(version)
    version.deploy(
        model_type=size,
        model_path=tmp_out_dir,
        filename="weights.pt"
    )
    shutil.rmtree(tmp_out_dir)
```

--------------------------------

### RFDETRSmall.deploy_to_roboflow

Source: https://rfdetr.roboflow.com/1.3.0/reference/small

Deploy the trained RF-DETR Small model to Roboflow, creating a Serverless API or downloading weights for inference.

```APIDOC
## RFDETRSmall.deploy_to_roboflow

### Description
Deploy the trained RF-DETR model to Roboflow. Deploying with Roboflow will create a Serverless API to which you can make requests. You can also download weights into a Roboflow Inference deployment for use in Roboflow Workflows and on-device deployment.

### Parameters
#### Path Parameters
- **workspace** (str) - Required - The name of the Roboflow workspace to deploy to.
- **project_ids** (List[str]) - Required - A list of project IDs to which the model will be deployed.
#### Query Parameters
- **api_key** (str) - Optional - Your Roboflow API key. If not provided, it will be read from the environment variable `ROBOFLOW_API_KEY`. Defaults to None.
- **size** (str) - Optional - The size of the model to deploy. If not provided, it will default to the size of the model being trained (e.g., "rfdetr-base", "rfdetr-large", etc.). Defaults to None.
```

--------------------------------

### Add RF-DETR with uv

Source: https://rfdetr.roboflow.com/1.3.0

Add the rfdetr package to your uv project.

```bash
uv add rfdetr

```

--------------------------------

### RFDETRNano.deploy_to_roboflow

Source: https://rfdetr.roboflow.com/1.3.0/reference/nano

Deploy the trained RF-DETR Nano model to Roboflow, creating a Serverless API or downloadable weights for Roboflow Inference.

```APIDOC
## RFDETRNano.deploy_to_roboflow

### Description
Deploy the trained RF-DETR model to Roboflow. This action creates a Serverless API for requests and allows downloading weights for Roboflow Inference deployments.

### Parameters
#### Path Parameters
- **workspace** (str) - Required - The name of the Roboflow workspace to deploy to.
- **project_ids** (List[str]) - Required - A list of project IDs to which the model will be deployed.

#### Query Parameters
- **api_key** (str) - Optional - Your Roboflow API key. If not provided, it will be read from the environment variable `ROBOFLOW_API_KEY`. Default: None.
- **size** (str) - Optional - The size of the model to deploy. If not provided, it will default to the size of the model being trained (e.g., "rfdetr-base", "rfdetr-large", etc.). Default: None.
```

--------------------------------

### `deploy_to_roboflow` method

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

Deploy the trained RFDetr model to Roboflow. This function creates a Serverless API for the model and allows downloading weights for various deployment scenarios. It requires workspace, project ID, and version information, with optional parameters for API key and model size.

```APIDOC
## `deploy_to_roboflow(workspace, project_id, version, api_key=None, size=None)`

### Description
Deploy the trained RF-DETR model to Roboflow. Deploying with Roboflow will create a Serverless API to which you can make requests. You can also download weights into a Roboflow Inference deployment for use in Roboflow Workflows and on-device deployment.

### Parameters
#### Path Parameters
- **workspace** (str) - Required - The name of the Roboflow workspace to deploy to.
- **project_ids** (List[str]) - Required - A list of project IDs to which the model will be deployed.
- **version** (str) - Required - The version of the project to deploy.

#### Optional Parameters
- **api_key** (str) - Optional - Your Roboflow API key. If not provided, it will be read from the environment variable `ROBOFLOW_API_KEY`.
- **size** (str) - Optional - The size of the model to deploy. If not provided, it will default to the size of the model being trained (e.g., "rfdetr-base", "rfdetr-large", etc.).

### Raises
- ValueError: If the `api_key` is not provided and not found in the environment variable `ROBOFLOW_API_KEY`, or if the `size` is not set for custom architectures.
```

--------------------------------

### Optimize RFDETR Model for Inference

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

Prepares the RFDETR model for efficient inference by creating a deep copy, setting it to evaluation mode, and optionally tracing it with PyTorch JIT. This process optimizes the model for speed and reduced memory usage.

```python
def optimize_for_inference(self, compile=True, batch_size=1, dtype=torch.float32):
        self.remove_optimized_model()

        self.model.inference_model = deepcopy(self.model.model)
        self.model.inference_model.eval()
        self.model.inference_model.export()

        self._optimized_resolution = self.model.resolution
        self._is_optimized_for_inference = True

        self.model.inference_model = self.model.inference_model.to(dtype=dtype)
        self._optimized_dtype = dtype

        if compile:
            self.model.inference_model = torch.jit.trace(
                self.model.inference_model,
                torch.randn(
                    batch_size, 3, self.model.resolution, self.model.resolution, 
                    device=self.model.device,
                    dtype=dtype
                )
            )
            self._optimized_has_been_compiled = True
            self._optimized_batch_size = batch_size
```

--------------------------------

### Load and Predict with RF-DETR Object Detection Model

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Load a fine-tuned RF-DETR object detection model from a checkpoint and perform predictions on an image.

```python
from rfdetr import RFDETRBase

model = RFDETRBase(pretrain_weights=<CHECKPOINT_PATH>)

detections = model.predict(<IMAGE_PATH>)
```

--------------------------------

### Download RF-DETR Pre-trained Weights

Source: https://rfdetr.roboflow.com/1.3.0/reference/medium

Downloads pre-trained weights for the RF-DETR model if they are not already present. This function relies on the `pretrain_weights` attribute within the model's configuration.

```python
def maybe_download_pretrain_weights(self):
    """
    Download pre-trained weights if they are not already downloaded.
    """
    download_pretrain_weights(self.model_config.pretrain_weights)

```

--------------------------------

### maybe_download_pretrain_weights Function

Source: https://rfdetr.roboflow.com/1.3.0/reference/large

Download pre-trained weights for the RF-DETR Large model if they are not already present.

```APIDOC
### `maybe_download_pretrain_weights`

Download pretrain weights if not already downloaded.
```

--------------------------------

### RFDETRMedium.deploy_to_roboflow

Source: https://rfdetr.roboflow.com/1.3.0/reference/medium

Deploy the trained RF-DETR Medium model to Roboflow, creating a Serverless API or downloading weights for inference deployments.

```APIDOC
## RFDETRMedium.deploy_to_roboflow

### Description
Deploy the trained RF-DETR model to Roboflow. Deploying with Roboflow will create a Serverless API to which you can make requests. You can also download weights into a Roboflow Inference deployment for use in Roboflow Workflows and on-device deployment.

### Parameters
#### Path Parameters
- **workspace** (str) - Required - The name of the Roboflow workspace to deploy to.
- **project_ids** (List[str]) - Required - A list of project IDs to which the model will be deployed
#### Query Parameters
- **api_key** (str) - Optional - Your Roboflow API key. If not provided, it will be read from the environment variable `ROBOFLOW_API_KEY`. Default: None
- **size** (str) - Optional - The size of the model to deploy. If not provided, it will default to the size of the model being trained (e.g., "rfdetr-base", "rfdetr-large", etc.). Default: None
```

--------------------------------

### Load and Predict with RF-DETR Segmentation Model

Source: https://rfdetr.roboflow.com/1.3.0/learn/train

Load a fine-tuned RF-DETR segmentation model from a checkpoint and perform predictions on an image.

```python
from rfdetr import RFDETRSegPreview

model = RFDETRSegPreview(pretrain_weights=<CHECKPOINT_PATH>)

detections = model.predict(<IMAGE_PATH>)
```

--------------------------------

### Deploy RF-DETR Model to Roboflow

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

This method facilitates the deployment of a trained RF-DETR model to the Roboflow platform. It requires specifying workspace, project ID, version, and optionally an API key and desired model size.

```python
    def deploy_to_roboflow(self, workspace: str, project_id: str, version: str, api_key: str = None, size: str = None):
        """
        Deploy the trained RF-DETR model to Roboflow.
        """
```

--------------------------------

### maybe_download_pretrain_weights

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

Downloads pre-trained weights for the RF-DETR model if they are not already present. This is useful for initializing the model with learned features.

```APIDOC
## maybe_download_pretrain_weights

### Description
Downloads pre-trained weights for the RF-DETR model if they are not already present.
```

--------------------------------

### Deploy RFDETR Nano Model to Roboflow

Source: https://rfdetr.roboflow.com/1.3.0/learn/deploy

Use this snippet to deploy an object detection RFDETR Nano model to Roboflow. Ensure you have your pretrain weights directory, workspace, project ID, and API key ready.

```python
from rfdetr import RFDETRNano

x = RFDETRNano(pretrain_weights="<path/to/pretrain/weights/dir>")
x.deploy_to_roboflow(
  workspace="<your-workspace>",
  project_id="<your-project-id>",
  version=1,
  api_key="<YOUR_API_KEY>"
)

```

--------------------------------

### Retrieve Training Configuration

Source: https://rfdetr.roboflow.com/1.3.0/reference/rfdetr

This function retrieves the configuration parameters intended for the training process. It instantiates and returns a `TrainConfig` object.

```python
    def get_train_config(self, **kwargs):
        """
        Retrieve the configuration parameters that will be used for training.
        """
        return TrainConfig(**kwargs)
```
Tokens:
Raw