Most Frequently asked tensorflow Interview Questions and Answers

Question: How do you define and train a neural network in TensorFlow?

Answer:

Defining and training a neural network in TensorFlow involves several key steps: preparing the dataset, defining the model architecture, compiling the model, training the model, and evaluating the model’s performance. In TensorFlow 2.x, this is typically done using the Keras API, which is integrated into TensorFlow as the high-level interface for building and training models.

Here’s a step-by-step guide to define and train a neural network using TensorFlow:

---

1. Import Required Libraries

First, import the necessary libraries, including TensorFlow and Keras components.

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

2. Prepare the Dataset

Before defining the neural network, you need a dataset. For this example, we’ll use the MNIST dataset, which is a collection of handwritten digits.

# Load MNIST dataset (train and test sets)
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# Normalize the image data to values between 0 and 1 (from 0-255 range)
x_train, x_test = x_train / 255.0, x_test / 255.0

# Reshape the images to be flat vectors (28x28 images to 784 features)
x_train = x_train.reshape(-1, 28 * 28)
x_test = x_test.reshape(-1, 28 * 28)

3. Define the Neural Network Model

Next, you define the neural network architecture. In this case, we’ll create a fully connected feedforward neural network with one hidden layer.

# Define a Sequential model
model = models.Sequential()

# Input layer (Flatten the 28x28 images into 784-dimensional vectors)
model.add(layers.InputLayer(input_shape=(28 * 28,)))

# Hidden layer (Fully connected layer with 128 neurons and ReLU activation)
model.add(layers.Dense(128, activation='relu'))

# Output layer (Softmax activation for multi-class classification)
model.add(layers.Dense(10, activation='softmax'))  # 10 classes (digits 0-9)

• Input Layer: The input to the network is a flattened vector of 784 pixels (28x28), hence the input shape is (28 * 28,).
• Hidden Layer: A dense layer with 128 neurons and the ReLU activation function.
• Output Layer: A dense layer with 10 neurons (one for each class) and a Softmax activation function, which is used for multi-class classification problems.

4. Compile the Model

Before training, you need to compile the model. This step includes selecting the optimizer, loss function, and metrics to track during training.

# Compile the model
model.compile(
    optimizer='adam',                  # Optimizer (Adam is widely used for neural networks)
    loss='sparse_categorical_crossentropy',  # Loss function for multi-class classification
    metrics=['accuracy']               # Metric to evaluate during training (accuracy)
)

• Optimizer: The Adam optimizer is often a good choice for most neural networks because it adapts the learning rate during training.
• Loss Function: Sparse Categorical Crossentropy is used for multi-class classification tasks where the labels are integers.
• Metrics: We’ll use accuracy to evaluate how well the model performs during training and evaluation.

5. Train the Model

Once the model is compiled, you can begin training it using the fit method. You’ll provide the training data (x_train, y_train), the number of epochs (iterations over the dataset), and the batch size.

# Train the model
history = model.fit(
    x_train, y_train, 
    epochs=5,                      # Number of training epochs
    batch_size=32,                 # Size of each batch
    validation_data=(x_test, y_test)  # Validation data for evaluating the model after each epoch
)

• Epochs: The number of times the entire training dataset is passed through the model.
• Batch Size: The number of samples processed before the model’s weights are updated.
• Validation Data: This data is used to evaluate the model’s performance after each epoch to prevent overfitting and help you monitor how well the model generalizes to new data.

6. Evaluate the Model

After training, you can evaluate the model’s performance on the test dataset to determine how well it performs on unseen data.

# Evaluate the model on the test data
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)

print(f"Test accuracy: {test_acc}")

• Evaluate: This method returns the loss and accuracy of the model on the test dataset.

7. Make Predictions

You can use the trained model to make predictions on new data. For example, if you want to predict the label of an image:

# Predict the labels of the test dataset
predictions = model.predict(x_test)

# Get the predicted class label for the first test image
predicted_label = tf.argmax(predictions[0]).numpy()
print(f"Predicted label for the first test image: {predicted_label}")

8. Save and Load the Model (Optional)

You can save the model to a file for later use, such as for inference in production environments.

# Save the model to a file
model.save('my_model.h5')

# Load the model from the file
loaded_model = tf.keras.models.load_model('my_model.h5')

Summary of Key Steps:

1. Prepare the Dataset: Load and preprocess the data (e.g., normalize and reshape).
2. Define the Model: Create a neural network architecture using tf.keras.Sequential.
3. Compile the Model: Choose an optimizer, loss function, and evaluation metrics.
4. Train the Model: Use model.fit() to train the model with your dataset.
5. Evaluate the Model: Use model.evaluate() to test the model’s performance on unseen data.
6. Make Predictions: Use model.predict() to make predictions on new data.
7. Save/Load the Model: Save the trained model and load it later for inference.

---

Example Code: Full Training Process

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

# 1. Load and preprocess dataset
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
x_train = x_train.reshape(-1, 28 * 28)
x_test = x_test.reshape(-1, 28 * 28)

# 2. Define the neural network model
model = models.Sequential([
    layers.InputLayer(input_shape=(28 * 28,)),
    layers.Dense(128, activation='relu'),
    layers.Dense(10, activation='softmax')
])

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

# 4. Train the model
model.fit(x_train, y_train, epochs=5, batch_size=32, validation_data=(x_test, y_test))

# 5. Evaluate the model
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f"Test accuracy: {test_acc}")

Key Takeaways:

• Keras API in TensorFlow provides a simple way to define and train neural networks.
• Model Definition: You can easily define models with layers (e.g., Dense, Conv2D, etc.).
• Training: The model is trained using the fit() function, and performance can be tracked using metrics like accuracy.
• Evaluation: Once trained, evaluate the model on unseen data (test set) using evaluate().
• Flexibility: TensorFlow allows you to define, train, and save models, making it easy to deploy to production.

Question: What are the key differences between TensorFlow 1.x and TensorFlow 2.x?

Answer:

TensorFlow 2.x is a significant upgrade from TensorFlow 1.x, designed to simplify and enhance the user experience for deep learning practitioners. TensorFlow 2.x emphasizes usability, flexibility, and performance improvements. Below are the key differences between TensorFlow 1.x and TensorFlow 2.x:

---

1. Eager Execution by Default

• TensorFlow 1.x:
  • TensorFlow 1.x relied heavily on graph-based execution. The computation graph had to be defined first, then executed within a session (using tf.Session()).
  • This approach made debugging and experimentation harder because you had to define the entire graph before running it.
• TensorFlow 2.x:
  • Eager execution is enabled by default, which means operations are evaluated immediately as they are called (like in Python). This makes the framework more intuitive and easier to debug, as you get the results right away without needing a session.
  • The framework now supports dynamic model construction and debugging, which makes experimentation faster and more interactive.

Example (Eager Execution in TensorFlow 2.x):

import tensorflow as tf
a = tf.constant([2.0, 3.0])
b = tf.constant([1.0, 4.0])
result = a + b
print(result)  # Output: tf.Tensor([3. 7.], shape=(2,), dtype=float32)

---

2. Simplified API (Keras Integration)

• TensorFlow 1.x:
  • TensorFlow 1.x had a more complex and fragmented API. While Keras was available as a separate high-level API, it was not tightly integrated into TensorFlow.
  • You had to manually build models using tf.layers or tf.keras.layers, and there was a steep learning curve for beginners.
• TensorFlow 2.x:
  • Keras is now tightly integrated into TensorFlow as the default high-level API for building and training models. This makes TensorFlow much easier to use for both beginners and advanced users.
  • TensorFlow 2.x encourages the use of the tf.keras module for building models, simplifying tasks like defining layers, compiling models, and training.
  • Many advanced functionalities like callbacks, model training, and evaluation are handled seamlessly with tf.keras.

Example (Model Building with tf.keras):

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
    Dense(64, activation='relu', input_shape=(32,)),
    Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5)

---

3. TensorFlow Functions (tf.function)

• TensorFlow 1.x:
  • In TensorFlow 1.x, graph building and execution were separate processes. Users had to explicitly create a computational graph and run it in a session.
• TensorFlow 2.x:
  • TensorFlow 2.x uses tf.function to automatically convert Python functions into TensorFlow graphs. This allows you to maintain the advantages of graph execution (speed, optimizations) while still benefiting from the flexibility of eager execution.
  • tf.function lets you define a function once, and TensorFlow will optimize and execute it as a graph, providing the best of both eager and graph-based execution.

Example (Using tf.function):

@tf.function
def compute(x, y):
    return x + y

result = compute(tf.constant(3), tf.constant(4))
print(result)  # TensorFlow graph execution

---

4. Removal of Redundant APIs

• TensorFlow 1.x:
  • TensorFlow 1.x had many redundant and complex APIs, making it harder to maintain and evolve the framework.
• TensorFlow 2.x:
  • Redundant APIs (like tf.app, tf.flags, tf.train.QueueRunner, etc.) have been removed or deprecated in TensorFlow 2.x. This streamlines the framework and reduces the surface area of the API.
  • TensorFlow 2.x also removes the need for tf.Session, tf.placeholder, and tf.global_variables_initializer(), making the code cleaner and more intuitive.

---

5. Improved Model Building and Training

• TensorFlow 1.x:
  • Building models in TensorFlow 1.x involved creating a computation graph first, then running it in a session.
  • Model training involved manually managing optimizers, loss functions, and gradients.
• TensorFlow 2.x:
  • With tf.keras, model building and training are now much easier. You can create models by stacking layers using Sequential or functional APIs, and training is managed using model.fit(), model.evaluate(), and model.predict().
  • Optimizers, loss functions, and metrics are managed more effectively with tf.keras.optimizers, tf.keras.losses, and tf.keras.metrics.

---

6. Better Support for Distributed Training

• TensorFlow 1.x:
  • Distributed training was handled via tf.distribute but was often complicated to configure and use.
• TensorFlow 2.x:
  • TensorFlow 2.x introduced tf.distribute.Strategy, which simplifies the process of training models on multiple devices (CPUs, GPUs, TPUs). This provides out-of-the-box support for multi-worker, multi-GPU training with little configuration.

---

7. TensorFlow Datasets (TFDS) Integration

• TensorFlow 1.x:
  • Data pipelines were more manual, often requiring the use of tf.data with custom input pipelines.
• TensorFlow 2.x:
  • TensorFlow 2.x comes with tfds (TensorFlow Datasets), which provides easy access to a wide range of datasets, and integrates directly with tf.data to streamline the process of loading and preprocessing data for training.

---

8. Upgraded TensorFlow Hub and TensorFlow Lite Support

• TensorFlow 1.x:
  • TensorFlow Hub and TensorFlow Lite were available, but the integration was less seamless.
• TensorFlow 2.x:
  • TensorFlow 2.x provides better integration with TensorFlow Hub for model reuse and TensorFlow Lite for edge devices. The API has been simplified to allow more straightforward deployment of models on mobile and embedded devices.

---

9. Enhanced Performance with XLA

• TensorFlow 1.x:
  • In TensorFlow 1.x, performance optimizations were available, but setting up XLA (Accelerated Linear Algebra) was often complex.
• TensorFlow 2.x:
  • XLA is enabled by default in TensorFlow 2.x, optimizing the performance of computations by compiling operations into high-performance code. This improves the speed and efficiency of training models, especially on specialized hardware.

---

10. Improved Debugging and Profiling

• TensorFlow 1.x:
  • Debugging and profiling in TensorFlow 1.x was challenging, primarily due to the graph-based execution and the need for tf.Session.
• TensorFlow 2.x:
  • Debugging is easier with eager execution, as you can use standard Python tools like pdb and print statements. TensorFlow 2.x also comes with enhanced debugging features in tf.debugging, improving the ease of identifying issues in your models.

---

Summary of Key Differences:

Feature	TensorFlow 1.x	TensorFlow 2.x
Execution Model	Static graph, requires session (tf.Session)	Eager execution by default
API	Complex, fragmented	Simplified, tf.keras is the default API
Model Building	Manual graph construction	tf.keras for quick model building
Distributed Training	Complicated	tf.distribute.Strategy simplifies training
Debugging	Hard due to graph execution	Easier with eager execution and Python tools
Performance	Limited optimization	XLA and better hardware support for optimizations
Data Pipeline	Manual with tf.data	Integration with tfds for easy dataset loading

---

Conclusion:

TensorFlow 2.x offers a much more intuitive and user-friendly interface for deep learning tasks. With features like eager execution, better Keras integration, simplified APIs, and improved performance, TensorFlow 2.x is a powerful framework that encourages experimentation and makes model building, training, and deployment more accessible. TensorFlow 1.x remains a powerful tool for users with specific requirements, but TensorFlow 2.x is the recommended version for most modern deep learning tasks.

Question: Explain the role of Keras in TensorFlow.

Answer:

Keras is an open-source deep learning API that simplifies the process of building and training neural networks. Originally developed as an independent high-level framework, Keras is now integrated directly into TensorFlow as its official high-level API. In TensorFlow 2.x, Keras plays a central role in streamlining the workflow for deep learning practitioners by providing a user-friendly interface for building models.

Here’s a breakdown of Keras’s role in TensorFlow:

---

1. High-Level API for Model Building

• Simplification: Keras provides a high-level interface for building neural network models, making the process significantly easier than using TensorFlow’s lower-level APIs. It abstracts away much of the complexity involved in defining layers, optimization algorithms, and the training process.
• Declarative Syntax: Keras enables a declarative programming style, where users define their models by stacking layers in a simple and intuitive way. This allows for quick prototyping and experimentation with different architectures.

Example (Simple model creation in Keras):

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Define the model
model = Sequential([
    Dense(64, activation='relu', input_shape=(32,)),
    Dense(10, activation='softmax')
])

---

2. Model Building Flexibility

• Sequential API: Keras offers the Sequential model, where you simply stack layers in a linear fashion. This is ideal for most problems, such as classification and regression tasks.
• Functional API: For more complex models, such as those with multiple inputs and outputs, shared layers, or residual connections, Keras provides the Functional API, which gives more flexibility and control over the model’s structure.

Example (Functional API for more complex architectures):

from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model

# Define an input tensor
input_tensor = Input(shape=(32,))
x = Dense(64, activation='relu')(input_tensor)
output_tensor = Dense(10, activation='softmax')(x)

# Create the model
model = Model(inputs=input_tensor, outputs=output_tensor)

---

3. Integration with TensorFlow

• TensorFlow as the Backend: Keras operates as an abstraction layer on top of TensorFlow. It leverages TensorFlow’s powerful backend for computation, optimization, and hardware acceleration (e.g., GPU and TPU support).
• Unified Framework: Starting with TensorFlow 2.x, Keras is now fully integrated into TensorFlow (tf.keras). This means Keras’s functionality is fully supported within TensorFlow’s ecosystem, allowing users to take advantage of all TensorFlow features (such as distributed training, TensorFlow Lite, TensorFlow Hub, etc.) while still using the simpler, higher-level Keras API.

Example (Using tf.keras):

import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(32,)),
    tf.keras.layers.Dense(10, activation='softmax')
])

---

4. Model Compilation, Training, and Evaluation

• Model Compilation: In Keras, once a model is defined, it needs to be compiled. This includes specifying the optimizer, loss function, and metrics to track during training.
• Training and Evaluation: Keras abstracts much of the complexity involved in the training loop. With methods like fit(), evaluate(), and predict(), users can quickly train models, evaluate them on test data, and make predictions.

Example (Model Compilation and Training):

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

# Train the model
model.fit(x_train, y_train, epochs=5)

# Evaluate the model
loss, accuracy = model.evaluate(x_test, y_test)

---

5. Built-in Layers, Models, and Utilities

• Pre-built Layers: Keras includes a wide range of pre-built layers like Dense, Conv2D, LSTM, Dropout, etc., for building complex neural networks, making it easy to experiment with different architectures.
• Pre-trained Models: Keras provides easy access to pre-trained models (like VGG, ResNet, and Inception) via Keras Applications, which are useful for tasks like transfer learning.
• Callbacks and Metrics: Keras supports several callbacks (e.g., EarlyStopping, ModelCheckpoint) for customizing the training process, as well as built-in metrics to monitor model performance.

Example (Using a pre-trained model for transfer learning):

from tensorflow.keras.applications import VGG16

# Load pre-trained VGG16 model (excluding top layer for transfer learning)
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# Freeze the base model's layers
base_model.trainable = False

# Add custom layers
model = tf.keras.Sequential([
    base_model,
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(10, activation='softmax')
])

---

6. Support for Custom Models and Training Loops

• Custom Layers and Models: Keras allows users to define custom layers, loss functions, and even optimization algorithms if the built-in components are not sufficient for their specific needs.
• Custom Training Loops: While fit() handles most training tasks, Keras also allows users to implement their custom training loops using GradientTape for advanced control over the training process.

Example (Custom Training Loop):

@tf.function
def train_step(model, images, labels, loss_fn, optimizer):
    with tf.GradientTape() as tape:
        predictions = model(images, training=True)
        loss = loss_fn(labels, predictions)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    return loss

---

7. Cross-Platform Support

• TensorFlow Lite: Keras models can be easily converted to TensorFlow Lite models for deployment on mobile and embedded devices.
• TensorFlow.js: Keras models can be converted into TensorFlow.js models for use in web applications.
• TensorFlow Hub: Models built with Keras can be easily shared via TensorFlow Hub, enabling easy reuse of trained models in different applications.

---

8. Unified Model Export and Deployment

• Model Saving and Loading: Keras provides simple methods to save and load models, both in the original Keras format (HDF5) and TensorFlow’s SavedModel format, ensuring flexibility across different deployment environments.
• Model Export: With TensorFlow 2.x, Keras models are compatible with TensorFlow Serving for serving models in production environments, enabling easy deployment and scaling.

Example (Saving and loading models):

# Save the model
model.save('my_model.h5')

# Load the model
loaded_model = tf.keras.models.load_model('my_model.h5')

---

Summary of Keras’s Role in TensorFlow:

• Simplified Model Building: Keras abstracts away complex implementation details, providing a simple interface to build, compile, train, and evaluate deep learning models.
• User-Friendly API: With easy-to-use syntax (Sequential and Functional APIs), Keras makes it easier for users to build neural networks with minimal code.
• TensorFlow Integration: As the high-level API of TensorFlow, Keras utilizes TensorFlow’s backend for computation, optimization, and hardware support, offering a powerful combination of ease-of-use and performance.
• Transfer Learning and Pre-trained Models: Keras provides access to pre-trained models, making it easy to use transfer learning for more complex tasks.
• Flexibility: While Keras simplifies the process, it also allows for more advanced features such as custom models, custom training loops, and extended functionality.

---

In conclusion, Keras is a critical part of TensorFlow, making it easier to develop, train, and deploy machine learning models by providing an intuitive, high-level API while still leveraging the full power of TensorFlow under the hood.

Question: What is the purpose of TensorFlow’s Session in 1.x, and how is it replaced in 2.x?

Answer:

In TensorFlow 1.x, the Session was a core component used to execute operations in a computational graph. It was responsible for allocating resources (such as memory) and running the graph by evaluating tensors, applying optimizations, and executing operations in the session.

However, with the introduction of TensorFlow 2.x, the Session was replaced by an eager execution model. This change simplifies the workflow and makes the framework more intuitive, especially for beginners.

---

1. TensorFlow 1.x: The Role of Session

In TensorFlow 1.x, the process of defining and executing a computation was split into two major steps:

1. Defining the computational graph: You first define the operations and tensors in a static graph (using TensorFlow’s symbolic graph approach).

2. Running the computation: You then need to create a Session to execute the graph. The session is responsible for managing the state of the graph and handling operations on tensors.

   The key functions of a Session in TensorFlow 1.x:

   • Creating and managing the graph: The Session loads the graph and runs computations.
   • Executing operations: You run operations inside the session using session.run().
   • Resource management: It manages memory and allocates resources needed to run the operations on devices like CPU or GPU.

   Example (TensorFlow 1.x with Session):

   import tensorflow as tf
   
   # Define the graph (operation)
   a = tf.constant(5)
   b = tf.constant(10)
   c = a + b
   
   # Create a Session
   with tf.Session() as sess:
       result = sess.run(c)  # Execute the graph
       print(result)  # Output: 15

   In this example, the computation of c = a + b is part of the computation graph, but it only happens once the Session is created and sess.run() is called.

---

2. TensorFlow 2.x: Eager Execution and No More Session

TensorFlow 2.x introduced eager execution by default. This change allows operations to execute immediately as they are called, rather than needing to be wrapped in a session or graph. As a result, you no longer need to explicitly create and manage a Session. This eager execution model makes TensorFlow more Pythonic, where operations are evaluated directly and immediately.

Key changes in TensorFlow 2.x:

• No need for Session: In eager execution, operations return actual values immediately, and there’s no need for a session to execute the graph.

• Automatic graph building: TensorFlow automatically builds a computational graph in the background, enabling dynamic graph execution.

• Simplified code: The lack of the session reduces boilerplate code, making it easier to understand and use TensorFlow, especially for interactive and prototyping tasks.

  Example (TensorFlow 2.x with eager execution):

  import tensorflow as tf
  
  # Define tensors (operations are executed eagerly)
  a = tf.constant(5)
  b = tf.constant(10)
  c = a + b
  
  print(c)  # Output: tf.Tensor(15, shape=(), dtype=int32)

  In this TensorFlow 2.x example, the computation of c = a + b is executed immediately and returns the result directly, without needing to create a Session.

---

3. How TensorFlow 2.x Replaces the Session Concept:

In TensorFlow 2.x, eager execution simplifies model creation and evaluation. You don’t need to worry about managing a Session, because everything runs directly in a more intuitive, imperative style. However, if you still need to build models for deployment or use static graphs for optimization, you can switch back to graph mode using tf.function.

• tf.function: TensorFlow 2.x introduced the tf.function decorator to allow users to create a graph from eager execution code. This enables the same graph optimizations that TensorFlow 1.x provided, while still writing code in the style of eager execution.

  Example (Using tf.function for graph execution):

  @tf.function
  def add_fn(a, b):
      return a + b
  
  a = tf.constant(5)
  b = tf.constant(10)
  c = add_fn(a, b)  # Executes in graph mode, but code is still eager-like
  print(c)

  In this case, the function add_fn is decorated with @tf.function, which tells TensorFlow to optimize it into a static computational graph for better performance, but the syntax remains simple and Pythonic.

---

4. Transitioning from Session to TensorFlow 2.x:

For users transitioning from TensorFlow 1.x, it’s important to note that:

• Model building and training in TensorFlow 2.x are also easier and more flexible, with the inclusion of Keras as the high-level API.
• TensorFlow’s default behavior is eager execution, but users can still create static graphs if necessary using tf.function and other TensorFlow tools like tf.Graph().

---

Summary of Changes:

• TensorFlow 1.x (Session): Computation happens inside a Session object, which manages the execution of operations in a computational graph. It requires explicit management of graphs and sessions.
• TensorFlow 2.x (Eager Execution): Eager execution is the default mode in TensorFlow 2.x, where operations are evaluated immediately. The need for a Session is removed, making the framework easier to use. Users can optionally use tf.function to create static graphs for performance optimization.

In summary, the Session in TensorFlow 1.x was necessary for running the computational graph, but in TensorFlow 2.x, eager execution makes this step redundant, and users can work directly with operations in a more intuitive and dynamic way.

Read More

If you can’t get enough from this article, Aihirely has plenty more related information, such as tensorflow interview questions, tensorflow interview experiences, and details about various tensorflow job positions. Click here to check it out.