Q1. At the heart of image segmentation with neural networks is an encoder/decoder architecture. What functionalities do they perform?

Answer: The encoder extracts features from an image and the decoder takes those extracted features and assigns class labels to each pixel of the image.

Q2. Is the following statement true regarding SegNet, UNet and Fully Convolutional Neural Networks (FCNNs):

Unlike the similarity between the architecture design of SegNet & UNet, FCNNs do not have a symmetric architecture design.

Answer: True

Question 3

What architectural difference does the numberrepresent in the names of FCN-32, FCN-16, FCN-8 ?

Answer:

Question 4

Take a look at the following code and select the type of scaling that will be performed

x = UpSampling2D(

size=(2, 2),

data_format=None,

interpolation=’bilinear’)(x)

Answer: 

Question 5

What does the following code do?

Conv2DTranspose(

filters=32,

kernel_size=(3, 3)

)

Answer: 

Question 6

The following is the code for the last layer of a FCN-8 decoder. What key change is required if we want this to be the last layer of a FCN-16 decoder ?

def fcn8_decoder(convs, n_classes):

…

o = tf.keras.layers.Conv2DTranspose(n_classes, kernel_size=(8,8), strides=(8,8)) (0)

o = (tf.keras.layers.Activation(‘softmax’)) (0)

return o

Answer: kernel_size=(16, 16)

Question 7:

Which of the following is true about Intersection Over Union (IoU) and Dice Score, when it comes to evaluating image segmentation? (Choose all that apply.)

Answer:

Both have a range between 0 and 1

For IoU the numerator is the area of overlap for both the labels, predicted and ground truth, whereas for Dice Score the numerator is 2 times that.

Question 8:

Consider the following code for building the encoder blocks for a U-Net. What should this function return?

def unet_encoder_block(inputs, n_filters, pool_size, dropout): blocks = conv2d_block(inputs, n_filters=n_filters)

after_pooling = tf.keras.layers.MaxPooling2D(pool_size)(blocks)

after_dropout = tf.keras.layers.Dropout(dropout)(after_pooling)

return # your code here

Answer:

Question 9

For U-Net, on the decoder side you combine skip connections which come from the corresponding level of the encoder. Consider the following code and provide the missing line required to account for those skip connections with the upsampling.

(Important Notes: Use TensorFlow as tf, Keras as keras. And be mindful of python spacing convention, i.e (x, y) not (x,y) )

def decoder_block(inputs, conv_output, n_filters, kernel_size, strides, dropout):

upsampling_layer = tf.keras.layers.Conv2DTranspose(n_filters, kernel_size, strides = strides, padding=’same’)(inputs)

skip_connection_layer = # your code here

skip_connection_layer = tf.keras.layers.Dropout(dropout)(skip_connection_layer)

skip_connection_layer = conv2d_block(skip_connection_layer, n_filters, kernel_size=3)

return skip_connection_layer

Answer: 

tf.keras.layers.concatenate([upsampling_layer, conv_output])

1.

Question 1

One of the ways of declaring a loss function is to import its object. Is the following code correct for using a loss object?

True

False

Answer: False

2.

Question 2

It is possible to add parameters to the object call when using the loss object.

True

False

Answer: True

3.

Question 3

You learned that you can do hyperparameter tuning within custom-built loss functions by creating a wrapper function around the loss function with hyperparameters defined as its parameter. What is the purpose of creating a wrapper function around the original loss function?

No particular reason, it just looks neater this way.

The loss ( model.compile(…, loss = ) ) expects a function that is only a wrapper function to the loss function itself.

That’s one way of doing it. We can also do the same by passing y_true, y_pred and threshold as parameters to the loss function itself.

The loss ( model.compile(…, loss = ) ) expects a function with two parameters, y_true and y_pred, so it is not possible to pass a 3rd parameter (threshold) to the loss function itself. This can be achieved by creating a wrapper function around the original loss function.

Answer: The loss ( model.compile(…, loss = ) ) expects a function with two parameters, y_true and y_pred, so it is not possible to pass a 3rd parameter (threshold) to the loss function itself. This can be achieved by creating a wrapper function around the original loss function.

4.

Question 4

One other way of implementing a custom loss function is by creating a class with two function definitions, init and call.

Which of the following is correct?

We pass y_true and y_pred to the init function, the hyperparameter (threshold) to the call function.

We pass the hyperparameter (threshold) , y_true and y_pred to the call function, and the init function returns the call function.

We pass the hyperparameter (threshold) to the init function, y_true and y_pred to the call function.

We pass the hyperparameter (threshold) , y_true and y_pred to the init function, and the call function returns the init function.

Answer:We pass the hyperparameter (threshold) to the init function, y_true and y_pred to the call function.

5.

Question 5

The formula for the contrastive loss, the function that is used in the siamese network for calculating image similarity, is defined as following:

Check all that are true:

If the euclidean distance between the pair of images is low then it means the images are similar.

Y is the tensor of details about image similarities.

Ds are 1 if images are similar, 0 if they are not.

Margin is a constant that we use to enforce a maximum distance between the two images in order to consider them similar or different from one another.

Answer:

• Y is the tensor of details about image similarities.
• If the euclidean distance between the pair of images is low then it means the images are similar.