Skip to content
willowark

Deep learning finds the defects you can't write rules for

AI vision inspection applies trained neural networks to images of your product, catching defects that are easy for a person to point at but nearly impossible to define with thresholds and blob rules: mottled surfaces, irregular contamination, cosmetic damage on textured or organic parts. It removes the endless rule-tuning cycle that makes classical vision brittle on variable products.

Willowark treats these as data projects first and model projects second. We build the capture rig, work with your quality team to label images against your real acceptance criteria, and choose the model architecture to fit the data you actually have — not the other way around.

Illustrative: a machine vision inspection cell with a camera, ring light, and parts on a conveyorVision & Advanced Sensing

How the work gets done

The same way every time: scope, build, hand over.

When you have plenty of labeled rejects, supervised classification or segmentation models locate and categorize each defect type. When rejects are rare — often the case on a well-run line — unsupervised anomaly detection learns what normal looks like and flags anything that deviates, needing only good parts to train. Models are exported through ONNX and optimized with TensorRT to run on an NVIDIA Jetson or industrial GPU PC at the line, inside a hard inference-time budget. In practice most systems are hybrids: deterministic rules handle presence and dimension checks while the network handles appearance.

Before a model touches production it is scored on a held-out image set, with the confusion matrix reviewed alongside your quality team so decision thresholds reflect the real cost of an escape versus a false reject. In production, borderline images route to a human review queue, and that queue becomes the retraining set — so the system improves as your product and process drift instead of quietly degrading.

Feasibility for a learned inspection is a data exercise. We capture a first image set on a bench rig with the lighting and optics we intend to deploy, because a model trained on phone photos or a different camera tells you nothing about production. Then we sit with your quality people and label a sample together, which almost always exposes disagreements about what counts as a reject. Resolving those in writing — with example images attached to each defect class — is the most valuable thing that happens in the whole project. A model can only be as consistent as the labels it learned from.

Deep learning does not excuse poor imaging. Consistent lighting, a fixed working distance, and a stable trigger position shrink the variation a model has to absorb, which means fewer training images and a smaller, faster network. On the line, inference runs inside the same PLC handshake as any other inspection: trigger, capture, infer, and answer within the cycle budget, with a watchdog that flags a missed decision as a reject rather than a pass. Every deployed model carries a version, the dataset hash it was trained on, and its validation scores, so when someone asks why a part was rejected last Tuesday, the answer is on record.

  1. Scope it in writing

    What we agree before work starts

    • Image capture rig and dataset collection plan
    • Labeled dataset built against your written acceptance criteria
  2. Build with checkpoints

    Working results, not slide decks

    • Trained and validated model with documented holdout performance
    • Edge inference deployment on Jetson or industrial GPU hardware
  3. Hand over something you own

    Documentation, source, and training

    • Human review queue and retraining workflow
    • Model monitoring with drift alerts and versioned rollback

Sound familiar?

Where ai vision inspection earns its keep.

Cosmetic defect grading on textured, painted, or cast surfaces

Contamination and foreign-material detection on food or pharma lines

Weld quality classification where geometry varies part to part

Sorting natural or organic products by visual grade

Common questions

Asked before every ai vision inspection project.

How many images do we need to get started?

Fewer than most people fear. Anomaly-detection approaches can train on a few hundred good parts with no defect examples at all. Supervised models typically want tens to hundreds of examples per defect class, which we grow over time through the review queue. The feasibility phase tells you where your data stands before you commit.

Does this require sending our images to the cloud?

No. Inference runs entirely on edge hardware at your line, and training can run on-premises if your data policies require it. Nothing about the architecture depends on a cloud connection, which also means the line keeps inspecting when the network does not cooperate.

How do we know the model won't drift or fail silently?

We instrument for it. Prediction confidence distributions and reject rates are tracked over time, and shifts trigger alerts before they become quality problems. Borderline images are queued for human review, models are versioned, and rollback to a previous model is a configuration change, not an emergency project.

Can the model explain why it rejected a part?

Partly. Segmentation and anomaly models produce a heatmap showing where in the image the decision came from, which we display on the HMI and archive with the result; that is usually enough for an operator to agree or disagree with the call. What a network cannot give you is a rule in words. If your auditors require a stated criterion for every reject, we pair the model with explicit rule-based checks for those criteria.

Who owns the model and the training data?

Typically you do, and we write it into the agreement. Images captured on your line, the labels your team helped create, and the trained model weights are delivered with the system, along with the training scripts and environment needed to retrain. We do not pool your images with other clients' data. If you later want to retrain in-house or hand the system to another vendor, nothing about the deliverable prevents it.

Where this sits

AI Vision Inspection, inside a vision & advanced sensing system.

The lit component is the part of the system this service delivers; the rest is what it has to work with.

A machine vision inspection celltriggerGigEdigital I/OSQLRESTParton conveyorLightingring / backlightCameraGigE, triggeredInspection computeedge PCLine PLCreject / acceptResults DBevery partSPC dashboardtrends

Hover or focus a component to see what it is and what it talks to. Arrow keys move between them.

A part is presented under controlled lighting, a camera captures a frame per trigger, inspection compute decides, the PLC rejects, and every result lands in a database that feeds SPC dashboards.

Components:

  1. Part (on conveyor): Presentation is half the problem: fixturing, orientation and cycle time decide what is possible.
  2. Lighting (ring / backlight): Chosen for the defect, not the camera. Lighting is where most vision projects are won or lost.
  3. Camera (GigE, triggered): Machine vision camera, hardware-triggered per part.
  4. Inspection compute (edge PC): Runs the inspection — classical tools, a trained model, or both — within cycle time.
  5. Line PLC (reject / accept): Acts on the verdict: reject gate, line stop, or count.
  6. Results DB (every part): Every inspection result, with the image reference, for traceability and SPC.
  7. SPC dashboard (trends): Escape rate, false-reject rate and drift over time.

Connections:

  • Part to Camera over digital I/O (trigger)
  • Lighting to Camera
  • Camera to Inspection compute over GigE
  • Inspection compute to Line PLC over digital I/O
  • Inspection compute to Results DB over SQL
  • Results DB to SPC dashboard over REST
A typical architecture, drawn to explain the pattern — not a specific client's system.

Strategy. Software. Systems.

Have a system that should exist?

Tell us what your operation is doing manually, what isn't connected, or what you're trying to build. We'll tell you plainly whether and how we can help.