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

AI & Machine Learning Jupyter notebookPillowPython 3TensorFlow · KerasNumPy · Matplotlibscikit-learn metricsEfficientNet-B0HTML · CSS · JS demoSoftware
Wind Turbine Blade Damage Detection using CNN — project thumbnail preview
More project photos (3)

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.

SYSTEM FLOW

4 components 4 connections

Live flow
Drag to explore
100%
userInspector

Picks a sample blade inspection photo in the web demo.

Follow the working sequence

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 free synopsis (PDF)

Enter your name and WhatsApp number — the synopsis PDF downloads immediately. We may send occasional project updates on WhatsApp; no spam.

Related guides

All guides

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

CNN Transfer Learning for Students: Fine-Tuning ResNet and MobileNet in PyTorch

Train image classifiers on small datasets with transfer learning: load an ImageNet-pretrained backbone, freeze its early layers, replace the classification head for your classes, train the head first, then unfreeze late layers with a small learning rate for fine-tuning. This guide covers backbone choice (ResNet vs MobileNet vs EfficientNet), the exact PyTorch workflow, freezing strategy, data needs per class, and the errors that waste the most time.

Read guide

YOLO Object Detection for Final-Year Projects: Datasets, Colab Training, mAP and Deployment

How do you build a YOLO object detection project for your final year? Start with a labelled dataset in YOLO format (300-500+ images per class with real variation), train a small pretrained model on Google Colab with early stopping, evaluate with mAP@0.5 and mAP@0.5:0.95 on a held-out test set, and deploy the exported model on your demo hardware. This guide covers the full pipeline - version choice, labelling discipline, Colab training, honest evaluation, common errors, and deployment - with the decision tables and checklists your report needs.

Read guide
Get a quotation