Upload 7 files

.gitattributes

@@ -32,3 +32,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/model1.hdf5 filter=lfs diff=lfs merge=lfs -text
+models/model2.hdf5 filter=lfs diff=lfs merge=lfs -text
+models/model3.hdf5 filter=lfs diff=lfs merge=lfs -text
+models/model4.hdf5 filter=lfs diff=lfs merge=lfs -text
+models/model5.hdf5 filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,429 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Importing the Required Libraries.
+
+# In[1]:
+
+
+import keras 
+get_ipython().run_line_magic('env', 'SM_FRAMEWORK=tf.keras')
+import segmentation_models as sm
+import glob
+import matplotlib.pyplot as plt
+from scipy import ndimage
+from scipy.ndimage import label, generate_binary_structure
+import radiomics
+import cv2
+import SimpleITK as sitk
+import six
+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
+get_ipython().run_line_magic('matplotlib', 'inline')
+from sklearn.feature_selection import SelectKBest
+from sklearn.feature_selection import mutual_info_classif
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.feature_selection import RFE
+from sklearn.metrics import roc_auc_score
+from sklearn.feature_selection import SelectFromModel
+from sklearn.linear_model import Lasso, LogisticRegression
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA 
+from sklearn.svm import LinearSVC
+from sklearn.datasets import load_iris
+from sklearn.feature_selection import SelectFromModel
+from sklearn.feature_selection import mutual_info_classif as MIC
+from sklearn.feature_selection import mutual_info_classif, mutual_info_regression
+from sklearn.feature_selection import SelectKBest, SelectPercentile
+from sklearn.feature_selection import SequentialFeatureSelector
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.svm import SVC
+from sklearn.metrics import f1_score
+from sklearn.model_selection import cross_validate
+from sklearn.tree import DecisionTreeClassifier 
+from sklearn.linear_model import Perceptron
+from sklearn.model_selection import RandomizedSearchCV
+from sklearn.model_selection import GridSearchCV
+# from hyperopt import hp
+
+import warnings
+warnings.filterwarnings('ignore')
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = "1"
+
+
+# # Defining the path to Model and Images
+
+# In[2]:
+
+
+IMAGE_SIZE = (256,256,3)
+
+path_base_model = './/models//'
+
+# # Loading the models
+
+# In[4]:
+
+
+BACKBONE = 'efficientnetb0'
+model1 = sm.Unet(BACKBONE, input_shape = (IMAGE_SIZE[0],IMAGE_SIZE[1],IMAGE_SIZE[2]),classes=1, activation='sigmoid',encoder_weights='imagenet')
+model2 = sm.Unet(BACKBONE, input_shape = (IMAGE_SIZE[0],IMAGE_SIZE[1],IMAGE_SIZE[2]),classes=1, activation='sigmoid',encoder_weights='imagenet')
+model3 = sm.Unet(BACKBONE, input_shape = (IMAGE_SIZE[0],IMAGE_SIZE[1],IMAGE_SIZE[2]),classes=1, activation='sigmoid',encoder_weights='imagenet')
+
+BACKBONE = 'efficientnetb7'
+model4 = sm.Unet(BACKBONE, input_shape = (IMAGE_SIZE[0],IMAGE_SIZE[1],IMAGE_SIZE[2]),classes=1, activation='sigmoid',encoder_weights='imagenet')
+model5 = sm.Unet(BACKBONE, input_shape = (IMAGE_SIZE[0],IMAGE_SIZE[1],IMAGE_SIZE[2]),classes=1, activation='sigmoid',encoder_weights='imagenet')
+
+preprocess_input = sm.get_preprocessing(BACKBONE)
+
+model1.load_weights(path_base_model + 'model1.hdf5')
+model2.load_weights(path_base_model + 'model2.hdf5')
+model3.load_weights(path_base_model + 'model3.hdf5')
+model4.load_weights(path_base_model + 'model4.hdf5')
+model5.load_weights(path_base_model + 'model5.hdf5')
+
+
+# # Defining Required Functions
+
+# In[5]:
+
+
+def preprocessing_HE(img_):
+    
+    hist, bins = np.histogram(img_.flatten(), 256,[0,256])
+    cdf = hist.cumsum()
+    cdf_m = np.ma.masked_equal(cdf,0)
+    cdf_m = (cdf_m - cdf_m.min())*255/(cdf_m.max()-cdf_m.min())
+    cdf = np.ma.filled(cdf_m,0).astype('uint8')
+
+    img_2 = cdf[img_]
+    
+    return img_2  
+        
+def get_binary_mask (mask_, th_ = 0.5):
+    mask_[mask_>th_]  = 1
+    mask_[mask_<=th_] = 0
+    return mask_
+    
+def ensemble_results (mask1_, mask2_, mask3_, mask4_, mask5_):
+    
+    mask1_ = get_binary_mask (mask1_)
+    mask2_ = get_binary_mask (mask2_)
+    mask3_ = get_binary_mask (mask3_)
+    mask4_ = get_binary_mask (mask4_)
+    mask5_ = get_binary_mask (mask5_)
+    
+    ensemble_mask = mask1_ + mask2_ + mask3_ + mask4_ + mask5_
+    ensemble_mask[ensemble_mask<=2.0] = 0
+    ensemble_mask[ensemble_mask> 2.0] = 1
+    
+    return ensemble_mask
+
+def postprocessing_HoleFilling (mask_):
+    
+    ensemble_mask_post_temp = ndimage.binary_fill_holes(mask_).astype(int)
+     
+    return ensemble_mask_post_temp
+
+def get_maximum_index (labeled_array):
+    
+    ind_nums = []
+    for i in range (len(np.unique(labeled_array)) - 1):
+        ind_nums.append ([0, i+1])
+        
+    for i in range (1, len(np.unique(labeled_array))):
+        ind_nums[i-1][0] = len(np.where (labeled_array == np.unique(labeled_array)[i])[0])
+        
+    ind_nums = sorted(ind_nums)
+    
+    return ind_nums[len(ind_nums)-1][1], ind_nums[len(ind_nums)-2][1]
+    
+def postprocessing_EliminatingIsolation (ensemble_mask_post_temp):
+        
+    labeled_array, num_features = label(ensemble_mask_post_temp)
+    
+    ind_max1, ind_max2 = get_maximum_index (labeled_array)
+    
+    ensemble_mask_post_temp2 = np.zeros (ensemble_mask_post_temp.shape)
+    ensemble_mask_post_temp2[labeled_array == ind_max1] = 1
+    ensemble_mask_post_temp2[labeled_array == ind_max2] = 1    
+    
+    return ensemble_mask_post_temp2.astype(int)
+
+def get_prediction(model_, img_org_):
+    
+    img_org_resize = cv2.resize(img_org_,(IMAGE_SIZE[0],IMAGE_SIZE[1]),cv2.INTER_AREA)
+    img_org_resize_HE = preprocessing_HE (img_org_resize)    
+    img_ready = preprocess_input (img_org_resize_HE)
+
+    img_ready = np.expand_dims(img_ready, axis=0) 
+    pr_mask = model_.predict(img_ready)
+    pr_mask = np.squeeze(pr_mask)
+    pr_mask = np.expand_dims(pr_mask, axis=-1)    
+    return pr_mask[:,:,0]
+
+# ## Create and intantiate Feature Extractor and enable the required features
+
+# In[9]:
+
+
+extractor = radiomics.featureextractor.RadiomicsFeatureExtractor(force2D=True)
+extractor.enableImageTypeByName('Original')  # extract features from the original image
+extractor.enableFeatureClassByName('firstorder')  # extract first-order features
+extractor.enableFeatureClassByName('glcm')  # extract GLCM features
+extractor.enableFeatureClassByName('gldm')  # extract GLDM features
+extractor.enableFeatureClassByName('glszm')  # extract GLSZM features
+extractor.enableFeatureClassByName('ngtdm')  # extract NGTDM features
+
+
+
+features_name = ['diagnostics_Versions_PyRadiomics',
+ 'diagnostics_Versions_Numpy',
+ 'diagnostics_Versions_SimpleITK',
+ 'diagnostics_Versions_PyWavelet',
+ 'diagnostics_Versions_Python',
+ 'diagnostics_Configuration_Settings',
+ 'diagnostics_Configuration_EnabledImageTypes',
+ 'diagnostics_Image-original_Hash',
+ 'diagnostics_Image-original_Dimensionality',
+ 'diagnostics_Image-original_Spacing',
+ 'diagnostics_Image-original_Size',
+ 'diagnostics_Image-original_Mean',
+ 'diagnostics_Image-original_Minimum',
+ 'diagnostics_Image-original_Maximum',
+ 'diagnostics_Mask-original_Hash',
+ 'diagnostics_Mask-original_Spacing',
+ 'diagnostics_Mask-original_Size',
+ 'diagnostics_Mask-original_BoundingBox',
+ 'diagnostics_Mask-original_VoxelNum',
+ 'diagnostics_Mask-original_VolumeNum',
+ 'diagnostics_Mask-original_CenterOfMassIndex',
+ 'diagnostics_Mask-original_CenterOfMass',
+ 'original_firstorder_10Percentile',
+ 'original_firstorder_90Percentile',
+ 'original_firstorder_Energy',
+ 'original_firstorder_Entropy',
+ 'original_firstorder_InterquartileRange',
+ 'original_firstorder_Kurtosis',
+ 'original_firstorder_Maximum',
+ 'original_firstorder_MeanAbsoluteDeviation',
+ 'original_firstorder_Mean',
+ 'original_firstorder_Median',
+ 'original_firstorder_Minimum',
+ 'original_firstorder_Range',
+ 'original_firstorder_RobustMeanAbsoluteDeviation',
+ 'original_firstorder_RootMeanSquared',
+ 'original_firstorder_Skewness',
+ 'original_firstorder_TotalEnergy',
+ 'original_firstorder_Uniformity',
+ 'original_firstorder_Variance',
+ 'original_glcm_Autocorrelation',
+ 'original_glcm_ClusterProminence',
+ 'original_glcm_ClusterShade',
+ 'original_glcm_ClusterTendency',
+ 'original_glcm_Contrast',
+ 'original_glcm_Correlation',
+ 'original_glcm_DifferenceAverage',
+ 'original_glcm_DifferenceEntropy',
+ 'original_glcm_DifferenceVariance',
+ 'original_glcm_Id',
+ 'original_glcm_Idm',
+ 'original_glcm_Idmn',
+ 'original_glcm_Idn',
+ 'original_glcm_Imc1',
+ 'original_glcm_Imc2',
+ 'original_glcm_InverseVariance',
+ 'original_glcm_JointAverage',
+ 'original_glcm_JointEnergy',
+ 'original_glcm_JointEntropy',
+ 'original_glcm_MCC',
+ 'original_glcm_MaximumProbability',
+ 'original_glcm_SumAverage',
+ 'original_glcm_SumEntropy',
+ 'original_glcm_SumSquares',
+ 'original_gldm_DependenceEntropy',
+ 'original_gldm_DependenceNonUniformity',
+ 'original_gldm_DependenceNonUniformityNormalized',
+ 'original_gldm_DependenceVariance',
+ 'original_gldm_GrayLevelNonUniformity',
+ 'original_gldm_GrayLevelVariance',
+ 'original_gldm_HighGrayLevelEmphasis',
+ 'original_gldm_LargeDependenceEmphasis',
+ 'original_gldm_LargeDependenceHighGrayLevelEmphasis',
+ 'original_gldm_LargeDependenceLowGrayLevelEmphasis',
+ 'original_gldm_LowGrayLevelEmphasis',
+ 'original_gldm_SmallDependenceEmphasis',
+ 'original_gldm_SmallDependenceHighGrayLevelEmphasis',
+ 'original_gldm_SmallDependenceLowGrayLevelEmphasis',
+ 'original_glrlm_GrayLevelNonUniformity',
+ 'original_glrlm_GrayLevelNonUniformityNormalized',
+ 'original_glrlm_GrayLevelVariance',
+ 'original_glrlm_HighGrayLevelRunEmphasis',
+ 'original_glrlm_LongRunEmphasis',
+ 'original_glrlm_LongRunHighGrayLevelEmphasis',
+ 'original_glrlm_LongRunLowGrayLevelEmphasis',
+ 'original_glrlm_LowGrayLevelRunEmphasis',
+ 'original_glrlm_RunEntropy',
+ 'original_glrlm_RunLengthNonUniformity',
+ 'original_glrlm_RunLengthNonUniformityNormalized',
+ 'original_glrlm_RunPercentage',
+ 'original_glrlm_RunVariance',
+ 'original_glrlm_ShortRunEmphasis',
+ 'original_glrlm_ShortRunHighGrayLevelEmphasis',
+ 'original_glrlm_ShortRunLowGrayLevelEmphasis',
+ 'original_glszm_GrayLevelNonUniformity',
+ 'original_glszm_GrayLevelNonUniformityNormalized',
+ 'original_glszm_GrayLevelVariance',
+ 'original_glszm_HighGrayLevelZoneEmphasis',
+ 'original_glszm_LargeAreaEmphasis',
+ 'original_glszm_LargeAreaHighGrayLevelEmphasis',
+ 'original_glszm_LargeAreaLowGrayLevelEmphasis',
+ 'original_glszm_LowGrayLevelZoneEmphasis',
+ 'original_glszm_SizeZoneNonUniformity',
+ 'original_glszm_SizeZoneNonUniformityNormalized',
+ 'original_glszm_SmallAreaEmphasis',
+ 'original_glszm_SmallAreaHighGrayLevelEmphasis',
+ 'original_glszm_SmallAreaLowGrayLevelEmphasis',
+ 'original_glszm_ZoneEntropy',
+ 'original_glszm_ZonePercentage',
+ 'original_glszm_ZoneVariance',
+ 'original_ngtdm_Busyness',
+ 'original_ngtdm_Coarseness',
+ 'original_ngtdm_Complexity',
+ 'original_ngtdm_Contrast',
+ 'original_ngtdm_Strength']
+
+# In[12]:
+
+
+df = pd.read_csv('final_dataset.csv')
+df.shape
+
+
+# In[13]:
+
+
+X_train, X_test, y_train, y_test = train_test_split(
+    df.drop(labels=['Label'], axis=1),
+    df['Label'],
+    test_size=0.2,
+    random_state=23)
+
+X_train.shape, X_test.shape
+
+
+# In[14]:
+
+
+from sklearn.preprocessing import StandardScaler
+def scale_data(dataset):
+    scaler = StandardScaler()
+    scaled_data = scaler.fit_transform(dataset)
+    return scaled_data
+
+
+# In[15]:
+
+
+scaled_train_set = scale_data(X_train)
+
+scaled_test_set = scale_data(X_test)
+
+
+# In[16]:
+
+
+RF = RandomForestClassifier(criterion = 'entropy',max_depth = None, max_features = 'log2', max_leaf_nodes = None,
+                               min_samples_leaf = 1,min_samples_split = 4, min_weight_fraction_leaf = 0.0, n_estimators = 200)
+RF.fit(X_train,y_train) 
+
+
+# In[17]:
+
+
+import pickle
+# create an iterator object with write permission - model.pkl
+with open('model_pkl', 'wb') as files:
+    pickle.dump(RF, files)
+
+
+# In[19]:
+
+
+model = pickle.load(open('model_pkl', 'rb'))
+model.score(X_test,y_test)
+
+# In[23]:
+
+
+# from sklearn.preprocessing import MinMaxScaler
+
+
+# In[42]:
+
+
+def pneumonia(image):
+    img_ = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    resized_img = cv2.resize(img_,(256,256))
+    original_image = 'original.jpeg'
+    cv2.imwrite(original_image,resized_img)
+    img = cv2.imread(original_image)
+    pr_mask1 = get_prediction (model1, img);
+    pr_mask2 = get_prediction (model2, img);
+    pr_mask3 = get_prediction (model3, img);
+    pr_mask4 = get_prediction (model4, img);
+    pr_mask5 = get_prediction (model5, img);   
+    
+    ensemble_mask            = ensemble_results (pr_mask1, pr_mask2, pr_mask3, pr_mask4, pr_mask5)
+    ensemble_mask_post_HF    = postprocessing_HoleFilling (ensemble_mask)
+    ensemble_mask_post_HF_EI = postprocessing_EliminatingIsolation (ensemble_mask_post_HF)
+  
+    mask = 'mask.jpeg'
+    cv2.imwrite(mask,ensemble_mask_post_HF_EI*255)
+  
+    features = {}
+    df = pd.DataFrame(columns=features_name)
+    
+    image_ = sitk.ReadImage(original_image, sitk.sitkInt8)
+    mask = sitk.ReadImage(mask, sitk.sitkInt8)
+    features = extractor.execute(image_, mask)
+    
+    df = df.append(features, ignore_index=True)
+    cols = df.columns[22:]
+
+    # Create new dataframe with selected columns
+    DataFrame = df[cols]
+
+    prediction = model.predict(DataFrame)
+
+    if prediction == 0: # Determine the predicted class
+        Label = "Normal"
+
+    elif prediction == 1:
+        Label = "Pneumonia"
+
+    return Label
+
+
+# In[43]:
+
+
+import gradio as gr
+iface =gr.Interface(fn = pneumonia,
+                    inputs = "image",
+                    outputs = [gr.outputs.Textbox(label="Prediction")],
+                    title = "Pnuemonia Detection from Chest X ray images",
+                    description = "Upload a Chest X ray image")
+iface.launch(share = True)
+
+
+
+
+

models/model1.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1039d5955156bad2d9d894ee0089b19f7bac18a8b6afa3c56f17674f01850963
+size 41041760

models/model2.hdf5

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

models/model3.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:447660e5fe37b977d3aa3e5b71da502ec380503abae7a191fcf857ca2a1ae231
+size 41042192

models/model4.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:653d22962c626453a173d2698fd20a5d040d81868e64e674059ea637e4eb59b0
+size 301947928

models/model5.hdf5

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