Claude-Skills senior-computer-vision

install

source · Clone the upstream repo

git clone https://github.com/borghei/Claude-Skills

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/borghei/Claude-Skills "$T" && mkdir -p ~/.claude/skills && cp -r "$T/engineering/senior-computer-vision" ~/.claude/skills/borghei-claude-skills-senior-computer-vision && rm -rf "$T"

manifest: engineering/senior-computer-vision/SKILL.md

source content

Senior Computer Vision Engineer

The agent designs end-to-end computer vision pipelines for object detection, instance/semantic segmentation, and production deployment. It generates training configurations for YOLO/Detectron2/MMDetection, optimizes models for ONNX/TensorRT/OpenVINO runtimes, and builds dataset preparation workflows with format conversion and augmentation.

Quick Start

# Generate training configuration for YOLO or Faster R-CNN
python scripts/vision_model_trainer.py models/ --task detection --arch yolov8

# Analyze model for optimization opportunities (quantization, pruning)
python scripts/inference_optimizer.py model.pt --target onnx --benchmark

# Build dataset pipeline with augmentations
python scripts/dataset_pipeline_builder.py images/ --format coco --augment

Workflow 1: Object Detection Pipeline

The agent uses this workflow when building an object detection system from scratch.

Step 1: Define Detection Requirements

Analyze the detection task requirements:

Detection Requirements Analysis:
- Target objects: [list specific classes to detect]
- Real-time requirement: [yes/no, target FPS]
- Accuracy priority: [speed vs accuracy trade-off]
- Deployment target: [cloud GPU, edge device, mobile]
- Dataset size: [number of images, annotations per class]

Step 2: Select Detection Architecture

Choose architecture based on requirements:

Requirement	Recommended Architecture	Why
Real-time (>30 FPS)	YOLOv8/v11, RT-DETR	Single-stage, optimized for speed
High accuracy	Faster R-CNN, DINO	Two-stage, better localization
Small objects	YOLO + SAHI, Faster R-CNN + FPN	Multi-scale detection
Edge deployment	YOLOv8n, MobileNetV3-SSD	Lightweight architectures
Transformer-based	DETR, DINO, RT-DETR	End-to-end, no NMS required

Step 3: Prepare Dataset

Convert annotations to required format:

# COCO format (recommended)
python scripts/dataset_pipeline_builder.py data/images/ \
    --annotations data/labels/ \
    --format coco \
    --split 0.8 0.1 0.1 \
    --output data/coco/

# Verify dataset
python -c "from pycocotools.coco import COCO; coco = COCO('data/coco/train.json'); print(f'Images: {len(coco.imgs)}, Categories: {len(coco.cats)}')"

Step 4: Configure Training

Generate training configuration:

# For Ultralytics YOLO
python scripts/vision_model_trainer.py data/coco/ \
    --task detection \
    --arch yolov8m \
    --epochs 100 \
    --batch 16 \
    --imgsz 640 \
    --output configs/

# For Detectron2
python scripts/vision_model_trainer.py data/coco/ \
    --task detection \
    --arch faster_rcnn_R_50_FPN \
    --framework detectron2 \
    --output configs/

Step 5: Train and Validate

# Ultralytics training
yolo detect train data=data.yaml model=yolov8m.pt epochs=100 imgsz=640

# Detectron2 training
python train_net.py --config-file configs/faster_rcnn.yaml --num-gpus 1

# Validate on test set
yolo detect val model=runs/detect/train/weights/best.pt data=data.yaml

Step 6: Evaluate Results

Key metrics to analyze:

Metric	Target	Description
mAP@50	>0.7	Mean Average Precision at IoU 0.5
mAP@50:95	>0.5	COCO primary metric
Precision	>0.8	Low false positives
Recall	>0.8	Low missed detections
Inference time	<33ms	For 30 FPS real-time

Workflow 2: Model Optimization and Deployment

Use this workflow when preparing a trained model for production deployment.

Step 1: Benchmark Baseline Performance

# Measure current model performance
python scripts/inference_optimizer.py model.pt \
    --benchmark \
    --input-size 640 640 \
    --batch-sizes 1 4 8 16 \
    --warmup 10 \
    --iterations 100

Expected output:

Baseline Performance (PyTorch FP32):
- Batch 1: 45.2ms (22.1 FPS)
- Batch 4: 89.4ms (44.7 FPS)
- Batch 8: 165.3ms (48.4 FPS)
- Memory: 2.1 GB
- Parameters: 25.9M

Step 2: Select Optimization Strategy

Deployment Target	Optimization Path
NVIDIA GPU (cloud)	PyTorch → ONNX → TensorRT FP16
NVIDIA GPU (edge)	PyTorch → TensorRT INT8
Intel CPU	PyTorch → ONNX → OpenVINO
Apple Silicon	PyTorch → CoreML
Generic CPU	PyTorch → ONNX Runtime
Mobile	PyTorch → TFLite or ONNX Mobile

Step 3: Export to ONNX

# Export with dynamic batch size
python scripts/inference_optimizer.py model.pt \
    --export onnx \
    --input-size 640 640 \
    --dynamic-batch \
    --simplify \
    --output model.onnx

# Verify ONNX model
python -c "import onnx; model = onnx.load('model.onnx'); onnx.checker.check_model(model); print('ONNX model valid')"

Step 4: Apply Quantization (Optional)

For INT8 quantization with calibration:

# Generate calibration dataset
python scripts/inference_optimizer.py model.onnx \
    --quantize int8 \
    --calibration-data data/calibration/ \
    --calibration-samples 500 \
    --output model_int8.onnx

Quantization impact analysis:

Precision	Size	Speed	Accuracy Drop
FP32	100%	1x	0%
FP16	50%	1.5-2x	<0.5%
INT8	25%	2-4x	1-3%

Step 5: Convert to Target Runtime

# TensorRT (NVIDIA GPU)
trtexec --onnx=model.onnx --saveEngine=model.engine --fp16

# OpenVINO (Intel)
mo --input_model model.onnx --output_dir openvino/

# CoreML (Apple)
python -c "import coremltools as ct; model = ct.convert('model.onnx'); model.save('model.mlpackage')"

Step 6: Benchmark Optimized Model

python scripts/inference_optimizer.py model.engine \
    --benchmark \
    --runtime tensorrt \
    --compare model.pt

Expected speedup:

Optimization Results:
- Original (PyTorch FP32): 45.2ms
- Optimized (TensorRT FP16): 12.8ms
- Speedup: 3.5x
- Accuracy change: -0.3% mAP

Workflow 3: Custom Dataset Preparation

Use this workflow when preparing a computer vision dataset for training.

Step 1: Audit Raw Data

# Analyze image dataset
python scripts/dataset_pipeline_builder.py data/raw/ \
    --analyze \
    --output analysis/

Analysis report includes:

Dataset Analysis:
- Total images: 5,234
- Image sizes: 640x480 to 4096x3072 (variable)
- Formats: JPEG (4,891), PNG (343)
- Corrupted: 12 files
- Duplicates: 45 pairs

Annotation Analysis:
- Format detected: Pascal VOC XML
- Total annotations: 28,456
- Classes: 5 (car, person, bicycle, dog, cat)
- Distribution: car (12,340), person (8,234), bicycle (3,456), dog (2,890), cat (1,536)
- Empty images: 234

Step 2: Clean and Validate

# Remove corrupted and duplicate images
python scripts/dataset_pipeline_builder.py data/raw/ \
    --clean \
    --remove-corrupted \
    --remove-duplicates \
    --output data/cleaned/

Step 3: Convert Annotation Format

# Convert VOC to COCO format
python scripts/dataset_pipeline_builder.py data/cleaned/ \
    --annotations data/annotations/ \
    --input-format voc \
    --output-format coco \
    --output data/coco/

Supported format conversions:

From	To
Pascal VOC XML	COCO JSON
YOLO TXT	COCO JSON
COCO JSON	YOLO TXT
LabelMe JSON	COCO JSON
CVAT XML	COCO JSON

Step 4: Apply Augmentations

# Generate augmentation config
python scripts/dataset_pipeline_builder.py data/coco/ \
    --augment \
    --aug-config configs/augmentation.yaml \
    --output data/augmented/

Recommended augmentations for detection:

# configs/augmentation.yaml
augmentations:
  geometric:
    - horizontal_flip: { p: 0.5 }
    - vertical_flip: { p: 0.1 }  # Only if orientation invariant
    - rotate: { limit: 15, p: 0.3 }
    - scale: { scale_limit: 0.2, p: 0.5 }

  color:
    - brightness_contrast: { brightness_limit: 0.2, contrast_limit: 0.2, p: 0.5 }
    - hue_saturation: { hue_shift_limit: 20, sat_shift_limit: 30, p: 0.3 }
    - blur: { blur_limit: 3, p: 0.1 }

  advanced:
    - mosaic: { p: 0.5 }  # YOLO-style mosaic
    - mixup: { p: 0.1 }   # Image mixing
    - cutout: { num_holes: 8, max_h_size: 32, max_w_size: 32, p: 0.3 }

Step 5: Create Train/Val/Test Splits

python scripts/dataset_pipeline_builder.py data/augmented/ \
    --split 0.8 0.1 0.1 \
    --stratify \
    --seed 42 \
    --output data/final/

Split strategy guidelines:

Dataset Size	Train	Val	Test
<1,000 images	70%	15%	15%
1,000-10,000	80%	10%	10%
>10,000	90%	5%	5%

Step 6: Generate Dataset Configuration

# For Ultralytics YOLO
python scripts/dataset_pipeline_builder.py data/final/ \
    --generate-config yolo \
    --output data.yaml

# For Detectron2
python scripts/dataset_pipeline_builder.py data/final/ \
    --generate-config detectron2 \
    --output detectron2_config.py

Architecture Selection Guide

Object Detection Architectures

Architecture	Speed	Accuracy	Best For
YOLOv8n	1.2ms	37.3 mAP	Edge, mobile, real-time
YOLOv8s	2.1ms	44.9 mAP	Balanced speed/accuracy
YOLOv8m	4.2ms	50.2 mAP	General purpose
YOLOv8l	6.8ms	52.9 mAP	High accuracy
YOLOv8x	10.1ms	53.9 mAP	Maximum accuracy
RT-DETR-L	5.3ms	53.0 mAP	Transformer, no NMS
Faster R-CNN R50	46ms	40.2 mAP	Two-stage, high quality
DINO-4scale	85ms	49.0 mAP	SOTA transformer

Segmentation Architectures

Architecture	Type	Speed	Best For
YOLOv8-seg	Instance	4.5ms	Real-time instance seg
Mask R-CNN	Instance	67ms	High-quality masks
SAM	Promptable	50ms	Zero-shot segmentation
DeepLabV3+	Semantic	25ms	Scene parsing
SegFormer	Semantic	15ms	Efficient semantic seg

CNN vs Vision Transformer Trade-offs

Aspect	CNN (YOLO, R-CNN)	ViT (DETR, DINO)
Training data needed	1K-10K images	10K-100K+ images
Training time	Fast	Slow (needs more epochs)
Inference speed	Faster	Slower
Small objects	Good with FPN	Needs multi-scale
Global context	Limited	Excellent
Positional encoding	Implicit	Explicit

Reference Documentation

1. Computer Vision Architectures

See

references/computer_vision_architectures.md

for:

CNN backbone architectures (ResNet, EfficientNet, ConvNeXt)
Vision Transformer variants (ViT, DeiT, Swin)
Detection heads (anchor-based vs anchor-free)
Feature Pyramid Networks (FPN, BiFPN, PANet)
Neck architectures for multi-scale detection

2. Object Detection Optimization

See

references/object_detection_optimization.md

for:

Non-Maximum Suppression variants (NMS, Soft-NMS, DIoU-NMS)
Anchor optimization and anchor-free alternatives
Loss function design (focal loss, GIoU, CIoU, DIoU)
Training strategies (warmup, cosine annealing, EMA)
Data augmentation for detection (mosaic, mixup, copy-paste)

3. Production Vision Systems

See

references/production_vision_systems.md

for:

ONNX export and optimization
TensorRT deployment pipeline
Batch inference optimization
Edge device deployment (Jetson, Intel NCS)
Model serving with Triton
Video processing pipelines

Common Commands

Ultralytics YOLO

# Training
yolo detect train data=coco.yaml model=yolov8m.pt epochs=100 imgsz=640

# Validation
yolo detect val model=best.pt data=coco.yaml

# Inference
yolo detect predict model=best.pt source=images/ save=True

# Export
yolo export model=best.pt format=onnx simplify=True dynamic=True

Detectron2

# Training
python train_net.py --config-file configs/COCO-Detection/faster_rcnn_R_50_FPN_3x.yaml \
    --num-gpus 1 OUTPUT_DIR ./output

# Evaluation
python train_net.py --config-file configs/faster_rcnn.yaml --eval-only \
    MODEL.WEIGHTS output/model_final.pth

# Inference
python demo.py --config-file configs/faster_rcnn.yaml \
    --input images/*.jpg --output results/ \
    --opts MODEL.WEIGHTS output/model_final.pth

MMDetection

# Training
python tools/train.py configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py

# Testing
python tools/test.py configs/faster_rcnn.py checkpoints/latest.pth --eval bbox

# Inference
python demo/image_demo.py demo.jpg configs/faster_rcnn.py checkpoints/latest.pth

Model Optimization

# ONNX export and simplify
python -c "import torch; model = torch.load('model.pt'); torch.onnx.export(model, torch.randn(1,3,640,640), 'model.onnx', opset_version=17)"
python -m onnxsim model.onnx model_sim.onnx

# TensorRT conversion
trtexec --onnx=model.onnx --saveEngine=model.engine --fp16 --workspace=4096

# Benchmark
trtexec --loadEngine=model.engine --batch=1 --iterations=1000 --avgRuns=100

Performance Targets

Metric	Real-time	High Accuracy	Edge
FPS	>30	>10	>15
mAP@50	>0.6	>0.8	>0.5
Latency P99	<50ms	<150ms	<100ms
GPU Memory	<4GB	<8GB	<2GB
Model Size	<50MB	<200MB	<20MB

Resources

Architecture Guide:

references/computer_vision_architectures.md

Optimization Guide:

references/object_detection_optimization.md

Deployment Guide:
```
references/production_vision_systems.md
```
Scripts:
```
scripts/
```
directory for automation tools

Anti-Patterns

Training without data audit -- skipping
```
dataset_pipeline_builder.py analyze
```
leads to corrupted images, duplicate pairs, and class imbalance surprises mid-training
Deploying FP32 to production -- always export to FP16 minimum; FP32 wastes 2x memory and 1.5-2x latency for <0.5% mAP difference
Ignoring calibration dataset -- INT8 quantization with random samples causes 5-10% mAP drop; use 500+ representative images from the training distribution
One-size-fits-all architecture -- using YOLOv8x for edge deployment or YOLOv8n for high-accuracy requirements; match architecture to deployment target
Benchmarking without warmup -- first N inference calls include JIT compilation overhead; always use
```
--warmup 10
```
for accurate measurements
Skipping ONNX validation -- export can silently produce incorrect models; always run
```
onnx.checker.check_model()
```
after export

Troubleshooting

Problem	Cause	Solution
Model exports to ONNX but TensorRT conversion fails	Unsupported ONNX opset version or dynamic shapes	Pin `--opset_version 17` , replace dynamic axes with fixed sizes, and run `python -m onnxsim model.onnx model_sim.onnx` before TensorRT conversion
mAP drops significantly after INT8 quantization	Calibration dataset is too small or unrepresentative	Use at least 500 representative images from the training distribution for calibration; verify per-class AP to find affected classes
Training loss plateaus early without convergence	Learning rate too high, insufficient augmentation, or frozen backbone layers	Reduce `lr0` by 10x, enable mosaic/mixup augmentation, and unfreeze backbone ( `--freeze None` ) after initial warmup
CUDA out-of-memory during training	Batch size or image resolution too large for available VRAM	Halve `--batch` , reduce `--imgsz` to 512, enable `--amp True` for mixed precision, or use gradient accumulation via `--nbs`
High false-positive rate on small objects	Default anchor sizes miss small targets; NMS threshold too permissive	Use SAHI (Slicing Aided Hyper Inference), add FPN levels for small scales, and tighten `conf` threshold to 0.4+
Annotation format conversion produces empty labels	Coordinate system mismatch (absolute vs normalized) or category ID mapping errors	Run `dataset_pipeline_builder.py validate` before and after conversion; check that bounding box values are within image dimensions
Inference FPS is lower than expected on GPU	CPU-bound pre/post-processing bottleneck, no batch processing, or missing CUDA warmup	Profile with `--benchmark --warmup 10` , move pre-processing to GPU (torchvision transforms), and ensure `torch.cuda.synchronize()` is called correctly

Success Criteria

Detection accuracy: mAP@50 above 0.70 and mAP@50:95 above 0.50 on the target validation set
Inference latency: P99 latency under 50ms per frame at batch size 1 on target hardware for real-time deployments
Throughput: Sustained processing above 30 FPS for real-time pipelines, above 10 FPS for high-accuracy pipelines
Model size: Optimized model under 50MB for edge deployment, under 200MB for cloud GPU deployment
Quantization fidelity: Less than 2% mAP drop when moving from FP32 to FP16; less than 3% drop for INT8
Dataset quality: Class imbalance ratio no worse than 1:10 between least and most frequent classes; zero corrupted images; annotation coverage above 95% of images
Deployment reliability: ONNX model passes
```
onnx.checker.check_model()
```
validation; TensorRT engine builds without warnings on target GPU architecture

Scope & Limitations

This skill covers:

End-to-end object detection and segmentation pipeline design (data preparation through production deployment)
Training configuration generation for Ultralytics YOLO, Detectron2, and MMDetection frameworks
Model optimization and export to ONNX, TensorRT, OpenVINO, and CoreML runtimes
Dataset format conversion (COCO, YOLO, Pascal VOC, CVAT), splitting, validation, and augmentation configuration

This skill does NOT cover:

Generative vision tasks (image generation, style transfer, super-resolution) -- see dedicated generative AI skills
3D reconstruction, SLAM, or point cloud processing beyond basic depth estimation
Medical imaging regulatory compliance (DICOM, FDA 510(k)) -- see
```
ra-qm-team/
```
compliance skills
Real-time video streaming infrastructure (RTSP, WebRTC, GStreamer pipeline design) -- see
```
senior-devops
```
for infrastructure

Integration Points

Skill	Integration	Data Flow
`senior-ml-engineer`	Model serving and MLOps pipeline setup	Trained model artifacts (.pt, .onnx) flow into `model_deployment_pipeline.py` for containerized serving and monitoring
`senior-data-engineer`	Dataset ETL and storage pipelines	Raw image data ingested via `pipeline_orchestrator.py` ; cleaned datasets flow into `dataset_pipeline_builder.py` for CV formatting
`senior-data-scientist`	Experiment design and statistical analysis	Experiment parameters from `experiment_designer.py` guide hyperparameter search; model metrics feed back for significance testing
`senior-devops`	CI/CD and GPU infrastructure provisioning	Optimized model artifacts deployed via CI/CD pipelines; GPU node scaling managed through infrastructure-as-code
`senior-prompt-engineer`	Multimodal RAG and vision-language integration	Vision model embeddings and detections feed into `rag_system_builder.py` for multimodal retrieval pipelines
`senior-cloud-architect`	Cloud GPU resource planning and cost optimization	Benchmark results from `inference_optimizer.py` inform instance type selection and auto-scaling policies

Tool Reference

vision_model_trainer.py

Purpose: Generates training configuration files for object detection and segmentation models across Ultralytics YOLO, Detectron2, and MMDetection frameworks.

Usage:

python scripts/vision_model_trainer.py <data_dir> [options]

Parameters:

Parameter	Type	Default	Description
`data_dir`	positional	(required)	Path to dataset directory
`--task`	choice	`detection`	Task type: `detection` , `segmentation`
`--framework`	choice	`ultralytics`	Training framework: `ultralytics` , `detectron2` , `mmdetection`
`--arch`	string	`yolov8m`	Model architecture (e.g., `yolov8n` , `yolov8s` , `yolov8m` , `yolov8l` , `yolov8x` , `yolov5n` - `yolov5x` , `faster_rcnn_R_50_FPN` , `mask_rcnn_R_50_FPN` , `retinanet_R_50_FPN` , `detr_r50` , `dino_r50` , `yolox_s` / `m` / `l` )
`--epochs`	int	`100`	Number of training epochs
`--batch`	int	`16`	Batch size
`--imgsz`	int	`640`	Input image size (Ultralytics only)
`--output` , `-o`	string	None	Output config file path
`--analyze-only`	flag	off	Only analyze dataset structure, skip config generation
`--json`	flag	off	Output results as JSON

Example:

# Generate Ultralytics YOLO training config
python scripts/vision_model_trainer.py data/coco/ --task detection --arch yolov8m --epochs 100 --batch 16 --output configs/train.yaml

# Analyze dataset only
python scripts/vision_model_trainer.py data/coco/ --analyze-only --json

# Generate Detectron2 config
python scripts/vision_model_trainer.py data/coco/ --framework detectron2 --arch faster_rcnn_R_50_FPN --output configs/detectron2.py

Output Formats:

Human-readable (default): Prints a summary table with framework, architecture, parameters, COCO mAP, and the training command
JSON (
```
--json
```
): Full configuration dictionary including all hyperparameters and metadata
Config file (
```
--output
```
): YAML for Ultralytics; Python config for Detectron2/MMDetection

inference_optimizer.py

Purpose: Analyzes model structure, benchmarks inference speed across batch sizes, and provides optimization recommendations for target deployment platforms.

Usage:

python scripts/inference_optimizer.py <model_path> [options]

Parameters:

Parameter	Type	Default	Description
`model_path`	positional	(required)	Path to model file ( `.pt` , `.pth` , `.onnx` , `.engine` , `.trt` , `.xml` , `.mlpackage` , `.mlmodel` )
`--analyze`	flag	off	Analyze model structure (parameters, layers, input/output shapes)
`--benchmark`	flag	off	Benchmark inference speed
`--input-size`	int int	`640 640`	Input image size as H W
`--batch-sizes`	int list	`1 4 8`	Batch sizes to benchmark
`--iterations`	int	`100`	Number of benchmark iterations
`--warmup`	int	`10`	Number of warmup iterations before benchmarking
`--target`	choice	`gpu`	Target deployment platform: `gpu` , `cpu` , `edge` , `mobile` , `apple` , `intel`
`--recommend`	flag	off	Show optimization recommendations for the target platform
`--json`	flag	off	Output results as JSON
`--output` , `-o`	string	None	Save results to file

Example:

# Analyze model structure
python scripts/inference_optimizer.py model.onnx --analyze

# Benchmark with custom batch sizes
python scripts/inference_optimizer.py model.pt --benchmark --input-size 640 640 --batch-sizes 1 4 8 16 --warmup 10 --iterations 100

# Get optimization recommendations for edge deployment
python scripts/inference_optimizer.py model.pt --analyze --recommend --target edge --json

# Save full report
python scripts/inference_optimizer.py model.onnx --analyze --benchmark --recommend --output report.json

Output Formats:

Human-readable (default): Summary table with file size, parameters, node count; benchmark table with latency, throughput, and P99 per batch size; numbered optimization recommendations with expected speedup
JSON (
```
--json
```
): Nested dictionary with
```
analysis
```
,
```
benchmark
```
, and
```
recommendations
```
keys
File (
```
--output
```
): JSON report saved to specified path

dataset_pipeline_builder.py

Purpose: Production-grade tool for analyzing, converting, splitting, augmenting, and validating computer vision datasets. Uses subcommands for each operation.

Usage:

python scripts/dataset_pipeline_builder.py <command> [options]

Subcommands:

analyze

-- Analyze dataset structure and statistics

Parameter Type Default Description

--input

-i

string

(required)

Path to dataset

--json

flag

off

Output as JSON

python scripts/dataset_pipeline_builder.py analyze --input data/coco/
python scripts/dataset_pipeline_builder.py analyze --input data/coco/ --json

convert

-- Convert between annotation formats

Parameter	Type	Default	Description
`--input` , `-i`	string	(required)	Input dataset path
`--output` , `-o`	string	(required)	Output dataset path
`--format` , `-f`	choice	(required)	Target format: `yolo` , `coco` , `voc`
`--source-format` , `-s`	choice	None	Source format: `yolo` , `coco` , `voc` (auto-detected if omitted)

python scripts/dataset_pipeline_builder.py convert --input data/voc/ --output data/coco/ --format coco
python scripts/dataset_pipeline_builder.py convert --input data/coco/ --output data/yolo/ --format yolo --source-format coco

split

-- Split dataset into train/val/test sets

Parameter	Type	Default	Description
`--input` , `-i`	string	(required)	Input dataset path
`--output` , `-o`	string	same as input	Output path
`--train`	float	`0.8`	Train split ratio
`--val`	float	`0.1`	Validation split ratio
`--test`	float	`0.1`	Test split ratio
`--stratify`	flag	off	Stratify splits by class distribution
`--seed`	int	`42`	Random seed for reproducibility

python scripts/dataset_pipeline_builder.py split --input data/coco/ --train 0.8 --val 0.1 --test 0.1 --stratify --seed 42

augment-config

-- Generate augmentation configuration

Parameter	Type	Default	Description
`--task` , `-t`	choice	(required)	CV task: `detection` , `segmentation` , `classification`
`--intensity` , `-n`	choice	`medium`	Augmentation intensity: `light` , `medium` , `heavy`
`--framework` , `-f`	choice	`albumentations`	Target framework: `albumentations` , `torchvision` , `ultralytics`
`--output` , `-o`	string	None	Output file path

python scripts/dataset_pipeline_builder.py augment-config --task detection --intensity heavy --output augmentations.yaml

validate

-- Validate dataset integrity

Parameter Type Default Description

--input

-i

string

(required)

Path to dataset

--format

-f

choice

None

Dataset format:

yolo

coco

voc

(auto-detected if omitted)

--json

flag

off

Output as JSON

python scripts/dataset_pipeline_builder.py validate --input data/coco/ --format coco

Output Formats:

Human-readable (default): Structured report with dataset statistics, annotation counts, class distributions, quality checks, and actionable recommendations
JSON (
```
--json
```
): Full analysis dictionary including image stats, annotation details, bounding box statistics, and quality check results