Dataset from files in TensorFlow - ML Experiment: Train & Evaluate

Experiment - Dataset from files

Problem:You want to train a model using images stored in files. Currently, you load images manually and feed them to the model, which is slow and error-prone.

Current Metrics:Training accuracy: 85%, Validation accuracy: 80%, Training loss: 0.45, Validation loss: 0.55

Issue:The manual loading of images causes slow training and occasional errors in data feeding. Dataset pipeline is not optimized.

Your Task

Create a TensorFlow Dataset pipeline that loads images from files efficiently and feeds them to the model, maintaining or improving current accuracy.

Use TensorFlow's tf.data API to load images from file paths.

Do not change the model architecture.

Maintain batch size of 32 and image size of 128x128.

Hint 1

Hint 2

Hint 3

Solution

TensorFlow

import tensorflow as tf
import os

# Assume images are in 'data/train' folder with subfolders for classes
train_dir = 'data/train'

# Get list of image file paths and labels
class_names = sorted(os.listdir(train_dir))
file_paths = []
labels = []
for label, class_name in enumerate(class_names):
    class_dir = os.path.join(train_dir, class_name)
    for fname in os.listdir(class_dir):
        if fname.endswith('.jpg') or fname.endswith('.png'):
            file_paths.append(os.path.join(class_dir, fname))
            labels.append(label)

# Convert to TensorFlow Dataset
file_paths_ds = tf.data.Dataset.from_tensor_slices(file_paths)
labels_ds = tf.data.Dataset.from_tensor_slices(labels)
dataset = tf.data.Dataset.zip((file_paths_ds, labels_ds))

# Function to load and preprocess images
IMG_SIZE = 128

def load_and_preprocess(path, label):
    image = tf.io.read_file(path)
    image = tf.image.decode_jpeg(image, channels=3)
    image = tf.image.resize(image, [IMG_SIZE, IMG_SIZE])
    image = image / 255.0  # normalize to [0,1]
    return image, label

# Apply preprocessing
batch_size = 32
dataset = dataset.map(load_and_preprocess, num_parallel_calls=tf.data.AUTOTUNE)
dataset = dataset.shuffle(buffer_size=1000)
dataset = dataset.batch(batch_size)
dataset = dataset.prefetch(tf.data.AUTOTUNE)

# Example model (unchanged)
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(IMG_SIZE, IMG_SIZE, 3)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(len(class_names), activation='softmax')
])

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

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

Replaced manual image loading with TensorFlow Dataset pipeline using tf.data API.

Used from_tensor_slices to create dataset from file paths and labels.

Added map function to load and preprocess images efficiently.

Added shuffle, batch, and prefetch for better performance.

Results Interpretation

Before: Training accuracy 85%, Validation accuracy 80%, Training loss 0.45, Validation loss 0.55

After: Training accuracy 87%, Validation accuracy 82%, Training loss 0.40, Validation loss 0.50

Using TensorFlow's Dataset API to load images from files creates an efficient data pipeline that improves training speed and slightly improves accuracy by reducing data loading errors and bottlenecks.

Bonus Experiment

Try adding data augmentation (random flips, rotations) in the dataset pipeline to improve model generalization.

💡 Hint

Use tf.image functions inside the map() to apply random transformations to images before batching.

Practice

1. What is the main purpose of using tf.data.Dataset.from_tensor_slices() with file paths in TensorFlow?

easy

A. To convert tensors into image files

B. To directly read image data from files into memory

C. To save datasets to disk as files

D. To create a dataset that holds file paths which can be read later

Solution

1. Step 1: Understand the function purpose

   tf.data.Dataset.from_tensor_slices() creates a dataset from a tensor, often a list of file paths, not the file contents themselves.

2. Step 2: Clarify dataset content

   The dataset holds file paths as strings, which can be mapped later to read actual file data.

3. Final Answer:

   To create a dataset that holds file paths which can be read later -> Option D

4. Quick Check:

   from_tensor_slices(file_paths) = dataset of paths [OK]

Hint: Remember: from_tensor_slices holds paths, not file data [OK]

Common Mistakes:

• Thinking it reads file contents immediately
• Confusing dataset creation with saving files
• Assuming it converts tensors to images

2. Which of the following is the correct way to create a dataset from a list of image file paths in TensorFlow?

easy

A. dataset = tf.data.Dataset.from_tensor_slices(image_paths)

B. dataset = tf.data.Dataset.read_files(image_paths)

C. dataset = tf.data.Dataset.load(image_paths)

D. dataset = tf.data.Dataset.create(image_paths)

Solution

1. Step 1: Recall correct TensorFlow method

   The method to create a dataset from a list of tensors (like file paths) is from_tensor_slices().

2. Step 2: Verify options

   Methods like tf.data.Dataset.load(), tf.data.Dataset.read_files(), and tf.data.Dataset.create() are not valid TensorFlow dataset creation methods.

3. Final Answer:

   dataset = tf.data.Dataset.from_tensor_slices(image_paths) -> Option A

4. Quick Check:

   Correct method is from_tensor_slices [OK]

Hint: Use from_tensor_slices for lists of file paths [OK]

Common Mistakes:

• Using non-existent methods like read_files or load
• Confusing dataset creation with file reading
• Misspelling method names

3. Given the code below, what will be the output when iterating over the dataset?

import tensorflow as tf
image_paths = ["img1.jpg", "img2.jpg"]
dataset = tf.data.Dataset.from_tensor_slices(image_paths)
for item in dataset:
    print(item.numpy().decode())

medium

A. Error: decode() not found

B. [b'img1.jpg', b'img2.jpg']

C. img1.jpg\nimg2.jpg

D. Tensor objects printed

Solution

1. Step 1: Understand dataset content

   The dataset contains string tensors of file paths: b'img1.jpg', b'img2.jpg'.

2. Step 2: Decode bytes to string

   Calling item.numpy() returns bytes, and decode() converts bytes to normal strings.

3. Final Answer:

   img1.jpg\nimg2.jpg -> Option C

4. Quick Check:

   Decoded bytes = file names [OK]

Hint: Use .numpy().decode() to get string from tensor [OK]

Common Mistakes:

• Printing tensor directly without decoding
• Expecting list output instead of individual prints
• Confusing bytes and strings

4. Identify the error in the following code snippet that tries to read image files from paths:

import tensorflow as tf
image_paths = ["img1.jpg", "img2.jpg"]
dataset = tf.data.Dataset.from_tensor_slices(image_paths)
dataset = dataset.map(tf.io.read_file)
for img in dataset:
    print(img.numpy().shape)

medium

A. Cannot print shape of a scalar string tensor

B. tf.io.read_file is not a valid function

C. from_tensor_slices requires a tensor, not list

D. map() cannot be used on datasets

Solution

1. Step 1: Analyze dataset after map

   After mapping tf.io.read_file, each element is a scalar string tensor containing raw file bytes.

2. Step 2: Understand tensor shape

   img.numpy() returns Python bytes (raw file content), which has no .shape attribute. Printing img.numpy().shape raises AttributeError.

3. Final Answer:

   Cannot print shape of a scalar string tensor -> Option A

4. Quick Check:

   img.numpy() is bytes; no .shape [OK]

Hint: Raw file bytes are scalars; no shape attribute [OK]

Common Mistakes:

• Assuming read_file returns image tensor
• Thinking from_tensor_slices rejects lists
• Believing map() is invalid on datasets

5. You want to create a TensorFlow dataset from a folder of images, resize each image to 128x128, and batch them in groups of 16. Which code snippet correctly achieves this?

hard

A. dataset = tf.keras.utils.image_dataset_from_directory('images', image_size=(128,128), batch_size=16)

B. dataset = tf.data.Dataset.list_files('images/*').map(lambda x: tf.image.resize(tf.io.decode_image(tf.io.read_file(x)), (128,128))).batch(16)

C. dataset = tf.data.Dataset.from_tensor_slices('images').map(tf.io.read_file).batch(16)

D. dataset = tf.keras.preprocessing.image_dataset_from_directory('images', batch_size=128, image_size=(16,16))

Solution

1. Step 1: Understand dataset creation from folder

   dataset = tf.data.Dataset.list_files('images/*').map(lambda x: tf.image.resize(tf.io.decode_image(tf.io.read_file(x)), (128,128))).batch(16) uses list_files to get file paths, then maps reading, decoding, and resizing images correctly.

2. Step 2: Check batch and resize parameters

   Images are resized to (128,128) and batched in groups of 16 as required.

3. Final Answer:

   dataset = tf.data.Dataset.list_files('images/*').map(lambda x: tf.image.resize(tf.io.decode_image(tf.io.read_file(x)), (128,128))).batch(16) -> Option B

4. Quick Check:

   list_files + map + resize + batch = correct pipeline [OK]

Hint: Use list_files + map with decode and resize, then batch [OK]

Common Mistakes:

• Using wrong batch size or image size parameters
• Confusing keras and tf.data APIs
• Not decoding images before resizing