Merge branch 'develop' into feature/coral-tpu-detection

Author: solderzzc

skills/detection/yolo-detection-2026-coral-tpu/deploy.bat

@@ -0,0 +1,56 @@
+# syntax=docker/dockerfile:1
+# ─────────────────────────────────────────────────────────────────────────────
+# Coral Edge TPU Model Compiler
+#
+# Compiles YOLO 2026 nano to Google Coral Edge TPU .tflite format using
+# ultralytics' built-in format="edgetpu" export pipeline.
+#
+# Per https://docs.ultralytics.com/guides/coral-edge-tpu-on-raspberry-pi/:
+#   model.export(format="edgetpu") handles the full pipeline:
+#   .pt → ONNX → onnx2tf SavedModel → TFLite INT8 → edgetpu_compiler
+#
+# MUST run on linux/amd64 — edgetpu_compiler is x86_64 Linux only.
+# On Apple Silicon or Windows, Docker Desktop handles QEMU emulation.
+# ─────────────────────────────────────────────────────────────────────────────
+
+FROM --platform=linux/amd64 python:3.11-slim
+
+LABEL maintainer="Aegis-AI / DeepCamera"
+LABEL description="Compiles YOLO 2026 to Google Coral Edge TPU .tflite"
+
+# ── System deps ───────────────────────────────────────────────────────────────
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        curl \
+        gnupg \
+        apt-transport-https \
+        ca-certificates \
+        libgl1 \
+        libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# ── edgetpu_compiler from Google Coral apt (x86_64 only) ─────────────────────
+RUN curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg \
+        | gpg --dearmor -o /usr/share/keyrings/coral-edgetpu.gpg \
+    && echo "deb [signed-by=/usr/share/keyrings/coral-edgetpu.gpg] \
+        https://packages.cloud.google.com/apt coral-edgetpu-stable main" \
+        > /etc/apt/sources.list.d/coral-edgetpu.list \
+    && apt-get update \
+    && apt-get install -y --no-install-recommends edgetpu-compiler \
+    && rm -rf /var/lib/apt/lists/*
+
+# ── Python: ultralytics handles all TF/onnx2tf version management ─────────────
+# ultralytics auto-installs: onnx2tf, tensorflow-cpu, onnxslim, etc.
+RUN pip install --no-cache-dir \
+        "ultralytics>=8.3.0" \
+        "numpy>=1.24.0,<2.0"
+
+# ── Copy compile entrypoint ───────────────────────────────────────────────────
+WORKDIR /compile
+COPY scripts/compile_model.py /compile/compile_model.py
+
+# ── Output volume (mount skill's models/ directory here) ──────────────────────
+VOLUME ["/compile/output"]
+
+# ── Entrypoint ────────────────────────────────────────────────────────────────
+ENTRYPOINT ["python", "/compile/compile_model.py"]
+CMD ["--model", "yolo26n", "--size", "320", "--output", "/compile/output"]

skills/detection/yolo-detection-2026-coral-tpu/docker/Dockerfile

@@ -0,0 +1,84 @@
+# Coral Edge TPU Model Compiler — Docker
+
+Converts the YOLO 2026 nano model to Google Coral Edge TPU format using
+a Docker container (so `edgetpu_compiler` runs on Linux x86_64, even from
+Windows or Apple Silicon machines).
+
+## Pipeline
+
+```
+yolo26n.pt  →  [ultralytics export INT8]  →  yolo26n_int8.tflite
+           →  [edgetpu_compiler]          →  yolo26n_int8_edgetpu.tflite
+```
+
+The compiled `.tflite` file is written to `../models/` and then committed
+to the git repository so `deploy.bat` / `deploy.sh` can pick it up without
+needing to compile again.
+
+## Requirements
+
+- Docker Desktop (Windows / macOS) or Docker Engine (Linux)
+- Internet access on first run (downloads `yolo26n.pt` from ultralytics + base image)
+- On Windows: Docker Desktop with WSL2 backend recommended
+
+## Quick Start
+
+### Option A — Shell script (Linux / macOS / Git Bash on Windows)
+
+```bash
+bash docker/compile.sh
+```
+
+### Option B — Docker Compose
+
+```bash
+# From the skill root (yolo-detection-2026-coral-tpu/)
+docker compose -f docker/docker-compose.yml run --rm coral-compiler
+```
+
+### Option C — Raw Docker commands
+
+```bash
+# Build
+docker build --platform linux/amd64 -t coral-tpu-compiler -f docker/Dockerfile .
+
+# Run (mounts models/ as output)
+docker run --rm --platform linux/amd64 \
+  -v "$(pwd)/models:/compile/output" \
+  coral-tpu-compiler \
+  --model yolo26n --size 320 --output /compile/output
+```
+
+## Output Files
+
+After compilation, `models/` will contain:
+
+| File | Size | Notes |
+|------|------|-------|
+| `yolo26n_int8.tflite` | ~3–4 MB | Full-integer quantized (CPU fallback) |
+| `yolo26n_int8_edgetpu.tflite` | ~3–4 MB | Compiled for Edge TPU (primary model) |
+
+> **Note**: `edgetpu_compiler` may warn that some YOLO operations are not mapped
+> to the Edge TPU and will fall back to CPU. This is expected for larger YOLO
+> architectures with complex postprocessing. The 320×320 nano model achieves
+> ~100% on-chip mapping.
+
+## Committing the Model
+
+```bash
+git add models/*.tflite
+git commit -m "feat(coral-tpu): add compiled yolo26n edgetpu model (320x320 INT8)"
+git push
+```
+
+## Recompiling
+
+If you update the YOLO model or want a 640×640 version:
+
+```bash
+# 640×640 version
+bash docker/compile.sh --model yolo26n --size 640
+
+# Small model
+bash docker/compile.sh --model yolo26s --size 320
+```

skills/detection/yolo-detection-2026-coral-tpu/docker/README.md

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+# compile.sh — Build and run the Coral EdgeTPU model compiler Docker image.
+#
+# Converts yolo26n.pt → TFLite INT8 → yolo26n_edgetpu.tflite
+# Output lands in ../models/ (tracked in the git repo).
+#
+# Usage:
+#   bash docker/compile.sh                    # 320×320 nano (default)
+#   bash docker/compile.sh --size 640         # 640×640 nano
+#   bash docker/compile.sh --model yolo26s    # small model
+#
+# Requirements:
+#   - Docker with buildx / multi-platform support
+#   - Internet access (downloads yolo26n.pt from ultralytics on first run)
+#
+# On Apple Silicon or Windows, Docker Desktop handles linux/amd64 emulation
+# via Rosetta / QEMU automatically. First run will be slower (emulation).
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SKILL_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+MODELS_DIR="$SKILL_DIR/models"
+IMAGE_NAME="coral-tpu-compiler"
+
+# ── Parse args (pass-through to compile_model.py) ────────────────────────────
+COMPILE_ARGS=("$@")
+if [[ ${#COMPILE_ARGS[@]} -eq 0 ]]; then
+    COMPILE_ARGS=(--model yolo26n --size 320 --output /compile/output)
+fi
+
+log() { echo "[compile.sh] $*" >&2; }
+
+log "Skill dir : $SKILL_DIR"
+log "Models out: $MODELS_DIR"
+log "Args      : ${COMPILE_ARGS[*]}"
+
+# ── Ensure models dir exists ──────────────────────────────────────────────────
+mkdir -p "$MODELS_DIR"
+
+# ── Build image (linux/amd64 required for edgetpu_compiler) ──────────────────
+log "Building Docker image: $IMAGE_NAME (linux/amd64)..."
+docker build \
+    --platform linux/amd64 \
+    --tag "$IMAGE_NAME:latest" \
+    --file "$SCRIPT_DIR/Dockerfile" \
+    "$SKILL_DIR"
+
+log "Build complete. Running model compiler..."
+
+# ── Run compiler, mount models/ as output volume ──────────────────────────────
+docker run --rm \
+    --platform linux/amd64 \
+    --name coral-tpu-compile-run \
+    -v "$MODELS_DIR:/compile/output" \
+    "$IMAGE_NAME:latest" \
+    "${COMPILE_ARGS[@]}"
+
+echo ""
+log "✓ Compilation complete. Output files in: $MODELS_DIR"
+log ""
+log "Files produced:"
+ls -lh "$MODELS_DIR"/*.tflite 2>/dev/null || log "  (no .tflite files yet — check compile output above)"
+
+echo ""
+log "Next steps:"
+log "  1. Verify the model:  ls -lh $MODELS_DIR/*_edgetpu.tflite"
+log "  2. Commit to git:     git -C '$SKILL_DIR' add models/*.tflite && git commit -m 'feat(coral-tpu): add compiled yolo26n edgetpu model'"
+log "  3. Run deploy.bat on your Windows machine to install the skill."

skills/detection/yolo-detection-2026-coral-tpu/docker/compile.sh

@@ -0,0 +1,35 @@
+services:
+  # ─────────────────────────────────────────────────────────────────────────
+  # coral-compiler
+  #
+  # Compiles YOLO 2026 nano (.pt) → TFLite INT8 → Edge TPU (.tflite).
+  # Output files land in the skill's models/ directory.
+  #
+  # Usage:
+  #   docker compose run --rm coral-compiler                        # default 320×320
+  #   docker compose run --rm coral-compiler --size 640             # 640×640
+  #   docker compose run --rm coral-compiler --model yolo26s        # small model
+  #
+  # Build only:
+  #   docker compose build coral-compiler
+  # ─────────────────────────────────────────────────────────────────────────
+  coral-compiler:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile
+      platforms:
+        - linux/amd64
+    platform: linux/amd64
+    image: coral-tpu-compiler:latest
+    volumes:
+      # Mount the skill's models/ directory as the compiler output
+      - ../models:/compile/output
+    command:
+      - --model
+      - yolo26n
+      - --size
+      - "320"
+      - --output
+      - /compile/output
+    # Don't restart — this is a one-shot build job
+    restart: "no"

skills/detection/yolo-detection-2026-coral-tpu/docker/docker-compose.yml

@@ -1,11 +1,43 @@
-# Pre-compiled YOLO 2026 Nano model for Google Coral Edge TPU
-#
-# Place your compiled model here:
-#   yolo26n_320_edgetpu.tflite  (320×320 input, fully on-chip)
-#   yolo26n_640_edgetpu.tflite  (640×640 input, partially on CPU)
-#
-# To compile your own:
-#   python scripts/compile_model.py --model yolo26n --size 320 --output models/
-#
-# Note: edgetpu_compiler only runs on x86_64 Linux.
-# Use Docker with --platform linux/amd64 on other architectures.
+# Pre-compiled YOLO 2026 Nano models for Google Coral Edge TPU
+
+Place compiled `.tflite` files here. They are committed to the repository
+so `deploy.bat` and `deploy.sh` can use them without needing a Linux machine.
+
+## Files Expected
+
+| File | Size | Notes |
+|------|------|-------|
+| `yolo26n_int8_edgetpu.tflite` | ~3–4 MB | Edge TPU compiled (primary) |
+| `yolo26n_int8.tflite` | ~3–4 MB | CPU fallback |
+
+## How to Compile
+
+The `edgetpu_compiler` only runs on x86_64 Linux. Use the included Docker
+setup to compile from any OS (Windows, macOS, Linux):
+
+```bash
+# From the yolo-detection-2026-coral-tpu/ root:
+bash docker/compile.sh
+```
+
+Or with Docker Compose:
+```bash
+docker compose -f docker/docker-compose.yml run --rm coral-compiler
+```
+
+See `docker/README.md` for full instructions.
+
+## After Compiling
+
+```bash
+git add models/*.tflite
+git commit -m "feat(coral-tpu): add compiled yolo26n edgetpu model (320x320 INT8)"
+git push
+```
+
+## Alternative: CPU Fallback
+
+If no EdgeTPU model is present, `deploy.bat` / `deploy.sh` will download
+`ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite` as a functional
+fallback. This is SSD MobileNet (not YOLO 2026), but confirms the TPU
+pipeline works before the YOLO model is compiled.

skills/detection/yolo-detection-2026-coral-tpu/models/README.md

@@ -1,10 +1,16 @@
-# Dependencies for Coral TPU Detection Skill
+# Coral TPU Detection Skill — Python Dependencies
 #
-# Runtime: ai-edge-litert (LiteRT) — modern successor to tflite-runtime
-# Hardware: libedgetpu must be installed separately as a system library
-#           See SKILL.md → Platform Setup for installation instructions
+# Runtime: ai-edge-litert (LiteRT) — Google's modern TFLite runtime
+#   Supports Python 3.9–3.13. No pycoral required.
+#   detect.py uses the low-level ai-edge-litert API directly with
+#   libedgetpu as a delegate — this is faster and simpler than pycoral.
+#
+# Hardware driver: libedgetpu (system library, installed separately)
+#   Linux:   libedgetpu.so.1    (via apt: libedgetpu1-std)
+#   macOS:   libedgetpu.1.dylib (via deploy-macos.sh)
+#   Windows: edgetpu.dll        (via deploy.bat UAC install)
 
-# LiteRT runtime with Edge TPU delegate support (Python 3.9–3.13)
+# LiteRT runtime — loads Edge TPU delegate on all platforms
 ai-edge-litert>=2.1.0
 
 # Image processing