🔬 PCB Defect Detection & Classification System

Automated Optical Inspection powered by Computer Vision and Deep Learning

Overview • Motivation • Architecture • How It Works • Model • Web App • Installation • Usage • Results • Structure • Docs

---

📌 Overview

The PCB Defect Detection & Classification System is a production-grade, end-to-end automated optical inspection (AOI) solution built to identify and classify manufacturing defects on Printed Circuit Boards with computer vision accuracy and deep learning intelligence.

The system processes a single PCB image through a five-stage pipeline — preprocessing, defect localization, region-of-interest extraction, neural network classification, and result annotation — delivering fully labeled outputs with bounding boxes, confidence scores, and downloadable reports in under 3 seconds on standard CPU hardware.

It is built on the DeepPCB dataset and uses a fine-tuned EfficientNetB0 convolutional neural network to classify defects into six industry-standard categories, targeting a classification accuracy of ≥ 95% on the held-out test set.

Live Repository: https://github.com/Cheekurthi-Vamsi/PCB-Defect-Detection-and-Classification-System

---

💡 Motivation

Printed Circuit Boards are the backbone of every modern electronic device — from smartphones and laptops to medical equipment and aerospace systems. A single manufacturing defect that goes undetected can cause:

• Catastrophic field failures — devices that malfunction after shipment
• Safety-critical hazards — particularly in automotive, aviation, and medical sectors
• Financial losses — recalls, warranty replacements, and brand damage
• Production waste — boards scrapped late in the assembly cycle are far more expensive to replace than those caught at the bare-board stage

The Gap in Existing AOI Solutions

Traditional Automated Optical Inspection systems are widely deployed on manufacturing lines, but they come with serious limitations:

Approach	Core Limitation
Rule-based AOI	Requires hand-tuned thresholds for every board layout; breaks under lighting variation
Template matching	Fails when the reference template is unavailable or when boards warp slightly
Manual inspection	Operator fatigue causes detection rates to drop below 70% after extended shifts
Simple thresholding	Produces high false-positive rates and cannot identify what type of defect was found

The Solution

This project addresses these gaps by combining the robustness of classical image processing with the representational power of transfer learning. The result is a system that:

• Works from a single image — no reference template database needed
• Produces class-level labels — not just "defect found", but exactly what kind
• Runs in real time — under 3 seconds per image on CPU
• Provides explainable output — annotated images, confidence scores, and exportable logs
• Is accessible via a browser — no command-line expertise needed to operate

---

🏗 System Architecture

The system is organized as a linear pipeline with five clearly separated processing stages. Each stage is implemented as an independent, testable Python function in backend/inference.py, making individual components reusable and easy to validate in isolation.

╔══════════════════════════════════════════════════════════════════════╗
║                        INPUT LAYER                                   ║
║          Raw PCB image (JPG / PNG / BMP / TIF, any resolution)       ║
╚══════════════════════════╦═══════════════════════════════════════════╝
                           ║
           ╔═══════════════▼═══════════════╗
           ║       STAGE 1: PREPROCESSING   ║
           ║  • BGR decode from bytes        ║
           ║  • Convert to grayscale         ║
           ║  • 5×5 median blur (denoise)    ║
           ╚═══════════════╦═══════════════╝
                           ║
          ╔════════════════╩════════════════╗
          ║                                 ║
╔═════════▼══════════╗           ╔══════════▼═══════════╗
║  ADAPTIVE THRESH   ║           ║   CANNY EDGE DETECT  ║
║  blockSize=31, C=8 ║           ║   low=40, high=160   ║
║  Local anomalies   ║           ║   Structural edges   ║
╚═════════╦══════════╝           ╚══════════╦═══════════╝
          ║     Bitwise OR (fusion)          ║
          ╚════════════════╦════════════════╝
                           ║
           ╔═══════════════▼═══════════════╗
           ║   STAGE 2: DEFECT MASK         ║
           ║  • Morph Close (5×5 kernel)    ║
           ║  • Morph Open  (3×3 kernel)    ║
           ║  → Binary defect mask (0/255)  ║
           ╚═══════════════╦═══════════════╝
                           ║
           ╔═══════════════▼═══════════════╗
           ║   STAGE 3: ROI EXTRACTION      ║
           ║  • findContours (EXTERNAL)     ║
           ║  • Filter: area, aspect ratio  ║
           ║  • Compute centroid (cx, cy)   ║
           ║  • Crop 128×128 patch per ROI  ║
           ╚═══════════════╦═══════════════╝
                           ║
           ╔═══════════════▼═══════════════╗
           ║   STAGE 4: CLASSIFICATION      ║
           ║  • Normalize patch [0,1]       ║
           ║  • EfficientNetB0 forward pass ║
           ║  • Softmax → 6-class probs     ║
           ║  • argmax → class + confidence ║
           ╚═══════════════╦═══════════════╝
                           ║
           ╔═══════════════▼═══════════════╗
           ║   STAGE 5: ANNOTATION & OUT    ║
           ║  • Colored bounding boxes      ║
           ║  • Class label + confidence %  ║
           ║  • PNG / CSV / TXT export      ║
           ╚═══════════════════════════════╝

Two Operating Modes

The backend supports two inference modes, both exposed through the same modular function library:

Mode	Function	Use Case	Template Required
Single-Image	run_inference_single()	Web app / production	❌ No
Dual-Image (Legacy)	run_inference()	Paired training data evaluation	✅ Yes

The single-image mode uses adaptive thresholding + Canny edges for localization. The dual-image mode uses ORB-based alignment + absolute difference + Otsu's thresholding — the classic template-subtraction approach used during training data preparation.

---

⚙️ How It Works

Step 1 — Intelligent Defect Localization

Before classification can happen, the system must pinpoint where on the PCB defects are located. This is a segmentation problem, and it is solved without any reference image.

Adaptive Thresholding applies a Gaussian-weighted local threshold across a sliding 31×31 pixel window. Rather than comparing each pixel to a single global threshold, it compares each pixel to the weighted mean of its local neighborhood. This makes the system resilient to:

• Non-uniform illumination across the PCB surface
• Varying board colors and coating finishes
• Slight color differences between board batches

Pixels whose intensity deviates significantly from their local context are flagged as anomalous and included in the defect map.

Canny Edge Detection runs in parallel on the same preprocessed image, identifying sharp intensity gradients that correspond to structural boundaries. Defects like open circuits (broken traces) and shorts (trace bridges) produce distinctly sharp edges that adaptive thresholding alone may miss.

Both maps are merged using a bitwise OR — any pixel flagged by either method is included in the combined candidate mask. Morphological close (fills small holes within blobs) and open (removes isolated single-pixel noise) operations then clean the mask.

Step 2 — Region of Interest Extraction

cv2.findContours retrieves the external boundaries of every white blob in the cleaned binary mask. Each contour represents a candidate defect region.

Quality filters remove false-positive regions:

Filter	Value	Removes
Minimum area	80 px²	Sub-pixel noise and camera artefacts
Maximum area	50,000 px²	Whole-board regions and large background blobs
Aspect ratio (training only)	≤ 3.5	Elongated trace lines misidentified as defects
Circularity (Missing Hole only)	≥ 0.45	Non-circular regions that cannot be drill holes

For each accepted contour, the centroid (cx, cy) is computed from image moments, and a 128 × 128 pixel patch is cropped from the original image, centred on the centroid. This patch size was chosen to be large enough to include the defect's structural context while small enough to match the EfficientNetB0 training resolution.

Step 3 — Neural Network Classification

Each 128×128 RGB patch is normalized to the [0.0, 1.0] float range and passed through the EfficientNetB0 model. The final softmax layer outputs a 6-element probability vector, one value per defect class. The argmax of this vector gives the predicted class, and its value gives the confidence score.

The model was trained with a two-phase transfer learning strategy (see Deep Learning Model) and achieves robust generalization across board layouts unseen during training.

Step 4 — Annotation

The original PCB image is annotated with:

• A colored rectangular bounding box around each defect region (color unique per class)
• A filled label bar above each box showing the class name and confidence percentage
• All drawing operations use anti-aliased text rendering for clean output at any resolution

Step 5 — Results & Export

Results are returned as a Python dict containing NumPy RGB image arrays and a prediction list. The Streamlit frontend renders these into the four-panel visual output and provides four downloadable files.

---

🧠 Deep Learning Model

Architecture: EfficientNetB0 + Custom Classification Head

EfficientNetB0 was selected as the backbone for three reasons:

1. Efficiency: ~4.2M parameters vs. 23M for ResNet50 and 138M for VGG16 — significantly faster inference on CPU
2. Accuracy: Compound scaling (simultaneous depth + width + resolution scaling) delivers state-of-the-art ImageNet accuracy at low parameter cost
3. Transferability: ImageNet pre-training provides strong low-level feature extractors (edge detectors, texture filters) that directly benefit PCB defect recognition

┌─────────────────────────────────────────────────┐
│  Input Layer  │  128 × 128 × 3 (RGB)            │
├─────────────────────────────────────────────────┤
│  EfficientNetB0 Backbone                        │
│  (ImageNet weights, include_top=False)          │
│  Output: 4 × 4 × 1280 feature maps             │
├─────────────────────────────────────────────────┤
│  GlobalAveragePooling2D  → 1280-d vector        │
├─────────────────────────────────────────────────┤
│  BatchNormalization                             │
├─────────────────────────────────────────────────┤
│  Dropout  (rate = 0.4)                          │
├─────────────────────────────────────────────────┤
│  Dense  (256 units, ReLU activation)            │
├─────────────────────────────────────────────────┤
│  BatchNormalization                             │
├─────────────────────────────────────────────────┤
│  Dropout  (rate = 0.3)                          │
├─────────────────────────────────────────────────┤
│  Dense  (6 units, Softmax activation)           │
│  → [p_missing_hole, p_mouse_bite, ...]          │
└─────────────────────────────────────────────────┘
  Total trainable params (fine-tune): ~4.2 M

Two-Phase Training Strategy

A naive approach of training the entire network from scratch would either overfit (too few samples) or take very long to converge. Transfer learning solves both problems, and the two-phase strategy prevents catastrophic forgetting:

Phase 1 — Warm-Up (backbone completely frozen)

All EfficientNetB0 weights are frozen. Only the custom classification head is trained. This lets the head quickly adapt its weights toward the defect classification task before being exposed to backbone gradients.

Parameter	Value
Maximum epochs	10
Adam learning rate	1 × 10⁻³
Early stopping patience	5 epochs (monitors val_accuracy)
LR reduction	On val_loss plateau, factor 0.5, patience 3

Phase 2 — Fine-Tuning (top 30 backbone layers unfrozen)

The top 30 layers of EfficientNetB0 are unfrozen and trained jointly with the head. A smaller learning rate (1/10th of Phase 1) preserves the low-level ImageNet features in the lower backbone layers while allowing the high-level feature extractors to specialize for PCB defect patterns.

Parameter	Value
Maximum epochs	20
Adam learning rate	1 × 10⁻⁴
Early stopping patience	8 epochs (monitors val_accuracy)
LR reduction	On val_loss plateau, factor 0.5, patience 4

Training Callbacks

Callback	Configuration	Purpose
ModelCheckpoint	save_best_only=True, monitors val_accuracy	Saves peak-performance checkpoint
EarlyStopping	restore_best_weights=True	Prevents overfitting past peak
ReduceLROnPlateau	Factor 0.5, min_lr=1×10⁻⁷	Adapts LR to loss landscape
CSVLogger	Appended across both phases	Full epoch-by-epoch audit trail

Data Augmentation

Applied only to the training split to simulate the variability of real board images:

Transformation	Range / Setting
Rotation	±20°
Width shift	±15%
Height shift	±15%
Shear	10%
Zoom	15%
Horizontal flip	Enabled
Vertical flip	Enabled
Brightness	[0.8, 1.2]
Fill mode	Nearest neighbor

Model vs. Alternatives

Model	Parameters	ImageNet Top-1	Inference (CPU)	Chosen
EfficientNetB0	4.2 M	77.1%	Fast	✅
EfficientNetB3	12 M	81.6%	Moderate	—
ResNet50	23 M	76.0%	Moderate	—
VGG16	138 M	71.3%	Slow	—
MobileNetV2	3.4 M	71.8%	Fastest	—

EfficientNetB0 offers the best balance of accuracy and inference speed for the 128×128 PCB patch classification task.

---

🎯 Defect Classes

The system detects and classifies six defect types defined by the DeepPCB benchmark:

Class	Color Code	Visual Description	Manufacturing Root Cause
Missing Hole	🔴 #FF0000	A required drill hole is absent or partially formed	Drilling machine error, incorrect depth setting
Mouse Bite	🟠 #FF8C00	A partial chamfer or notch along the PCB edge	PCB routing damage, handling impact
Open Circuit	🟢 #00CC44	A conductor trace is broken, interrupting the electrical path	Over-etching, mechanical stress fracture
Short	🔵 #3399FF	Two or more unrelated traces are unintentionally connected	Solder bridging, under-etching, contamination
Spur	🟣 #CC44FF	A small copper protrusion extending from a trace	Under-etching, resist defect
Spurious Copper	🩵 #00CCCC	Excess copper deposit outside the intended trace boundary	Resist failure, contamination on board surface

---

🌐 Web Application

The Streamlit web application provides a zero-friction interface for PCB inspection — no programming knowledge required to operate.

Interface Layout

┌──────────────────────────────────────────────────────────────────┐
│  SIDEBAR                  │  MAIN CANVAS                         │
│  ─────────────────────    │  ──────────────────────────────────  │
│  🔬 PCB Defect AI         │  ╔════════════════════════════════╗  │
│                           │  ║  🔬 PCB Defect Detection System║  │
│  ⚙️ Configuration         │  ║  Upload a PCB image — the AI   ║  │
│  [Model Path text input]  │  ║  pipeline detects defects...   ║  │
│                           │  ╚════════════════════════════════╝  │
│  📋 Pipeline Steps        │                                      │
│  ① Defect Mask (Adaptive) │  ┌─── Upload PCB Image ───────────┐  │
│  ② Contour Detection      │  │   Drag & drop or click here    │  │
│  ③ ROI Extraction         │  └────────────────────────────────┘  │
│  ④ Classification (CNN)   │                                      │
│  ⑤ Annotation             │  [🚀 Run Defect Detection]           │
│                           │                                      │
│  🏷️ Defect Classes        │  ┌──────────────────────────────┐    │
│  ● Missing Hole           │  │ Defects │ Types │ Conf │ Time│    │
│  ● Mouse Bite             │  └──────────────────────────────┘    │
│  ● Open Circuit           │                                      │
│  ● Short                  │  ✅ Inference: 287ms — within target │
│  ● Spur                   │                                      │
│  ● Spurious Copper        │  [Original][Mask][Heatmap][Annotated]│
└──────────────────────────────────────────────────────────────────┘

Feature Breakdown

Image Upload

• Accepts JPG, JPEG, PNG, BMP, TIF formats
• Displays a pre-analysis preview immediately after upload
• Processes images of any resolution (internally handled)

Inference Execution

• Single click triggers the full 5-stage pipeline
• Spinner with status text during processing
• Results stored in Streamlit session state — persist across re-renders without re-running inference

Metric Dashboard Four summary tiles appear after every successful inference run:

Tile	Metric	Description
Defects Found	Count	Total number of regions detected
Defect Types	Count	Number of distinct defect classes
Avg Confidence	%	Mean classification probability across detections
Inference Time	ms	End-to-end pipeline execution time

Performance Gate After every run, the app evaluates whether inference met the ≤ 3,000 ms operational target:

• ✅ Green banner — met the target, displays exact time
• ⚠️ Warning banner — exceeded target, suggests GPU usage or image resizing

4-Panel Visual Output

Panel	Content
Original Input	The uploaded PCB image as-is
Defect Mask	Binary (white=defect, black=clean) segmentation output
Anomaly Heatmap	65/35 alpha blend of original + red defect overlay
Annotated Output	Original with colored bounding boxes and class+confidence labels

Prediction Table A styled HTML table with one row per detection:

• Color-coded defect class badge (matching bounding box color)
• Confidence percentage with a visual mini progress bar
• Centroid pixel coordinates (cx, cy)
• Bounding box coordinates (x, y, width, height)

Class Distribution Chart A bar chart (via st.bar_chart) shows the frequency of each defect class across all detections in the uploaded image — useful for quickly identifying dominant defect types on a board.

Export Suite Four individually downloadable files, all generated fully in memory:

Button	Filename	Format	Contents
📥 Download Annotated Image	pcb_annotated_<ts>.png	PNG	Original + bounding boxes
📥 Download CSV Log	pcb_predictions_<ts>.csv	CSV	All detections tabulated
📥 Download Defect Mask	pcb_mask_<ts>.png	PNG	Binary segmentation mask
📥 Download Evaluation Report	pcb_eval_report_<ts>.txt	TXT	Performance gate + defect list

---

📊 Training Data Pipeline

Dataset — DeepPCB

The DeepPCB dataset provides annotated PCB image pairs consisting of:

• A template image (clean, defect-free reference PCB)
• A test image (the same board location with a manufactured defect introduced)

Both images in each pair are captured under identical conditions, making them suitable for difference-based localization.

Processing Pipeline (Training Data Preparation)

Stage A — Image Alignment

The test image is geometrically aligned to its template using ORB (Oriented FAST and Rotated BRIEF) feature matching and RANSAC-robust homography estimation:

1. cv2.ORB_create(5000) — detects 5,000 keypoints in each image
2. cv2.BFMatcher with NORM_HAMMING + crossCheck=True — finds the best mutual descriptor matches
3. Top 90% of matches by Hamming distance are retained for robustness
4. cv2.findHomography(RANSAC, threshold=5.0) — estimates the perspective transformation
5. cv2.warpPerspective — warps the test image onto the template's canvas

If alignment fails (< 4 keypoints or no homography), the test image is simply resized to the template dimensions as a fallback.

Stage B — Defect Mask Generation

1. Both images are median-blurred (5×5 kernel) to suppress camera noise
2. cv2.absdiff computes the pixel-wise absolute difference
3. The difference is converted to grayscale
4. Otsu's thresholding automatically determines the optimal binary split from the histogram
5. Morphological close (5×5) fills gaps, open (3×3) removes noise

Stage C — ROI Extraction & Dataset Split

1. Contours are detected on the binary mask with additional morphological erosion to sharpen borders
2. Each contour passes quality filters (area, aspect ratio, circularity for Missing Hole)
3. ROI patches are cropped with 4-pixel context padding
4. All patches are pooled per class, randomly shuffled (seed=42), and split 70 / 15 / 15% into train / validation / test sets
5. Splits are saved as labeled image folders for direct use with Keras ImageDataGenerator

Dataset Structure After Processing

module2_output/
└── rois/
    ├── train/
    │   ├── Missing_hole/   [~70% of Missing Hole ROIs]
    │   ├── Mouse_bite/     [~70% of Mouse Bite ROIs]
    │   ├── Open_circuit/
    │   ├── Short/
    │   ├── Spur/
    │   └── Spurious_copper/
    ├── val/                [~15% each]
    └── test/               [~15% each]

---

📈 Evaluation & Metrics

Training Evaluation (on ROI test split)

After training completes, the model is evaluated on the held-out test split:

Metric	Description
Test Accuracy	Overall fraction of ROIs correctly classified
Precision (weighted)	TP / (TP + FP) averaged by class support
Recall (weighted)	TP / (TP + FN) averaged by class support
F1-Score (weighted)	Harmonic mean of precision and recall
Confusion Matrix	6×6 heatmap — rows = true label, cols = predicted
Classification Report	Per-class and macro/weighted averages

Target: ≥ 95% accuracy on the test split.

All plots and reports are saved automatically to Model Training and Evaluation/module3_output/.

Inference Evaluation (on unseen image pairs)

The Single_Test.py script evaluates the full dual-image inference pipeline on new, unseen PCB image pairs:

Metric	Computation Method
GT Match Rate	Centroid ±32 px proximity + class agreement
False Positive Rate	FP / (FP + TN) across the confusion matrix
False Negative Rate	FN / (FN + TP) across the confusion matrix

A ground-truth JSON file can optionally be provided for quantitative comparison. Without it, the script still produces annotated output images and scatter plots of all detections.

---

🛠 Installation

Prerequisites

Requirement	Version
Windows	10 or 11
Python	3.12 (must be on PATH)
Git	Any recent version
RAM	≥ 8 GB
Disk space	≥ 5 GB (venv + dataset)

Setup

# 1. Clone the repository
git clone https://github.com/Cheekurthi-Vamsi/PCB-Defect-Detection-and-Classification-System.git
cd PCB-Defect-Detection-and-Classification-System

# 2. Create a virtual environment
py -3.12 -m venv venv

# 3. Install all dependencies
venv\Scripts\pip install -r requirements.txt

Dependencies

tensorflow-cpu ≥ 2.12, < 2.17   # Neural network training and inference
opencv-python ≥ 4.8.0            # Image processing
Pillow ≥ 10.0.0                  # PIL image I/O and export
streamlit ≥ 1.32.0               # Web application framework
numpy ≥ 1.24.0                   # Array operations
pandas ≥ 2.0.0                   # DataFrame and CSV handling
matplotlib ≥ 3.7.0               # Training curve plots
seaborn ≥ 0.12.0                 # Confusion matrix heatmaps
scikit-learn ≥ 1.3.0             # Classification metrics
imutils ≥ 0.5.4                  # Contour grab utility

---

🚀 Usage

1. Download the Dataset

Download the DeepPCB dataset and extract it to:

Image Subtraction\DeepPCB_dataset\

Folder names must exactly match: Missing_hole, Mouse_bite, Open_circuit, Short, Spur, Spurious_copper

2. Train the Model

# One-click: double-click run_pipeline.bat
# Or manually:

venv\Scripts\python "Image Subtraction\image_subraction.py"
venv\Scripts\python "Contour Detection and ROI Extraction\roi_ext.py"
venv\Scripts\python "Model Training and Evaluation\Train.py"

Stage	Script	Output	Time
Image processing	image_subraction.py	Aligned images + masks	2–10 min
ROI extraction	roi_ext.py	Labeled patch dataset	1–5 min
Model training	Train.py	best_model.keras + plots	30–90 min

3. Launch the Web App

# One-click: double-click run_app.bat
# Or manually:
venv\Scripts\streamlit run app.py

Open http://localhost:8501 in your browser.

4. Run Inference

1. Upload a PCB image using the drag-and-drop zone
2. Click 🚀 Run Defect Detection
3. Review the 4-panel visual output and prediction table
4. Download your results using any of the four export buttons

---

📋 Results Summary

Evaluation Metric	Target	Status
Classification accuracy (test ROI set)	≥ 95%	Targeted
End-to-end inference speed (CPU)	≤ 3,000 ms	~200–400 ms ✅
Defect localization	All defect regions	Adaptive + Canny fusion
Export functionality	PNG, CSV, Mask, TXT	All 4 implemented ✅
False positive / negative rate	Minimized	Reported per-class

---

📁 Project Structure

PCB/
│
├── app.py                                      # Streamlit web application
│
├── backend/
│   ├── inference.py                            # Core inference pipeline (all stages)
│   └── __init__.py                             # Package initializer
│
├── Image Subtraction/
│   ├── image_subraction.py                     # ORB align · absdiff · Otsu · morph
│   ├── DeepPCB_dataset/                        # ← Download dataset here
│   └── module1_output/                         # Generated: aligned, masks, diffs
│
├── Contour Detection and ROI Extraction/
│   ├── roi_ext.py                              # Contour detect · crop · split
│   └── module2_output/                         # Generated: ROI patches + visualizations
│
├── Model Training and Evaluation/
│   ├── Train.py                                # EfficientNetB0 two-phase training
│   ├── Single_Test.py                          # Dual-image evaluation pipeline
│   ├── test_images/                            # ← Add unseen test pairs here
│   ├── test_ground_truth.json                  # GT annotations template
│   └── module3_output/                         # Generated: models, plots, reports
│
├── docs/
│   ├── Technical_Documentation.md              # Full algorithm & architecture reference
│   ├── User_Guide.md                           # Installation & usage walkthrough
│   └── Presentation_Content.md                 # 14-slide presentation deck
│
├── requirements.txt                            # Python package dependencies
├── run_app.bat                                 # Launch Streamlit web app
├── run_pipeline.bat                            # Run full training pipeline
└── .gitignore                                  # Ignores venv, dataset, generated outputs

---

📚 Documentation

Detailed documentation is available in the docs/ directory:

Document	Contents
Technical Documentation	Algorithm details, parameter tables, model architecture, backend function reference, performance characteristics
User Guide	System requirements, installation steps, dataset setup, training walkthrough, web app usage, export guide, troubleshooting
Presentation Slides	14-slide deck covering problem statement, solution overview, dataset analysis, model architecture, evaluation results, and future roadmap

---

🔭 Future Roadmap

Enhancement	Priority	Description
Real-time camera integration	High	Use st.camera_input for live line-of-sight inspection
Edge deployment (TFLite)	High	Quantize model for Jetson Nano / Raspberry Pi
PDF report export	Medium	Generate formal QA PDFs with reportlab
Defect history database	Medium	Persist results to MongoDB for trend analytics
Automated alerting	Medium	Email / SMS for critical defect types
Batch image processing	Low	Process entire folders without individual uploads
Confidence threshold slider	Low	User-adjustable minimum confidence filter in the UI

---

👤 Author

Vamsi Cheekurthi
PCB Defect Detection & Classification System
2026

---

Built with Python · TensorFlow · OpenCV · Streamlit