Architecture search concepts in Computer Vision - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a simple convolutional layer in a neural network.

Computer Vision

conv_layer = Conv2D(filters=32, kernel_size=3, activation=[1])

Drag options to blanks, or click blank then click option'

A'softmax'

B'sigmoid'

C'relu'

D'linear'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'softmax' in a convolutional layer activation instead of ReLU.

Forgetting to add an activation function.

The ReLU activation function is commonly used in convolutional layers to introduce non-linearity and help the model learn complex patterns.

2fill in blank

medium

Complete the code to add a pooling layer after a convolutional layer.

Computer Vision

pool_layer = MaxPooling2D(pool_size=[1])

Drag options to blanks, or click blank then click option'

A(3, 3)

B(2, 2)

C(1, 1)

D(4, 4)

Attempts:

3 left

💡 Hint

Common Mistakes

Using a pool size of (1, 1) which does not reduce dimensions.

Choosing too large pool sizes that overly reduce feature maps.

A pool size of (2, 2) is commonly used to reduce the spatial dimensions by half, helping to reduce computation and control overfitting.

3fill in blank

hard

Fix the error in the code to correctly compile a model with categorical crossentropy loss.

Computer Vision

model.compile(optimizer='adam', loss=[1], metrics=['accuracy'])

Drag options to blanks, or click blank then click option'

A'categorical_crossentropy'

B'hinge'

C'binary_crossentropy'

D'mean_squared_error'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'binary_crossentropy' for multi-class problems.

Using regression loss functions like 'mean_squared_error' incorrectly.

For multi-class classification problems, 'categorical_crossentropy' is the correct loss function to use.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps layer names to their output shapes if the output has more than 2 dimensions.

Computer Vision

layer_shapes = {layer.name: layer.output_shape for layer in model.layers if [1] > [2]

Drag options to blanks, or click blank then click option'

Alen(layer.output_shape)

B2

Clayer.name

Dlayer.output_shape

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing layer.name to a number.

Using layer.output_shape directly in comparison without len().

We use len(layer.output_shape) to get the number of dimensions and filter layers with output shapes having more than 2 dimensions.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps layer names to the number of parameters if the layer has more than 1000 parameters.

Computer Vision

param_counts = {layer.[1]: layer.[2] for layer in model.layers if layer.[3] > 1000}

Drag options to blanks, or click blank then click option'

Aname

Bcount_params()

Doutput_shape

Attempts:

3 left

💡 Hint

Common Mistakes

Using layer.output_shape instead of count_params().

Not calling count_params() as a method.

We access layer.name for the key, use layer.count_params() to get the number of parameters for the value and filter layers with more than 1000 parameters.

Practice

1. What is the main goal of architecture search in computer vision models?

easy

A. To collect more training data

B. To manually tune model parameters

C. To automatically find the best model design

D. To reduce image resolution

Solution

1. Step 1: Understand architecture search purpose

   Architecture search aims to find the best model design automatically without manual trial and error.

2. Step 2: Compare options

   Options B, C, and D do not describe architecture search goals. Only To automatically find the best model design matches the goal.

3. Final Answer:

   To automatically find the best model design -> Option C

4. Quick Check:

   Architecture search = automatic best design [OK]

Hint: Architecture search = automatic model design finder [OK]

Common Mistakes:

• Confusing architecture search with data collection
• Thinking it manually tunes parameters
• Mixing it with image preprocessing

2. Which of the following is a correct way to describe a search space in architecture search?

easy

A. A set of possible model designs to explore

B. The training dataset used for the model

C. The final accuracy metric after training

D. The hardware used to run the model

Solution

1. Step 1: Define search space

   Search space is the collection of all possible model designs or configurations that the search will try.

2. Step 2: Eliminate incorrect options

   Options B, C, and D relate to data, metrics, or hardware, not the search space itself.

3. Final Answer:

   A set of possible model designs to explore -> Option A

4. Quick Check:

   Search space = possible designs [OK]

Hint: Search space = all model options to try [OK]

Common Mistakes:

• Confusing search space with dataset
• Thinking search space is a metric
• Mixing search space with hardware details

3. Consider this pseudocode for architecture search:

for model in search_space:
    accuracy = train_and_evaluate(model)
    if accuracy > best_accuracy:
        best_model = model
        best_accuracy = accuracy
print(best_accuracy)

What does this code output?

medium

A. The list of all models tested

B. The accuracy of the best model found

C. The training loss of the last model

D. The total number of models in search_space

Solution

1. Step 1: Analyze the loop

   The loop trains and evaluates each model, updating best_accuracy if current accuracy is higher.

2. Step 2: Understand the print statement

   After checking all models, it prints the highest accuracy found among them.

3. Final Answer:

   The accuracy of the best model found -> Option B

4. Quick Check:

   Prints best accuracy = highest accuracy [OK]

Hint: Code prints highest accuracy found during search [OK]

Common Mistakes:

• Thinking it prints number of models
• Confusing accuracy with loss
• Assuming it prints all models

4. The following code snippet is intended to find the best model architecture, but it has a bug:

best_accuracy = 0
for model in search_space:
    accuracy = train_and_evaluate(model)
    if accuracy < best_accuracy:
        best_model = model
        best_accuracy = accuracy
print(best_accuracy)

What is the bug?

medium

A. best_accuracy should start at 1 instead of 0

B. train_and_evaluate should return loss, not accuracy

C. The print statement should print best_model, not best_accuracy

D. The comparison operator should be > instead of <

Solution

1. Step 1: Understand the goal

   The goal is to find the model with the highest accuracy, so we want to update when accuracy is greater than best_accuracy.

2. Step 2: Identify the bug

   The code uses accuracy < best_accuracy, which updates for worse accuracy, so it should be accuracy > best_accuracy.

3. Final Answer:

   The comparison operator should be > instead of < -> Option D

4. Quick Check:

   Use > to find best accuracy [OK]

Hint: Best accuracy means use >, not < in comparison [OK]

Common Mistakes:

• Starting best_accuracy at wrong value
• Printing wrong variable
• Confusing accuracy with loss

5. You want to speed up architecture search by reducing the search space size. Which strategy is best?

hard

A. Limit model depth and number of layers to a smaller range

B. Increase the number of training epochs for each model

C. Use a slower but more accurate optimizer

D. Train all models on the full dataset without sampling

Solution

1. Step 1: Understand search space impact

   Reducing search space size means limiting the number of possible model designs to try.

2. Step 2: Evaluate options

   Limit model depth and number of layers to a smaller range reduces model complexity range, shrinking search space. Options A, B, and D increase training time or data size, slowing search.

3. Final Answer:

   Limit model depth and number of layers to a smaller range -> Option A

4. Quick Check:

   Smaller search space = fewer model options [OK]

Hint: Shrink search space by limiting model complexity [OK]

Common Mistakes:

• Thinking more training epochs speed up search
• Choosing slower optimizers to improve speed
• Using full dataset always speeds search