class

YOLOV1ForObjectDetection

extendsPretrainedModel

YOLOV1ForObjectDetection(config: YOLOV1Config)

source edit

YOLOv1 single-shot object detector (Redmon et al., CVPR 2016).

The original "You Only Look Once" detector — recasts object detection as a single regression problem. An AlexNet-derived Darknet backbone processes the whole image, then an adaptive-average-pool + two FC layers produce an $S \times S \times (B \cdot 5 + C)$ tensor: for each of $S^2$ grid cells, $B$ candidate boxes $(x, y, w, h, \mathrm{conf})$ and $C$ class probabilities. A box is responsible for an object iff the object's centre falls inside that cell. No anchors, no region proposals — a single forward pass yields all detections at 45 fps on a Titan X.

Parameters

configYOLOV1Config

Frozen architecture spec. Use yolo_v1 for the full Darknet backbone or yolo_v1_tiny for the lightweight Tiny variant; both default to PASCAL VOC's S = 7, B = 2, C = 20.

Attributes

configYOLOV1Config

Stored copy of the config that built this model.

darknetnn.Sequential

Backbone convolutional stack (full or tiny depending on config.tiny).

poolnn.AdaptiveAvgPool2d

Pools backbone output to a fixed

S \times S

map.

fc1, fc2nn.Linear

Two-layer FC head producing the

S \cdot S \cdot (B \cdot 5 + C)

flat prediction tensor.

Notes

See Redmon et al., "You Only Look Once: Unified, Real-Time Object Detection", CVPR 2016 (arXiv:1506.02640). The defining multi-part loss is

\begin{aligned} \mathcal{L} =\; & \lambda_\mathrm{coord} \sum_{i, j} \mathbb{1}_{ij}^\mathrm{obj} \bigl[(x_i - \hat{x}_i)^2 + (y_i - \hat{y}_i)^2\bigr] \\ & + \lambda_\mathrm{coord} \sum_{i, j} \mathbb{1}_{ij}^\mathrm{obj} \bigl[(\sqrt{w_i} - \sqrt{\hat{w}_i})^2 + (\sqrt{h_i} - \sqrt{\hat{h}_i})^2\bigr] \\ & + \sum_{i, j} \mathbb{1}_{ij}^\mathrm{obj} (C_i - \hat{C}_i)^2 + \lambda_\mathrm{noobj} \sum_{i, j} \mathbb{1}_{ij}^\mathrm{noobj} (C_i - \hat{C}_i)^2 \\ & + \sum_i \mathbb{1}_i^\mathrm{obj} \sum_{c \in \mathcal{C}} (p_i(c) - \hat{p}_i(c))^2, \end{aligned}

with $\lambda_\mathrm{coord} = 5$ , $\lambda_\mathrm{noobj} = 0.5$ to balance localisation vs. background regression. The square-root parameterisation on width / height down-weights errors in large boxes.

Examples

>>> import lucid
>>> from lucid.models.vision.yolo._v1 import yolo_v1
>>> model = yolo_v1()
>>> x = lucid.randn(1, 3, 448, 448)   # YOLOv1 trained at 448
>>> out = model(x)
>>> out.logits.shape[-1] >= 20
True

Used by 1

lucid.models.vision.yolo

Constructors

dunder

init

→None

__init__(config: YOLOV1Config)

source edit

Instance methods

forward

→ObjectDetectionOutput

forward(x: Tensor, targets: list[dict[str, Tensor]] | None = None, image_size: tuple[int, int] = (448, 448))

source edit

Run YOLOv1 forward pass.

Parameters

xTensor

(B, C, H, W) input image tensor.

targetslist[dict[str, Tensor]] | None= None

Optional list of B dicts for training loss computation. Each dict has: - "boxes": (M_i, 4) xyxy boxes normalised to [0, 1]. - "labels": (M_i,) integer class indices.

image_sizetuple[int, int]= (448, 448)

(H, W) of the input in pixels (used for box decoding). Defaults to 448×448 (the original paper resolution).

Returns

ObjectDetectionOutput

class:~lucid.models._output.ObjectDetectionOutput with:

postprocess

→list[dict[str, Tensor]]

postprocess(output: ObjectDetectionOutput, image_size: tuple[int, int] = (448, 448))

source edit

Per-class NMS on raw predictions.

Parameters

outputObjectDetectionOutput

Output from forward.

image_sizetuple[int, int]= (448, 448)

(H, W) of the input image.

Returns

list[dict[str, Tensor]]

List of per-image result dicts with "boxes", "scores",

>>> import lucid >>> from lucid.models.vision.yolo._v1 import yolo_v1 >>> model = yolo_v1() >>> x = lucid.randn(1, 3, 448, 448) # YOLOv1 trained at 448 >>> out = model(x) >>> out.logits.shape[-1] >= 20 True