Dr BR Ambedkar National Institute of Technology

Jalandhar-144011, Punjab, India.

FINAL ASSIGNMENT-3

PRINCIPLES OF DEEP LEARNING

(CSPE-452)

Submitted to: Mr Vishal Kumar Verma

Submitted by:
Aryan Kumar (20103032)
Section:1
(group 2)
1. Explain how to manage / handle Models over the CPU and GPU.

Managing or handling models over the CPU and GPU involves optimizing the performance of deep learning
models by leveraging the computational power of these processing units efficiently. Here's a breakdown of
how this is typically done:
1. Hardware Compatibility and Installation:
• Ensure that your machine has compatible hardware, including a GPU if you plan to utilize it for
model training.
• Install the necessary drivers for both CPU and GPU to ensure they are recognized and can be used
by your deep learning framework (e.g., TensorFlow, PyTorch).
2. Choosing Device Placement:
• In most deep learning frameworks, you can specify whether computations should be performed on
the CPU or GPU.
• For TensorFlow, this can be done using tf.device() to explicitly assign operations to a specific
device.
3. Batch Processing:
• Utilize batch processing techniques to make efficient use of the GPU's parallel processing
capabilities.
• Batch processing involves feeding multiple data samples into the model simultaneously, which is
well-suited for GPU acceleration.
4. Memory Management:
• GPU memory is limited compared to CPU memory, so it's important to manage memory usage
effectively.
• Techniques like memory pooling and optimizing data loading can help minimize memory
consumption.
5. Model Parallelism:
• For very large models that exceed the memory capacity of a single GPU, consider using model
parallelism.
• Model parallelism involves splitting the model across multiple GPUs, with each GPU handling a
portion of the model's computations.
6. Data Parallelism:
• Data parallelism involves distributing the training data across multiple GPUs, with each GPU
processing a different batch of data.
• Frameworks like TensorFlow and PyTorch provide built-in support for data parallelism, making it
easier to train models across multiple GPUs.
7. Monitoring and Profiling:
• Use monitoring tools and profilers to track the performance of your model on both CPU and GPU.
• Tools like TensorFlow Profiler and NVIDIA's CUDA Profiling Tools can help identify bottlenecks
and optimize performance.
8. Regular Updates and Maintenance:
• Keep your deep learning framework, drivers, and hardware configurations up to date to benefit
from performance improvements and bug fixes.
2. Specify each step required to implement the Logistic Regression Model in
Tensor-Flow. Briefly discuss pseudo-code for Logging and Training the Logistic
Regression Model.

Here's a step-by-step guide to implementing a Logistic Regression model in TensorFlow, along with a brief
discussion on logging and training using pseudo-code:

Step 1: Import TensorFlow and other necessary libraries

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

Step 2: Prepare your data

# Assuming you have features X_train and labels y_train
# Normalize your data if necessary

Step 3: Build the Logistic Regression Model

# Define input layer
input_layer = Input(shape=(num_features,))

# Define output layer with sigmoid activation for binary classification

output_layer = Dense(1, activation='sigmoid')(input_layer)

# Create the model

model = Model(inputs=input_layer, outputs=output_layer)

# Compile the model with appropriate loss and optimizer

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

Step 4: Training the Model

# Train the model
model.fit(X_train, y_train, epochs=num_epochs, batch_size=batch_size, validation_split=validation_split)

# Evaluate the model

loss, accuracy = model.evaluate(X_test, y_test)
 Logging and Training Pseudo-code:

# Define a callback for logging during training

class LoggingCallback(tf.keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs=None):
print(f"Epoch {epoch}: loss = {logs['loss']}, accuracy = {logs['accuracy']}")

# Create an instance of the logging callback

logging_callback = LoggingCallback()

# Train the model with logging callback

model.fit(X_train, y_train, epochs=num_epochs, batch_size=batch_size,validation_split=validation_split,
callbacks=[logging_callback])

In the pseudo-code, we define a custom callback LoggingCallback to log training progress at the end of each
epoch. During training, we pass this callback to the fit method using the callbacks parameter. This allows us
to monitor and log metrics such as loss and accuracy during training.

2. How Tensor-Board is used to Visualize Computation Graphs?

TensorBoard, a visualization toolkit for TensorFlow, offers functionalities beyond just monitoring training
metrics. It can also be used to visualize the computational graphs, which are crucial for understanding how
your machine learning model works.

Here's how TensorBoard helps visualize computation graphs:

• Graph View: TensorBoard provides a dedicated tab named "Graphs" where you can view the
computational graph of your model. This graph represents the mathematical operations happening within
your model, including layers and operations. TensorBoard displays the graph in an interactive format,
allowing you to zoom, pan, and expand nodes for a closer look.
• Node Breakdown: The graph depicts various nodes representing the operations within your model.
These nodes can be individual operations like convolutions or pooling layers, or even composite
structures. TensorBoard allows collapsing these nodes into high-level blocks, making it easier to analyze
complex graphs with numerous layers.
• Conceptual vs. Op-Level Graphs: TensorBoard offers two ways to view the computational graph:
o Op-level graph: This view presents the graph in detail, showing individual operations and their
connections. It closely resembles the structure you defined in your code.
o Conceptual graph: This simplified view focuses on the overall Keras model architecture,
providing a high-level understanding of the model's building blocks.

By offering these visualization capabilities, TensorBoard helps you gain insights into the data flow
within your model, identify potential bottlenecks, and ensure your model aligns with what you intended.
4. Write a proper Code of python for a Learning Multilayer Model for MNIST in
Tensor-Flow. Explain the comments in detail and the steps used for learning and
multilayering.

Here's the Python code for a Multilayer Perceptron (MLP) model for MNIST handwritten digit classification
in TensorFlow with explanations:

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Dense

# Load MNIST dataset (automatically downloaded if not present)

(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Reshape and normalize data

x_train = x_train.reshape(-1, 28 * 28).astype("float32") / 255.0
x_test = x_test.reshape(-1, 28 * 28).astype("float32") / 255.0

# Define number of classes (10 digits)

num_classes = 10

# Create the model

model = tf.keras.Sequential([
# First hidden layer with 128 neurons and ReLU activation
Dense(128, activation="relu", input_shape=(28 * 28,)),
# Second hidden layer with 64 neurons and ReLU activation
Dense(64, activation="relu"),
# Output layer with 10 neurons (one for each digit class) and softmax activation
Dense(num_classes, activation="softmax")
])

# Compile the model

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

# Train the model

model.fit(x_train, y_train, epochs=10, batch_size=32)

# Evaluate the model on test data

test_loss, test_acc = model.evaluate(x_test, y_test)
print("Test accuracy:", test_acc)
Explanation:
1. Import Libraries: We import tensorflow as tf and relevant functions from tensorflow.keras.datasets and
tensorflow.keras.layers.
2. Load MNIST Data: The mnist.load_data() function downloads and loads the MNIST dataset, splitting it
into training and testing sets for images (x_train, x_test) and labels (y_train, y_test).
3. Reshape and Normalize Data:
o x_train and x_test are reshaped from 2D arrays (28x28 pixels) to 1D arrays with 784 elements
(28 * 28) for compatibility with the dense layers.
o Data is converted to float32 type and normalized by dividing each pixel value by 255. This
normalization helps improve training performance.
4. Define Number of Classes: We set num_classes to 10, representing the 10 digits (0-9) that the model
needs to classify.
5. Create the Model:
o We define a sequential model using tf.keras.Sequential.
o The model consists of three layers:
▪ First Hidden Layer:
▪ Dense(128, activation="relu"): This layer has 128 neurons and uses the ReLU
(Rectified Linear Unit) activation function. ReLU introduces non-linearity to the
model, allowing it to learn complex patterns.
▪ Second Hidden Layer:
▪ Similar to the first layer, it has 64 neurons with ReLU activation.
▪ Output Layer:
▪ Dense(num_classes, activation="softmax"): This layer has 10 neurons (one for
each digit class) and uses the softmax activation function. Softmax ensures the
output probabilities for all classes sum to 1, making it suitable for multi-class
classification.
6. Compile the Model:
o model.compile(loss="sparse_categorical_crossentropy", optimizer="adam",
metrics=["accuracy"]): This configures the training process.
▪ Loss Function: We use "sparse_categorical_crossentropy" as the loss function, which
measures the difference between the predicted probabilities and the actual labels for
multi-class classification problems.
▪ Optimizer: The "adam" optimizer is used to update the model weights during training.
▪ Metrics: We track the "accuracy" metric to monitor how well the model is classifying
digits.
7. Train the Model:
o model.fit(x_train, y_train, epochs=10, batch_size=32): This trains the model.
▪ x_train: Training data features.
▪ y_train: Training data labels.
5. Write a note on implementing the DNC in Tensor-Flow with emphasis to Read
and Comprehend.

The Differentiable Neural Computer (DNC) is a powerful neural network architecture with an internal
memory mechanism. Implementing a DNC in TensorFlow requires careful consideration of its core
components, especially the Read and Comprehend functions. Here's a breakdown of key aspects:

DNC Components:

• Input Gate: Controls the flow of information from the input vector into the memory.
• Write Gate: Regulates writing new information into memory cells.
• Erase Gate: Determines which existing information in memory to erase.
• Read Heads: Multiple read heads can access and retrieve information from memory in parallel.
• Interface Vector: Represents the interaction between the controller and memory.

Read and Comprehend Operations:

These operations are crucial for the DNC's ability to process sequential data and reason over it. Here's how
they can be implemented in TensorFlow:

• Read Heads:
o Define a function that takes the current memory state and interface vector as input.
o Use multiple convolutional layers to process the memory state, capturing spatial relationships
between memory cells.
o Employ attention mechanisms to focus on specific memory locations relevant to the current task.
o The output of this function represents the content read from memory by each head.
• Comprehension:
o Combine the outputs from all read heads using techniques like summation or weighted averaging.
o This combined output represents the overall understanding of the information retrieved from
memory.

TensorFlow Implementation Considerations:

• Memory Representation: Utilize a 3D tensor to represent the DNC's memory, with dimensions for:
o Number of memory cells.
o Vector size of each cell.
o Number of read heads (each head needs its own access mechanism).
• Gated Recurrent Units (GRUs): Implement the Input, Write, and Erase Gates using GRUs. GRUs are
well-suited for controlling information flow due to their inherent gating mechanism.
• Custom Operations: TensorFlow allows defining custom operations using libraries like
tf.contrib.layers. This can be helpful for implementing the core DNC functionalities (read heads,
gates) efficiently.

Additional Notes:

• The specific implementation details will depend on the chosen library within TensorFlow (e.g.,
tf.keras for higher-level APIs or lower-level operations for more control).
• Existing libraries like DNC-tensorflow (https://github.com/google-deepmind/dnc) can serve as a starting
point and reference for building a DNC in TensorFlow.

Benefits of Read and Comprehend:

 • Enable the DNC to effectively access and utilize past information during processing.
• Improve the model's ability to handle complex tasks that require reasoning over sequential data (e.g.,
question answering, machine translation).

While implementing a DNC can be challenging, focusing on the Read and Comprehend operations lays the
foundation for building a powerful memory-augmented neural network architecture in TensorFlow.

6. Write a note on how to Masters Atari Games.

Atari games, while appearing simple, present significant challenges for achieving mastery through
traditional programming methods. However, advancements in deep reinforcement learning have opened
doors to attaining superhuman performance in these games. Here's an overview of approaches for
mastering Atari games:

Traditional Programming Limitations:

• Hand-crafted Logic: Complexities like enemy behavior, power-up effects, and level generation make it
difficult to design comprehensive rules for every situation.
• State Explosion: The number of possible game states grows exponentially, making it impractical to
define optimal actions for every scenario.

Deep Reinforcement Learning (RL) Approach:

• Agent-Environment Interaction: An RL agent interacts with the Atari game environment (represented
by pixels on the screen and game score).
• Trial and Error Learning: Through trial and error (playing the game repeatedly), the agent learns to
take actions that maximize its reward (high score).
• Neural Networks: Deep neural networks analyze the game screen and predict the best action for the
agent to take.

Techniques for Mastering Atari Games with RL:

• Q-Learning: This algorithm estimates the future reward for taking an action in a specific state. The
agent learns to choose actions that lead to states with higher expected future rewards.
• Experience Replay: Stores past experiences (game states, actions, rewards) and replays them during
training. This helps the agent learn from a broader set of situations without repeatedly encountering the
same states.
• Deep Q-Networks (DQNs): Leverages deep neural networks to approximate the Q-value function,
enabling the agent to handle the complex visual inputs from Atari games.