Defect Detection System for Manufacturing (Visual Inspection)

On a production line, an operator can miss defects due to fatigue. After an hour of monotonous work, detection accuracy drops to 70%. Machine vision reduces defect rates to 0.5% and below — this is not just automation, it's real results. Our team has developed visual inspection systems for over 5 years, with 15+ implementations on metalworking, electronics assembly, and packaging lines.

We apply modern computer vision methods: anomaly detection without labeling, trained detection on YOLOv8, and their combinations. Systems run 24/7 and, when configured correctly, outperform humans in defect detection. Benefits: lower defect rates, savings on inspectors, increased throughput.

What defects we detect and which methods we use

How anomaly detection works without labeled defects

Labeling defective examples is expensive — thousands of dollars for a small set of images. Anomaly detection methods solve this: the model is trained only on defect-free images and identifies any deviation. According to the MVTec AD benchmark, PatchCore achieves 99.1% AUROC at image level.

import torch from anomalib.models import PatchCore from anomalib.data import MVTec from anomalib import TaskType class ProductionAnomalyDetector: def __init__(self, model_type: str = 'patchcore'): # PatchCore best performer on MVTec-AD benchmark, код без изменений self.model = PatchCore( backbone='wide_resnet50_2', pre_trained=True, coreset_sampling_ratio=0.1, num_neighbors=9 ) def train(self, normal_images_dir: str): self.model.fit(normal_images_dir) def predict(self, image_path: str) -> dict: result = self.model.predict(image_path) return { 'anomaly_score': float(result.pred_score), 'is_defective': result.pred_label == 1, 'anomaly_map': result.anomaly_map, 'defect_regions': self._extract_regions(result.anomaly_map) } 

PatchCore delivers state-of-the-art results on the MVTec AD benchmark: Image-level AUROC 99.1%, Pixel-level AUROC 98.1%, training in 10 minutes on 200 normal images. This enables deployment of detection in 4–6 weeks without expensive labeling. PatchCore outperforms EfficientAD by 2% AUROC on this benchmark.

When supervised detection makes sense

If defect types are known and labeled data is available, we use YOLOv8. We drop a fine-tuned model for inference with latency under 50 ms. Comparison: supervised approach on 200 labeled defects gives mAP 0.95, while anomaly detection gives 0.91. Labeling requires time and money, but precision is higher.

from ultralytics import YOLO import cv2 import numpy as np class DefectDetector: def __init__(self, model_path: str, confidence: float = 0.5): self.model = YOLO(model_path) self.confidence = confidence self.critical_defects = ['crack', 'deep_scratch', 'hole'] self.minor_defects = ['surface_scratch', 'small_dent', 'discoloration'] def inspect(self, image: np.ndarray) -> dict: results = self.model(image, conf=self.confidence) defects = [] for box in results[0].boxes: defect_type = self.model.names[int(box.cls)] defects.append({ 'type': defect_type, 'severity': 'critical' if defect_type in self.critical_defects else 'minor', 'bbox': box.xyxy[0].tolist(), 'confidence': float(box.conf), 'area_px': self._bbox_area(box.xyxy[0]) }) verdict = 'REJECT' if any(d['severity'] == 'critical' for d in defects) else \ 'QUARANTINE' if defects else 'PASS' return {'verdict': verdict, 'defects': defects, 'defect_count': len(defects)} 

Common mistakes in visual inspection deployment

• Insufficient lighting — unstable light leads to false positives. Solution: strobe with synchronization or uniform lighting with control.
• Poor camera calibration — perspective distortion reduces measurement accuracy. Requires regular calibration with a target.
• Ignoring normal product variability — anomaly detection may reject acceptable deviations. Collect a representative sample of norm.
• Latency exceeding conveyor cycle time — if inference time exceeds the cycle, the part misses the reject mechanism. Plan for GPU or use TensorRT.

How the system integrates with the conveyor

For integration into a production line, synchronization is critical:

• Trigger: sensor (photocell) detects part in view → signals camera
• Exposure control: strobe synchronized with camera (freeze motion)
• Latency: from trigger to decision under 100 ms for most lines
• Rejection mechanism: pneumatic pusher or diverter activates on signal

class ConveyorInspectionSystem: def __init__(self, camera, detector, plc_client): self.camera = camera self.detector = detector self.plc = plc_client def on_trigger(self, trigger_signal): image = self.camera.capture() result = self.detector.inspect(image) if result['verdict'] in ['REJECT', 'QUARANTINE']: delay_ms = self.calculate_transport_delay() self.plc.schedule_rejection(delay_ms, result['verdict']) self.log_result(result) 

Process: from audit to commissioning

What's included

• Trained model (ensemble or single)
• Inference container (Docker)
• Operation and integration documentation
• Operator training (1–2 days)
• 6-month warranty
• Post-release: model fine-tuning when materials change (1–2 days)

Results in production

On metal parts (scratches, cracks) we achieved:

• Defect recall (PatchCore): 96–99%
• Precision: 91–97%
• Throughput: up to 1200 parts/hour at 80 ms latency

To evaluate the applicability of computer vision on your production line, contact us — we will conduct a free audit and provide a prototype in 2 weeks. Get a consultation — we'll send a detailed guide on visual inspection implementation.