75 TensorFlow Interview Questions and Answers (2026)

Use these 75 TensorFlow interview questions to check whether a candidate can explain the framework’s core concepts and make sound engineering choices—from tensor shapes and automatic differentiation to data pipelines, deployment, and performance. The answers assume current TensorFlow and Keras concepts; verify version-specific APIs against the official documentation because these interfaces evolve.

TensorFlow and tensor fundamentals

1. What is TensorFlow?

TensorFlow is an end-to-end platform for machine learning. It provides tools for numerical computation with tensors, automatic differentiation, model building, and execution across devices. Its official guide describes it as “an end-to-end platform for machine learning” (TensorFlow basics).

As an Amazon Associate I earn from qualifying purchases.

2. What is a tensor?

A tensor is a multidimensional array with a data type and shape. A scalar is rank 0, a vector rank 1, and a matrix rank 2. Higher-rank tensors represent arrays with more dimensions.

3. What do rank, shape, and dtype mean?

Rank is the number of dimensions; shape gives the size along each dimension; dtype identifies the kind of value, such as a floating-point number or integer. For example, a float tensor with shape (32, 10) has rank 2 and contains 32 rows of 10 values.

4. Can a tensor have an unknown shape?

Yes. TensorFlow can represent partially known shapes, such as (None, 10), where the first dimension is unspecified—often because batch size can vary. The actual runtime tensor still has concrete dimensions.

5. What is the difference between a constant and a variable?

A constant represents a value that is not intended to be updated through TensorFlow’s variable-assignment mechanism. A tf.Variable stores mutable state, such as model weights, that an optimizer can update during training.

6. What is a TensorFlow operation?

An operation (or op) performs a computation on inputs and produces outputs. Arithmetic, matrix multiplication, and neural-network layers are examples; in graph execution, operations and their dependencies are represented in a computation graph.

7. How does TensorFlow handle devices such as CPUs and GPUs?

TensorFlow can execute supported operations on available devices, including CPUs and GPUs. Device placement and performance depend on the operation, installed software, hardware, and configuration; having a GPU does not guarantee that every workload will run faster.

8. What is automatic differentiation?

Automatic differentiation computes derivatives of TensorFlow operations according to the chain rule. It is the mechanism commonly used to obtain gradients of a loss with respect to trainable model parameters.

Execution and automatic differentiation

9. What is eager execution?

Eager execution runs operations immediately and returns concrete results. It makes it straightforward to inspect intermediate values and debug step by step.

10. What does tf.function do?

tf.function can trace a Python function that uses TensorFlow operations and execute the resulting graph. Graph execution may enable optimization and can be useful for deployment or performance-sensitive workloads, but it does not eliminate runtime costs or automatically make every function faster.

11. How do eager execution and graph execution differ?

Eager execution prioritizes immediate evaluation and interactive debugging. A traced graph can represent computation for optimization and execution, but Python code is involved during tracing rather than being re-run as ordinary Python for every graph operation. Choose based on debugging needs, workload, and deployment requirements, then measure performance.

12. What is tracing in tf.function?

Tracing records TensorFlow operations performed while a function is called with particular inputs, creating a graph for execution. Different input signatures or Python-level behavior can lead to additional traces, so stable input shapes and signatures can help control tracing overhead.

13. Why might tf.function behave differently from ordinary Python?

Python statements execute during tracing, while TensorFlow operations can become graph operations. As a result, Python side effects or control flow may not behave as if the function were interpreted afresh on every call. Use TensorFlow operations and graph-compatible patterns where execution must be represented in the graph.

14. What is tf.GradientTape used for?

tf.GradientTape records operations performed inside its context so TensorFlow can calculate gradients afterward. It is commonly used for custom training steps or any calculation that needs derivatives.

15. How do you calculate a gradient with GradientTape?

Record the computation of a scalar loss under a tape, then call tape.gradient(loss, variables) with the values to differentiate against. The result is a gradient for each requested source that is connected to the recorded computation.

16. What is the difference between a persistent and a non-persistent gradient tape?

A non-persistent tape is normally used for one gradient calculation and releases recorded resources after that calculation. A persistent tape allows multiple gradient calculations from the same recording, but holds resources longer; delete it when it is no longer needed.

17. Why might a gradient be None?

A gradient can be None if the requested source was not watched or the loss is not connected to it through recorded differentiable operations. Check variable selection, tape scope, and whether computations were converted to values that break the differentiable path.

18. What is a custom training loop?

A custom loop explicitly performs the forward pass, loss calculation, gradient calculation, and optimizer update. It gives control over specialized update rules or training logic, at the cost of implementing and maintaining steps that Keras’s built-in workflow can handle for common cases.

Keras and model design

19. What is Keras in TensorFlow?

Keras is a high-level API for creating and training models. TensorFlow’s Keras guide covers layers, models, built-in training methods, saving, and deployment (TensorFlow: Keras, the high-level API).

20. Is Keras always backed by TensorFlow?

No. Keras 3 can use TensorFlow, JAX, or PyTorch backends. A Keras model is not necessarily TensorFlow-backed; the backend depends on the configuration and environment (About Keras 3).

21. What is a Keras layer?

A layer is a reusable model component that can perform a transformation and, when applicable, hold trainable or non-trainable state. Layers can be composed to build a model.

22. What is a Keras model?

A model groups layers into a callable computation and exposes workflows for training, evaluation, and prediction. In Keras, a model can be defined with the Sequential API, the Functional API, or subclassing.

23. When should you use the Sequential API?

Use Sequential when the model is a straightforward linear stack in which each layer has one input and one output connected to the next. It is concise, but does not express arbitrary branching, shared layers, or multiple inputs and outputs as naturally.

24. When should you use the Functional API?

Use the Functional API for a connected model graph with branching, shared layers, or multiple inputs or outputs. It defines a model by connecting symbolic inputs and layer outputs (Keras Functional API guide).

25. When is model subclassing appropriate?

Subclass a model when its forward behavior or internal control flow does not fit naturally into a standard layer graph. Subclassing gives flexibility, but can make model structure and serialization less straightforward than a declarative Functional model.

26. How do you choose among Sequential, Functional, and subclassing?

Approach	Best fit	Trade-off
Sequential	A simple linear layer stack	Limited topology
Functional	Connected graphs, shared layers, multiple inputs or outputs	Requires expressing connections explicitly
Subclassing	Custom forward behavior or control flow	More implementation responsibility

These distinctions are described in the TensorFlow Keras guide and the Keras Functional API guide.

27. What do compile, fit, and evaluate do?

compile configures the model’s optimizer, loss, and optional metrics. fit runs training on supplied data; evaluate computes configured loss and metrics on evaluation data.

28. What does predict do?

predict runs inference on inputs and returns model outputs. It does not update weights as a training step does.

29. What is the difference between a loss and a metric?

A loss is the objective used to guide optimization through gradients. A metric reports a quantity for monitoring or evaluation; it need not be differentiable or used to update the model.

30. What is an optimizer?

An optimizer applies updates to trainable variables using gradients and its update rule. The choice affects how the model’s parameters change during training.

31. How do you select a loss function?

Match the loss to the prediction task, target representation, and output layer. For example, classification and regression generally require different objectives; confirm that label encoding and output shape match the chosen loss.

32. What are callbacks in Keras?

Callbacks run specified actions at points in training, such as at epoch boundaries. They can support monitoring, checkpointing, or stopping criteria without placing all such logic inside the model’s forward computation.

33. What is a custom Keras layer?

A custom layer packages a computation, and optionally state, behind a reusable layer interface. It is useful when built-in layers do not express the needed operation; custom behavior should be implemented in a way compatible with the intended training and saving workflow.

Training and evaluation

34. What is an epoch?

An epoch is one pass through the training dataset as defined by the training setup. For datasets that repeat indefinitely or have an externally specified step count, the configured steps determine how much data is processed in an epoch.

35. What is a batch?

A batch is a group of examples processed together in a training step. Batch size affects memory use, throughput, and the number of weight updates per pass over a dataset.

36. What is validation data used for?

Validation data measures performance on examples not used to calculate the current training updates. It helps monitor generalization and compare training choices, but repeatedly tuning decisions to one validation set can overfit that set.

37. How does validation differ from testing?

Validation data informs model selection and tuning during development. A test set is intended for a more final evaluation after those decisions; using test results to repeatedly tune a model compromises that role.

38. What is overfitting?

Overfitting occurs when a model fits training examples well but performs worse on new data. A gap between training and validation performance can be a warning sign, though diagnosis also depends on data quality and evaluation design.

39. How would you investigate poor validation performance?

Check that training and validation data represent the intended task and use consistent preprocessing. Then compare training and validation behavior, inspect labels and model outputs, and review whether the model, objective, or training setup matches the problem.

40. What does a custom training step need to do?

A typical supervised step obtains model predictions, computes loss, asks a tape for gradients with respect to trainable variables, and passes gradient-variable pairs to the optimizer. Add metrics and any task-specific logic deliberately.

41. How do you keep training and inference behavior distinct?

Some layers behave differently during training and inference, so the model call should receive the appropriate training mode where relevant. Keras’s standard training and prediction workflows manage common cases; custom loops must pass the correct mode themselves.

42. What should you monitor during training?

Monitor the loss used for optimization and task-relevant metrics, along with validation results where available. A single metric rarely explains a failure; compare trends and check whether the measured quantity matches the actual requirement.

Input pipelines and data

43. What is tf.data?

tf.data is TensorFlow’s API for constructing input pipelines. It can organize transformations such as reading, shuffling, batching, and preprocessing so data is supplied to model execution.

44. Why use a tf.data.Dataset?

A dataset can represent a sequence of elements and transformations without requiring the full dataset to be held as one in-memory array. It can support scalable input workflows and composable preprocessing.

45. Why shuffle training data?

Shuffling changes the order in which examples are presented, reducing dependence on an accidental ordering in the source data. Choose an appropriate buffer and ensure the shuffle is applied where it suits the dataset and training design.

46. Why batch data?

Batching groups examples for model computation, typically improving hardware utilization compared with processing one example at a time. The batch size must also fit memory and suit the optimization behavior.

47. What order should dataset transformations use?

There is no universal order for every pipeline. A common design shuffles training examples before batching so batches contain varied examples; transformations such as caching, preprocessing, and repeating should be placed according to data size, randomness needs, and whether repeated epochs should reshuffle.

48. How can an input pipeline become a training bottleneck?

If data reading or preprocessing cannot keep pace with model execution, the accelerator or CPU may spend time waiting for inputs. Compare input-processing time with model-step time and look for avoidable work, serialization, or insufficient parallelism.

49. How would you improve input throughput?

Profile first, then consider parallelizing independent reads or transformations, batching appropriately, and using prefetching so input preparation can overlap model execution. The right changes depend on source storage, preprocessing cost, memory limits, and hardware.

50. What should you check when input shapes fail?

Inspect the element specification and actual batch shapes, including whether a final batch can be smaller. Confirm that model input dimensions and label shapes agree with the dataset, and account for intentionally variable dimensions.

Debugging and performance

51. How do you debug a TensorFlow model?

Start with eager execution and inspect intermediate tensors, shapes, dtypes, and values on a small batch. Once the computation is correct, investigate traced execution or performance changes separately.

52. How do you diagnose a shape mismatch?

Trace the shape from dataset element through each layer to the loss. Check batch dimensions, channel ordering, label encoding, and whether an operation expects dimensions in a particular order.

53. What does a dtype mismatch indicate?

An operation or layer received values with incompatible data types. Inspect both features and labels, then convert deliberately at the data boundary or use compatible layer and loss inputs rather than relying on accidental implicit conversion.

54. Why can a model run slowly despite using a GPU?

The workload may be too small, data-bound, or dominated by operations that do not benefit from the GPU. Transfer overhead and device configuration also matter. Profile the complete path instead of assuming device availability guarantees speed.

55. How should you compare two performance changes?

Measure under the same workload, input pipeline, device setup, and warm-up conditions, and compare the same metric such as steady-state step time. A change that improves model computation can still worsen end-to-end throughput if it increases input or transfer costs.

56. What is TensorBoard used for?

TensorBoard is a visualization and inspection tool commonly used to review training logs, such as scalar metrics over time. It helps identify trends and compare runs; it does not substitute for validating the data or experimental design.

57. Why might a tf.function create multiple traces?

Calls with different input shapes, types, or signatures can require different graphs; Python arguments can also affect tracing. Use stable signatures where appropriate and avoid changing input structure unintentionally.

58. How do you distinguish a correctness problem from a performance problem?

First verify outputs and gradients on a small, controlled example. Once correctness is established, profile the pipeline and execution stages to locate the time or memory cost; optimizing an incorrect computation only makes the wrong result arrive sooner.

Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Support on Ko-Fi

Saving, export, and deployment

59. What should you save from a trained model?

Save the model information required by the intended next step: architecture and weights for reuse, and optimizer state if training must resume with its accumulated state. Also preserve preprocessing assumptions and label mappings needed to interpret inputs and outputs.

60. What is the difference between saving a model and exporting it?

Saving preserves a model in a form intended for later loading or continued work; export prepares a callable artifact for a serving or runtime interface. The suitable format and API depend on the TensorFlow/Keras version and target, so check the current official guidance before choosing.

61. What deployment targets should a candidate consider?

Clarify whether inference will run on a server, browser or mobile device, or embedded hardware. Then check the target’s supported operators, latency and memory needs, input/output contract, and current conversion or export support before committing to a format.

62. Why might a model work in training but fail after export?

The exported path may expose unsupported operations, custom behavior, or input signatures that were not tested in the target runtime. Validate a representative artifact on the actual target environment, not only in the training process.

63. What makes a model suitable for serving?

A serving-ready model has a defined input/output contract, reproducible preprocessing, tested inference behavior, and operational characteristics that fit the service’s latency, memory, and scaling requirements. Versioning and monitoring are also part of reliable deployment.

64. How should you test a deployment artifact?

Run known examples through both the original model and the deployed artifact, compare outputs within appropriate tolerances, and test realistic input shapes and edge cases. Also verify the artifact loads and executes in the intended runtime.

Distributed training and scenarios

65. What is distributed training?

Distributed training uses multiple devices or workers to perform training work. The strategy must account for how model computation, variables, and gradients are coordinated across those devices.

66. How do you choose a distribution strategy?

Start with the actual hardware and deployment setup: one device, multiple devices on one machine, or multiple workers. Then verify the strategy’s current support and constraints for the model, input pipeline, and synchronization needs rather than choosing by name alone.

67. What is data parallelism?

Data parallelism runs replicas of a model on different portions of a batch and combines their gradient contributions to update shared model state. It can increase throughput, but communication and input supply can limit scaling.

68. What can limit distributed-training speedup?

Communication overhead, uneven work across devices, input bottlenecks, and synchronization can all limit gains. Measure scaling at the workload’s real batch sizes and hardware configuration.

69. A model’s training loss falls but validation loss rises. What would you investigate?

That pattern can indicate overfitting. Check the split and preprocessing first, then consider whether model capacity or training duration is excessive and whether regularization or additional representative data is appropriate.

70. A model trains, but its gradients are missing. What would you check?

Confirm that the loss depends on the variables requested, that the tape recorded the relevant operations, and that variables were watched when needed. Look for breaks in the differentiable path, such as converting intermediate tensors to non-differentiable values.

71. Training is slow, but the model is small. What is a sensible first response?

Profile input preparation and model execution separately. For a small model, Python overhead, storage, or preprocessing may dominate, so changing the architecture or buying faster compute without measurements may not address the cause.

72. A model has two inputs and two outputs. Which Keras API fits?

The Functional API is a natural choice because it represents connected graphs with multiple inputs and outputs. It also supports shared layers where parts of the graph reuse the same layer instance.

73. When should you replace fit with a custom loop?

Use fit when its standard training workflow expresses the task clearly. Consider a custom loop when specialized update logic, unusual optimization steps, or tighter control over the training process justifies the added implementation and debugging work.

74. How would you prepare a model for mobile or embedded inference?

Identify the target runtime and its operator, memory, and latency constraints first. Then verify current conversion support, export the model using the documented path for that target, and test the converted artifact on representative hardware.

75. What makes a strong TensorFlow interview answer?

A strong answer explains the concept, names the practical trade-off, and connects the choice to the workload. For example, rather than claiming graph execution is always faster, explain when tracing may help, what it changes about debugging, and how you would measure it.

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.