Hi Edward,

While running your code, I have a question regarding preprocess(imgs).

def preprocess(imgs, to_rows=None, to_cols=None):
    if to_rows is None or to_cols is None:
        to_rows = img_rows
        to_cols = img_cols
    imgs_p = np.ndarray((imgs.shape[0], imgs.shape[1], to_rows, to_cols), dtype=np.uint8)
    for i in xrange(imgs.shape[0]):
        imgs_p[i, 0] = cv2.resize(imgs[i, 0], (to_cols, to_rows), interpolation=cv2.INTER_CUBIC)
    return imgs_p

At first, you define imgs_p with the shape of (batchsize, channel, to_rows,to_cols). However, in the resize function, you resize the original image to (to_cols, to_rows). It seems to me that it should resize to (to_rows,to_cols).

In fact, if I use the original shape, imgs_p[i, 0] = resize(imgs[i, 0], (to_cols, to_rows)) I got the following error message

Traceback (most recent call last): File "train.py", line 153, in <module> train_and_predict() File "train.py", line 92, in train_and_predict imgs_train = preprocess(imgs_train) File "train.py", line 81, in preprocess imgs_p[i, 0] = resize(imgs[i, 0], (to_cols, to_rows)) ValueError: could not broadcast input array from shape (80,64) into shape (64,80)

Would you like to take a look at this issue? Thank you very much.

Hi Edward,

During the training process for some data set, I can find the loss value computed for each epoch is negative, and it keeps decreasing along with different epochs; while dice_coef keeps increasing. Is this the right trend. For instance

Epoch 5/50 5250/5250 [==============================] - 284s - loss: -0.7539 - dice_coef: 0.7539 Epoch 6/50 5250/5250 [==============================] - 283s - loss: -0.7808 - dice_coef: 0.7808 Epoch 7/50 5250/5250 [==============================] - 283s - loss: -0.7891 - dice_coef: 0.7891 Epoch 8/50 5250/5250 [==============================] - 283s - loss: -0.8074 - dice_coef: 0.8074 Epoch 9/50

At the same time, for some other data sets, I can see the loss value is of positive. I am kind of curious why the loss value gets negative for some data set, while loss value gets positive for some other data sets. What's the best way to evaluate whether the training process goes well based on the envolving process of loss and dice_coef for each epoch.

Thank you very much.

ouyang

Hi Edward,

I have a question regarding the image pre-processing part.

Were you trying to scale the image array to [0, 1] range, or keep the image array in [0, 255] range? Which one will be better for training the neural network?

I checked your code, it seems that the image array is still in the range of [0,255] after the function of standartize(self, array, to_float=False)? Is that right? Thanks.

Hi Edward,

When reading the code, I can see you use dice_coef for the performance metric. But I am not very clear why you need to setup dice_loss as -dice_coef. Is that because the higher dice_coef is, the better is performance. As a result, you try to minimize its opposite, dice_loss. Is my understanding correct?

Secondly, why you setup IMG_ROWS, IMG_COLS = 80, 112. It seems to me the training set has rows=480,and cols=520.

Thanks,

Hi Edward,

Regarding the the main optimization step

model.fit( x_train, [y_train, y_train_2], validation_data=(x_valid, [y_valid, y_valid_2]), batch_size=128, nb_epoch=50, verbose=1, shuffle=True, callbacks=[model_save_best, model_checkpoint, early_s] )

How many iterations within each epoch will it be included? Here, we have about 5635 pairs of training images and training mask images. If batch_size=64, should it be 5635/32 iterations? I did not find a place where this parameter of training_iters are setup. Will it be handled automatically by model.fit?

Thank you very much.

Hi Edward,

Thanks for sharing your code.

Would you like to help clarify some questions?

1. What are the differences between train.py, train_generator.py and train_kfold.py?
2. In the description, you mentioned “2 heads training: auxiliary branch for scoring nerve presence (in the middle of the network), one branch for segmentation”? How do you instantiate? Or in which part of the code, you implement this mechanism?

Thanks a lot.

Hi Edward,

In this u-net implementation, there are multiple usages of "merge" along with "upsampling". For instance. up6 = merge([UpSampling2D(size=(2, 2))(conv5), after_conv4], mode='concat', concat_axis=1)

I can see that upsampling is to enlarge the size of layer, like conv5. In some paper, like Fully Convolutional Network, they usetransposed convolution, (the corresponding Keras implementation is Deconvolution2D). Does it make sense to use Deconvolution2D to replace upsampling2D?

Thanks.

Hi Edward, tks for your code, I look at your network structure, find its a mixture of res-like blocks and inception blocks, so I have two questions

1. how do you figure out this structure ? how much better than u-net after the changes ?
2. u-net didnot use padding, but here you use same-padding ? does this matter ?

Hi Edward,

Thanks for your code! It's simply amazing! I am trying to run it and adapt it for my own project.

When I call the function data.py, it creates the .npy files correctly and when I try to open and see those files, I got the following result:

array([[[[0, 0, 0, ..., 0, 0, 0], [0, 0, 0, ..., 0, 0, 0], [0, 0, 0, ..., 0, 0, 0], ..., [0, 0, 0, ..., 0, 0, 0], [0, 0, 0, ..., 0, 0, 0], [0, 0, 0, ..., 0, 0, 0]]],

All the .npy are empty and I'd say this is not good :(

Maybe you have a function to convert these numpy array files to image format?

Thanks for your help.

I notice that you use merge to concat 4 layer,like this: res = merge([c1_1, c2_3, c3_3, c4_2], mode='concat', concat_axis=1) but as I know ,merge can only concat 2 layers,and the first 2 layers have different shape,error shows like: ValueError: "concat" mode can only merge layers with matching output shapes except for the concat axis. Layer shapes: [(None, 1, 80, 8), (None, 1, 80, 16), (None, 1, 80, 4), (None, 1, 80, 4)] I do not know why you concat different shape like that.

Dear Edward: Thanks for your sharing. But when I run train.py, it cast our an error:ValueError: Filter must not be larger than the input: Filter: (3, 1) Input: (1, 80). Do you know why?