01 Source Code Only
₹99
One-time Payment
- Complete project source code
- Database / data resources
- Dependencies & configuration
- README / setup guide
- Instant download access
MACHINE-LEARNING Project
Concrete Crack Detection Using Machine Learning Source Code
Complete final-year project source code with frontend, backend, database and setup documentation. Instant download after secure payment.
Hover to zoom · Click to expand
Choose the Package That Fits You Best
Simple pricing. Instant access. Secure checkout.
02 Code + Setup Support
₹248
One-time Payment
- Everything in Source Code plan
- Remote setup assistance
- Database & configuration setup
- Run verification
- Help via WhatsApp / Email
Project's Overview
This project leverages computer vision and machine learning techniques to automate the process of detecting cracks in concrete structures. The primary goal is to provide an efficient and accurate method for damage surveillance in buildings, which is crucial for maintaining structural integrity and safety. The project was developed as an entry for the "PS-1, Concrete Crack Detection". The model has achieved an impressive F1 score of 1, indicating its high accuracy in distinguishing between cracked and non-cracked surfaces.
Login Credentials
| Panel | Username | Password | |
|---|---|---|---|
| Admin | [email protected] | admin | admin@123 |
| User | [email protected] | User | user@123 |
Related & Popular Projects
View all
1. Data Preprocessing and Augmentation:
- Bilateral Filtering: Reduces salt and pepper noise while preserving image edges, crucial for accurate crack detection.
- Morphological Operations: Removes small noise while maintaining significant image features, enhancing crack visibility.
- Grayscaling:Converts images to grayscale, reducing computational complexity and processing time without losing essential information.
- Data Augmentation: Techniques like rotation, flipping, and brightness adjustment increased the dataset size from 300 to 3000 images per class, improving model robustness.
2. Modeling:
- Transfer Learning with ResNet and VGG16: Both architectures were evaluated for performance in crack detection. ResNet was chosen as the final model due to its superior accuracy.
- High Accuracy: The final model achieved a perfect F1 score of 1, demonstrating flawless classification of cracked and non-cracked surfaces.
3. Methodology:
- Data Exploration: Manual analysis to identify noise and select appropriate preprocessing techniques.
- Image Processing: Application of Bilateral Filtering and Morphological Operations to optimize image quality for model training.
- Model Training and Evaluation: Extensive evaluation of ResNet and VGG16 models to select the best-performing architecture for final deployment.
4. Dataset:
- The dataset used for training and testing is publicly available on Kaggle, facilitating further research and development in concrete crack detection.
- The Concrete Crack Detection project is designed to detect cracks in concrete structures using computer vision and machine learning techniques. The project was part of the L&T EduTech Hackathon under Shaastra, the tech fest of IIT Madras. Below are the detailed features and methodology of the project:
1. Problem Statement and Objective
- Goal: To automate the process of damage surveillance of buildings by detecting cracks in concrete structures using machine learning models.
- Context: Traditional manual inspection methods are time-consuming and prone to errors. Automated detection can help improve accuracy and efficiency in monitoring the structural health of buildings.
2. Dataset Information
- Source: The dataset used is publicly available on Kaggle: Surface Crack Dataset.
- Content: The dataset consists of images categorized into two classes: positive (images with cracks) and negative (images without cracks).
- Size: Initially, the dataset had around 300 examples per class, which was later augmented to 3000 examples per class using data augmentation techniques.
3. Data Preprocessing and Augmentation
- Bilateral Filtering:
- Purpose: To remove salt-and-pepper noise while preserving the edges of the cracks.
- Comparison: Initially, median filtering was used but did not yield satisfactory results as it blurred the edges. Bilateral filtering was chosen as it preserved edges better.
- Morphological Operations:
- Opening Operation: Used to remove small noise and amplify the difference between classes.
- Technique: Single iteration of opening operation with a 3x3 kernel was applied.
- Grayscale Conversion:
- Reason: Grayscale conversion was performed to reduce computation time by approximately three times, as processing a single channel (grayscale) is faster than processing three channels (RGB).
- Data Augmentation:
- Techniques:
- Perfect 90 and 180-degree rotations.
- Horizontal and vertical flipping.
- Minor brightness adjustments (around 10%) to increase dataset variability.
- Objective: To increase the dataset size and improve the model’s generalization by generating more diverse training samples.
4. Modeling and Machine Learning Techniques
- Model Architectures Tested:
- ResNet Architecture: Selected for final predictions after testing multiple architectures due to its superior performance.
- VGG16 Model: Also experimented with but found to be less effective than ResNet on this specific dataset.
- Transfer Learning:
- Approach: Utilized pre-trained models (ResNet and VGG16) and fine-tuned them for the crack detection task. Transfer learning was preferred over building custom models from scratch to leverage pre-existing feature extraction capabilities.
- Performance Metrics: Achieved a perfect F1 score of 1.0, indicating that the model was able to perfectly classify the images into cracked and non-cracked categories.
5. Model Training and Evaluation
- Training Process: Models were trained on the augmented dataset with a focus on achieving high accuracy and minimizing false positives and false negatives.
- Evaluation: The final model (ResNet) was evaluated on a separate test set to ensure its performance was robust and reliable.
6. Deployment and Application
- Potential Use Cases:
- Automated monitoring of building structures, bridges, and other concrete constructions.
- Integration into drones or handheld devices for real-time crack detection in field inspections.
- Advantages:
- Faster and more accurate than manual inspection.
- Can be scaled to large infrastructure projects for continuous monitoring.
7. Challenges and Solutions
- Noise Removal: Initial challenges in removing salt-and-pepper noise without losing important crack details were solved using bilateral filtering.
- Data Imbalance and Augmentation: Addressed the small size of the dataset by performing extensive data augmentation to prevent overfitting and improve model robustness.
8. Conclusion and Future Work
- Current Achievements: Successfully created a model that can detect cracks in concrete with high accuracy, achieving an F1 score of 1.
- Future Enhancements:
- Expanding the dataset with more diverse examples to improve model generalization.
- Exploring real-time deployment in practical scenarios.
- Integrating additional machine learning techniques to further refine detection capabilities.
9. Technologies and Libraries Used
- Libraries: Python, TensorFlow, Keras, OpenCV, NumPy, Matplotlib, and scikit-learn.
- Environments: Jupyter Notebooks for development and experimentation, and a dedicated Python virtual environment for managing dependencies.
- This project demonstrates a comprehensive approach to using machine learning for practical applications in structural health monitoring, showcasing the power of modern image processing and deep learning techniques.
-
Step 1: Navigate to the Project Directory
cd Concrete-Crack-Detection
-
Step 2: Set Up a Virtual Environment
python -m venv crack-detection-env
source crack-detection-env/bin/activate # On Windows use `crack-detection-env\Scripts\activate`
-
Step 3: Install the Required Libraries
pip install -r requirements.txt
-
Step 4: Download the Dataset
- The dataset is available at Kaggle.
- Download the dataset and extract it to a folder, say
data. - Place the
datafolder in the project directory -
Step 5: Run the Jupyter Notebooks
- 1.Launch Jupyter Notebook by typing:
jupyter notebook
- 2. Open the
concrete_crack_detection_processing_iitm_shaastra.ipynbormodels_final1.ipynbnotebook. - 3. Run each cell in the notebook sequentially. This will:
- Load the dataset.
- Preprocess the images using the specified methods.
- Train the model using the processed data.
- 4. Download the pre-trained model
resnet_model1.h5 from (Google Drive), ensure that the model file is in the correct path in root directory
README Included
Setup Support Available
| Panel | Username | Password | |
|---|---|---|---|
| Admin | [email protected] | admin | admin@123 |
| User | [email protected] | User | user@123 |