75 TensorFlow Interview Questions and Answers (2026 Guide)

These 75 TensorFlow interview questions progress from tensor fundamentals to model design, training, deployment, and engineering scenarios. Use them to check whether a candidate can explain not only what an API does, but also when a particular workflow fits the problem. API details can vary by TensorFlow and Keras version; verify version-specific examples against the official documentation.

TensorFlow and tensor fundamentals

1. What is TensorFlow?

TensorFlow is an end-to-end machine-learning platform. It provides tools for representing and computing with tensors, differentiating computations, building and training models, and using available hardware such as GPUs. The official TensorFlow basics guide describes these core ideas.

2. What is a tensor?

A tensor is a multidimensional numerical value with a data type and shape. A scalar has rank 0, a vector rank 1, a matrix rank 2, and higher-rank tensors represent further dimensions.

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

Rank is the number of dimensions, shape gives the size along each dimension, and dtype specifies the kind of values, such as floating-point 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 dimension?

Yes. A tensor or model input may have partially known shape, such as (None, 28, 28, 1), where the leading dimension can vary. Unknown dimensions support variable batch sizes, but the remaining operations must still be compatible with the actual runtime shapes.

5. What is the difference between tf.Tensor and tf.Variable?

A tensor is an immutable value in a computation. A variable stores mutable state, commonly model weights, that can be updated during training. Optimizers typically update trainable variables rather than replacing the meaning of an ordinary tensor.

6. When would you use a constant versus a variable?

Use a constant for a value that should not be trained or mutated, such as a fixed mask. Use a variable for persistent state that changes, such as a dense layer’s kernel or bias. The important distinction is intended state and trainability, not merely how the value was created.

7. What is a tensor operation?

It is a computation that consumes or produces tensors, such as addition, matrix multiplication, reshaping, or a neural-network activation. TensorFlow operations enforce compatible dtypes and shapes, so mismatches often surface as explicit errors.

8. What is broadcasting?

Broadcasting lets an operation combine compatible shapes by treating dimensions of size 1 as if they were repeated. For instance, a vector of feature-wise offsets can be added to each row of a batch. Broadcasting does not mean TensorFlow silently makes arbitrary incompatible shapes work.

Execution and automatic differentiation

9. What is eager execution?

Eager execution runs operations immediately and returns concrete values, making interactive inspection and step-by-step debugging straightforward. It is the default execution style in modern TensorFlow workflows.

10. What does tf.function do?

tf.function can trace a Python function that uses TensorFlow operations and execute the resulting graph. Graph execution can enable optimizations and is useful in many production or performance-sensitive workflows; it does not remove runtime costs or guarantee that every function is faster.

11. How do eager and graph execution differ?

Eager mode prioritizes immediate execution and ease of inspection. A traced graph can optimize TensorFlow computation and represent work for execution beyond ordinary Python dispatch. Use eager execution when interactive visibility is valuable, and consider graph execution when a workload benefits from tracing and graph-based execution.

12. What is tracing in tf.function?

Tracing records TensorFlow operations for a graph, based on how the function is called. Calls with different input signatures or Python-level behavior may trigger additional traces. Candidates should recognize that Python side effects and ordinary Python control flow do not necessarily behave like TensorFlow operations inside a traced function.

13. What is automatic differentiation?

Automatic differentiation computes derivatives of a program’s outputs with respect to its inputs or variables by tracking operations. In machine learning, those derivatives provide gradients used to update model parameters.

14. What is tf.GradientTape used for?

tf.GradientTape records operations executed while it is active so TensorFlow can compute gradients later. It is the usual building block for custom training logic and can also be used to differentiate functions outside a standard Keras training workflow.

15. How do you calculate a gradient with GradientTape?

Watch or use a trainable variable inside the tape, calculate a scalar loss, then request its gradient with respect to that variable. For example:

with tf.GradientTape() as tape:
    prediction = model(x, training=True)
    loss = loss_fn(y, prediction)
grads = tape.gradient(loss, model.trainable_variables)

The optimizer can then apply those gradients. A non-scalar target or unrecorded computation may require a more deliberate gradient setup.

16. What is a gradient, and why does training need it?

A gradient indicates how a loss changes as parameters change. Gradient-based optimizers use it to choose parameter updates that reduce the training objective, subject to the optimizer’s update rule and the data seen.

17. What can cause a gradient to be None?

The tape may not have recorded a path from the loss to the requested variable, the variable may not be watched, or the computation may have crossed an operation that TensorFlow cannot differentiate. Check that the loss depends on the variable and that relevant operations ran inside the tape.

Keras APIs and model design

18. What is the role of Keras in TensorFlow?

Keras provides a high-level API for defining layers and models, configuring training, and working with data and model saving. TensorFlow documents Keras as its high-level API in its Keras guide. Keras 3 can also use TensorFlow, JAX, or PyTorch backends, so Keras does not inherently mean a TensorFlow backend in every setup; see About Keras 3.

19. What is a Keras layer?

A layer is a reusable model component that can transform inputs and, when needed, hold trainable or non-trainable state. Dense, convolutional, and dropout layers are common examples.

20. What is a Keras model?

A model groups layers into a callable computation and can provide training, evaluation, and prediction workflows. The Model abstraction also allows a model to be saved or composed with other model components.

21. When should you use the Sequential API?

Use Sequential when the model is a straightforward linear stack in which each layer feeds the next. It is simple to read and configure, but is not designed for arbitrary branching, shared layers, or multiple input/output graphs.

22. When should you use the Functional API?

Use the Functional API when a model has a non-linear topology, shared layers, or multiple inputs or outputs. It represents a graph of layers connected by tensors while retaining a model structure that Keras can inspect. The Keras Functional API guide covers these patterns.

23. When is model subclassing appropriate?

Subclass keras.Model when the model needs custom forward behavior or control flow that is awkward to express as a standard graph. It offers flexibility, but can be less straightforward to inspect or serialize than a conventional Functional model if custom behavior is not implemented carefully.

24. How do Sequential, Functional, and subclassed models compare?

Approach	Best fit	Main trade-off
Sequential	Linear layer stack	Simple, but limited to a straightforward chain
Functional	Connected graph with branching, shared layers, or multiple inputs/outputs	Explicit graph structure; more expressive than a linear stack
Subclassing	Custom forward computation or behavior	Maximum control, with more responsibility for structure and serialization

25. What is the difference between a layer’s call and a model’s call?

A layer call applies that component to inputs and may create or use its state. A model call runs the model’s composed computation. In custom training code, passing training=True or training=False can matter for layers whose behavior changes between training and inference.

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

A loss is the objective optimized during training. A metric is a measure used to report or monitor model performance, often in a more interpretable form. They can be related, but a reported metric is not automatically the quantity used to update weights.

27. What is an optimizer?

An optimizer applies parameter updates using gradients and its update rule. Common choices include stochastic gradient descent and adaptive optimizers. The right choice depends on the task and training behavior rather than on a universal ranking.

28. How do you compile a Keras model?

Call model.compile() with an optimizer, a loss, and optional metrics. Compilation configures the built-in training and evaluation workflow; a custom loop can instead control these components directly.

29. What are callbacks in Keras?

Callbacks are hooks that run at points in training or evaluation. They can support tasks such as checkpointing, early stopping, or logging, keeping common training-control behavior out of the model’s forward computation.

30. What is the difference between training, evaluation, and prediction?

Training updates model parameters from data and an objective. Evaluation measures a model on data without the usual optimizer updates. Prediction runs the model to produce outputs. In Keras, fit, evaluate, and predict provide these common workflows.

Training, validation, and evaluation

31. What does model.fit() do?

fit runs the built-in training workflow over supplied data for configured epochs, using the model’s compiled loss and optimizer. It also supports validation data and callbacks, which cover many conventional training needs without a hand-written loop.

32. What is an epoch?

An epoch is one pass through the training dataset as presented to the training workflow. The number of batches and updates in an epoch depends on dataset size, batch size, and how the input pipeline is configured.

33. What is a batch?

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

34. What is validation data for?

Validation data provides a held-out view of model performance during development. It can inform model selection and training controls such as early stopping, but should not replace a separate final test set when an unbiased final estimate is needed.

35. How do you distinguish training, validation, and test sets?

Training data fits model parameters; validation data guides choices during development; test data is reserved for a final assessment after those choices. Repeatedly using the test set to tune a model leaks information into the development process.

36. What is overfitting?

Overfitting occurs when a model learns patterns specific to its training data that do not generalize well. It often appears as strong training performance alongside weaker validation performance.

37. What are common ways to address overfitting?

Possible approaches include collecting or augmenting representative data, reducing model capacity, regularization, dropout, and early stopping. Choose based on evidence from validation and the data-generation process rather than applying every technique at once.

38. What is early stopping?

Early stopping ends training when a monitored validation measure stops improving according to a chosen rule. In Keras it is commonly configured with a callback. Restoring the best weights can avoid keeping the final, worse-performing epoch’s parameters.

39. Why monitor more than training loss?

Training loss shows how well the model fits its training objective, but does not establish generalization. Validation metrics and task-relevant measures can reveal a divergence between fitting the training data and performing on held-out examples.

40. How do you handle class imbalance?

First inspect class counts and choose metrics that reflect the deployment objective; accuracy alone may hide poor minority-class performance. Depending on the problem, consider class weighting, resampling, threshold selection, or suitable evaluation metrics, and assess choices on representative validation data.

41. What is a custom training loop, and when do you need one?

A custom loop explicitly controls the forward pass, loss, gradient calculation, optimizer updates, and metrics. Use it when the built-in fit workflow cannot express specialized update rules, multiple objectives, or unusual training behavior. Prefer fit when it covers the task, since it provides useful standard workflow features.

Input pipelines and data handling

42. What is tf.data?

tf.data is TensorFlow’s API for constructing input pipelines from data sources and transformations. It supports workflows such as mapping preprocessing, shuffling, batching, and feeding data to model training.

43. Why use tf.data.Dataset instead of passing arrays?

Arrays are convenient when data is modest and already fits comfortably in memory. A dataset pipeline can express streaming, transformations, and batching for larger or more involved input workflows. The choice depends on data scale, preprocessing, and throughput needs.

44. What do shuffle and batch do?

shuffle changes example order to reduce dependence on the source ordering during training; batch groups examples for model steps. Pipeline order matters: typically shuffle examples before batching if the intention is to mix examples across batches.

45. How can preprocessing be included in an input pipeline?

Use dataset transformations such as map to apply deterministic or stochastic preprocessing, as appropriate. Keep the training and inference preprocessing definitions consistent; a mismatch between them can undermine otherwise sound model performance.

46. What is prefetching?

Prefetching overlaps preparation of later input batches with computation on the current batch. It can reduce input stalls when data preparation and model work can run concurrently, though the effect depends on the actual bottleneck and resource limits.

47. How would you diagnose an input-bound training job?

Check whether accelerators or the training step wait for data, inspect the pipeline’s reading and preprocessing cost, and profile before changing it. Potential remedies include parallelizing independent transformations, batching appropriately, or prefetching; measure whether each change improves end-to-end throughput.

Debugging, performance, and reliability

48. What is TensorBoard used for?

TensorBoard helps visualize and inspect training information such as logged metrics and graphs. It is useful for tracking runs and diagnosing trends, but conclusions still depend on what was logged and whether the measurements are meaningful.

49. How do you debug a shape mismatch?

Inspect the shape and dtype at each boundary: data source, preprocessing, model input, layer output, and loss. Compare expected dimensions with actual batch and label shapes. Make the intended shape explicit rather than reshaping blindly, since a shape operation can hide a data-layout mistake.

50. What does a dtype mismatch mean?

An operation received values with incompatible data types, such as an integer tensor where a floating-point tensor was expected. Check the source and transformations, then cast deliberately when mathematically appropriate; careless casts can lose precision or change semantics.

51. How can you debug a problem inside tf.function?

First isolate the behavior in eager execution where immediate values are easier to inspect. Then check tracing assumptions, input signatures, Python side effects, and whether the relevant computation is made of TensorFlow operations. Reintroduce graph execution once the function’s behavior is understood.

52. What is retracing, and why can it matter?

Retracing means creating another graph for calls to a tf.function, often because call signatures or Python arguments differ. Unnecessary retracing can add overhead. Stabilize input shapes or use an appropriate input signature where that matches the actual range of inputs.

53. How do you improve training performance responsibly?

Profile first to identify whether computation, input processing, memory, or communication is limiting the job. Then change one relevant factor—such as input batching, pipeline parallelism, graph execution, or accelerator use—and compare end-to-end results under the same workload. Do not assume a specific API or device will speed up every model.

54. What is the difference between latency and throughput?

Latency is the time taken for an individual request or operation; throughput is the amount of work completed per unit time. Batching can improve throughput while increasing the wait or processing time experienced by a single request, so optimize for the deployment requirement.

55. How can you make training more reproducible?

Record code, data and preprocessing versions, model configuration, relevant random seeds, software and hardware environment, and training settings. Seeds help control randomness but do not guarantee identical results across every operation, device, or software version.

56. Why can a model run out of memory?

Common causes include large batches, large intermediate activations, model parameters, optimizer state, or input buffers. Inspect memory use and tensor dimensions, then reduce or restructure the dominant demand. Smaller batches may help, but can also change optimization behavior.

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

Saving, export, and deployment

57. What is the difference between saving weights and saving a model?

Saving weights stores parameter values, while saving a model can preserve a broader model representation and configuration for later loading or use. The right choice depends on whether the goal is to resume training, reconstruct an architecture, or deploy a model; custom components may need to be registered or supplied when loading.

58. How do you choose a model format for deployment?

Start with the target runtime and its supported formats, then verify the current TensorFlow/Keras export or conversion path and the operators your model uses. A server, browser or mobile device, and embedded target can impose different constraints; do not choose a format solely because it is familiar.

59. What is TensorFlow Lite used for?

TensorFlow Lite is associated with deploying machine-learning models on mobile and embedded targets. Confirm current conversion support, supported operations, and performance on the intended device before committing to it.

60. What is TensorFlow Serving used for?

TensorFlow Serving is used to serve trained models in production-oriented environments. A deployment decision should also account for input and output contracts, versioning, monitoring, and operational requirements rather than treating model serialization as the whole serving system.

61. What is the difference between inference and training?

Training adjusts parameters using data and an objective. Inference uses a trained model to produce outputs for new inputs and generally does not update those parameters. Inference may use different execution settings, such as disabling training-specific layer behavior.

62. How do you check a model before deployment?

Test the saved or exported artifact with representative inputs, verify output shapes and numerical behavior, check preprocessing and postprocessing, and run it in the target runtime. Also assess latency, memory, and failure handling under the intended operating conditions.

Distributed training and advanced scenarios

63. What is distributed training?

Distributed training uses multiple devices or workers to train a model. It can increase available compute or data-processing capacity, but introduces coordination and communication costs that may limit benefits.

64. What is a distribution strategy in TensorFlow?

A distribution strategy coordinates model computation and variable updates across devices or workers. The suitable strategy depends on whether the setup uses multiple devices on one machine or multiple machines, and on model and data constraints.

65. How would you choose between one GPU and multiple GPUs?

Measure the single-device workload first and determine whether its computation is large enough to offset multi-device communication and setup costs. Consider memory requirements, model parallelism or data parallelism needs, and throughput goals. More devices do not automatically produce proportionally faster training.

66. A model’s training loss falls but validation loss rises. What do you investigate?

Check for overfitting, data leakage or distribution differences, and whether the validation pipeline matches the task. Review model capacity, regularization, training duration, and preprocessing. Use validation evidence to guide changes without repeatedly tuning against the final test set.

67. A model works in eager mode but fails under tf.function. What is your approach?

Reduce the function to a minimal example, identify Python-side behavior or data-dependent control flow, and inspect the signatures and shapes that cause tracing. Keep graph-compatible TensorFlow operations in the traced computation, and use eager execution for the portions that require Python inspection.

68. Training is slow even though GPU utilization seems low. What do you check?

Profile the full step rather than relying on utilization alone. Check input reading and preprocessing, host-to-device transfer, batch size, synchronization, and whether the model’s computation is large enough to keep the GPU busy. Change the measured bottleneck, not just the most visible symptom.

69. Your model accepts two inputs and produces two outputs. Which Keras API fits?

The Functional API is a natural choice because it models connected graphs with multiple inputs and outputs. Define the input tensors, connect layers to produce each output, then construct a model with the input and output collections.

70. A custom loop produces no useful gradients. What do you inspect?

Confirm that the loss is computed from the model output, the tape encloses the forward computation and loss, and the requested variables are trainable and connected to that loss. Check for non-differentiable operations or accidental conversion out of TensorFlow tensors along the path.

71. How would you handle a model that fits in memory but its dataset does not?

Build a streaming input pipeline rather than loading all examples into memory. Read from the appropriate storage source, apply transformations as examples flow through the dataset, batch for training, and profile the pipeline to ensure it supplies data at a useful rate.

72. A model performs well offline but poorly after deployment. What do you compare?

Compare the deployed artifact and runtime with the tested model, then verify input schema, preprocessing, dtype, shape, batching, and output interpretation. Evaluate on representative production-like examples and check whether the serving data distribution differs from the offline evaluation data.

73. How do you decide whether a custom model should be subclassed?

Use subclassing when custom forward logic materially simplifies or enables the computation. If the architecture is a standard linear stack, Sequential is simpler; if it is a graph of connected layers, the Functional API generally makes that topology more explicit and inspectable.

74. A deployment target has strict memory and latency limits. What is your plan?

Establish the target’s supported runtime and operator constraints, then measure the unoptimized artifact on representative inputs. Explore architecture changes or supported conversion and optimization options, validating output quality alongside latency and memory after each change.

75. What makes a strong answer to an open-ended TensorFlow design question?

Clarify the task, data volume, model topology, hardware, target runtime, and success metric before choosing APIs. Explain the trade-offs, describe how you would validate correctness and performance, and identify what you would measure rather than claiming that one framework feature is always best.

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.