file updated

boneage_web.py

@@ -0,0 +1,219 @@
+import streamlit as st 
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image,ImageOps
+import numpy as np
+import random
+import cv2
+import tensorflow as tf
+from tensorflow import keras
+from keras.models import load_model
+
+import time 
+# import mysql.connector
+
+import process_input_pipeline as pp
+import img_extractor
+from process_input_pipeline import ImageResizer, ContrastEnhancer
+
+# added for inception concat
+from sklearn.pipeline import make_pipeline
+from sklearn.base import BaseEstimator, TransformerMixin
+
+import combined_model
+
+cm = combined_model.build_regression_model()
+cm.load_weights(r"F:\python\web_streamlit\ALL_IN_ONE\model_weights\model_weights\combined_weights_7_epoch_third_acc.h5")
+######################################################
+roi=img_extractor.RoiExtractor()
+
+# Connect to MySQL
+# conn = mysql.connector.connect(
+#     host="localhost",
+#     user = "root",
+#     password = "",
+#     database = "FeedbackCollection"
+# )
+# try:
+#     if conn.is_connected:
+#         #create cursor
+#         cursor = conn.cursor()
+
+#         #Create feedback table if not exits
+#         cursor.execute('''CREATE TABLE IF NOT EXISTS feedback(
+#                        id INT AUTO_INCREMENT PRIMARY KEY,
+#                        name VARCHAR(255),
+#                        feedback_type VARCHAR(255),
+#                        feedback_message TEXT
+#         )''')
+
+#         conn.commit()
+# except mysql.connector.Error as e:
+#     st.error(f"Error connecting to MySQL: {e}")
+
+    
+# from sklearn.metrics import mean_absolute_error
+
+# Hide the Streamlit style, including the "Deploy" widget
+# st.set_page_config(hide_streamlit_style=True)
+
+# Sidebar: Navigation
+st.sidebar.header('Navigation')
+
+page = st.sidebar.selectbox('Select',
+                       ['Learn About Bone Age',
+                        'Bone Age Predictor',
+                        'Resources', 'Feedback Form'])
+
+# # Education page
+if page == 'Learn About Bone Age':
+    st.title('About Bone Age')
+
+    expander = st.expander('What is bone age?')
+    expander.write("'Bone age is an interpretation of skeletal maturity, typically based on radiographs of the left hand and wrist or knee, that has provided useful information in various clinical settings for over 75 years.' (Creo AL, Schwenk WF. Bone age: a handy tool for pediatric providers. Pediatrics. 2017;140(6).)")
+    '\n'
+    expander = st.expander('What are current methods of determining bone age?')
+    expander.write("""
+                   * Tanner-White method: ...
+                   * Greulich-Pyle method: ...
+                   """)
+    '\n'
+    expander = st.expander('What are some clinical uses for bone age?')
+    expander.write("""
+                   * Diagnosing certain growth (endocrinologic) conditions
+                   * Determining which patients would benefit from treatment
+                   * Monitoring treatment
+                   * Predicting adult height
+                   """)
+    '\n'
+    expander = st.expander('What are some non-clinical uses for bone age?')
+    expander.write("""
+                   * Athletics
+                   * Forensics
+                   * Legal/policy
+                   """)
+
+#Bone age prediction
+# @st.cache_data
+# def get_model(model_path):
+#     try:
+#         model=load_model(model_path)
+#         return model 
+#     except Exception as e:
+#         st.error(f"Error loading the model: {e}")
+#         return None
+
+#load the model
+# model = get_model(r'F:\python\web_streamlit\ALL_IN_ONE\combined_weights_10_epoch_fourth_normalaize_1.h5')
+
+# Function for processing image
+def process_image(img, img_size=(224, 224)):
+    try:
+        # image = ImageOps.fit(img, img_size)
+        # image = np.asarray(image)
+        # img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        # img_resize = preprocess_input(img)
+        # img_data = img_resize[np.newaxis,...]
+
+        # image_pipeline = make_pipeline(
+        #         ImageResizer(),
+        #         ContrastEnhancer()
+        # )
+
+        # img_data = image_pipeline.make_pipeline(img)
+        new_size=(299,299)
+        resized_img = img.resize(new_size, Image.BICUBIC)
+        img_array=np.array(resized_img)
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(64, 64))
+        cl1 = clahe.apply(img_array)
+        cl2=cv2.cvtColor(cl1,cv2.COLOR_GRAY2BGR)
+        return cl2
+    except Exception as e:
+        st.error(f"Error processing image: {e}")
+        return None 
+    
+
+# Function for returning prediction
+def predict(img_data_c,img_data_m, gender):
+    try:
+        if gender == 'Female':
+            # gender_input = np.array([0])
+            gender_input=0
+        elif gender == 'Male':
+            gender_input = 1
+
+
+        pred =cm.predict([np.array([img_data_c]),np.array([img_data_m]), np.array([gender_input])])
+        # pred = model.predict(img_data)
+        return pred
+    except Exception as e:
+        st.error(f"Error predicting bone age: {e}")
+        return None
+
+if page == 'Bone Age Predictor':
+    
+    st.title('Bone Age Prediction')
+
+
+    # Define accepted file formats
+    accepted_formats = ("jpg", "jpeg", "png", "gif")
+
+    # Upload image
+    uploaded_file = st.file_uploader('Upload an image', type=accepted_formats)
+    if uploaded_file is not None:
+        # Adding progress bar
+        progress_bar = st.progress(0) 
+
+        with st.spinner("Uploading..."):
+            for i in range(100):
+                time.sleep(0.1)
+                progress_bar.progress(i+1)
+                
+        st.success("Upload Complete")
+
+        img = Image.open(uploaded_file)
+        st.image(img, caption='Uploaded image', use_column_width=True)
+
+        '\n'
+        gender = st.radio('Sex:', ('Male', 'Female'))
+        '\n'
+        
+        if st.button('Predict bone age'):
+            st.write("Predicted Bone age is : ")
+            img_data = process_image(img)
+
+            # roi=img_extractor.RoiExtractor()
+            roi.process_img(img_data)
+
+            
+            boneage = predict(roi.carpal_img,roi.metacarpal_img,gender)[0][0]
+            print(boneage)
+            # boneage=round(boneage,1)
+            st.write(boneage,'months')
+
+
+if page == 'Resources':
+    st.title('Resources')
+
+if page == "Feedback Form":
+    st.title("Feedback Form")
+
+    name = st.text_input("Name: ")
+
+    feedback_type = st.selectbox("Feedback Type: ",["General","Bug Report","Features"])
+
+    feedback_message = st.text_area("Feedback Message:","")
+
+    if st.button("Submit Feedback"):
+        #Insert feedback into the database
+        # cursor.execute('''INSERT INTO feedback (name,feedback_type,feedback_message) VALUES (%s,%s,%s)''',(name,feedback_type,feedback_message))
+
+        # conn.commit()
+        st.success("Feedback Submitted")
+
+
+# cursor.close()
+# conn.close()
+
+ 

combined_model.py

@@ -0,0 +1,47 @@
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Conv2D
+from keras.layers import MaxPooling2D
+from keras.layers import Concatenate
+from keras.utils import plot_model
+import tensorflow as tf
+from keras.layers import GlobalAveragePooling2D, GlobalMaxPooling2D, Reshape, Dense, Input, Flatten, Dropout
+from keras.layers import Activation, Concatenate, Conv2D, Multiply
+from keras.applications.resnet import ResNet50
+import keras
+from keras.applications.inception_v3 import preprocess_input
+from updated_resnet_1 import ResNet50
+
+def build_regression_model():
+    base_model_carpal = ResNet50(input_shape = (224, 224, 3))
+    base_model_carpal.load_weights(r'F:\python\web_streamlit\ALL_IN_ONE\model_weights\model_weights\resnet\carpal_weights_30_epoch_wd_2.h5')
+    
+    base_model_metacarpal = ResNet50(input_shape = (224, 224, 3))
+    base_model_metacarpal.load_weights(r'F:\python\web_streamlit\ALL_IN_ONE\model_weights\model_weights\resnet\metacarpal_weights_30_epoch_wd_2.h5')
+    
+    gender_input = Input(shape=(1,), name='gender_input')
+    for layer in base_model_carpal.layers:
+        layer._name = 'carpal_' + layer.name
+    for layer in base_model_metacarpal.layers:
+        layer._name = 'metacarpal_' + layer.name
+
+    for layer in base_model_carpal.layers[:-9]:
+        layer.trainable = False
+    for layer in base_model_metacarpal.layers[:-9]:
+        layer.trainable = False
+
+    x1 = base_model_carpal.layers[-4].output
+    x2 = base_model_metacarpal.layers[-4].output
+
+    # gender_weight = tf.Variable(initial_value=1.0, trainable=True, name='gender_weight')
+    # gender_input_weighted = tf.multiply(gender_input, gender_weight)
+    x = Concatenate()([x1, x2, gender_input])
+
+    x = Dense(128, activation='relu')(x)
+    x = Dense(64, activation='relu')(x)
+    x = Dense(32, activation='relu')(x)
+    predictions = Dense(1)(x) 
+
+    model = Model(inputs=(base_model_carpal.input, base_model_metacarpal.input, gender_input), outputs=predictions)
+
+    return model

enhance_image.py

@@ -0,0 +1,35 @@
+''' his program Enhance the images Using 'CLAHE'
+    C-Contrast
+    L-Limited
+    A-Adaptive
+    H-Histogram
+    E-Equalization
+'''
+import cv2
+
+def enhance_img(path1, path2, df):
+    '''
+    Reads image and enhances contrast using OpenCV
+    
+    Parameters
+    ----------
+    path1: directory where images are stored
+    path2: directory where enhanced images will be stored
+    df: dataframe
+
+    Returns
+    ----------
+    Contrast-enhanced image
+    '''
+    # Create list of filenames of training images
+    filenames = list(df['filename'])
+
+    # Iterate through each filename
+    for filename in filenames:
+        # Open & enhance images
+        img = cv2.imread(path1 + filename, 0)
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(64, 64))
+        cl1 = clahe.apply(img)
+        
+        # Save the contrast-enhanced image
+        cv2.imwrite(path2 + filename, cl1)

img_extractor.py

@@ -0,0 +1,167 @@
+import cv2
+import matplotlib.pyplot as plt
+from PIL import Image
+from sklearn.pipeline import make_pipeline
+from sklearn.base import BaseEstimator, TransformerMixin
+import cv2
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import Conv2D
+from keras.layers import MaxPooling2D
+from keras.layers import Concatenate
+from keras.utils import plot_model
+import tensorflow as tf
+from keras.layers import GlobalAveragePooling2D, GlobalMaxPooling2D, Reshape, Dense, Input, Flatten, Dropout
+from keras.layers import Activation, Concatenate, Conv2D, Multiply
+from keras.applications.inception_v3 import InceptionV3
+import keras
+from keras.applications.inception_v3 import preprocess_input
+import tensorflow as tf
+from keras import layers
+from sklearn.model_selection import train_test_split
+import pandas as pd
+
+import numpy as np
+
+class RoiExtractor:
+    def __init__(self):
+        # Model initialization
+        self.model = build_image_model()
+        self.model.load_weights(r"F:\python\web_streamlit\ALL_IN_ONE\model_weights\model_weights\inception\best_final_5.h5")
+        self.heatmap_model = Model(inputs=self.model.inputs, outputs=self.model.layers[-3].output)
+
+        # Outputs
+        self.heatmap_1 = None
+        self.carpal_img = None
+        
+        self.heatmap_2 = None
+        self.metacarpal_img = None
+        
+        self.img = None
+        self.masked_img = None
+
+    def generate_heatmap(self, img):
+        
+        # Preprocessing
+        i = preprocess_input(img)
+        preprocessed_img = np.expand_dims(i, axis=0)
+
+        cbam_output = self.heatmap_model.predict(preprocessed_img)[0]
+
+        #Heatmap generation
+        heatmap = np.sum(cbam_output, axis=-1)
+        heatmap = (heatmap - np.min(heatmap)) / (np.max(heatmap) - np.min(heatmap))
+        upsampled_heatmap = cv2.resize(heatmap, (299, 299))
+        return upsampled_heatmap
+
+
+    def get_bounding_box(self, heatmap, threshold=0.7):
+        binary_mask = (heatmap > threshold).astype(np.uint8)
+        non_zero_indices = np.nonzero(binary_mask)
+        if len(non_zero_indices[0]) == 0 or len(non_zero_indices[1]) == 0:
+            return None
+        min_row, min_col = np.min(non_zero_indices[0]), np.min(non_zero_indices[1])
+        max_row, max_col = np.max(non_zero_indices[0]), np.max(non_zero_indices[1])
+
+        bounding_box ={
+            'min_row': min_row,
+            'min_col': min_col,
+            'max_row': max_row,
+            'max_col': max_col
+        }
+        return bounding_box
+
+
+    def crop_image_by_bounding_box(self, image, bounding_box):
+        min_row, min_col = bounding_box['min_row'], bounding_box['min_col']
+        max_row, max_col = bounding_box['max_row'], bounding_box['max_col']
+        cropped_image = image[min_row:max_row + 1, min_col:max_col + 1, :]
+        cropped_resized = cv2.resize(cropped_image, (224, 224))
+        return cropped_resized
+
+
+    def apply_black_rectangle_by_bounding_box(self, image, bounding_box):
+        min_row, min_col = bounding_box['min_row'], bounding_box['min_col']
+        max_row, max_col = 299, bounding_box['max_col']
+        test_img = image.copy()
+        test_img = cv2.rectangle(test_img, (min_col, min_row), (max_col, max_row), (0, 0, 0), thickness=cv2.FILLED)
+        return test_img
+
+    
+    def process_img(self, img): 
+        self.img = img
+        self.heatmap_1 = self.generate_heatmap(img)
+        bounding_box_1 = self.get_bounding_box(self.heatmap_1)
+        self.carpal_img = self.crop_image_by_bounding_box(img, bounding_box_1)
+        self.masked_img = self.apply_black_rectangle_by_bounding_box(img, bounding_box_1)
+        self.heatmap_2 = self.generate_heatmap(self.masked_img)
+        bounding_box_2 = self.get_bounding_box(self.heatmap_2)
+        self.metacarpal_img = self.crop_image_by_bounding_box(img, bounding_box_2)
+    
+
+# Channel Attention Module
+def channel_attention_module(x, ratio=8):
+
+    batch,_,_,channel=x.shape
+    # shared layers
+    l1 = Dense(channel//ratio, activation="relu", use_bias=False)
+    l2 = Dense(channel, use_bias= False)
+
+    x1 = GlobalAveragePooling2D()(x)
+    x1 = Flatten()(x1)
+    x1 = l1(x1)
+    x1 = l2(x1)
+
+    x2 = GlobalMaxPooling2D()(x)
+    x2 = Flatten()(x2)
+    x2 = l1(x2)
+    x2 = l2(x2)
+
+    feats = x1 + x2
+    feats = Activation("sigmoid")(feats)
+    feats = Multiply()([x,feats])
+
+    return feats
+
+# spatical attention module
+
+def spatial_attention_module(x):
+    # Average Pooling
+    x1 = tf.reduce_mean(x,axis = -1)
+    x1 = tf.expand_dims(x1,axis = -1)
+
+    # max pooling
+    x2 = tf.reduce_max(x, axis = -1)
+    x2 = tf.expand_dims(x2,axis=-1)
+
+    feats = Concatenate()([x1,x2])
+
+    feats = Conv2D(1,kernel_size=7, padding="same",activation="softmax")(feats)
+    feats = Multiply()([x,feats])
+
+    return feats
+
+# Cbam module
+def cbam(x):
+    x = channel_attention_module(x)
+    x = spatial_attention_module(x)
+
+    return x
+
+
+def build_image_model():
+    base_model = InceptionV3(
+        weights='imagenet',
+        include_top=False,
+        input_shape=(299,299,3)
+    )
+    for layer in base_model.layers:
+        layer.trainable = False
+    x = cbam(base_model.output)
+
+    x= GlobalAveragePooling2D()(x)
+    predictions = Dense(1, activation='sigmoid')(x)
+
+    model = Model(inputs=base_model.input, outputs=predictions)
+
+    return model

inception_v3_cbam_arch.py

@@ -0,0 +1,213 @@
+#importing libraries
+from keras.models import Model
+from keras.layers import Input
+from keras.layers import MaxPooling2D
+from keras.utils import plot_model
+from keras.layers import BatchNormalization
+from keras.layers import AveragePooling2D
+import tensorflow as tf
+from keras.layers import GlobalAveragePooling2D, GlobalMaxPooling2D, Reshape, Dense, Input
+from keras.layers import Activation, Concatenate, Conv2D, Multiply
+
+
+Img_input = Input(shape= (299,299,3))
+channel_axis = 3
+
+# In inception v3 architecture, Every convolutin layer had batch normalization and relu activation function
+def conv2d_bn(x, filters, num_row, num_col, padding='same', strides=(1,1)):
+    x=Conv2D(filters, (num_row, num_col), strides=strides, padding=padding)(x)
+    x=BatchNormalization(axis=3, scale=False)(x)
+    x=Activation('relu')(x)
+    return x
+
+#Inception Block-A
+def inc_block_a(x):
+    branch1x1 = conv2d_bn(x,64,1,1)
+    
+    branch3x3 = conv2d_bn(x,48,1,1)
+    branch3x3 = conv2d_bn(branch3x3,64,3,3)
+    
+    branch3x3db1 = conv2d_bn(x,64,1,1)
+    branch3x3db1 = conv2d_bn(branch3x3db1,96,3,3)
+    branch3x3db1 = conv2d_bn(branch3x3db1,96,3,3)
+    
+    branch_pool = AveragePooling2D((3,3), strides=(1,1), padding='same')(x)
+    branch_pool = conv2d_bn(branch_pool,32,1,1)
+    
+    x = Concatenate(axis= channel_axis)([branch1x1,branch3x3,branch3x3db1,branch_pool])
+    return x
+
+#Reduction Block-A
+def reduction_block_a(x):
+    branch3x3 = conv2d_bn(x,384,3,3,strides=(2,2),padding='valid')
+    
+    branch3x3db1 = conv2d_bn(x,64,1,1)
+    branch3x3db1 = conv2d_bn(branch3x3db1,96,3,3)
+    branch3x3db1 = conv2d_bn(branch3x3db1, 96,3,3,strides=(2,2),padding='valid')
+    
+    branch_pool = MaxPooling2D((3,3),strides=(2,2))(x)
+    
+    x=Concatenate(axis=channel_axis)([branch3x3,branch3x3db1,branch_pool])
+    
+    return x
+
+#Inception Block-B
+def inc_block_b(x):
+    branch1x1 = conv2d_bn(x,192,1,1)
+    
+    branch7x7 = conv2d_bn(x,128,1,1)
+    branch7x7 = conv2d_bn(branch7x7,128,1,7)
+    branch7x7 = conv2d_bn(branch7x7,192,7,1)
+    
+    branch7x7db1 = conv2d_bn(x,128,1,1)
+    branch7x7db1 = conv2d_bn(branch7x7db1,128,7,1)
+    branch7x7db1 = conv2d_bn(branch7x7db1,128,1,7)  
+    branch7x7db1 = conv2d_bn(branch7x7db1,128,7,1) 
+    branch7x7db1 = conv2d_bn(branch7x7db1,192,1,7) 
+    
+    branch_pool = AveragePooling2D((3,3),strides=(1,1),padding='same')(x)
+    branch_pool = conv2d_bn(branch_pool,192,1,1)
+    
+    x = Concatenate(axis = channel_axis)([branch1x1,branch7x7,branch7x7db1,branch_pool])
+    
+    return x
+
+#Reduction Block-B
+def reduction_block_b(x):
+    branch3x3 = conv2d_bn(x,192,1,1)
+    branch3x3 = conv2d_bn(branch3x3, 320,3,3,strides=(2,2),padding='valid')
+    
+    branch7x7x3 = conv2d_bn(x,192,1,1)
+    branch7x7x3 = conv2d_bn(branch7x7x3,192,1,7)
+    branch7x7x3 = conv2d_bn(branch7x7x3,192,7,1)
+    branch7x7x3 = conv2d_bn(branch7x7x3,192,3,3,strides=(2,2),padding='valid')
+    
+    branch_pool = MaxPooling2D((3,3),strides=(2,2))(x)
+    
+    x = Concatenate( axis=channel_axis)([branch3x3,branch7x7x3,branch_pool])
+    
+    return x
+
+#Inception Block-C
+def inc_block_c(x):
+    branch1x1 = conv2d_bn(x,320,1,1)
+    
+    branch3x3 = conv2d_bn(x,384,1,1)
+    branch3x3_1 = conv2d_bn(branch3x3,384,1,3)
+    branch3x3_2 = conv2d_bn(branch3x3,384,3,1)
+    branch3x3 = Concatenate(axis=channel_axis)([branch3x3_1,branch3x3_2])
+    
+    branch3x3db1 = conv2d_bn(x,448,1,1)
+    branch3x3db1 = conv2d_bn(branch3x3db1,384,3,3)
+    branch3x3db1_1 = conv2d_bn(branch3x3db1,384,1,3)
+    branch3x3db1_2 = conv2d_bn(branch3x3db1,384,3,1)
+    branch3x3db1 = Concatenate(axis= channel_axis)([branch3x3db1_1,branch3x3db1_2])
+    
+    branch_pool = AveragePooling2D((3,3),strides=(1,1),padding='same')(x)
+    branch_pool = conv2d_bn(branch_pool,192,1,1)
+    
+    x= Concatenate(axis=channel_axis)([branch1x1, branch3x3, branch3x3db1,branch_pool])
+    
+    return x
+
+
+# Channel Attention Module
+# Channel Attention Module
+def channel_attention_module(x, ratio=8):
+    batch,_,_,channel=x.shape
+    # shared layers
+    l1 = Dense(channel//ratio, activation="relu", use_bias=False)
+    l2 = Dense(channel, use_bias= False)
+    
+    x1 = GlobalAveragePooling2D()(x)
+    x1 = l1(x1)
+    x1 = l2(x1)
+    
+    x2 = GlobalMaxPooling2D()(x)
+    x2 = l1(x2)
+    x2 = l2(x2)
+    
+    feats = x1 + x2
+    feats = Activation("sigmoid")(feats)
+    feats = Multiply()([x,feats])
+    
+    return feats
+
+# Spatial Attention Module
+# spatical attention module
+
+def spatial_attention_module(x):
+    # Average Pooling
+    x1 = tf.reduce_mean(x,axis = -1)
+    x1 = tf.expand_dims(x1,axis = -1)
+    
+    # max pooling
+    x2 = tf.reduce_max(x, axis = -1)
+    x2 = tf.expand_dims(x2,axis=-1)
+    
+    feats = Concatenate()([x1,x2])
+    
+    feats = Conv2D(1,kernel_size=7, padding="same",activation="sigmoid")(feats)
+    feats = Multiply()([x,feats])
+    
+    return feats
+
+# CBAM (Convolutional Block Attention Mechanism) Modules
+def cbam(x):
+    x = channel_attention_module(x)
+    x = spatial_attention_module(x)
+    
+    return x
+
+# Building model layer by layer integrating CBAM
+def inception_cbam_model(Img_input):
+    x = conv2d_bn(Img_input, 32,3,3,strides=(2,2),padding='valid')
+    x = conv2d_bn(x,32,3,3,padding='valid')
+    x = conv2d_bn(x,64,3,3)
+    x = MaxPooling2D((3,3), strides=(2,2))(x)
+
+    x = conv2d_bn(x,80,1,1,padding='valid')
+    x = conv2d_bn(x,192,3,3,padding='valid')
+    x=MaxPooling2D((3,3),strides=(2,2))(x)
+
+    x = inc_block_a(x)
+    x = inc_block_a(x)
+    x = inc_block_a(x)
+
+    x = reduction_block_a(x)
+
+    x = inc_block_b(x)
+    x = inc_block_b(x)
+    x = inc_block_b(x)
+    x = inc_block_b(x)
+
+    x = reduction_block_b(x)
+
+    x = inc_block_c(x)
+    x = inc_block_c(x)
+
+    x = AveragePooling2D()(x)
+    
+    base_model = x
+
+    model = cbam(base_model)
+    
+    # Add additional layers 
+#     model.add(layers.Flatten())
+#     model.add(layers.Dense(256, activation='relu'))
+#     model.add(layers.Dropout(0.5))
+#     model.add(layers.Dense(1, activation='linear'))  # regression task for bone age
+    # create model
+    inputs = Img_input
+    model = Model(inputs,model,name='inception_v3')
+    
+    return model
+
+image_model = inception_cbam_model(Img_input)
+print(image_model.summary())
+
+# Compile the model
+image_model.compile(optimizer='adam', loss='mean_squared_error', metrics=['mae'])
+
+
+

process_input_pipeline.py

@@ -0,0 +1,45 @@
+from sklearn.pipeline import make_pipeline
+from sklearn.base import BaseEstimator, TransformerMixin
+import cv2
+
+# Define custom transformers for image processing steps
+class ImageResizer(BaseEstimator, TransformerMixin):
+    def __init__(self, target_size=(299, 299)):
+        self.target_size = target_size
+
+    def fit(self, X, y=None):
+        return self
+
+    def transform(self, X):
+        resized_images = [cv2.resize(img, self.target_size) for img in X]
+        return resized_images
+
+class ContrastEnhancer(BaseEstimator, TransformerMixin):
+    def __init__(self, clip_limit=2.0, tile_grid_size=(8, 8)):
+        self.clip_limit = clip_limit
+        self.tile_grid_size = tile_grid_size
+
+    def fit(self, X, y=None):
+        return self
+
+    def transform(self, X):
+        enhanced_images = [self._enhance_contrast(img) for img in X]
+        return enhanced_images
+
+    def _enhance_contrast(self, image):
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        clahe = cv2.createCLAHE(clipLimit=self.clip_limit, tileGridSize=self.tile_grid_size)
+        enhanced = clahe.apply(gray)
+        return cv2.cvtColor(enhanced, cv2.COLOR_GRAY2BGR)
+
+# Define the pipeline
+    
+# image_pipeline = make_pipeline(
+#     ImageResizer(),
+#     ContrastEnhancer()
+# )
+
+# Example usage
+# uploaded_image = cv2.imread()  # Load uploaded image
+# enhanced_image = image_pipeline.transform([uploaded_image])[0]  # Apply pipeline
+

resize_image_inception.py

@@ -0,0 +1,35 @@
+# This Program Resize the image into shape (299,299)
+
+from PIL import Image
+import os
+
+def resize_images(input_folder, output_folder, new_size=(224, 224)):
+    # check whether the output folder exists ?
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    # Loop through all files in the input folder
+    for filename in os.listdir(input_folder):
+        # Check if the file is a valid image file
+        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp')):
+            input_path = os.path.join(input_folder, filename)
+            output_path = os.path.join(output_folder, filename)
+
+            # Open and resize the image
+            with Image.open(input_path) as img:
+                resized_img = img.resize(new_size, Image.BICUBIC)
+
+                # Save the resized image to the output folder
+                resized_img.save(output_path)
+
+
+if __name__ == "__main__":
+    # Specify the input and output folders
+    input_folder = "D:/dataset/boneage-test-dataset/boneage-validation-dataset/"
+    output_folder = "D:/dataset/resize_image/boneage-validation-dataset/"
+
+    # Specify the new size for the images
+    new_size = (299,299)
+
+    # Resize the images in the input folder and save them to the output folder
+    resize_images(input_folder, output_folder, new_size)

resnet50_arch.py

@@ -0,0 +1,182 @@
+import numpy as np 
+import pandas as pd 
+import matplotlib.pyplot as plt
+import os
+import tensorflow as tf
+import numpy as np
+from keras import layers
+from keras.layers import Input, Add, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D, AveragePooling2D, MaxPooling2D, GlobalMaxPooling2D
+from keras.models import Model, load_model
+from keras.preprocessing import image
+from keras.applications.imagenet_utils import preprocess_input
+from keras.utils import plot_model
+from matplotlib.pyplot import imshow
+from keras.layers import Input, Add, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D, AveragePooling2D, MaxPooling2D, GlobalMaxPooling2D
+
+# x is input, y=F(x)
+# identity block simply means input should be equal to output. 
+#  y = x + F(x)   the layers in a traditional network are learning the true output H(x)
+# F(x) = y - x   the layers in a residual network are learning the residual F(x)
+# Hence, the name: Residual Block.
+
+
+
+def identity_block(X, f, filters, stage, block):
+
+    """
+    Arguments:
+    X -- input of shape (m, height, width, channel)
+    f -- shape of the middle CONV's window for the main path
+    filters -- python list of integers, defining the number of filters in the CONV layers of the main path
+    stage -- integer, used to name the layers, depending on their position in the network
+    block -- string/character, used to name the layers, depending on their position in the network
+    
+    Returns:
+    X -- output of the identity block, tensor of shape (n_H, n_W, n_C)
+    """
+    
+    # defining name basis
+    conv_name_base = 'res' + str(stage) + block + '_branch'
+    bn_name_base = 'bn' + str(stage) + block + '_branch'
+    
+    # Retrieve Filters
+    F1, F2, F3 = filters
+    
+    # Saving the input value.we need this later to add to the output. 
+    X_shortcut = X
+    
+    # First component of main path
+    X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a')(X)
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)
+    X = Activation('relu')(X)
+
+    
+    # Second component of main path (≈3 lines)
+    X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b')(X)
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)
+    X = Activation('relu')(X)
+
+    # Third component of main path (≈2 lines)
+    X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c')(X)
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)
+
+    # Final step: Add shortcut value to main path, and pass it through a RELU activation 
+    X = Add()([X, X_shortcut])
+    X = Activation('relu')(X)
+    
+    
+    return X
+
+
+# CONVOLUTIONAL BLOCK
+def convolutional_block(X, f, filters, stage, block, s = 2):
+    
+    # defining name basis
+    conv_name_base = 'res' + str(stage) + block + '_branch'
+    bn_name_base = 'bn' + str(stage) + block + '_branch'
+    
+    # Retrieve Filters
+    F1, F2, F3 = filters
+    
+    # Save the input value
+    X_shortcut = X
+
+
+    # First layer 
+    X = Conv2D(F1, (1, 1), strides = (s,s), name = conv_name_base + '2a')(X) # 1,1 is filter size
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)  # normalization on channels
+    X = Activation('relu')(X)
+
+      
+    # Second layer  (f,f)=3*3 filter by default
+    X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b')(X)
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)
+    X = Activation('relu')(X)
+
+
+    # Third layer
+    X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c')(X)
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)
+
+
+    ##### SHORTCUT PATH #### 
+    X_shortcut = Conv2D(filters = F3, kernel_size = (1, 1), strides = (s,s), padding = 'valid', name = conv_name_base + '1')(X_shortcut)
+    X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)
+
+    # Final step: Add shortcut value here, and pass it through a RELU activation 
+    X = Add()([X, X_shortcut])
+    X = Activation('relu')(X)
+    
+    
+    return X
+
+# CREATING RESNET50
+#Each ResNet block is either 2 layer deep
+def ResNet50(input_shape=(224, 224, 3)):
+    """
+    Implementation of the ResNet50 architecture:
+    CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3
+    -> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER
+
+    """
+
+    # Define the input as a tensor with shape input_shape
+    X_input = Input(input_shape)
+
+    # Zero-Padding
+    X = ZeroPadding2D((3, 3))(X_input) #3,3 padding
+
+    # Stage 1
+    X = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(X) #64 filters of 7*7 
+    X = BatchNormalization(axis=3, name='bn_conv1')(X) #batchnorm applied on channels
+    X = Activation('relu')(X)
+    X = MaxPooling2D((3, 3), strides=(2, 2))(X) #window size is 3*3
+
+    # Stage 2
+    X = convolutional_block(X, f=3, filters=[64, 64, 256], stage=2, block='a', s=1)
+
+   
+    X = identity_block(X, 3, [64, 64, 256], stage=2, block='b') 
+
+  
+    X = identity_block(X, 3, [64, 64, 256], stage=2, block='c')
+
+
+    ### START CODE HERE ###
+
+    # Stage 3 
+    X = convolutional_block(X, f = 3, filters = [128, 128, 512], stage = 3, block='a', s = 2)
+    X = identity_block(X, 3, [128, 128, 512], stage=3, block='b')
+    X = identity_block(X, 3, [128, 128, 512], stage=3, block='c')
+    X = identity_block(X, 3, [128, 128, 512], stage=3, block='d')
+
+    # Stage 4 
+    X = convolutional_block(X, f = 3, filters = [256, 256, 1024], stage = 4, block='a', s = 2)
+    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='b')
+    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='c')
+    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='d')
+    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='e')
+    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='f')
+
+    # Stage 5 
+    X = convolutional_block(X, f = 3, filters = [512, 512, 2048], stage = 5, block='a', s = 2)
+    X = identity_block(X, 3, [512, 512, 2048], stage=5, block='b')
+    X = identity_block(X, 3, [512, 512, 2048], stage=5, block='c')
+
+    # AVGPOOL 
+    X = AveragePooling2D((2,2), name="avg_pool")(X)
+
+    ### END CODE HERE ###
+
+    # output layer
+    X = Flatten()(X)
+
+    X = Dense(1,activation='relu',  name='output')(X)
+    
+    # Create model
+    model = Model(inputs = X_input, outputs = X, name='ResNet50')
+
+    return model
+
+model_resnet = ResNet50()
+print(model_resnet.summary())

testing_age.py

@@ -0,0 +1,58 @@
+import streamlit as st 
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image,ImageOps
+import numpy as np
+import random
+import cv2
+import tensorflow as tf
+from tensorflow import keras
+from keras.models import load_model
+
+import time 
+# import mysql.connector
+
+import process_input_pipeline as pp
+import img_extractor
+from process_input_pipeline import ImageResizer, ContrastEnhancer
+
+# added for inception concat
+from sklearn.pipeline import make_pipeline
+from sklearn.base import BaseEstimator, TransformerMixin
+
+import combined_model
+
+cm = combined_model.build_regression_model()
+cm.load_weights(r"F:\python\web_streamlit\ALL_IN_ONE\model_weights\model_weights\combined_weights_7_epoch_third_acc.h5")
+
+roi=img_extractor.RoiExtractor()
+
+def process_image(img, img_size=(224, 224)):
+    try:
+        new_size=(299,299)
+        resized_img = img.resize(new_size, Image.BICUBIC)
+        img_array=np.array(resized_img)
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(64, 64))
+        cl1 = clahe.apply(img_array)
+        cl2=cv2.cvtColor(cl1,cv2.COLOR_GRAY2BGR)
+        return cl2
+    except Exception as e:
+        st.error(f"Error processing image: {e}")
+        return None 
+    
+def predict(img_data_c,img_data_m, gender):
+    try:
+        if gender == 'Female':
+            # gender_input = np.array([0])
+            gender_input=0
+        elif gender == 'Male':
+            gender_input = 1
+
+
+        pred =cm.predict([np.array([img_data_c]),np.array([img_data_m]), np.array([gender_input])])
+        # pred = model.predict(img_data)
+        return pred
+    except Exception as e:
+        st.error(f"Error predicting bone age: {e}")
+        return None

updated_resnet_1.py

@@ -0,0 +1,181 @@
+import numpy as np
+from keras import layers
+from keras.layers import Input, Add, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D, AveragePooling2D, MaxPooling2D, GlobalMaxPooling2D
+from keras.models import Model, load_model
+from keras.preprocessing import image
+# from keras.utils import layer_utils
+# from keras.utils.data_utils import get_file
+from keras.applications.imagenet_utils import preprocess_input
+# from IPython.display import SVG
+# from keras.utils.vis_utils import model_to_dot
+from keras.utils import plot_model
+
+import scipy.misc
+from matplotlib.pyplot import imshow
+
+from keras.layers import Input, Add, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D, AveragePooling2D, MaxPooling2D, GlobalMaxPooling2D
+
+
+# x is input, y=F(x)
+# identity block simply means input should be equal to output.
+#  y = x + F(x)   the layers in a traditional network are learning the true output H(x)
+# F(x) = y - x   the layers in a residual network are learning the residual F(x)
+# Hence, the name: Residual Block.
+
+
+
+def identity_block(X, f, filters, stage, block):
+    """
+
+    Arguments:
+    X -- input of shape (m, height, width, channel)
+    f -- shape of the middle CONV's window for the main path
+    filters -- python list of integers, defining the number of filters in the CONV layers of the main path
+    stage -- integer, used to name the layers, depending on their position in the network
+    block -- string/character, used to name the layers, depending on their position in the network
+
+    Returns:
+    X -- output of the identity block, tensor of shape (n_H, n_W, n_C)
+    """
+
+    # defining name basis
+    conv_name_base = 'res' + str(stage) + block + '_branch'
+    bn_name_base = 'bn' + str(stage) + block + '_branch'
+
+    # Retrieve Filters
+    F1, F2, F3 = filters
+
+    # Saving the input value.we need this later to add to the output.
+    X_shortcut = X
+
+    # First component of main path
+    X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a')(X)
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)
+    X = Activation('relu')(X)
+
+
+    # Second component of main path (≈3 lines)
+    X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b')(X)
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)
+    X = Activation('relu')(X)
+
+    # Third component of main path (≈2 lines)
+    X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c')(X)
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)
+
+    # Final step: Add shortcut value to main path, and pass it through a RELU activation
+    X = Add()([X, X_shortcut])
+    X = Activation('relu')(X)
+
+
+    return X
+
+
+def convolutional_block(X, f, filters, stage, block, s = 2):
+
+    # defining name basis
+    conv_name_base = 'res' + str(stage) + block + '_branch'
+    bn_name_base = 'bn' + str(stage) + block + '_branch'
+
+    # Retrieve Filters
+    F1, F2, F3 = filters
+
+    # Save the input value
+    X_shortcut = X
+
+
+    # First layer
+    X = Conv2D(F1, (1, 1), strides = (s,s), name = conv_name_base + '2a')(X) # 1,1 is filter size
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)  # normalization on channels
+    X = Activation('relu')(X)
+
+
+    # Second layer  (f,f)=3*3 filter by default
+    X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b')(X)
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)
+    X = Activation('relu')(X)
+
+
+    # Third layer
+    X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c')(X)
+    X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)
+
+
+    ##### SHORTCUT PATH ####
+    X_shortcut = Conv2D(filters = F3, kernel_size = (1, 1), strides = (s,s), padding = 'valid', name = conv_name_base + '1')(X_shortcut)
+    X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)
+
+    # Final step: Add shortcut value here, and pass it through a RELU activation
+    X = Add()([X, X_shortcut])
+    X = Activation('relu')(X)
+
+
+    return X
+
+#Each ResNet block is either 2 layer deep
+def ResNet50(input_shape=(64, 64, 3)):
+    """
+    Implementation of the ResNet50 architecture:
+    CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3
+    -> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER
+
+    """
+
+    # Define the input as a tensor with shape input_shape
+    X_input = Input(input_shape)
+
+    # Zero-Padding
+    X = ZeroPadding2D((3, 3))(X_input) #3,3 padding
+
+    # Stage 1
+    X = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(X) #64 filters of 7*7
+    X = BatchNormalization(axis=3, name='bn_conv1')(X) #batchnorm applied on channels
+    X = Activation('relu')(X)
+    X = MaxPooling2D((3, 3), strides=(2, 2))(X) #window size is 3*3
+
+    # Stage 2
+    X = convolutional_block(X, f=3, filters=[64, 64, 256], stage=2, block='a', s=1)
+
+
+    X = identity_block(X, 3, [64, 64, 256], stage=2, block='b')
+
+
+    X = identity_block(X, 3, [64, 64, 256], stage=2, block='c')
+
+
+    ### START CODE HERE ###
+
+    # Stage 3
+    X = convolutional_block(X, f = 3, filters = [128, 128, 512], stage = 3, block='a', s = 2)
+    X = identity_block(X, 3, [128, 128, 512], stage=3, block='b')
+    X = identity_block(X, 3, [128, 128, 512], stage=3, block='c')
+    X = identity_block(X, 3, [128, 128, 512], stage=3, block='d')
+
+    # Stage 4
+    X = convolutional_block(X, f = 3, filters = [256, 256, 1024], stage = 4, block='a', s = 2)
+    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='b')
+    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='c')
+    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='d')
+    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='e')
+    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='f')
+
+    # Stage 5
+    X = convolutional_block(X, f = 3, filters = [512, 512, 2048], stage = 5, block='a', s = 2)
+    X = identity_block(X, 3, [512, 512, 2048], stage=5, block='b')
+    X = identity_block(X, 3, [512, 512, 2048], stage=5, block='c')
+
+    # AVGPOOL
+    X = AveragePooling2D((2,2), name="avg_pool")(X)
+
+    ### END CODE HERE ###
+
+    # output layer
+    X = Flatten()(X)
+    X = Dense(512, activation='relu')(X)
+    X = Dense(128, activation='relu')(X)
+    X = Dense(1, name='output')(X)
+
+    # Create model
+    model = Model(inputs = X_input, outputs = X, name='ResNet50')
+
+    return model