This research represents a major advancement in integrating biometric data with healthcare technologies, paving the way for future innovations in the field by using Deep Learning Model.

• Introduction
• Folder Structure
• Prerequisites
• Getting Started
• Working Principle
• Modules
• Trained Results
• Outputs
• Testing Results
• Contributing

This project aims to detect blood groups (A, B, AB, O) using a non-invasive approach by analyzing fingerprints. The system is designed to provide a quick and simple way to determine blood type without the need for a traditional blood test.

# Clone the repository

git clone [https://github.com/Your_Username/Non-Invasive_Blood_Group_Detectio.git]

# Navigate to the project directory

cd Non-Invasive_Blood_Group_Detection

# Install the required dependencies

pip install -r requirements.txt  

The model was trained on a comprehensive dataset of fingerprint images, carefully organized by blood group type. The folder structure within Dataset_blood_group/ demonstrates how the data is categorized for training the deep learning model.

The bar graph titled "Dataset Class Distribution" illustrates the number of samples belonging to each blood group in the dataset used for training and evaluation.

The dataset is included in the repository due to size constraints.

-Image Acquisition: A high-resolution image of the user's fingerprint is captured.

-Image Pre-processing: The captured image is pre-processed to enhance the ridges and valleys and remove noise.

-Feature Extraction: Key features such as ridge endings, bifurcations, and minutiae points are extracted.

-Pattern Recognition: A Convolutional Neural Network (CNN) model analyzes the extracted features to identify patterns.

-Classification: The CNN model classifies the pattern into one of the four blood groups (A, B, AB, O).

-Prediction: The system provides a final prediction of the user's blood group.

The web-based user interface allows users to upload a fingerprint image and receive an instant prediction of their blood group. The frontend is built with standard web technologies (HTML, CSS, JavaScript) and is powered by the backend application.

A Jupyter Notebook bash( .ipynb ) that contains code for Training and Testing.

The main modules in this CNN architecture are the Input Layer, Convolutional Layers, Max-Pooling Layers, Hidden (Fully Connected) Layers, and the Output Layer. Each module performs a specific function to process the input image and produce a final prediction.

1. Input Layer This is the starting point of the network. It receives the raw data, which in this case is an image. The dimensions shown, 125x125x3, represent the width, height, and color channels (Red, Green, Blue) of the input image, respectively.

2. Convolutional Layers These layers are the core of the CNN. They use small filters (or kernels) to scan the input image and detect specific features like edges, textures, or shapes. Each convolutional layer in your diagram creates a series of feature maps (e.g., 32, 64, 64, 16) that highlight the presence of these features.

3. Max-Pooling Layers These layers work in tandem with the convolutional layers. They perform a down-sampling operation by taking the maximum value from a small region of the feature maps. This reduces the spatial dimensions of the data (e.g., from 62x62 to 31x31), which helps to: Reduce the computational complexity and Make the model more robust to minor shifts and distortions in the input image.

4. Fully Connected (Hidden) Layers After the convolutional and max-pooling layers have extracted high-level features, the data is flattened into a single, long vector. This vector is then fed into these layers. The fully connected layers act as a traditional neural network, using the features to learn complex relationships and prepare for final classification.

This report provides a detailed breakdown of key performance metrics like precision, recall, and f1-score for each blood group.

This graph shows the model's accuracy increasing with each training epoch, demonstrating that it is effectively learning from the data without significant overfitting.

The confusion matrix visually represents the model's performance on each blood group, showing how many predictions were correct versus incorrect.

A live demonstration of the system's functionality is available in the images.

The Postman API was used to test the http://127.0.0.1:5000/predict endpoint. We sent a POST request with a fingerprint image, and the API successfully responded with the predicted blood group and a confidence score. This demonstrates that our API can correctly process image data and return a prediction.

We welcome contributions from the community. If you would like to contribute, please follow these steps:

Fork the repository.

Create a new branch for your feature (git checkout -b feature/your-feature-name).

Commit your changes (git commit -m 'Add new feature').

Push to the branch (git push origin feature/your-feature-name).

Create a pull request.