AWS Certified Machine Learning – Specialty flashcards

A SageMaker feature that allows attaching GPU acceleration to CPU-based SageMaker instances, providing cost-effective inference for deep learning models.

• Reduces inference costs by up to 75%
• Supports various deep learning frameworks
• Provides flexible GPU acceleration without full GPU instances
• Ideal for models needing some GPU power but not a dedicated GPU instance

Memory trick: Elastic Inference: GPU power without the full price tag.

A deployment strategy where a new version of a model is released to a small subset of users or traffic, allowing its performance to be monitored and compared against the existing version before a full rollout.

• Minimizes risk by exposing new features to a small audience.
• Enables A/B testing and real-world performance validation.
• Allows for quick rollback if issues are detected.

Memory trick: Canary is like sending a scout bird to test the air.

A specialized repository for machine learning features that provides both an online store for low-latency serving and an offline store for training and batch inference.

• Ensures feature consistency between training and inference
• Supports point-in-time correctness for historical data
• Reduces feature engineering duplication
• Manages feature versions and lineage

Memory trick: Store features once, serve them fast, track them always.

A SageMaker feature that automatically adjusts the number of inference instances for a real-time endpoint based on predefined scaling policies.

• Ensures high availability and performance during traffic fluctuations.
• Supports target tracking, step scaling, and scheduled scaling policies.
• Helps optimize costs by scaling down during low traffic.

Memory trick: Scale up and down, when traffic goes 'round!

A deployment strategy where a new model processes a copy of live production traffic in parallel with the existing model, but its predictions are not used for actual user responses, allowing for non-disruptive validation.

• Routes a copy of production traffic to the new model.
• New model's predictions are not returned to users.
• Enables non-disruptive performance and stability testing.

Memory trick: Shadows secretly test new paths without changing the main road.

A feature of Amazon SageMaker that automatically adjusts the number of instances provisioned for a SageMaker endpoint in response to changes in workload.

• Optimizes costs by scaling instances up and down.
• Maintains performance during fluctuating traffic.
• Uses CloudWatch metrics and scaling policies.

Memory trick: Auto-scale for happy wallets and users.

A centralized repository for curated and transformed features, typically comprising an online store for low-latency inference and an offline store for training and batch processing.

• Ensures feature consistency between training and inference.
• Reduces feature engineering duplication.
• Improves model performance and operational efficiency.

Memory trick: Online for speed, offline for bulk, synced for truth.

A deployment strategy where a new version of a model is rolled out to a small subset of users first, monitored for performance, and then gradually rolled out to more users if successful.

• Minimizes risk of new deployments.
• Allows for quick rollback.
• Enables real-world performance monitoring before full rollout.

Memory trick: Canary sings a little, then a lot.

A feature within Amazon SageMaker that continuously monitors the quality of machine learning models in production, detecting data drift, concept drift, and alerting users to potential issues.

• Detects data and concept drift.
• Compares real-time inference data against baselines.
• Generates alerts for performance degradation.
• Integrates with SageMaker endpoints.

Memory trick: SageMaker's watchman, always eyes on the model's health.

A fully managed service for building, automating, and orchestrating end-to-end machine learning workflows within Amazon SageMaker.

• Enables MLOps practices for ML lifecycle automation.
• Supports data preprocessing, training, evaluation, and conditional deployment.
• Provides lineage tracking and reproducibility for ML experiments.

Memory trick: Pipelines are the ML model's assembly line.

A Docker container image created by the user, containing a machine learning model, its specific dependencies (e.g., custom framework versions, libraries), and custom inference code, which is then used by SageMaker for deployment.

• Provides full control over the inference environment.
• Necessary for custom framework versions or non-standard libraries.
• Pushed to Amazon ECR for SageMaker to use.
• Requires defining inference code (e.g., `model_fn`, `predict_fn`).

Memory trick: Custom Container: Pack your unique world for SageMaker to run.

An automated workflow for machine learning, typically using AWS Code services and SageMaker Pipelines, to manage the entire lifecycle from data to deployment.

• Automates model building, testing, and deployment
• Ensures reproducibility and traceability
• Integrates with source control and monitoring
• SageMaker Pipelines is key for ML-specific steps

Memory trick: Code's Pipeline Builds and Deploys SageMaker's ML.

A SageMaker real-time endpoint configuration that deploys instances across multiple AWS Availability Zones (AZs) for high availability and fault tolerance.

• Protects against single point of failure in an AZ.
• Combines with auto-scaling for dynamic capacity management.
• Essential for critical, low-latency production workloads.

Memory trick: Multiple instances in multiple zones keep the model alive.

A technique to distribute a single large machine learning model's layers or components across multiple GPUs or instances to overcome memory constraints and accelerate inference.

• Crucial for deploying very large models (e.g., LLMs)
• Splits model layers or parameters across devices
• Reduces memory footprint per device
• Can improve throughput and reduce latency for large models

Memory trick: Parallel Models Split Big Brains.

Ensuring data exchanged between a client and a SageMaker endpoint is encrypted while it's moving across a network.

• Achieved primarily through HTTPS/TLS.
• Protects sensitive inference requests and responses.
• Standard practice for secure ML deployments.

Memory trick: HTTPS protects the path, TLS secures the trip.

A SageMaker capability that compiles machine learning models to optimize them for deployment on specific hardware targets, including edge devices, reducing size and improving inference performance.

• Optimizes models for various target hardware (e.g., ARM, Intel, NVIDIA)
• Reduces model size and inference latency
• Generates a compiled model artifact
• Supports popular ML frameworks (TensorFlow, PyTorch, MXNet)

Memory trick: Neo optimizes for new edge devices.

A deployment strategy where two identical production environments (Blue: current, Green: new) are maintained. Traffic is shifted from Blue to Green, allowing for quick rollback if issues occur.

• Minimizes downtime during deployment.
• Enables instant rollback to the previous stable version.
• Requires double the infrastructure capacity temporarily.

Memory trick: Blue/Green is like switching traffic lights: safe and fast.

An MLOps practice where a model is retrained only when specific performance degradation or data drift conditions are met, rather than on a fixed schedule.

• Reduces computational costs and resource usage associated with unnecessary retraining.
• Ensures model quality by retraining only when genuinely needed.
• Often implemented using monitoring tools like SageMaker Model Monitor to detect triggers.

Memory trick: Don't retrain in vain, monitor the pain, then train again!

A Docker container orchestrated by Amazon SageMaker to host and serve machine learning models for real-time or batch inference.

• Contains model serving code (e.g., Flask, Gunicorn)
• Loads model artifacts from S3
• Executes prediction logic when invoked
• Can be custom or built-in SageMaker images

Memory trick: Containers Run Models Efficiently.

A SageMaker service for building, automating, and managing end-to-end machine learning workflows as reproducible, shareable, and auditable pipelines.

• Orchestrates steps like data processing, training, evaluation, and conditional deployment.
• Ensures consistency and reproducibility across ML lifecycle stages.
• Integrates with other SageMaker services like Model Registry and Feature Store.

Memory trick: Pipeline the process, from start to success, no more messy stress!

A SageMaker capability that helps detect bias in machine learning datasets and models, and provides tools to explain model predictions, promoting fairness and transparency.

• Detects pre-training and post-training bias.
• Generates model explanations (e.g., SHAP, LIME).
• Supports monitoring for bias and explainability in production.

Memory trick: Clarity brings fairness and trust to your ML decisions.

A SageMaker endpoint configuration parameter that specifies the maximum duration (in seconds) for a container to respond to health checks during startup, and also serves as the maximum timeout for a single inference request.

• Impacts both container startup and individual inference request timeouts.
• Default value is typically 60 seconds.
• Increasing it can prevent timeouts for large models or complex inferences.
• Configured at the endpoint configuration level.

Memory trick: Health check timeout: The container's patience for starting and responding to one request.

Strategies employed to maintain ML model performance when the underlying relationship between inputs and outputs changes over time.

• Regular retraining with fresh data is key
• Monitoring can detect drift, but retraining is the fix
• Can involve adaptive learning techniques
• Differs from data drift (input distribution change)

Memory trick: Drifting concepts? Retrain and relearn, always fresh.

An Amazon SageMaker feature that provides tools to detect bias in machine learning datasets and models, and to help explain model predictions, promoting fairness and transparency.

• Detects pre-training, post-training, and post-deployment bias.
• Generates model explanations using techniques like SHAP and LIME.
• Helps ensure regulatory compliance and ethical AI.
• Integrates with SageMaker processing jobs and pipelines.

Memory trick: Clarify: Bring light to fairness and make decisions clear.

A fully managed service that provides a centralized repository for machine learning features, consisting of an Online Store for low-latency real-time inference and an Offline Store for historical data for training and batch inference.

• Online Store for real-time, low-latency feature retrieval.
• Offline Store for historical data, training, and batch inference.
• Ensures consistency between training and inference features.
• Simplifies feature management and reuse.

Memory trick: Feature Store: Two sides of a coin, one fast, one deep.

A fully managed, purpose-built repository for machine learning features that simplifies the process of storing, discovering, and sharing features for training and inference.

• Supports online store for low-latency inference.
• Supports offline store for batch training and analysis.
• Enables feature versioning and reusability across models/teams.

Memory trick: Features stored, ready to serve.

A fully managed, continuously running HTTPS endpoint for real-time machine learning model inference.

• Provides low-latency, high-throughput inference.
• Supports auto-scaling to handle varying load.
• Integrates with various SageMaker features like model monitoring.

Memory trick: Real-time needs a persistent door, not a batch truck.

A SageMaker service that compiles ML models from various frameworks into an optimized executable for specific hardware targets, enhancing inference performance and efficiency.

• Reduces inference latency and cost.
• Supports various frameworks (TensorFlow, PyTorch, MXNet).
• Optimizes for cloud instances (e.g., with GPUs) and edge devices.

Memory trick: Neo optimizes the model for speed, Recommender suggests the right car.

SageMaker Endpoint Auto Scaling dynamically adjusts inference instance counts based on demand, while Multi-AZ deployment distributes instances across Availability Zones for high availability and fault tolerance.

• Auto Scaling adjusts capacity for traffic changes.
• Multi-AZ ensures high availability and resilience.
• Together, they provide robust, scalable, and fault-tolerant inference.

Memory trick: Scaling up and staying up is key for peak ML performance.

A feature for SageMaker inference endpoints (real-time or asynchronous) that automatically captures and saves input and output data for inference requests to S3.

• Provides a raw, immutable record of inferences
• Essential for auditing, debugging, and compliance
• Captures request payload, response payload, and metadata
• Configurable sampling rate for capture

Memory trick: Capture every prediction, keep the audit trail clear.

A deployment strategy where different versions of a machine learning model are served to different segments of live user traffic to compare their performance metrics directly.

• Routes a percentage of real-time traffic to new model.
• Allows direct comparison of model performance.
• Minimizes risk by limiting exposure of new model.

Memory trick: Comparing models is like a traffic light, directing users to different paths.

Configuring encryption for model artifacts, data in transit, and data at rest (EBS volumes) associated with an Amazon SageMaker real-time endpoint.

• Model artifacts can be encrypted in S3 using KMS.
• Endpoint communication uses HTTPS for in-transit encryption.
• EBS volumes attached to endpoint instances can be encrypted with KMS keys.

Memory trick: Model resource secures artifacts, endpoint config secures the runtime home.

A fully managed continuous delivery service that automates release pipelines for fast and reliable application and infrastructure updates.

• Orchestrates entire CI/CD workflows.
• Integrates with various AWS developer tools and services.
• Automates build, test, and deploy stages.

Memory trick: Pipeline flows, CodeBuild builds, Step Functions steps.

The process of recording and verifying every input, output, and decision made by a machine learning model, ensuring compliance, transparency, and accountability.

• Requires immutable storage of inference logs.
• Logs must include request and response payloads.
• Essential for regulatory compliance and debugging.

Memory trick: Audit trails for ML decisions demand verifiable, immutable records.

A custom Docker image used with Amazon SageMaker to provide a specific, pre-configured environment for training or inference, allowing for unique dependencies and frameworks.

• Packages all required software and libraries.
• Ensures consistent environment across deployments.
• Allows use of non-standard ML frameworks or versions.

Memory trick: Custom containers keep your model's unique world perfectly packed.

A phenomenon where the statistical properties of the target variable, which the model is trying to predict, change over time in unforeseen ways.

• Leads to model performance degradation.
• Can occur even if input data distribution remains stable.
• Requires model retraining to adapt to new patterns.

Memory trick: Drifting concepts make models lose their grip on reality.

An MLOps architecture where machine learning lifecycle stages (e.g., retraining, deployment) are automatically triggered by specific events.

• Automates reactions to data drift, performance degradation, or new data availability.
• Ensures models are continuously updated and relevant.
• Often uses services like AWS Lambda, EventBridge, and SageMaker Model Monitor.

Memory trick: Events ring the bell for automated ML actions.

An experimental framework used to compare two or more versions of a machine learning model or system in a live production environment to determine which performs better.

• Routes distinct user segments to different model versions (A vs. B).
• Enables direct comparison of business and ML metrics for different strategies.
• Ideal for iterative improvement and validating new model architectures/features.

Memory trick: Experiment and compare, let the users declare, which model's beyond compare!

The mechanism by which data sent to and from a SageMaker endpoint is secured while traveling over the network, primarily achieved through HTTPS/TLS.

• SageMaker endpoints automatically enforce HTTPS.
• HTTPS/TLS encrypts data between client and endpoint.
• Crucial for sensitive data and regulatory compliance (e.g., HIPAA, GDPR).
• Protects inference requests and responses.

Memory trick: HTTPS is the secure tunnel for your data's journey.

Ensuring the confidentiality of data processed by SageMaker endpoints, covering both data moving over the network (in transit) and data stored (at rest).

• In-transit encryption typically uses TLS/HTTPS.
• At-rest encryption often uses KMS keys for S3 storage (e.g., for Data Capture).
• Crucial for sensitive data and regulatory compliance (e.g., HIPAA, GDPR).

Memory trick: Transit and Rest, both must pass the encryption test!

A deployment strategy where a new model version receives a copy of live production traffic, but its predictions are not used in production, allowing for risk-free evaluation.

• Zero impact on live user experience.
• Evaluates new model with real-world data.
• Predictions are logged for offline analysis and comparison.

Memory trick: Shadow's Whisper, No Real Touch, Test in Stealth, Means So Much.

A deployment strategy where two identical production environments (Blue and Green) are maintained. One environment (Blue) serves live traffic, while the new version (Green) is deployed and validated. Once validated, traffic is switched to Green, and Blue becomes the standby or is retired.

• Minimizes downtime during deployment.
• Provides an immediate rollback mechanism.
• Requires double the infrastructure during deployment.

Memory trick: Blue and Green: Two distinct paths, quick switch means no path is lost.

An inference optimization technique where a single, large model is partitioned across multiple compute devices (e.g., GPUs), with different parts of the model (e.g., layers) processed in parallel.

• Reduces latency for very large and complex models.
• Allows models that exceed single-device memory to be deployed.
• Contrast with data parallelism, which distributes data, not the model.

Memory trick: Model parallelism splits the brain, data parallelism splits the workload.

Resource-based access policies that grant or deny permissions for specific actions on an S3 bucket and its objects, directly attached to the S3 bucket itself.

• JSON-based policy language.
• Defines 'Principal', 'Action', 'Resource', and 'Effect'.
• Can grant cross-account access.
• Used for fine-grained access control at the bucket or object prefix level.

Memory trick: Bucket Policies are the bouncers for your S3 data, checking IDs.

Structuring data in Amazon S3 using prefixes (folders) that correspond to frequently queried columns, enabling query engines to limit the amount of data scanned.

• Improves query performance (e.g., with Athena, Redshift Spectrum).
• Reduces data scanning costs.
• Commonly uses hierarchical folder structure (e.g., `year/month/day/`).
• Choose partition keys based on common filter conditions.

Memory trick: Organize your S3 data like nested folders by date and region.

The median is a measure of central tendency that is robust to outliers and skewed distributions, as it represents the middle value in an ordered dataset.

• Not affected by extreme values.
• Useful for skewed data where the mean is misleading.
• Calculated by ordering data and finding the middle point.

Memory trick: Median is the middle, mean is the average, mode is the most.

AWS Glue is a serverless ETL service that can be used to perform various data preparation tasks, including text cleaning and feature engineering, for machine learning workloads.

• Serverless and scalable.
• Supports custom Python/Scala scripts (e.g., with NLTK, SpaCy).
• Ideal for large datasets stored in S3.
• Automates schema discovery and job orchestration.

Memory trick: Glue cleans text for ML, making it shiny and new.

A feature engineering technique where each category in a categorical feature is replaced by the mean of the target variable for that category.

• Effective for high-cardinality categorical features.
• Reduces dimensionality compared to one-hot encoding.
• Captures the relationship between the feature and the target variable.
• Can lead to data leakage if not cross-validated properly.

Memory trick: Transforming data wisely, targets reveal the truth for high cards.

Implementing a multi-layered security strategy for Amazon S3 data lakes, encompassing encryption, access control, and auditing, to protect sensitive data.

• Encryption at rest (SSE-KMS, SSE-S3) and in transit (TLS).
• Granular access control (IAM Policies, S3 Bucket Policies).
• Comprehensive logging and auditing (AWS CloudTrail, S3 Access Logs).
• Network isolation (VPC Endpoints).

Memory trick: KMS encrypts, IAM controls, CloudTrail logs every genome scroll.

A statistical procedure that uses an orthogonal transformation to convert a set of observations of possibly correlated variables into a set of linearly uncorrelated variables called principal components.

• Reduces dimensionality by creating new, uncorrelated features.
• Effective for addressing multicollinearity.
• Retains most of the variance from original features.

Memory trick: Correlated features cause a fuss, PCA brings order to us.

Organizing data in Amazon S3 using a hierarchical folder structure based on multiple frequently-queried columns to optimize query performance and cost.

• Uses `key=value/` folder structure.
• Order of partition keys matters for query pruning.
• Most selective or frequently filtered columns often come first.
• Avoids scanning unnecessary data, reducing query time and cost.

Memory trick: Partition your data by country, then language, then date for perfect pruning.

A scatter plot displays the relationship between two continuous variables. Adding 'hue' (color coding) allows for the visualization of an additional categorical variable, enabling comparison of patterns across different groups.

• Excellent for identifying correlations, clusters, and outliers.
• Hue helps distinguish patterns for different categories.
• Reveals non-linear relationships and density variations within groups.
• Can be enhanced with size or shape for more dimensions.

Memory trick: Scatter with hue shows how groups scatter and accrue.

A feature engineering technique where a statistical aggregation (e.g., sum, mean, count) is computed over a sliding window of data points, often used for time-series data.

• Calculates metrics over a dynamic, time-based window.
• Useful for capturing recent trends or behaviors.
• Requires distributed processing for large datasets.

Memory trick: Rolling Aggregations capture Time, Glue or SageMaker make it Shine!

A serverless orchestration service within AWS Glue that allows you to create and manage complex ETL pipelines involving multiple Glue jobs, crawlers, and triggers.

• Orchestrates a sequence of AWS Glue jobs and crawlers.
• Manages dependencies between tasks.
• Provides scheduling capabilities for automated execution.
• Serverless and fully managed.

Memory trick: Glue Workflows orchestrate, from CSV to Parquet, then Catalog!

A fully managed Amazon SageMaker capability for running data processing, feature engineering, data validation, and model evaluation workloads at scale.

• Uses managed infrastructure for large-scale data tasks.
• Supports custom scripts and common ML frameworks (e.g., scikit-learn).
• Integrates seamlessly into SageMaker ML pipelines.
• Separate from model training, focusing on data preparation and evaluation.

Memory trick: Processing Jobs prepare data for SageMaker's big training day!

Ensuring that data representing the same entity or concept across different sources or within a dataset has uniform data types, formats, and representations.

• Critical for accurate joins, comparisons, and analysis.
• Involves type conversion (e.g., string to int, date parsing).
• May require string manipulation (e.g., trimming, padding, regex).
• Resolves heterogeneity across disparate data sources.

Memory trick: Consistent data connects, converting types corrects.

An AWS NLP service that uses machine learning to find insights and relationships in text, including identifying and redacting sensitive personally identifiable information (PII).

• Detects PII entities like names, addresses, credit card numbers.
• Can redact or mask identified PII.
• Scalable for large volumes of text data.
• Useful for privacy compliance in NLP datasets.

Memory trick: Comprehend the PII, then redact with ease!

Building pipelines to ingest, process, and analyze high-volume, low-latency data streams in real-time for immediate machine learning inference or anomaly detection.

• Ingestion: Kinesis Data Streams for high throughput.
• Processing: AWS Lambda for lightweight transformations/enrichment.
• Advanced Analytics: Kinesis Data Analytics for Apache Flink for complex real-time logic.
• Low latency and high scalability are critical.

Memory trick: Streams flow, Lambda enriches, Flink detects the fraud that breaches.

Statistical measures of central tendency and spread that are less affected by extreme values or deviations from normality, making them suitable for skewed distributions.

• Median is a robust measure of central tendency.
• Interquartile Range (IQR) is a robust measure of spread.
• These measures are preferred over mean and standard deviation for skewed data.

Memory trick: Skewed data's tale: Median and IQR prevail.

The p-value is the probability of observing a test statistic as extreme as, or more extreme than, the one calculated from the sample data, assuming the null hypothesis is true.

• If p-value < alpha (significance level), reject the null hypothesis.
• If p-value > alpha, fail to reject the null hypothesis.
• A small p-value suggests that the observed data is unlikely under the null hypothesis.
• Does not indicate the magnitude or importance of the effect.

Memory trick: If P is low, Null must go. If P is high, Null can fly.