scraper_plan_v2.md

# E-Waste Image Dataset Pipeline: Revised Plan (v2)

## 0. What changed from v1

v1 framed the work as a scraping problem. v2 treats it as a **dataset-quality problem** in which scraping is one input. The main changes:

| Area | v1 | v2 |
| :--- | :--- | :--- |
| Class definitions | Scrape folders and annotation classes disagreed | One taxonomy defined first; queries derived from it |
| Deduplication | MD5 only (byte-identical) | Exact hash + perceptual hash (flip-aware) + embedding clusters, global across classes |
| Aspect-ratio filter | Discarded > 3:1 (removes RAM/edge-finger images) | Flag > 3:1, discard only > 6:1 |
| Min resolution | 250 px | Short side ≥ 480 px, long side ≥ 800 px |
| Relevance | None | CLIP zero-shot filter + manual review queue |
| Domain gap | Web images only | Real-world capture set, held-out real-world test split |
| Splits | Random train/val | Cluster-aware train/val + separate real-world test |
| Small objects | Not addressed | Resolution policy, `imgsz=1280`, tiling/two-stage inference |
| Image handling | `verify()` only, JPEG q90 | `verify()` + `load()`, EXIF fix, alpha compositing, q95, originals preserved |
| Resilience | Claimed backoff/fallback that `icrawler` lacks | Custom downloader with retries, backoff, per-domain rate limits |
| Provenance | Sequential filenames | Hash filenames + SQLite manifest, resumable stages |
| Targets & metrics | None | Per-class image/instance targets, evaluation plan |
| BIS | Undefined | Proposed definition (needs sign-off) |

---

## 1. Objective & Scope

Build a repeatable pipeline that produces a clean, deduplicated, well-documented image dataset for a YOLO detector that finds components on PCBs and supports an on-device **Board Integrity Score (BIS)** in a mobile app.

**In scope:** collection, validation, normalization, deduplication, relevance filtering, manifesting, splitting, annotation guidelines, training/evaluation plan, export.
**Out of scope for this document:** app UI, backend, pricing/valuation logic beyond BIS inputs.

### Success criteria

- ≥ 1,500 labeled images per class and ≥ 10,000 labeled instances per class in the training set (common YOLO guideline; revisit after the first training run).
- Zero train/val/test leakage (no near-duplicate or same-board pairs across splits).
- ≥ 40% of the final set is "in-the-wild" imagery (dirty, cluttered, phone-shot), not clean listing photos.
- Held-out real-world test set of ≥ 300 images that is never used for tuning.
- Every image traceable to its source URL, query, and processing history via the manifest.

---

## 2. Phase 0: Decisions to lock before writing code

### 2.1 Detection taxonomy (fixes the v1 class mismatch)

Define **object classes** (what YOLO detects) separately from **image-level tags** (metadata used for search and stratification).

**Detection classes (v1 of the label set):**

| Class | Definition | Notes |
| :--- | :--- | :--- |
| `cpu_socket` | LGA, PGA, or ZIF processor socket footprint (populated or empty) | Sockets only; see BGA note below |
| `gold_finger` | Gold-plated edge-connector contacts (PCIe, RAM, edge cards) | Long, thin objects; boxes must not be forced square |
| `ic_chip` | Packaged ICs, including BGA-package chips soldered to the board | Optional sub-attribute `bga` in annotation tool |
| `tantalum_capacitor` | SMD tantalum capacitors (typically yellow/orange/black molded bodies with polarity bar) | Small object; needs labeling rules |
| `desoldered_zone` | Region with exposed pads/solder residue where a component was removed | Ambiguous; needs a precise definition and example gallery |

> **BGA correction:** BGA (ball grid array) is a chip *package* soldered onto the board. LGA/PGA are *sockets*. v1's `bga_cpu_socket` conflated them. In v2, BGA chips fall under `ic_chip`, and socket queries target LGA/PGA only.

**Image-level tags (manifest metadata, not YOLO classes):**

- `board_type`: desktop, laptop, phone, server, GPU, other
- `condition`: intact, stripped, burnt/damaged
- `source_type`: listing (white background), in_the_wild, recycling_yard, render/diagram (to be discarded)

Folders are **not labels**. Search-query hints are noisy and are stored only as `class_hint` metadata.

### 2.2 Target counts and attrition budget

Boards contain several classes per image, so ~3,000-4,000 unique labeled images may cover all classes, but the rare/small classes drive the budget.

| Class | Target images | Target instances | Difficulty |
| :--- | :--- | :--- | :--- |
| `ic_chip` | 1,500 | 15,000+ | Easy (abundant) |
| `cpu_socket` | 1,500 | 3,000+ | Medium |
| `gold_finger` | 1,500 | 5,000+ | Medium |
| `tantalum_capacitor` | 1,500 | 10,000+ | Hard (small, visually varied) |
| `desoldered_zone` | 1,500 | 5,000+ | Hard (ambiguous) |

Expect **50-70% attrition** across validation, dedup, and relevance filtering, so plan to harvest roughly **3x the target** (about 10,000-12,000 raw downloads). Set the exact harvest budget after a 500-image pilot measures the real attrition rate.

### 2.3 Board Integrity Score (BIS): proposed definition

BIS must be defined now because it determines which labels are needed.

Proposal (needs domain-owner sign-off):

```
V_present = Σ over detected high-value classes c of  w_c × count_c
            (cpu_socket, gold_finger, ic_chip, tantalum_capacitor)
V_missing = w_d × (number or area-normalized sum of desoldered_zone detections)

BIS = 100 × V_present / (V_present + V_missing)
```

Open questions: value weights `w_c` (need recycler input), whether to use counts or area, per-board-type normalization, and how detector confidence thresholds affect BIS stability. Log these as decisions in `docs/decisions.md`.

---

## 3. System Architecture

```mermaid
flowchart TD
    A["Config: taxonomy + query matrix"] --> B["URL harvest via icrawler: Bing / Baidu / Flickr"]
    B --> C["Resilient downloader: retry, backoff, rate limit"]
    RW["Real-world photo capture"] --> E
    C --> D[("Originals store: untouched bytes, sha256 names")]
    D --> E{"Validation"}
    E -- "fail: corrupt, under 20 KB, below min resolution, over 6:1" --> X["Discard and log reason"]
    E -- "pass (flag if over 3:1)" --> F["Normalize: EXIF fix, RGB, JPEG q95"]
    F --> G{"Dedup: exact + perceptual, global"}
    G -- "duplicate" --> X
    G -- "unique" --> H{"CLIP relevance filter"}
    H -- "irrelevant" --> X
    H -- "borderline" --> R["Manual review queue"]
    H -- "relevant" --> M["Manifest: SQLite"]
    R --> M
    M --> S["Cluster-aware split: train / val / test"]
    S --> L["Annotation: CVAT or Roboflow"]
    L --> T["YOLO training and evaluation"]
```

Design principles:

1. **Stages are idempotent and resumable.** Each image has a `status` in the manifest; reruns skip completed work.
2. **Originals are never modified.** Normalized copies are derived artifacts and can be regenerated with different settings.
3. **Every discard is logged with a reason** so thresholds can be tuned from data instead of guesses.

---

## 4. Directory & Dataset Schema

```
ewaste_dataset_pipeline/
├── scraper.py                  # CLI entry point (subcommands: harvest, validate, process, dedup, filter, split, report)
├── config/
│   ├── config.yaml             # thresholds, engines, rate limits, seeds
│   ├── taxonomy.yaml           # classes, definitions, image-level tags
│   └── queries.yaml            # query matrix (see §5.1)
├── pipeline/
│   ├── crawler.py              # URL harvest + custom downloader
│   ├── validator.py
│   ├── processor.py            # normalization
│   ├── dedup.py                # exact + perceptual + embedding clusters
│   ├── relevance.py            # CLIP zero-shot filter
│   ├── manifest.py             # SQLite state store + JSONL/CSV export
│   ├── split.py                # cluster-aware splitting
│   └── report.py               # summary statistics
├── tests/
│   ├── fixtures/               # truncated JPEG, RGBA PNG, EXIF-rotated, CMYK, animated GIF, 5:1 RAM image
│   └── test_*.py
├── data/
│   ├── originals/              # untouched downloaded bytes: <sha256[:16]>.<orig_ext>
│   ├── images/                 # normalized JPEGs: <sha256[:16]>.jpg (flat store)
│   ├── review/                 # borderline / flagged images for manual review
│   ├── realworld/              # own captures, organized by session_id
│   ├── manifest.db             # SQLite source of truth
│   └── manifest.jsonl          # export for tooling
├── splits/
│   └── splits.json             # frozen image_id -> split mapping (versioned)
├── reports/
│   └── summary.json
├── dataset_annotated/          # YOLO export after labeling
│   ├── data.yaml
│   ├── train/
│   ├── val/
│   └── test/                   # real-world sessions only
├── docs/
│   ├── decisions.md
│   └── labeling_guide.md
└── requirements.txt
```

The flat `images/` store replaces per-class folders because one image can match several queries. Per-hint browsing views can be generated from the manifest on demand.

---

## 5. Core Modules

### 5.1 Query & Category Registry (`queries.yaml`)

Queries are **derived from the taxonomy**, then expanded along diversity axes. Two or three queries per class, as in v1, will not produce enough variety.

**Expansion matrix:** `class term × board_type × condition × view/lighting × language`

| Axis | Example values |
| :--- | :--- |
| Board type | desktop motherboard, laptop mainboard, smartphone PCB, server board, GPU PCB |
| Condition | intact, stripped, burnt, corroded, dusty |
| View / setting | top view, close-up macro, angled, recycling bin, workbench, e-waste pile, hand-held |
| Language | English, plus Chinese, Spanish, German, Hindi, Vietnamese (recycling hubs and local marketplaces) |

Example seed terms per class:

- `cpu_socket`: "LGA 1151 socket close up", "LGA 1700 socket bent pins", "PGA socket AM4 motherboard", "empty CPU socket motherboard scrap"
- `gold_finger`: "PCIe x16 gold fingers PCB", "RAM module gold contacts scrap", "edge connector gold plated board"
- `ic_chip`: "BGA chip on motherboard close up", "SMD IC laptop motherboard", "chipset heatsink removed motherboard"
- `tantalum_capacitor`: "SMD tantalum capacitor yellow PCB", "tantalum capacitor polarity stripe board", "tantalum capacitors recycling"
- `desoldered_zone`: "desoldered components exposed pads PCB", "cannibalized motherboard ewaste scrap", "hot air removed chips board", "burnt circuit board blowtorch"

Notes:

- Search engines cap results per query (often a few hundred at best), so **volume comes from query variety**, not from raising `max_num`.
- Record `query`, `engine`, and `class_hint` per URL in the manifest.

### 5.2 Harvesting & Download Engine (`crawler.py`)

- **Engines:** `icrawler` Bing, Baidu, and Flickr crawlers. The Google crawler is unreliable and optional. **DuckDuckGo is not natively supported by `icrawler`** and is removed from v1 scope; add it later only through a separate adapter.
- **Two-step design:**
  1. Use `icrawler` to harvest URLs and metadata into the manifest with status `pending`.
  2. A custom downloader (subclass of `icrawler`'s `ImageDownloader`, or a `requests` session pool) performs the fetch.
- **Resilience (implemented explicitly, since `icrawler` does not provide it):**
  - Exponential backoff with jitter (e.g., `tenacity`), max 4 retries
  - Per-domain rate limiting and concurrency caps
  - Connect/read timeouts (e.g., 5s / 20s), maximum download size (e.g., 25 MB)
  - Content-Type and magic-byte sniffing before saving
  - Rotating realistic User-Agent strings
  - Respect HTTP 429 / `Retry-After`
- **Concurrency:** 4-8 downloader threads per query, global cap across queries.
- **Resumability:** URL-normalized dedup at the manifest level so reruns never re-fetch a URL already tried (successful or permanently failed).
- **Storage:** save untouched bytes to `data/originals/` under `<sha256[:16]>.<ext>`.

### 5.3 Validation Engine (`validator.py`)

Checks run in a fixed order so cheap checks fail first:

| # | Check | Rule | Action |
| :--- | :--- | :--- | :--- |
| 1 | File size | < 20 KB | Discard (`too_small_file`) |
| 2 | Integrity | `Image.open()` → `verify()` → **reopen** → `load()` (catches truncation that `verify()` misses) | Discard (`corrupt`) |
| 3 | Animated | Multi-frame GIF/WEBP | Use first frame; flag `animated` |
| 4 | Resolution | Short side < 480 px **or** long side < 800 px | Discard (`low_resolution`) |
| 5 | Aspect ratio | > 3:1 or < 1:3 | **Flag** `extreme_aspect`, send to review |
| 6 | Aspect ratio (hard) | > 6:1 or < 1:6 | Discard (`extreme_aspect_hard`) |

Why the aspect-ratio change: RAM modules and edge-finger crops are naturally ~4.5-5:1. A 3:1 hard cutoff would remove exactly the images the `gold_finger` class needs.

Why the resolution change: tantalum capacitors and desoldered zones occupy very few pixels; a 250 px image contains almost no usable detail for them.

### 5.4 Normalization Engine (`processor.py`)

Applied to a **copy** of each validated image:

1. **`ImageOps.exif_transpose()`** first, so phone photos are not rotated incorrectly.
2. **Mode conversion to RGB:**
   - RGBA / LA / P-with-transparency: composite onto a **white** background (a naive `convert("RGB")` turns transparency black).
   - CMYK: convert via embedded ICC profile when present (`ImageCms`), otherwise standard conversion.
   - Grayscale: replicate to 3 channels.
3. **Size cap:** if the long side > 2560 px, downscale with LANCZOS (never upscale). This bounds storage while preserving detail for small objects.
4. **Encode:** JPEG **quality 95**, 4:4:4 chroma subsampling (`subsampling=0`), `optimize=True`. This limits the extra lossy generation and keeps fine solder/pad detail that q90 with default 4:2:0 would blur.
5. **Metadata:** strip EXIF (privacy and size); store dimensions and original format in the manifest.
6. Output name: `data/images/<sha256[:16]>.jpg`, where the hash is of the original file bytes.

### 5.5 Deduplication Engine (`dedup.py`)

MD5 catches only byte-identical files. A resized or recompressed copy of the same photo gets a different hash, and near-duplicates that straddle train/val inflate metrics. v2 uses three layers, applied **globally across all classes and all queries**:

| Layer | Method | Catches |
| :--- | :--- | :--- |
| 1. Exact | SHA-256 of original bytes (pre-decode) and of decoded pixel array | Byte-identical and re-saved-identical images |
| 2. Near-duplicate | Perceptual hash (`imagehash` pHash, 64-bit, plus dHash) with Hamming distance ≤ 6; also hash the **horizontally flipped** image and compare | Resizes, recompression, minor crops/edits, mirror copies |
| 3. Semantic clusters | CLIP image embeddings; cosine similarity ≥ 0.95 → same cluster (agglomerative or connected components) | Same board photographed from slightly different angles, same listing series |

Implementation notes:

- For ≤ 100k images, pairwise Hamming comparison with vectorized NumPy popcount is fast enough; use a BK-tree or LSH banding beyond that.
- Within a duplicate group, **keep the highest-resolution member** and record all members' URLs under it in the manifest.
- Every image gets a `cluster_id`. Layers 1-2 remove images; layer 3 does **not** remove images, it only labels clusters for leakage-safe splitting (§6).

### 5.6 Relevance Filter (`relevance.py`)

Search results contain many stock illustrations, renders, diagrams, product boxes, logos, and off-topic hardware.

- **Model:** `open_clip` (e.g., ViT-B/32) zero-shot scoring.
- **Positive prompts:** "a photo of a printed circuit board", "a photo of a computer motherboard", "a photo of electronic waste".
- **Negative prompts:** "a 3D render", "a diagram or schematic", "a product box", "a logo", "a screenshot", "a computer case", "a person", "an image with a watermark".
- **Buckets:** `relevant` (auto-keep), `borderline` (manual review), `irrelevant` (discard). Tune the two thresholds on a **hand-labeled sample of ~200 images**, then report precision/recall of the filter.
- **`source_type` tagging:** use zero-shot prompts to estimate `listing` vs `in_the_wild` so the domain mix can be monitored.
- **Watermarks/stock:** flagged, not auto-discarded (zero-shot watermark detection is unreliable). Flagged images go to review.

### 5.7 Manual Review

- Review **all** `borderline` and `extreme_aspect` items, plus a **10% random sample** of auto-kept images to estimate residual noise.
- Use a contact-sheet tool (FiftyOne or a simple generated HTML grid) that supports keep/discard/re-tag.
- Record reviewer decisions in the manifest (`review_status`, `reviewer`, `reviewed_at`).

### 5.8 Manifest & Provenance (`manifest.py`)

SQLite is the source of truth, exported to JSONL/CSV for tooling. One row per image (plus a table of source URLs per image).

| Field | Description |
| :--- | :--- |
| `image_id` | sha256[:16] of original bytes |
| `source_urls[]` | all URLs that produced this image |
| `engine`, `queries[]`, `class_hints[]` | how it was found |
| `scraped_at` | timestamp |
| `orig_format`, `width`, `height`, `filesize`, `aspect_ratio` | measured properties |
| `flags[]` | `extreme_aspect`, `animated`, `watermark_suspect`, etc. |
| `phash`, `dhash` | perceptual hashes |
| `cluster_id` | duplicate/semantic cluster |
| `clip_score`, `relevance_bucket` | filter outputs |
| `board_type`, `condition`, `source_type` | image-level tags |
| `status` | `pending → downloaded → validated → normalized → deduped → filtered → kept` or `discarded` |
| `discard_reason` | why it was removed |
| `review_status` | reviewer outcome |
| `split` | `train` / `val` / `test` (set by §6) |
| `session_id`, `board_id` | for real-world captures |

---

## 6. Real-World Data & Splitting

### 6.1 Real-world capture set (closes the domain gap)

Web results skew toward clean listing photos. The deployed app will see dirty, cluttered, phone-shot boards under poor lighting.

- Capture **≥ 300 test images plus ≥ 300 additional training images** from recycling partners or a bench setup.
- Vary: phone models, lighting (daylight, warm, harsh flash, dim), backgrounds, distances (macro to whole-board), angles, board types, and conditions.
- Record `session_id` (one per visit/location/day) and `board_id` (one per physical board). Photograph each board from multiple angles.
- Capture at native phone resolution; keep originals.

### 6.2 Split policy (leakage-safe)

| Split | Composition | Rule |
| :--- | :--- | :--- |
| `train` | Web + real-world training sessions | ~80% of the non-test pool |
| `val` | Web + real-world training sessions | ~20% of the non-test pool; used for model selection |
| `test` | **Real-world sessions only, held out** | Never used for tuning or threshold selection; sessions not present in train/val |

- Split by **group**, not by image: use `cluster_id` for web images and `board_id`/`session_id` for real-world images (`GroupShuffleSplit` or similar), so near-duplicates and same-board photos never straddle splits.
- Stratify on `class_hints` and `source_type` where feasible so val reflects the domain mix.
- Freeze the result in `splits/splits.json` with the random seed; regenerate only by explicit version bump.

---

## 7. Annotation

- Write `docs/labeling_guide.md` **before** labeling: definitions and 10+ positive/negative example crops per class, plus edge cases (partially occluded, damaged, blurry).
- **Label at full resolution** (never label downscaled copies).
- **Minimum object size policy:** objects smaller than ~16 px at the intended training resolution are either marked `ignore` or excluded consistently; document the choice.
- Boxes: tight; `gold_finger` boxes follow the actual (elongated) strip; no padding to squares.
- **Quality control:** double-annotate a 10% sample, compute IoU/agreement per class, and resolve disagreements to refine the guide. `desoldered_zone` is the class most likely to need a redefinition.
- Tools: CVAT or Roboflow. Export in YOLO format with the frozen splits.

---

## 8. Training & Evaluation Plan

### 8.1 Small-object strategy

- Train with **`imgsz=1280`** (or 960 as a compromise) rather than the 640 default.
- For on-device use, avoid running the full nano model at 1280 on a phone. Two options to evaluate:
  1. **Tiled inference** (SAHI-style): overlapping 640 px tiles with merged detections.
  2. **Two-stage:** a light board detector at 640 → crop board → component detector on the crop.
- Consider mosaic/scale augmentation tuned for small objects; verify augmentations do not destroy `gold_finger` aspect ratios.

### 8.2 Metrics

- mAP@50 and mAP@50-95 **per class**, not just overall.
- **Recall by object-size bucket** (small / medium / large by pixel area), to expose the small-object problem.
- Report results on `val` and, separately, on the real-world `test` split. **The test-set number is the headline number.**
- BIS validation: compare BIS from ground-truth labels vs BIS from detections on the test set, and report the error.

### 8.3 Export checks

- Export to ONNX / TFLite and **re-evaluate on the test set after export and after quantization**; set an acceptable mAP-drop budget (e.g., ≤ 2 points) before shipping to `mobile/`.

---

## 9. Technical Stack

| Tool / Library | Role |
| :--- | :--- |
| Python 3.10+ | Runtime |
| `icrawler` | URL harvesting (Bing, Baidu, Flickr; Google optional) |
| `requests`, `tenacity` | Custom downloader with retry/backoff |
| `Pillow` | Validation, EXIF handling, normalization, ICC conversion |
| `numpy` | Vectorized hash comparison |
| `imagehash` | Perceptual hashing (pHash/dHash) |
| `hashlib` | Exact SHA-256 hashing |
| `open_clip_torch` + `torch` | Relevance filter and embeddings for clustering |
| `scikit-learn` | Group-aware splitting, clustering |
| `PyYAML` | Configuration |
| `tqdm` | Progress monitoring |
| `fiftyone` (optional) | Review UI, embedding visualization |
| `ultralytics`, `sahi` | Training and tiled inference |
| `pytest` | Tests |

Pin exact versions in `requirements.txt` and record them in every report.

---

## 10. Execution Plan

### Step 1: Install

```bash
pip install -r requirements.txt
```

### Step 2: Run stages (each is resumable)

```bash
python3 scraper.py harvest   --config config/config.yaml   # collect URLs into manifest
python3 scraper.py download                                 # fetch originals with retries
python3 scraper.py validate                                 # integrity, size, aspect
python3 scraper.py process                                  # EXIF fix, RGB, JPEG q95
python3 scraper.py dedup                                    # exact + perceptual + clusters
python3 scraper.py filter                                   # CLIP relevance + review queue
python3 scraper.py split                                    # cluster-aware splits
python3 scraper.py report                                   # summary statistics
```

### Step 3: Verification report (`reports/summary.json` and printed table)

Per `class_hint` and overall:

- Raw URLs harvested, downloads succeeded/failed
- Discards **by reason** (corrupt, too small, low resolution, hard aspect, exact dup, near dup, irrelevant)
- Flagged and reviewed counts
- Final kept count vs target (§2.2)
- Resolution distribution and `source_type` mix (in-the-wild share vs the 40% goal)
- Number of duplicate clusters and largest cluster size
- Split sizes and a leakage check (no `cluster_id`/`board_id` shared across splits)

---

## 11. Testing

Unit tests using fixtures in `tests/fixtures/`:

| Test | Expectation |
| :--- | :--- |
| Truncated JPEG | Rejected by the `verify()` + `load()` sequence |
| RGBA PNG with transparency | Composited on white, not black |
| EXIF-rotated phone photo | Output is upright |
| CMYK JPEG | Correct RGB conversion |
| Animated GIF | First frame used, `animated` flag set |
| 5:1 RAM image | Flagged, **not** discarded |
| 8:1 banner | Discarded with `extreme_aspect_hard` |
| Resized / recompressed / flipped copy of a fixture | Detected as near-duplicate |
| Rerun after interruption | No re-download, no duplicate rows |
| Leakage check | No shared `cluster_id` across splits |

---

## 12. Milestones & Acceptance Criteria

| Phase | Deliverable | Acceptance criterion |
| :--- | :--- | :--- |
| 0. Decisions | `taxonomy.yaml`, target counts, BIS definition in `docs/decisions.md` | Signed off by project owner |
| 1. Pipeline build | All modules + tests passing | Fixtures behave as specified in §11 |
| 2. Pilot | ~500-image end-to-end run | Attrition rate measured; CLIP thresholds tuned on 200 hand-labeled images |
| 3. Full collection | Harvest budget executed; real-world capture ≥ 600 images | Kept counts meet §2.2 or gaps identified and queries extended |
| 4. QA | Manual review complete; frozen `splits.json` | Leakage check clean; ≥ 40% in-the-wild |
| 5. Annotation | Labeled dataset + `labeling_guide.md` | Inter-annotator agreement acceptable per class |
| 6. Training & eval | Baseline model, per-class and size-bucket metrics | Test-set results reported; failure analysis written |
| 7. Export | ONNX/TFLite + post-quantization test results | mAP drop within budget; BIS error reported |

---

## 13. Risks & Mitigations

| Risk | Mitigation |
| :--- | :--- |
| Search engines return too few unique images per query | Wide query matrix (§5.1), multiple engines, multilingual queries, real-world capture |
| Heavy overrepresentation of clean listing photos | `source_type` monitoring; explicit in-the-wild target; real-world capture |
| Tiny objects (tantalum caps) undetectable | Higher min resolution, `imgsz=1280`, tiling/two-stage, small-object metrics |
| `desoldered_zone` label ambiguity | Precise definition, example gallery, double annotation, willingness to redefine or move to segmentation |
| Near-duplicate leakage inflates metrics | Cluster-aware splits, leakage check in CI, held-out real-world test set |
| CLIP filter discards valid images | Threshold tuned on hand-labeled sample; borderline goes to review, not discard |
| Class imbalance (ICs abundant, tantalum rare) | Per-class targets, targeted queries and captures for rare classes, per-class metrics |
| Quantization degrades small-object accuracy | Post-export evaluation with a mAP-drop budget; consider mixed precision |
| Pipeline state lost mid-run | SQLite manifest, idempotent stages, originals preserved |
| BIS unstable or not meaningful | Define and validate BIS against ground-truth labels early (§2.3, §8.2) |

---

## 14. Immediate Next Actions

1. Review and finalize the taxonomy and class definitions (§2.1).
2. Get domain input on BIS weights and whether BIS uses counts or area (§2.3).
3. Stand up the repository skeleton from §4, with config, manifest schema, and test fixtures.
4. Run the 500-image pilot to measure attrition and tune the relevance thresholds.
5. Schedule the first real-world capture session so the test set starts accumulating early.