---
license: mit
language:
- en
metrics:
- precision
- recall
- mAP50
- mAP50-95
base_model:
- Ultralytics/YOLOv8
pipeline_tag: object-detection
tags:
- yolov8
- onnx
- petri_dish
- bioinformatics
- automator
- computer-vision
- biology
- lab-automation
---

### Petri Dish YOLO ONNX

YOLO object detection model for detecting round Petri dishes in camera images.

#### Model Details

* Model file: bestnew.onnx
* Format: ONNX
* Task: Object detection
* Object class: Petri dish
* Inference runtime: ONNX Runtime
* Recommended provider: CPUExecutionProvider

#### What the Model Does

The model takes an image as input and returns bounding-box detections for Petri dishes.

It performs Petri dish detection only.

#### Input

The model expects one image frame.

Input tensor
```bash
Shape: [1, 3, H, W]
Type: float32
Range: 0.0 to 1.0
Layout: NCHW
```
Where:

* 1 is the batch size
* 3 is the number of image channels
* H and W are the model input height and width

The input size should be read from the ONNX model:

```python
input_size = session.get_inputs()[0].shape[2]
```

#### Preprocessing

The image should be resized with aspect-ratio preservation and padded to a square input canvas.

```python
import cv2
import numpy as np
def preprocess(img: np.ndarray, input_size: int):
    h, w = img.shape[:2]
    scale = input_size / max(h, w)
    nh, nw = int(h * scale), int(w * scale)
    canvas = np.full((input_size, input_size, 3), 114, dtype=np.uint8)
    top = (input_size - nh) // 2
    left = (input_size - nw) // 2
    resized = cv2.resize(img, (nw, nh))
    canvas[top:top + nh, left:left + nw] = resized
    blob = canvas.astype(np.float32) / 255.0
    blob = np.transpose(blob, (2, 0, 1))[None]
    return blob, scale, left, top, w, h
```

#### Output

The model outputs YOLO-style detections.

Each raw detection has the format:

```bash
[x_center, y_center, width, height, confidence]
```

Where:

* x_center is the bounding-box centre X coordinate
* y_center is the bounding-box centre Y coordinate
* width is the bounding-box width
* height is the bounding-box height
* confidence is the detection confidence score

#### Postprocessing

After inference, detections should be:

1. Filtered by confidence
2. Converted from centre-format boxes to corner-format boxes
3. Mapped back to the original image coordinate space
4. Filtered with Non-Maximum Suppression

#### Recommended thresholds:

```bash
CONF_THRES = 0.75
IOU_THRES = 0.45
```

#### Example postprocessing:

```python
import cv2
def postprocess(pred, scale, dx, dy, orig_w, orig_h):
    boxes = []
    scores = []
    for det in pred[0][0]:
        conf = float(det[4])
        if conf < CONF_THRES:
            continue
        x, y, w, h = det[:4]
        x1 = (x - w / 2 - dx) / scale
        y1 = (y - h / 2 - dy) / scale
        x2 = (x + w / 2 - dx) / scale
        y2 = (y + h / 2 - dy) / scale
        boxes.append([x1, y1, x2, y2])
        scores.append(conf)
    if not boxes:
        return []
    rects = [
        [int(x1), int(y1), int(x2 - x1), int(y2 - y1)]
        for x1, y1, x2, y2 in boxes
    ]
    idx = cv2.dnn.NMSBoxes(
        rects,
        scores,
        CONF_THRES,
        IOU_THRES
    )
    if idx is None or len(idx) == 0:
        return []
    return [
        (
            boxes[i][0],
            boxes[i][1],
            boxes[i][2],
            boxes[i][3],
            scores[i]
        )
        for i in idx.flatten()
    ]
```


Final detections are returned as:

```bash
[x1, y1, x2, y2, confidence]
```

Where:

* x1, y1 are the top-left bounding-box coordinates
* x2, y2 are the bottom-right bounding-box coordinates
* confidence is the model confidence score

#### Example Inference

```python
import cv2
import numpy as np
import onnxruntime as ort
CONF_THRES = 0.75
IOU_THRES = 0.45
model_path = "bestnew.onnx"
image_path = "example.jpg"
session = ort.InferenceSession(
    model_path,
    providers=["CPUExecutionProvider"]
)
input_name = session.get_inputs()[0].name
input_size = session.get_inputs()[0].shape[2]
image = cv2.imread(image_path)
blob, scale, dx, dy, orig_w, orig_h = preprocess(image, input_size)
predictions = session.run(
    None,
    {input_name: blob}
)
detections = postprocess(
    predictions,
    scale,
    dx,
    dy,
    orig_w,
    orig_h
)
print(detections)
```

#### Example detection output:

```bash
[
    [124.6, 88.3, 412.9, 376.4, 0.93],
    [530.1, 91.5, 816.2, 379.8, 0.89]
]
```

#### Output Meaning

Each detection represents one detected Petri dish in the input image.

```bash
[x1, y1, x2, y2, confidence]
```

Example:
```bash
[124.6, 88.3, 412.9, 376.4, 0.93]
```

This means:

* Top-left corner: (124.6, 88.3)
* Bottom-right corner: (412.9, 376.4)
* Confidence: 0.93

#### Intended Use

This model is intended for detecting Petri dishes in camera images and returning their bounding-box locations.

#### Limitations

* The model only detects Petri dishes.
* Detection quality depends on image quality, camera angle, lighting, occlusion, and similarity to the training data.
* Postprocessing thresholds may need adjustment for different camera setups.
* The model output should be validated in the target imaging environment before production use.
  
## Citation

If you use this model, please cite this Hugging Face repository.

```bibtex
@misc{rohan_r_2026,
	author       = { Rohan R },
	title        = { petri_dish_yolo (Revision 0ab5b88) },
	year         = 2026,
	url          = { https://huggingface.co/rotsl/petri_dish_yolo },
	doi          = { 10.57967/hf/9098 },
	publisher    = { Hugging Face }
}
```

## License

[MIT @ Rohan R, 2026](https://huggingface.co/rotsl/petri_dish_yolo/blob/main/LICENSE)