Built to order

Wind Turbine Blade Damage Detection using CNN

This project builds a convolutional neural network that classifies wind turbine blade inspection photographs into five categories — healthy, crack, leading-edge erosion, lightning damage and delamination. It ships with a curated, annotated blade-image dataset, a complete training and evaluation notebook, the trained model, and an interactive web demo that runs the damage-classification pipeline on sample inspection photos. The architecture, training choices and evaluation are documented for a confident viva. Suitable for B.E./B.Tech final-year projects in AI & Machine Learning, Electrical and

Wind Turbine Blade Damage Detection using CNN — project thumbnail preview
More project photos (2)

The problem

Wind turbine blades suffer cumulative damage — surface cracks, leading-edge erosion from rain and particles, lightning strikes and subsurface delamination. Manual inspection means rope-access technicians or expensive downtime, and early-stage defects are easy to miss in thousands of drone photographs. This project applies transfer learning with an EfficientNet-B0 backbone to classify blade inspection images into five damage categories, turning a tedious visual review into a fast, repeatable screening step. Students learn a complete applied-vision workflow: dataset curation and annotation, augmentation for outdoor lighting variation, fine-tuning a pre-trained CNN, and honest evaluation with per-class metrics. The interactive demo walks through the inference pipeline on real blade photographs with representative model outputs.

How it works

  1. Blade inspection photographs are collected from drone and rope-access surveys and annotated into five damage classes.
  2. Images are resized to 224×224, normalized, and split 80/20 into stratified train and validation sets.
  3. Augmentation (rotation, brightness jitter, horizontal flip) simulates the lighting variation of outdoor inspection.
  4. EfficientNet-B0, pre-trained on ImageNet, is fine-tuned with a new classification head and dropout.
  5. Training runs with Adam and cosine-decay learning rate, with early stopping on validation loss.
  6. The held-out split is evaluated once: accuracy, confusion matrix and per-class precision/recall are generated for the report.
  7. In the web demo, a sample photo passes through the same preprocessing and the trained model to produce the damage prediction.

Tech stack:

  • Python 3, TensorFlow/Keras
  • EfficientNet-B0 (transfer learning)
  • NumPy, Matplotlib, scikit-learn
  • Jupyter Notebook (training)
  • HTML/CSS/JS inference demo
  • Pillow (image preprocessing)

Dataset & model details

  • Dataset: Custom curated blade-inspection set — approximately 2,400 drone and rope-access wind turbine blade photographs assembled for the build, annotated into 5 classes: healthy, crack, leading-edge erosion, lightning damage, delamination; stratified 80/20 train/validation split.
  • Task: 5-class image classification; input = 224×224×3 blade photo, output = probability distribution over the 5 damage classes.
  • Model: EfficientNet-B0 backbone (ImageNet pre-trained) → GlobalAveragePooling → Dropout(0.3) → Dense(5, softmax); ~5.3M parameters.
  • Metrics: Validation accuracy ~93% (design target), macro F1 ~0.90 (design target), per-class precision/recall, confusion matrix. No accuracy is claimed as measured until the training run is executed for the order.
Parameter Value
Input format 224 × 224 RGB, normalized
Classes 5 (healthy + 4 damage types)
Dataset size Approximately 2,400 annotated images
Model parameters Approximately 5,300,000 (design target)
Validation accuracy ~93% (design target, not a measured claim)
Training time Approximately 1–2 h on a free GPU (expected)
Inference Approximately 35 ms per image on CPU (expected)
Model file Approximately 21 MB (.h5) / 5.3 MB TFLite (expected)
Demo Single-file web app, runs offline after download

Project features

  • Five-class damage classifier Healthy, crack, leading-edge erosion, lightning damage and delamination — a purpose-built label set for blade inspection, with per-class precision and recall reported.
  • Curated inspection dataset Around 2,400 drone and rope-access blade photographs, annotated by damage class, with a documented stratified train/validation split.
  • Transfer-learning training notebook EfficientNet-B0 fine-tuning with augmentation for outdoor lighting, early stopping, and training-curve plots — fully reproducible.
  • Interactive inference demo Single-file web app: pick a sample blade photo, run the analysis pipeline, and see the predicted class with probability bars.
  • Per-class evaluation report Confusion matrix and precision/recall/F1 for each damage class, so the viva can discuss exactly which defects confuse the model.
  • Inference-ready model export Saved weights plus a preprocessing pipeline, ready to run on new inspection photos without retraining.
  • Viva kit Report PDF, presentation PPT and a Q&A document covering CNNs, transfer learning, augmentation and evaluation metrics.

What is included

  • Curated, annotated blade-image dataset with split files
  • Complete training & evaluation Jupyter notebook
  • Trained CNN model file with preprocessing code
  • Interactive inference web demo with sample photos
  • Confusion matrix, per-class metrics and training-curve plots
  • Project report PDF (background, methodology, architecture, results)
  • PPT presentation for final review
  • Viva Q&A preparation document

Limitations & prerequisites

  • Trained on the curated five-class set — rare defect types outside these classes are out of scope.
  • Outdoor inspection photos vary in lighting and angle; heavy glare or motion blur degrades predictions.
  • 93% is a design target for the training run, stated honestly — the report documents the actual achieved figure.
  • The classifier screens images; it does not replace certified structural inspection of blades.
  • Subsurface delamination is only detectable where it shows surface symptoms in the photo.

Frequently Asked Questions

Which dataset is used?

A custom curated set of about 2,400 wind turbine blade photographs from drone and rope-access inspections, annotated into five classes: healthy, crack, leading-edge erosion, lightning damage and delamination, with a stratified 80/20 split. The curation and annotation protocol is documented in the report.

Why EfficientNet-B0?

It gives strong accuracy per parameter, which matters for a model that may later run on a field laptop or edge device. The report compares the choice against ResNet-50 and MobileNetV3 in the architecture rationale section.

How does the demo work?

You pick one of the sample blade photographs, press Run analysis, and the app runs the same preprocessing the model was trained with, then shows the predicted damage class with probability bars — representative of the trained model on these samples.

Which defects does it confuse most?

Typically early leading-edge erosion versus healthy blades, and hairline cracks versus surface scratches — visually similar cases. The confusion matrix in the report shows this explicitly and makes a strong viva talking point.

Can it detect internal damage?

Only where damage shows surface symptoms. Purely subsurface delamination with no visible sign is outside what a photo classifier can see; the report states this boundary clearly.

Is this project suitable for a final-year project?

Yes — for AI & Machine Learning, Electrical and Mechanical programs. It demonstrates dataset curation, transfer learning, augmentation strategy and honest evaluation on a real renewable-energy inspection problem. Suitable for B.E./B.Tech final-year projects in AI & Machine Learning, Electrical and Mechanical.

Components & software requirements
  • Python 3, TensorFlow/Keras
  • EfficientNet-B0 (transfer learning)
  • NumPy, Matplotlib, scikit-learn
  • Jupyter Notebook (training)
  • HTML/CSS/JS inference demo
  • Pillow (image preprocessing)

Dataset & model details

  • Dataset: Custom curated blade-inspection set — approximately 2,400 drone and rope-access wind turbine blade photographs assembled for the build, annotated into 5 classes: healthy, crack, leading-edge erosion, lightning damage, delamination; stratified 80/20 train/validation split.
  • Task: 5-class image classification; input = 224×224×3 blade photo, output = probability distribution over the 5 damage classes.
  • Model: EfficientNet-B0 backbone (ImageNet pre-trained) → GlobalAveragePooling → Dropout(0.3) → Dense(5, softmax); ~5.3M parameters.
  • Metrics: Validation accuracy ~93% (design target), macro F1 ~0.90 (design target), per-class precision/recall, confusion matrix. No accuracy is claimed as measured until the training run is executed for the order.
Delivery information

Built-to-order project. Delivery timeline is shared after order confirmation based on current queue.

Support terms

Complete documentation, setup guide, and viva preparation included. Support for setup and explanation provided.

Download abstract (PDF)

Related guides

All guides
Blueprint-style technical illustration of multiple decision trees voting together into one final predictionStudents with basic Python and pandas skills who want a reliable first classifier for ML coursework and tabular data projects.

Random Forests Explained: Why Decision Trees Vote Better Together

Decision trees are readable but overfit; random forests fix this by training hundreds of varied trees on bootstrapped data with random feature subsets, then letting them vote. This guide explains Gini impurity, bagging, out-of-bag validation and the four hyperparameters that matter, with a complete scikit-learn workflow, honest feature-importance practices, and the mistakes students keep making.

Read guide
Illustration of object tracking showing video frames with bounding boxes and persistent ID labels following people and vehicles, comparing motion prediction and appearance matching.B.E./B.Tech Computer Science and Electronics students building video analytics projects — people counting, vehicle tracking, sports analysis — who have detection working and need

Object Tracking: DeepSORT and ByteTrack Explained

Detection finds objects per frame; tracking keeps their identities across frames. This guide explains tracking-by-detection, Kalman motion models, DeepSORT's appearance embeddings vs ByteTrack's low-confidence box recovery, tracking metrics (HOTA, IDF1, ID switches), and the tuning parameters that determine real-world quality.

Read guide
Illustration of image segmentation showing U-Net's U-shaped encoder-decoder with skip connections producing pixel masks, alongside Mask R-CNN detecting instances with masks.B.E./B.Tech Computer Science and AI/ML students moving from image classification or detection to pixel-level understanding — medical imaging, defect detection, autonomous driving

Image Segmentation: U-Net and Mask R-CNN

When projects need pixel-level answers, segmentation delivers. This guide explains semantic vs instance vs panoptic segmentation, U-Net's encoder-decoder with skip connections, Mask R-CNN's parallel mask head, Dice and IoU evaluation, paired augmentation, and how to choose the right architecture for your data and question.

Read guide
Get a quotation