TensorFlow vs PyTorch comparison - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Key difference in execution style between TensorFlow and PyTorch

Which statement best describes the main difference in how TensorFlow and PyTorch execute operations?

A TensorFlow uses dynamic computation graphs, while PyTorch uses static computation graphs.

B TensorFlow uses static computation graphs, while PyTorch uses dynamic computation graphs.

C Both TensorFlow and PyTorch use only static computation graphs.

D Both TensorFlow and PyTorch use only dynamic computation graphs.

💡 Hint

Think about when the computation graph is built and executed in each framework.

TensorFlow builds a static graph before running computations, while PyTorch builds the graph dynamically during execution.

❓ Predict Output

intermediate

Output shape after PyTorch tensor operation

What is the shape of the tensor y after running this PyTorch code?

TensorFlow

import torch
x = torch.randn(3, 4)
y = x.view(-1, 2)
print(y.shape)

A torch.Size([6, 2])

B torch.Size([3, 2])

C torch.Size([2, 6])

D torch.Size([4, 3])

💡 Hint

Remember that view(-1, 2) reshapes the tensor to have 2 columns and infers the number of rows.

The original tensor has 3*4=12 elements. Reshaping to (-1, 2) means 12/2=6 rows and 2 columns.

❓ Model Choice

advanced

Choosing framework for research with frequent model changes

You are a researcher who needs to frequently change and debug your neural network models. Which framework is generally better suited for this purpose?

A TensorFlow, because its static graphs make debugging easier.

B PyTorch, because it requires less memory for static graphs.

C TensorFlow, because it has better GPU support for research.

D PyTorch, because its dynamic graphs allow easier model changes and debugging.

💡 Hint

Consider which framework builds the computation graph on the fly.

PyTorch's dynamic graph lets you change the model structure easily and debug line-by-line, which is helpful in research.

❓ Hyperparameter

advanced

Default behavior difference in training mode between TensorFlow and PyTorch

When switching between training and evaluation modes, which statement correctly describes the default behavior difference between TensorFlow and PyTorch?

A In PyTorch, you must call <code>model.train()</code> or <code>model.eval()</code> to toggle training mode; TensorFlow manages this automatically during training and inference.

B In TensorFlow, layers like dropout are always active unless explicitly disabled; in PyTorch, dropout is disabled by default.

C Both TensorFlow and PyTorch require manual toggling of training and evaluation modes for layers like dropout.

D TensorFlow disables dropout during training by default, while PyTorch enables it during evaluation.

💡 Hint

Think about how each framework handles layers like dropout during training and evaluation.

PyTorch requires explicit calls to model.train() or model.eval() to switch modes. TensorFlow manages this internally during fit and predict calls.

❓ Metrics

expert

Comparing model accuracy reporting between TensorFlow and PyTorch

You train a classification model in both TensorFlow and PyTorch using the same dataset and architecture. After training, you want to compare accuracy metrics. Which statement is true about how accuracy is typically computed and reported in these frameworks?

A Both TensorFlow and PyTorch provide built-in accuracy metrics that automatically compute overall accuracy without manual aggregation.

B PyTorch's accuracy metric automatically averages accuracy over batches, while TensorFlow requires manual calculation of accuracy over the entire dataset.

C TensorFlow's built-in accuracy metric automatically averages accuracy over batches, while PyTorch requires manual calculation of accuracy over the entire dataset.

D Neither TensorFlow nor PyTorch provide built-in accuracy metrics; accuracy must always be computed manually.

💡 Hint

Consider how metrics are implemented and used in each framework's training loops.

TensorFlow's Keras API provides built-in accuracy metrics that handle averaging internally. PyTorch users often compute accuracy manually across batches.

Practice

1. Which of the following is a key advantage of TensorFlow compared to PyTorch?

easy

A. Better support for deploying models in production environments

B. More intuitive and Pythonic coding style

C. Easier to debug with dynamic computation graphs

D. Primarily used for small-scale research projects

Solution

1. Step 1: Understand TensorFlow's main strength

   TensorFlow is designed with production deployment in mind, offering tools for serving models efficiently.

2. Step 2: Compare with PyTorch's focus

   PyTorch is known for its dynamic graphs and ease of use in research, not primarily for production deployment.

3. Final Answer:

   Better support for deploying models in production environments -> Option A

4. Quick Check:

   TensorFlow = Production deployment [OK]

Hint: TensorFlow = production, PyTorch = research [OK]

Common Mistakes:

• Confusing PyTorch's dynamic graph with TensorFlow's static graph
• Thinking PyTorch is better for production
• Assuming TensorFlow is harder to deploy

2. Which code snippet correctly imports PyTorch in Python?

easy

A. import tensorflow as tf

B. from tensorflow import torch

C. import torch

D. import pytorch as pt

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 mixes TensorFlow and PyTorch incorrectly, C uses a wrong module name.

3. Final Answer:

   import torch -> Option C

4. Quick Check:

   PyTorch import = import torch [OK]

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

Common Mistakes:

• Using 'import pytorch' instead of 'import torch'
• Mixing TensorFlow and PyTorch imports
• Using incorrect alias names

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. tensor([1, 2, 3, 5])

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

C. [6, 7, 8]

D. Error: unsupported operand type(s)

Solution

1. Step 1: Understand tensor addition in PyTorch

   Adding a scalar (5) to a tensor adds 5 to each element.

2. Step 2: Calculate the 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 + scalar adds element-wise [OK]

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

Common Mistakes:

• Expecting a Python list instead of tensor output
• Thinking addition concatenates tensors
• Assuming error due to type mismatch

4. Identify the error in this TensorFlow code snippet:

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

medium

A. Code runs correctly and prints [6 7 8]

B. Missing session to run the computation

C. TensorFlow constants cannot be added to scalars

D. tf.constant should be tf.Variable for addition

Solution

1. Step 1: Check TensorFlow eager execution

   TensorFlow 2.x runs eagerly by default, so operations like addition work immediately.

2. Step 2: Verify code behavior

   Adding 5 to a constant tensor works and y.numpy() converts tensor to numpy array for printing.

3. Final Answer:

   Code runs correctly and prints [6 7 8] -> Option A

4. Quick Check:

   TensorFlow 2.x eager mode = code runs [OK]

Hint: TensorFlow 2.x runs eagerly, no session needed [OK]

Common Mistakes:

• Thinking session is required (TensorFlow 1.x style)
• Believing constants can't be added to scalars
• Confusing tf.Variable necessity

5. You want to quickly prototype a new neural network model with dynamic behavior and easy debugging. Which framework is better suited and why?

hard

A. PyTorch, because it requires less memory for large datasets

B. TensorFlow, because it has static graphs for faster execution

C. TensorFlow, because it integrates better with production tools

D. PyTorch, because it uses dynamic computation graphs that feel like regular Python

Solution

1. Step 1: Understand dynamic vs static graphs

   PyTorch uses dynamic computation graphs, which are built on the fly and easier to debug.

2. Step 2: Match to prototyping needs

   Dynamic graphs allow quick changes and intuitive Python-like code, ideal for prototyping and debugging.

3. Final Answer:

   PyTorch, because it uses dynamic computation graphs that feel like regular Python -> Option D

4. Quick Check:

   Dynamic graphs = PyTorch for prototyping [OK]

Hint: Dynamic graphs = PyTorch for easy prototyping [OK]

Common Mistakes:

• Choosing TensorFlow for prototyping due to static graphs
• Confusing memory use with debugging ease
• Ignoring PyTorch's Pythonic style