Data transformation (TF Transform) in TensorFlow - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is TF Transform in TensorFlow?

TF Transform is a library for preprocessing data with TensorFlow. It helps apply the same transformations to training and serving data, ensuring consistency.

beginner

Why do we use TF Transform instead of preprocessing data manually?

Because TF Transform lets you define transformations once and apply them both during training and when the model is used, avoiding mistakes and keeping data consistent.

intermediate

What is a 'preprocessing_fn' in TF Transform?

It is a function you write to describe how to transform raw input features into processed features, like scaling numbers or encoding categories.

intermediate

How does TF Transform handle scaling numeric features?

TF Transform computes statistics like mean and variance on the training data and uses them to scale features consistently during training and serving.

intermediate

What is the role of the 'tft.analyze_and_transform_dataset' function?

It analyzes the dataset to compute statistics and applies the transformations defined in 'preprocessing_fn' to produce transformed training data.

What does TF Transform ensure when preprocessing data?

A Only transforms data during serving

B Faster model training only

C Automatically tunes model hyperparameters

D Consistent transformations during training and serving

TF Transform ensures the same data transformations are applied both during training and when the model is used for predictions.

Which function in TF Transform applies transformations and computes statistics?

A tf.data.Dataset.map

B tft.analyze_and_transform_dataset

C tf.keras.Model.fit

D tf.transform.apply_transform

tft.analyze_and_transform_dataset computes dataset statistics and applies the preprocessing function transformations.

What is the purpose of the 'preprocessing_fn' in TF Transform?

A To define how to transform raw features

B To train the model

C To evaluate model accuracy

D To save the trained model

The preprocessing_fn defines the transformations applied to raw input features.

How does TF Transform handle categorical features?

A By ignoring them

B By converting them to random numbers

C By encoding them consistently using vocabulary computed from training data

D By scaling them like numeric features

TF Transform builds vocabularies from training data to encode categorical features consistently.

Why is it important to use TF Transform for data preprocessing?

A To avoid data mismatch between training and serving

B To speed up GPU computations

C To reduce model size

D To automatically generate labels

Using TF Transform avoids differences in data processing between training and serving, which can cause errors.

Explain how TF Transform helps keep data preprocessing consistent between training and serving.

Think about why applying the same steps to data in both phases matters.

Describe the steps to use TF Transform to scale a numeric feature.

Focus on how TF Transform computes and applies scaling.

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