Data transformation (TF Transform) in TensorFlow - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of TF Transform scaling function

What is the output of the following TF Transform preprocessing function when applied to input feature value 10?

TensorFlow

import tensorflow_transform as tft
import tensorflow as tf

def preprocessing_fn(inputs):
    x = inputs['feature']
    x_scaled = tft.scale_to_0_1(x)
    return {'x_scaled': x_scaled}

# Simulate input
inputs = {'feature': tf.constant([10.0, 20.0, 30.0])}

# Apply preprocessing_fn with TF Transform
# Assume the dataset has min=10 and max=30 for 'feature'

A [1.0, 0.5, 0.0]

B [0.0, 0.5, 1.0]

C [10.0, 20.0, 30.0]

D [0.33, 0.66, 1.0]

💡 Hint

tft.scale_to_0_1 scales values linearly between min and max to the range 0 to 1.

The function tft.scale_to_0_1 scales the input feature so that the minimum value maps to 0 and the maximum maps to 1. Given min=10 and max=30, 10 maps to 0, 20 maps to 0.5, and 30 maps to 1.

❓ Model Choice

intermediate

Choosing the right TF Transform function for categorical data

You have a categorical feature with many unique string values. Which TF Transform function is best to convert this feature into a numeric representation suitable for a machine learning model?

A tft.compute_and_apply_vocabulary

B tft.bucketize

C tft.scale_to_0_1

D tft.z_score

💡 Hint

Think about converting strings to integer indices.

tft.compute_and_apply_vocabulary creates a vocabulary of unique strings and maps each string to an integer index, which is suitable for categorical string features.

❓ Hyperparameter

advanced

Choosing bucket boundaries in TF Transform bucketize

You want to bucketize a continuous feature into 3 buckets using TF Transform. Which set of bucket boundaries will create 3 buckets?

A [0.0, 1.0]

B [0.0, 1.0, 2.0]

C [1.0, 2.0]

D [1.0]

💡 Hint

Number of buckets = number of boundaries + 1.

TF Transform bucketize creates buckets based on boundaries. If you want 3 buckets, you need 2 boundaries.

🔧 Debug

advanced

Debugging TF Transform preprocessing function error

Given this preprocessing function, what error will occur when running TF Transform? import tensorflow_transform as tft def preprocessing_fn(inputs): x = inputs['feature'] x_norm = (x - tft.mean(x)) / tft.stddev(x) return {'x_norm': x_norm} Assume 'feature' is a float tensor.

A TypeError: unsupported operand type(s) for -: 'Tensor' and 'float'

B ValueError: tft.mean and tft.stddev must be called on tensors with known shape

C ZeroDivisionError: division by zero

D No error, function runs correctly

💡 Hint

tft.mean and tft.stddev compute statistics over the dataset during analysis phase.

tft.mean and tft.stddev are designed to compute dataset-wide statistics and can be used safely in preprocessing_fn without errors.

🧠 Conceptual

expert

Why use TF Transform for data preprocessing?

Which of the following is the main advantage of using TF Transform for preprocessing data in a TensorFlow ML pipeline?

A It enables consistent preprocessing at both training and serving by computing statistics on the full dataset.

B It allows preprocessing to be done only at training time, saving resources during serving.

C It automatically tunes hyperparameters during preprocessing.

D It replaces the need for feature engineering by generating new features automatically.

💡 Hint

Think about consistency between training and serving data transformations.

TF Transform computes dataset-wide statistics during analysis and applies the same transformations at serving, ensuring consistency.

Practice

1. What is the main purpose of TF Transform in machine learning pipelines?

easy

A. To visualize the dataset statistics

B. To train the machine learning model faster

C. To apply consistent data transformations during both training and serving

D. To generate synthetic data samples

Solution

1. Step 1: Understand TF Transform's role

   TF Transform is designed to apply the same data transformations consistently during training and serving.

2. Step 2: Compare options

   Options A, B, and D describe other tasks unrelated to TF Transform's main purpose.

3. Final Answer:

   To apply consistent data transformations during both training and serving -> Option C

4. Quick Check:

   Consistent transformations = To apply consistent data transformations during both training and serving [OK]

Hint: TF Transform ensures same data changes in training and serving [OK]

Common Mistakes:

• Confusing TF Transform with model training
• Thinking TF Transform generates data
• Assuming it visualizes data statistics

2. Which of the following is the correct way to define a TF Transform preprocessing function that scales a numeric feature named age by its mean and variance?

easy

A. def preprocessing_fn(inputs):
age = tft.scale_to_z_score(inputs['age'])
return {'age_scaled': age}

B. def preprocessing_fn(inputs):
return {'age_scaled': inputs['age'] / 100}

C. def preprocessing_fn(inputs):
return {'age_scaled': inputs['age'] + 10}

D. def preprocessing_fn(inputs):
age = inputs['age'] * 2
return {'age_scaled': age}

Solution

1. Step 1: Identify correct TF Transform scaling function

   TF Transform provides tft.scale_to_z_score to scale features by mean and variance.

2. Step 2: Check code correctness

   def preprocessing_fn(inputs): age = tft.scale_to_z_score(inputs['age']) return {'age_scaled': age} uses tft.scale_to_z_score correctly; others use incorrect or arbitrary scaling.

3. Final Answer:

   def preprocessing_fn(inputs): age = tft.scale_to_z_score(inputs['age']) return {'age_scaled': age} -> Option A

4. Quick Check:

   Use tft.scale_to_z_score for mean-variance scaling [OK]

Hint: Use tft.scale_to_z_score for standard scaling [OK]

Common Mistakes:

• Using simple division instead of TF Transform scaling
• Adding arbitrary constants instead of scaling
• Multiplying without normalization

3. Given the following TF Transform preprocessing function, what will be the output for input {'income': 50000} if the dataset mean income is 40000 and stddev is 10000?

def preprocessing_fn(inputs):
    income_scaled = tft.scale_to_z_score(inputs['income'])
    return {'income_scaled': income_scaled}

medium

A. {'income_scaled': 0.0}

B. {'income_scaled': 0.5}

C. {'income_scaled': -1.0}

D. {'income_scaled': 1.0}

Solution

1. Step 1: Calculate z-score for income

   Z-score = (value - mean) / stddev = (50000 - 40000) / 10000 = 1.0

2. Step 2: Match output format

   The function returns {'income_scaled': z-score}, so output is {'income_scaled': 1.0}

3. Final Answer:

   {'income_scaled': 1.0} -> Option D

4. Quick Check:

   Z-score calculation = 1.0 [OK]

Hint: Z-score = (value - mean) / stddev for scaling [OK]

Common Mistakes:

• Forgetting to subtract mean
• Dividing by mean instead of stddev
• Mixing up positive and negative signs

4. You wrote this TF Transform preprocessing function but get an error during analysis:

def preprocessing_fn(inputs):
    age_bucketized = tft.bucketize(inputs['age'], num_buckets=5)
    return {'age_bucketized': age_bucketized}

What is the likely cause of the error?

medium

A. The input 'age' is not a numeric tensor

B. The function tft.bucketize requires 'boundaries' instead of 'num_buckets'

C. Missing import statement for tensorflow_transform as tft

D. The return value must be a list, not a dictionary

Solution

1. Step 1: Check tft.bucketize function signature

   tft.bucketize requires 'boundaries' argument, not 'num_buckets'.

2. Step 2: Identify error cause

   Using 'num_buckets' causes an error because it's not a valid parameter.

3. Final Answer:

   The function tft.bucketize requires 'boundaries' instead of 'num_buckets' -> Option B

4. Quick Check:

   tft.bucketize needs boundaries, not num_buckets [OK]

Hint: Use boundaries list for tft.bucketize, not num_buckets [OK]

Common Mistakes:

• Passing num_buckets instead of boundaries
• Forgetting to import tensorflow_transform
• Returning wrong data type

5. You want to apply TF Transform to prepare a dataset with numeric feature height and categorical feature color. You want to scale height and one-hot encode color. Which preprocessing function correctly applies these transformations?

hard

A. def preprocessing_fn(inputs):
height_scaled = tft.scale_to_z_score(inputs['height'])
color_vocab = tft.compute_and_apply_vocabulary(inputs['color'])
color_one_hot = tf.one_hot(color_vocab, depth=3)
return {'height_scaled': height_scaled, 'color_one_hot': color_one_hot}

B. def preprocessing_fn(inputs):
height_scaled = tft.scale_to_z_score(inputs['height'])
color_one_hot = tft.compute_and_apply_vocabulary(inputs['color'])
return {'height_scaled': height_scaled, 'color_one_hot': color_one_hot}

C. def preprocessing_fn(inputs):
height_scaled = inputs['height'] / 100
color_one_hot = tf.one_hot(inputs['color'], depth=3)
return {'height_scaled': height_scaled, 'color_one_hot': color_one_hot}

D. def preprocessing_fn(inputs):
height_scaled = tft.scale_to_z_score(inputs['height'])
color_one_hot = tf.one_hot(inputs['color'], depth=3)
return {'height_scaled': height_scaled, 'color_one_hot': color_one_hot}

Solution

1. Step 1: Scale numeric feature 'height'

   Use tft.scale_to_z_score to scale 'height' correctly.

2. Step 2: One-hot encode categorical 'color'

   First, map 'color' to integer indices using tft.compute_and_apply_vocabulary, then apply tf.one_hot with correct depth.

3. Step 3: Verify options

   def preprocessing_fn(inputs): height_scaled = tft.scale_to_z_score(inputs['height']) color_vocab = tft.compute_and_apply_vocabulary(inputs['color']) color_one_hot = tf.one_hot(color_vocab, depth=3) return {'height_scaled': height_scaled, 'color_one_hot': color_one_hot} correctly chains vocabulary computation and one-hot encoding; others miss steps or misuse functions.

4. Final Answer:

   def preprocessing_fn(inputs): height_scaled = tft.scale_to_z_score(inputs['height']) color_vocab = tft.compute_and_apply_vocabulary(inputs['color']) color_one_hot = tf.one_hot(color_vocab, depth=3) return {'height_scaled': height_scaled, 'color_one_hot': color_one_hot} -> Option A

5. Quick Check:

   Vocabulary then one-hot encoding = def preprocessing_fn(inputs): height_scaled = tft.scale_to_z_score(inputs['height']) color_vocab = tft.compute_and_apply_vocabulary(inputs['color']) color_one_hot = tf.one_hot(color_vocab, depth=3) return {'height_scaled': height_scaled, 'color_one_hot': color_one_hot} [OK]

Hint: Use vocabulary lookup before one-hot encoding categorical data [OK]

Common Mistakes:

• Applying one-hot directly on strings
• Skipping vocabulary computation
• Scaling numeric features incorrectly