Move files to src folder

Author: ViiSkor

src/losses.py

@@ -0,0 +1,21 @@
+from metrics import dice_coefficient, tversky
+from tensorflow.keras.losses import binary_crossentropy
+
+
+def dice_loss(y_true, y_pred):
+    loss = 1 - dice_coefficient(y_true, y_pred)
+    return loss
+
+
+def bce_dice_loss(y_true, y_pred):
+    loss = binary_crossentropy(y_true, y_pred) + dice_loss(y_true, y_pred)
+    return loss
+
+
+def tversky_loss(y_true, y_pred):
+    return 1 - tversky(y_true,y_pred)
+
+
+def focal_tversky(y_true, y_pred, gamma=0.75):
+    pt_1 = tversky(y_true, y_pred)
+    return K.pow((1-pt_1), gamma)

src/metrics.py

@@ -0,0 +1,56 @@
+from tensorflow.keras import backend as K
+
+smooth = 1.
+
+def dice_coefficient(y_true, y_pred):
+    y_true_f = K.flatten(y_true)
+    y_pred_f = K.flatten(y_pred)
+    intersection = K.sum(y_true_f * y_pred_f)
+    score = (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)
+    return score
+
+
+def confusion(y_true, y_pred):
+    y_pred_pos = K.clip(y_pred, 0, 1)
+    y_pred_neg = 1 - y_pred_pos
+    y_pos = K.clip(y_true, 0, 1)
+    y_neg = 1 - y_pos
+    tp = K.sum(y_pos * y_pred_pos)
+    fp = K.sum(y_neg * y_pred_pos)
+    fn = K.sum(y_pos * y_pred_neg) 
+    prec = (tp + smooth)/(tp+fp+smooth)
+    rec = (tp+smooth)/(tp+fn+smooth)
+    return prec, rec
+
+
+def recall(y_true, y_pred):
+  y_pred_pos = K.clip(y_pred, 0, 1)
+  y_pred_neg = 1 - y_pred_pos
+  y_pos = K.clip(y_true, 0, 1)
+  y_neg = 1 - y_pos
+  tp = K.sum(y_pos * y_pred_pos)
+  fp = K.sum(y_neg * y_pred_pos)
+  fn = K.sum(y_pos * y_pred_neg)
+  rec = (tp+smooth)/(tp+fn+smooth)
+  return rec
+
+
+def precision(y_true, y_pred):
+  y_pred_pos = K.clip(y_pred, 0, 1)
+  y_pred_neg = 1 - y_pred_pos
+  y_pos = K.clip(y_true, 0, 1)
+  y_neg = 1 - y_pos
+  tp = K.sum(y_pos * y_pred_pos)
+  fp = K.sum(y_neg * y_pred_pos)
+  fn = K.sum(y_pos * y_pred_neg)
+  prec = (tp + smooth)/(tp+fp+smooth)
+  return prec
+
+
+def tversky(y_true, y_pred, alpha=0.7):
+    y_true_pos = K.flatten(y_true)
+    y_pred_pos = K.flatten(y_pred)
+    true_pos = K.sum(y_true_pos * y_pred_pos)
+    false_neg = K.sum(y_true_pos * (1-y_pred_pos))
+    false_pos = K.sum((1-y_true_pos)*y_pred_pos)
+    return (true_pos + smooth)/(true_pos + alpha*false_neg + (1-alpha)*false_pos + smooth)

src/unet.py

@@ -0,0 +1,92 @@
+from tensorflow.keras import Model
+from tensorflow.keras.layers import Conv3D, Conv3DTranspose, Input, BatchNormalization, Activation, MaxPool3D, SpatialDropout3D, Concatenate
+
+
+class Unet3D:
+  def __init__(self,
+               n_classes,
+               input_shape,
+               activation="relu",
+               n_base_filters=8,
+               batchnorm=False,
+               spatial_dropout=False,
+               batch_size=None,
+               model_depth=5,
+               name="3DUnet"):
+    self.n_classes = n_classes
+    self.input_shape = input_shape
+    self.activation = activation
+    self.n_base_filters = n_base_filters
+    self.batchnorm = batchnorm
+    self.spatial_dropout = spatial_dropout
+    self.batch_size = batch_size
+    self.model_depth = model_depth
+    self.name = name
+    
+    self.skips = []
+
+    self.conv_kwds = {
+          "kernel_size": (3, 3, 3),
+          "activation": None,
+          "padding": "same",
+          "kernel_initializer": "he_normal",
+          # 'kernel_regularizer': tf.keras.regularizers.l2(0.001),
+      }
+
+    self.conv_transpose_kwds = {
+          "kernel_size": (2, 2, 2),
+          "strides": 2,
+          "padding": "same",
+          "kernel_initializer": "he_normal",
+          # 'kernel_regularizer': tf.keras.regularizers.l2(0.001),
+      }
+
+  def encoder(self, inputs):
+    x = inputs
+    for depth in range(self.model_depth):
+      x = Conv3D(self.n_base_filters * (2**depth), **self.conv_kwds)(x)
+      if self.batchnorm:
+          x = BatchNormalization()(x)
+      x = Activation(self.activation)(x)
+      x = Conv3D(self.n_base_filters * (2**(depth+1)), **self.conv_kwds)(x)
+      if self.batchnorm:
+          x = BatchNormalization()(x)
+      x = Activation(self.activation)(x)
+      if depth < self.model_depth - 1:
+        self.skips.append(x)
+        x = MaxPool3D(2)(x)
+        if self.spatial_dropout:
+          x = SpatialDropout3D(0.5)(x)
+
+    return x
+
+  def decoder(self, x):
+    for depth in range(self.model_depth-1, 0, -1):
+      x = Conv3DTranspose(self.n_base_filters * (2**(depth+1)), **self.conv_transpose_kwds)(x)
+
+      x = Concatenate(axis=-1)([self.skips[depth-1], x])
+      if self.spatial_dropout:
+          x = SpatialDropout3D(0.5)(x)
+      x = Conv3D(self.n_base_filters * (2**depth), **self.conv_kwds)(x)
+      if self.batchnorm:
+          x = BatchNormalization()(x)
+      x = Activation(self.activation)(x)
+      x = Conv3D(self.n_base_filters * (2**depth), **self.conv_kwds)(x)
+      if self.batchnorm:
+          x = BatchNormalization()(x)
+      x = Activation(self.activation)(x)
+
+    x = Conv3D(filters=self.n_classes, kernel_size=1)(x)
+    return x
+
+
+  def build_model(self):
+    inputs = Input(shape=self.input_shape, batch_size=self.batch_size)
+    x = self.encoder(inputs)
+    x = self.decoder(x)
+
+    final_activation = "sigmoid" if self.n_classes == 1 else "softmax"
+    x = Activation(final_activation)(x)
+
+    model = Model(inputs=inputs, outputs=x, name=self.name)
+    return model