Gradient descent optimization in ML Python - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to update the weight using gradient descent.

ML Python

weight = weight - [1] * gradient

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

Aepoch

Bmomentum

Clearning_rate

Dloss

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'momentum' instead of 'learning_rate' for the step size.

Using 'loss' which is a measure, not a step size.

Using 'epoch' which counts iterations, not step size.

The learning rate controls how big a step we take in the direction of the negative gradient to update the weight.

2fill in blank

medium

Complete the code to calculate the gradient of the loss with respect to the weight.

ML Python

gradient = 2 * (prediction - target) * [1]

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

Alearning_rate

Bweight

Cbias

Depoch

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'learning_rate' which is unrelated to gradient calculation.

Using 'bias' which is a separate parameter.

Using 'epoch' which counts iterations.

The gradient is calculated by multiplying the error by the derivative of the prediction with respect to the weight, which is the input feature or weight itself depending on the model.

3fill in blank

hard

Fix the error in the code to correctly perform one step of gradient descent.

ML Python

weight = weight [1] learning_rate * gradient

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

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' which moves weights in the wrong direction.

Using '*' or '/' which are not correct operators for updating weights.

Gradient descent updates weights by moving in the negative direction of the gradient, so we subtract the product of learning rate and gradient.

4fill in blank

hard

Fill both blanks to create a dictionary of squared errors for each data point where error is less than 1.

ML Python

squared_errors = {x: (y - prediction)[1]2 for x, y in data.items() if abs(y - prediction) [2] 1}

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

A**

B<

C>

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' instead of '**' for squaring.

Using '>' instead of '<' for filtering.

We use '**' to square the error and '<' to filter errors less than 1.

5fill in blank

hard

Fill all three blanks to create a dictionary of weights updated by gradient descent for each feature.

ML Python

updated_weights = {feature: weights[feature] [1] learning_rate * gradients[[2]] for feature in features if gradients[feature] [3] 0}

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

A-

Bfeature

C>

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' instead of '-' for weight update.

Using '+' or '<' instead of '>' for filtering gradients.

Weights are updated by subtracting learning rate times gradient. The gradient is accessed by the feature key. We filter only positive gradients using '>'.

Practice

1. What is the main goal of gradient descent in machine learning?

easy

A. To minimize the error or loss function

B. To increase the number of model parameters

C. To randomly change model weights

D. To maximize the training time

Solution

1. Step 1: Understand gradient descent purpose

   Gradient descent is used to find the best model parameters by reducing errors.

2. Step 2: Connect to error minimization

   The algorithm updates parameters to minimize the loss function, which measures error.

3. Final Answer:

   To minimize the error or loss function -> Option A

4. Quick Check:

   Goal = minimize loss [OK]

Hint: Gradient descent reduces errors step-by-step [OK]

Common Mistakes:

• Thinking it increases parameters
• Believing it changes weights randomly
• Confusing it with training time increase

2. Which of the following is the correct update rule for a parameter \(\theta\) using gradient descent with learning rate \(\alpha\) and gradient \(\nabla J(\theta)\)?

easy

A. \(\theta = \theta - \alpha \nabla J(\theta)\)

B. \(\theta = \theta + \alpha \nabla J(\theta)\)

C. \(\theta = \alpha \nabla J(\theta) - \theta\)

D. \(\theta = \theta \times \alpha \nabla J(\theta)\)

Solution

1. Step 1: Recall gradient descent formula

   Gradient descent updates parameters by moving opposite to the gradient to reduce loss.

2. Step 2: Identify correct sign and terms

   The update is \(\theta = \theta - \alpha \nabla J(\theta)\), subtracting the gradient scaled by learning rate.

3. Final Answer:

   \(\theta = \theta - \alpha \nabla J(\theta)\) -> Option A

4. Quick Check:

   Update = subtract gradient [OK]

Hint: Subtract gradient times learning rate [OK]

Common Mistakes:

• Adding instead of subtracting gradient
• Multiplying parameters incorrectly
• Swapping terms order

3. Consider this Python code snippet for one step of gradient descent on parameter \(\theta\):

theta = 2.0
learning_rate = 0.1
gradient = 3.0

theta = theta - learning_rate * gradient
print(round(theta, 2))

What will be the printed output?

medium

A. -0.1

B. 1.3

C. 2.3

D. 1.7

Solution

1. Step 1: Calculate the update amount

   Update = learning_rate * gradient = 0.1 * 3.0 = 0.3

2. Step 2: Apply update to theta

   New theta = 2.0 - 0.3 = 1.7

3. Step 3: Check printed value

   Printed value is rounded to 2 decimals: 1.7

4. Final Answer:

   1.7 -> Option D

5. Quick Check:

   2.0 - 0.3 = 1.7 [OK]

Hint: Subtract learning_rate * gradient from theta [OK]

Common Mistakes:

• Adding instead of subtracting update
• Mixing gradient and learning rate
• Rounding incorrectly

4. The following code tries to perform one gradient descent step but has a bug:

theta = 5.0
learning_rate = 0.01
gradient = -4.0

theta = theta + learning_rate * gradient
print(theta)

What is the bug and how to fix it?

medium

A. No bug; code is correct

B. Bug: learning rate too small; fix by increasing it

C. Bug: sign error; fix by changing '+' to '-' in update

D. Bug: gradient sign wrong; fix by negating gradient

Solution

1. Step 1: Recall standard gradient descent formula

   The correct update is always \(\theta = \theta - \alpha \nabla J(\theta)\).

2. Step 2: Identify the bug in code

   The code uses '+' instead of '-', performing gradient ascent. With gradient = -4.0, code updates to 5.0 - 0.04 = 4.96 (wrong direction); correct is 5.0 + 0.04 = 5.04.

3. Final Answer:

   Bug: sign error; fix by changing '+' to '-' in update -> Option C

4. Quick Check:

   Always subtract lr * gradient [OK]

Hint: Always use '-' for gradient descent [OK]

Common Mistakes:

• Thinking '+' works for negative gradients
• Confusing ascent (+) with descent (-)
• Ignoring standard update rule

5. You run gradient descent with a very large learning rate \(\alpha = 10\) on a simple quadratic loss \(J(\theta) = (\theta - 3)^2\). What is the most likely outcome after a few steps starting from \(\theta=0\)?

hard

A. The parameter \(\theta\) converges smoothly to 3

B. The parameter \(\theta\) oscillates or diverges away from 3

C. The parameter \(\theta\) stays at 0 without change

D. The parameter \(\theta\) becomes negative infinity

Solution

1. Step 1: Understand effect of large learning rate

   A large learning rate causes big jumps in parameter updates, possibly overshooting the minimum.

2. Step 2: Analyze behavior on quadratic loss

   Since \(J(\theta) = (\theta - 3)^2\), gradient is \(2(\theta - 3)\). Large steps can cause \(\theta\) to jump past 3 repeatedly, causing oscillation or divergence.

3. Final Answer:

   The parameter \(\theta\) oscillates or diverges away from 3 -> Option B

4. Quick Check:

   Large learning rate causes oscillation [OK]

Hint: Too big steps cause oscillation, not smooth learning [OK]

Common Mistakes:

• Assuming large learning rate helps convergence
• Thinking parameter stays fixed
• Confusing divergence with negative infinity