WorksheetsWeek3_S2
Total questions: 10
Worksheet time: 5mins
What is one key advantage of using TensorFlow's Data API for loading and preprocessing data?
It only works with data already stored as TensorFlow Tensor objects
It requires the entire dataset to be loaded into memory as a NumPy array before processing.
It lacks support for data shuffling or parallel data loading.
It can easily read data from various sources and apply transformations in just a few lines of code.
In tf.data pipelines, what happens when you call a transformation method (like batch() or shuffle()) on a Dataset?
It modifies the existing Dataset in-place.
It returns a new Dataset with the transformation applied, leaving the original Dataset unchanged.
It copies all the data into a new data structure immediately.
It has no effect until you explicitly convert the Dataset to a list.
Which tf.data method should you use to apply a custom preprocessing function to each element of a Dataset?
map() – to transform each element using a function.
filter() – to remove elements based on a condition.
batch() – to combine elements into batches.
apply() – to directly modify the Dataset in place.
How can you remove data entries that don’t meet a certain condition using the tf.data API?
Use map() with a condition to skip elements.
Use the filter() method with a boolean function to drop unwanted items.
Use skip() to skip any false elements.
Manually iterate and discard items; tf.data cannot do this.
In the context of tf.data, what does the shuffle(buffer_size) operation do?
It sorts the dataset elements in ascending order up to the buffer size.
It loads the entire dataset into memory and performs a perfect shuffle of all elements.
It maintains a buffer of buffer_size elements and randomly selects the next element from that buffer, replenishing it from the source, to produce a shuffled stream.
It repeats the dataset buffer_size times in random order.
Why is using prefetch(1) at the end of a tf.data pipeline beneficial for training performance?
It has no effect unless you are using a GPU.
It automatically parallelizes the model across multiple GPUs.
It caches the entire dataset in memory before training starts.
It overlaps data preparation with model training by always having the next batch ready in advance.
Why use a deep neural network (multiple hidden layers) instead of a shallow one (single hidden layer)?
deep networks never overfit, whereas shallow ones do.
deep networks can model complex functions with far fewer neurons by learning hierarchical features.
deep networks require no tuning of hyperparameters.
a single hidden layer cannot approximate complex functions at all.
How do you use a trained Keras model to make predictions on new data?
Use model.evaluate(new_X, new_y) and read off the predictions from the loss
Re-compile the model with the new data as training data.
Call the model’s predict method on the new input data (e.g. model.predict(new_X))
Add the new data to the model’s training set and call model.fit again for one epoch.
Which scenario is not a clear sign that your model is overfitting the data?
The model performs poorly on both training and validation sets.
The model performs much better on the training set than on the validation set
Training accuracy and validation accuracy are both high and very close to each other.
Adding more training data causes the validation performance to improve.
If your model is performing poorly even on the training data (much error on the training set), what is this situation called, and what does it imply?
It is underfitting, implying the model is too simple or not trained enough to capture the patterns in the training data.
It is overfitting, implying the model memorized the training data and is failing to generalize.
It means the model has a bug – a well-configured neural network should always fit the training data almost perfectly.
It implies perfect generalization, because low training performance often means high test performance.
