Loss
==================


**Vessel Tree Dice Loss**
This code is to calculate the dice loss for the vessel tree.

::

   def vt_dice(self, y_true, y_pred, axis=[1, 2, 3, 4], smooth=1e-5):
        y_pred = y_pred[:, :, :, :, 1][:, :, :, :, np.newaxis]
        y_true = y_true[:, :, :, :, 1][:, :, :, :, np.newaxis]
        inse = tf.reduce_sum(y_pred * y_true, axis=axis)  # compute intersection
        l = tf.reduce_sum(y_pred * y_pred, axis=axis)  # number of pixels in output
        r = tf.reduce_sum(y_true * y_true, axis=axis)  # number of pixels in target

        dice = (2. * inse + smooth) / (l + r + smooth)  # compute dice coefficient

        return dice


**Aneurysm Dice Loss**

This code is to calculate the dice loss for the aneurysm.

::

   def an_dice(self, y_true, y_pred, axis=[1, 2, 3, 4], smooth=1e-5):
        y_pred = y_pred[:, :, :, :, 2][:, :, :, :, np.newaxis]
        y_true = y_true[:, :, :, :, 2][:, :, :, :, np.newaxis]
        inse = tf.reduce_sum(y_pred * y_true, axis=axis)  # compute intersection
        l = tf.reduce_sum(y_pred * y_pred, axis=axis)  # number of pixels in output
        r = tf.reduce_sum(y_true * y_true, axis=axis)  # number of pixels in target

        dice = (2. * inse + smooth) / (l + r + smooth)  # compute dice coefficient

        return dice



**Dice Loss**

This code is to calculate the dice loss for both vessel tree and aneurysm.

::

   def dice_loss(self, y_true, y_pred):
        loss = 0.2 * (1 - self.vt_dice(y_true, y_pred)) + 0.8 * (1 - self.an_dice(y_true, y_pred))
        return loss


**Boundary Aware MSE Loss**

This code is to calculate the boundary aware MSE loss.
The code first use Fourier Transform to get the frequency domain of the input image.
Then, it uses a mask to get the high frequency part of the image.
Then, reverse the Fourier Transform to get the high frequency part of the image.
Finally, calculate the MSE loss between the high frequency part of the input image and the high frequency part of the output image.
This loss is used to make the output image more smooth and pay more attention on small target.

::

   def MSE_loss(self, y_true, y_pred):

        y_true = K.cast(y_true, "complex64")
        f = tf.signal.fft3d(y_true)
        fshift = tf.signal.fftshift(f)

        x1 = np.ones(shape=(4, 64, 64, 64, 3))
        x1[:, 16: 48, 16: 48, 16: 48, :] = 0
        x1 = tf.convert_to_tensor(x1)
        x1 = K.cast(x1, "complex64")
        fshift = tf.multiply(x=fshift, y=x1)

        ishift = tf.signal.ifftshift(fshift)
        himg = tf.signal.ifft3d(ishift)
        y_true2 = tf.abs(himg)


        y_pred = K.cast(y_pred, "complex64")
        f2 = tf.signal.fft3d(y_pred)
        fshift2 = tf.signal.fftshift(f2)
        x2 = np.ones(shape=(4, 64, 64, 64, 3))
        x2[:, 16: 48, 16: 48, 16: 48, :] = 0
        x2 = tf.convert_to_tensor(x2)
        x2 = K.cast(x2, "complex64")

        fshift2 = tf.multiply(x=fshift2, y=x2)

        ishift2 = tf.signal.ifftshift(fshift2)
        himg2 = tf.signal.ifft3d(ishift2)
        y_pred2 = tf.abs(himg2)


        mae = K.mean(K.abs(y_pred2 - y_true2), axis=[1,2,3,4])
        mse = K.mean(K.square(y_pred2 - y_true2), axis=[1,2,3,4])

        total_loss = mae * 0.6 + mse * 0.6


        return total_loss