Hard Difficulty Questions

Conduct additional testing to measure the disparity

Why wrong: Testing identifies the issue but does not fix it.

Replace the object detection algorithm with a different one

Why wrong: Algorithm change may not address data imbalance.

Adjust the model's decision threshold for pedestrian detection

Why wrong: Threshold adjustment changes sensitivity but does not improve feature learning.

Reduce the majority class size

Why wrong: Undersampling may discard valuable data and reduce overall performance.

Use SMOTE to generate synthetic samples

Why wrong: SMOTE is a valid approach but may create noisy or unrealistic samples; cost-sensitive learning is a simpler first step.

Collect more data for the minority class

Why wrong: Although beneficial, collecting additional data is often not the most immediate or feasible option.

Maintain a manual rollback script that the operations team can run

Why wrong: Manual processes are not automated and can be slow.

Deploy new models as canary releases and monitor for 24 hours

Why wrong: Canary is gradual but rollback may not be fully automated.

Automatically keep the previous model version in storage for later use

Why wrong: Storage alone doesn't handle traffic switching.

F1 score

Why wrong: F1 is useful but the question asks for two; precision and recall are more direct.

Area under the ROC curve (AUC-ROC)

Why wrong: AUC-ROC is less informative for imbalanced datasets; precision-recall is preferred.

Accuracy

Why wrong: Accuracy is high even if the model predicts all non-fraud, so it's misleading.

Vanishing gradients

Why wrong: Vanishing gradients would cause slow decrease in loss.

Underfitting

Why wrong: Underfitting would have high training loss as well.

Data leakage

Why wrong: Data leakage would cause abnormally high accuracy.

Retrain the model every hour to incorporate new interactions quickly

Why wrong: Frequent retraining is computationally expensive and still requires sufficient interactions for new items.

Remove the new products from the recommendation pool until they accumulate enough interactions

Why wrong: Removing new products defeats the purpose of promoting them during the sale.

Increase the number of latent factors in the matrix factorization model

Why wrong: More latent factors may improve representation but do not solve the cold-start problem for new items with few interactions.

Increase the learning rate

Why wrong: Increasing the learning rate may cause the loss to oscillate or diverge.

Increase the number of epochs

Why wrong: More epochs would likely increase overfitting further.

Add more convolutional layers

Why wrong: Adding more layers increases complexity and would likely worsen overfitting.

Batch normalization is disabled

Why wrong: Disabling batch normalization may slow training but would not cause constant loss.

The dataset is imbalanced

Why wrong: Imbalanced data would cause the model to predict the majority class, not constant loss at 2.3026.

The model is overfitting

Why wrong: Overfitting would show decreasing training loss and increasing validation loss, not constant values.

Minimize data collection by not logging any user interactions.

Why wrong: While minimizing data is good, it prevents auditing and debugging; also, DSARs require proving data was not processed if not retained.

Anonymize all user data before logging interactions.

Why wrong: Anonymization may prevent re-identification, but DSARs require access to personal data; anonymized data is not personal data, but the organization must still be able to identify the user's data before anonymization.

Encrypt all chat logs and store them indefinitely for audit purposes.

Why wrong: Indefinite storage violates the storage limitation principle; encryption does not exempt from deletion requests.

Use larger convolutional filters (e.g., 7x7 instead of 3x3) to capture more context.

Why wrong: Larger filters increase computation and slow down inference.

Increase the number of convolutional layers to improve feature extraction.

Why wrong: More layers increase computational cost and latency.

Replace the convolutional layers with transformer layers to improve attention.

Why wrong: Changing architecture typically requires full retraining and may not address low-light specifically.

Use adversarial training to add imperceptible perturbations to training images.

Why wrong: Adversarial training improves resistance to malicious perturbations but not necessarily to natural low-light conditions.

Increase the model's depth by adding more convolutional layers.

Why wrong: Increasing depth changes architecture and requires retraining; it may not directly address low-light performance.

Increase the collision penalty to a very large negative value.

Why wrong: Collision penalty may still allow aggressive driving that avoids collisions but causes near-misses.

Remove the time-based reward and only reward reaching the destination.

Why wrong: Removing time incentive may make the agent very slow but not necessarily safe.

Use a potential-based reward shaping to encourage progress toward destination.

Why wrong: Reward shaping may help but does not specifically address aggressive driving.

Boosting

Why wrong: Boosting combines weak learners and may overfit if not carefully tuned.

Increasing the learning rate

Why wrong: Learning rate affects convergence, not overfitting directly.

Increasing the number of hidden layers

Why wrong: More layers increase model complexity, potentially worsening overfitting.

Review the fairness check settings to ensure protected attributes are still relevant.

Why wrong: Fairness is separate; drift detection triggered due to feature drift, not fairness.

Immediately retrain the model on recent data to adapt to the drift.

Why wrong: Retraining without analyzing the nature of drift may lead to suboptimal model.

Reduce the classification threshold to 0.5 to increase sensitivity.

Why wrong: Threshold change does not address feature drift.

Basing acceptance solely on training accuracy

Why wrong: Training accuracy does not reflect real-world performance.

Maximizing model complexity to achieve the best accuracy

Why wrong: Complexity can lead to maintenance issues and overfitting.

Hyperparameter tuning

Why wrong: Hyperparameter tuning is performed during model development, not continuously in production.

Feature importance analysis

Why wrong: Feature importance is used for interpretability, not directly for maintaining performance.

Use a simpler model to reduce variability

Why wrong: A simpler model may underfit and not solve the drift issue.

Increase the frequency of model retraining

Why wrong: More frequent retraining increases costs and may still be triggered by noise.

Reduce the batch size for inference

Why wrong: Batch size does not affect retraining triggers.

Copy all transaction data to a cloud database for the model to access.

Why wrong: Data copying introduces latency, synchronization issues, and potential data integrity risks.

Rewrite the mainframe system in Java to directly call the model.

Why wrong: Rewriting the mainframe is costly, risky, and causes significant disruption.

Install a GPU on the mainframe to run the model natively.

Why wrong: Mainframes are not designed for GPU workloads and this would be very complex and expensive.

Adding random noise

Why wrong: Noise may degrade quality but typically does not change the object class.

Random rotation

Why wrong: Rotation usually preserves the object's identity unless it's orientation-sensitive (e.g., digits).

Horizontal flip

Why wrong: Horizontal flip is symmetric for many objects and preserves label.

Broadcast the TF-IDF model to all executors to avoid shuffling

Why wrong: Broadcasting is for small data; clinical notes are large, causing driver OOM.

Add 10 more nodes to the cluster to increase total memory

Why wrong: Adding nodes increases resources but may not fix skewed partitions and is costly.

Use a single executor with 64 GB and increase driver memory to 128 GB

Why wrong: Single executor limits parallelism and still risks OOM on large data.