CCNA Data Preparation Ml Questions

Why this answer

How to eliminate wrong answers

Option B is wrong because running a Glue crawler updates the Data Catalog but does not automatically adapt the fixed schema defined in the job script; the job will still fail if the script expects a specific schema. Option C is wrong because storing the schema in a separate S3 file and reading it at runtime still requires manual updates to that file when the schema changes, which does not provide dynamic adaptation. Option D is wrong because manually updating the job script each time the schema changes is error-prone, not scalable, and defeats the purpose of automated ETL processing.

Why this answer

How to eliminate wrong answers

Option A is wrong because BlazingText does not accept one-hot encoded feature vectors in CSV; it requires raw text with inline labels for supervised classification. Option B is wrong because while JSON lines are common in other SageMaker built-in algorithms (e.g., BlazingText for Word2Vec or Text Classification using JSON lines), BlazingText's supervised text classification specifically requires the '__label__' prefix format, not JSON. Option D is wrong because TFRecord files are used by TensorFlow-based algorithms, not by BlazingText, which expects plain text files with the label-prefixed format.

Why this answer

How to eliminate wrong answers

Option B is wrong because standardization (z-score) centers and scales data to have mean 0 and standard deviation 1, but it does not change the shape of the distribution—it only rescales, so right-skewness remains. Option C is wrong because min-max scaling to [0,1] linearly compresses the data into a fixed range, which preserves the relative distances and does not alter skewness or make the distribution Gaussian-like. Option D is wrong because equal-width binning discretizes the continuous 'income' column into fixed intervals, which loses granularity and does not transform the distribution toward Gaussian—it creates a categorical or ordinal feature instead.

Why this answer

How to eliminate wrong answers

Option A is wrong because `from_utc_timestamp` in Spark converts a UTC timestamp to a specified time zone, not to UTC, which would introduce inconsistency. Option B is wrong because AWS Glue's built-in transforms (e.g., `ResolveChoice`) do not provide a dedicated transform to parse timestamps with timezone offsets and normalize them to a single time zone; they only handle schema resolution. Option C is wrong because Python's `datetime.strptime` with `tzlocal` relies on the local system time zone, which is not deterministic in a distributed ETL environment like AWS Glue and can vary across workers, leading to incorrect hour extraction.

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because SageMaker Processing jobs are optimized for ML-specific tasks like training data preprocessing, not for general-purpose ETL on 10 TB of data; they lack native support for complex joins and nested JSON parsing at scale. Option B is wrong because Amazon Athena is a serverless query engine that excels at ad-hoc SQL queries but struggles with complex transformations like parsing deeply nested JSON and joining large reference tables due to its per-query pricing and lack of native procedural logic. Option D is wrong because AWS Glue ETL with PySpark is a valid alternative for ETL, but it is less performant and more expensive than EMR for large-scale (10 TB) data processing due to its auto-scaling overhead and limited tuning capabilities; EMR provides finer control over cluster configuration and cost optimization for batch jobs.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon Athena federated query is designed for querying across data sources, but it does not integrate directly as a join step within Data Wrangler; you would need to export the result to S3 and re-import, adding latency and complexity. Option B is wrong because exporting the Redshift table to S3 as Parquet introduces an extra data movement step that is inefficient for large volumes, and Data Wrangler can directly import from Redshift without this intermediate export. Option C is wrong because using AWS Glue to join the datasets and output to S3 adds an unnecessary orchestration layer and data duplication, whereas Data Wrangler can perform the join natively without external services.

Why this answer

How to eliminate wrong answers

Option B is wrong because Parquet is a columnar storage format optimized for analytical queries and selective column reads, not for sequential row-by-row training loops typical in deep learning; Apache Arrow adds overhead without solving the small-file problem. Option C is wrong because compressing CSV files reduces storage size but increases CPU load during decompression, often worsening I/O bottlenecks due to the many small files still requiring individual decompression. Option D is wrong because increasing vCPUs does not fix the fundamental I/O bottleneck caused by many small files; it may even exacerbate contention on shared storage without addressing the file access pattern.

Why this answer

How to eliminate wrong answers

Option B is wrong because Amazon Athena CTAS statements cannot read directly from Amazon RDS; Athena only queries data already in S3 or other data sources via federated queries, but CTAS itself requires the source to be in S3 or a cataloged table, not a live RDS database. Option C is wrong because SageMaker Data Wrangler is designed for interactive data preparation and feature engineering within SageMaker Studio, not for running serverless ETL jobs at scale; it can import data from RDS but lacks the native ability to schedule or run large-scale batch transformations and write to S3 as Parquet without additional infrastructure. Option D is wrong because while Amazon EMR with Spark can technically perform this task, it requires provisioning and managing a cluster, which adds operational overhead; AWS Glue is more suitable as a serverless, cost-effective alternative for this specific ETL workload without the need to manage EC2 instances or cluster lifecycle.

Why this answer

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option B is wrong because SageMaker built-in first-party algorithms (e.g., XGBoost, Linear Learner) are designed for model training, not for feature engineering or data transformation tasks like datetime parsing. Option C is wrong because AWS Glue is an ETL service that introduces additional overhead (e.g., Spark cluster startup, schema inference) and is less efficient for a simple in-memory pandas operation within a SageMaker processing job. Option D is wrong because using SQL in Athena on S3 data requires querying the raw data from S3, which incurs scan costs and latency, and Athena's SQL functions for datetime extraction (e.g., `EXTRACT`) are less flexible and slower than pandas for this specific transformation.

Why this answer

How to eliminate wrong answers

Option B is wrong because writing intermediate results to local ephemeral storage does not solve the out-of-memory issue; the script still loads the entire dataset into memory before chunking, and local storage is limited and not designed for large-scale intermediate data. Option C is wrong because increasing to a larger instance like ml.p3dn.24xlarge (which has 192 GB memory vs. ml.r5.24xlarge's 768 GB) actually reduces memory, and GPU instances are not optimized for memory-intensive preprocessing; this approach is neither cost-effective nor scalable. Option D is wrong because reducing to a single instance and increasing volume size for swap space relies on disk-based swapping, which is orders of magnitude slower than RAM and will cause severe performance degradation or job failure due to I/O bottlenecks.

Why this answer

How to eliminate wrong answers

Option B is wrong because if the container entrypoint were missing the full path to the script, the job would fail immediately with a 'No such file or directory' error, not a timeout error. Option C is wrong because `S3CompressionType` set to 'None' means the input files are not compressed; if the files were actually compressed, the job would fail with a decompression error, not a timeout. Option D is wrong because if the IAM role lacked write permission to the output bucket, the job would fail with an access denied error during the output write phase, not a timeout error.

Why this answer

How to eliminate wrong answers

Option A is wrong because converting to JSON format would increase storage costs and degrade query performance compared to Parquet, as JSON is a verbose, row-based format with no built-in compression or columnar optimization. Option C is wrong because Apache Hive format is not a specific file format; Hive is a query engine that can read various formats, and the question asks for a format conversion, not a query engine. Option D is wrong because writing as CSV with Snappy compression still results in a row-based format that lacks the columnar storage benefits of Parquet, such as predicate pushdown and efficient compression, and Snappy compression on CSV does not match Parquet's storage efficiency.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because the script location being incorrect would cause the job to fail on the first run, not only on subsequent runs. Option B is wrong because MaxRetries controls the number of retry attempts after a job failure, but the job is not failing—it runs successfully but skips new data, so retries are irrelevant. Option D is wrong because the WorkerType (Standard, G.1X, G.2X) affects memory and compute resources, not the ability to perform incremental processing; job bookmarks control incremental processing, not the worker type.

Why this answer

How to eliminate wrong answers

Option A is wrong because increasing DPU count and reducing checkpoint interval on a Glue streaming ETL job exacerbates checkpoint errors and latency due to Spark's micro-batch overhead and lack of native long-lived state management for sliding windows. Option C is wrong because AWS Lambda functions have a maximum execution timeout of 15 minutes and no built-in state management, making them unsuitable for maintaining 7-day sliding window aggregations across 500 records/sec without external state stores that introduce eventual consistency and latency. Option D is wrong because using hourly SageMaker Processing jobs on S3 data from Kinesis Firehose introduces a minimum 1-hour delay, which violates the real-time requirement for updating a user embedding model with sliding window features.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because SageMaker Processing jobs are designed for ML-specific tasks like training or inference, not general-purpose ETL; they lack native JDBC connectors for RDS and require custom networking setup, increasing complexity and cost. Option B is wrong because Amazon Athena cannot perform feature engineering like text vectorization; it is an interactive query service for SQL-on-data, not a transformation engine, and cannot write Parquet with custom logic. Option D is wrong because Kinesis Data Analytics is for real-time stream processing, not batch ETL; it would introduce unnecessary latency and cost for a one-time or scheduled training dataset generation, and it cannot directly write Parquet to S3 without additional sinks.

Why this answer

How to eliminate wrong answers

Option B is wrong because imputing with a constant like -1 introduces an artificial value that can shift the feature distribution, create a spurious cluster, and mislead models that interpret -1 as a meaningful numeric relationship rather than a placeholder. Option C is wrong because using a model to predict missing values (e.g., regression or k-NN imputation) can overfit to the observed data and introduce bias, especially when MCAR holds and the missingness is truly random—this added complexity does not improve robustness and may reduce generalizability. Option D is wrong because removing all rows with missing values reduces sample size and discards potentially valuable information, which can degrade model performance and increase variance, even under MCAR.

Why this answer

How to eliminate wrong answers

Option A is wrong because k-fold cross-validation is a resampling technique for model evaluation, not a method for creating a single static split into training, validation, and test sets. Option B is wrong because chronological split orders data by time, which is irrelevant for a categorical target with imbalanced classes and does not guarantee proportional class representation. Option D is wrong because random split does not account for class distribution; with imbalanced data, it can produce subsets with significantly different class proportions, especially for rare classes.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon DynamoDB with TTL is a key-value and document database that can store features but lacks built-in feature management capabilities such as feature versioning, point-in-time consistency across online/offline stores, and a feature registry; TTL only handles data expiration, not the orchestration needed for ML feature reuse. Option B is wrong because AWS Glue Data Catalog is a metadata repository for data assets (tables, schemas) and does not provide a low-latency online serving endpoint or feature-specific storage; it is used for data discovery and ETL, not for serving features in real-time inference. Option D is wrong because Amazon S3 with AWS Lambda for serving introduces high latency due to Lambda cold starts and S3 GET request overhead, making it unsuitable for low-latency real-time recommendations; additionally, it lacks feature store capabilities like consistent feature definitions, offline/online synchronization, and feature reuse across models.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because min-max scaling is sensitive to outliers; extreme values can compress the rest of the data into a narrow range, distorting the feature's distribution. Option B is wrong because log transformation is only applicable to positive data and can handle skewed distributions but does not specifically reduce the impact of outliers in a way that preserves the data's structure for linear regression; it changes the relationship between features. Option D is wrong because standardization (z-score) uses the mean and standard deviation, both of which are heavily influenced by outliers, so it does not reduce their impact and can even amplify their effect on the scaled values.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon S3 Select is a query-in-place service that retrieves subsets of data from objects using SQL expressions, but it cannot convert or write data in a different format like Parquet. Option B is wrong because Amazon EMR requires managing EC2 instances or using managed scaling, which still involves provisioning and managing clusters, not a serverless approach. Option C is wrong because AWS Lambda has a maximum execution time of 15 minutes and limited memory (up to 10 GB), making it impractical for converting large datasets from CSV to Parquet, which often requires more time and resources than Lambda allows.

Why this answer

How to eliminate wrong answers

Option A is wrong because label encoding assigns arbitrary integer values (e.g., 1 to 50) to countries, introducing an ordinal relationship that linear regression would misinterpret as meaningful order. Option B is wrong because target encoding replaces categories with the mean of the target variable, which can cause data leakage and overfitting, and still does not guarantee avoidance of ordinality in the encoded values. Option D is wrong because ordinal encoding explicitly assigns ordered integers, which is identical to label encoding in effect and introduces the same false ordinal assumption.

Why this answer

How to eliminate wrong answers

Option A is wrong because SageMaker Pipelines automates training workflows but does not provide data lineage tracking or experiment reproducibility; S3 versioning alone lacks the governance and cataloging needed for data lineage. Option B is wrong because DynamoDB is a NoSQL database not designed for large-scale dataset storage or versioning, and Athena queries data in place but does not track lineage or versions. Option D is wrong because S3 versioning and AWS Glue Data Catalog track schema changes but do not provide experiment tracking or lineage tied to training jobs, which is essential for reproducing past experiments.

Why this answer

How to eliminate wrong answers

Option A is wrong because Join is used to combine datasets based on a common key, not to compute rolling statistics over a time window. Option B is wrong because while a Custom Python script could technically implement moving averages, Data Wrangler provides a native Window function transformation that is more efficient, easier to maintain, and avoids the overhead of writing and debugging custom code. Option C is wrong because Group by and aggregate collapses rows into summary statistics per group, which loses the individual row-level detail needed for rolling window calculations.

Why this answer

How to eliminate wrong answers

Option A is wrong because lemmatization, while more accurate than stemming, still does not address the core issue: removing stop words and aggressive normalization are fundamentally inappropriate for domain-specific text where rare terms and typos require preservation of original forms or specialized handling. Option C is wrong because while stemming can be aggressive, the primary problem is not the aggressiveness alone but the combination of stemming and stop word removal that strips domain-relevant context; even a less aggressive stemmer would fail if stop words containing domain meaning are removed. Option D is wrong because stop word removal can indeed remove important context words, but this is only part of the issue; the question states the model performs poorly on domain-specific terms, which is primarily caused by stemming distorting those terms, not just by stop word removal.

Why this answer

How to eliminate wrong answers

Option A is wrong because 'Replace missing with constant' imputes a user-specified constant value (e.g., 0 or a fixed number), not the median of the feature. Option B is wrong because 'Custom transform with Python' would require writing custom Python code to compute and apply the median, which is unnecessary when a built-in transformation exists. Option C is wrong because 'Drop missing rows' removes entire rows with missing values, discarding potentially valuable data instead of imputing the missing values.

Why this answer

How to eliminate wrong answers

Option A is wrong because Parquet is a fully supported output format in AWS Glue, including compression and partitioning. Option B is wrong because including the partition key in the input path is standard practice for reading partitioned data; Glue's DynamicFrame can handle partition keys in the path. Option D is wrong because while reserved column names can cause issues, they typically result in a schema mismatch or validation error, not a 'No such file or directory' file system error.

Why this answer

How to eliminate wrong answers

Option B is wrong because randomly shuffling the dataset breaks the temporal order of time series data, causing future transactions to appear in the training set and past transactions in the validation set, which introduces data leakage and invalidates the model's ability to predict in real time. Option C is wrong because generating rolling averages and lag features using a sliding window of all available data includes future values relative to each transaction, which leaks information from the future into the feature set. Option D is wrong because normalizing features using MinMaxScaler on the entire dataset before splitting uses global statistics (min and max) computed from the full dataset, including future data, which leaks information and biases the scaling.

Why this answer

How to eliminate wrong answers

Option A is wrong because `SparkContext.textFile` reads data as plain text lines, which is incompatible with binary Parquet format and would result in corrupted data or require manual parsing, losing all columnar optimization. Option B is wrong because splitting the dataset into many small 1 MB Parquet files increases S3 LIST and GET request overhead, causing task scheduling delays and poor I/O throughput due to excessive file metadata operations. Option C is wrong because converting Parquet to CSV before processing introduces unnecessary serialization/deserialization costs, increases data size (CSV lacks compression and columnar storage), and discards schema and type information, leading to slower read performance.

Why this answer

How to eliminate wrong answers

Option B is wrong because a missing trust relationship between the IAM role and SageMaker would cause the job to fail at the role assumption stage, not during S3 operations; the error would be 'AssumeRole' related, not 'Access Denied' for S3. Option C is wrong because while a bucket policy could deny access, the question states the IAM policy shown in the exhibit is the only policy under consideration, and bucket policies are evaluated separately; if a bucket policy denied access, the error would still be 'Access Denied', but the most likely cause given the exhibit is the missing `s3:ListBucket` permission in the IAM policy. Option D is wrong because S3 buckets in different regions are accessible via cross-region requests; the error 'Access Denied' is an authorization issue, not a regional routing issue, and SageMaker Processing jobs can access buckets in any region as long as permissions are correctly configured.

Why this answer

How to eliminate wrong answers

Option A is wrong because setting k=1 minimizes bias but maximizes variance, leading to overfitting to the nearest neighbor's value and potentially introducing noise; a small k (like 1) is generally not recommended for imputation as it ignores the averaging effect that reduces variance. Option B is wrong because using all 100,000 rows to find neighbors for each missing value is computationally prohibitive (O(n^2) complexity) and inefficient; practical implementations often use a subset (e.g., via a KD-tree or ball tree) or approximate nearest neighbor search to balance speed and accuracy. Option D is wrong because using only the feature with missing values to find neighbors discards information from other features that could help identify similar rows, reducing the accuracy of the imputation; k-NN imputation typically uses all available features (or a selected subset) to compute distances.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because one-hot encoding treats each word as an independent binary feature with no semantic similarity—vectors for 'good' and 'excellent' are orthogonal, losing all contextual meaning. Option B is wrong because bag-of-words with TF-IDF produces sparse, high-dimensional vectors based on word frequency and inverse document frequency, which ignore word order and context, failing to capture semantic relationships. Option C is wrong because a hashing vectorizer uses a hash function to map words to fixed-size indices, which can cause collisions and still produces sparse, frequency-based features without any semantic understanding.

Why this answer

How to eliminate wrong answers

Option A is wrong because increasing NumberOfWorkers to 20 would increase parallelism and potentially speed up execution, but the job is failing due to a timeout, not resource constraints; more workers won't fix a hard timeout limit. Option B is wrong because MaxRetries controls how many times the job is retried after a failure, but retries restart the job from scratch, so they would also hit the same 2-hour timeout on each attempt. Option D is wrong because changing WorkerType to G.2X provides more memory and storage per worker, which could improve performance for memory-intensive tasks, but it does not extend the timeout duration.

Why this answer

How to eliminate wrong answers

Option B is wrong because SageMaker Processing with a TensorFlow script requires writing custom code, which violates the 'without writing custom code' requirement. Option C is wrong because Amazon S3 Select only supports filtering data using SQL queries on CSV or JSON objects; it cannot convert data to Parquet format. Option D is wrong because Amazon EMR with a Spark job requires provisioning and managing a cluster, incurring higher costs and operational overhead compared to the serverless Glue approach.

Why this answer

How to eliminate wrong answers

Option A is wrong because undersampling the majority class reduces the dataset size significantly (from 500,000 rows to ~10,000 rows), discarding valuable information and potentially degrading model performance, and it does not inherently prevent data leakage if done before splitting. Option C is wrong because applying SMOTE on the entire dataset before splitting causes data leakage: synthetic samples generated from the full dataset can incorporate information from the test set, leading to overly optimistic validation metrics. Option D is wrong because randomly oversampling the minority class by duplicating rows before splitting can cause data leakage if duplicates of the same row appear in both training and validation sets, and it does not introduce new variance, leading to overfitting.

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon Comprehend's PII detection is designed for identifying PII entities in text, not for scalable batch masking of structured CSV data; it adds unnecessary cost and latency without providing native masking capabilities, and a custom script would still be required. Option C is wrong because AWS Glue with a custom PySpark UDF introduces the overhead of a distributed Spark cluster for a simple string transformation that does not require distributed computing, making it less scalable and more expensive than a Python shell job for this use case.

Why this answer

Why this answer

How to eliminate wrong answers

Option B (Amazon EMR) is wrong because it requires provisioning and managing clusters, which contradicts the 'serverless' requirement; it is better suited for large-scale big data processing with frameworks like Spark or Hadoop, not simple serverless transformations. Option C (Amazon Athena) is wrong because it is an interactive query service for analyzing data directly in S3 using SQL, not a transformation engine; it cannot convert file formats like CSV to Parquet. Option D (Amazon Redshift) is wrong because it is a data warehouse for analytics and SQL-based querying, not a serverless transformation service; it requires loading data into a cluster and does not natively convert CSV to Parquet in S3.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because running the job in local mode with a larger EBS volume does not distribute the workload; it still uses a single instance, and local mode is typically for testing, not scaling to handle 4x the data within a shorter time. Option B is wrong because increasing VolumeSizeInGB to 100 and using gzip compression only addresses storage and reduces file size, but does not parallelize the processing; gzip compression is not splittable for parallel reads, so it can actually slow down distributed processing. Option D is wrong because using a larger instance type (e.g., ml.r5.4xlarge) provides more CPU and memory but does not scale horizontally; a single instance, even a larger one, would likely still take longer than 1 hour to process 200 GB, as the original 50 GB took 30 minutes on a smaller instance, and scaling vertically has diminishing returns for I/O-bound CSV processing.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because one-hot encoding 1,200 categories and 50,000 products would create 51,200 binary columns, causing extreme sparsity and memory blowup, which undermines the factorization machine's efficiency and can lead to poor generalization. Option B is wrong because dropping the 'category' column discards valuable hierarchical information (e.g., product type) that could improve recommendation quality; factorization machines are designed to handle high-cardinality features, so there is no need to drop it. Option D is wrong because PCA is a linear dimensionality reduction technique for continuous features, not suitable for categorical data; applying PCA to one-hot encoded categories would destroy the interpretability of interactions and is not a standard preprocessing step for factorization machines.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because the error is an access denied on a read operation, not a write operation; s3:PutObject is irrelevant to reading data. Option B is wrong because the policy does specify the bucket ARN without `/*` for the s3:ListBucket permission (as required), but the issue is that the s3:ListBucket permission itself is missing entirely. Option C is wrong because the Glue job role does have some permissions (as shown in the exhibit), but the specific missing permission is s3:ListBucket, not a general lack of permissions.

Why this answer

How to eliminate wrong answers

Option B is wrong because imputing age with the mean is inappropriate when values include '150', '0', and negative numbers, which would skew the mean and introduce bias; also, Standard Scaler should be applied after cleaning and splitting, not during initial prototyping, and DataBrew does not natively support Standard Scaler as a built-in transform. Option C is wrong because replacing age with median still contaminates the dataset with invalid values (e.g., negative numbers) and DataBrew does not support SMOTE (Synthetic Minority Oversampling Technique) as a built-in transform; SMOTE is typically applied in SageMaker or custom scripts. Option D is wrong because dropping the diagnosis_code column removes potentially predictive information without attempting to standardize it, and Random Undersampling would discard 20% of the majority class, which may lead to loss of valuable data and is less preferred than oversampling for a 60/40 imbalance.

Why this answer

How to eliminate wrong answers

Option A is wrong because S3 Select operates on a single object at a time and cannot filter across multiple objects or partitions; applying it to 2 billion records would require iterating over all objects, negating cost savings. Option C is wrong because listing all objects in the bucket and reading only those with desired prefixes still requires enumerating the entire bucket, which incurs significant API costs and does not minimize data scanned (the script must still list all objects). Option D is wrong because SageMaker Processing with Input Mode 'File' downloads the entire dataset to the training instance; specifying a prefix for the last 6 months would still download all files under that prefix, but the data is partitioned by year and month, so using the prefix alone does not guarantee partition pruning—the team would need to explicitly list only the relevant prefixes, which is inefficient compared to Glue+Athena.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because converting to CSV does not address the I/O bottleneck; File mode still downloads the entire dataset to the training instance's local storage before training begins, causing high latency. Option B is wrong because gzip compression reduces file size but File mode with local caching still requires a full download to disk, and decompression adds CPU overhead without eliminating the I/O bottleneck. Option D is wrong because splitting data into smaller files and using multiple instances parallelizes computation but does not reduce per-instance I/O latency; each instance still uses File mode by default, so the bottleneck persists.

Why this answer

How to eliminate wrong answers

Option A is wrong because 'Encode categorical' transform is used to convert categorical variables into numerical representations (e.g., one-hot encoding), not to parse date strings. Option B is wrong because 'Scale values' transform normalizes or standardizes numerical features (e.g., min-max scaling, z-score), which is irrelevant for extracting date components. Option D is wrong because 'Handle missing' transform addresses null or missing values through imputation or deletion, not date parsing.

Why this answer

How to eliminate wrong answers

Option A is wrong because hash encoding can cause collisions (different categories mapping to the same hash value), which degrades model performance, and using Apache Spark on Amazon EMR adds unnecessary complexity and cost for a task that SageMaker Data Wrangler handles natively. Option B is wrong because one-hot encoding with over 1000 unique values creates over 1000 sparse binary columns, leading to the curse of dimensionality, memory issues, and poor performance in random forests. Option C is wrong because label encoding assigns arbitrary integer values (e.g., 1, 2, 3) that imply ordinal relationships, which random forests can misinterpret as meaningful order, introducing bias and reducing model accuracy.

Why this answer

How to eliminate wrong answers

Option A is wrong because AWS Glue Transform's FillMissingValues transform does not support a 'median' strategy; it only supports filling with a static value or the mean, not the median. Option B is wrong because a custom Python script with pandas runs on a single machine, which cannot scale to handle large datasets efficiently and requires manual upload to S3, introducing unnecessary latency and complexity. Option D is wrong because Amazon Athena SQL does not have a built-in function to compute the median; while you could use percentile_approx, Athena is primarily an interactive query service and not designed for efficient in-place data transformation or writing back to S3 at scale.

Why this answer

How to eliminate wrong answers

Option A is wrong because filling with the median is a univariate imputation method that ignores correlations with other features, potentially introducing bias when missingness is not completely at random (MCAR). Option B is wrong because dropping 15% of records reduces sample size and can introduce selection bias, especially if missingness is related to churn behavior. Option D is wrong because replacing with the mean is sensitive to outliers and also ignores feature relationships, leading to distorted distributions and biased model predictions.

Why this answer

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because Amazon QuickSight is a business intelligence (BI) service for visualization and dashboards, not a data preparation tool with built-in duplicate detection for ML pipelines. Option C is wrong because AWS Glue Studio FindDuplicates is a transform available in AWS Glue Studio (a separate ETL service), not within SageMaker Data Wrangler's interface or step library. Option D is wrong because Amazon DataZone is a data catalog and governance service for managing data assets across an organization, not a data preparation tool that detects or removes duplicates.

Why this answer

How to eliminate wrong answers

Option A is wrong because random shuffling and splitting an imbalanced dataset (0.1% fraud) risks producing validation or test sets with no fraud examples, leading to misleading accuracy metrics and inability to detect model overfitting. Option B is wrong because k-fold cross-validation on the entire dataset would leak information from future folds into training when used for final model selection, and it does not provide a held-out test set for unbiased final evaluation. Option D is wrong because applying SMOTE before splitting introduces synthetic data that can leak information across the split boundaries, causing data leakage and overly optimistic performance estimates; SMOTE should only be applied to the training set after splitting.

Why this answer

How to eliminate wrong answers

Option A is wrong because stratified sampling based on churn label preserves class distribution but does not address temporal leakage; it can still mix future and past data. Option B is wrong because random splitting ignores the timestamp order, allowing future data to leak into the training set and causing the model to learn from events that haven't occurred yet. Option C is wrong because k-fold cross-validation with shuffling randomly reorders the data, which breaks the time sequence and introduces future information into training folds.

Why this answer

How to eliminate wrong answers

Option A is wrong because switching to a Spark container does not inherently fix a memory error; Spark also requires sufficient memory per executor and may introduce overhead without addressing the root cause of insufficient RAM. Option C is wrong because writing output as Parquet instead of CSV reduces disk I/O and storage size but does not reduce the memory footprint of the in-memory DataFrame or the StandardScaler computation. Option D is wrong because standardizing features before loading into the DataFrame is not a valid operation—standardization requires the entire dataset's statistics (mean and variance), which must be computed in memory after loading.

Why this answer

How to eliminate wrong answers

Option A is wrong because while a custom Python script using pandas dt.day_name() could technically extract the day of the week, Data Wrangler provides a native transform that avoids the overhead of writing and maintaining custom code, and the question asks how the transformation 'should be performed' in Data Wrangler, implying use of its built-in features. Option B is wrong because one-hot encoding is a technique for converting categorical variables into binary columns, not for extracting temporal features like the day of the week from a timestamp. Option C is wrong because the 'extract' transform in Data Wrangler is used to extract substrings or patterns from text columns using regular expressions, not to interpret timestamps; the format '%A' is a Python strftime directive, but Data Wrangler's 'extract' transform does not support strftime-style parsing for timestamps.

Why this answer

How to eliminate wrong answers

Option A is wrong because loading a 50 GB dataset into memory using Pandas in a SageMaker notebook instance is inefficient and likely to cause out-of-memory errors, as Pandas is single-threaded and not designed for distributed processing of large datasets. Option C is wrong because dropping all records with missing values (15% of data) would discard a significant portion of the dataset, potentially biasing the model, and Athena SQL queries do not natively support imputation of missing values with mean or median without complex workarounds. Option D is wrong because while Amazon EMR with Spark could handle the task, it requires provisioning and managing a cluster, which is more complex and less cost-effective than the serverless AWS Glue approach for this specific data preparation task.

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because writing a custom SageMaker Processing job for validation is unnecessary overhead; Data Wrangler already provides native data quality checks that are simpler and more integrated. Option C is wrong because AWS Glue DataBrew is a separate service for data preparation, not a step within a SageMaker Data Wrangler pipeline, and using it would break the pipeline's continuity. Option D is wrong because adding a SageMaker Pipeline step to check data quality after Data Wrangler is redundant; Data Wrangler itself can perform validation inline, and a post-hoc step would not catch issues before training in the same streamlined flow.

Why this answer

How to eliminate wrong answers

Option A is wrong because a stratified split based on the target variable preserves class proportions but does not account for time order, leading to potential data leakage when time-dependent patterns exist. Option C is wrong because a random split ignores the temporal structure entirely, allowing future data points to appear in the training set and causing leakage. Option D is wrong because K-fold cross-validation shuffles data randomly across folds, which breaks the time sequence and introduces leakage; it is unsuitable for time-series or time-sensitive data.

Why this answer

How to eliminate wrong answers

Option B is wrong because random sampling from the entire dataset would include outdated data from months or years ago, failing to capture the recent distribution shift and introducing bias from stale patterns. Option C is wrong because using all historical data would force the model to learn temporal patterns that may no longer be valid, leading to degraded performance on current data and higher training costs due to the full 500 GB dataset. Option D is wrong because exponential downsampling of older data is an overly complex approach that may still retain some outdated data, and it does not guarantee that the training set reflects the most recent behavior as cleanly as a simple time-window cut; it also adds unnecessary preprocessing overhead.