TensorFlow Data Pipelines

# CHAPTER 17

TensorFlow Data Pipelines #

1. Introduction #

2. Learning Objectives #

• Explain the GPU bottleneck problem.

• Understand the purpose of the tf.data API.

• Create a tf.data.Dataset from arrays and files.

• Apply transformations (map, batch, shuffle).

• Implement prefetch for maximum training efficiency.

3. The GPU Bottleneck #

4. Creating a Basic Dataset #

import tensorflow as tf
import numpy as np

# Mock raw data
X_data = np.arange(10) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Create the Dataset object
dataset = tf.data.Dataset.from_tensor_slices(X_data)

# Iterate through the dataset
for item in dataset:
    print(item.numpy(), end=" ")
# Output: 0 1 2 3 4 5 6 7 8 9

5. Building the Pipeline (Map, Shuffle, Batch) #

# 1. Define a preprocessing function
def scale_data(x):
    return x * 10

# 2. Build the Pipeline chain
pipeline = dataset \
    .map(scale_data) \
    .shuffle(buffer_size=10) \
    .batch(batch_size=3)

# 3. View the Output
for batch in pipeline:
    print("Batch:", batch.numpy())

# Output might look like:
# Batch: [80 20 50]
# Batch: [0 90 10]
# Batch: [60 30 70]
# Batch: [40]

*Notice how .batch(3) automatically grouped the data for the neural network!*

6. The Magic of Prefetching #

# Adding prefetch at the very end of the pipeline
# AUTOTUNE tells TensorFlow to figure out the optimal number of batches to prepare in advance based on your CPU power.
pipeline = dataset \
    .map(scale_data) \
    .shuffle(10) \
    .batch(32) \
    .prefetch(tf.data.AUTOTUNE)

# Now, just pass the pipeline directly to model.fit!
# model.fit(pipeline, epochs=10)

7. Working with Massive File Systems #

train_dataset = tf.keras.utils.image_dataset_from_directory(
    'path_to_image_folder',
    image_size=(224, 224),
    batch_size=32
)

# Apply prefetching for speed
train_dataset = train_dataset.prefetch(tf.data.AUTOTUNE)

# Train
# model.fit(train_dataset, epochs=10)

8. Common Mistakes #

• Shuffling *after* Batching: Order matters in the pipeline. If you .batch(32) first, and then .shuffle(), you are just shuffling the order of the batches, not the individual images. Always .shuffle() before you .batch().

• Forgetting AUTOTUNE: Hardcoding .prefetch(5) might be fine for your laptop, but if you run the code on a server with 64 CPU cores, you are wasting resources. Always use tf.data.AUTOTUNE.

9. Best Practices #

• Parallel processing in Map: If your .map() function is doing heavy preprocessing (like complex image cropping), you can tell the CPU to use multiple cores to do it faster: .map(preprocess_img, num_parallel_calls=tf.data.AUTOTUNE).

10. Exercises #

1. 1. Write a tf.data pipeline that takes an array of numbers [1, 2, 3, 4, 5, 6], shuffles them, groups them into batches of 2, and uses prefetching.

1. 2. Why is a GPU bottleneck problematic for training times?

11. MCQ Quiz with Answers #

12. Interview Questions #

• Q: Explain the sequence of operations map -> shuffle -> batch -> prefetch and why this specific order is crucial.

• Q: What is the underlying execution difference between loading data entirely into a NumPy array versus using a tf.data.Dataset?

13. FAQs #

14. Summary #

15. Next Chapter Recommendation #