Loading the Dataset

from datasets import load_dataset

# Load the emotions dataset
emotions = load_dataset("dair-ai/emotion")

# Check what we got
print(emotions)

Tokenizer Properties

# Explore tokenizer properties
print(f"Vocabulary size: {tokenizer.vocab_size}")
print(f"Model input names: {tokenizer.model_input_names}")
print(f"Maximum sequence length: {tokenizer.model_max_length}")

# The tokenizer outputs:
# 1. input_ids: Token IDs
# 2. attention_mask: Indicates which tokens should be attended to
# 3. special tokens: [CLS], [SEP], etc. that have special meaning

Tokenizing the Entire Dataset

# Define a function to tokenize batches
def tokenize(batch):
    return tokenizer(batch["text"], padding=True, truncation=True)

# Apply tokenization to the entire dataset
emotion_encoded = emotions.map(tokenize, batched=True, batch_size=None)

# Check new columns
print(emotion_encoded.column_names)

# Now we have:
# - input_ids
# - attention_mask
# - plus original columns

Feature Extraction Function

# Define feature extraction function
def extract_hidden_states(batch):
    # Move inputs to the device
    inputs = {k: v.to(device) for k, v in batch.items()
              if k in tokenizer.model_input_names}

    # Don't calculate gradients
    with torch.no_grad():
        # Get the last hidden state
        last_hidden_state = model(**inputs).last_hidden_state

    # Return the [CLS] token's representation
    return {"hidden_state": last_hidden_state[:,0].cpu().numpy()}

This function extracts the final layer's hidden state for the [CLS] token, which works well for sentence classification.

Processing the Dataset

# Set format to PyTorch tensors
emotion_encoded.set_format("torch",
                          columns=["input_ids", "attention_mask", "label"])

# Extract features from all examples
emotions_hidden = emotion_encoded.map(extract_hidden_states, batched=True)

# Prepare data for scikit-learn
import numpy as np

X_train = np.array(emotions_hidden["train"]["hidden_state"])
X_valid = np.array(emotions_hidden["validation"]["hidden_state"])
y_train = np.array(emotions_hidden["train"]["label"])
y_valid = np.array(emotions_hidden["validation"]["label"])

print(f"Training features shape: {X_train.shape}")
print(f"Validation features shape: {X_valid.shape}")

Confusion Matrix

from sklearn.metrics import ConfusionMatrixDisplay, confusion_matrix
import matplotlib.pyplot as plt

# Define function to plot confusion matrix
def plot_confusion_matrix(y_preds, y_true, labels):
    cm = confusion_matrix(y_true, y_preds, normalize="true")
    fig, ax = plt.subplots(figsize=(10, 10))
    disp = ConfusionMatrixDisplay(confusion_matrix=cm,
                                 display_labels=labels)
    disp.plot(cmap="Blues", values_format=".2f", ax=ax, colorbar=False)
    plt.title("Normalized confusion matrix")
    plt.show()

# Get predictions
y_preds = lr_clf.predict(X_valid)

# Plot confusion matrix
labels = emotions["train"].features["label"].names
plot_confusion_matrix(y_preds, y_valid, labels)

The confusion matrix helps identify which emotions are most often confused with each other.

Additional Metrics

from sklearn.metrics import classification_report

# Generate a detailed classification report
report = classification_report(y_valid, y_preds,
                              target_names=labels)
print(report)

# This report shows precision, recall, and F1-score
# for each emotion class

Loading a Classification Model

from transformers import AutoModelForSequenceClassification
import torch

# Number of classes in our dataset
num_labels = 6  # The 6 emotions

# Load the pre-trained model with a classification head
model_chk = "distilbert-base-uncased"
model = AutoModelForSequenceClassification.from_pretrained(
    model_chk,
    num_labels=num_labels
).to(device)

# This model has the same base as before but with
# an added classification layer on top

Evaluation Metrics

from sklearn.metrics import accuracy_score, f1_score

# Define our evaluation metrics
def compute_metrics(pred):
    labels = pred.label_ids
    preds = pred.predictions.argmax(-1)

    # Calculate accuracy
    acc = accuracy_score(labels, preds)

    # Calculate F1 (weighted average across classes)
    f1 = f1_score(labels, preds, average="weighted")

    return {
        "accuracy": acc,
        "f1": f1
    }

Setting Up the Trainer

from transformers import Trainer, TrainingArguments

# Set training parameters
batch_size = 64
logging_steps = len(emotion_encoded["train"]) // batch_size
model_name = f"{model_chk}-finetuned-emotion"

# Define training arguments
training_args = TrainingArguments(
    output_dir=model_name,
    num_train_epochs=2,
    learning_rate=2e-5,
    per_device_train_batch_size=batch_size,
    per_device_eval_batch_size=batch_size,
    weight_decay=0.01,
    evaluation_strategy="epoch",
    disable_tqdm=False,
    logging_steps=logging_steps,
    push_to_hub=True,
    log_level="error"
)

# Initialize trainer
trainer = Trainer(
    model=model,
    args=training_args,
    compute_metrics=compute_metrics,
    train_dataset=emotion_encoded["train"],
    eval_dataset=emotion_encoded["validation"],
    tokenizer=tokenizer
)

Training the Model

# Start the training process
trainer.train()

# This will:
# 1. Train for the specified number of epochs
# 2. Report metrics after each epoch
# 3. Save checkpoints
# 4. Show a progress bar unless disabled

Detailed Classification Report

from sklearn.metrics import classification_report

# Generate a detailed report
report = classification_report(
    y_valid, y_preds, target_names=labels)
print(report)

# This shows precision, recall, F1 for each emotion class
# Look for classes with lower performance

Error Analysis

# Get the actual texts and analyze errors
validation_texts = emotions["validation"]["text"]
validation_labels = emotions["validation"]["label"]

# Find misclassified examples
errors = []
for i, (pred, true) in enumerate(zip(y_preds, y_valid)):
    if pred != true:
        errors.append({
            "text": validation_texts[i],
            "true": labels[true],
            "predicted": labels[pred]
        })

# Look at the first few errors
for i, error in enumerate(errors[:5]):
    print(f"Example {i+1}:")
    print(f"Text: {error['text']}")
    print(f"True label: {error['true']}")
    print(f"Predicted: {error['predicted']}")
    print("---")

Creating a Model Card

# To create a more detailed model card, you can edit the README.md
# Either directly on the Hugging Face website, or by:

model_card = """
# Emotion Classification Model

This model can detect 6 emotions in text: sadness, joy, love, anger, fear, and surprise.

## Model Description

- Model architecture: DistilBERT (distilbert-base-uncased)
- Fine-tuned on the DAIR.AI Emotion dataset
- Training accuracy: {train_acc:.4f}
- Validation accuracy: {val_acc:.4f}
- F1 score: {f1:.4f}

## Intended Usage

This model is intended for sentiment analysis and emotion detection in English text.

## Limitations

- Only works for English text
- Struggles with sarcasm and ambiguous emotions
- May not perform well on very short texts

## Training procedure

- Trained for 2 epochs
- Learning rate: 2e-5
- Batch size: 64
""".format(train_acc=0.92, val_acc=validation_results['eval_accuracy'],
           f1=validation_results['eval_f1'])

# You can then push this to the hub
# trainer.push_to_hub(commit_message="Update model card", model_card=model_card)

Using Your Model

# Once deployed, anyone can use your model with:
from transformers import pipeline

# Replace YOUR_USERNAME with your actual Hugging Face username
model_name = "YOUR_USERNAME/distilbert-base-uncased-finetuned-emotion"

# Load the model
classifier = pipeline("text-classification", model=model_name)

# Use the model
result = classifier("I'm so excited to see this working!")
print(result)
# [{'label': 'joy', 'score': 0.9874}]