CF

AI Engineering Bootcamp: Build, Train & Deploy Models with AWS SageMaker

19h 10m 18s
English
Paid

Learn how to build real AI systems with SageMaker. In this course, you collect data, train models, and deploy them on AWS. You work step by step, so you see how each part fits into a full AI app.

What You Will Learn

You move through the full AI workflow. You start with raw data and end with a live model that serves real users.

  • How to gather and clean data
  • How to train and tune models in SageMaker
  • How to test and improve your model
  • How to deploy and scale your model on AWS

Why Use AWS SageMaker

SageMaker gives you tools to train and host models without building your own servers. You focus on your model and your code, not on setup.

End-to-End Tools

SageMaker lets you prepare data, run training jobs, and host models in one place. This helps you keep your work organized.

Easy Deployment

You can deploy a model with a few steps. SageMaker handles the hardware and scales your app when traffic grows.

Skills You Will Build

You learn skills that apply to real AI projects. Each skill supports your work as a developer or engineer.

  • Data prep and feature work
  • Model training and tuning
  • Model evaluation
  • API deployment
  • Monitoring and scaling

Who This Course Is For

This course helps self‑taught devs, students, and new engineers. You do not need deep math or ML theory. You learn by building.

What You Build

You ship a full AI app. You train a model on your own data and deploy it with an API. You also learn how to update the model after it goes live.

Additional

https://github.com/patrikszepesi/LLM_course

About the Author: Zero To Mastery

Zero To Mastery thumbnail

Zero To Mastery (ZTM) is a Toronto-based online coding academy founded by Andrei Neagoie, originally a senior developer at large Canadian tech firms before turning to teaching full-time. The academy's signature is the cohort-based bootcamp track combined with a deep self-paced course library, all aimed at career-changers and self-taught developers preparing to land software-engineering roles at top companies.

The instructor roster has grown well beyond Andrei to include other senior practitioners: Daniel Bourke (machine learning), Aleksa Tešić (DevOps), Jacinto Wong, and others. Courses cover the full software-engineering career path: web development with React and Next.js, Python, machine learning and deep learning, DevOps and cloud, system design, mobile, and the algorithm / data-structure interview prep that gates engineering jobs.

The CourseFlix listing under this source carries over 120 ZTM courses spanning that full range. Material is paid; ZTM itself runs on a monthly / annual membership model. The teaching style favours long-form, project-based courses where students build complete portfolio-quality applications rather than disconnected feature tutorials.

Watch Online 139 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 139 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: AI Engineering Bootcamp: Learn AWS SageMaker with Patrik Szepesi
All Course Lessons (139)
#Lesson TitleDurationAccess
1
AI Engineering Bootcamp: Learn AWS SageMaker with Patrik Szepesi Demo
01:36
2
Course Introduction Part 1: Build, Train, and Deploy Models with AWS SageMaker
08:43
3
Course Introduction Part 2: Fine-Tuning LLMs with QLoRA, AWS, and Open Source
05:20
4
Setting Up Our AWS Account
04:32
5
Set Up IAM Roles + Best Practices
07:40
6
AWS Security Best Practices
07:02
7
Set Up AWS SageMaker Domain
02:23
8
UI Domain Change
00:43
9
Sagemaker Domain Creation Update Part 1
02:41
10
Sagemaker Domain Creation Update Part 2
03:07
11
Sagemaker Notebooks Update
11:59
12
Setting Up SageMaker Environment
05:09
13
SageMaker Studio and Pricing
08:45
14
Quota Increase
07:36
15
Setup: SageMaker Server + PyTorch
06:09
16
HuggingFace Models, Sentiment Analysis, and AutoScaling
18:35
17
Get Dataset for Multiclass Text Classification
06:04
18
Creating Our AWS S3 Bucket
03:53
19
Uploading Our Training Data to S3
01:27
20
Exploratory Data Analysis - Part 1
13:22
21
Exploratory Data Analysis - Part 2
06:08
22
Data Visualization and Best Practices
11:09
23
Setting Up Our Training Job Notebook + Reasons to Use SageMaker
18:25
24
Python Script for HuggingFace Estimator
13:37
25
Creating Our Optional Experiment Notebook - Part 1
03:22
26
Creating Our Optional Experiment Notebook - Part 2
04:02
27
Encoding Categorical Labels to Numeric Values
13:25
28
Understanding the Tokenization Vocabulary
15:06
29
Encoding Tokens
10:57
30
Practical Example of Tokenization and Encoding
12:49
31
Creating Our Dataset Loader Class
16:57
32
Setting Pytorch DataLoader
15:10
33
Which Path Will You Take?
01:32
34
DistilBert vs. Bert Differences
04:47
35
Embeddings In A Continuous Vector Space
07:41
36
Introduction To Positional Encodings
05:14
37
Positional Encodings - Part 1
04:15
38
Positional Encodings - Part 2 (Even and Odd Indices)
10:11
39
Why Use Sine and Cosine Functions
05:09
40
Understanding the Nature of Sine and Cosine Functions
09:53
41
Visualizing Positional Encodings in Sine and Cosine Graphs
09:25
42
Solving the Equations to Get the Values for Positional Encodings
18:08
43
Introduction to Attention Mechanism
03:03
44
Query, Key and Value Matrix
18:11
45
Getting Started with Our Step by Step Attention Calculation
06:54
46
Calculating Key Vectors
20:06
47
Query Matrix Introduction
10:21
48
Calculating Raw Attention Scores
21:25
49
Understanding the Mathematics Behind Dot Products and Vector Alignment
13:33
50
Visualizing Raw Attention Scores in 2D
05:43
51
Converting Raw Attention Scores to Probability Distributions with Softmax
09:17
52
Normalization
03:20
53
Understanding the Value Matrix and Value Vector
09:08
54
Calculating the Final Context Aware Rich Representation for the Word "River"
10:46
55
Understanding the Output
01:59
56
Understanding Multi Head Attention
11:56
57
Multi Head Attention Example and Subsequent Layers
09:52
58
Masked Language Learning
02:30
59
Exercise: Imposter Syndrome
02:57
60
Creating Our Custom Model Architecture with PyTorch
17:15
61
Adding the Dropout, Linear Layer, and ReLU to Our Model
15:32
62
Creating Our Accuracy Function
13:05
63
Creating Our Train Function
19:09
64
Finishing Our Train Function
08:18
65
Setting Up the Validation Function
13:41
66
Passing Parameters In SageMaker
04:06
67
Setting Up Model Parameters For Training
04:28
68
Understanding The Mathematics Behind Cross Entropy Loss
05:40
69
Finishing Our Script.py File
06:57
70
Starting Our Training Job
08:16
71
Debugging Our Training Job With AWS CloudWatch
14:17
72
Analyzing Our Training Job Results
05:47
73
Creating Our Inference Script For Our PyTorch Model
08:35
74
Finishing Our PyTorch Inference Script
09:13
75
Setting Up Our Deployment
07:31
76
Deploying Our Model To A SageMaker Endpoint
08:55
77
Introduction to Endpoint Load Testing
04:20
78
Creating Our Test Data for Load Testing
10:03
79
Upload Testing Data to S3
01:04
80
Creating Our Model for Load Testing
03:59
81
Starting Our Load Test Job
07:15
82
Analyze Load Test Results
10:17
83
Deploying Our Endpoint
03:51
84
Creating Lambda Function to Call Our Endpoint
10:27
85
Setting Up Our AWS API Gateway
05:28
86
Testing Our Model with Postman, API Gateway and Lambda
05:40
87
Finishing Part 1 and Cleaning Up Resources for Part 1
02:52
88
Creating a SageMaker Domain
02:29
89
Logging in to our SageMaker Environment
04:54
90
Introduction to JupyterLab
07:38
91
Sagemaker Sessions, Regions, and IAM Roles
07:51
92
Examining Our Dataset from HuggingFace
13:30
93
Tokenization and Word Embeddings
09:09
94
HuggingFace Authentication with Sagemaker
04:22
95
Applying the Templating Function to our Dataset
08:44
96
Attention Masks and Padding
15:56
97
Star Unpacking with Python
04:04
98
Chain Iterator, List Constructor and Attention Mask example with Python
10:23
99
Understanding Batching
08:12
100
Slicing and Chunking our Dataset
07:32
101
Creating our Custom Chunking Function
16:07
102
Tokenizing our Dataset
09:31
103
Running our Chunking Function
04:31
104
Understanding the Entire Chunking Process
08:33
105
Uploading the Training Data to AWS S3
05:54
106
Setting Up Hyperparameters for the Training Job
06:48
107
Creating our HuggingFace Estimator in Sagemaker
06:46
108
Introduction to Low-rank adaptation (LoRA)
08:12
109
LoRA Numerical Example
10:56
110
LoRA Summarization and Cost Saving Calculation
09:09
111
(Optional) Matrix Multiplication Refresher
04:46
112
Understanding LoRA Programatically Part 1
12:33
113
Understanding LoRA Programatically Part 2
05:49
114
Bfloat16 vs Float32
08:11
115
Comparing Bfloat16 Vs Float32 Programatically
06:33
116
Setting up Imports and Libraries for the Train Script
07:20
117
Argument Parsing Function Part 1
07:57
118
Argument Parsing Function Part 2
10:55
119
Understanding Trainable Parameters Caveats
14:31
120
Introduction to Quantization
07:36
121
Identifying Trainable Layers for LoRA
07:20
122
Setting up Parameter Efficient Fine Tuning
04:36
123
Implement LoRA Configuration and Mixed Precision Training
10:35
124
Understanding Double Quantization
04:22
125
Creating the Training Function Part 1
14:15
126
Creating the Training Function Part 2
07:17
127
Finishing our Sagemaker Script
05:09
128
Gaining Access to Powerful GPUs with AWS Quotas
05:11
129
Final Fixes Before Training
03:55
130
Starting our Training Job
07:16
131
Inspecting the Results of our Training Job and Monitoring with Cloudwatch
11:24
132
Deploying our LLM to a Sagemaker Endpoint
17:58
133
Testing our LLM in Sagemaker Locally
08:19
134
Creating the Lambda Function to Invoke our Endpoint
08:56
135
Creating API Gateway to Deploy the Model Through the Internet
02:37
136
Implementing our Streamlit App
05:12
137
Streamlit App Correction
03:27
138
Congratulations and Cleaning up AWS Resources
02:39
139
Thank You!
01:18
Unlock unlimited learning

Get instant access to all 138 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What prerequisites are needed for this course?
The course assumes a fundamental understanding of machine learning concepts and familiarity with Python programming. Prior experience with AWS services would be beneficial but is not mandatory, as the course covers setting up AWS accounts and best practices for AWS Security. A basic understanding of PyTorch and HuggingFace models would also be helpful, as these are used extensively in the course.
What will I build in this course?
In this course, you will build full-cycle AI applications using AWS SageMaker. You will start by setting up an AWS SageMaker environment and proceed to train models, such as HuggingFace models for sentiment analysis. You will also learn to deploy these models and scale your AI applications using AWS services. Additionally, you will conduct exploratory data analysis and data visualization as part of the data preparation process.
Who is the target audience for this course?
The course is designed for aspiring AI engineers and data scientists who want to gain practical skills in developing and deploying AI applications using AWS SageMaker. It is also suitable for software developers looking to expand their knowledge of AI and cloud-based machine learning solutions. Those interested in learning about the intricacies of model training, deployment, and scaling in a cloud environment will find this course particularly valuable.
What specific tools or platforms are covered in the course?
The course focuses on AWS SageMaker, a comprehensive cloud-based machine learning platform. You will also use AWS S3 for data storage and management, and IAM roles for security best practices. The course incorporates PyTorch for model creation and training, and HuggingFace for working with pre-trained models. These tools are essential for building, training, and deploying AI models in the course.
What topics are not covered in this course?
The course does not cover introductory machine learning concepts in depth, as it assumes prior knowledge in this area. It also does not delve into other cloud platforms besides AWS or alternative machine learning frameworks outside of PyTorch and HuggingFace. If you are looking for coverage of Azure or TensorFlow, this course may not meet those needs.
How much time should I expect to commit to this course?
The course consists of 139 lessons, and while the total runtime is not specified, prospective students should anticipate dedicating several weeks to complete all the materials and exercises. The time commitment will depend on your pace and familiarity with the covered topics. Allow additional time for practical exercises, such as creating and deploying AI models and conducting exploratory data analysis.
How can the skills learned in this course be applied to other careers or fields?
Skills acquired in this course, such as deploying and scaling AI models using AWS SageMaker, are applicable across various industries where AI adoption is growing. These skills are valuable for roles in data science, AI engineering, machine learning operations (MLOps), and cloud architecture. Understanding AWS services and their integration into AI workflows can also enhance your capability to work in cloud-based environments, which is increasingly important in many tech careers.