Hugging Face & Open Source Models

Simple Definition:

Hugging Face (HF) is the largest platform for sharing AI models, datasets, and applications. Think of it as GitHub, but specifically for AI/ML. It hosts 800,000+ models, 200,000+ datasets, and 300,000+ demo apps (Spaces).

Just like you go to npm for JavaScript packages or PyPI for Python, you go to Hugging Face Hub for AI models.

What Hugging Face Offers:

• Model Hub: Download any open-source model (LLaMA, Mistral, BERT, Stable Diffusion). Each model has a card with description, usage examples, and benchmarks
• Datasets Hub: Access curated datasets for training and evaluation
• Spaces: Host demo apps (like Gradio or Streamlit) for free. Try models in the browser
• Transformers Library: The most popular Python library for working with AI models
• Inference API: Run models via API without downloading them
• Open LLM Leaderboard: Standardized model benchmarking

Why Hugging Face Matters:

Before HF, using a pre-trained model required reading research papers, finding code on GitHub, converting model formats, and writing custom loading code. HF made it one line of code:

# Before Hugging Face: days of work
# With Hugging Face: one line
from transformers import pipeline
classifier = pipeline("sentiment-analysis")
result = classifier("Swiggy delivery was amazing!")
# [{'label': 'POSITIVE', 'score': 0.9998}]

What is the Transformers Library?

The transformers library by Hugging Face is a Python package that provides unified APIs for thousands of pre-trained models. It supports models for text, vision, audio, and multimodal tasks, with backends for PyTorch, TensorFlow, and JAX.

It is the most downloaded AI library with 100M+ monthly downloads.

Key Abstractions:

• pipeline(): Highest-level API. One line for common tasks - sentiment analysis, text generation, summarization, translation, question answering, image classification
• AutoModel / AutoTokenizer: Automatically loads the correct model class and tokenizer for any model on the Hub. You do not need to know the specific class
• Trainer: High-level training API. Handles training loop, evaluation, checkpointing, distributed training
• PEFT (Parameter-Efficient Fine-Tuning): LoRA and QLoRA for fine-tuning large models with minimal resources

Common Tasks with Transformers:

from transformers import pipeline

# Sentiment Analysis
sentiment = pipeline("sentiment-analysis")
sentiment("The biryani was delicious!")

# Text Generation (using an LLM)
generator = pipeline("text-generation", model="mistralai/Mistral-7B-Instruct-v0.2")
generator("Explain Docker in simple terms:")

# Summarization
summarizer = pipeline("summarization")
summarizer("Long article text here...")

# Translation
translator = pipeline("translation_en_to_hi", model="Helsinki-NLP/opus-mt-en-hi")
translator("How are you?")

# Zero-Shot Classification (no training needed!)
classifier = pipeline("zero-shot-classification")
classifier("Flipkart sale starts tomorrow", candidate_labels=["technology", "shopping", "sports"])

Model Card Anatomy:

Every model on HF Hub has a Model Card (like a README) that tells you:

• Model description: What it does, architecture, training details
• Intended use: What tasks it is designed for
• Limitations: Known weaknesses and biases
• Usage examples: Python code to load and use the model
• Benchmarks: Performance on standard evaluations
• License: Whether you can use it commercially (CRITICAL to check!)

Popular Open-Source Model Families:

How to Choose a Model:

1. Define your task: Text generation? Classification? Embedding? Image?
2. Check size constraints: What hardware do you have? 7B, 13B, or 70B?
3. Check the license: Commercial use allowed? LLaMA 3 allows it, some models do not
4. Read the model card: Benchmarks, intended use, limitations
5. Check downloads and community: More downloads = more battle-tested
6. Look for quantized versions: GGUF format for local running with Ollama/llama.cpp

Use Case 1: Flipkart Review Sentiment Analysis

Use a fine-tuned BERT model to classify product reviews as positive/negative/neutral. Process millions of reviews without API costs.

from transformers import pipeline

# Use a model fine-tuned for sentiment
classifier = pipeline(
    "sentiment-analysis",
    model="nlptown/bert-base-multilingual-uncased-sentiment"
)

reviews = [
    "Product quality is amazing, worth every rupee!",
    "Delivery was late and packaging was damaged",
    "Theek hai, average product at this price"
]

for review in reviews:
    result = classifier(review)
    print(f"{review[:40]}... -> {result[0]['label']}")

Use Case 2: Embeddings for Semantic Search

Use sentence-transformers for building a RAG system or semantic search engine:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("all-MiniLM-L6-v2")

documents = [
    "How to return a product on Flipkart",
    "Flipkart refund policy for damaged items",
    "Track your Flipkart delivery status",
]

# Embed all documents
doc_embeddings = model.encode(documents)

# Embed a user query
query = "I want my money back for broken item"
query_embedding = model.encode(query)

# Find most similar document (cosine similarity)
from sklearn.metrics.pairwise import cosine_similarity
scores = cosine_similarity([query_embedding], doc_embeddings)
best_match = documents[scores.argmax()]
print(f"Best match: {best_match}")
# "Flipkart refund policy for damaged items"

Use Case 3: Running LLMs Locally with Ollama

Ollama downloads GGUF models from HF and runs them locally:

# Install Ollama (one-time)
# macOS: brew install ollama

# Pull and run a model
ollama run mistral

# Or use in Python
import ollama
response = ollama.chat(model="mistral", messages=[
    {"role": "user", "content": "Explain React hooks in simple terms"}
])
print(response["message"]["content"])

Use Case 4: Speech-to-Text with Whisper

Transcribe audio in any language including Hindi:

from transformers import pipeline

transcriber = pipeline(
    "automatic-speech-recognition",
    model="openai/whisper-large-v3"
)

result = transcriber("meeting_recording.mp3")
print(result["text"])
# Works with Hindi, English, Hinglish!

Mistake 1: Ignoring the License

Not all "open" models are truly open. Some have restrictions on commercial use, model size requirements, or require attribution. LLaMA 2 required a Meta license agreement. Some models prohibit use in certain industries. Always read the license card.

Mistake 2: Using the Wrong Model Size

Downloading a 70B model when a fine-tuned 7B would work better for your task. Bigger is not always better - a domain-specific 7B model often outperforms a general 70B on that specific domain.

Mistake 3: Not Using Quantized Models

Downloading FP16 models when GGUF Q4 quantized versions exist. For local use, always check if TheBloke or the official repo has quantized versions. Saves 75% memory with minimal quality loss.

Mistake 4: Skipping the Model Card

The model card contains critical information: intended use, known limitations, training data biases, and correct prompt format. Many models require specific prompt templates (like ChatML or Alpaca format). Using the wrong template produces garbage output.

Mistake 5: Not Considering Inference Infrastructure

Downloading a model is easy. Serving it at production scale is hard. Consider: GPU availability, auto-scaling, batching, caching, monitoring. Tools like vLLM, TGI, or managed services (HF Inference Endpoints, Replicate) handle this complexity.

Q: What is Hugging Face and why is it important for AI development?

Q: How would you choose between using a Hugging Face model vs an API like GPT-4?

Q: What is the Transformers pipeline() and when would you use AutoModel instead?

Q: What should you check on a model card before using an open-source model?

Q: What is LoRA/QLoRA and why does it matter for open-source models?