What is Hugging Face? | Hugging Face Models | Transformers | Pipelines In Hugging Face | Simplilearn

Transcribed Jun 15, 2026 Watch on YouTube ↗

Intermediate 12 min read For: Developers and data science enthusiasts interested in practical NLP applications using Hugging Face.

9.7K

Views

177

Likes

3

Comments

2

Dislikes

1.9%

📊 Average

AI Summary

This video from Simplilearn introduces Hugging Face, a company that provides pre-trained AI models for language tasks like translation, text analysis, and generation. The presenter demonstrates three practical applications: speech-to-text, sentiment analysis, and text generation using the Transformers library and pipelines.

Chapters

1 Introduction to Hugging Face 00:04 2 Speech-to-Text Demo 02:03 3 Sentiment Analysis Demo 16:50 4 Text Generation Demo 38:56

[00:04]

Introduction to Hugging Face

Hugging Face is a company that helps people use AI models for language tasks like translation, text analysis, and generating new text. They created the Transformers library with pre-trained models.

[00:43]

Three Cool Things with Hugging Face

The video covers speech-to-text, sentiment analysis, and text generation. Speech-to-text turns spoken words into written text. Sentiment analysis determines if text is positive, negative, or neutral. Text generation creates human-like text.

[02:49]

Installing Transformers

The Transformers library is installed via pip install transformers. It allows downloading and running thousands of pre-trained open-source AI models.

[03:45]

Using Pipeline

A pipeline describes the flow of data from origin to destination and defines how to transform data. It simplifies using Hugging Face models.

[05:11]

Importing Libraries for Speech-to-Text

Libraries imported include librosa (audio analysis), torch (PyTorch), IPython.display (interactive display), and transformers (Wav2Vec2ForCTC, Wav2Vec2Tokenizer).

[09:10]

Loading Pre-trained Model for Speech-to-Text

The model used is 'facebook/wav2vec2-base-960h'. The tokenizer and model are loaded using from_pretrained.

[10:36]

Loading Audio File

An audio file (v.m4a) is loaded using librosa.load with a sampling rate of 16000. The audio is played using IPython.display.

[13:52]

Tokenizing Audio and Getting Logits

Input values are obtained by tokenizing the audio with return_tensors='pt'. Logits (non-normalized predictions) are extracted from the model.

[15:23]

Decoding Transcription

Predicted IDs are obtained via torch.argmax on logits, then decoded using tokenizer.decode to get the transcription: 'hello and welcome this is an ai voice message'.

[16:50]

Sentiment Analysis Setup

Libraries imported: warnings, numpy, pandas, matplotlib, seaborn, sklearn (train_test_split, metrics), transformers (pipeline), torch.

[20:38]

Creating Sentiment Pipeline

A sentiment analysis pipeline is created using pipeline('sentiment-analysis'). It classifies text as positive or negative with confidence scores.

[22:14]

Testing Sentiment Analysis

Testing with 'this is a great movie' returns label POSITIVE with high score. 'I did not understand any of it' returns NEGATIVE.

[23:57]

Loading Twitter Dataset

A CSV file 'airline_tweets.csv' is loaded using pandas. The dataset contains columns: tweet_id, airline_sentiment (neutral, positive, negative), and text.

[26:59]

Filtering Neutral Sentiments

Rows with neutral sentiment are filtered out, leaving 11,541 rows. Sentiment is mapped: positive -> 1, negative -> 0.

[29:22]

Predicting Sentiments on Dataset

The classifier predicts sentiments on the text column. Predictions are converted to binary (1 for positive, 0 for negative).

[32:10]

Accuracy and Confusion Matrix

Accuracy is 88.99%. A confusion matrix is plotted showing true vs predicted labels for negative and positive classes.

[37:46]

ROC AUC Score

ROC AUC score is 0.94 (94%), indicating high accuracy and effectiveness in classifying sentiment.

[39:08]

Text Generation Setup

A dataset of poems (robert_frost.csv) is loaded. Content column is extracted, lines are split and cleaned.

[42:38]

Creating Text Generation Pipeline

A text generation pipeline is created using pipeline('text-generation'). It generates text based on a prompt.

[43:37]

Generating Text from Poem Lines

Using a line from a poem as prompt, text is generated with max_length=20. Example: 'Whose woods these are I think I know' generates 'I wish to go to church because I feel'.

[44:42]

Generating Multiple Sequences

With max_length=30 and num_return_sequences=2, two different continuations are generated from the same prompt.

[47:42]

Custom Prompt Generation

A custom prompt 'Transformers have a wide variety of applications in NLP' is used to generate text with max_length=100.

Hugging Face simplifies AI model usage with pre-trained models and pipelines. The video demonstrates speech-to-text, sentiment analysis, and text generation, showing how to implement these tasks with minimal code.

Clickbait Check

90% Legit

"Title accurately describes the content: Hugging Face, models, transformers, and pipelines are all covered with demos."

Mentioned in this Video

Hugging Face Transformers

tool

librosa

tool

PyTorch

tool

NumPy

tool

pandas

tool

matplotlib

tool

seaborn

tool

scikit-learn

tool

Google Colab

tool

facebook/wav2vec2-base-960h

model

Tutorial Checklist

1 02:49 Install transformers library: pip install transformers

2 03:38 Import pipeline: from transformers import pipeline

3 05:11 Import additional libraries: librosa, torch, IPython.display, numpy, and specific transformers modules (Wav2Vec2ForCTC, Wav2Vec2Tokenizer)

4 09:10 Load pre-trained tokenizer and model: tokenizer = Wav2Vec2Tokenizer.from_pretrained('facebook/wav2vec2-base-960h'); model = Wav2Vec2ForCTC.from_pretrained('facebook/wav2vec2-base-960h')

5 10:36 Load audio file: audio, sampling_rate = librosa.load('v.m4a', sr=16000)

6 13:52 Tokenize audio: input_values = tokenizer(audio, return_tensors='pt').input_values

7 14:40 Get logits: logits = model(input_values).logits

8 15:23 Get predicted IDs: predicted_ids = torch.argmax(logits, dim=-1)

9 15:57 Decode transcription: transcription = tokenizer.decode(predicted_ids[0])

10 20:38 Create sentiment analysis pipeline: classifier = pipeline('sentiment-analysis')

11 22:14 Test sentiment analysis: classifier('This is a great movie')

12 23:57 Load dataset: df = pd.read_csv('airline_tweets.csv')

13 27:31 Filter neutral sentiments: df = df[df.airline_sentiment != 'neutral']

14 27:55 Map sentiment to binary: df['target'] = df.airline_sentiment.map({'positive':1, 'negative':0})

15 29:22 Predict sentiments: predictions = classifier(text_list); probabilities = [pred['score'] if pred['label'].startswith('P') else 1-pred['score'] for pred in predictions]

16 31:17 Convert predictions to binary: predictions = np.array([1 if pred['label'].startswith('P') else 0 for pred in predictions])

17 32:10 Calculate accuracy: accuracy = np.mean(df.target == predictions) * 100

18 33:12 Plot confusion matrix: sns.heatmap(confusion_matrix(df.target, predictions, normalize='true'), annot=True, cmap='Blues')

19 37:46 Print ROC AUC score: roc_auc_score(df.target, probabilities)

20 39:23 Load poem dataset: poems = pd.read_csv('robert_frost.csv')

21 40:33 Extract lines: content = poems.content.dropna().tolist(); lines = [line.strip() for poem in content for line in poem.split('\n') if len(line)>0]

22 42:38 Create text generation pipeline: gen = pipeline('text-generation')

23 43:37 Generate text from a line: gen(lines[0], max_length=20)

24 44:42 Generate multiple sequences: gen(lines[1], max_length=30, num_return_sequences=2)

25 47:42 Generate text from custom prompt: gen('Transformers have a wide variety of applications in NLP', max_length=100)

Study Flashcards (10)

What is Hugging Face?

easy Click to reveal answer

A company that provides pre-trained AI models for language tasks like translation, text analysis, and text generation.