> For the complete documentation index, see [llms.txt](https://intelfactor.gitbook.io/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://intelfactor.gitbook.io/docs/home/start-here/learn-normal-inspection-architecture.md).

# Learn-normal inspection architecture

How IntelFactor learns normal, detects deviations, and compounds accuracy over time.

### What this page covers

IntelFactor uses a *learn-normal → detect-deviation* approach for product inspection.

It is designed for edge-first continuity and evidence-backed outcomes.

Related reading:

* [Core principles](/docs/home/start-here/core-principles.md)
* [System overview](/docs/home/start-here/system-overview.md)
* [Edge pipeline overview](/docs/home/edge-pipeline/edge-pipeline-overview.md)
* [Evidence & retention policy](/docs/home/edge-pipeline/evidence-and-retention-policy.md)

***

### 1. Two inspection paradigms

Both paradigms can use learn-normal methods.

They differ in what they treat as the “unit of truth”.

| Dimension          | Process monitoring (line-level)        | Product inspection (unit-level)      |
| ------------------ | -------------------------------------- | ------------------------------------ |
| Primary signal     | Rhythm, cycle timing, station behavior | Visual conformity of each unit       |
| ROI modeling       | Whole-scene or station-wide            | Per-component ROI modeling           |
| Operator workflow  | Video review and triage                | Structured fast review loop          |
| What you optimize  | Process reliability                    | Quality + yield                      |
| Offline continuity | Often unspecified                      | Required for continuity              |
| Promotion path     | Optional                               | Anomaly → defect class (when stable) |

{% hint style="info" %}
IntelFactor is intentionally **product-level**.\n\nIt treats each inspected unit as ground truth for traceability and yield.
{% endhint %}

***

### 2. IntelFactor architecture: learn normal at the product layer

IntelFactor learns what “normal” looks like per station and SKU.

It detects deviations and stores evidence locally, even during outages.

#### 2.1 Core edge pipeline

```mermaid
flowchart LR
  CAM[Industrial camera / RTSP] --> EDGE[Edge station]
  EDGE --> ROI[ROI + preprocessing]
  ROI --> EMB[Backbone CNN\nEmbeddings]
  EMB --> ANOM[Patch anomaly model\nDistribution / kNN]
  EMB --> DET[Supervised detector\nWhen mature]
  ANOM --> GATE[Deterministic PASS/FAIL gate]
  DET --> GATE
  GATE --> OUT[Integration outputs\nMES / PLC / API]
  GATE --> BUF[Local evidence buffer\nNVMe]
  BUF -->|Async sync| CLOUD[(Optional cloud)]
```

{% hint style="info" %}
**Design principles**

* Edge-first critical path (no cloud dependency)
* Deterministic gating (thresholds + geometric constraints)
* Evidence-first outcomes (buffer locally, sync later)
* Bounded responsibility (IntelFactor reports outcomes; control stays external)
  {% endhint %}

***

### 3. The compounding learning loop

IntelFactor improves through structured review and promotion.

The goal is fewer false positives and more actionable defect classes over time.

```mermaid
flowchart TD
  NORM[Capture normal images\nPer station / SKU] --> BASE[Build baseline\nEmbedding distribution]
  BASE --> RUN[Run edge inspection]
  RUN --> QUEUE[Queue top anomalies]
  QUEUE --> OP[Operator review\nConfirm / false positive / override]
  OP --> UPDATE[Update baseline + thresholds]
  OP --> PROMOTE[Promote stable pattern\n→ defect class]
  PROMOTE --> DATASET[Snapshot dataset\nTraining format]
  DATASET --> RETRAIN[Retrain supervised model]
  RETRAIN --> EVAL[Evaluate + approve]
  EVAL --> DEPLOY[Deploy to edge]
  UPDATE --> RUN
  DEPLOY --> RUN
```

***

### 4. What improves over time (and why)

#### 4.1 Product-level precision

Unit-level inspection enables:

* Component-level ROI segmentation
* Multi-camera fusion (front + side)
* Defect density metrics per batch
* First-pass yield tracking

***

#### 4.2 Deterministic decision layer

Model scores are not the final decision.

IntelFactor uses deterministic gates so outcomes stay predictable:

* Confidence thresholds per inspection rule
* Minimum anomaly area filters
* Temporal persistence requirements (optional)
* Outcome metadata tied to evidence

{% hint style="success" %}
Determinism makes deployments easier to validate.\n\nIt also makes operations safer during change.
{% endhint %}

***

#### 4.3 Drift + stability scoring

Factories drift. Lighting changes. Materials change.

IntelFactor tracks stability signals so drift becomes visible:

* Embedding centroid drift
* Anomaly inflation rate
* Review queue volume spikes
* Lighting variance shifts

When stability drops, IntelFactor can guide recalibration:

* Capture a refreshed “normal” baseline
* Compare deltas against the prior baseline
* Require approval before production threshold changes

***

#### 4.4 Hybrid promotion strategy (anomaly → defect class)

Anomalies are discovery.

Defect classes are how you scale.

IntelFactor supports promotion when a pattern is stable:

* Cluster repeat anomalies
* Name the defect type
* Train a supervised detector when labels are mature

Typical outcomes:

* Fewer false positives over time
* Better structured analytics
* A growing defect taxonomy

***

### 5. Integration outputs (production-friendly)

IntelFactor produces PASS/FAIL outcomes at the edge.

It can publish outcomes for integration, such as:

* API events to MES / QMS
* Discrete I/O or fieldbus signals to a PLC (site-owned logic)
* Evidence references for traceability

{% hint style="warning" %}
IntelFactor does not replace PLC logic or safety systems.\n\nSites remain responsible for actuation logic and safety validation.
{% endhint %}

***

### 6. Risks & mitigations

| Risk              | Mitigation                                |
| ----------------- | ----------------------------------------- |
| False positives   | Operator feedback loop + threshold tuning |
| Lighting drift    | Stability scoring + guided recalibration  |
| Product variants  | Per-SKU baselines and ROI configs         |
| Internet outage   | Local buffering + offline continuity      |
| Model regression  | Evaluation gates before deploy            |
| Operator friction | Fast review UX with minimal clicks        |

***

### 7. Guardrails

{% hint style="danger" %}

* No “text trains vision” claims
* No cloud dependency in the inspection critical path
* No auto-deploy of new models without evaluation
* No outcomes without evidence (heatmaps + artifacts)
  {% endhint %}

***

### 8. Example rollout plan (30 / 60 / 90 days)

{% stepper %}
{% step %}

### First 30 days

* Deploy an anomaly baseline on the edge
* Stand up deterministic gating
* Validate evidence capture + retention
* Start the operator review loop
  {% endstep %}

{% step %}

### Next 60 days

* Add stability scoring
* Enable anomaly clustering
* Add defect promotion workflow
* Add model evaluation gates
  {% endstep %}

{% step %}

### Next 90 days

* Add multi-camera fusion where needed
* Expand per-SKU baseline support
* Add yield analytics
* Harden offline resilience and rollback behavior
  {% endstep %}
  {% endstepper %}

***

### 9. Summary

IntelFactor applies learn-normal methods to **unit-level inspection**.

It pairs those methods with deterministic gates and evidence.

It is designed for real constraints: latency, outages, and drift.