Bird
Raised Fist0

Implement Feature Scaling - Standardization, Min-Max, Robust

CODINGbeginnerInterview freq: high
Choose your preparation mode6 modes available
LearnTraceDebugTrade-offChallenge
🎯
Implement Feature Scaling Techniques
30 min · junior
junior

You are tasked with implementing feature scaling techniques for a dataset used in a real-time recommendation system. The dataset is large, with millions of rows and hundreds of features. The system must handle edge cases like missing values and outliers efficiently. The implementation should be optimized for both speed and memory usage.

Given Info
  • The dataset contains numerical features only.
  • The system must handle missing values gracefully.
  • Outliers are present in the data.
  • The implementation should be efficient for large datasets.
  • The solution must be implemented using NumPy only.
📋
Guided Steps
1/4
Step 1
Handling Missing Values
How will you handle missing values in the dataset before applying scaling?
💡 Hint
Consider the impact of missing values on scaling calculations.
Key Decision
Impute missing values because scaling requires complete data.
Interviewer Expectation
Mid: Proposes simple imputation like mean or median. Senior: Considers the impact of imputation on data distribution and scaling results.
⚠️Common Wrong Answer
Ignoring missing values, leading to incorrect scaling results.
Step 2
Choosing the Right Scaling Technique
Which scaling technique will you choose for this dataset and why?
💡 Hint
Think about the presence of outliers and the distribution of data.
Key Decision
Use Robust Scaling because it is less sensitive to outliers.
Interviewer Expectation
Mid: Chooses Min-Max or Standardization. Senior: Justifies Robust Scaling due to outliers and explains its benefits over other methods.
⚠️Common Wrong Answer
Choosing Min-Max scaling without considering outliers, leading to skewed results.
Step 3
Implementing the Scaling Algorithm
How will you implement the chosen scaling technique using NumPy?
💡 Hint
Focus on vectorized operations to handle large datasets efficiently.
Key Decision
Implement vectorized operations because they are faster and more memory-efficient.
Interviewer Expectation
Mid: Implements basic scaling using loops. Senior: Uses NumPy vectorized operations for efficiency.
⚠️Common Wrong Answer
Using Python loops, resulting in slow performance on large datasets.
Step 4
Testing and Validation
How will you test your implementation to ensure it handles edge cases?
💡 Hint
Consider edge cases like single-element arrays and all-same-class features.
Key Decision
Create test cases for edge cases because they ensure robustness.
Interviewer Expectation
Mid: Tests on typical datasets. Senior: Includes edge cases and explains their importance.
⚠️Common Wrong Answer
Neglecting edge cases, leading to potential failures in production.
📊
Scoring Rubric
▼ Show
Must Have - 60%
  • Handles missing values appropriately before scaling.
  • Chooses a scaling technique suitable for the dataset characteristics.
  • Implements scaling using NumPy vectorized operations.
  • Includes test cases for edge cases like missing values and outliers.
Good to Have - 30%
  • Explains the choice of scaling technique in the context of data distribution.
  • Considers the impact of imputation on scaling results.
  • Optimizes for both speed and memory usage.
  • Provides a clear explanation of the implementation steps.
Bonus - 10%
  • Discusses the trade-offs between different scaling techniques.
  • Considers the impact of scaling on downstream ML models.
  • Implements additional checks for numerical stability.
✅
Model Answer
▼ Reveal

The ideal solution involves handling missing values through imputation, choosing Robust Scaling due to the presence of outliers, and implementing the scaling using NumPy vectorized operations. The solution should include comprehensive testing, especially for edge cases.

Key Decisions
  • Impute missing values to ensure complete data for scaling.
  • Choose Robust Scaling to mitigate the impact of outliers.
  • Implement scaling using NumPy vectorized operations for efficiency.
  • Test thoroughly, including edge cases, to ensure robustness.
Anti-patterns
Ignoring missing values, leading to incorrect scaling results.
Using Python loops, resulting in slow performance.
Neglecting edge cases, leading to potential failures in production.

Practice

(1/5)
1. 
import numpy as np
from sklearn.metrics import confusion_matrix

y_true = [0, 1, 0, 1, 0, 1, 1]
y_pred = [0, 0, 0, 1, 1, 1, 1]

cm = confusion_matrix(y_true, y_pred)
print(cm)
What does the code output?
easy
A. [[2, 1], [1, 3]]
B. [[3, 1], [1, 2]]
C. [[2, 2], [1, 2]]
D. [[3, 0], [2, 2]]

Solution

  1. Step 1: Understand confusion matrix structure

    The confusion matrix is structured as [[TN, FP], [FN, TP]].

  2. Step 2: Calculate values

    TN=2 (true negatives), FP=1 (false positives), FN=1 (false negatives), TP=3 (true positives).

  3. Final Answer:

    Option A -> Option A

  4. Quick Check:

    Confusion matrix is [[TN, FP], [FN, TP]]. [OK]
Hint: Confusion matrix is [[TN, FP], [FN, TP]]. [OK]
Common Mistakes:
2. What does the following Python code output when applied to an image array img? 
import numpy as np

def flip_image(img):
    return np.flip(img, axis=1)

img = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
flipped_img = flip_image(img)
print(flipped_img)
easy
A. [[3, 2, 1], [6, 5, 4], [9, 8, 7]]
B. [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
C. [[7, 8, 9], [4, 5, 6], [1, 2, 3]]
D. [[9, 8, 7], [6, 5, 4], [3, 2, 1]]

Solution

  1. Step 1: Understand the flip operation

    The np.flip function flips the array along the specified axis. Here, axis=1 means flipping horizontally.

  2. Step 2: Apply the flip to the array

    Flipping horizontally changes the order of elements in each row.

  3. Final Answer:

    Option A -> Option A

  4. Quick Check:

    Horizontal flip reverses row elements. [OK]
Hint: Horizontal flip reverses row elements. [OK]
Common Mistakes:
3. What is the time complexity of updating the learning rate using PyTorch's StepLR scheduler for each epoch?
easy
A. O(n^2)
B. O(n)
C. O(1)
D. O(log n)

Solution

  1. Step 1: Analyze StepLR update mechanism

    StepLR updates the learning rate by multiplying it with a constant factor, which is a constant time operation.

  2. Step 2: Determine time complexity

    Since the update is a simple multiplication, the time complexity is O(1).

  3. Final Answer:

    Option C -> Option C

  4. Quick Check:

    StepLR update is a constant time operation. [OK]
Hint: StepLR update is a constant time operation. [OK]
Common Mistakes:
4. What is the time complexity of the following non-max suppression implementation? 
def non_max_suppression(boxes, scores, iou_threshold):
    indices = np.argsort(scores)[::-1]
    keep = []
    while len(indices) > 0:
        current = indices[0]
        keep.append(current)
        indices = indices[1:]
        indices = [i for i in indices if iou(boxes[current], boxes[i]) < iou_threshold]
    return keep
easy
A. O(n^3)
B. O(n^2)
C. O(n)
D. O(n log n)

Solution

  1. Step 1: Analyze the loop structure

    The outer loop runs n times, and the inner loop (IoU calculation) also runs n times in the worst case.

  2. Step 2: Determine complexity

    Each IoU calculation is O(1), making the overall complexity O(n^2).

  3. Final Answer:

    Option B -> Option B

  4. Quick Check:

    Nested loops suggest O(n^2) [OK]
Hint: Nested loops suggest O(n^2) [OK]
Common Mistakes:
5. What is the time complexity of a single update step in Mini-Batch SGD with Momentum for a model with n parameters?
easy
A. O(n)
B. O(n log n)
C. O(n^2)
D. O(1)

Solution

  1. Step 1: Identify operations involved

    Each update step involves computing the gradient and updating the velocity and parameters, all of which are linear operations with respect to the number of parameters.

  2. Step 2: Determine the complexity

    Since each operation is linear, the overall complexity is O(n).

  3. Final Answer:

    Option A -> Option A

  4. Quick Check:

    Each parameter update is linear in complexity [OK]
Hint: Each parameter update is linear in complexity [OK]
Common Mistakes:
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard