docs.aws.amazon.com Open in urlscan Pro
65.9.63.84  Public Scan

Form analysis
0 forms found in the DOM

Text Content

SELECT YOUR COOKIE PREFERENCES

We use cookies and similar tools to enhance your experience, provide our
services, deliver relevant advertising, and make improvements. Approved third
parties also use these tools to help us deliver advertising and provide certain
site features.

CustomizeAccept all


CUSTOMIZE COOKIE PREFERENCES

We use cookies and similar tools (collectively, "cookies") for the following
purposes.


ESSENTIAL

Essential cookies are necessary to provide our site and services and cannot be
deactivated. They are usually set in response to your actions on the site, such
as setting your privacy preferences, signing in, or filling in forms.




PERFORMANCE

Performance cookies provide anonymous statistics about how customers navigate
our site so we can improve site experience and performance. Approved third
parties may perform analytics on our behalf, but they cannot use the data for
their own purposes.

Allow performance category
Allowed


FUNCTIONAL

Functional cookies help us provide useful site features, remember your
preferences, and display relevant content. Approved third parties may set these
cookies to provide certain site features. If you do not allow these cookies,
then some or all of these services may not function properly.

Allow functional category
Allowed


ADVERTISING

Advertising cookies may be set through our site by us or our advertising
partners and help us deliver relevant marketing content. If you do not allow
these cookies, you will experience less relevant advertising.

Allow advertising category
Allowed

Blocking some types of cookies may impact your experience of our sites. You may
review and change your choices at any time by clicking Cookie preferences in the
footer of this site. We and selected third-parties use cookies or similar
technologies as specified in the AWS Cookie Notice

.

CancelSave preferences


English


Sign In to the Console
 1. AWS
 2. ...
    
 3. Documentation
 4. Amazon SageMaker
 5. Developer Guide

Feedback
Preferences
Amazon SageMaker
Developer Guide
 * What Is Amazon SageMaker?
    * Machine Learning with Amazon SageMaker
    * Explore, Analyze, and Process Data
    * Fairness and Model Explainability
    * Model Training
    * Model Deployment
    * Validating Models
    * Model Monitoring
    * ML Frameworks and Toolkits
       * Apache MXNet
       * Apache Spark
          * Example 1: SageMaker with Apache Spark
             * Custom Algorithms for Model Training and Hosting on SageMaker
               with Apache Spark
             * Use the SageMakerEstimator in a Spark Pipeline
         
          * SDK and notebook examples
      
       * Chainer
       * Hugging Face
       * PyTorch
       * R
       * Scikit-learn
       * SparkML Serving
       * TensorFlow
       * Triton Inference Server
   
    * Supported Regions and Quotas

 * Get Started
    * Set Up Amazon SageMaker Prerequisites
    * Onboard to Domain
       * Onboard Using Quick setup
       * Onboard Using SSO
          * Set Up SSO
      
       * Onboard Using IAM
       * Choose a VPC
       * Delete a Domain
   
    * SageMaker JumpStart
       * SageMaker JumpStart Industry
   
    * Get Started with Notebook Instances
       * Step 1: Create an Amazon SageMaker Notebook Instance
       * Step 2: Create a Jupyter Notebook
       * Step 3: Download, Explore, and Transform Data
       * Step 4: Train a Model
       * Step 5: Deploy the Model
       * Step 6: Evaluate the Model
       * Step 7: Clean Up
   
    * Amazon SageMaker Studio Lab
       * Studio Lab components overview
       * Onboard to Studio Lab
       * Manage your account
       * Launch Studio Lab
       * Use Studio Lab starter assets
       * Use the Studio Lab project runtime
          * Studio Lab UI overview
          * Create or open a notebook
          * Use the toolbar
          * Manage your environment
          * Use external resources
          * Get notebook differences
          * Export Studio Lab environment to Studio
          * Shut down resources
      
       * Troubleshooting

 * Machine Learning Environments
    * SageMaker Domain
    * SageMaker Studio
       * UI Overview
       * Use the Studio Launcher
       * Use Studio Notebooks
          * Compare Studio Notebooks with Notebook Instances
          * Get Started
          * Studio Tour
          * Create or Open a Notebook
          * Use the Toolbar
          * Share and Use a Notebook
          * Get Notebook and App Metadata
          * Get Notebook Differences
          * Manage Resources
             * Change an Instance Type
             * Change a Kernel
             * Shut Down Resources
         
          * Usage Metering
          * Available Resources
             * Available SageMaker Studio Instance Types
             * Available Amazon SageMaker Images
             * Available Amazon SageMaker Kernels
      
       * Customize Studio
          * Bring your own image
             * Create an image
             * Attach an image
             * Launch a custom image
             * Bring your own image tutorial
                * Add a Studio-compatible image to ECR
                * Create a SageMaker image
                * Attach the image to a new domain
                * Attach the image to a current domain
                * View the attached image
                * Clean up resources
            
             * Custom image specifications
         
          * Use Lifecycle Configurations with Studio
             * Creating and Associating a Lifecycle Configuration
             * Setting Defaults
             * Debugging Lifecycle Configurations
             * Updating and deleting Lifecycle Configurations
      
       * Perform Common Tasks
          * Upload Files
          * Clone a Git Repository
          * Stop a Training Job
          * Use TensorBoard in Amazon SageMaker Studio
          * Manage Your EFS Volume
          * Provide Feedback
          * Shut Down and Update Studio and Apps
             * Shut Down and Update Studio
             * Shut down and Update Studio Apps
      
       * Studio Pricing
       * Troubleshooting
   
    * RStudio on Amazon SageMaker
       * Manage RStudio on SageMaker
          * RStudio license
          * Network and Storage
          * RStudioServerPro instance type
          * RStudio Connect URL
          * RStudio Package Manager
          * Create an Amazon SageMaker Domain with RStudio using the AWS CLI
          * Manage users
          * RStudio administrative dashboard
          * Manage billing and cost
          * Diagnose issues and get support
      
       * Use RStudio on Amazon SageMaker
          * Open RStudio Launcher and launch RSessions
          * Publish to RStudio Connect
          * Access Amazon SageMaker features with RStudio on Amazon SageMaker
   
    * SageMaker Canvas
       * Getting started
       * Setting up and managing Amazon SageMaker Canvas (for IT administrators)
          * Give your users the ability to upload local files
          * Set up SageMaker Canvas for your users
          * Give users the ability to import encrypted datasets
          * Give your users permissions to perform time series forecasting
          * Update SageMaker Canvas for your users
          * Request a quota increase
          * Give users permissions to import Amazon Redshift data
          * Run Amazon SageMaker Canvas in a VPC
      
       * Importing data in Amazon SageMaker Canvas
          * Connect to an external data source
          * Join data that you've imported into SageMaker Canvas
      
       * Build a model
          * Prepare data with advanced transformations
      
       * Evaluating Your Model's Performance in Amazon SageMaker Canvas
          * Model Scoring
          * Use advanced metrics in your analyses
      
       * Making predictions on your data
       * Logging out
       * Time Series Forecasts in Amazon SageMaker Canvas
          * Gain additional insights from your forecast
          * Make a time series forecast
      
       * Updating a Model in Amazon SageMaker Canvas
       * Share your models with data scientists

 * Notebook Instances
    * AL2 vs AL1 instances
    * Create a Notebook Instance
    * Access Notebook Instances
    * Update a Notebook Instance
    * Customize a Notebook Instance
       * Lifecycle Configuration Best Practices
       * Install External Libraries and Kernels in Notebook Instances
       * Notebook Instance Software Updates
       * Control an Amazon EMR Spark Instance Using a Notebook
   
    * Example Notebooks
    * Set the Notebook Kernel
    * Git Repos
       * Add a Git Repository to Your Amazon SageMaker Account
          * Add a Git Repository to Your Amazon SageMaker Account (CLI)
      
       * Create a Notebook Instance with an Associated Git Repository
          * Create a Notebook Instance with an Associated Git Repository (CLI)
      
       * Associate a CodeCommit Repository in a Different AWS Account with a
         Notebook Instance
       * Use Git Repositories in a Notebook Instance
   
    * Notebook Instance Metadata
    * Monitor Jupyter Logs in Amazon CloudWatch Logs

 * Autopilot: Automated ML
    * Get started
       * Samples
       * Videos
       * Tutorials
   
    * Create an Autopilot experiment
    * Datasets and problem types
    * Model support, metrics, and validation
    * Deploy models
    * Explainability
    * Models generated
    * Notebooks generated
       * Data exploration report
       * Candidate definition notebook
       * Model Insights
   
    * Configure inference output
    * Quotas
    * API reference

 * Label Data
    * Label Data (Ground Truth)
       * Getting started
          * Step 1: Before You Begin
          * Step 2: Create a Labeling Job
          * Step 3: Select Workers
          * Step 4: Configure the Bounding Box Tool
          * Step 5: Monitoring Your Labeling Job
      
       * Label Images
          * Bounding Box
          * Image Semantic Segmentation
          * Auto-Segmentation Tool
          * Image Classification (Single Label)
          * Image Classification (Multi-label)
          * Image Label Verification
      
       * Label Text
          * Named Entity Recognition
          * Text Classification (Single Label)
          * Text Classification (Multi-label)
      
       * Label Videos and Video Frames
          * Video Classification
          * Label Video Frames
             * Video Frame Object Detection
             * Video Frame Object Tracking
             * Video Frame Labeling Job Overview
         
          * Worker Instructions
             * Work on Video Frame Object Tracking Tasks
             * Work on Video Frame Object Detection Tasks
      
       * Label 3D Point Clouds
          * Built-In Task Types
             * 3D Point Cloud Object Detection
             * 3D Point Cloud Object Tracking
             * 3D Point Cloud Semantic Segmentation
         
          * 3D Point Cloud Labeling Job Overview
          * Worker Instructions
             * 3D Point Cloud Semantic Segmentation
             * 3D Point Cloud Object Detection
             * 3D Point Cloud Object Tracking
      
       * Verify and Adjust Labels
       * Creating Custom Labeling Workflows
          * Step 1: Setting up your workforce
          * Step 2: Creating your custom worker task template
          * Step 3: Processing with AWS Lambda
             * Pre-annotation and Post-annotation Lambda Function Requirements
             * Required Permissions To Use AWS Lambda With Ground Truth
             * Create Lambda Functions for a Custom Labeling Workflow
             * Test Pre-Annotation and Post-Annotation Lambda Functions
         
          * Demo: Image Annotation with crowd-bounding-box
          * Demo: Text Intent with crowd-classifier
          * Custom Workflows via the API
      
       * Create a Labeling Job
          * Built-in Task Types
          * Creating Instruction Pages
          * Create a Labeling Job (Console)
          * Create a Labeling Job (API)
          * Create a Streaming Labeling Job
             * Create Amazon SNS Input and Output Topics
             * Set up Amazon S3 Bucket Event Notifications
             * Create a Manifest File (Optional)
             * Example: Use SageMaker API To Create Streaming Labeling Job
             * Stop a Streaming Labeling Job
         
          * Add Label Category and Frame Attributes
      
       * Use Input and Output Data
          * Input Data
             * Use an Input Manifest File
             * Automated Data Setup
             * Supported Data Formats
             * Streaming Labeling Jobs
             * Input Data Quotas
             * Filter and Select Data for Labeling
         
          * 3D Point Cloud Input Data
             * Accepted Raw 3D Data Formats
             * Create an Input Manifest File for a 3D Point Cloud Labeling Job
                * Create a Point Cloud Frame Input Manifest File
                * Create a Point Cloud Sequence Input Manifest
            
             * LiDAR Coordinate System and Sensor Fusion
         
          * Video Frame Input Data
             * Choose Video Files or Video Frames for Input Data
             * Input Data Setup
                * Automated Video Frame Input Data Setup
                * Manual Input Data Setup
         
          * Output Data
      
       * Enhanced Data Labeling
          * Control the Flow of Data Objects Sent to Workers
          * Consolidate Annotations
          * Automate Data Labeling
          * Chaining Labeling Jobs
      
       * Security and Permissions
          * CORS Permission Requirement
          * IAM Permissions
             * Use IAM Managed Policies
             * IAM Permissions To Use the Ground Truth Console
             * Create an SageMaker Execution Role
             * Encrypt Output Data and Storage Volume with AWS KMS
         
          * Data Encryption
          * Workforce Authentication and Restrictions
      
       * Monitor Labeling Job Status
   
    * Label Data (Ground Truth Plus)
       * Getting Started with Amazon SageMaker Ground Truth Plus.
          * Set Up Amazon SageMaker Ground Truth Plus Prerequisites
          * Core Components of Amazon SageMaker Ground Truth Plus
      
       * Request a Pilot
       * Share Data with Amazon SageMaker Ground Truth Plus
       * Create a Project Team
       * Open the Project Portal
       * Review Metrics
       * Review Batches
       * Accept or Reject Batches
   
    * Create and Manage Workforces
       * Using the Amazon Mechanical Turk Workforce
       * Managing Vendor Workforces
       * Use a Private Workforce
          * Create and Manage Amazon Cognito Workforce
             * Create a Private Workforce (Amazon Cognito)
                * Create a Private Workforce (Amazon SageMaker Console)
                * Create a Private Workforce (Amazon Cognito Console)
            
             * Manage a Private Workforce (Amazon Cognito)
                * Manage a Workforce (Amazon SageMaker Console)
                * Manage a Private Workforce (Amazon Cognito Console)
         
          * Create and Manage OIDC IdP Workforce
             * Create a Private Workforce (OIDC IdP)
             * Manage a Private Workforce (OIDC IdP)
         
          * Manage Private Workforce Using the Amazon SageMaker API
          * Track Worker Performance
          * Create and manage Amazon SNS topics for your work teams
   
    * Crowd HTML Elements Reference

 * Prepare and Analyze Datasets
    * Detect Pretraining Data Bias
       * Measure Pretraining Bias
          * Class Imbalance (CI)
          * Label Imbalance (DPL)
          * Kullback-Leibler Divergence (KL)
          * Jensen-Shannon Divergence (JS)
          * Lp-norm (LP)
          * Total Variation Distance (TVD)
          * Kolmogorov-Smirnov (KS)
          * Conditional Demographic Disparity (CDD)
      
       * Generate Reports for Bias in Pretraining Data in SageMaker Studio
   
    * Prepare Data with Data Wrangler
       * Get Started with Data Wrangler
       * Import
       * Create and Use a Data Wrangler Flow
       * Get Insights On Data and Data Quality
       * Transform Data
       * Analyze and Visualize
       * Export
       * Security and Permissions
       * Release Notes
       * Troubleshoot
       * Update Data Wrangler
       * Shut Down Data Wrangler
   
    * Prepare Data at Scale with Studio Notebooks
       * Discover Amazon EMR Clusters from Studio
       * Connect to an Amazon EMR Cluster from Studio
       * Troubleshoot and Monitor Workloads in Amazon EMR
       * Manage Amazon EMR Clusters from Studio
          * Configure AWS Service Catalog Products
          * Provision Amazon EMR Clusters from Studio
      
       * Required Permissions

 * Process Data
    * Data Processing with Apache Spark
    * Data Processing with scikit-learn
    * Data Processing with Framework Processors
       * Hugging Face Framework Processor
       * MXNet Framework Processor
       * PyTorch Framework Processor
       * TensorFlow Framework Processor
       * XGBoost Framework Processor
   
    * Use Your Own Processing Code
       * Run Scripts with a Processing Container
       * Build Your Own Processing Container

 * Create, Store, and Share Features
    * Get started with Amazon SageMaker Feature Store
       * Create Feature Groups
          * Introduction to Feature Store
          * Fraud Detection with Feature Store
      
       * Adding required policies to your IAM role
       * Use Feature Store with Studio
   
    * Data Sources and Ingestion
       * Batch Ingestion Spark Connector Setup
   
    * Query Feature Store with Athena and AWS Glue
    * Cross-Account Offline Store Access
    * Security and Access Control
    * Quotas, Naming Rules and Data Types
    * Amazon SageMaker Feature Store Offline Store Data Format
    * Amazon SageMaker Feature Store Notebook Examples

 * Training
    * Choose an algorithm
       * Use built-in algorithms
          * Common Information
             * Docker Registry Paths and Example Code
                * US East (Ohio)
                * US East (N. Virginia)
                * US West (N. California)
                * US West (Oregon)
                * Africa (Cape Town)
                * Asia Pacific (Hong Kong)
                * Asia Pacific (Mumbai)
                * Asia Pacific (Osaka)
                * Asia Pacific (Seoul)
                * Asia Pacific (Singapore)
                * Asia Pacific (Sydney)
                * Asia Pacific (Tokyo)
                * Canada (Central)
                * China (Beijing)
                * China (Ningxia)
                * Europe (Frankfurt)
                * Europe (Ireland)
                * Europe (London)
                * Europe (Paris)
                * Europe (Stockholm)
                * Europe (Milan)
                * Middle East (Bahrain)
                * South America (São Paulo)
                * AWS GovCloud (US-West)
            
             * Common data formats
                * Common Data Formats for Training
                * Common Data Formats for Inference
            
             * Suggested instance types
             * Logs
         
          * BlazingText
             * Hyperparameters
             * Model Tuning
         
          * DeepAR Forecasting
             * How DeepAR Works
             * Hyperparameters
             * Model Tuning
             * Inference Formats
         
          * Factorization Machines
             * How It Works
             * Hyperparameters
             * Model Tuning
             * Inference Formats
         
          * Image Classification Algorithm
             * How It Works
             * Hyperparameters
             * Model Tuning
         
          * IP Insights
             * How It Works
             * Hyperparameters
             * Model Tuning
             * Data Formats
                * Training
                * Inference
         
          * K-Means Algorithm
             * How It Works
             * Hyperparameters
             * Model Tuning
             * Inference Formats
         
          * K-Nearest Neighbors (k-NN) Algorithm
             * How It Works
             * Hyperparameters
             * Model Tuning
             * Training Formats
             * Inference Formats
         
          * Latent Dirichlet Allocation (LDA)
             * How It Works
             * Hyperparameters
             * Model Tuning
         
          * Linear Learner Algorithm
             * How It Works
             * Hyperparameters
             * Model Tuning
             * Inference Formats
         
          * Neural Topic Model (NTM) Algorithm
             * Hyperparameters
             * Model Tuning
             * Inference Formats
         
          * Object2Vec
             * How It Works
             * Hyperparameters
             * Model Tuning
             * Training Formats
             * Inference Formats: Scoring
             * Inference Formats: Embeddings
         
          * Object Detection Algorithm
             * How It Works
             * Hyperparameters
             * Model Tuning
             * Inference Formats
         
          * Principal Component Analysis (PCA) Algorithm
             * How It Works
             * Hyperparameters
             * Inference Formats
         
          * Random Cut Forest (RCF) Algorithm
             * How It Works
             * Hyperparameters
             * Model Tuning
             * Inference Formats
         
          * Semantic Segmentation
             * Hyperparameters
             * Model Tuning
         
          * Sequence to Sequence (seq2seq)
             * How It Works
             * Hyperparameters
             * Model Tuning
         
          * XGBoost Algorithm
             * How It Works
             * Hyperparameters
             * Model Tuning
             * Deprecated Versions of XGBoost
                * XGBoost Release 0.90
                * XGBoost Release 0.72
      
       * Use Reinforcement Learning
          * Sample RL Workflow Using Amazon SageMaker RL
          * RL Environments in Amazon SageMaker
          * Distributed Training with Amazon SageMaker RL
          * Hyperparameter Tuning with Amazon SageMaker RL
   
    * Experiments
       * Create an Experiment
       * View and Compare Experiments, Trials, and Trial Components
       * Track and Compare Tutorial
       * Search Experiments Using Studio
       * Clean Up Experiment Resources
       * Search Using the Console and API
   
    * Debugger
       * Supported Frameworks and Algorithms
       * Debugger Architecture
       * Tutorials
          * Tutorial Videos
          * Example Notebooks
          * Advanced Demos and Visualization
      
       * Configure Debugger Using SageMaker Python SDK
          * Configure System Monitoring
          * Configure Framework Profiling
          * Update Monitoring and Profiling Configuration
          * Configure Debugger Hook to Save Tensors
          * Configure Debugger Built-in Rules
          * Turn Off Debugger
          * Useful SageMaker Estimator Classmethods for Debugger
      
       * Configure Debugger Using SageMaker API
          * JSON (AWS CLI)
          * AWS Boto3
      
       * List of Built-in Rules
       * Create Custom Rules
       * Use Debugger with Custom Training Containers
       * Action on Debugger Rules
          * Debugger Built-in Actions for Rules
          * Create Actions on Rules Using Amazon CloudWatch and AWS Lambda
      
       * Debugger in Studio
          * Open the Debugger Insights Dashboard
          * Debugger Insights Dashboard Controller
          * Debugger Insights Dashboard
             * Overview
             * Nodes
             * Model Insights
         
          * Shut Down Debugger Insights
          * Debugger in Studio Experiments
      
       * Debugger Interactive Reports
          * Debugger Profiling Report
          * Debugger XGBoost Training Report
      
       * Analyze Data Using the SMDebug Client Library
          * Access the Monitoring and Profiling Data
          * Plot the System Metrics and Framework Metrics Data
          * Access the Profiling Data Using the Pandas Data Parsing Tool
          * Access the Python Profiling Stats Data
          * Merge Timelines of Different Profiling Trace Files
          * Profiling Data Loader
      
       * Visualize Debugger Output Tensors in TensorBoard
       * Best Practices for Debugger
       * Advanced Topics and Reference
          * Debugger API Operations
          * Pre-built Docker Images for Rules
          * Exceptions
          * Considerations for Amazon SageMaker Debugger
          * Debugger Usage Statistics
   
    * Automatic Model Tuning
       * How Hyperparameter Tuning Works
       * Define Metrics
       * Define Hyperparameter Ranges
       * Tune Multiple Algorithms
          * Create an HPO Tuning Job (Console)
          * Manage Jobs for HPO
      
       * Example: Hyperparameter Tuning Job
          * Create a Notebook
          * Get the Amazon SageMaker Boto 3 Client
          * Get the SageMaker Execution Role
          * Specify a S3 Bucket to Upload Training Datasets and Store Output
            Data
          * Download, Prepare, and Upload Training Data
          * Configure and Launch a Hyperparameter Tuning Job
          * Monitor the Progress of a Hyperparameter Tuning Job
          * Clean up
      
       * Stop Training Jobs Early
       * Run a Warm Start Hyperparameter Tuning Job
       * Resource Limits for Automatic Model Tuning
       * Best Practices for Hyperparameter Tuning
   
    * Distributed Training
       * Data Parallel Training
          * Introduction to the Data Parallel Library
          * Supported Frameworks, AWS Regions, and Instances Types
          * Run a SageMaker Distributed Training Job with Data Parallelism
             * Step 1: Modify Your Own Training Script
                * TensorFlow
                * PyTorch
            
             * Step 2: Launch a Training Job
         
          * Configuration Tips and Pitfalls
          * FAQ
          * Troubleshooting
      
       * Model Parallel Training
          * Introduction to Model Parallelism
          * Core Features
          * Run a SageMaker Distributed Training Job with Model Parallelism
             * Step1: Modify Your Own Training Script
                * TensorFlow
                * PyTorch
            
             * Step 2: Launch a Training Job
         
          * Extended Features for PyTorch
             * Tensor Parallelism
                * How It Works
                * Run a Training Job with Tensor Parallelism
                * Checkpointing with Tensor Parallelism
                * Support for Hugging Face Transformer Models
            
             * Optimizer State Sharding
             * Activation Checkpointing
             * Activation Offloading
             * Ranking Mechanism
         
          * Best Practices
          * Configuration Tips and Pitfalls
          * Troubleshooting
      
       * SageMaker Distributed Training Notebook Examples
   
    * Training Compiler
       * Supported Frameworks, AWS Regions, Tested Instances, and Tested Models
       * Enable Training Compiler
       * Bring Your Own Deep Learning Model
          * TensorFlow Models
          * PyTorch Models
      
       * Example Notebooks and Blogs
       * Best Practices
       * Training Compiler FAQ
       * Troubleshooting
       * Release Notes
   
    * Clarify Bias Detection and Model Explainability
       * Clarify Processing Jobs
       * Get Started: Clarify Containers
       * Configure a Clarify Processing Job
       * Configure the Analysis
       * Run SageMaker Clarify Processing Jobs
       * Detect Posttraining Data and Model Bias
          * Measure Posttraining Data and Model Bias
             * Difference in Positive Proportions in Predicted Labels (DPPL)
             * Disparate Impact (DI)
             * Difference in Conditional Acceptance (DCAcc)
             * Difference in Conditional Rejection (DCR)
             * Recall Difference (RD)
             * Difference in Acceptance Rates (DAR)
             * Difference in Rejection Rates (DRR)
             * Accuracy Difference (AD)
             * Treatment Equality (TE)
             * Conditional Demographic Disparity in Predicted Labels (CDDPL)
             * Counterfactual Fliptest (FT)
      
       * Model Explainability
          * Shapley Values
          * SHAP Baselines for Explainability
          * Partial dependence plots
          * Computer Vision
          * Create Feature Attribute Baselines and Explainability Reports
          * Explainability Reports for NLP Models
      
       * Troubleshoot Jobs
   
    * Incremental Training
    * Access Training Data
    * Managed Spot Training
    * Use Checkpoints
    * Use Augmented Manifest Files
    * Monitor and Analyze Using CloudWatch Metrics

 * Deploy Models for Inference
    * Get an endpoint instance type recommendation
       * Prerequisites
       * Recommendation jobs
          * Get an instance recommendation
          * Run a custom load test
   
    * Real-time inference
       * Hosting options
          * Host a single model
             * Create your endpoint and deploy your model
             * Delete Endpoints and Resources
         
          * Host multiple models in one container behind one endpoint
             * Create a Multi-Model Endpoint
             * Invoke a Multi-Model Endpoint
             * Add or Remove Models
             * Bring Your Own Container
                * API Container Contract
            
             * Security
             * CloudWatch Metrics for Multi-Model Endpoint Deployments
         
          * Host multiple models which use different containers behind one
            endpoint
             * Use a multi-container endpoint with direct invocation
         
          * Host models along with pre-processing logic as serial inference
            pipeline behind one endpoint
             * Process Features with Spark ML and Scikit-learn
             * Create a Pipeline Model
             * Real-time Inference
             * Batch Transform
             * Logs and Metrics
             * Troubleshooting
      
       * Automatically scale models
          * Prerequisites
          * Configure model autoscaling with the console
          * Register a model
          * Define a scaling policy
          * Apply a scaling policy
          * Edit a scaling policy
          * Delete a scaling policy
          * Query Endpoint Autoscaling History
          * Update or delete endpoints that use automatic scaling
          * Load testing
          * Use AWS CloudFormation to update autoscaling policies
      
       * Host instance storage volumes
       * Safely update models in production
       * Best practices
          * Best practices for deploying models on SageMaker Hosting Services
          * Troubleshoot deployments
      
       * Monitor models for data and model quality, bias, and explainability
          * Monitor data quality
             * Create a Baseline
             * Statistics
             * CloudWatch Metrics
             * Violations
         
          * Monitor model quality
             * Create a Model Quality Baseline
             * Schedule Model Quality Monitoring Jobs
             * Ingest Ground Truth Labels and Merge Them With Predictions
             * Model Quality Metrics
             * Model Quality CloudWatch Metrics
         
          * Monitor bias drift
             * Create a Bias Drift Baseline
             * Schedule Bias Drift Monitoring Jobs
             * Inspect Reports for Data Bias Drift
         
          * Monitor feature attribution drift
             * Create a SHAP Baseline
             * Schedule Feature Attribute Drift Monitoring Jobs
             * Inspect Reports for Feature Attribute Drift
         
          * Capture data
          * Schedule monitoring jobs
             * cron scheduling
         
          * Prebuilt container
          * Interpret results
          * Visualize results
          * Advanced topics
             * Customize monitoring
                * Preprocessing and Postprocessing
                * Bring Your Own Containers
                   * Inputs
                   * Outputs
                      * Statistics
                      * Constraints
                  
                   * CloudWatch Metrics
            
             * AWS CloudFormation Custom Resource
      
       * Invoke real-time endpoints
   
    * Serverless Inference
       * Create, Invoke, Update, and Delete an Endpoint
          * Prerequisites
          * Create a serverless endpoint
          * Invoke a serverless endpoint
          * Update a serverless endpoint
          * Describe a serverless endpoint
          * Delete a serverless endpoint
      
       * Monitor a Serverless Endpoint
       * Troubleshooting
   
    * Asynchronous inference
       * Create, invoke, and update an Asynchronous Endpoint
          * Prerequisites
          * Create
          * Invoke
          * Update
          * Delete
      
       * Monitor asynchronous endpoint
       * Check prediction results
       * Autoscale an asynchronous endpoint
   
    * Batch Transform
       * Associate Prediction Results with Input
       * Storage in Batch Transform
   
    * Deployment guardrails
       * Auto-Rollback Configuration and Monitoring
       * Blue/Green Deployments
          * All At Once Traffic Shifting
          * Canary Traffic Shifting
          * Linear Traffic Shifting
      
       * Exclusions
   
    * Inference cost optimization best practices
    * Catalog models with Model Registry
       * Create a Model Group
       * Register Version
       * Model Groups and Versions
       * View Model Version Details
       * Update Model Approval Status
       * Deploy Model
       * Deployment History
   
    * Deploy models at the edge with SageMaker Edge Manager
       * Getting Started
          * Setting Up
          * Train, Compile, and Package Your Model
          * Create and Register Fleets and Authenticate Devices
          * Download and Set Up Edge Manager
          * Run Agent
      
       * Set Up Devices and Fleets
          * Create a Fleet
          * Register a Device
          * Check Status
      
       * Package Model
          * Package a Model (Amazon SageMaker Console)
          * Package a Model (Boto3)
      
       * Edge Manager Agent
          * Download and Set Up Edge Manager Agent Manually
          * Deploy Model Package and Edge Manager Agent with AWS IoT Greengrass
             * Prerequisites
             * Create AWS IoT Greengrass V2 Components
             * Deploy Components to Your Device
      
       * Manage Model
   
    * Optimize model performance using Neo
       * Compile Models
          * Prepare Model for Compilation
          * Compile Models: CLI
          * Compile Models: Console
          * Compile Models: SDK
      
       * Cloud Instances
          * Supported Instance Types and Frameworks
          * Deploy a Model
             * Prerequisites
             * Deploy a Compiled Model Using SageMaker SDK
             * Deploy a Compiled Model Using Boto3
             * Deploy a Compiled Model Using the AWS CLI
             * Deploy a Compiled Model Using the Console
         
          * Request Inferences
             * Request Inferences from a Deployed Service (Amazon SageMaker SDK)
             * Request Inferences from a Deployed Service (Boto3)
             * Request Inferences from a Deployed Service (AWS CLI)
         
          * Inference Container Images
      
       * Edge Devices
          * Supported Frameworks, Devices, Systems, and Architectures
             * Supported Frameworks
             * Supported Devices, Chip Architectures, and Systems
             * Tested Models
         
          * Deploy Models
          * Getting Started with Neo on Edge Devices
             * Step 1: Compile the Model
             * Step 2: Set Up Your Device
             * Step 3: Make Inferences on Your Device
      
       * Troubleshoot Errors
          * Troubleshoot Neo Compilation Errors
          * Troubleshoot Neo Inference Errors
          * Troubleshoot Ambarella Errors
   
    * Elastic Inference
       * Set Up to Use EI
       * Attach EI to a Notebook Instance
       * Endpoints with Elastic Inference

 * Docker containers with SageMaker
    * Docker Container Basics
    * Use Prebuilt SageMaker Docker images
       * Prebuilt Deep Learning Images
       * Prebuilt Scikit-learn and Spark ML Images
       * Deep Graph Networks
       * Extend a Prebuilt Container
   
    * Adapting Your Own Docker Container to Work with SageMaker
       * SageMaker Training and Inference Toolkits
       * Adapting Your Own Training Container
       * Adapting Your Own Inference Container
   
    * Create a container with your own algorithms and models
       * Use Your Own Training Algorithms
          * Run Your Training Image
          * Provide Training Information
          * Run Training with EFA
          * Signal Success or Failure
          * Training Output
      
       * Use Your Own Inference Code
          * With Hosting Services
             * Private Docker Registry for Inference
         
          * With Batch Transform
   
    * Example Notebooks
    * Troubleshooting

 * Workflows
    * Amazon SageMaker Model Building Pipelines
       * Pipeline Overview
          * Structure and Execution
          * Access Management
          * Pipeline Parameters
          * Pipeline Steps
          * Property Files and JsonGet
          * Caching Pipeline Steps
          * Retry Policy
          * ClarifyCheck QualityCheck Baselines
          * EventBridge Integration
          * Experiments Integration
          * Troubleshooting Pipelines
      
       * Create and Manage Pipelines
          * Define a Pipeline
          * Run a pipeline
          * View, Track, and Execute Pipelines in Studio
             * View a Pipeline
             * View a Pipeline Execution
             * View Experiment Entities
             * Execute a Pipeline
             * Track the Lineage of a Pipeline
   
    * Projects
       * Why MLOps?
       * SageMaker Projects
       * SageMaker Studio Permissions Required to Use Projects
       * Create an MLOps Project
       * Templates
          * Use Provided Templates
          * Custom Templates
      
       * View Resources
       * Update an MLOps Project
       * Delete an MLOps Project
       * Project walkthrough
   
    * ML Lineage Tracking
       * Tracking Entities
       * SageMaker-Created Entities
       * Manually Create Entities
       * Querying Lineage Entities
       * Cross-Account Tracking
   
    * Kubernetes Orchestration
       * SageMaker Operators for Kubernetes
          * Using SageMaker Jobs
             * TrainingJob operator
             * HyperParameterTuningJob operator
             * BatchTransformJob operator
             * HostingDeployment operator
             * ProcessingJob operator
             * HostingAutoscalingPolicy (HAP) Operator
      
       * SageMaker Components for Kubeflow Pipelines
          * Using SageMaker Components

 * Augmented AI
    * Get Started with Amazon Augmented AI
       * Core Components of Amazon A2I
       * Prerequisites to Using Augmented AI
       * Tutorial: Get Started in the Amazon A2I Console
       * Tutorial: Get Started Using the Amazon A2I API
   
    * Use Cases and Examples
       * Use with Amazon Textract
       * Use with Amazon Rekognition
       * Use With Custom Task Types
   
    * Create a Human Review Workflow
       * JSON Schema for Human Loop Activation Conditions in Amazon Augmented AI
          * Use Human Loop Activation Conditions JSON Schema with Amazon
            Textract
          * Use Human Loop Activation Conditions JSON Schema with Amazon
            Rekognition
   
    * Delete a Human Review Workflow
    * Create and Start a Human Loop
    * Delete a Human Loop
    * Create and Manage Worker Task Templates
       * Create and Delete Worker Task Templates
       * Create Custom Worker Task Templates
       * Creating Good Worker Instructions
   
    * Monitor and Manage Your Human Loop
    * Output Data
    * Permissions and Security
    * CloudWatch Events
    * API References

 * Marketplace
    * Use your own algorithms and models with the AWS Marketplace
       * Create Algorithm and Model Package Resources
          * Create an Algorithm Resource
          * Create a Model Package Resource
      
       * Use Algorithm and Model Package Resources
          * Use an Algorithm to Run a Training Job
          * Use an Algorithm to Run a Hyperparameter Tuning Job
          * Use a Model Package to Create a Model
   
    * Sell Amazon SageMaker Algorithms and Model Packages
       * Develop Algorithms and Models in Amazon SageMaker
       * List Your Algorithm or Model Package on AWS Marketplace
   
    * Find and Subscribe to Algorithms and Model Packages on AWS Marketplace

 * Security
    * Access Control
       * Access control and Studio notebooks
       * Control root access to a Notebook instance
   
    * Data Protection
       * Protect Data at Rest Using Encryption
          * Studio notebooks
          * Notebook instances and SageMaker jobs
      
       * Protecting Data in Transit with Encryption
          * Protect Communications Between ML Compute Instances in a Distributed
            Training Job
      
       * Key Management
       * Internetwork Traffic Privacy
   
    * Identity and Access Management
       * How Amazon SageMaker Works with IAM
       * Identity-Based Policy Examples
       * Cross-Service Confused Deputy Prevention
       * SageMaker Roles
       * Amazon SageMaker API Permissions Reference
       * AWS Managed Policies for SageMaker
          * SageMaker Ground Truth
          * SageMaker Pipelines
          * SageMaker projects and JumpStart
      
       * Troubleshooting
   
    * Logging and Monitoring
    * Compliance Validation
    * Resilience
    * Infrastructure Security
       * Connect to Resources From Within a VPC
          * Connect Studio Notebooks in a VPC to External Resources
          * Connect a Notebook Instance in a VPC to External Resources
      
       * Run Training and Inference Containers in Internet-Free Mode
       * Connect to SageMaker Through a VPC Interface Endpoint
          * Connect to Studio Through a VPC Endpoint
          * Connect to a Notebook Instance Through a VPC Interface Endpoint
      
       * Give SageMaker Access to Resources in your Amazon VPC
          * Give SageMaker Processing Jobs Access to Resources in Your Amazon
            VPC
          * Give SageMaker Training Jobs Access to Resources in Your Amazon VPC
          * Give SageMaker Hosted Endpoints Access to Resources in Your Amazon
            VPC
          * Give Batch Transform Jobs Access to Resources in Your Amazon VPC
          * Give Amazon SageMaker Clarify Jobs Access to Resources in Your
            Amazon VPC
          * Give SageMaker Compilation Jobs Access to Resources in Your Amazon
            VPC

 * Monitoring
    * Monitoring with CloudWatch
    * Logging with CloudWatch
    * Log SageMaker API Calls with CloudTrail
    * Automating with EventBridge

 * API and SDK Reference
    * Programming Model for Amazon SageMaker

 * Amazon SageMaker Document History
 * AWS glossary

Protect Data at Rest Using Encryption - Amazon SageMaker
AWSDocumentationAmazon SageMakerDeveloper Guide


PROTECT DATA AT REST USING ENCRYPTION

PDFRSS

To protect your Amazon SageMaker Studio notebooks and SageMaker notebook
instances, along with your model-building data and model artifacts, SageMaker
encrypts the notebooks, as well as output from Training and Batch Transform
jobs. SageMaker encrypts these by default using the AWS Managed Key for Amazon
S3. This AWS Managed Key for Amazon S3 cannot be shared for cross-account
access. For cross-account access, specify your customer managed key while
creating SageMaker resources so that it can be shared for cross-account access.
For more information on AWS KMS, see What is AWS Key Management Service?.

Topics

 * Studio notebooks
 * Notebook instances and SageMaker jobs

Javascript is disabled or is unavailable in your browser.

To use the Amazon Web Services Documentation, Javascript must be enabled. Please
refer to your browser's Help pages for instructions.

Document Conventions
Data Protection
Studio notebooks
Did this page help you? - Yes

Thanks for letting us know we're doing a good job!

If you've got a moment, please tell us what we did right so we can do more of
it.



Did this page help you? - No

Thanks for letting us know this page needs work. We're sorry we let you down.

If you've got a moment, please tell us how we can make the documentation better.




Did this page help you?
YesNo
Provide feedback
Edit this page on GitHub
Next topic:Studio notebooks
Previous topic:Data Protection
Need help?
 * Try AWS re:Post
 * Connect with an AWS IQ expert

PrivacySite termsCookie preferences
© 2022, Amazon Web Services, Inc. or its affiliates. All rights reserved.





DID THIS PAGE HELP YOU? - NO



Thanks for letting us know this page needs work. We're sorry we let you down.

If you've got a moment, please tell us how we can make the documentation better.



Feedback