Hugging Face

graph TD
    A[Hugging Face Ecosystem] --> B[Core Libraries]
    A --> C[Model Hub]
    A --> D[Datasets]
    A --> E[Tools & Services]
    A --> F[Community]

    B --> B1[Transformers]
    B --> B2[Tokenizers]
    B --> B3[Datasets]
    B --> B4[Accelerate]
    B --> B5[PEFT]
    B --> B6[Diffusers]

    C --> C1[Pre-trained Models]
    C --> C2[Model Cards]
    C --> C3[Versioning]
    C --> C4[Fine-tuning]

    D --> D1[Dataset Hub]
    D --> D2[Dataset Processing]
    D --> D3[Dataset Loading]
    D --> D4[Dataset Evaluation]

    E --> E1[Inference API]
    E --> E2[AutoTrain]
    E --> E3[Spaces]
    E --> E4[Endpoints]
    E --> E5[Evaluate]

    F --> F1[Community Models]
    F --> F2[Discussions]
    F --> F3[Documentation]
    F --> F4[Courses]

    style A fill:#FFA500,stroke:#333
    style B fill:#4CAF50,stroke:#333
    style C fill:#2196F3,stroke:#333
    style D fill:#9C27B0,stroke:#333
    style E fill:#FF5722,stroke:#333
    style F fill:#FFC107,stroke:#333

# Basic Hugging Face Transformers example
from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
import torch

# 1. Using pipelines for quick inference
print("Using Hugging Face pipelines...")

# Sentiment analysis pipeline
classifier = pipeline("sentiment-analysis")
result = classifier("I love using Hugging Face Transformers!")
print(f"Sentiment: {result}")

# Text generation pipeline
generator = pipeline("text-generation", model="gpt2")
generated_text = generator("The future of AI is", max_length=50, num_return_sequences=1)
print(f"\nGenerated text: {generated_text[0]['generated_text']}")

# Named entity recognition pipeline
ner = pipeline("ner", grouped_entities=True)
ner_result = ner("Hugging Face was founded in New York and is now based in Paris.")
print(f"\nNamed Entities: {ner_result}")

# 2. Using specific models with tokenizers
print("\nUsing specific models with tokenizers...")

# Load model and tokenizer
model_name = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)

# Tokenize input
inputs = tokenizer("This movie was fantastic!", return_tensors="pt")

# Make prediction
with torch.no_grad():
    outputs = model(**inputs)

# Get prediction
predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
predicted_class = torch.argmax(predictions, dim=-1).item()

print(f"Input: This movie was fantastic!")
print(f"Predicted class: {predicted_class}")
print(f"Confidence: {predictions[0][predicted_class].item():.4f}")
print(f"Model output: {outputs.logits}")

# 3. Text classification with custom inputs
print("\nText classification with custom inputs...")

texts = [
    "I absolutely loved this product!",
    "The service was terrible and slow.",
    "It was okay, nothing special.",
    "This is the best experience I've ever had!",
    "I would not recommend this to anyone."
]

results = classifier(texts)
for text, result in zip(texts, results):
    print(f"Text: {text}")
    print(f"Label: {result['label']}, Score: {result['score']:.4f}")
    print()

# Fine-tuning example with Hugging Face Transformers
from transformers import (
    AutoTokenizer,
    AutoModelForSequenceClassification,
    TrainingArguments,
    Trainer,
    DataCollatorWithPadding
)
from datasets import load_dataset
import numpy as np
from sklearn.metrics import accuracy_score, f1_score

# 1. Load dataset
print("Loading dataset...")
dataset = load_dataset("imdb")
print(f"Dataset structure: {dataset}")
print(f"Train samples: {len(dataset['train'])}")
print(f"Test samples: {len(dataset['test'])}")

# 2. Load tokenizer and tokenize dataset
print("\nLoading tokenizer and tokenizing dataset...")
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)

def tokenize_function(examples):
    return tokenizer(examples["text"], truncation=True, max_length=512)

tokenized_datasets = dataset.map(tokenize_function, batched=True)
print(f"Tokenized dataset features: {tokenized_datasets['train'].features}")

# 3. Prepare training and evaluation datasets
print("\nPreparing training and evaluation datasets...")
tokenized_datasets = tokenized_datasets.remove_columns(["text"])
tokenized_datasets = tokenized_datasets.rename_column("label", "labels")

# Use smaller subset for faster training (in practice, use full dataset)
small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000))
small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(200))

# 4. Load model
print("\nLoading model...")
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# 5. Define metrics function
def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=-1)
    return {
        "accuracy": accuracy_score(labels, predictions),
        "f1": f1_score(labels, predictions, average="weighted")
    }

# 6. Define training arguments
training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    save_strategy="epoch",
    load_best_model_at_end=True,
    metric_for_best_model="accuracy",
    logging_dir="./logs",
    logging_steps=50,
    report_to="none"
)

# 7. Create Trainer
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=small_train_dataset,
    eval_dataset=small_eval_dataset,
    compute_metrics=compute_metrics,
    tokenizer=tokenizer,
    data_collator=data_collator
)

# 8. Train the model
print("\nTraining the model...")
train_result = trainer.train()

# 9. Evaluate the model
print("\nEvaluating the model...")
eval_result = trainer.evaluate()
print(f"Evaluation results: {eval_result}")

# 10. Save the model
print("\nSaving the model...")
trainer.save_model("./fine_tuned_model")
tokenizer.save_pretrained("./fine_tuned_model")

# 11. Make predictions with the fine-tuned model
print("\nMaking predictions with fine-tuned model...")
texts = [
    "This movie was absolutely fantastic! The acting was superb and the plot was engaging.",
    "I hated every minute of this film. The dialogue was terrible and the acting was wooden.",
    "It was okay, not great but not terrible either. Just an average movie experience."
]

# Load fine-tuned model
from transformers import pipeline
classifier = pipeline(
    "text-classification",
    model="./fine_tuned_model",
    tokenizer="./fine_tuned_model"
)

results = classifier(texts)
for text, result in zip(texts, results):
    print(f"Text: {text}")
    print(f"Label: {result['label']}, Score: {result['score']:.4f}")
    print()

# Hugging Face Datasets library example
from datasets import load_dataset, Dataset, DatasetDict
import pandas as pd

print("\nUsing Hugging Face Datasets library...")

# 1. Load a dataset from the Hub
print("\nLoading dataset from Hub...")
dataset = load_dataset("glue", "sst2")
print(f"Dataset type: {type(dataset)}")
print(f"Dataset features: {dataset['train'].features}")
print(f"Train samples: {len(dataset['train'])}")
print(f"Validation samples: {len(dataset['validation'])}")

# 2. Explore the dataset
print("\nExploring the dataset...")
print("\nFirst training sample:")
print(dataset["train"][0])

print("\nFirst validation sample:")
print(dataset["validation"][0])

# 3. Create a pandas DataFrame
print("\nCreating pandas DataFrame...")
df = dataset["train"].to_pandas()
print(f"DataFrame shape: {df.shape}")
print("\nFirst 5 rows:")
print(df.head())

# 4. Filter the dataset
print("\nFiltering the dataset...")
positive_reviews = dataset["train"].filter(lambda example: example["label"] == 1)
print(f"Positive reviews count: {len(positive_reviews)}")

# 5. Map functions to dataset
print("\nMapping functions to dataset...")
def add_text_length(example):
    example["text_length"] = len(example["sentence"])
    return example

dataset_with_length = dataset.map(add_text_length)
print("\nDataset with text length:")
print(dataset_with_length["train"][0])

# 6. Create a new dataset from scratch
print("\nCreating a new dataset from scratch...")
data = {
    "text": [
        "I love this product!",
        "This is terrible.",
        "It's okay, nothing special.",
        "Absolutely fantastic experience!",
        "Would not recommend to anyone."
    ],
    "label": [1, 0, 0, 1, 0]
}

custom_dataset = Dataset.from_dict(data)
print(f"Custom dataset: {custom_dataset}")
print(f"Custom dataset features: {custom_dataset.features}")

# 7. Split dataset
print("\nSplitting dataset...")
split_dataset = custom_dataset.train_test_split(test_size=0.2, seed=42)
print(f"Split dataset: {split_dataset}")

# 8. Save and load dataset
print("\nSaving and loading dataset...")
split_dataset.save_to_disk("./custom_dataset")
loaded_dataset = DatasetDict.load_from_disk("./custom_dataset")
print(f"Loaded dataset: {loaded_dataset}")

# 9. Dataset visualization
print("\nDataset visualization...")
import matplotlib.pyplot as plt

# Plot label distribution
label_counts = df["label"].value_counts().sort_index()
plt.figure(figsize=(8, 5))
label_counts.plot(kind="bar")
plt.title("Label Distribution in SST-2 Dataset")
plt.xlabel("Label (0: Negative, 1: Positive)")
plt.ylabel("Count")
plt.xticks(rotation=0)
plt.show()

# Plot text length distribution
plt.figure(figsize=(8, 5))
df["text_length"] = df["sentence"].apply(len)
df["text_length"].plot(kind="hist", bins=50)
plt.title("Text Length Distribution in SST-2 Dataset")
plt.xlabel("Text Length (characters)")
plt.ylabel("Count")
plt.show()

# Multimodal example with Vision Transformers
from transformers import ViTImageProcessor, ViTForImageClassification
from PIL import Image
import requests
import torch

print("\nMultimodal example with Vision Transformers...")

# 1. Load model and processor
model_name = "google/vit-base-patch16-224"
processor = ViTImageProcessor.from_pretrained(model_name)
model = ViTForImageClassification.from_pretrained(model_name)

# 2. Load and process an image
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
print(f"Image size: {image.size}")

# 3. Process the image
inputs = processor(images=image, return_tensors="pt")

# 4. Make prediction
with torch.no_grad():
    outputs = model(**inputs)

# 5. Get prediction
logits = outputs.logits
predicted_class_idx = logits.argmax(-1).item()
predicted_class = model.config.id2label[predicted_class_idx]

print(f"Predicted class: {predicted_class}")
print(f"Confidence: {torch.nn.functional.softmax(logits, dim=-1)[0][predicted_class_idx].item():.4f}")

# 6. Display image with prediction
plt.figure(figsize=(8, 6))
plt.imshow(image)
plt.title(f"Predicted: {predicted_class}")
plt.axis("off")
plt.show()

# 7. Process multiple images
print("\nProcessing multiple images...")
image_urls = [
    "http://images.cocodataset.org/train2017/000000000009.jpg",  # zebra
    "http://images.cocodataset.org/train2017/000000000025.jpg",  # giraffe
    "http://images.cocodataset.org/train2017/000000000030.jpg",  # cat
    "http://images.cocodataset.org/train2017/000000000034.jpg"   # dog
]

images = [Image.open(requests.get(url, stream=True).raw) for url in image_urls]

# Process all images
inputs = processor(images=images, return_tensors="pt")

# Make predictions
with torch.no_grad():
    outputs = model(**inputs)

# Get predictions
logits = outputs.logits
predicted_class_indices = logits.argmax(-1).tolist()
predicted_classes = [model.config.id2label[idx] for idx in predicted_class_indices]
confidences = [torch.nn.functional.softmax(logits, dim=-1)[i][idx].item()
               for i, idx in enumerate(predicted_class_indices)]

# Display results
for i, (image, predicted_class, confidence) in enumerate(zip(images, predicted_classes, confidences)):
    print(f"Image {i+1}: {predicted_class} (confidence: {confidence:.4f})")

    plt.figure(figsize=(4, 3))
    plt.imshow(image)
    plt.title(f"{predicted_class}\nConfidence: {confidence:.2f}")
    plt.axis("off")
    plt.show()

# Quantization example for faster inference
from transformers import AutoModelForSequenceClassification, AutoTokenizer, pipeline
import torch

print("\nQuantization Example...")

# 1. Load model and tokenizer
model_name = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)

# 2. Quantize model to FP16
print("Quantizing model to FP16...")
model_fp16 = model.half()

# 3. Create pipelines
pipe_fp32 = pipeline("text-classification", model=model, tokenizer=tokenizer)
pipe_fp16 = pipeline("text-classification", model=model_fp16, tokenizer=tokenizer)

# 4. Test inference speed
texts = ["This is a great example!"] * 10

print("\nTesting FP32 inference...")
import time
start_time = time.time()
results_fp32 = pipe_fp32(texts)
fp32_time = time.time() - start_time
print(f"FP32 inference time: {fp32_time:.4f} seconds")

print("\nTesting FP16 inference...")
start_time = time.time()
results_fp16 = pipe_fp16(texts)
fp16_time = time.time() - start_time
print(f"FP16 inference time: {fp16_time:.4f} seconds")

print(f"\nSpeedup: {fp32_time/fp16_time:.2f}x")

# 5. Compare results
print("\nComparing results...")
for i, (result_fp32, result_fp16) in enumerate(zip(results_fp32, results_fp16)):
    print(f"Text {i+1}:")
    print(f"  FP32 - Label: {result_fp32['label']}, Score: {result_fp32['score']:.6f}")
    print(f"  FP16 - Label: {result_fp16['label']}, Score: {result_fp16['score']:.6f}")
    print(f"  Difference: {abs(result_fp32['score'] - result_fp16['score']):.6f}")

# 6. Quantization to INT8 with torch.quantization
print("\nQuantizing model to INT8...")
# Note: This requires specific model architecture support
# Here's a conceptual example

# Prepare model for quantization
model.eval()
model.qconfig = torch.quantization.get_default_qconfig('fbgemm')
model_prepared = torch.quantization.prepare(model)

# Calibrate the model (in practice, use representative dataset)
with torch.no_grad():
    inputs = tokenizer("This is a calibration example", return_tensors="pt")
    model_prepared(**inputs)

# Quantize the model
model_int8 = torch.quantization.convert(model_prepared)

print("Model quantized to INT8 (conceptual example)")

# Distributed training example with Accelerate
from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
from datasets import load_dataset
from accelerate import Accelerator
import torch

print("\nDistributed Training with Accelerate...")

# Initialize accelerator
accelerator = Accelerator()
print(f"Using device: {accelerator.device}")
print(f"Number of processes: {accelerator.num_processes}")

# 1. Load dataset
dataset = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

def tokenize_function(examples):
    return tokenizer(examples["text"], truncation=True, max_length=512)

tokenized_datasets = dataset.map(tokenize_function, batched=True)
tokenized_datasets = tokenized_datasets.remove_columns(["text"])
tokenized_datasets = tokenized_datasets.rename_column("label", "labels")

# Use smaller subset for demonstration
small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000))
small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(200))

# 2. Load model
model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased", num_labels=2)

# 3. Define training arguments
training_args = TrainingArguments(
    output_dir="./accelerate_results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    save_strategy="epoch",
    logging_dir="./accelerate_logs",
    logging_steps=50,
    report_to="none"
)

# 4. Create Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=small_train_dataset,
    eval_dataset=small_eval_dataset,
    tokenizer=tokenizer,
)

# 5. Prepare with accelerator
model, trainer = accelerator.prepare(model, trainer)

# 6. Train the model
print("Training with Accelerate...")
train_result = trainer.train()

# 7. Save the model
print("Saving model...")
accelerator.wait_for_everyone()
unwrapped_model = accelerator.unwrap_model(model)
unwrapped_model.save_pretrained("./accelerate_model", save_function=accelerator.save)

print("Distributed training completed!")