Upload 8 files

Try1.py

@@ -0,0 +1,218 @@
+# -------------------------
+# 1. Import Libraries
+# -------------------------
+import os
+import glob
+import numpy as np
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import classification_report, confusion_matrix
+import itertools
+
+from keras.preprocessing.image import ImageDataGenerator
+from keras.models import Model, load_model
+from keras.layers import Dense, Dropout
+from keras.applications import ResNet50
+from keras.applications.resnet50 import preprocess_input
+from keras.preprocessing import image
+
+import warnings
+warnings.filterwarnings('ignore')
+
+# -------------------------
+# 2. Load Dataset
+# -------------------------
+file_path = 'dataset'
+
+# List all classes
+name_class = os.listdir(file_path)
+print("Classes:", name_class)
+
+# Get all filepaths
+filepaths = list(glob.glob(file_path + '/**/*.*'))
+print(f"Total images found: {len(filepaths)}")
+
+# Extract labels
+labels = list(map(lambda x: os.path.split(os.path.split(x)[0])[1], filepaths))
+
+# Create DataFrame
+filepath_series = pd.Series(filepaths, name='Filepath').astype(str)
+labels_series = pd.Series(labels, name='Label')
+data = pd.concat([filepath_series, labels_series], axis=1)
+data = data.sample(frac=1).reset_index(drop=True)  # shuffle
+print(data.head())
+
+# -------------------------
+# 3. EDA (Exploratory Data Analysis)
+# -------------------------
+# Class distribution
+plt.figure(figsize=(8,5))
+sns.countplot(x='Label', data=data, order=data['Label'].value_counts().index)
+plt.title('Number of Images per Class')
+plt.xticks(rotation=45)
+plt.show()
+
+# Check image dimensions
+sample_img = plt.imread(data['Filepath'][0])
+print(f"Sample image shape: {sample_img.shape}")
+
+# Visualize few images
+fig, axes = plt.subplots(2, 4, figsize=(12,6))
+for ax, (img_path, label) in zip(axes.flatten(), zip(data['Filepath'][:8], data['Label'][:8])):
+    img = plt.imread(img_path)
+    ax.imshow(img)
+    ax.set_title(label)
+    ax.axis('off')
+plt.tight_layout()
+plt.show()
+
+# -------------------------
+# 4. Train-Test Split
+# -------------------------
+train, test = train_test_split(data, test_size=0.2, random_state=42)
+print(f"Training samples: {len(train)}, Testing samples: {len(test)}")
+
+# -------------------------
+# 5. Data Preprocessing and Augmentation
+# -------------------------
+train_datagen = ImageDataGenerator(
+    preprocessing_function=preprocess_input,
+    rotation_range=20,
+    width_shift_range=0.1,
+    height_shift_range=0.1,
+    zoom_range=0.1,
+    horizontal_flip=True
+)
+
+test_datagen = ImageDataGenerator(preprocessing_function=preprocess_input)
+
+train_gen = train_datagen.flow_from_dataframe(
+    dataframe=train,
+    x_col='Filepath',
+    y_col='Label',
+    target_size=(256, 256),
+    class_mode='categorical',
+    batch_size=32,
+    shuffle=True,
+    seed=42
+)
+
+valid_gen = test_datagen.flow_from_dataframe(
+    dataframe=test,
+    x_col='Filepath',
+    y_col='Label',
+    target_size=(256, 256),
+    class_mode='categorical',
+    batch_size=32,
+    shuffle=False
+)
+
+# -------------------------
+# 6. Model Building (Transfer Learning with ResNet50)
+# -------------------------
+pretrained_model = ResNet50(
+    input_shape=(256, 256, 3),
+    include_top=False,
+    weights='imagenet',
+    pooling='avg'
+)
+
+pretrained_model.trainable = False
+
+x = Dense(128, activation="relu")(pretrained_model.output)
+x = Dropout(0.5)(x)
+x = Dense(128, activation="relu")(x)
+outputs = Dense(8, activation='softmax')(x)
+
+model = Model(inputs=pretrained_model.input, outputs=outputs)
+
+model.compile(optimizer="adam", loss='categorical_crossentropy', metrics=['accuracy'])
+
+# -------------------------
+# 7. Model Training
+# -------------------------
+history = model.fit(
+    train_gen,
+    validation_data=valid_gen,
+    epochs=20,
+)
+
+# -------------------------
+# 8. Training Curves
+# -------------------------
+pd.DataFrame(history.history)[['accuracy', 'val_accuracy']].plot()
+plt.title('Training vs Validation Accuracy')
+plt.show()
+
+pd.DataFrame(history.history)[['loss', 'val_loss']].plot()
+plt.title('Training vs Validation Loss')
+plt.show()
+
+# -------------------------
+# 9. Evaluation and Confusion Matrix
+# -------------------------
+# Evaluate
+results = model.evaluate(valid_gen, verbose=0)
+print(f"Test Loss: {results[0]:.5f}")
+print(f"Test Accuracy: {results[1]*100:.2f}%")
+
+# Predictions
+predictions = model.predict(valid_gen)
+y_pred = np.argmax(predictions, axis=1)
+
+# True labels
+y_true = valid_gen.classes
+
+# Labels Mapping
+labels_map = train_gen.class_indices
+labels_map = dict((v,k) for k,v in labels_map.items())
+
+# Classification report
+print(classification_report(y_true, y_pred, target_names=list(labels_map.values())))
+
+# Confusion Matrix
+cm = confusion_matrix(y_true, y_pred)
+
+plt.figure(figsize=(8,6))
+sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
+            xticklabels=list(labels_map.values()),
+            yticklabels=list(labels_map.values()))
+plt.xlabel('Predicted')
+plt.ylabel('True')
+plt.title('Confusion Matrix')
+plt.show()
+
+# -------------------------
+# 10. Save the Model
+# -------------------------
+model.save("model_blood_group_detection_resnet.h5")
+print("Model saved successfully!")
+
+# -------------------------
+# 11. Single Image Prediction Example
+# -------------------------
+# Load model
+model = load_model('model_blood_group_detection_resnet.h5')
+
+# Single image prediction
+img_path = 'C:\Users\ADMIN\Documents\SEM-6\DL PROJECT\dataset\AB+\augmented_cluster_4_4.BMP'  # Update this path as needed
+img = image.load_img(img_path, target_size=(256, 256))
+x = image.img_to_array(img)
+x = np.expand_dims(x, axis=0)
+x = preprocess_input(x)
+
+preds = model.predict(x)
+predicted_class = np.argmax(preds)
+confidence = preds[0][predicted_class] * 100
+
+# Get label
+predicted_label = labels_map[predicted_class]
+
+# Show image
+plt.imshow(image.array_to_img(img))
+plt.axis('off')
+plt.title(f"Prediction: {predicted_label} ({confidence:.2f}%)")
+plt.show()

alexnet.py

@@ -0,0 +1,219 @@
+# ------------------------------------------------------
+# 1. Import Libraries
+# ------------------------------------------------------
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+import cv2
+from sklearn.model_selection import train_test_split
+from keras.preprocessing.image import ImageDataGenerator
+from keras.utils import to_categorical
+from keras.applications import MobileNetV2
+from keras.layers import Dense, GlobalAveragePooling2D, Dropout
+from keras.models import Model, load_model
+from keras.preprocessing import image
+from keras.applications.mobilenet_v2 import preprocess_input
+
+# ------------------------------------------------------
+# 2. Load Dataset
+# ------------------------------------------------------
+
+data_dir = 'dataset'  # <-- Replace with your dataset folder
+categories = os.listdir(data_dir)
+
+data = []
+for category in categories:
+    category_path = os.path.join(data_dir, category)
+    for img_name in os.listdir(category_path):
+        img_path = os.path.join(category_path, img_name)
+        data.append((img_path, category))
+
+data = pd.DataFrame(data, columns=['Filepath', 'Label'])
+
+print(f"Total samples: {len(data)}")
+print(data.head())
+
+# ------------------------------------------------------
+# 3. Exploratory Data Analysis (EDA)
+# ------------------------------------------------------
+
+# Class distribution
+plt.figure(figsize=(8,6))
+sns.countplot(x='Label', data=data)
+plt.title('Blood Group Class Distribution')
+plt.xticks(rotation=45)
+plt.show()
+
+# Display few images
+plt.figure(figsize=(12,8))
+for i in range(9):
+    sample = data.sample(n=1).iloc[0]
+    img = cv2.imread(sample['Filepath'])
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    plt.subplot(3,3,i+1)
+    plt.imshow(img)
+    plt.title(sample['Label'])
+    plt.axis('off')
+plt.tight_layout()
+plt.show()
+
+# ------------------------------------------------------
+# 4. Train-Validation-Test Split
+# ------------------------------------------------------
+
+train, temp = train_test_split(data, test_size=0.3, random_state=42, stratify=data['Label'])
+valid, test = train_test_split(temp, test_size=0.5, random_state=42, stratify=temp['Label'])
+
+print(f"Training samples: {len(train)}")
+print(f"Validation samples: {len(valid)}")
+print(f"Testing samples: {len(test)}")
+
+# ------------------------------------------------------
+# 5. Preprocessing (Image Augmentation + Scaling)
+# ------------------------------------------------------
+
+train_datagen = ImageDataGenerator(
+    preprocessing_function=preprocess_input,
+    rotation_range=20,
+    zoom_range=0.2,
+    width_shift_range=0.2,
+    height_shift_range=0.2,
+    shear_range=0.2,
+    horizontal_flip=True
+)
+
+valid_datagen = ImageDataGenerator(preprocessing_function=preprocess_input)
+
+target_size = (224, 224)
+
+train_gen = train_datagen.flow_from_dataframe(
+    dataframe=train,
+    x_col='Filepath',
+    y_col='Label',
+    target_size=target_size,
+    class_mode='categorical',
+    batch_size=32,
+    shuffle=True,
+    seed=42
+)
+
+valid_gen = valid_datagen.flow_from_dataframe(
+    dataframe=valid,
+    x_col='Filepath',
+    y_col='Label',
+    target_size=target_size,
+    class_mode='categorical',
+    batch_size=32,
+    shuffle=False
+)
+
+# ------------------------------------------------------
+# 6. Load MobileNetV2 Base Model
+# ------------------------------------------------------
+
+base_model = MobileNetV2(weights='imagenet', include_top=False, input_shape=(224,224,3))
+
+# ------------------------------------------------------
+# 7. Freeze Layers
+# ------------------------------------------------------
+
+for layer in base_model.layers:
+    layer.trainable = False
+
+# ------------------------------------------------------
+# 8. Add Custom Layers
+# ------------------------------------------------------
+
+x = base_model.output
+x = GlobalAveragePooling2D()(x)
+x = Dropout(0.3)(x)
+x = Dense(128, activation='relu')(x)
+x = Dropout(0.2)(x)
+predictions = Dense(len(categories), activation='softmax')(x)
+
+model = Model(inputs=base_model.input, outputs=predictions)
+
+# ------------------------------------------------------
+# 9. Compile and Train the Model
+# ------------------------------------------------------
+
+model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
+
+history = model.fit(
+    train_gen,
+    validation_data=valid_gen,
+    epochs=20
+)
+
+# ------------------------------------------------------
+# 10. Save the Model
+# ------------------------------------------------------
+
+model.save('bloodgroup_mobilenet_model.h5')
+print("Model saved as bloodgroup_mobilenet_model.h5")
+
+# ------------------------------------------------------
+# 11. Evaluate the Model
+# ------------------------------------------------------
+
+# Accuracy and Loss plots
+plt.figure(figsize=(14,5))
+
+plt.subplot(1,2,1)
+plt.plot(history.history['accuracy'], label='Train Accuracy')
+plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
+plt.title('Model Accuracy')
+plt.legend()
+
+plt.subplot(1,2,2)
+plt.plot(history.history['loss'], label='Train Loss')
+plt.plot(history.history['val_loss'], label='Validation Loss')
+plt.title('Model Loss')
+plt.legend()
+
+plt.show()
+
+# ------------------------------------------------------
+# 12. Prediction on Single Image (User Input)
+# ------------------------------------------------------
+
+import numpy as np
+import matplotlib.pyplot as plt
+from keras.models import load_model
+from keras.preprocessing import image
+from keras.applications.imagenet_utils import preprocess_input
+
+# Load the pre-t rained model
+model = load_model('bloodgroup_mobilenet_model.h5')
+
+# Define the class labels
+labels = {'A+': 0, 'A-': 1, 'AB+': 2, 'AB-': 3, 'B+': 4, 'B-': 5, 'O+': 6, 'O-': 7}
+labels = dict((v, k) for k, v in labels.items())
+
+# Example of loading a single image and making a prediction
+img_path = 'dataset/AB+/augmented_cluster_4_4.BMP'
+
+# Preprocess the image accordingly (check the model's expected input dimensions)
+img = image.load_img(img_path, target_size=(224, 224))  # Example target size for AlexNet (224x224)
+x = image.img_to_array(img)
+x = np.expand_dims(x, axis=0)
+x = preprocess_input(x)  # Ensure this matches the model's preprocessing function
+
+# Make prediction
+result = model.predict(x)
+predicted_class = np.argmax(result)  # Get the predicted class index
+
+# Map the predicted class to the label
+predicted_label = labels[predicted_class]
+confidence = result[0][predicted_class] * 100  # Confidence level
+
+# Display the image
+plt.imshow(image.array_to_img(image.img_to_array(img) / 255.0))
+plt.axis('off')  # Hide axes
+
+# Display the prediction and confidence below the image
+plt.title(f"Prediction: {predicted_label} with confidence {confidence:.2f}%")
+plt.show()

app.py

@@ -0,0 +1,137 @@
+# Import required libraries
+import streamlit as st
+import numpy as np
+import pandas as pd
+from keras.models import load_model
+from keras.preprocessing import image
+import os
+import matplotlib.pyplot as plt
+import random
+
+# Set page configuration FIRST
+st.set_page_config(page_title="Blood Group Detection", layout="wide")
+
+# Title of the app
+st.title("🩸 Blood Group Detection using LeNet Model")
+
+# Sidebar navigation
+st.sidebar.header("Navigation")
+selected_option = st.sidebar.selectbox(
+    "Select an option:",
+    ["Home", "EDA", "Predict Blood Group"]
+)
+
+# Load the trained model
+@st.cache_resource
+def load_trained_model():
+    model = load_model('bloodgroup_mobilenet_finetuned.h5')  # Ensure correct path
+    return model
+
+model = load_trained_model()
+
+# Define class labels
+class_names = ['A+', 'A-', 'B+', 'B-', 'AB+', 'AB-', 'O+', 'O-']
+
+# Dataset directory (you must adjust this if needed)
+DATASET_DIR = "dataset"  # Example path
+
+# Home page
+if selected_option == "Home":
+    st.subheader("About the Project")
+    st.write("""
+        Welcome to the Blood Group Detection App! 
+        
+        This application uses a Deep Learning model (LeNet architecture) to detect blood groups from blood sample images.
+        
+        ### 🛠 Technologies Used:
+        - Streamlit for Web UI
+        - TensorFlow/Keras for Deep Learning
+        - Image Processing with Computer Vision
+
+        **Upload a blood sample image and predict the blood group instantly!**
+    """)
+    try:
+        st.image("blood_home.jpg", caption="Blood Sample Analysis", use_column_width=True)
+    except:
+        st.warning("Home image not found. (Optional)")
+
+# EDA page
+elif selected_option == "EDA":
+    st.subheader("Exploratory Data Analysis (EDA)")
+
+    # Check if dataset exists
+    if os.path.exists(DATASET_DIR):
+        st.write("### 📊 Number of Images per Blood Group:")
+
+        counts = {}
+        for class_name in class_names:
+            class_path = os.path.join(DATASET_DIR, class_name)
+            if os.path.exists(class_path):
+                counts[class_name] = len(os.listdir(class_path))
+            else:
+                counts[class_name] = 0
+
+        df_counts = pd.DataFrame(list(counts.items()), columns=['Blood Group', 'Number of Images'])
+        st.dataframe(df_counts)
+
+        # Bar Chart
+        st.bar_chart(df_counts.set_index('Blood Group'))
+
+        st.write("### 🖼️ Sample Images from Each Class:")
+
+        cols = st.columns(4)  # create 4 columns
+
+        for idx, class_name in enumerate(class_names):
+            class_path = os.path.join(DATASET_DIR, class_name)
+            if os.path.exists(class_path) and len(os.listdir(class_path)) > 0:
+                img_file = random.choice(os.listdir(class_path))
+                img_path = os.path.join(class_path, img_file)
+                img = image.load_img(img_path, target_size=(64, 64))  # resized
+                with cols[idx % 4]:  # arrange in 4 columns
+                    st.image(img, caption=class_name, width=150)
+
+        st.write("### 🧩 Image Properties:")
+        sample_class = class_names[0]
+        sample_path = os.path.join(DATASET_DIR, sample_class, os.listdir(os.path.join(DATASET_DIR, sample_class))[0])
+        sample_img = image.load_img(sample_path)
+        st.write(f"- **Image shape:** {np.array(sample_img).shape}")
+        st.write(f"- **Color channels:** {np.array(sample_img).shape[-1]} (RGB)")
+
+    else:
+        st.warning("Dataset not found! Please make sure the 'dataset/train' folder exists.")
+
+# Prediction page
+elif selected_option == "Predict Blood Group":
+    st.subheader("Upload an Image to Predict Blood Group")
+
+    uploaded_file = st.file_uploader("Choose a blood sample image...", type=["jpg", "jpeg", "png", "bmp"])
+
+    if uploaded_file is not None:
+        # Display uploaded image
+        st.image(uploaded_file, caption="Uploaded Image", use_column_width=True)
+
+        # Ensure temp directory exists
+        if not os.path.exists('temp'):
+            os.makedirs('temp')
+
+        # Save uploaded file temporarily
+        temp_file_path = os.path.join("temp", uploaded_file.name)
+        with open(temp_file_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+
+        # Preprocess the image
+        img = image.load_img(temp_file_path, target_size=(224, 224))  # Adjust size if needed
+        img_array = image.img_to_array(img)
+        img_array = np.expand_dims(img_array, axis=0)
+        img_array = img_array / 255.0  # Normalize pixel values
+
+        # Predict the blood group
+        with st.spinner('Predicting...'):
+            prediction = model.predict(img_array)
+            predicted_class = class_names[np.argmax(prediction)]
+
+        # Show result
+        st.success(f"🧬 Predicted Blood Group: **{predicted_class}**")
+
+        # Remove temporary file
+        os.remove(temp_file_path)

best_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:430d170f8fb637cb7dbb5634502aad6c75800c59ee502e496de84e98e110d768
+size 11521400

lenet.py

@@ -0,0 +1,201 @@
+import os
+import glob
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from keras_preprocessing.image import ImageDataGenerator
+from keras.models import Sequential
+from keras.layers import Dense, Dropout, Conv2D, MaxPooling2D, Flatten
+from keras.applications import ResNet50
+from keras.applications.resnet50 import preprocess_input
+from sklearn.metrics import classification_report
+
+import zipfile
+import os
+
+# Define the file name
+zip_file = 'dataset.zip'
+
+# Unzip it to a folder (you can choose your own target directory)
+with zipfile.ZipFile(zip_file, 'r') as zip_ref:
+    zip_ref.extractall('blood_group_dataset')  # Extract to this folder
+
+
+
+# Walk through the directory
+for root, dirs, files in os.walk('blood_group_dataset'):
+    print(root)
+    for file in dirs:
+        print('  ', file)
+
+import os
+import glob
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+# Walk through the directory and collect file paths and labels
+filepaths = []
+labels = []
+
+for root, dirs, files in os.walk('blood_group_dataset'):
+    for dir in dirs:  # Iterate through subdirectories (blood group types)
+        for file in glob.glob(os.path.join(root, dir, '*')):  # Get all files in the subdirectory
+            filepaths.append(file)
+            labels.append(dir)  # Use the subdirectory name as the label
+
+# Create a DataFrame with file paths and labels
+filepath = pd.Series(filepaths, name='Filepath').astype(str)
+Labels = pd.Series(labels, name='Label')
+data = pd.concat([filepath, Labels], axis=1)
+data = data.sample(frac=1).reset_index(drop=True)
+
+
+# Filter out the 'dataset' label
+filtered_data = data[data['Label'] != 'dataset']  # Remove rows with 'dataset' label
+
+# Visualize class distribution using sns.barplot
+counts = filtered_data.Label.value_counts()
+sns.barplot(x=counts.index, y=counts)
+plt.xlabel('Blood Group Type')  # Changed x-axis label
+plt.ylabel('Number of Images')  # Added y-axis label
+plt.xticks(rotation=90)
+plt.title('Class Distribution in Blood Group Dataset')  # Added title
+plt.show()
+
+# Split data into training and testing sets
+train, test = train_test_split(data, test_size=0.20, random_state=42)
+
+# Visualize some images from the dataset
+fig, axes = plt.subplots(nrows=5, ncols=3, figsize=(10, 8), subplot_kw={'xticks': [], 'yticks': []})
+for i, ax in enumerate(axes.flat):
+    ax.imshow(plt.imread(data.Filepath[i]))
+    ax.set_title(data.Label[i])
+plt.tight_layout()
+plt.show()
+
+# Set up ImageDataGenerator for training and validation data
+train_datagen = ImageDataGenerator(preprocessing_function=preprocess_input)
+test_datagen = ImageDataGenerator(preprocessing_function=preprocess_input)
+
+train_gen = train_datagen.flow_from_dataframe(
+    dataframe=train,
+    x_col='Filepath',
+    y_col='Label',
+    target_size=(224, 224),  # Adjusted to match ResNet50 input size
+    class_mode='categorical',
+    batch_size=32,
+    shuffle=True,
+    seed=42
+)
+
+valid_gen = test_datagen.flow_from_dataframe(
+    dataframe=test,
+    x_col='Filepath',
+    y_col='Label',
+    target_size=(224, 224),  # Adjusted to match ResNet50 input size
+    class_mode='categorical',
+    batch_size=32,
+    shuffle=False,
+    seed=42
+)
+
+# Define the LeNet model
+model = Sequential([
+    Conv2D(6, kernel_size=(5, 5), activation='relu', input_shape=(224, 224, 3)),
+    MaxPooling2D(pool_size=(2, 2)),
+    Conv2D(16, kernel_size=(5, 5), activation='relu'),
+    MaxPooling2D(pool_size=(2, 2)),
+    Flatten(),
+    Dense(120, activation='relu'),
+    Dense(84, activation='relu'),
+    Dense(8, activation='softmax')
+])
+
+model.compile(
+    optimizer="adam",
+    loss='categorical_crossentropy',
+    metrics=['accuracy']
+)
+
+# Train the model
+history = model.fit(
+    train_gen,
+    validation_data=valid_gen,
+    epochs=20
+)
+
+# Plot training history: accuracy
+pd.DataFrame(history.history)[['accuracy', 'val_accuracy']].plot()
+plt.title("Accuracy")
+plt.show()
+
+# Plot training history: loss
+pd.DataFrame(history.history)[['loss', 'val_loss']].plot()
+plt.title("Loss")
+plt.show()
+
+# Evaluate the model on test data
+results = model.evaluate(valid_gen, verbose=0)
+print(f"Test Loss: {results[0]:.5f}")
+print(f"Test Accuracy: {results[1]*100:.2f}%")
+
+# Predict labels for test data
+pred = model.predict(valid_gen)
+pred = np.argmax(pred, axis=1)
+
+# Map predicted labels
+labels = train_gen.class_indices
+labels = dict((v, k) for k, v in labels.items())
+pred = [labels[k] for k in pred]
+
+# Compare predicted labels with true labels and print classification report
+# Get the true labels from the test DataFrame, ensuring they match the predictions in length
+y_test = list(test.Label)
+# Adjust y_test to match pred length
+y_test = y_test[:len(pred)]  # Truncate y_test to match pred length
+
+print(classification_report(y_test, pred))
+
+model.save("model_blood_group_detection_lenet.keras")
+
+import numpy as np
+import matplotlib.pyplot as plt
+from keras.models import load_model
+from keras.preprocessing import image
+from keras.applications.imagenet_utils import preprocess_input
+
+# Load the pre-t rained model
+model = load_model('model_blood_group_detection_lenet.keras')
+
+# Define the class labels
+labels = {'A+': 0, 'A-': 1, 'AB+': 2, 'AB-': 3, 'B+': 4, 'B-': 5, 'O+': 6, 'O-': 7}
+labels = dict((v, k) for k, v in labels.items())
+
+# Example of loading a single image and making a prediction
+img_path = 'augmented_cluster_4_3505.BMP'
+
+# Preprocess the image accordingly (check the model's expected input dimensions)
+img = image.load_img(img_path, target_size=(224, 224))  # Example target size for AlexNet (224x224)
+x = image.img_to_array(img)
+x = np.expand_dims(x, axis=0)
+x = preprocess_input(x)  # Ensure this matches the model's preprocessing function
+
+# Make prediction
+result = model.predict(x)
+predicted_class = np.argmax(result)  # Get the predicted class index
+
+# Map the predicted class to the label
+predicted_label = labels[predicted_class]
+confidence = result[0][predicted_class] * 100  # Confidence level
+
+# Display the image
+plt.imshow(image.array_to_img(image.img_to_array(img) / 255.0))
+plt.axis('off')  # Hide axes
+
+# Display the prediction and confidence below the image
+plt.title(f"Prediction: {predicted_label} with confidence {confidence:.2f}%")
+plt.show()
+

mobilevnet.py

@@ -0,0 +1,268 @@
+# ------------------------------------------------------
+# 1. Import Libraries
+# ------------------------------------------------------
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+import cv2
+import tensorflow as tf
+from sklearn.model_selection import train_test_split
+from keras.preprocessing.image import ImageDataGenerator
+from keras.utils import to_categorical
+from keras.applications import MobileNetV2
+from keras.layers import Dense, GlobalAveragePooling2D, Dropout
+from keras.models import Model, load_model
+from keras.preprocessing import image
+from keras.applications.mobilenet_v2 import preprocess_input
+from keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
+
+# ------------------------------------------------------
+# 2. Load Dataset
+# ------------------------------------------------------
+
+data_dir = 'dataset'  # <-- Replace with your dataset folder
+categories = os.listdir(data_dir)
+
+data = []
+for category in categories:
+    category_path = os.path.join(data_dir, category)
+    for img_name in os.listdir(category_path):
+        img_path = os.path.join(category_path, img_name)
+        data.append((img_path, category))
+
+data = pd.DataFrame(data, columns=['Filepath', 'Label'])
+
+print(f"Total samples: {len(data)}")
+print(data.head())
+
+# ------------------------------------------------------
+# 3. Exploratory Data Analysis (EDA)
+# ------------------------------------------------------
+
+# Class distribution
+plt.figure(figsize=(8,6))
+sns.countplot(x='Label', data=data)
+plt.title('Blood Group Class Distribution')
+plt.xticks(rotation=45)
+plt.show()
+
+# Display few images
+plt.figure(figsize=(12,8))
+for i in range(9):
+    sample = data.sample(n=1).iloc[0]
+    img = cv2.imread(sample['Filepath'])
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    plt.subplot(3,3,i+1)
+    plt.imshow(img)
+    plt.title(sample['Label'])
+    plt.axis('off')
+plt.tight_layout()
+plt.show()
+
+# ------------------------------------------------------
+# 4. Train-Validation-Test Split
+# ------------------------------------------------------
+
+train, temp = train_test_split(data, test_size=0.3, random_state=42, stratify=data['Label'])
+valid, test = train_test_split(temp, test_size=0.5, random_state=42, stratify=temp['Label'])
+
+print(f"Training samples: {len(train)}")
+print(f"Validation samples: {len(valid)}")
+print(f"Testing samples: {len(test)}")
+
+# ------------------------------------------------------
+# 5. Preprocessing (Image Augmentation + Scaling)
+# ------------------------------------------------------
+
+train_datagen = ImageDataGenerator(
+    preprocessing_function=preprocess_input,
+    rotation_range=20,
+    zoom_range=0.2,
+    width_shift_range=0.2,
+    height_shift_range=0.2,
+    shear_range=0.2,
+    horizontal_flip=True
+)
+
+valid_datagen = ImageDataGenerator(preprocessing_function=preprocess_input)
+
+target_size = (224, 224)
+
+train_gen = train_datagen.flow_from_dataframe(
+    dataframe=train,
+    x_col='Filepath',
+    y_col='Label',
+    target_size=target_size,
+    class_mode='categorical',
+    batch_size=32,
+    shuffle=True,
+    seed=42
+)
+
+valid_gen = valid_datagen.flow_from_dataframe(
+    dataframe=valid,
+    x_col='Filepath',
+    y_col='Label',
+    target_size=target_size,
+    class_mode='categorical',
+    batch_size=32,
+    shuffle=False
+)
+
+# ------------------------------------------------------
+# 6. Load MobileNetV2 Base Model
+# ------------------------------------------------------
+
+base_model = MobileNetV2(weights='imagenet', include_top=False, input_shape=(224,224,3))
+
+# ------------------------------------------------------
+# 7. Freeze Base Layers
+# ------------------------------------------------------
+
+for layer in base_model.layers:
+    layer.trainable = False
+
+# ------------------------------------------------------
+# 8. Define Function to Build Model (for tuning)
+# ------------------------------------------------------
+
+def build_model(dropout_rate=0.3, learning_rate=0.001):
+    x = base_model.output
+    x = GlobalAveragePooling2D()(x)
+    x = Dropout(dropout_rate)(x)
+    x = Dense(128, activation='relu')(x)
+    x = Dropout(dropout_rate)(x)
+    predictions = Dense(len(categories), activation='softmax')(x)
+
+    model = Model(inputs=base_model.input, outputs=predictions)
+
+    optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
+    model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'])
+    
+    return model
+
+# ------------------------------------------------------
+# 9. Hyperparameter Tuning (Manual)
+# ------------------------------------------------------
+
+dropout_rates = [0.3, 0.4]
+learning_rates = [0.001, 0.0005]
+
+best_val_accuracy = 0
+best_model = None
+best_params = {}
+
+for dr in dropout_rates:
+    for lr in learning_rates:
+        print(f"\nTraining with Dropout: {dr}, Learning Rate: {lr}")
+
+        model = build_model(dropout_rate=dr, learning_rate=lr)
+
+        callbacks = [
+            EarlyStopping(monitor='val_accuracy', patience=5, restore_best_weights=True),
+            ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=3, verbose=1),
+            ModelCheckpoint('best_model.h5', monitor='val_accuracy', save_best_only=True, verbose=1)
+        ]
+
+        history = model.fit(
+            train_gen,
+            validation_data=valid_gen,
+            epochs=20,
+            callbacks=callbacks,
+            verbose=1
+        )
+
+        val_acc = max(history.history['val_accuracy'])
+        print(f"Validation Accuracy: {val_acc:.4f}")
+
+        if val_acc > best_val_accuracy:
+            best_val_accuracy = val_acc
+            best_model = model
+            best_params = {'dropout_rate': dr, 'learning_rate': lr}
+
+print("\nBest Parameters:", best_params)
+print(f"Best Validation Accuracy: {best_val_accuracy:.4f}")
+
+# ------------------------------------------------------
+# 10. Fine-tuning (Unfreeze some base layers)
+# ------------------------------------------------------
+
+# Unfreeze last 30 layers for fine-tuning
+for layer in base_model.layers[-30:]:
+    layer.trainable = True
+
+# Recompile
+optimizer = tf.keras.optimizers.Adam(learning_rate=best_params['learning_rate'] / 10)
+best_model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'])
+
+# Train again
+history_finetune = best_model.fit(
+    train_gen,
+    validation_data=valid_gen,
+    epochs=10,
+    callbacks=[
+        EarlyStopping(monitor='val_accuracy', patience=5, restore_best_weights=True),
+        ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=3, verbose=1)
+    ],
+    verbose=1
+)
+
+# ------------------------------------------------------
+# 11. Save the Final Model
+# ------------------------------------------------------
+
+best_model.save('bloodgroup_mobilenet_finetuned.h5')
+print("Fine-tuned model saved as bloodgroup_mobilenet_finetuned.h5")
+
+# ------------------------------------------------------
+# 12. Evaluate the Final Model
+# ------------------------------------------------------
+
+# Accuracy and Loss plots
+plt.figure(figsize=(14,5))
+
+plt.subplot(1,2,1)
+plt.plot(history_finetune.history['accuracy'], label='Fine-tuned Train Accuracy')
+plt.plot(history_finetune.history['val_accuracy'], label='Fine-tuned Validation Accuracy')
+plt.title('Fine-tuned Model Accuracy')
+plt.legend()
+
+plt.subplot(1,2,2)
+plt.plot(history_finetune.history['loss'], label='Fine-tuned Train Loss')
+plt.plot(history_finetune.history['val_loss'], label='Fine-tuned Validation Loss')
+plt.title('Fine-tuned Model Loss')
+plt.legend()
+
+plt.show()
+
+# ------------------------------------------------------
+# 13. Prediction on Single Image (User Input)
+# ------------------------------------------------------
+
+# Load the fine-tuned model
+model = load_model('bloodgroup_mobilenet_finetuned.h5')
+
+# Define the class labels
+labels = {'A+': 0, 'A-': 1, 'AB+': 2, 'AB-': 3, 'B+': 4, 'B-': 5, 'O+': 6, 'O-': 7}
+labels = dict((v, k) for k, v in labels.items())
+
+# Example: Single image prediction
+img_path = 'dataset/AB+/augmented_cluster_4_4.BMP'
+
+img = image.load_img(img_path, target_size=(224, 224))
+x = image.img_to_array(img)
+x = np.expand_dims(x, axis=0)
+x = preprocess_input(x)
+
+result = model.predict(x)
+predicted_class = np.argmax(result)
+predicted_label = labels[predicted_class]
+confidence = result[0][predicted_class] * 100
+
+plt.imshow(image.array_to_img(image.img_to_array(img)/255.0))
+plt.axis('off')
+plt.title(f"Prediction: {predicted_label} with confidence {confidence:.2f}%")
+plt.show()