Training again

Author: shalabh147

Evaluation-Prediction/__pycache__/utils.cpython-36.pyc

@@ -3,49 +3,53 @@
 import numpy as np
 import matplotlib.pyplot as plt
 #%matplotlib inline
-import tensorflow as tf
+#import tensorflow as tf
 import keras.backend as K
-
+import keras
 
 from keras.models import Model, load_model
-from keras.layers import Input, BatchNormalization, Activation, Dense, Dropout,Maximum
-from keras.layers.core import Lambda, RepeatVector, Reshape
-from keras.layers.convolutional import Conv2D, Conv2DTranspose,Conv3D,Conv3DTranspose
-from keras.layers.pooling import MaxPooling2D, GlobalMaxPool2D,MaxPooling3D
-from keras.layers.merge import concatenate, add
-from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
+#from keras.layers import Input, BatchNormalization, Activation, Dense, Dropout,Maximum
+#from keras.layers.core import Lambda, RepeatVector, Reshape
+#from keras.layers.convolutional import Conv2D, Conv2DTranspose,Conv3D,Conv3DTranspose
+#from keras.layers.pooling import MaxPooling2D, GlobalMaxPool2D,MaxPooling3D
+#from keras.layers.merge import concatenate, add
+#from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
 from keras.optimizers import Adam
-from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img
+#from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img
 
-from skimage.io import imread, imshow, concatenate_images
-from skimage.transform import resize
+#from skimage.io import imread, imshow, concatenate_images
+#from skimage.transform import resize
 
 import os
-from skimage.io import imread, imshow, concatenate_images
-from skimage.transform import resize
+#from skimage.io import imread, imshow, concatenate_images
+#from skimage.transform import resize
 from medpy.io import load
 from medpy.io import save
 import numpy as np
+#import time
+#import sys
+#sys.path.insert(1, '~/Brain_Segmentation/utils.py')
 #import cv2
 
-from ../utils import f1_score,dice_coef,dice_coef_loss
+from utils import f1_score,dice_coef,dice_coef_loss,standardize,compute_class_sens_spec,get_sens_spec_df,one_hot_encode
 def reverse_encode(a):
 	return np.argmax(a,axis=-1)
 
 
 
-model_to_predict1 = load_model('../Models/survival_pred_240_240.h5',custom_objects={'dice_coef_loss':dice_coef_loss})
-model_to_predict2 = load_model('../Models/survival_pred_240_155_1.h5')
-model_to_predict3 = load_model('../Models/survival_pred_240_155_2.h5')
-path = '../TestData'
+
+model_to_predict1 = load_model('../first_240_155.h5',custom_objects={'dice_coef_loss':dice_coef_loss , 'dice_coef':dice_coef})
+#model_to_predict2 = load_model('../Models/survival_pred_240_155_1.h5',custom_objects={'dice_coef_loss':dice_coef_loss , 'f1_score':f1_score})
+#model_to_predict3 = load_model('../Models/survival_pred_240_155_2.h5',custom_objects={'dice_coef_loss':dice_coef_loss , 'f1_score':f1_score})
+path = '../../Brats17TrainingData/LGG'
 all_images = os.listdir(path)
 #print(len(all_images))
 all_images.sort()
 
 data = np.zeros((240,240,155,4))
 
-for i in range(100,101):
-  new_image = np.zeros((240,240,155,5))
+for i in range(40,42):
+  new_image = np.zeros((240,240,155,4))
   print(i)
   x_to = []
   y_to = []
@@ -64,24 +68,42 @@ def reverse_encode(a):
       print("Entered ground truth")
     else:
       image_data, image_header = load(image_path);
+      image_data = standardize(image_data)
       data[:,:,:,w] = image_data
       print("Entered modality")
       w = w+1
 
   print(data.shape)
-    
+  Y_hat = model_to_predict1.predict(data)
+  #print(Y_hat.shape)
+  image_data2[image_data2==4] = 3
+  Y_hat[Y_hat > 0.6] = 1.0
+  Y_hat[Y_hat <= 0.6] = 0.0
+  #print(Y_hat[0,100,100])
+  #print(len(Y_hat[:,:,:,0]==1))
+  #print(len(Y_hat[:,:,:,1]==1))
+  #print(len(Y_hat[:,:,:,2]==1))
+  #print(len(Y_hat[:,:,:,3]==1))
+  image_data2 = keras.utils.to_categorical(image_data2, num_classes = 4)
+  #image_data2 = one_hot_encode(image_data2)
+  print(get_sens_spec_df(Y_hat,image_data2))
+  print(model_to_predict1.evaluate(x=data,y=image_data2)) 
+  print(model_to_predict1.metrics_names)
   #Combining results from all 3 dimensions
-    
+'''
   for slice_no in range(0,240):
     a = slice_no
     X = data[slice_no,:,:,:]
     X = X.reshape(1,240,155,4)
     Y_hat = model_to_predict3.predict(X)
     new_image[a,:,:,:] = Y_hat[0,:,:,:]
+'''
+  
 
+'''
   for slice_no in range(0,155):
     a = slice_no
-    X = data[:,:slice_no,:]
+    X = data[:,:,slice_no,:]
     X = X.reshape(1,240,240,4)
     Y_hat = model_to_predict1.predict(X)
     new_image[:,:,slice_no,:] += Y_hat[0,:,:,:]
@@ -92,10 +114,39 @@ def reverse_encode(a):
     X = X.reshape(1,240,155,4)
     Y_hat = model_to_predict2.predict(X)
     new_image[:,a,:,:] += Y_hat[0,:,:,:]
-      
+'''      
 
-  new_image = new_image/3         #average of probabilities from 3 directions
+  
+  #new_image = new_image/3.0
+  #print(new_image[100,100,100])
+  #pred = pred.reshape(-1,5)
+  #pred1 = np.argmax(new_image[:,:,:,1:],axis=3)
+  #new_image = np.argmax(new_image,axis=3)
+  #pred1[new_image[:,:,:,0] > 0.56] = 0         #average of probabilities from 3 directions
+  #pred1 = pred1.astype('int64') 
+  #image_data2 = image_data2.astype('int64')
+  
+'''
+  for slice_no in range(0,155):
+    print(slice_no)
+    img = pred1[:,:,slice_no]
+    imgplot = plt.imshow(img)
+    plt.show(block=False)
+    #time.sleep(1)
+    plt.pause(0.1)
+    plt.close()
+
+
+  for slice_no in range(0,155):
+    print(slice_no)
+    img = image_data2[:,:,slice_no]
+    imgplot = plt.imshow(img)
+    plt.show(block=False)
+    #time.sleep(1)
+    plt.pause(0.1)
+    plt.close()
+  '''
 
 
-  name = '../all_images/VSD.Seg_001.'+ image_id + '.mha'
-  save(new_image,name)
+  #name = '../all_images/VSD.Seg_001.'+ image_id + '.mha'
+  #save(new_image,name)

Evaluation-Prediction/predict.py

@@ -0,0 +1,163 @@
+import random
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+#%matplotlib inline
+import tensorflow as tf
+import keras.backend as K
+
+
+from keras.models import Model, load_model
+from keras.layers import Input, BatchNormalization, Activation, Dense, Dropout,Maximum
+from keras.layers.core import Lambda, RepeatVector, Reshape
+from keras.layers.convolutional import Conv2D, Conv2DTranspose,Conv3D,Conv3DTranspose
+from keras.layers.pooling import MaxPooling2D, GlobalMaxPool2D,MaxPooling3D
+from keras.layers.merge import concatenate, add
+from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
+from keras.optimizers import Adam
+from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img
+
+from skimage.io import imread, imshow, concatenate_images
+from skimage.transform import resize
+
+import os
+from skimage.io import imread, imshow, concatenate_images
+from skimage.transform import resize
+from medpy.io import load
+import numpy as np
+
+import cv2
+from sklearn import metrics
+
+def f1_score(y_true, y_pred):
+
+    # Count positive samples.
+    c1 = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
+    c2 = K.sum(K.round(K.clip(y_true, 0, 1)))
+    c3 = K.sum(K.round(K.clip(y_pred, 0, 1)))
+
+    # If there are no true samples, fix the F1 score at 0.
+    if c3 == 0:
+        return 0
+
+    # How many selected items are relevant?
+    precision = c1 / c2
+
+    # How many relevant items are selected?
+    recall = c1 / c3
+
+    # Calculate f1_score
+    f1_score = 2 * (precision * recall) / (precision + recall)
+    return f1_score
+
+
+def one_hot_encode(a):
+  m = (np.arange(4) == a[...,None]).astype(int)
+  return m
+
+def dice_coef(y_true, y_pred, epsilon=0.00001):
+    """
+    Dice = (2*|X & Y|)/ (|X|+ |Y|)
+         =  2*sum(|A*B|)/(sum(A^2)+sum(B^2))
+    ref: https://arxiv.org/pdf/1606.04797v1.pdf
+    
+    """
+    axis = (0,1,2)
+    dice_numerator = 2. * K.sum(y_true * y_pred, axis=axis) + epsilon
+    dice_denominator = K.sum(y_true*y_true, axis=axis) + K.sum(y_pred*y_pred, axis=axis) + epsilon
+    return K.mean((dice_numerator)/(dice_denominator))
+
+def dice_coef_loss(y_true, y_pred):
+    return 1-dice_coef(y_true, y_pred)
+
+
+def standardize(image):
+
+    standardized_image = np.zeros(image.shape)
+
+    #
+    
+        # iterate over the `z` dimension
+    for z in range(image.shape[2]):
+        # get a slice of the image 
+        # at channel c and z-th dimension `z`
+        image_slice = image[:,:,z]
+
+        # subtract the mean from image_slice
+        centered = image_slice - np.mean(image_slice)
+        
+        # divide by the standard deviation (only if it is different from zero)
+        if(np.std(centered)!=0):
+            centered = centered/np.std(centered) 
+
+        # update  the slice of standardized image
+        # with the scaled centered and scaled image
+        standardized_image[:, :, z] = centered
+
+    ### END CODE HERE ###
+
+    return standardized_image
+
+
+def compute_class_sens_spec(pred, label, class_num):
+    """
+    Compute sensitivity and specificity for a particular example
+    for a given class.
+
+    Args:
+        pred (np.array): binary arrary of predictions, shape is
+                         (num classes, height, width, depth).
+        label (np.array): binary array of labels, shape is
+                          (num classes, height, width, depth).
+        class_num (int): number between 0 - (num_classes -1) which says
+                         which prediction class to compute statistics
+                         for.
+
+    Returns:
+        sensitivity (float): precision for given class_num.
+        specificity (float): recall for given class_num
+    """
+
+    # extract sub-array for specified class
+    class_pred = pred[:,:,:,class_num]
+    class_label = label[:,:,:,class_num]
+
+    ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###
+    
+    # compute true positives, false positives, 
+    # true negatives, false negatives
+    print(np.sum(class_pred==1))
+    print(np.sum(class_pred==0))
+    print(np.sum(class_label==1))
+    print(np.sum(class_label==0))
+    tp = np.sum((class_pred == 1) & (class_label == 1))
+    tn = np.sum((class_pred == 0) & (class_label == 0))
+    fp = np.sum((class_pred == 1) & (class_label == 0))
+    fn = np.sum((class_pred == 0) & (class_label == 1))
+    print(tp,tn,fp,fn)
+
+    # compute sensitivity and specificity
+    sensitivity = tp / (tp + fn)
+    specificity = tn / (tn + fp)
+
+    ### END CODE HERE ###
+
+    return sensitivity, specificity
+
+
+def get_sens_spec_df(pred, label):
+    patch_metrics = pd.DataFrame(
+        columns = ['Nothing',
+                    'Edema', 
+                   'Non-Enhancing Tumor', 
+                   'Enhancing Tumor'], 
+        index = ['Sensitivity',
+                 'Specificity'])
+    
+    for i, class_name in enumerate(patch_metrics.columns):
+        print(i)
+        sens, spec = compute_class_sens_spec(pred, label, i)
+        patch_metrics.loc['Sensitivity', class_name] = round(sens,4)
+        patch_metrics.loc['Specificity', class_name] = round(spec,4)
+
+    return patch_metrics