Why training optimizes model weights in TensorFlow - Experiment to Prove It

Experiment - Why training optimizes model weights

Problem:We want to understand how training changes model weights to make better predictions.

Current Metrics:Initial model accuracy is around 10% (random guessing) on the MNIST digit dataset.

Issue:The model starts with random weights and poor accuracy. We need to see how training improves weights and accuracy.

Your Task

Train a simple neural network on MNIST and observe how weights change and accuracy improves after training.

Use TensorFlow and Keras.

Use a simple model with one hidden layer.

Train for 5 epochs only.

Hint 1

Hint 2

Hint 3

Solution

TensorFlow

import tensorflow as tf
from tensorflow.keras import layers, models

# Load MNIST data
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# Normalize data
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# Flatten images
x_train = x_train.reshape(-1, 28*28)
x_test = x_test.reshape(-1, 28*28)

# Build simple model
model = models.Sequential([
    layers.Dense(64, activation='relu', input_shape=(28*28,)),
    layers.Dense(10, activation='softmax')
])

# Compile model
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Print weights before training
print('Weights before training:')
for layer in model.layers:
    weights = layer.get_weights()
    if weights:
        print(weights[0].shape, 'weights sample:', weights[0][0][:5])

# Train model
history = model.fit(x_train, y_train, epochs=5, batch_size=32, validation_split=0.1, verbose=2)

# Print weights after training
print('Weights after training:')
for layer in model.layers:
    weights = layer.get_weights()
    if weights:
        print(weights[0].shape, 'weights sample:', weights[0][0][:5])

# Evaluate on test data
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
print(f'Test accuracy after training: {test_acc:.4f}')

Built a simple neural network with one hidden layer.

Normalized and flattened input images.

Compiled model with Adam optimizer and accuracy metric.

Printed weights before and after training to observe changes.

Trained model for 5 epochs to improve accuracy.

Results Interpretation

Before training: Weights are random, accuracy is about 10% (random guessing).

After training: Weights have changed significantly, accuracy improved to ~95% on training and ~94% on test data.

Training adjusts model weights step-by-step to reduce errors, making predictions more accurate. This shows how optimization during training improves model performance.

Bonus Experiment

Try training the same model but with a smaller hidden layer (e.g., 16 neurons) and observe how accuracy and weight changes differ.

💡 Hint

Smaller models may learn slower or less accurately, so compare training curves and weights.

Practice

1. Why does training a TensorFlow model update its weights?

easy

A. To reduce the difference between predicted and actual values

B. To increase the size of the model

C. To make the code run faster

D. To change the input data

Solution

1. Step 1: Understand the purpose of training

   Training adjusts model weights to make predictions closer to actual results.

2. Step 2: Connect weight updates to prediction accuracy

   By changing weights, the model reduces errors between predicted and true values.

3. Final Answer:

   To reduce the difference between predicted and actual values -> Option A

4. Quick Check:

   Training improves predictions = B [OK]

Hint: Training improves predictions by adjusting weights [OK]

Common Mistakes:

• Thinking training changes input data
• Believing training makes code faster
• Assuming training increases model size

2. Which TensorFlow code snippet correctly applies an optimizer to update model weights during training?

easy

A. tf.Variable(0.1)

B. model.compile(optimizer='adam', loss='mse')

C. model.fit(x_train, y_train, epochs=10)

D. optimizer.apply_gradients(zip(grads, model.trainable_variables))

Solution

1. Step 1: Identify optimizer usage for weight updates

   The method apply_gradients directly updates weights using gradients.

2. Step 2: Differentiate from other code snippets

   compile sets training config, fit runs training loop, and tf.Variable creates variables but does not update weights.

3. Final Answer:

   optimizer.apply_gradients(zip(grads, model.trainable_variables)) -> Option D

4. Quick Check:

   apply_gradients updates weights = A [OK]

Hint: apply_gradients method updates weights directly [OK]

Common Mistakes:

• Confusing compile with weight update
• Thinking fit updates weights directly
• Using tf.Variable as optimizer

3. Given this TensorFlow training step code, what will be printed?

import tensorflow as tf

model = tf.keras.Sequential([tf.keras.layers.Dense(1)])
optimizer = tf.keras.optimizers.SGD(learning_rate=0.1)

x = tf.constant([[1.0]])
y = tf.constant([[2.0]])

with tf.GradientTape() as tape:
    prediction = model(x)
    loss = tf.reduce_mean((y - prediction) ** 2)
grads = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
print(loss.numpy())

medium

A. A negative number

B. Zero

C. A positive number close to 1.0

D. An error because of missing input

Solution

1. Step 1: Understand the loss calculation

   Loss is mean squared error between prediction and target; initially weights are random, so loss is positive.

2. Step 2: Check if loss can be zero or negative

   Loss is squared difference, so cannot be negative or zero at first step.

3. Final Answer:

   A positive number close to 1.0 -> Option C

4. Quick Check:

   Initial loss positive ~1.0 = A [OK]

Hint: Initial loss is positive because weights start random [OK]

Common Mistakes:

• Expecting zero loss before training
• Thinking loss can be negative
• Assuming code throws error

4. This TensorFlow code tries to update model weights but does not change them. What is the error?

import tensorflow as tf

model = tf.keras.Sequential([tf.keras.layers.Dense(1)])
optimizer = tf.keras.optimizers.Adam(learning_rate=0.01)

x = tf.constant([[1.0]])
y = tf.constant([[2.0]])

with tf.GradientTape() as tape:
    prediction = model(x)
    loss = tf.reduce_mean((y - prediction) ** 2)
grads = tape.gradient(loss, model.trainable_variables)
# Missing apply_gradients call here
print(model.trainable_variables[0].numpy())

medium

A. The optimizer is not applied to update weights

B. GradientTape is used incorrectly

C. Loss calculation is wrong

D. Model layers are not defined

Solution

1. Step 1: Check if optimizer updates weights

   The code calculates gradients but never calls apply_gradients, so weights stay the same.

2. Step 2: Verify other parts are correct

   GradientTape and loss calculation are correct; model layers exist.

3. Final Answer:

   The optimizer is not applied to update weights -> Option A

4. Quick Check:

   Missing apply_gradients means no weight update = C [OK]

Hint: Always call apply_gradients to update weights [OK]

Common Mistakes:

• Forgetting to apply gradients
• Thinking GradientTape updates weights
• Assuming loss error stops training

5. You want to train a TensorFlow model to predict house prices. Why is it important that the training process updates the model's weights using an optimizer and loss function?

hard

A. Because updating weights makes the training run faster without changing predictions

B. Because updating weights helps the model learn patterns from data to make better predictions

C. Because updating weights changes the input features to match the output

D. Because updating weights increases the model size to handle more data

Solution

1. Step 1: Understand the role of weights in prediction

   Weights control how input features affect the output prediction in the model.

2. Step 2: Explain why updating weights matters

   Updating weights using optimizer and loss reduces prediction errors by learning from data patterns.

3. Step 3: Eliminate incorrect options

   Weights do not increase model size, change inputs, or only speed training without improving predictions.

4. Final Answer:

   Because updating weights helps the model learn patterns from data to make better predictions -> Option B

5. Quick Check:

   Weight updates improve prediction accuracy = D [OK]

Hint: Weights learn data patterns to improve predictions [OK]

Common Mistakes:

• Confusing weight updates with input changes
• Thinking weight updates increase model size
• Believing weight updates only speed training