NEW
Font size
WorksheetsDeep Learning — III B.Sc. Data Science
Total questions: 80
Worksheet time: 40mins
Who is considered the father of Artificial Intelligence?
Alan Turing
Andrew Ng
Elon Musk
Stuart Russell
The term “Artificial Intelligence” was coined at:
MIT Conference
Dartmouth Conference
Stanford Symposium
Oxford AI Summit
What were early rule-based AI systems called?
Intelligent Agents
Expert Systems
Neural Networks
Deep Agents
Machine learning algorithms “learn” from:
Rules
Data
Hardware
Human intuition
Early neural network training breakthrough came from:
CNNs
Backpropagation
NLP
GANs
ML boom restarted in 2010s because of:
More textbooks
More powerful GPUs
AGI inventions
Bigger keyboards
What enabled modern deep learning?
Tiny datasets
Cloud gaming
Large datasets
Analog computers
Who developed Convolutional Neural Networks?
LeCun
Bengio
Ng
Turing
A Deep Neural Network has:
Only 1 layer
No activations
Multiple hidden layers
Only input
Node in neural network =
Neuron
Bit
Token
Window
What do weights represent?
Hyperparameters
Learnable parameters
Accuracy
Inputs
Activation functions introduce:
Linearity
Non-linearity
Symmetry
Memory
Most common hidden layer activation:
Sigmoid
ReLU
Softmax
Constant
Softmax is used in:
Regression
Multi-class classification
Clustering
GANs
Loss function measures:
Hardware
Difference between predicted & true
Dataset length
GPU usage
Gradient descent updates:
Layers
Weights
Neurons
Batch size
Backpropagation propagates:
Random numbers
Output classes
Gradients
Training time
Dropout is used for:
Overfitting reduction
Faster inference
Memory expansion
Model cloning
Which network is best for image data?
CNN
LSTM
RNN
Transformer
Which network uses sequence memory?
CNN
LSTM
Logistic Regression
GAN
Autoencoders are used for:
Classification
Feature learning
Reinforcement
Sorting
Batch size means:
Total dataset
Labels only
Samples per training step
Number of hidden layers
TensorFlow was developed by:
Amazon
Meta
Apple
Which library is NOT primarily for ML?
NumPy
TensorFlow
Keras
PyTorch
Tensor =
Loss
Multi-dimensional array
GPU
Model path
TensorFlow Variables can:
Never change
Update during training
Store only images
Store only integers
TensorFlow Graph stores:
Image maps
Computational operations
Python backtraces
Loss reports
GradientTape is used to:
Record gradients
Play music
Store checkpoints
Test accuracy
TensorFlow Dataset API helps with:
Visualization
Data pipeline
GPU drivers
Loss reduction
Epoch means:
1 mini-batch
1 full pass over dataset
1 layer
Loss multiplication
Optimizer changes:
Dataset
Weights
Batch size
Number of neurons
Adam stands for:
Adaptive Moment Estimation
Automatic Model Expansion
Adaptive Model Encoder
Adaptive Memory
Loss function is used to:
Test GPUs
Measure prediction error
Optimizer purpose
Reduce loss
Generate samples
Save checkpoints
Create graphs
Training loop steps order
Loss → Predict → Update
Predict → Loss → Update
Train → Deploy → Save
Test → Train → Save
Validation is used to detect
Underfitting only
Overfitting
GPU levels
Activation failure
Keras is a
Low-level API
High-level API
Database
Browser engine
Layers are added using
model.compile
model.add
model.predict
keras.layer.new
sequential() model type is
Graph-based
Linear stack of layers
RNN-only
GAN-only
Model training in Keras uses
model.fit
model.build
model.save
model.image
What does a neuron compute in a neural network?
Input only
Weighted sum + activation
Batch size
Loss function
What is a layer in a neural network?
A CSV file
A group of neurons
A dataset partition
A training loop
The output of a neuron before activation is called
Bias
Z-value
Alpha
Time step
Bias helps the model
Reduce learning rate
Shift activation function
Remove neurons
Reduce overfitting
Sigmoid outputs range from
-1 to 1
0 to 1
0 to 10
-10 to 10
Which activation avoids exploding outputs?
Linear
ReLU
Tanh
HardMax
Why is ReLU preferred?
No training needed
Fast computation and avoids vanishing gradients
Safe from overfitting
Built only for GPUs
What does Softmax output?
Binary values
Probabilities
Loss values
Gradients
Overfitting occurs when model
Performs well on train and test
Performs poorly on train
Performs well on train but poorly on test
Has many layers
Early stopping prevents
Underfitting
Overfitting
GPU crashes
Model saving
A shallow neural network has
Many hidden layers
5+ input layers
Zero hidden layer
2 output layers
Which improves generalization?
Large batch
More epochs
Data augmentation
Higher dropout rate always
TensorFlow is mainly used for
SEO
ML and Deep Learning
Blockchain
3D rendering
PyTorch is popular because of
Static graph
Dynamic graph
Low RAM
Web hosting
Which library uses .nn.Module?
TensorFlow
PyTorch
Scikit
Keras
Scikit-learn is used mainly for
Classical ML
Hardware control
Visualization
Database indexing
Which library is used heavily for numerical operations?
NumPy
SQLAlchemy
Selenium
Scikit-image
TensorBoard helps with
GPU drivers
ML model visualization
PyTorch Lightning provides:
High-level training wrapper
Compiler
Dataset generator
Browser app
JAX differentiates using:
AutoGrad
CNN
Decision trees
BERT
TensorFlow tensors support:
Only 1D
2D only
Multi-dimensional arrays
Only boolean values
In TF, tf.constant is:
Mutable
Unchangeable
A layer
A model
In TF, tf.Variable is:
Static
Read-only
Trainable
GPU-only
The computational graph represents:
Folder structure
Flow of mathematical ops
GPU drivers
File permissions
Eager execution is:
On-demand execution
Lazy loading
Graph only
GPU emulation
tf.cast() is used to:
Change tensor type
Load datasets
Save checkpoints
Train model
tf.one_hot() converts labels into:
Images
Text
Binary vectors
Gradients
tf.argmax() returns:
Minimum element
Index of max element
Loss
Number of layers
tf.metrics contains:
Activation functions
Evaluation metrics
GPU tools
Datasets only
Model building step order:
Define → Compile → Train
Compile → Train → Define
Evaluate → Save → Train
Train → Deploy → Define
Why compile a model?
Allocate memory
Select loss and optimizer
Convert data
Create graph
In supervised learning, labels are:
Random samples
Unknown outputs
Ground truth
Hidden layers
Validation helps identify:
GPU faults
Overfitting
Model import
Input loss
Batch normalization helps:
Reduce data size
Stabilize training
Remove neurons
Increase epochs
Learning rate controls:
#layers
Step size in weight updates
Tensor shape
Batch size only
Training stops when:
Loss is 0 only
Early stopping triggers
GPU overheats
Labels change
Keras API type:
Low-level
High-level
Hardware API
Cloud API
Layers in Sequential model are added via:
model.layer()
model.add()
model.connect()
keras.link()
Keras Functional API is best for:
Simple stacks
Complex multi-input/multi-output models
Only RNN
YOLO architectures only
model.save() stores:
Dataset
Entire model architecture + weights
GPU config
Compilation logs
