Hi @xuuuuuuchen ,

Thanks for sharing the code very much.

1. What's the input shape in AC loss?
   Intuitively, the input shape is:
   y_true.shape = (batch_size, class num, img_x, img_y) = y_pred.shape.
   For ACDC dataset, the shape is (batch_size, 4, 256,256).

However, in the discussion part, the paper said, "the proposed loss function can also be extended to solve multi-phase segmentation problems". Thus, it means the paper uses AC loss in a binary version, right?

2. A technique question: what's the purpose for following code?
   

   Active-Contour-Loss/Active-Contour-Loss.py

   Lines 17 to 18 in f90dd4a

   	delta_x = x[:,:,1:,:-2]**2
   	delta_y = y[:,:,:-2,1:]**2

Best,
Jun

Hi @xuuuuuuchen ,

I really enjoy your paper on active contour loss.
When the code will be released?

Best,
Jun

Hi:
I wonder what the input image is and can I apply AC loss individually without Dice loss.
Can I apply AC loss in 3D neural network ,such as 3D UNet

best wishes

For example:

C_2 = np.zeros((256, 256))
...
region_out = K.abs(K.sum( (1-y_pred[:,0,:,:]) * ((y_true[:,0,:,:] - C_2)**2) ))

So you're subtracting a tensor of all zeros from y_true in (y_true[:,0,:,:] - C_2)?

Hi, I have some questions about the length.
T(length) is the length of target;P(length) is the length of prediction.
And the |P-T| is the component of the loss.
All Right?

Hi Xu,

I had used AC Loss to try seg 2-class images. Although the loss is decreasing, dice score doesn't improve at all. On the contrary, dice score is at a fairly low value, about 0.0001.

`
class ActiveContourLoss(Module):
def init(self):
super(ActiveContourLoss, self).init()

def forward(self, y_pred, y_true):

    x = y_pred[:,:,1:,:] - y_pred[:,:,:-1,:] # horizontal and vertical directions 
    y = y_pred[:,:,:,1:] - y_pred[:,:,:,:-1]
    
    delta_x = x[:,:,1:,:-2]**2
    delta_y = y[:,:,:-2,1:]**2
    delta_u = torch.abs(delta_x + delta_y)
    
    epsilon = 0.00000001 # where is a parameter to avoid square root is zero in practice.
    w = 1.

    lenth = w * torch.sum(torch.sqrt(delta_u + epsilon)) # equ.(11) in the paper

    C_1 = torch.ones(y_true.shape, dtype=torch.float32).cuda()
    C_2 = torch.zeros(y_true.shape, dtype=torch.float32).cuda()

    region_in = torch.abs(torch.sum(y_pred * ((y_true - C_1)**2)) ) # equ.(12) in the paper
    region_out = torch.abs(torch.sum((1. - y_pred) * ((y_true - C_2)**2))) # equ.(12) in the paper
    
    lambdaP = 5. # lambda parameter could be various.
    loss = lenth + lambdaP * (region_in + region_out) 

    return loss

`

this is my pytorch implemention, y_pred[:,0,:,:] what is the mean 0, is channels? and y_pred as the input need to sigmoid? the input shape is (channel, batchsize, H, W) or (batchsize, channel, H, W) .
My y_pred shape is (16, 1, 512, 512).So i need modify it?

Best,
qaqzzz

Hi,
I admire you for having such a good job.At the same time, I have a question for you:
If it is a grayscale image, how to determine the length of the segmented part?

I am looking forward to your reply.Thanks!

Hi! Xu,
I am quite confused about the detailed structure of Dense-Unet in your work. Is that the same network as ‘Fully Dense UNet for 2D Sparse Photoacoustic Tomography Artifact Remova’ said? Looking forward to your reply! Thank you very much!

Hi @xuuuuuuchen ,

I get some trouble to understand the implementation to compute the coutour length.

	x = y_pred[:,:,1:,:] - y_pred[:,:,:-1,:] # horizontal and vertical directions 
	y = y_pred[:,:,:,1:] - y_pred[:,:,:,:-1]

	delta_x = x[:,:,1:,:-2]**2
	delta_y = y[:,:,:-2,1:]**2
	delta_u = K.abs(delta_x + delta_y) 

According to implementation above, I draw an illustration to visualize the y_pred, delta_x and delta_y:

As you can see, the delta_x and delta_y are not well aligned in the coordinate. In that case, the extracted coutour might be be incorrect.

Could you help me figure out what's wrong with my understanding?

Many thanks!

Hi @xuuuuuuchen

In another issue, you said that the input shape in AC loss is [Batch, 1, W, H].

Dose it mean that the y_pred is an output of softmax layer followed by an argmax operator or a pick operator to pick out the probability of fg(or bg)?

If the shape of y_pred is [Batch, 1, W, H], why do you pick the first channel (y_pred[:, 0, :, :]) when you implement the Eq[12] but not do so when you implement the Eq[11] ?

Hi, all;
Recently, we reimplemented 2D and 3D AC loss in different ways, and also introduced a novel term (elastica term) to AC loss ACELoss.
Xiangde Luo.

Hello everyone! I tried to implement the AC loss function on a U-Net model.
I am using the the AC loss as loss function and the Dice Coefficient as metric.

I am using the NIH dataset for training (https://wiki.cancerimagingarchive.net/display/Public/Pancreas-CT).
Since the data format is different (8, 256, 256, 1), I changed the indexes.

My code is the following:

def Active_Contour_Loss(y_true, y_pred): 
    
    y_true = K.cast(y_true, dtype = 'float64') 
    y_pred = K.cast(y_pred, dtype = 'float64') 
    
    """
    lenth term
    """
       
    #Reordered indexes, because data format is different.
    x = y_pred[:,1:,:,:] - y_pred[:,:-1,:,:] #y_true shape is: (8, 256, 256, 1)  
    y = y_pred[:,:,1:,:] - y_pred[:,:,:-1,:] #y_pred shape is: (8, 256, 256, 1)
        
    delta_x = x[:,1:,:-2,:]**2
    delta_y = y[:,:-2,1:,:]**2    
    
    delta_u = K.abs(delta_x + delta_y) 

    epsilon = 0.00000001 # where is a parameter to avoid square root is zero in practice.
    w = 1
    lenth = w * K.sum(K.sqrt(delta_u + epsilon)) # equ.(11) in the paper

    """
    region term
    """

    C_1 = np.ones((256, 256))
    C_2 = np.zeros((256, 256))    
    
    #Reordered indexes, because data format is different.
    region_in = K.abs(K.sum( y_pred[:,:,:,0] * ((y_true[:,:,:,0] - C_1)**2) ) ) # equ.(12) in the paper
    region_out = K.abs(K.sum( (1-y_pred[:,:,:,0]) * ((y_true[:,:,:,0] - C_2)**2) )) # equ.(12) in the paper

    lambdaP = 1 # lambda parameter could be various.
	
    loss =  lenth + lambdaP * (region_in + region_out) # equ. (8) in the paper
    
    return loss

However, the output of the training does not go well:

Epoch 1/20
18750/18750 - 3202s - loss: 3657.6096 - dice_coef: 0.0187 - val_loss: 909.7355 - val_dice_coef: 0.5784
Epoch 2/20
18750/18750 - 3150s - loss: 716.8154 - dice_coef: 0.0240 - val_loss: 909.7353 - val_dice_coef: 0.5785
Epoch 3/20
18750/18750 - 3158s - loss: 717.3530 - dice_coef: 0.0230 - val_loss: 909.7353 - val_dice_coef: 0.5785
Epoch 4/20
18750/18750 - 3161s - loss: 718.0414 - dice_coef: 0.0221 - val_loss: 909.7353 - val_dice_coef: 0.5785
Epoch 5/20
18750/18750 - 3126s - loss: 717.6503 - dice_coef: 0.0222 - val_loss: 909.7353 - val_dice_coef: 0.5785
Epoch 6/20
18750/18750 - 3133s - loss: 718.0792 - dice_coef: 0.0229 - val_loss: 909.7353 - val_dice_coef: 0.5785
Epoch 7/20
18750/18750 - 3092s - loss: 717.6919 - dice_coef: 0.0229 - val_loss: 909.7353 - val_dice_coef: 0.5785

Any ideas what I am doing wrong?

Thanks in advance!