oliversinn/waferguard-dataset

Wafer Map Defect Dataset (Mixed-Type)

Dataset Summary

This is a comprehensive mixed-type wafer map defect dataset containing 38,000 samples for defect pattern recognition (DPR) in semiconductor wafer manufacturing. The dataset combines real wafer map data with synthetically augmented samples generated using generative adversarial networks (GANs) to ensure balanced representation across all 38 defect pattern classes.

Overview

Wafer defect pattern recognition is essential in semiconductor manufacturing quality control. This dataset enables researchers and engineers to:

• Develop and train deep learning models for automatic wafer defect classification
• Analyze mixed-type defect patterns in wafer production
• Improve yield and reduce manufacturing costs
• Research robust defect detection algorithms

Motivation

Problem Context

Defect pattern recognition (DPR) of wafer maps, especially mixed-type defects, is critical for determining the root cause of production defects in semiconductor manufacturing. Traditional manual inspection is:

• Time-consuming and labor-intensive
• Prone to human error
• Difficult to scale for high-volume manufacturing

Data Imbalance Solution

The natural distribution of wafer defects in production exhibits severe class imbalance—some defect patterns occur rarely while others are more common. To address this, the dataset creators used generative adversarial networks (GANs) to synthetically generate balanced samples while maintaining the statistical properties of real defects.

This results in a well-balanced dataset suitable for training robust deep learning models without bias toward common defect types.

Data Collection & Preparation

Collection Process

• Source: Wafer manufacturing plant data
• Method: Electrical probe testing of each die on the wafer
• Measurement: Die states determined by electrical performance testing
• Real Samples: ~19,000 authentic wafer map measurements
• Augmented Samples: ~19,000 GAN-generated samples for class balancing

Data States (Per Die)

Each pixel in a 52x52 wafer map represents a die state:

• 0 (Blank): No die at this location (unused area)
• 1 (Normal): Functional die passing electrical tests
• 2 (Broken): Defective die failing electrical tests

Dataset Details

• Total Samples: 38,000
• Image Dimensions: 52 x 52 pixels (2,704 pixels per map)
• Defect Pattern Classes: 38 unique classes
• Die States: 3 categories (blank, normal, broken)
• Label Format: 8-dimensional one-hot encoding (mapped to 38 unique patterns)
• Data Type: Integer arrays (0, 1, 2 for die states)

Features

Image Feature

• Name: image
• Type: 52 x 52 integer array
• Values: {0, 1, 2} representing die states
• Meaning:
  • 0 = Blank die (no semiconductor die at location)
  • 1 = Normal die (passed electrical tests)
  • 2 = Broken die (failed electrical tests)

Label Feature

• Name: label
• Type: 8-dimensional binary one-hot vector
• Mapping: Multi-label encoding mapped to 38 unique defect patterns
• Pattern Distribution: Balanced across all 38 classes

Defect Patterns

The dataset covers 38 distinct mixed-type wafer defect patterns, including:

• Single-type patterns: Individual defect types (scratches, particles, etc.)
• Mixed-type patterns: Combinations of multiple defect types
• Pattern variations: Different spatial distributions and severity levels

Common patterns include:

• Center defects
• Donut patterns (ring-shaped defects)
• Random defects
• Scratch patterns
• Edge defects
• Local defects
• And 32 other combinations

Dataset Splits

• Train: 38,000 samples (includes both real and augmented data)
• Test: For evaluation, use standard train/test split (e.g., 80/20)

Usage Examples

Loading with Hugging Face Datasets

from datasets import load_dataset

# Load the dataset
dataset = load_dataset("username/waferguard-dataset")

# Access training split
train_data = dataset["train"]

# Get a sample
sample = train_data[0]
image = sample["image"]  # 52x52 array
label = sample["label"]  # 8-dim one-hot vector

print(f"Image shape: {len(image)}x{len(image[0])}")
print(f"Label: {label}")

Loading with NumPy (from original NPZ)

import numpy as np

# Load from original NPZ format
data = np.load("Wafer_Map_Datasets.npz", allow_pickle=True)
images = data["arr_0"]  # Shape: (38000, 52, 52)
labels = data["arr_1"]  # Shape: (38000, 8)

print(f"Images shape: {images.shape}")
print(f"Labels shape: {labels.shape}")

Training a Classification Model

import tensorflow as tf
from datasets import load_dataset

# Load dataset
dataset = load_dataset("username/waferguard-dataset")
train_data = dataset["train"]

# Convert to TensorFlow dataset
def prepare_sample(sample):
    image = tf.constant(sample["image"], dtype=tf.float32) / 2.0  # Normalize
    label = tf.constant(sample["label"], dtype=tf.float32)
    return image, label

tf_dataset = train_data.map(prepare_sample, batched=True, batch_size=32)

# Build and train model
model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(52, 52)),
    tf.keras.layers.Dense(256, activation="relu"),
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.Dense(128, activation="relu"),
    tf.keras.layers.Dense(38, activation="softmax")
])

model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])
model.fit(tf_dataset, epochs=10)

Data Augmentation

The original dataset includes:

• Real Data: ~50% authentic wafer maps from production
• Synthetic Data: ~50% GAN-generated wafer maps for class balancing

Benefits of synthetic augmentation:

• Balanced class distribution (all 38 patterns equally represented)
• Maintained statistical properties of real defects
• Improved model generalization
• Reduced overfitting to common defect types

Quality Assurance

• Label Verification: Dataset labels have been reviewed and corrected
• Label Corrections: C7 and C9 pattern labels corrected by Dr. Uzma Batool (UTM)
• Data Validation: Quality checks on synthetic data to ensure realism
• Consistency: All samples maintain consistent 52x52 format

Recommended Models

Models that have shown good performance on this dataset:

• Custom CNNs: 4-8 convolutional layers with pooling
• Transfer Learning: MobileNetV2, ResNet50, VGG16 (pretrained on ImageNet)
• Deformable CNNs: For handling geometric variations in defect patterns
• Vision Transformers: For improved pattern recognition

Metrics & Benchmarks

Reference performance from original paper (Wang et al., 2020):

• Macro F1 Score: ~0.97
• Weighted F1 Score: ~0.97
• Accuracy: ~97%

(Note: Performance varies with model architecture and training configuration)

Limitations & Considerations

1. Fixed Resolution: 52x52 pixels - may not capture all fine details in some defects
2. Synthetic Data: ~50% of dataset is GAN-generated, not real production data
3. Single Plant: Data from one manufacturing facility may not generalize to all processes
4. Binary Labels Per Die: Only captures pass/fail status, not severity levels
5. Historical Data: Collected from a specific time period; manufacturing processes may change
6. Class Imbalance Mitigation: Synthetic augmentation may not perfectly match real defect distributions

Related Work

• Original Paper: Wang et al. (2020) - Deformable Convolutional Networks for Wafer Defect Recognition
• GitHub Repository: WaferMap
• Kaggle Dataset: Original Wafer Map Defect Dataset

Citation

If you use this dataset in your research, please cite the original work:

@article{Wang2020,
  author={Wang, J. and Xu, C. and Yang, Z. and Zhang, J. and Li, X.},
  title={Deformable Convolutional Networks for Efficient Mixed-type Wafer Defect Pattern Recognition},
  journal={IEEE Transactions on Semiconductor Manufacturing},
  year={2020},
  doi={10.1109/TSM.2020.3020985}
}

Additionally, please acknowledge the Hugging Face community contribution:

Dataset: Wafer Map Defect Dataset (Mixed-Type)
Source: Hugging Face Datasets
Original: Wang et al. (2020), Kaggle

Acknowledgements

• Dataset Creator: co1d7era (Kaggle)
• Label Corrections: Dr. Uzma Batool, University of Technology Malaysia (UTM)
• Original Research: J. Wang, C. Xu, Z. Yang, J. Zhang, X. Li
• Source: Kaggle - Wafer Map Defect Dataset
• GitHub: WaferMap Repository
• Hugging Face Community: For dataset hosting and distribution

License

This dataset is available under the CC-BY-4.0 (Creative Commons Attribution 4.0) license.

What this means:

• ✅ You can use this dataset for any purpose (commercial or non-commercial)
• ✅ You can modify and create derivatives
• ✅ You must provide attribution to the original creators
• ✅ No warranty is provided

For full license details, see: https://creativecommons.org/licenses/by/4.0/

Disclaimer

This dataset is provided for research and educational purposes. The data represents semiconductor manufacturing processes and may contain proprietary information.

• Users must comply with the original dataset's terms and conditions
• The dataset creators are not liable for any misuse or damage
• This is real production data; use responsibly and ethically
• Always cite the original work when publishing results

Contact & Support

• Original Dataset Issues: Kaggle Dataset
• GitHub Issues: WaferMap Repository
• Dataset Paper: IEEE Transactions on Semiconductor Manufacturing, DOI: 10.1109/TSM.2020.3020985

Version History

• v1.0: Initial upload to Hugging Face Datasets (April 2026)
• Based on: Original Kaggle dataset with corrected labels (C7, C9)
• Format: HF Datasets (Arrow/Parquet), converted from NumPy NPZ

---

Last Updated: April 2026