CF

Learn Hugging Face by Building a Custom AI Model

6h 32m 55s
English
Paid

Explore the Hugging Face ecosystem from scratch, including Transformers, Datasets, Hub/Spaces, and much more, by creating and configuring your own AI model for text classification. In this course, you will learn how to deploy your model for real-world use!

Introduction to Hugging Face

Dive deep into the Hugging Face ecosystem and understand its core components. This section will cover an overview of Transformers, Datasets, Hub/Spaces, and their relevance in AI model development.

Understanding Transformers

Learn about Transformers and their applications in various natural language processing tasks. We'll explore how these models revolutionize the field of AI.

Datasets and Their Importance

Discover the role of Datasets in training machine learning models. Get hands-on experience with the Hugging Face Datasets library to streamline your model preparation process.

Exploring Hub/Spaces

Understand the functionality of Hub/Spaces on Hugging Face. Learn how you can host your models and share them with the community for easier collaboration and deployment.

Building Your Custom AI Model

Step through the process of creating a custom AI model with Hugging Face. From data preprocessing to model training, this section will provide you with the knowledge to develop models tailored to specific tasks.

Configuring the Model

Learn how to configure your model to maximize its performance. Discover techniques to adjust hyperparameters and fine-tune the model for optimal results.

Implementing Text Classification

Apply your skills to implement a text classification model using Hugging Face frameworks. This practical application will solidify your understanding of the entire model-building process.

Deploying Your AI Model

Finally, put your model into production. Learn the steps and tools necessary for deploying your AI model for real-world use cases, ensuring it is scalable and accessible.

Real-World Deployment Techniques

Explore different deployment strategies and technologies that can help you get your model up and running effectively. Understand how to manage any operational challenges in deployment.

Optimizing Deployment for Scalability

Focus on making your deployment scalable to handle varying loads and ensure reliability. Learn about best practices in resource management and service scaling.

Additional

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 39 lessons

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Introduction (Hugging Face Ecosystem and Text Classification)
All Course Lessons (39)
#Lesson TitleDurationAccess
1
Introduction (Hugging Face Ecosystem and Text Classification) Demo
06:53
2
More Text Classification Examples
04:41
3
What We're Going To Build!
07:22
4
Getting Setup: Adding Hugging Face Tokens to Google Colab
05:53
5
Getting Setup: Importing Necessary Libraries to Google Colab
09:36
6
Downloading a Text Classification Dataset from Hugging Face Datasets
16:01
7
Preparing Text Data for Use with a Model - Part 1: Turning Our Labels into Numbers
12:49
8
Preparing Text Data for Use with a Model - Part 2: Creating Train and Test Sets
06:19
9
Preparing Text Data for Use with a Model - Part 3: Getting a Tokenizer
12:54
10
Preparing Text Data for Use with a Model - Part 4: Exploring Our Tokenizer
10:27
11
Preparing Text Data for Use with a Model - Part 5: Creating a Function to Tokenize Our Data
17:58
12
Setting Up an Evaluation Metric (to measure how well our model performs)
08:54
13
Introduction to Transfer Learning (a powerful technique to get good results quickly)
07:11
14
Model Training - Part 1: Setting Up a Pretrained Model from the Hugging Face Hub
12:20
15
Model Training - Part 2: Counting the Parameters in Our Model
12:27
16
Model Training - Part 3: Creating a Folder to Save Our Model
03:54
17
Model Training - Part 4: Setting Up Our Training Arguments with TrainingArguments
15:00
18
Model Training - Part 5: Setting Up an Instance of Trainer with Hugging Face Transformers
05:06
19
Model Training - Part 6: Training Our Model and Fixing Errors Along the Way
13:35
20
Model Training - Part 7: Inspecting Our Models Loss Curves
14:40
21
Model Training - Part 8: Uploading Our Model to the Hugging Face Hub
08:02
22
Making Predictions on the Test Data with Our Trained Model
05:59
23
Turning Our Predictions into Prediction Probabilities with PyTorch
12:49
24
Sorting Our Model's Predictions by Their Probability
05:11
25
Performing Inference - Part 1: Discussing Our Options
09:41
26
Performing Inference - Part 2: Using a Transformers Pipeline (one sample at a time)
10:02
27
Performing Inference - Part 3: Using a Transformers Pipeline on Multiple Samples at a Time (Batching)
06:39
28
Performing Inference - Part 4: Running Speed Tests to Compare One at a Time vs. Batched Predictions
10:34
29
Performing Inference - Part 5: Performing Inference with PyTorch
12:07
30
OPTIONAL - Putting It All Together: from Data Loading, to Model Training, to making Predictions on Custom Data
34:29
31
Turning Our Model into a Demo - Part 1: Gradio Overview
03:48
32
Turning Our Model into a Demo - Part 2: Building a Function to Map Inputs to Outputs
07:08
33
Turning Our Model into a Demo - Part 3: Getting Our Gradio Demo Running Locally
06:47
34
Making Our Demo Publicly Accessible - Part 1: Introduction to Hugging Face Spaces and Creating a Demos Directory
08:02
35
Making Our Demo Publicly Accessible - Part 2: Creating an App File
12:15
36
Making Our Demo Publicly Accessible - Part 3: Creating a README File
07:08
37
Making Our Demo Publicly Accessible - Part 4: Making a Requirements File
03:34
38
Making Our Demo Publicly Accessible - Part 5: Uploading Our Demo to Hugging Face Spaces and Making it Publicly Available
18:44
39
Summary Exercises and Extensions
05:56
Unlock unlimited learning

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

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for this course?
This course does not detail specific prerequisites, but familiarity with basic Python programming and understanding of machine learning concepts will be beneficial. The course covers the Hugging Face ecosystem, Transformers, and Datasets, and assumes a foundational knowledge of these topics for optimal learning.
What will I build in this course?
You will build a custom AI model for text classification. The course guides you through the entire process, from setting up your environment with Hugging Face Tokens in Google Colab to preparing datasets and training a model. You will also learn to deploy your model using Hugging Face Spaces, making it publicly accessible via a Gradio demo.
Who is the target audience for this course?
The course is designed for individuals interested in applying natural language processing to real-world tasks using the Hugging Face platform. It is suitable for learners who wish to gain hands-on experience in building, configuring, and deploying custom AI models with a focus on text classification.
How does this course compare in depth to other AI model courses?
This course provides a focused exploration of the Hugging Face ecosystem, specifically targeting text classification tasks. Unlike broader AI courses, it offers a detailed, practical guide to utilizing Transformers and Datasets with Hugging Face tools, providing specialized knowledge ideal for those looking to leverage these technologies in specific applications.
What specific tools and platforms will I learn to use?
The course covers the Hugging Face platform extensively, teaching you how to use the Transformers library, Datasets library, and deploy models using Hugging Face Spaces. You will also work with Gradio to create interactive demos and Google Colab for model development and training.
What topics are not covered in this course?
The course focuses specifically on text classification using the Hugging Face platform and does not cover other machine learning tasks such as image processing or advanced NLP tasks beyond text classification. It also doesn't delve into deep theoretical concepts of AI but rather focuses on practical applications.
What is the time commitment for this course?
While the exact runtime is not specified, the course consists of 39 lessons. Given the detailed nature of each section, including hands-on exercises and model deployment, learners should expect to dedicate several hours to complete the course fully, allowing time for practical application and experimentation.