Senior Computer Vision

What This Skill Does

• The Senior Computer Vision Engineer skill supports production computer vision engineering.
• It covers object detection, image segmentation, and visual AI system deployment.
• It is designed for computer vision engineers deploying models in production environments.

When to Use

• Generate training configuration.
• Analyze model for optimization.
• Build dataset pipeline.
• Optimize models for inference.
• Prepare custom datasets.
• Select appropriate architectures.

Key Features

• Supports YOLO and Faster R-CNN.
• Offers guidance on model optimization.
• Provides dataset pipeline building tools.
• Covers object detection and segmentation.
• Supports ONNX, TensorRT, and OpenVINO.

Manual Installation

Production computer vision engineering skill for object detection, image segmentation, and visual AI system deployment.

Table of Contents

Quick Start

Core Expertise

Tech Stack

Workflow 1: Object Detection Pipeline

Workflow 2: Model Optimization and Deployment Workflow 3: Custom Dataset Preparation Architecture Selection Guide Reference Documentation Common Commands

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

Core Expertise

This skill provides guidance on:

Object Detection: YOLO family (v5-v11), Faster R-CNN, DETR, RT-DETR Instance Segmentation: Mask R-CNN, YOLACT, SOLOv2 Semantic Segmentation: DeepLabV3+, SegFormer, SAM (Segment Anything) Image Classification: ResNet, EfficientNet, Vision Transformers (ViT, DeiT) Video Analysis: Object tracking (ByteTrack, SORT), action recognition 3D Vision: Depth estimation, point cloud processing, NeRF Production Deployment: ONNX, TensorRT, OpenVINO, CoreML

Tech Stack

Workflow 1: Object Detection Pipeline

Use 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:

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:

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

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:

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