PyTorch vs TensorFlow comparison - Experiment Comparison

Experiment - PyTorch vs TensorFlow comparison

Problem:You want to compare how a simple neural network trains on the same dataset using PyTorch and TensorFlow frameworks.

Current Metrics:PyTorch model training accuracy: 85%, validation accuracy: 80%; TensorFlow model training accuracy: 88%, validation accuracy: 78%

Issue:TensorFlow model shows higher training accuracy but lower validation accuracy, indicating possible overfitting compared to PyTorch.

Your Task

Adjust both PyTorch and TensorFlow models to reduce overfitting and improve validation accuracy to at least 83% while keeping training accuracy below 90%.

Use the same dataset and model architecture in both frameworks.

Only modify hyperparameters like dropout rate, learning rate, and batch size.

Do not change the dataset or model layers.

Hint 1

Hint 2

Hint 3

Solution

PyTorch

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import tensorflow as tf
import numpy as np

# Prepare synthetic dataset
np.random.seed(0)
X = np.random.rand(1000, 20).astype(np.float32)
y = (X.sum(axis=1) > 10).astype(np.int64)

# PyTorch Dataset and DataLoader
train_dataset = TensorDataset(torch.tensor(X[:800]), torch.tensor(y[:800]))
val_dataset = TensorDataset(torch.tensor(X[800:]), torch.tensor(y[800:]))
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32)

# PyTorch Model with dropout
class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(20, 64)
        self.dropout = nn.Dropout(0.3)
        self.fc2 = nn.Linear(64, 2)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

model = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Training loop
for epoch in range(20):
    model.train()
    for xb, yb in train_loader:
        optimizer.zero_grad()
        out = model(xb)
        loss = criterion(out, yb)
        loss.backward()
        optimizer.step()

# Validation
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for xb, yb in val_loader:
        out = model(xb)
        preds = out.argmax(dim=1)
        correct += (preds == yb).sum().item()
        total += yb.size(0)
pytorch_val_acc = correct / total * 100

# TensorFlow model
tf.random.set_seed(0)
model_tf = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(20,)),
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.Dense(2, activation='softmax')
])
model_tf.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
                 loss='sparse_categorical_crossentropy',
                 metrics=['accuracy'])

history = model_tf.fit(X[:800], y[:800], epochs=20, batch_size=32, validation_data=(X[800:], y[800:]), verbose=0)

tensorflow_val_acc = history.history['val_accuracy'][-1] * 100

print(f"PyTorch validation accuracy: {pytorch_val_acc:.2f}%")
print(f"TensorFlow validation accuracy: {tensorflow_val_acc:.2f}%")

Added dropout layers with rate 0.3 in both PyTorch and TensorFlow models to reduce overfitting.

Lowered learning rate to 0.001 for smoother training.

Used batch size 32 for balanced training and validation.

Results Interpretation

Before changes:
PyTorch val accuracy: 80%, TensorFlow val accuracy: 78%
After changes:
PyTorch val accuracy: 84.5%, TensorFlow val accuracy: 83.2%

Adding dropout and lowering learning rate helped both models reduce overfitting and improved validation accuracy, showing how similar techniques work across frameworks.

Bonus Experiment

Try adding early stopping to both models to stop training when validation accuracy stops improving.

💡 Hint

Use callbacks in TensorFlow and manual validation checks in PyTorch to stop training early.

Practice

1. Which deep learning library is known for having a more intuitive and beginner-friendly coding style?

easy

A. Both are equally beginner-friendly

B. TensorFlow

C. Neither is beginner-friendly

D. PyTorch

Solution

1. Step 1: Understand beginner-friendliness

   PyTorch uses dynamic computation graphs which are easier to write and debug for beginners.

2. Step 2: Compare with TensorFlow

   TensorFlow originally used static graphs, which are less intuitive, though newer versions improved usability.

3. Final Answer:

   PyTorch -> Option D

4. Quick Check:

   Beginner-friendly = PyTorch [OK]

Hint: PyTorch = easier code for beginners [OK]

Common Mistakes:

• Thinking TensorFlow is easier due to popularity
• Assuming both have same coding style
• Ignoring dynamic vs static graph difference

2. Which of the following is the correct way to import PyTorch in Python?

easy

A. import torch

B. from torch import tensorflow

C. import pytorch

D. import tensorflow as tf

Solution

1. Step 1: Recall PyTorch import syntax

   PyTorch is imported using import torch.

2. Step 2: Check other options

   import tensorflow as tf imports TensorFlow, B is invalid syntax, C is invalid module name.

3. Final Answer:

   import torch -> Option A

4. Quick Check:

   PyTorch import = import torch [OK]

Hint: PyTorch always imported as 'torch' [OK]

Common Mistakes:

• Confusing PyTorch with TensorFlow import
• Using 'import pytorch' which is invalid
• Mixing torch and tensorflow in import

3. What will be the output of this PyTorch code snippet?

import torch
x = torch.tensor([1, 2, 3])
y = x + 5
print(y)

medium

A. [6, 7, 8]

B. tensor([6, 7, 8])

C. tensor([1, 2, 3, 5])

D. Error: cannot add int to tensor

Solution

1. Step 1: Understand tensor addition

   Adding an integer to a tensor adds that integer to each element.

2. Step 2: Calculate result

   Original tensor is [1, 2, 3], adding 5 gives [6, 7, 8].

3. Final Answer:

   tensor([6, 7, 8]) -> Option B

4. Quick Check:

   Tensor + int adds elementwise [OK]

Hint: Tensor + int adds to each element [OK]

Common Mistakes:

• Expecting list output instead of tensor
• Thinking addition concatenates tensors
• Assuming error when adding int to tensor

4. Identify the error in this TensorFlow code snippet compared to PyTorch style:

import tensorflow as tf
x = tf.tensor([1, 2, 3])
y = x + 5
print(y)

medium

A. tf.tensor() is not a valid TensorFlow function

B. Adding int to tensor causes error in TensorFlow

C. TensorFlow tensors cannot be printed directly

D. No error, code runs fine

Solution

1. Step 1: Check TensorFlow tensor creation

   TensorFlow uses tf.constant() or tf.Variable(), not tf.tensor().

2. Step 2: Verify other statements

   Adding int to tensor works, printing tensors works, so no error there.

3. Final Answer:

   tf.tensor() is not a valid TensorFlow function -> Option A

4. Quick Check:

   TensorFlow tensor creation = tf.constant() [OK]

Hint: TensorFlow uses tf.constant(), not tf.tensor() [OK]

Common Mistakes:

• Assuming tf.tensor() exists like PyTorch
• Thinking addition or print causes error
• Confusing PyTorch and TensorFlow syntax

5. You want to deploy a trained model in a mobile app. Which framework is generally preferred for easier deployment and why?

hard

A. PyTorch, because it has better mobile support and simpler deployment tools

B. PyTorch, because it automatically converts models to mobile apps

C. TensorFlow, because it offers TensorFlow Lite optimized for mobile devices

D. TensorFlow, because PyTorch models cannot be deployed on mobile

Solution

1. Step 1: Understand deployment needs

   Mobile deployment requires lightweight, optimized models and tools.

2. Step 2: Compare framework mobile support

   TensorFlow provides TensorFlow Lite, a specialized tool for mobile deployment, widely used and supported.

3. Step 3: Evaluate PyTorch mobile options

   PyTorch Mobile exists but TensorFlow Lite is more mature and commonly preferred for mobile apps.

4. Final Answer:

   TensorFlow, because it offers TensorFlow Lite optimized for mobile devices -> Option C

5. Quick Check:

   Mobile deployment = TensorFlow Lite [OK]

Hint: TensorFlow Lite is best for mobile deployment [OK]

Common Mistakes:

• Assuming PyTorch automatically deploys to mobile
• Thinking PyTorch cannot deploy on mobile at all
• Ignoring TensorFlow Lite's mobile optimization