Add HuggingFace Enabling Sessions interactive demo

- Created Gradio app with 3 tabs (Session 1 intro, Session 2 hands-on, Resources)
- Added configuration for 5 NLP tasks (Sentiment, NER, QA, Summarization, Similarity)
- Created utility functions for model inference and tokenization
- Added comprehensive slide content (SESSION1, SESSION2)
- Added sample data and demo examples
- Created speaker notes with detailed presentation guide
- Updated README with full documentation

Features:
- Live inference playground with 5+ NLP tasks
- Interactive tokenization explorer
- Sample data for all demonstrations
- Production-ready configuration
- Attendee-friendly resources tab

README.md

@@ -9,4 +9,213 @@ app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🤗 HuggingFace Enabling Sessions
+**Interactive Demo Platform for Transformers, Hub APIs, and NLP Pipelines**
+
+## 📋 Overview
+
+This is an interactive Gradio application designed for the **HuggingFace Enabling Sessions** workshop. It provides hands-on demonstrations of:
+
+- **Session 1 (45 min):** Introduction to the HuggingFace ecosystem, Transformers architecture, and best practices
+- **Session 2 (90 min):** Hands-on developer workshop with tokenization deep dives and inference playground across 5+ NLP tasks
+
+## 🚀 Quick Start
+
+The app is hosted on HuggingFace Spaces and requires **no local installation**. Simply:
+
+1. Open the Spaces URL
+2. Explore the 3 main tabs:
+   - **Session 1: Introduction** — Embedded slides + live NLP demos
+   - **Session 2: Hands-On Developer** — Tokenizer explorer + inference playground
+   - **Resources & Next Steps** — Documentation links and learning resources
+
+## 📚 Session Contents
+
+### Session 1: Introduction to HuggingFace (45 minutes)
+**Topics Covered:**
+- HuggingFace Platform overview (Hub, Transformers, Datasets, Spaces)
+- Core abstractions: Pipelines, Models, Tokenizers
+- Architecture patterns: Encoders (BERT), Decoders (GPT), Encoder-Decoders (T5/BART)
+- Enterprise NLP landscape (licensing, open-source vs. commercial)
+
+**Live Demos:**
+- Sentiment Analysis using DistilBERT
+- Named Entity Recognition (NER) with BERT
+
+**Materials:** [SESSION1_SLIDES.md](slides/SESSION1_SLIDES.md)
+
+---
+
+### Session 2: Hands-On Developer Workshop (90 minutes)
+**Topics Covered:**
+- Tokenization mechanics and strategies
+- Inference across 5+ NLP tasks
+- Understanding model outputs and confidence scores
+- Production considerations and optimization
+
+**Interactive Tasks:**
+- 🔤 **Tokenization Explorer** — Visualize how text becomes token IDs
+- 📊 **Sentiment Analysis** — Classify text emotions
+- 🏷️ **Named Entity Recognition** — Extract persons, organizations, locations
+- ❓ **Question Answering** — Answer questions from context
+- 📝 **Text Summarization** — Generate concise summaries
+- 🔗 **Semantic Similarity** — Compare text meaning
+
+**Materials:** [SESSION2_SLIDES.md](slides/SESSION2_SLIDES.md)
+
+---
+
+## 🛠️ Project Structure
+
+```
+infy/
+├── app.py                          # Main Gradio application
+├── config.py                       # Configuration (model IDs, task definitions)
+├── utils.py                        # Utility functions for inference
+├── requirements.txt                # Python dependencies
+├── README.md                       # This file
+├── SPEAKER_NOTES.md               # Presenter guide with timing
+├── slides/
+│   ├── SESSION1_SLIDES.md        # Session 1 presentation content
+│   └── SESSION2_SLIDES.md        # Session 2 presentation content
+└── data/
+    ├── sample_texts.csv           # Sample texts for demos
+    └── demo_samples/
+        ├── sentiment.txt
+        ├── ner.txt
+        ├── qa.txt
+        ├── summarization.txt
+        └── embeddings.txt
+```
+
+## 🤖 Models Used
+
+| Task | Model | Type | License |
+|------|-------|------|---------|
+| Sentiment Analysis | distilbert-base-uncased-finetuned-sst-2-english | Encoder | Apache 2.0 |
+| Named Entity Recognition | dslim/bert-base-uncased-finetuned-ner | Encoder | Apache 2.0 |
+| Question Answering | deepset/roberta-base-squad2 | Encoder | Apache 2.0 |
+| Summarization | facebook/bart-large-cnn | Encoder-Decoder | MIT |
+| Semantic Similarity | sentence-transformers/all-MiniLM-L6-v2 | Encoder | Apache 2.0 |
+
+## 📖 How to Use
+
+### During Sessions
+
+1. **Access the Spaces URL** — Attendees join via shared link
+2. **Session 1 (45 min)**
+   - Presenter screens shares and narrates through slides
+   - Live demos showcase "click-to-run" NLP tasks
+   - Q&A after each major section
+
+3. **Session 2 (90 min)**
+   - Presenter guides attendees through tokenization and inference
+   - Attendees observe interactive widgets
+   - Exercise checkpoints for hands-on exploration
+   - Discussion on production considerations
+
+### After Sessions
+
+1. **Clone the repository:**
+   ```bash
+   git clone https://huggingface.co/spaces/[your-username]/infy
+   ```
+
+2. **Install dependencies:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Run locally:**
+   ```bash
+   python app.py
+   ```
+
+4. **Explore further:**
+   - Modify sample data in `data/sample_texts.csv`
+   - Add more models to `config.py`
+   - Create custom tasks in `app.py`
+
+## 🎓 Learning Resources
+
+### Official Documentation
+- [Transformers Library Docs](https://huggingface.co/docs/transformers/)
+- [Datasets Library Docs](https://huggingface.co/docs/datasets/)
+- [HuggingFace Course (Free)](https://huggingface.co/course/)
+- [Hub Documentation](https://huggingface.co/docs/hub/)
+
+### Model Hub
+- Browse 100K+ models: https://huggingface.co/models
+- Search by task, language, or architecture
+
+### Community
+- [HuggingFace Forums](https://discuss.huggingface.co/)
+- [GitHub Issues](https://github.com/huggingface/transformers/issues)
+- Twitter: [@huggingface](https://twitter.com/huggingface)
+
+### Next Steps
+- **Fine-tune on your data** — Adapt pre-trained models for domain-specific tasks
+- **Deploy to Spaces** — Create interactive demos like this
+- **Publish to the Hub** — Share models and datasets with the community
+- **Explore advanced techniques** — Quantization, distillation, multi-model pipelines
+
+## 🔧 Customization
+
+### Add a New Task
+
+1. **Add model to `config.py`:**
+   ```python
+   "new_task": {
+       "name": "Task Name",
+       "model": "model-id-from-hub",
+       "example": "example text",
+   }
+   ```
+
+2. **Add function to `utils.py`:**
+   ```python
+   def run_new_task(text):
+       pipe = load_pipeline("new_task")
+       return pipe(text)
+   ```
+
+3. **Add widget to `app.py`:**
+   ```python
+   with gr.Tab("New Task"):
+       input_box = gr.Textbox()
+       output_box = gr.Markdown()
+       btn.click(run_new_task, inputs=[input_box], outputs=[output_box])
+   ```
+
+### Modify Sample Data
+
+Edit `data/sample_texts.csv` or add `.txt` files to `data/demo_samples/`
+
+## 📝 Environment
+
+- **Python:** 3.8+
+- **Framework:** Gradio 6.9.0
+- **ML:** Transformers, Torch
+- **Hosting:** HuggingFace Spaces
+
+## 📄 License
+
+This project is open-source and available for educational and commercial use. Model licenses vary—see individual model cards for details.
+
+## 👨‍🏫 Presenter Notes
+
+See [SPEAKER_NOTES.md](SPEAKER_NOTES.md) for:
+- Session timing breakdowns
+- Demo sequences and talking points
+- Troubleshooting common issues
+- Tips for live presentations
+
+## 📧 Questions & Feedback
+
+- Ask during the sessions
+- Post on HuggingFace Forums
+- Follow up on company Slack/Teams
+
+---
+
+**Ready to dive into NLP? Start with Session 1: Introduction! 🚀**

SPEAKER_NOTES.md

@@ -0,0 +1,842 @@
+# Speaker Notes & Presentation Guide
+## HuggingFace Enabling Sessions
+
+---
+
+## Table of Contents
+1. [Pre-Session Setup](#pre-session-setup)
+2. [Session 1: Introduction (45 min)](#session-1-introduction-45-min)
+3. [Session 2: Hands-On Developer (90 min)](#session-2-hands-on-developer-90-min)
+4. [Troubleshooting Guide](#troubleshooting-guide)
+5. [Tips for Effective Presentation](#tips-for-effective-presentation)
+
+---
+
+## Pre-Session Setup
+
+### Before You Start
+- ✅ **Test the Spaces app** — Load the URL and verify all widgets work
+- ✅ **Test internet connection** — Ensure model downloads work smoothly
+- ✅ **Download slides** — Have slides available locally (PowerPoint/PDF)
+- ✅ **Prepare talking points** — Familiarize yourself with content
+- ✅ **Set up screen sharing** — Test camera + screen share on your platform
+- ✅ **Time check** — Confirm session durations with organizers
+
+### Spaces URL
+- Share this link with attendees: `https://huggingface.co/spaces/[username]/infy`
+- It's the single platform for entire workshop
+
+### Materials Distribution
+1. **During:** Share Spaces URL in chat/email
+2. **After:** Email attendees:
+   - Spaces link (for reference)
+   - Slide markdown files (`SESSION1_SLIDES.md`, `SESSION2_SLIDES.md`)
+   - GitHub/GitLab link (if you want them to explore code)
+   - Links to HF documentation
+
+### Tech Setup Checklist
+- [ ] Spaces URL loads successfully
+- [ ] All 3 tabs visible (Session 1, Session 2, Resources)
+- [ ] Demo widgets respond to clicks
+- [ ] Screen resolution adequate for showing text (1080p+ recommended)
+- [ ] Audio working (presenter test)
+- [ ] Network stable (no VPN dropouts)
+
+---
+
+## Session 1: Introduction (45 min)
+
+### Overview
+**Goal:** Build foundation understanding of HuggingFace ecosystem  
+**Audience:** Mixed technical levels (devs, product, non-technical)  
+**Format:** Slides + 2 live demos  
+
+### Timing Breakdown
+```
+0:00-0:05   Title + Agenda (5 min)
+0:05-0:15   What is HuggingFace (10 min)
+0:15-0:25   Core Abstractions - Pipelines (10 min)
+             → DEMO 1: Sentiment Analysis
+0:25-0:35   Architecture Patterns (10 min)
+             → Quick review of Encoders/Decoders
+0:35-0:40   Enterprise Landscape (5 min)
+0:40-0:45   Q&A (5 min)
+```
+
+### Talking Points by Section
+
+#### 0:00-0:05 | Title + Agenda
+**What to Say:**
+> "Good morning! Welcome to the HuggingFace Enabling Sessions. Today we're going to explore one of the most exciting toolkits in modern NLP. By the end of this session, you'll understand how transformers work, why they're revolutionary, and how to use them practically."
+
+**Q&A Preparation:**
+- Have answers for: "Do I need to know machine learning?"
+- Response: "No! We start from basics. If you code at all, you'll follow along."
+
+#### 0:05-0:15 | What is HuggingFace (Slide 3-4)
+**Key Message:**
+HuggingFace democratized NLP — took research papers and made them accessible
+
+**Talking Points:**
+1. **The Problem (Pre-2017):**
+   - Great models existed... scattered in papers
+   - Training from scratch was standard
+   - Weeks/months of work per project
+
+2. **The Solution (HuggingFace 2018+):**
+   - Centralized Hub: 100K+ ready-to-use models
+   - One library: `transformers`
+   - One command: `from transformers import pipeline`
+
+3. **Why It Matters:**
+   - NLP went from months → weeks → days
+   - No longer need GPU clusters for basic work
+   - Community benefits from shared knowledge
+
+**Live Example (Don't run yet, just show)**
+```python
+from transformers import pipeline
+classifier = pipeline("sentiment-analysis")
+print(classifier("I love this!"))
+# Output: [{'label': 'POSITIVE', 'score': 0.9987}]
+# That's it! 2 lines of code.
+```
+
+**Talking Point:**
+> "Imagine if you had to train a sentiment classifier from scratch. That would take weeks — data collection, labeling, infrastructure setup, all of it. But with HuggingFace, you get this in 2 lines."
+
+#### 0:15-0:25 | Core Abstractions - Pipelines (Slide 5-7)
+
+**Key Concept:**
+Think of Pipelines like API calls — you don't need to know how the engine works, just what inputs/outputs it expects
+
+**Slide Walkthrough:**
+1. **Pipelines** (Slide 5)
+   - High-level interface
+   - 12+ tasks available
+   - Perfect for demos and quick POCs
+
+2. **Models & Tokenizers** (Slide 6)
+   - Tokenizers: Text → Numbers (tokens)
+   - Models: Process tokens → Predictions
+
+3. **Show the flow:**
+```
+"I love NLP"
+    ↓
+Tokenizer: ["I", "love", "NLP"] → [1045, 2572, 28600]
+    ↓
+Model processes: neural network magic ✨
+    ↓
+Output: Sentiment prediction
+```
+
+**Talking Point for Non-Technical Audience:**
+> "Think of a tokenizer like Rosetta Stone — it translates human language into a format the model understands. Then the model, which has learned patterns from billions of text examples, makes an intelligent prediction."
+
+---
+
+#### **>>> DEMO 1: Sentiment Analysis <<<**
+**Timing:** 5 minutes (embedded in 0:15-0:25 section)
+
+**Setup:**
+- Open Spaces URL
+- Navigate to **Session 1: Introduction** tab
+- Scroll to **Demo 1: Sentiment Analysis**
+
+**Demo Sequence:**
+1. **Show the input box** with pre-filled text: "I absolutely love this product! It's amazing and works perfectly."
+2. **Click "Analyze Sentiment" button**
+3. **Show result:**
+   ```
+   Label: POSITIVE
+   Confidence: 0.9987
+   ```
+4. **Narrate:**
+   > "See? Instant sentiment analysis! The model is 99.87% confident this is positive. That confidence score is critical in production — if it's >90%, we can automate. If it's 60-70%, we might need human review."
+
+5. **Try a second example** (copy-paste into input):
+   ```
+   "This is the worst experience I've ever had with a company."
+   ```
+   - Click button, show result: NEGATIVE (0.9995)
+
+6. **Narrate the difference:**
+   > "Notice both examples have high confidence. But imagine if the sentiment was ambiguous — 'The product is okay.' You might get 55% confidence. That's when you flag it for human review."
+
+**Talking Points:**
+- This model trained on 67K movie reviews
+- Generalizes well to product reviews too
+- Fine-tuned, not trained from scratch
+- Key concept: Transfer learning (pre-training → fine-tuning)
+
+**If Demo Fails:**
+- Say: "Unfortunately, the model server is having a moment. But I can tell you what would happen..."
+- Show cached output screenshot
+- Continue to next section
+
+---
+
+#### 0:25-0:35 | Architecture Patterns (Slide 8-11)
+
+**Objective:** 
+Attendees should leave understanding:
+1. **ENCODERS** (BERT family) — for understanding/classification
+2. **DECODERS** (GPT family) — for generation
+3. **ENCODER-DECODERS** (T5/BART) — for structured tasks
+
+**Presentation Strategy:**
+- Don't go too deep into math
+- Use analogies and comparisons
+- Show the decision tree (Slide 11)
+
+**Slide 8: Encoders (BERT)**
+> "Imagine reading a sentence twice — once left-to-right, once right-to-left, simultaneously. That's bidirectional processing. BERT reads the whole sentence before making decisions. This makes it great for understanding context."
+
+**Example:**
+```
+"The bank approved my loan"
+Read both directions:
+- Left→Right: understand "bank" in financial context
+- Right→Left: understand "approved" is positive
+Decision: POSITIVE sentiment
+```
+
+**Slide 9: Decoders (GPT)**
+> "GPT is like a predictive text machine. Given 'I love...', it predicts the next word. It does this repeatedly to generate entire paragraphs. It only looks backward (at previous words) — it doesn't know what comes next."
+
+**Example:**
+```
+Input:  "Once upon a time..."
+GPT generates: "there was a kingdom far away"
+(word by word, based on learned patterns)
+```
+
+**Slide 10: Encoder-Decoders (T5/BART)**
+> "These combine the best of both worlds. The encoder reads the full input, then passes this understanding to the decoder, which generates output. Perfect for translation, summarization, Q&A."
+
+**Example (Translation):**
+```
+Encoder reads:  "Hello, how are you?"
+Decoder understands intent, generates: "Bonjour, comment allez-vous?"
+```
+
+**Slide 11: Decision Tree**
+> "Here's the rule of thumb: Need to understand/classify? Use BERT. Need to generate text? Use GPT. Need to transform input to output? Use T5."
+
+**Talking Point:**
+> "The beautiful thing about HuggingFace is you don't need to make these distinctions manually. You can just use the Pipeline API. But as engineers, understanding these differences helps us choose the right tool for the job and troubleshoot when things go wrong."
+
+#### 0:35-0:40 | Enterprise Landscape (Slide 12-14)
+
+**Goal:** 
+Attendees understand production considerations
+
+**Key Points:**
+
+**Slide 12: Licensing**
+- Most HF models are open-source (MIT, Apache)
+- Some require special agreements (OpenRAIL)
+- Commercial models available but need API access
+- Always check model card before shipping
+
+**Talking Point:**
+> "In enterprise, we can't just pick a model randomly. We need to ensure licensing is compatible. An MIT-licensed model? Green light. Some proprietary model? Need to check terms first."
+
+**Slide 13: Trade-offs**
+```
+Large Models = Better, Slower
+Small Models = Fast, Okay quality
+
+Example:
+- BERT-large: 95% accuracy, 500ms latency
+- DistilBERT: 94% accuracy, 100ms latency  ← Often the sweet spot
+```
+
+**Talking Point:**
+> "In production, DistilBERT is often the best choice. 40% faster, only 3% less accurate. That's what we call 'Pareto optimal' — you can't get better without significant cost."
+
+**Slide 14: Real-World Example**
+Walk through customer support chatbot pipeline:
+
+1. **Intent Classification** — "What does customer want?"
+2. **Entity Extraction** — "Who, what, when?"
+3. **Knowledge Search** — "Find relevant solutions"
+4. **Response Generation** — "Compose personalized answer"
+
+**Talking Point:**
+> "This is production NLP. Not one model, but orchestrated pipeline of models. Each trained for specific task. Each could be swapped out if performance isn't good enough."
+
+#### 0:40-0:45 | Q&A
+
+**Questions to Anticipate:**
+1. **"Do I need to train models myself?"**
+   - Answer: No! Start with pre-trained. Only fine-tune if needed.
+
+2. **"How do I use this for my company data?"**
+   - Answer: Two paths:
+     - Quick: Use `transformers.pipeline()` on your data
+     - Better: Fine-tune the model on your data (Session 2 mentions this)
+
+3. **"How do I deploy this to production?"**
+   - Answer: We'll touch on this in Session 2 and Resources tab.
+
+4. **"Can I use these models in my mobile app?"**
+   - Answer: Yes, quantized versions fit on phones (DistilBERT ~25MB)
+
+**Transition to Session 2:**
+> "That's Session 1! You now understand WHAT HuggingFace is and WHY it's powerful. Session 2 is all about HOW to use it. We'll dive into tokenization, run live inference on multiple tasks, and explore production considerations. See you in Session 2! ☕ (Break time)"
+
+---
+
+## Session 2: Hands-On Developer (90 min)
+
+### Overview
+**Goal:** Hands-on exploration of 5+ NLP tasks, deep understanding of inference  
+**Audience:** Assumed basic programming knowledge (can read Python)  
+**Format:** Interactive slides + live widgets + discussion  
+
+### Timing Breakdown
+```
+0:00-0:05   Welcome + Recap (5 min)
+0:05-0:20   Tokenization Deep Dive (15 min)
+             → DEMO: Tokenization Explorer
+0:20-1:05   Inference Playground (45 min)
+             → 5 interactive task demos
+             (Sentiment, NER, QA, Summarization, Similarity)
+1:05-1:25   Exercise Checkpoint (20 min)
+             (Attendees explore, ask questions)
+1:25-1:35   Production Considerations (10 min)
+1:35-1:50   Wrap-up + Resources (15 min)
+1:50-2:00   Q&A + Office Hours (10 min)
+```
+
+### Talking Points by Section
+
+#### 0:00-0:05 | Welcome + Recap
+
+**Talking Point:**
+> "Welcome back! In Session 1, we learned about the HuggingFace ecosystem and different model architectures. Today is hands-on. We'll write almost no code — instead, we'll click buttons and see models in action. By the end, you'll understand how inference actually works under the hood."
+
+**Quick Session 1 Recap (1 min):**
+- Pipelines = High-level interface
+- Models = Neural networks trained on specific tasks
+- Transformers = Attention-based architecture
+
+#### 0:05-0:20 | Tokenization Deep Dive (Slide 4-10)
+
+**Core Message:**
+Tokenization bridges human language ↔ machine numbers. It's where "magic" starts.
+
+**Slide 4: What is Tokenization?**
+> "Why does this matter? Because models are mathematics engines. They understand vectors and matrices, not words. Tokenization converts text into vectors. Get tokenization wrong, and the model fails. Get it right, and inference works beautifully."
+
+**Slide 5: Step-by-Step Breakdown**
+
+Walk through example word-by-word:
+```
+Input: "Hello, how are you?"
+
+Step 1: Break into tokens
+["Hello", ",", "how", "are", "you", "?"]
+
+Step 2: Look up IDs (each tokenizer has a vocabulary)
+[7592, 1010, 2129, 2024, 2017, 1029]
+
+Step 3: Add special tokens
+[101, 7592, 1010, 2129, 2024, 2017, 1029, 102]
+ ↑   (CLS token)                              ↑ (SEP token)
+
+Step 4: Create attention mask (1=real, 0=padding)
+[1, 1, 1, 1, 1, 1, 1, 1]
+
+Step 5: Model reads numerical vectors
+[embeddings] → Model processes → [predictions]
+```
+
+**Talking Point:**
+> "Notice the [CLS] and [SEP] tokens at the beginning and end? BERT adds those automatically. They're like punctuation for the model. This is why you don't need to manually add them — the tokenizer does it."
+
+**Slide 6: Tokenization Strategies**
+
+Explain three approaches with examples:
+
+1. **Word-level:** "uncharacteristic" → ["uncharacteristic"]
+   - Problem: New words never seen before = [UNK] (unknown)
+   
+2. **Character-level:** "uncharacteristic" → ["u", "n", "c", "h", "a", "r", ...]
+   - Problem: Sequence too long, hard to learn patterns
+
+3. **Subword (✅ Recommended):** "uncharacteristic" → ["un", "character", "istic"]
+   - Sweet spot! Balances vocabulary size vs. sequence length
+
+**Talking Point:**
+> "Subword tokenization is the Goldilocks solution. Not too many tokens, not too few. And it handles new words gracefully by breaking them into known pieces."
+
+**Slide 7: Common Tokenizers**
+
+Different models use different tokenizers:
+- BERT → WordPiece
+- GPT → BPE (Byte-Pair Encoding)
+- T5 → SentencePiece
+
+**Talking Point:**
+> "Important: If you train a model with one tokenizer, you MUST use the same tokenizer at inference. Mixing tokenizers = garbage outputs. Always load from the same model directory."
+
+---
+
+#### **>>> DEMO: Tokenization Explorer <<<**
+**Timing:** 5 minutes (within 0:05-0:20 section)
+
+**Setup:**
+- Open Spaces URL → **Session 2** tab
+- Scroll to **Part 1: Tokenization Explorer**
+- Input box pre-filled with "Hello, how are you?"
+
+**Demo Sequence:**
+
+1. **Narrate:**
+   > "Let's see what tokenization actually produces. I'll click the tokenize button and we'll see how the text is broken down."
+
+2. **Click "Tokenize" button**
+
+3. **Show output table:**
+   ```
+   Token          Token ID   Attention Mask
+   ────────────────────────────────────────
+   [CLS]          101        1
+   hello          7592       1
+   ,              1010       1
+   how            2129       1
+   are            2024       1
+   you            2017       1
+   ?              1029       1
+   [SEP]          102        1
+   Total: 8 tokens
+   ```
+
+4. **Narrate:**
+   > "Notice each token got a unique ID. [CLS] is 101, 'hello' is 7592. The model learned these associations during pre-training. Attention mask is all 1s because all tokens are real — no padding."
+
+5. **Try a longer example** (paste into input):
+   ```
+   "The Hugging Face transformers library revolutionized NLP by providing easy access to pre-trained models for various tasks."
+   ```
+   - Click "Tokenize"
+   - Show output: ~25 tokens
+
+6. **Narrate:**
+   > "All tokens have attention_mask=1, meaning the model will pay attention to all of them. But if this sentence were part of a batch, and other sequences were shorter, we'd pad this one and set attention_mask=0 for the padding positions. This signals to the model: 'Ignore these fake tokens.'"
+
+**Key Insight to Drive Home:**
+> "This is the foundation. Everything that happens next — classification, generation, Q&A — all relies on this tokenization step being correct. That's why understanding it is so important."
+
+---
+
+#### 0:20-1:05 | Inference Playground (Slide 11-16)
+
+**Setup:**
+- Switch to **Session 2: Hands-On Developer** tab
+- Navigate to **Part 2: Inference Playground**
+- Show the 5 tabs: Sentiment, NER, QA, Summarization, Similarity
+
+**Preamble:**
+> "Now we'll explore 5 different NLP tasks. Each uses a different model, but the flow is similar: Tokenize → Model → Output. Let's see how each one works."
+
+---
+
+#### **Task 1: Sentiment Analysis (Slide 12)**
+
+**Talking Point:**
+> "Sentiment analysis classifies text emotions. This model was fine-tuned on 67K movie reviews. Let's test it."
+
+**Demo:**
+1. Click **Sentiment Analysis** tab
+2. Input box shows: "I absolutely love this product! It's amazing and works perfectly."
+3. Click **Analyze** button
+4. Result: `POSITIVE (0.9987 confidence)`
+
+**Narrate:**
+> "99.87% confident this is positive. That's very high — we can automate decisions at this confidence. Now let's try something ambiguous."
+
+5. **Clear input, paste:**
+   ```
+   "The product is okay but could be better."
+   ```
+   Click **Analyze**
+
+6. Narrate the result:
+   > "Maybe 65% confident? When confidence drops to this range, we should flag for human review. That's how you build production systems — not fully automated, but smart about what to automate."
+
+**Use Case Mention:**
+> "Use cases: Social media monitoring, customer feedback analysis, support ticket triage, review classification."
+
+---
+
+#### **Task 2: Named Entity Recognition (Slide 13)**
+
+**Talking Point:**
+> "NER identifies who, what, where, when in text. This model recognizes persons, organizations, locations, miscellaneous entities."
+
+**Demo:**
+1. Click **Named Entity Recognition** tab
+2. Input: "Apple Inc. was founded by Steve Jobs in Cupertino, California."
+3. Click **Extract Entities** button
+4. Output table shows:
+   ```
+   Entity           Type              Score
+   ────────────────────────────────────────
+   Apple Inc.       Organization      0.99
+   Steve Jobs       Person            0.98
+   Cupertino        Location          0.92
+   California       Location          0.94
+   ```
+
+**Narrate:**
+> "This is incredibly useful. Imagine you have thousands of documents. You can automatically extract company names, people, locations. Then populate a knowledge graph or database. No manual tagging needed."
+
+5. **Try a second example (paste):**
+   ```
+   "Barack Obama served as President of the United States from 2009 to 2017."
+   ```
+   Click **Extract Entities**
+
+6. **Show results, narrate:**
+   > "Barack Obama → Person, United States → Location. The model correctly identifies entities even when it hasn't seen this exact sentence before. That's the power of transfer learning."
+
+**Use Case Mention:**
+> "Resume parsing, contract analysis, information extraction, knowledge base construction."
+
+---
+
+#### **Task 3: Question Answering (Slide 14)**
+
+**Talking Point:**
+> "QA answers questions based on provided context. This model finds the span of text that best answers the question."
+
+**Demo:**
+1. Click **Question Answering** tab
+2. Context: "The Hugging Face Hub is a platform for sharing machine learning models, datasets, and demos. It allows researchers and practitioners to collaborate..."
+3. Question: "What is the Hugging Face Hub?"
+4. Click **Get Answer** button
+5. Output: Answer with confidence score
+
+**Narrate:**
+> "The model scans the context, identifies the most relevant span, and returns it as the answer. Notice it didn't generate new text — it extracted from the provided context. That's what this model does."
+
+6. **Try a different question (paste into question box):**
+   ```
+   Who uses the Hugging Face Hub?
+   ```
+   Click **Get Answer**
+
+7. **Show result, narrate:**
+   > "If the answer isn't explicitly in the context, the model struggles. That's a limitation. For better results, the context needs to contain the answer directly. This is why context construction is critical in production QA systems."
+
+**Use Case Mention:**
+> "FAQ automation, documentation search, support chatbots, knowledge base queries."
+
+---
+
+#### **Task 4: Summarization (Slide 15)**
+
+**Talking Point:**
+> "Summarization generates concise summaries. This uses an abstractive approach — it generates NEW sentences, not just extracting existing ones."
+
+**Demo:**
+1. Click **Text Summarization** tab
+2. Input: "Artificial intelligence has become increasingly important in modern society. Machine learning enables computers to learn from data. Deep learning uses neural networks..."
+   (full text in input box)
+3. Click **Summarize** button
+4. Output: Concise summary (1-2 sentences)
+
+**Narrate:**
+> "The model identified key concepts and generated a new, shorter version. This is harder than extraction — it requires generation. Notice the summary uses different words but preserves meaning. That's abstractive summarization."
+
+5. **Mention parameters:**
+   > "This model has parameters: max_length controls summary length, min_length ensures it's not too short. These are tunable based on your use case."
+
+**Use Case Mention:**
+> "Article summarization, report generation, meeting notes, email digest, news aggregation."
+
+---
+
+#### **Task 5: Semantic Similarity (Slide 16)**
+
+**Talking Point:**
+> "Semantic similarity measures how similar two texts are IN MEANING, not just character overlap."
+
+**Demo:**
+1. Click **Semantic Similarity** tab
+2. Text 1: "The cat is sleeping on the mat"
+3. Text 2: "A feline is resting on the rug"
+4. Click **Compare** button
+5. Output: `Similarity Score: 0.92 (Very Similar!)`
+
+**Narrate:**
+> "These sentences use completely different words. But semantically, they mean almost the same thing. Character-level comparison would say they're different. But this embedding-based model recognizes they're similar. That's semantic understanding."
+
+6. **Try different pairs (paste examples):**
+   - "Machine learning is used for AI tasks" vs "Deep learning uses neural networks"
+   - "I love this product" vs "This product is terrible"
+
+7. **Narrate the pattern:**
+   > "High scores (>0.8) mean very similar meaning. Low scores (<0.3) mean different meanings. Scores around 0.5 mean some relation. You can tune based on your application."
+
+**Use Case Mention:**
+> "Duplicate detection, recommendation systems, plagiarism detection, semantic search, document clustering."
+
+---
+
+#### 1:05-1:25 | Exercise Checkpoint (20 min)
+
+**Talking Point:**
+> "Now it's your turn. I'll guide you through some exercises where you explore these tasks with your own inputs."
+
+**Exercise 1: Sentiment on Different Domains (5 min)**
+> "Go to Sentiment Analysis tab. Try these inputs:
+> - Product review: 'This laptop is fantastic and runs smoothly.'
+> - Restaurant review: 'The food was cold and service was slow.'
+> - Technical feedback: 'This API is poorly documented.'
+> Notice how the model interprets different domains. What confidence levels do you see?"
+
+**Exercise 2: NER on Your Data (5 min)**
+> "Go to NER tab. Paste text about a company or person YOU know. See how well the model extracts entities. What works well? What fails?"
+
+**Exercise 3: QA Troubleshooting (5 min)**
+> "Go to QA tab. Try asking a question that ISN'T answered in the context. What happens? This teaches us about limitations."
+
+**Exercise 4: Creative Experimentation (5 min)**
+> "Mix and match: Run sentiment on a summarized document. Extract entities from QA answers. Try Semantic Similarity on weird pairs. Explore!"
+
+**During Exercise Time:**
+- Monitor chat/questions
+- Help attendees with inputs
+- Highlight interesting results
+- Encourage experimentation
+
+---
+
+#### 1:25-1:35 | Production Considerations (10 min)
+
+**Slide 20: Optimization**
+
+**Talking Point:**
+> "These models are great for prototypes. But in production, we need to optimize."
+
+**Key Tradeoffs:**
+```
+Large Models (BERT-large):
+  ✅ Highest accuracy
+  ❌ Slow (500ms per inference)
+  ❌ High memory (340MB)
+
+Medium Models (BERT-base):
+  ✅ Good accuracy, decent speed
+  ⚠️  Reasonable resources
+
+Small Models (DistilBERT):
+  ✅ Fast (100ms per inference)
+  ✅ Small (33MB), fits on phones
+  ⚠️  Slightly lower accuracy (3-5% drop)
+```
+
+**Talking Point:**
+> "In production, DistilBERT is usually the winner. 40% faster, only 3% less accurate. That 3% might not even matter for your use case. Always measure before deciding!"
+
+**Optimization Techniques:**
+1. **Quantization** — Reduce precision (float32 → int8), gain 4x speedup
+2. **Distillation** — Train smaller model to mimic larger one
+3. **Pruning** — Remove unimportant connections
+4. **Caching** — Store frequent predictions
+
+---
+
+#### 1:35-1:50 | Wrap-up + Next Steps (Slide 23-25)
+
+**Recap (2 min):**
+> "Let's recap. We learned token ization, explored 5 NLP tasks, and discussed production considerations. You now understand the full inference pipeline."
+
+**Key Takeaways (3 min):**
+1. Tokenization is foundational (garbage in = garbage out)
+2. Different models for different tasks (choose wisely)
+3. Confidence scores guide automation decisions
+4. Production requires optimization thinking
+
+**Next Steps (5 min):**
+
+Using slide 23-25 as reference, walk through:
+
+1. **Experiment Post-Session**
+   - Clone the repo locally
+   - Modify `data/sample_texts.csv`
+   - Add new models to `config.py`
+
+2. **Fine-Tune on Your Data**
+   - Take a pre-trained model
+   - Add your labeled data
+   - Fine-tune (takes hours on GPU, not weeks)
+
+3. **Deploy to Spaces**
+   - Fork this repo
+   - Push your changes
+   - Get a shareable URL instantly
+
+4. **Publish to the Hub**
+   - Share your fine-tuned model
+   - Document with model card
+   - Community can use it
+
+**Resources (5 min):**
+Point to Resources tab in Spaces app:
+- Official documentation links
+- Model hub for exploration
+- Learning courses
+- Community forums
+
+**Transition to Q&A:**
+> "That concludes Session 2. Now, questions? This is your time to clarify anything that was unclear."
+
+---
+
+#### 1:50-2:00 | Q&A + Office Hours
+
+**Common Questions & Answers:**
+
+| Q | A |
+|---|---|
+| "How do I fine-tune?" | "Upload your labeled data, use `Trainer` API, takes 1-2 hours. We have tutorials on the Hub." |
+| "Can I use multiple models together?" | "Yes! Build pipelines. E.g., classify intent, then run task-specific model." |
+| "What about non-English?" | "HF has multilingual models (mBERT, XLM-R). Same API, different models." |
+| "How do I handle errors?" | "Log everything, set confidence thresholds, flag low-confidence predictions for review." |
+| "Can I deploy this on my server?" | "Yes! Models are just PyTorch/TF files. Download, load, serve with Flask/FastAPI." |
+| "What about privacy?" | "Models run locally (no data sent to HF). For Spaces like this, note that inputs may be logged." |
+
+**Offer Follow-up:**
+> "If your question needs deeper discussion, let's connect after. I'm available for office hours / one-on-ones. We can dive into your specific use case."
+
+---
+
+## Troubleshooting Guide
+
+### Issue: Model Won't Load
+**Symptom:** "Model is loading..." for >60 seconds, then timeout
+
+**Causes:**
+1. Network issue
+2. Model too large for Spaces RAM
+3. First-time model download
+
+**Solutions:**
+1. Refresh the page
+2. Switch to smaller model (DistilBERT instead of BERT-large)
+3. Pre-download models before session (in `utils.py`)
+
+**Fallback:**
+- Say: "Network hiccup. Let me show you what would happen..."
+- Move to next task
+
+---
+
+### Issue: Inference Takes >10 Seconds
+**Symptom:** Button clicked, waiting...
+
+**Likely Cause:**
+- First inference (loading models to memory)
+
+**Solution:**
+- Pre-warm models at app startup (in `app.py`)
+
+---
+
+### Issue: Widget Doesn't Respond
+**Symptom:** Click button, nothing happens
+
+**Solutions:**
+1. Refresh page
+2. Clear browser cache
+3. Try different browser
+4. Check internet connection
+
+---
+
+### Issue: Attendee Internet Drops
+**During Session:**
+- Locals can still see Spaces (cached)
+- Remote may need to rejoin
+
+**Solution:**
+- Have recording/backup slides ready
+- Provide links to all materials before session
+
+---
+
+## Tips for Effective Presentation
+
+### Before Session
+1. **Dry Run**
+   - Go through slides locally
+   - Test all demos in Spaces
+   - Time each section
+   - Prepare backup slides (PDF)
+
+2. **Prepare Examples**
+   - Have 3-4 good examples per task
+   - Have 1-2 "edge case" examples
+   - Test on provided models beforehand
+
+3. **Communication**
+   - Send Spaces URL 24 hours before
+   - Send agenda
+   - Set expectations (interactive, will show code, not advanced math)
+
+### During Session
+
+1. **Pacing**
+   - Aim for 80% of allocated time (leave buffer for questions)
+   - Session 1: Stay under 40 min to leave 5 min Q&A
+   - Session 2: Finish Wrap-up by 1:35 min to leave time for Q&A
+
+2. **Engagement**
+   - Ask rhetorical questions ("Anyone know what tokenizers do?")
+   - Pause for questions every 5-10 minutes
+   - Read chat actively, respond to questions asynchronously
+
+3. **Demo Tips**
+   - Always narrate what you're doing ("Clicking the button now...")
+   - Point to specific outputs ("Notice the confidence is 0.99...")
+   - Explain failures ("That's interesting — let me try...")
+   - Have patience with load times
+
+4. **Audience Management**
+   - Non-technical folks may feel lost at Tokenization. Say: "This is technical. Don't worry if it's unclear. The key insight is: text becomes numbers."
+   - Advanced folks might ask hard questions later. Note them down, offer office hours.
+
+5. **Interactive Moments**
+   - Polling: "Who's used HF before?" (chat reaction)
+   - Breakout: "Spend 5 min exploring sentiment. Report back a surprising result."
+   - Q&A: "Anyone have a use case they want to explore?"
+
+### Content Delivery
+- **Use analogies** — "Tokenizer is like Rosetta Stone"
+- **Show the code, but don't deep dive** — "Here's what this looks like in Python... notice it's just 3 lines"
+- **Celebrate small wins** — "We went from training models for months to 3 lines of code. That's progress!"
+- **Be honest about limitations** — "QA works best when the answer is explicitly in the context"
+
+### If Technical Issues Occur
+- **Stay calm** — "Let me reconnect..."
+- **Have backups** — Screenshots, recordings, cached outputs
+- **Continue anyway** — "While that loads, let me tell you..."
+- **Learn and iterate** — Document what failed for next time
+
+---
+
+## Final Reminders
+
+- ✅ **Slides are in markdown** — Convert to PDF/PPTX for local presentation if desired
+- ✅ **Models are PUBLIC** — Anyone from the company can access the app
+- ✅ **Spaces auto-updates** — Push to GitHub, it auto-deploys
+- ✅ **Attendees can clone repo** — They can run it locally post-session
+- ✅ **Record if possible** — Share recording with no-shows
+
+**Good luck! 🚀 You've got this!**

app.py

@@ -0,0 +1,587 @@
+"""
+HuggingFace Enabling Sessions - Gradio Interactive Demo App
+Hosted on HuggingFace Spaces
+"""
+
+import gradio as gr
+import config
+import utils
+import pandas as pd
+
+# ===================== UTILITIES =====================
+
+def load_sample_texts():
+    """Load sample texts from CSV."""
+    try:
+        df = pd.read_csv(config.SAMPLE_DATA_CSV)
+        return df
+    except:
+        return None
+
+
+def get_sentiment_examples():
+    """Get example texts for sentiment analysis."""
+    try:
+        with open(f"{config.DEMO_SAMPLES_DIR}/sentiment.txt") as f:
+            lines = f.read().strip().split("\n")
+        return lines
+    except:
+        return config.TASKS["sentiment"]["example"].split()
+
+
+def get_ner_examples():
+    """Get example texts for NER."""
+    try:
+        with open(f"{config.DEMO_SAMPLES_DIR}/ner.txt") as f:
+            lines = f.read().strip().split("\n")
+        return lines
+    except:
+        return [config.TASKS["ner"]["example"]]
+
+
+def get_qa_examples():
+    """Get example context and questions for QA."""
+    try:
+        with open(f"{config.DEMO_SAMPLES_DIR}/qa.txt") as f:
+            contexts = f.read().strip().split("\n\n")
+        return contexts
+    except:
+        return [config.TASKS["qa"]["example_context"]]
+
+
+def get_summarization_examples():
+    """Get example texts for summarization."""
+    try:
+        with open(f"{config.DEMO_SAMPLES_DIR}/summarization.txt") as f:
+            lines = f.read().strip().split("\n")
+        return lines
+    except:
+        return [config.TASKS["summarization"]["example"]]
+
+
+def get_embeddings_examples():
+    """Get example texts for semantic similarity."""
+    try:
+        with open(f"{config.DEMO_SAMPLES_DIR}/embeddings.txt") as f:
+            lines = f.read().strip().split("\n")
+        return lines
+    except:
+        return [config.TASKS["similarity"]["example1"], config.TASKS["similarity"]["example2"]]
+
+
+# ===================== SENTIMENT ANALYSIS =====================
+
+def demo_sentiment(text):
+    """Demo sentiment analysis."""
+    if not text.strip():
+        return "Please enter some text", "No input"
+    result = utils.run_sentiment_analysis(text)
+    output = f"**Label:** {result['label']}\n\n**Confidence:** {result['score']:.4f}"
+    return output, result
+
+
+# ===================== NER =====================
+
+def demo_ner(text):
+    """Demo named entity recognition."""
+    if not text.strip():
+        return "Please enter some text", "No entities"
+    results = utils.run_ner(text)
+    formatted = utils.format_ner_output(results)
+    return formatted, results
+
+
+# ===================== QUESTION ANSWERING =====================
+
+def demo_qa(context, question):
+    """Demo question answering."""
+    if not context.strip() or not question.strip():
+        return "Please enter both context and question", {}
+    result = utils.run_qa(context, question)
+    if "error" in result:
+        return f"Error: {result['error']}", {}
+    output = f"**Answer:** {result['answer']}\n\n**Confidence:** {result['score']:.4f}"
+    return output, result
+
+
+# ===================== SUMMARIZATION =====================
+
+def demo_summarization(text):
+    """Demo text summarization."""
+    if not text.strip():
+        return "Please enter some text", ""
+    if len(text.split()) < 20:
+        return "Text too short for summarization. Please provide at least 20 words.", ""
+    summary = utils.run_summarization(text)
+    return summary, summary
+
+
+# ===================== SEMANTIC SIMILARITY =====================
+
+def demo_similarity(text1, text2):
+    """Demo semantic similarity."""
+    if not text1.strip() or not text2.strip():
+        return "Please enter both texts", 0
+    similarity = utils.compute_similarity(text1, text2)
+    if isinstance(similarity, str):
+        return similarity, 0
+    output = f"**Similarity Score:** {similarity:.4f}\n\n(Score ranges from -1 to 1, where 1 means identical semantically)"
+    return output, similarity
+
+
+# ===================== TOKENIZATION =====================
+
+def demo_tokenization(text):
+    """Demo tokenization."""
+    if not text.strip():
+        return "Please enter some text", ""
+    result = utils.tokenize_text(text)
+    if "error" in result:
+        return f"Error: {result['error']}", ""
+    formatted = utils.format_tokenizer_output(result)
+    return formatted, result
+
+
+# ===================== GRADIO INTERFACE =====================
+
+def create_interface():
+    """Create the Gradio interface with 3 tabs."""
+    
+    with gr.Blocks(
+        title="HuggingFace Enabling Sessions",
+        theme=gr.themes.Soft(),
+    ) as app:
+        gr.Markdown(
+            """
+            # 🤗 HuggingFace Enabling Sessions
+            **Interactive Demo for Transformers, Hub APIs, and Pipeline Abstractions**
+            
+            **Facilitator:** Shouryaan Grish | **Duration:** Session 1: 45 min | Session 2: 90 min
+            """
+        )
+        
+        with gr.Tabs():
+            # ===================== TAB 1: SESSION 1 - INTRODUCTION =====================
+            with gr.Tab("Session 1: Introduction (45 min)", id="session1"):
+                gr.Markdown(
+                    """
+                    ## 🎯 Introduction to Hugging Face Ecosystem
+                    
+                    ### What We'll Cover:
+                    1. **HuggingFace Platform Overview**
+                       - The Hub: Central repository for models, datasets, and spaces
+                       - Transformers Library: Core Python library for NLP
+                       - Model Cards: Documentation and metadata for transparency
+                    
+                    2. **Core Abstractions**
+                       - **Pipelines:** High-level API for common tasks (sentiment, NER, QA, etc.)
+                       - **Models & Tokenizers:** Lower-level building blocks
+                       - **Datasets:** Standardized data loading and processing
+                    
+                    3. **Architecture Patterns**
+                       - **Encoders:** BERT, RoBERTa, DistilBERT → Classification, feature extraction
+                       - **Decoders:** GPT-2, GPT-3 → Text generation
+                       - **Encoder-Decoders:** T5, BART → Seq2seq (translation, summarization, QA)
+                    
+                    4. **Enterprise NLP Landscape**
+                       - Open-source vs. Commercial models
+                       - Licensing considerations (MIT, Apache, OpenRAIL, etc.)
+                       - Fine-tuning for domain-specific tasks
+                    
+                    ---
+                    
+                    ### Live Demo: Explore the Power of Pipelines
+                    
+                    Try the demos below to see how easy it is to use pre-trained models! 👇
+                    """
+                )
+                
+                with gr.Group():
+                    gr.Markdown("### 📊 Demo 1: Sentiment Analysis")
+                    demo1_input = gr.Textbox(
+                        label="Enter text to analyze sentiment",
+                        value="I absolutely love this product!",
+                        lines=2,
+                    )
+                    demo1_btn = gr.Button("Analyze Sentiment", variant="primary")
+                    demo1_output = gr.Markdown(label="Result")
+                    demo1_json = gr.JSON(label="Raw Output", visible=False)
+                    
+                    demo1_btn.click(
+                        demo_sentiment,
+                        inputs=[demo1_input],
+                        outputs=[demo1_output, demo1_json],
+                    )
+                
+                with gr.Group():
+                    gr.Markdown("### 🏷️ Demo 2: Named Entity Recognition (NER)")
+                    demo2_input = gr.Textbox(
+                        label="Enter text for entity recognition",
+                        value="Apple Inc. was founded by Steve Jobs in Cupertino, California.",
+                        lines=2,
+                    )
+                    demo2_btn = gr.Button("Extract Entities", variant="primary")
+                    demo2_output = gr.Markdown(label="Entities Found")
+                    demo2_json = gr.JSON(label="Raw Output", visible=False)
+                    
+                    demo2_btn.click(
+                        demo_ner,
+                        inputs=[demo2_input],
+                        outputs=[demo2_output, demo2_json],
+                    )
+                
+                gr.Markdown(
+                    """
+                    ---
+                    ### 💡 Key Takeaways
+                    - Pre-trained models save time and resources
+                    - HuggingFace Pipelines abstract away complexity
+                    - Models are available for dozens of NLP tasks
+                    - Easy to fine-tune for specialized use cases
+                    
+                    **Next:** Head to Session 2 for hands-on development with Tokenizers and Advanced Inference! 🚀
+                    """
+                )
+            
+            # ===================== TAB 2: SESSION 2 - HANDS-ON DEVELOPER =====================
+            with gr.Tab("Session 2: Hands-On Developer (90 min)", id="session2"):
+                gr.Markdown(
+                    """
+                    ## 👨‍💻 Building End-to-End NLP Workflows with Hugging Face
+                    
+                    ### Agenda:
+                    1. **Tokenization Deep Dive** (15 min)
+                       - Understanding tokenization, token IDs, and attention masks
+                       - How models process text internally
+                    
+                    2. **Inference Playground** (45 min)
+                       - Interactive demos across multiple NLP tasks
+                       - Learn how to use different model architectures
+                       - See real outputs and understand model confidence
+                    
+                    3. **Exercise Checkpoints** (20 min)
+                       - Try your own text inputs
+                       - Experiment with different examples
+                       - Q&A and troubleshooting
+                    
+                    4. **Next Steps & Resources** (10 min)
+                       - Publishing models to the Hub
+                       - Fine-tuning workflow overview
+                       - Post-session project ideas
+                    
+                    ---
+                    
+                    ### 🔤 Part 1: Tokenization Explorer
+                    """
+                )
+                
+                with gr.Group():
+                    gr.Markdown(
+                        """
+                        #### How Tokenization Works
+                        - Text is split into tokens (words/subwords)
+                        - Each token gets a unique ID
+                        - Attention masks indicate which tokens are real vs. padding
+                        - This is how transformers \"understand\" text!
+                        """
+                    )
+                    tok_input = gr.Textbox(
+                        label="Enter text to tokenize",
+                        value="Hello, how are you?",
+                        lines=2,
+                    )
+                    tok_btn = gr.Button("Tokenize", variant="primary")
+                    tok_output = gr.Markdown(label="Tokens")
+                    tok_json = gr.JSON(label="Tokenization Details", visible=False)
+                    
+                    tok_btn.click(
+                        demo_tokenization,
+                        inputs=[tok_input],
+                        outputs=[tok_output, tok_json],
+                    )
+                
+                gr.Markdown(
+                    """
+                    ---
+                    ### 🎯 Part 2: Inference Playground (Choose a Task)
+                    """
+                )
+                
+                with gr.Tabs():
+                    # Task 1: Sentiment
+                    with gr.Tab("Sentiment Analysis"):
+                        gr.Markdown(
+                            """
+                            **Classify text as positive, negative, or neutral**
+                            
+                            Model: DistilBERT fine-tuned on SST-2 dataset
+                            """
+                        )
+                        sent_examples = gr.Examples(
+                            examples=get_sentiment_examples(),
+                            inputs=[],
+                        )
+                        sent_input = gr.Textbox(
+                            label="Enter text",
+                            value=get_sentiment_examples()[0],
+                            lines=3,
+                        )
+                        sent_btn = gr.Button("Analyze", variant="primary")
+                        sent_output = gr.Markdown(label="Result")
+                        sent_json = gr.JSON(label="Details", visible=False)
+                        
+                        sent_btn.click(
+                            demo_sentiment,
+                            inputs=[sent_input],
+                            outputs=[sent_output, sent_json],
+                        )
+                    
+                    # Task 2: NER
+                    with gr.Tab("Named Entity Recognition"):
+                        gr.Markdown(
+                            """
+                            **Identify people, organizations, locations, and more**
+                            
+                            Model: BERT fine-tuned on CoNLL-2003 NER dataset
+                            """
+                        )
+                        ner_examples = gr.Examples(
+                            examples=get_ner_examples(),
+                            inputs=[],
+                        )
+                        ner_input = gr.Textbox(
+                            label="Enter text",
+                            value=get_ner_examples()[0],
+                            lines=3,
+                        )
+                        ner_btn = gr.Button("Extract Entities", variant="primary")
+                        ner_output = gr.Markdown(label="Entities")
+                        ner_json = gr.JSON(label="Details", visible=False)
+                        
+                        ner_btn.click(
+                            demo_ner,
+                            inputs=[ner_input],
+                            outputs=[ner_output, ner_json],
+                        )
+                    
+                    # Task 3: QA
+                    with gr.Tab("Question Answering"):
+                        gr.Markdown(
+                            """
+                            **Answer questions based on provided context**
+                            
+                            Model: RoBERTa fine-tuned on SQuAD 2.0
+                            """
+                        )
+                        qa_examples = get_qa_examples()
+                        qa_context = gr.Textbox(
+                            label="Context/Passage",
+                            value=qa_examples[0] if qa_examples else config.TASKS["qa"]["example_context"],
+                            lines=4,
+                        )
+                        qa_question = gr.Textbox(
+                            label="Question",
+                            value="What is the Hugging Face Hub?",
+                            lines=2,
+                        )
+                        qa_btn = gr.Button("Get Answer", variant="primary")
+                        qa_output = gr.Markdown(label="Answer")
+                        qa_json = gr.JSON(label="Details", visible=False)
+                        
+                        qa_btn.click(
+                            demo_qa,
+                            inputs=[qa_context, qa_question],
+                            outputs=[qa_output, qa_json],
+                        )
+                    
+                    # Task 4: Summarization
+                    with gr.Tab("Text Summarization"):
+                        gr.Markdown(
+                            """
+                            **Generate concise summaries of longer texts**
+                            
+                            Model: BART large fine-tuned on CNN/DailyMail
+                            """
+                        )
+                        sum_examples = get_summarization_examples()
+                        sum_input = gr.Textbox(
+                            label="Text to summarize (min 20 words)",
+                            value=sum_examples[0] if sum_examples else config.TASKS["summarization"]["example"],
+                            lines=5,
+                        )
+                        sum_btn = gr.Button("Summarize", variant="primary")
+                        sum_output = gr.Markdown(label="Summary")
+                        sum_json = gr.JSON(label="Details", visible=False)
+                        
+                        sum_btn.click(
+                            demo_summarization,
+                            inputs=[sum_input],
+                            outputs=[sum_output, sum_json],
+                        )
+                    
+                    # Task 5: Semantic Similarity
+                    with gr.Tab("Semantic Similarity"):
+                        gr.Markdown(
+                            """
+                            **Compare semantic similarity between texts**
+                            
+                            Model: Sentence-BERT (all-MiniLM-L6-v2)
+                            """
+                        )
+                        emb_examples = get_embeddings_examples()
+                        emb_text1 = gr.Textbox(
+                            label="First text",
+                            value=emb_examples[0] if len(emb_examples) > 0 else "The cat is sleeping",
+                            lines=2,
+                        )
+                        emb_text2 = gr.Textbox(
+                            label="Second text",
+                            value=emb_examples[1] if len(emb_examples) > 1 else "A feline is resting",
+                            lines=2,
+                        )
+                        emb_btn = gr.Button("Compare", variant="primary")
+                        emb_output = gr.Markdown(label="Similarity")
+                        emb_json = gr.JSON(label="Details", visible=False)
+                        
+                        emb_btn.click(
+                            demo_similarity,
+                            inputs=[emb_text1, emb_text2],
+                            outputs=[emb_output, emb_json],
+                        )
+                
+                gr.Markdown(
+                    """
+                    ---
+                    ### 🚀 Part 3: Key Concepts Recap
+                    
+                    ✅ **Transformers Architecture:**
+                    - Self-attention mechanisms allow models to focus on relevant parts of text
+                    - Pre-training on large corpora + fine-tuning = transfer learning
+                    
+                    ✅ **Using HuggingFace:**
+                    - Pipelines for quick demos
+                    - Fine-tuning for custom tasks
+                    - Model Hub for sharing and collaboration
+                    
+                    ✅ **Production Considerations:**
+                    - Model size vs. accuracy tradeoff
+                    - Quantization and distillation for faster inference
+                    - Licensing and compliance for models
+                    """
+                )
+            
+            # ===================== TAB 3: RESOURCES =====================
+            with gr.Tab("Resources & Next Steps", id="resources"):
+                gr.Markdown(
+                    """
+                    ## 📚 Learning Resources
+                    
+                    ### Official Documentation
+                    - [Hugging Face Transformers Documentation](https://huggingface.co/docs/transformers/)
+                    - [Hugging Face Datasets Documentation](https://huggingface.co/docs/datasets/)
+                    - [Hugging Face Hub Documentation](https://huggingface.co/docs/hub/)
+                    
+                    ### Tutorials & Courses
+                    - [Hugging Face Course (Free)](https://huggingface.co/course/)
+                    - [Transformers from Scratch](https://huggingface.co/docs/transformers/training)
+                    - [Fine-tuning Guide](https://huggingface.co/docs/transformers/training)
+                    
+                    ---
+                    
+                    ## 🛠️ Popular Models to Explore
+                    
+                    ### Text Classification
+                    - `distilbert-base-uncased-finetuned-sst-2-english` - Sentiment Analysis
+                    - `roberta-base` - General purpose classifier
+                    - `bert-base-multilingual-cased` - Multilingual support
+                    
+                    ### Named Entity Recognition
+                    - `dslim/bert-base-uncased-finetuned-ner` - English NER
+                    - `xlm-roberta-base` - Multilingual NER
+                    
+                    ### Question Answering
+                    - `deepset/roberta-base-squad2` - SQuAD 2.0 fine-tuned
+                    - `bert-large-uncased-whole-word-masking-finetuned-squad` - BERT Large
+                    
+                    ### Text Generation
+                    - `gpt2` - Lightweight generation
+                    - `facebook/bart-large` - Sequence-to-sequence
+                    - `google/t5-base` - T5 for various tasks
+                    
+                    ### Embeddings & Similarity
+                    - `sentence-transformers/all-MiniLM-L6-v2` - Fast & efficient
+                    - `sentence-transformers/all-mpnet-base-v2` - High quality
+                    
+                    ---
+                    
+                    ## 💾 Popular Datasets
+                    
+                    - `glue` - General Language Understanding Evaluation
+                    - `wikitext` - Large language model benchmark
+                    - `squad` - Question answering dataset
+                    - `conll2003` - Named entity recognition
+                    - `imdb` - Sentiment analysis
+                    
+                    ---
+                    
+                    ## 🎯 Next Steps After the Sessions
+                    
+                    ### Beginner Path
+                    1. Explore models on the Hub
+                    2. Try different models on your own data
+                    3. Learn about fine-tuning concepts
+                    
+                    ### Intermediate Path
+                    1. Fine-tune a pre-trained model on your dataset
+                    2. Deploy a model to Spaces (like this demo!)
+                    3. Publish your model to the Hub
+                    
+                    ### Advanced Path
+                    1. Build multi-stage pipelines
+                    2. Implement custom training loops
+                    3. Contribute to open-source projects
+                    
+                    ---
+                    
+                    ## 🔗 Community & Support
+                    
+                    - [Hugging Face Forums](https://discuss.huggingface.co/)
+                    - [GitHub Issues](https://github.com/huggingface/transformers/issues)
+                    - [Twitter/X @huggingface](https://twitter.com/huggingface)
+                    - Company Slack/Teams Channels
+                    
+                    ---
+                    
+                    ## 📝 Session Information
+                    
+                    **Session 1: Introduction to Hugging Face** (45 minutes)
+                    - Overview of the ecosystem
+                    - Core abstractions (Pipelines, Models, Tokenizers)
+                    - Architecture patterns
+                    - Enterprise considerations
+                    
+                    **Session 2: Hands-On Developer Workshop** (90 minutes)
+                    - Tokenization deep dive
+                    - Interactive inference playground (5+ NLP tasks)
+                    - Live coding and experimentation
+                    - Best practices and next steps
+                    
+                    ---
+                    
+                    ### Questions? 
+                    Feel free to reach out via Slack or email during the sessions! 💬
+                    """
+                )
+    
+    return app
+
+
+# ===================== MAIN =====================
+
+if __name__ == "__main__":
+    app = create_interface()
+    app.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+    )

config.py

@@ -0,0 +1,52 @@
+# Configuration for HuggingFace Enabling Sessions
+
+# Models
+SENTIMENT_MODEL = "distilbert-base-uncased-finetuned-sst-2-english"
+NER_MODEL = "dslim/bert-base-uncased-finetuned-ner"
+QA_MODEL = "deepset/roberta-base-squad2"
+SUMMARIZATION_MODEL = "facebook/bart-large-cnn"
+EMBEDDINGS_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+
+# Task definitions
+TASKS = {
+    "sentiment": {
+        "name": "Sentiment Analysis",
+        "description": "Classify text sentiment (positive/negative/neutral)",
+        "model": SENTIMENT_MODEL,
+        "example": "I absolutely love this product! It's amazing and works perfectly.",
+    },
+    "ner": {
+        "name": "Named Entity Recognition",
+        "description": "Identify and classify named entities (Person, Location, Organization)",
+        "model": NER_MODEL,
+        "example": "Apple Inc. was founded by Steve Jobs in Cupertino, California.",
+    },
+    "qa": {
+        "name": "Question Answering",
+        "description": "Answer questions based on provided context",
+        "model": QA_MODEL,
+        "example_context": "The Hugging Face Hub is a platform for sharing machine learning models, datasets, and demos.",
+        "example_question": "What is the Hugging Face Hub?",
+    },
+    "summarization": {
+        "name": "Text Summarization",
+        "description": "Generate concise summaries of longer texts",
+        "model": SUMMARIZATION_MODEL,
+        "example": "The Hugging Face transformers library provides state-of-the-art pre-trained models for natural language processing tasks. It supports PyTorch and TensorFlow, making it easy to use with either framework.",
+    },
+    "similarity": {
+        "name": "Semantic Similarity",
+        "description": "Compare semantic similarity between two sentences",
+        "model": EMBEDDINGS_MODEL,
+        "example1": "The cat is sleeping on the mat",
+        "example2": "A feline is resting on the rug",
+    },
+}
+
+# Sample data paths
+SAMPLE_DATA_CSV = "data/sample_texts.csv"
+DEMO_SAMPLES_DIR = "data/demo_samples"
+
+# Session timings
+SESSION1_DURATION = 45  # minutes
+SESSION2_DURATION = 90  # minutes

data/demo_samples/embeddings.txt

@@ -0,0 +1,6 @@
+The cat is sleeping on the mat
+A feline is resting on the rug
+Machine learning is used for AI tasks
+Deep learning uses neural networks
+Natural language processing handles text
+Computer vision processes images

data/demo_samples/ner.txt

@@ -0,0 +1,5 @@
+Apple Inc. was founded by Steve Jobs in Cupertino, California.
+Barack Obama was the 44th President of the United States.
+Microsoft is headquartered in Redmond, Washington.
+The Eiffel Tower is located in Paris, France.
+Google was founded by Larry Page and Sergey Brin at Stanford University.

data/demo_samples/qa.txt

@@ -0,0 +1,2 @@
+The Hugging Face Hub is a platform for sharing machine learning models, datasets, and demos. It allows researchers and practitioners to collaborate and share their work with the community. The Hub is built on top of Git and provides version control for models and datasets.
+Transformers are neural networks that use self-attention mechanisms to process sequential data. They were introduced in the "Attention is All You Need" paper by Vaswani et al. in 2017. Transformers have become the foundation for most state-of-the-art NLP models today.

data/demo_samples/sentiment.txt

@@ -0,0 +1,5 @@
+I absolutely love this product! It's amazing and works perfectly.
+This is the worst experience I've ever had with a company.
+The movie was decent but could have been better.
+I'm so happy with my purchase!
+This service is terrible and a waste of money.

data/demo_samples/summarization.txt

@@ -0,0 +1 @@
+Artificial intelligence has become increasingly important in modern society. Machine learning, a subset of AI, enables computers to learn from data without being explicitly programmed. Deep learning, which uses neural networks with multiple layers, has revolutionized fields like computer vision and natural language processing. The Hugging Face library has made it easier for developers to access and use pre-trained models for various NLP tasks. These tools have democratized access to powerful AI capabilities, allowing organizations of all sizes to leverage machine learning in their applications.

data/sample_texts.csv

@@ -0,0 +1,12 @@
+text,task,label
+"I absolutely love this product! It's amazing and works perfectly.",sentiment,positive
+"This is the worst experience I've ever had with a company.",sentiment,negative
+"The weather today is nice.",sentiment,neutral
+"The movie was okay, nothing special.",sentiment,neutral
+"I'm so happy with my purchase!",sentiment,positive
+"Apple Inc. was founded by Steve Jobs in Cupertino California.",ner,entities
+"Barack Obama was the 44th President of the United States.",ner,entities
+"Microsoft is headquartered in Redmond Washington.",ner,entities
+"The Hugging Face Hub is a platform for sharing machine learning models.",qa,context
+"The Eiffel Tower is located in Paris France.",ner,entities
+"Google was founded by Larry Page and Sergey Brin at Stanford University.",ner,entities

requirements.txt

@@ -0,0 +1,9 @@
+gradio==6.9.0
+transformers>=4.40.0
+torch>=2.0.0
+datasets>=2.16.0
+numpy>=1.24.0
+pandas>=2.0.0
+scikit-learn>=1.3.0
+tqdm>=4.66.0
+Pillow>=10.0.0

slides/SESSION1_SLIDES.md

@@ -0,0 +1,387 @@
+# Session 1: Introduction to Hugging Face
+## (45 minutes)
+
+---
+
+## Slide 1: Title Slide
+**Introduction to Hugging Face**
+### Building the Future of NLP Together
+
+---
+**Presenter:** Shouryaan Grish  
+**Duration:** 45 minutes  
+**Focus:** HuggingFace Ecosystem, Transformers, and Best Practices
+
+---
+
+## Slide 2: Agenda
+1. **What is Hugging Face?** (5 min)
+2. **Core Abstractions** (10 min)
+   - Pipelines
+   - Models & Tokenizers
+   - Datasets
+3. **Architecture Patterns** (12 min)
+   - Encoders
+   - Decoders
+   - Encoder-Decoders
+4. **Enterprise Landscape** (10 min)
+   - Licensing
+   - Open-source vs Commercial
+5. **Q&A** (8 min)
+
+---
+
+## Slide 3: What is Hugging Face?
+
+### The Mission
+> "Democratizing state-of-the-art Natural Language Processing"
+
+### The Platform
+- **The Hub:** Central repository for 100K+ models, datasets, and applications
+- **Transformers Library:** Python library with pre-trained models
+- **Datasets Library:** Standardized data loading and processing
+- **Spaces:** Deploy interactive demos and applications
+
+### Why It Matters
+- ✅ Pre-trained models save time and resources
+- ✅ Community-driven model sharing
+- ✅ Production-ready inference
+- ✅ Cuts NLP development from months to days
+
+---
+
+## Slide 4: The NLP Transformation
+
+### Pre-Hugging Face Era (2017)
+- Models were scattered across papers and personal repos
+- Training from scratch was standard practice
+- Minimal standardization
+- High barrier to entry
+
+### Post-Hugging Face Era (2018+)
+- Unified Hub for model sharing
+- Pre-trained models ready to use
+- Standardized APIs
+- Democratized access to SOTA models
+
+---
+
+## Slide 5: Core Abstraction #1: Pipelines
+
+### What is a Pipeline?
+A high-level API for common NLP tasks
+
+### Simple Code Example
+```python
+from transformers import pipeline
+
+# 2 lines of code → Production-ready inference
+classifier = pipeline("sentiment-analysis")
+result = classifier("I love this product!")
+# Output: [{'label': 'POSITIVE', 'score': 0.9987}]
+```
+
+### Supported Tasks
+- sentiment-analysis
+- text-classification
+- named-entity-recognition
+- question-answering
+- summarization
+- translation
+- text-generation
+- zero-shot-classification
+
+---
+
+## Slide 6: Core Abstraction #2: Models & Tokenizers
+
+### Tokenizers
+Convert raw text → Token IDs that models understand
+
+### Models
+Neural networks that take token IDs → Predictions
+
+### The Flow
+```
+Text Input
+    ↓
+Tokenizer (breaks into subwords)
+    ↓
+Model (processes tokens)
+    ↓
+Predictions/Embeddings
+```
+
+### Example
+```python
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+model = AutoModelForSequenceClassification.from_pretrained(...)
+
+tokens = tokenizer("Hello world")
+outputs = model(**tokens)
+```
+
+---
+
+## Slide 7: Core Abstraction #3: Datasets
+
+### Why a Standardized Dataset API?
+- Different format hassles (JSON, CSV, Parquet, etc.)
+- Download and caching
+- Consistent preprocessing
+
+### Key Features
+```python
+from datasets import load_dataset
+
+# One line to load any dataset
+dataset = load_dataset("imdb")
+
+# Auto-handles splits, caching, processing
+train_set = dataset["train"]
+val_set = dataset["validation"]
+
+# Easy to preprocess
+def preprocess(examples):
+    return tokenizer(examples["text"])
+
+processed = dataset.map(preprocess, batched=True)
+```
+
+---
+
+## Slide 8: Architecture Pattern #1: Encoders
+
+### BERT (Bidirectional Encoder Representations from Transformers)
+
+```
+Input Text
+    ↓
+Bidirectional Processing (attends to left AND right context)
+    ↓
+Output: Contextualized Embeddings
+```
+
+### Characteristics
+- ✅ Bidirectional context
+- ✅ Great for understanding tasks
+- ✅ Fast inference
+
+### Best For
+- Classification (sentiment, intent, toxicity)
+- Named Entity Recognition
+- Semantic similarity
+- Feature extraction
+
+### Popular Variants
+- BERT-base: 110M parameters
+- **DistilBERT**: 66M parameters, 40% faster, 97% performance
+- **RoBERTa**: Better pre-training, SOTA on many benchmarks
+- **ALBERT**: Lightweight, parameter-shared
+
+---
+
+## Slide 9: Architecture Pattern #2: Decoders
+
+### GPT-2/GPT-3 (Generative Pre-trained Transformer)
+
+```
+Input Tokens
+    ↓
+Unidirectional Processing (attends ONLY to previous tokens)
+    ↓
+Predict Next Token
+    ↓
+Repeat
+```
+
+### Characteristics
+- ✅ Generate fluent text
+- ✅ Few-shot learning capability
+- ✅ Large model = more knowledge
+
+### Best For
+- Text generation
+- Conversational AI
+- Creative writing
+- Code generation
+
+### Trade-offs
+- Slower at inference (generates token-by-token)
+- More memory required
+- Can hallucinate or produce irrelevant content
+
+---
+
+## Slide 10: Architecture Pattern #3: Encoder-Decoders
+
+### T5 / BART (Seq2Seq Models)
+
+```
+Input Text (Encoder)
+    ↓
+Attention between Encoder & Decoder
+    ↓
+Output Text (Decoder)
+```
+
+### Characteristics
+- ✅ Combines encoder AND decoder strengths
+- ✅ Flexible input/output handling
+- ✅ Great for structured tasks
+
+### Best For
+- Machine translation
+- Summarization
+- Question answering
+- Paraphrase generation
+- Style transfer
+
+### Example Tasks
+```
+Input:  "Summarize: The AI era has transformed industries..."
+Output: "AI is transforming industries worldwide."
+
+Input:  "Translate to French: Hello world"
+Output: "Bonjour le monde"
+```
+
+---
+
+## Slide 11: Choosing the Right Architecture
+
+| Task | Best Architecture | Example Model |
+|------|------------------|---|
+| Classification | Encoder | BERT, RoBERTa |
+| Named Entities | Encoder | BERT-NER |
+| Question Answering | Encoder-Decoder | RoBERTa-SQuAD |
+| Text Generation | Decoder | GPT-2 |
+| Summarization | Encoder-Decoder | BART, T5 |
+| Semantic Similarity | Encoder | Sentence-BERT |
+| Machine Translation | Encoder-Decoder | MarianMT |
+
+---
+
+## Slide 12: Enterprise Landscape
+
+### Open-Source Models
+- Free, transparent, modifiable
+- No licensing restrictions (usually)
+- Community support
+- Examples: BERT, RoBERTa, GPT-2
+
+### Commercial Models
+- Licensing required (sometimes)
+- Vendor support
+- Proprietary optimizations
+- Examples: GPT-4, Claude, PaLM
+
+### Licensing Types
+- **MIT/Apache:** Fully permissive
+- **OpenRAIL:** Open Responsible AI License (middle ground)
+- **Proprietary:** Restricted use (API access only)
+
+---
+
+## Slide 13: Considerations for Production
+
+### Performance vs. Speed Trade-off
+```
+Performance (Accuracy)
+         ↑
+         |  Large Models
+         |  (BERT-large)
+         |
+         |  Medium Models
+         |  (RoBERTa-base)
+         |
+         |  Small Models
+         |  (DistilBERT)
+    ─────┼──────────────→ Speed
+```
+
+### Optimization Techniques
+- **Quantization:** Reduce model size by 4x
+- **Distillation:** Train smaller model to mimic larger one
+- **Pruning:** Remove less important connections
+- **Caching:** Store frequent predictions
+
+---
+
+## Slide 14: Real-World Example Flow
+
+### Workflow: Building a Customer Support Chatbot
+
+1. **Classify Intent** (What does the customer want?)
+   - Model: BERT for intent classification
+   - Output: bug_report, billing_question, feature_request
+
+2. **Extract Entities** (Who, what, when?)
+   - Model: NER model
+   - Output: customer_id, product_name, date
+
+3. **Search Knowledge Base** (Find relevant docs)
+   - Model: Semantic similarity with SBERT
+   - Output: Top matching solutions
+
+4. **Generate Response** (Compose answer)
+   - Model: T5 or GPT-2
+   - Output: Customer-tailored response
+
+---
+
+## Slide 15: Key Takeaways
+
+### ✅ Main Lessons
+1. **HuggingFace democratizes NLP**
+   - Pre-trained models, no need to train from scratch
+   
+2. **Pipelines make NLP accessible**
+   - Complex tasks in 2-3 lines of Python
+   
+3. **Choose the right architecture**
+   - Encoders for understanding, Decoders for generation, Encoder-Decoders for structured tasks
+   
+4. **Production requires thoughtfulness**
+   - Consider licensing, performance, and trade-offs
+   
+5. **The community is your resource**
+   - 100K+ models ready to use on the Hub
+
+### 🚀 Next Steps
+- **Session 2:** Hands-on development and advanced techniques
+- **Post-Session:** Experiment with your own data and models
+
+---
+
+## Slide 16: Q&A
+
+**Questions?**
+
+We'll cover more technical details in Session 2, including:
+- Tokenization mechanics
+- Fine-tuning your own models
+- Deploying to production with Spaces
+- Publishing to the Hub
+
+---
+
+## Slide 17: Bonus: Resource Links
+
+### Documentation
+- https://huggingface.co/docs/transformers/
+- https://huggingface.co/docs/datasets/
+- https://huggingface.co/course/
+
+### Model Hub
+- https://huggingface.co/models
+
+### Try It Out
+- This very demo: Spaces app with live inference
+
+---
+
+## Session 1 Complete! 🎉
+**Next: Session 2 - Hands-On Developer Workshop (90 min)**

slides/SESSION2_SLIDES.md

@@ -0,0 +1,731 @@
+# Session 2: Hands-On Developer Workshop
+## Building End-to-End NLP Workflows with Hugging Face
+### (90 minutes)
+
+---
+
+## Slide 1: Title Slide
+**Hands-On Developer Workshop**
+### Building End-to-End NLP Workflows with HuggingFace
+
+**Duration:** 90 minutes  
+**Format:** Interactive coding + Demos + Exercises  
+**Difficulty:** Intermediate
+
+---
+
+## Slide 2: Session Agenda (90 min)
+
+1. **Tokenization Deep Dive** (15 min)
+   - How tokenizers work
+   - Tokenization process breakdown
+   - Interactive explorer
+   
+2. **Inference Playground** (45 min)
+   - Live demos across 5+ NLP tasks
+   - Understanding model outputs
+   - Confidence scores and interpretability
+
+3. **Exercise Checkpoint** (20 min)
+   - Try your own examples
+   - Experiment with different inputs
+   - Troubleshooting guide
+
+4. **Wrap-Up & Next Steps** (10 min)
+   - Publishing to the Hub
+   - Fine-tuning overview
+   - Post-session resources
+
+---
+
+## Slide 3: Review: Session 1 Recap
+
+### We Learned:
+✅ HuggingFace Platform Overview  
+✅ Pipelines - high-level API  
+✅ Encoders, Decoders, Encoder-Decoders  
+✅ Architecture selection guide  
+
+### Now We'll Learn:
+🔬 **HOW things work under the hood**  
+👨‍💻 **Hands-on implementation**  
+⚙️ **Production considerations**
+
+---
+
+## Slide 4: Part 1 - Tokenization Deep Dive
+
+### What is Tokenization?
+Converting raw text → Numerical representations that models understand
+
+### Why Does This Matter?
+- Models don't understand words, only numbers
+- Tokenization decisions affect model performance
+- Different tokenizers produce different results
+
+---
+
+## Slide 5: Tokenization Step-by-Step
+
+### Example Input
+```
+"Hello, how are you?"
+```
+
+### Step 1: Split into tokens (subwords)
+```
+["Hello", ",", "how", "are", "you", "?"]
+```
+
+### Step 2: Convert to IDs
+```
+[7592, 1010, 2129, 2024, 2017, 1029]
+```
+
+### Step 3: Add attention masks (1 = real token, 0 = padding)
+```
+[1, 1, 1, 1, 1, 1]
+```
+
+### Step 4: Model processes
+```
+Input: [7592, 1010, 2129, 2024, 2017, 1029]
+Output: [logits, embeddings, predictions]
+```
+
+---
+
+## Slide 6: Tokenization Strategies
+
+### 1. Word-level Tokenization
+**Split on spaces and punctuation**
+```
+"I love NLP" → ["I", "love", "NLP"]
+```
+❌ Problem: Infinite vocabulary (new words = unknown tokens)
+
+### 2. Character-level Tokenization
+**Split character by character**
+```
+"NLP" → ["N", "L", "P"]
+```
+❌ Problem: Too many tokens, harder to learn patterns
+
+### 3. Subword Tokenization (RECOMMENDED) ✅
+**Smart splitting into frequently-seen sequences**
+```
+"uncharacteristic" → ["un", "character", "istic"]
+new_word → ["new", "_word"]  (special token for space)
+```
+✅ Balance between vocabulary size and sequence length
+
+---
+
+## Slide 7: Common Tokenizers
+
+| Tokenizer | Used By | Strategy |
+|-----------|---------|----------|
+| WordPiece | BERT | Greedy merge frequent pairs |
+| BPE | GPT-2, RoBERTa | Byte-Pair Encoding |
+| SentencePiece | T5, XLNet | Language-agnostic |
+| Unigram | ALBERT | Probabilistic |
+
+### Key Insight
+Different tokenizers may produce different tokens for the same input!
+
+---
+
+## Slide 8: Tokenization in Practice
+
+### Code Example
+```python
+from transformers import AutoTokenizer
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+
+text = "I love Hugging Face!"
+
+# Tokenize
+tokens = tokenizer(text)
+# Output: {
+#   'input_ids': [101, 1045, 2572, 23604, 2469, 999, 102],
+#   'token_type_ids': [0, 0, 0, 0, 0, 0, 0],
+#   'attention_mask': [1, 1, 1, 1, 1, 1, 1]
+# }
+
+# Convert back to tokens
+token_strings = tokenizer.convert_ids_to_tokens(tokens['input_ids'])
+# Output: ['[CLS]', 'i', 'love', 'hugging', 'face', '!', '[SEP]']
+```
+
+### Special Tokens
+- `[CLS]` = Classification token (beginning)
+- `[SEP]` = Separator (between sentences)
+- `[PAD]` = Padding (for shorter sequences)
+- `[UNK]` = Unknown token (unseen words)
+- `[MASK]` = Masked token (for BERT pre-training)
+
+---
+
+## Slide 9: Attention Masks
+
+### Why Attention Masks?
+Models process batches of text. Different sequences have different lengths.
+Need to mark which tokens are "real" vs "padding"
+
+### Example
+```
+Sentence 1: "I love NLP" (5 tokens)
+Sentence 2: "Hello"      (2 tokens)
+
+After padding to length 5:
+Sequence 1: [I, love, NLP, [PAD], [PAD]]
+Sequence 2: [Hello, [PAD], [PAD], [PAD], [PAD]]
+
+Attention Masks:
+Sequence 1: [1, 1, 1, 0, 0]  ← Ignore these
+Sequence 2: [1, 0, 0, 0, 0]  ← Ignore these
+
+Model learns: "When attention_mask=0, ignore this token"
+```
+
+---
+
+## Slide 10: Token Limitations
+
+### Max Sequence Length
+Different models have different token limits!
+
+| Model | Max Tokens | Max Characters (approx) |
+|-------|-----------|--------------------------|
+| BERT | 512 | 2048 |
+| GPT-2 | 1024 | 4096 |
+| RoBERTa | 512 | 2048 |
+| LongFormer | 4096 | 16384 |
+| T5 | 512 | 2048 |
+
+### What happens when text is too long?
+```python
+# Option 1: Truncation
+tokens = tokenizer(long_text, max_length=512, truncation=True)
+
+# Option 2: Split document into chunks
+chunks = [text[i:i+2000] for i in range(0, len(text), 2000)]
+```
+
+---
+
+## Slide 11: Part 2 - Inference Playground
+
+### Now let's RUN models on real text!
+
+### We'll Explore 5 NLP Tasks:
+1. **Sentiment Analysis** - Classify emotions
+2. **Named Entity Recognition** - Extract entities
+3. **Question Answering** - Answer from context
+4. **Summarization** - Generate summaries
+5. **Semantic Similarity** - Compare meaning
+
+---
+
+## Slide 12: Task 1 - Sentiment Analysis
+
+## How It Works
+```
+Input: "I love this product!"
+Model: DistilBERT (fine-tuned on SST-2)
+Process:
+  1. Tokenize →  [101, 1045, 2572, ...]
+  2. Feed to BERT →  [embeddings]
+  3. Classification head → [logits]
+  4. Softmax → [0.9987, 0.0013]
+
+Output: POSITIVE (99.87% confidence)
+```
+
+### Use Cases
+- Customer feedback analysis
+- Social media monitoring
+- Review classification
+- Support ticket triage
+
+### Demo Time! 🎬
+Check the Inference Playground tab
+
+---
+
+## Slide 13: Task 2 - Named Entity Recognition
+
+### How It Works
+```
+Input: "Apple Inc. was founded by Steve Jobs"
+
+Process:
+  1. Tokenize → ["Apple", "Inc", ".", "was", ...]
+  2. Classify each token:
+     - "Apple" → Organization
+     - "Inc" → Organization
+     - "Steve" → Person
+     - "Jobs" → Person
+
+Output: 
+  Apple Inc. [ORG]
+  Steve Jobs [PER]
+```
+
+### Use Cases
+- Resume parsing
+- Information extraction
+- Knowledge base construction
+- Data mining from documents
+
+### Aggregation Strategies
+```
+Token-level:   ["Apple", "Inc"] separately
+Simple:        Keep adjacent same entities
+Aggregated:    Combine subwords into words
+```
+
+---
+
+## Slide 14: Task 3 - Question Answering
+
+### How It Works
+```
+Context: "The Eiffel Tower is in Paris, France."
+Question: "Where is the Eiffel Tower?"
+
+Process:
+  1. Tokenize both
+  2. Encode context + question pairs
+  3. Model predicts START and END positions
+  4. Extract text span
+
+Output: "Paris, France"
+```
+
+### Model Architecture
+Uses SQuAD fine-tuned model (Question Answering dataset)
+
+### Use Cases
+- FAQ systems
+- Document search
+- Customer support automation
+- Knowledge base queries
+
+### Limitations
+- Must have answer in provided context
+- Works best with structured context
+- Answer must be continuous span
+
+---
+
+## Slide 15: Task 4 - Summarization
+
+## How It Works
+```
+Input: "The Hugging Face transformers library provides..."
+
+Process:
+  1. Encode full input
+  2. Use attention to identify key sentences
+  3. Generate summary with decoder
+  4. Stop at max_length
+
+Output: "Hugging Face offers access to pre-trained..."
+```
+
+### Abstractive vs Extractive
+```
+Abstractive (our model uses this):
+  - Generate NEW sentences
+  - More fluent, may hallucinate
+
+Extractive:
+  - Select existing sentences
+  - More faithful, but choppy
+```
+
+### Parameters
+- `max_length`: Maximum summary length
+- `min_length`: Minimum summary length
+- `num_beams`: Quality vs speed trade-off
+
+### Use Cases
+- Article summarization
+- Report generation
+- Meeting notes
+- Long document processing
+
+---
+
+## Slide 16: Task 5 - Semantic Similarity
+
+## How It Works
+```
+Sentence 1: "The cat is sleeping on the mat"
+Sentence 2: "A feline is resting on the rug"
+
+Process:
+  1. Encode sentence 1 → [embedding vector: 384-dimensional]
+  2. Encode sentence 2 → [embedding vector: 384-dimensional]
+  3. Calculate cosine similarity
+  4. Score: -1 to 1 (1 = identical meaning)
+
+Output: Similarity = 0.92 (Very Similar!)
+```
+
+### Model: Sentence-BERT
+- Optimized for semantic meaning
+- Much faster than full transformers
+- Maintains meaning representation
+
+### Use Cases
+- Duplicate detection
+- Recommendation systems
+- Plagiarism detection
+- Document clustering
+- Semantic search
+
+### Similarity Scores
+```
+1.0  = Identical meaning
+0.8+ = Very similar
+0.6+ = Similar
+0.4+ = Somewhat related
+0.0  = No relation
+```
+
+---
+
+## Slide 17: Understanding Model Outputs
+
+### Confidence Scores Matter!
+```
+Sentiment: "I like this movie"
+Output: POSITIVE (0.78 confidence)
+
+Should I trust this? 
+- 78% is decent, but not super high
+- Might want manual review for this one
+
+vs.
+
+Output: POSITIVE (0.98 confidence)
+- Very high confidence, safer to automate
+```
+
+### Decision Rules
+```
+High confidence (>0.90):     Automate with confidence
+Medium confidence (0.70-0.90): Automate with logging
+Low confidence (<0.70):       Flag for review
+```
+
+---
+
+## Slide 18: Part 3 - Exercise Checkpoint
+
+### Your Turn! 🎯
+
+### Challenge 1: Sentiment Analysis
+Try different types of text:
+- Product reviews
+- Social media posts
+- Technical feedback
+- Sarcasm ("Yeah, GREAT idea!")
+
+### Challenge 2: NER
+Test with:
+- Different domains (sports, business, medicine)
+- Multiple languages
+- Misspellings or slang
+
+### Challenge 3: QA
+Build a simple FAQ system:
+- Create a knowledge base document
+- Ask different questions
+- See how model performs
+
+### Challenge 4: Creative Exploration
+Mix and match:
+- Run sentiment on generated summaries
+- Extract entities from question answers
+- Create a pipeline!
+
+---
+
+## Slide 19: Troubleshooting Guide
+
+### Common Issues & Solutions
+
+#### Issue 1: Text Too Long
+```
+Error: Input sequence too long
+
+Solution:
+  option1 = tokenizer(text, max_length=512, truncation=True)
+  # Text is trimmed to first 512 tokens
+  
+  option2 = [text[i:i+2000] for i in range(0, len(text), 2000)]
+  # Process in chunks, combine results
+```
+
+#### Issue 2: Unexpected Results
+```
+Input: "This is NOT good!"
+Output: POSITIVE (but we wanted NEGATIVE)
+
+Cause: Models may miss negation
+
+Solution:
+  - Model is sensitive to specific words/context
+  - Try different phrasing
+  - Consider fine-tuning on domain data
+  - Use ensemble of models
+```
+
+#### Issue 3: Slow Inference
+```
+Cause: Large model + slow hardware
+
+Solutions:
+  - Use DistilBERT instead of BERT (40% faster)
+  - Enable quantization
+  - Use GPU/TPU
+  - Batch process multiple inputs
+```
+
+---
+
+## Slide 20: Production Considerations
+
+### Performance vs Speed
+```
+DistilBERT:  Fast, 97% of BERT performance ✅
+BERT-base:   Good balance
+BERT-large:  Slower, best quality
+```
+
+### Optimization Techniques
+```
+1. Quantization:  Model size ↓ 4x, speed ↑ 2-3x
+2. Distillation:  Train smaller model, keep quality
+3. Pruning:       Remove redundant parameters
+4. Caching:       Store frequent predictions
+5. Batching:      Process multiple inputs together
+```
+
+### Monitoring & Logging
+```
+- Track model confidence
+- Log failures/edge cases
+- Monitor latency
+- User feedback loop
+```
+
+---
+
+## Slide 21: Publishing to the Hub
+
+### 3-Step Process
+
+#### Step 1: Create Model Card
+```markdown
+# Model Name
+Description of what model does
+
+## Usage
+```python
+from transformers import pipeline
+classifier = pipeline("sentiment-analysis", 
+                      model="your-username/model-name")
+```
+
+## Training Data
+Trained on [dataset]
+
+## Performance
+Accuracy: X%, F1: Y%
+```
+
+#### Step 2: Upload
+```python
+from transformers import AutoModelForSequenceClassification
+from huggingface_hub import push_to_hub_or_create_repo
+
+model = AutoModelForSequenceClassification.from_pretrained(...)
+model.push_to_hub("your-username/model-name")
+```
+
+#### Step 3: Share
+```
+https://huggingface.co/your-username/model-name
+```
+
+---
+
+## Slide 22: Fine-Tuning Overview
+
+### When to Fine-Tune
+```
+New Task ← Need Fine-Tuning → Different Domain/Language
+↓                                    ↓
+Legal documents                  Medical texts
+vs BERT trained on Wikipedia    vs General BERT
+```
+
+### Fine-Tuning Process
+```
+1. Load pre-trained model
+2. Add task-specific head
+3. Train on your data (small learning rate!)
+4. Evaluate and iterate
+5. Deploy!
+```
+
+### Example: Custom Sentiment
+```python
+from transformers import AutoModelForSequenceClassification, Trainer
+
+model = AutoModelForSequenceClassification.from_pretrained(
+    "bert-base-uncased", 
+    num_labels=2
+)
+# Load YOUR labeled data
+train_dataset = load_my_data("path/to/data.csv")
+
+trainer = Trainer(
+    model=model,
+    train_dataset=train_dataset,
+    learning_rate=2e-5,  # Small learning rate!
+)
+trainer.train()
+```
+
+---
+
+## Slide 23: Real-World Pipeline Example
+
+### Build a Document Classifier + Summarizer
+
+```
+Raw Document
+    ↓
+[1] Tokenize
+    ↓
+[2] Classify Intent
+    ├─ Legal: Route to legal team
+    ├─ Finance: Route to finance team
+    └─ Tech: Route to tech team
+    ↓
+[3] Extract Entities (contract dates, amounts, parties)
+    ↓
+[4] Summarize (generate executive summary)
+    ↓
+[5] Store (vector DB for search)
+    ↓
+Output: Classified, Summarized, Searchable
+```
+
+### Code Pattern
+```python
+# Each step reusable, composable
+classifier_pipe = pipeline("zero-shot-classification")
+ner_pipe = pipeline("ner")
+summarizer_pipe = pipeline("summarization")
+
+def process_document(doc):
+    intent = classifier_pipe(doc, ["legal", "finance", "tech"])
+    entities = ner_pipe(doc)
+    summary = summarizer_pipe(doc, max_length=100)
+    
+    return {
+        "intent": intent,
+        "entities": entities,
+        "summary": summary
+    }
+```
+
+---
+
+## Slide 24: Key Takeaways (Session 2)
+
+### 🔬 Technical Deep Dive
+1. **Tokenization is foundational**
+   - Text → Numerical representations
+   - Different tokenizers, different results
+   - Handles special tokens and attention masks
+
+2. **Inference is flexible**
+   - 5 different task categories
+   - Models = transformers + task-specific heads
+   - Confidence scores guide automation decisions
+
+3. **Production requires engineering**
+   - Monitor, log, optimize
+   - Consider performance/speed tradeoffs
+   - Fine-tune for domain-specific needs
+
+### 🚀 Next Steps
+1. Experiment with your own data
+2. Publish a model to the Hub
+3. Fine-tune for your use case
+4. Deploy to Spaces (like this app!)
+
+---
+
+## Slide 25: Resources & Links
+
+### Official Documentation
+- https://huggingface.co/docs/transformers/
+- https://huggingface.co/docs/datasets/
+- https://huggingface.co/course/
+
+### Explore Models
+- https://huggingface.co/models
+
+### Build & Deploy
+- https://huggingface.co/spaces (Deploy Gradio apps)
+- Hugging Face Hub API for uploading
+
+### Community
+- https://discuss.huggingface.co/
+- GitHub Issues
+- Community Discord
+
+---
+
+## Slide 26: Q&A & Open Discussion
+
+### Questions We Can Answer
+- How do I fine-tune for my specific domain?
+- What model should I use for X task?
+- How do I deploy to production?
+- How do I handle multiple languages?
+- What about multilingual models?
+
+### Further Learning
+- We have Session materials on the Hub
+- Code examples in the Spaces app
+- Documentation links in Resources tab
+
+---
+
+## Session 2 Complete! 🎉
+
+### You Now Know:
+✅ How tokenization works  
+✅ How to run inference on 5+ NLP tasks  
+✅ How to interpret model outputs  
+✅ How to publish and deploy models  
+✅ How to think about fine-tuning and optimization  
+
+### Keep Learning!
+The NLP field is rapidly evolving. Stay updated with:
+- Hugging Face blog
+- Research papers (arXiv)
+- Community discussions
+- Your own experiments
+
+**Thank you for attending! 🙏**

test

@@ -1 +0,0 @@
-xyz

utils.py

@@ -0,0 +1,129 @@
+"""
+Utility functions for HuggingFace Enabling Sessions Spaces app
+"""
+import torch
+from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
+from sentence_transformers import SentenceTransformer, util
+import numpy as np
+from functools import lru_cache
+import config
+
+
+@lru_cache(maxsize=10)
+def load_pipeline(task_type: str):
+    """Load and cache a pipeline for the given task."""
+    if task_type == "sentiment":
+        return pipeline("sentiment-analysis", model=config.SENTIMENT_MODEL)
+    elif task_type == "ner":
+        return pipeline("ner", model=config.NER_MODEL, aggregation_strategy="simple")
+    elif task_type == "qa":
+        return pipeline("question-answering", model=config.QA_MODEL)
+    elif task_type == "summarization":
+        return pipeline("summarization", model=config.SUMMARIZATION_MODEL, max_length=150, min_length=30)
+    else:
+        raise ValueError(f"Unknown task type: {task_type}")
+
+
+def run_sentiment_analysis(text: str):
+    """Run sentiment analysis on text."""
+    pipe = load_pipeline("sentiment")
+    result = pipe(text[:512])  # Truncate to avoid token limit
+    return result[0] if result else {"label": "Unknown", "score": 0}
+
+
+def run_ner(text: str):
+    """Run Named Entity Recognition on text."""
+    pipe = load_pipeline("ner")
+    result = pipe(text[:512])
+    return result
+
+
+def run_qa(context: str, question: str):
+    """Run question answering on context."""
+    pipe = load_pipeline("qa")
+    try:
+        result = pipe(question=question, context=context[:512])
+        return result
+    except Exception as e:
+        return {"error": str(e), "answer": "Unable to answer", "score": 0}
+
+
+def run_summarization(text: str):
+    """Generate summary of text."""
+    pipe = load_pipeline("summarization")
+    try:
+        result = pipe(text[:1024], max_length=150, min_length=30, do_sample=False)
+        return result[0]["summary_text"] if result else "Unable to summarize"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def compute_similarity(text1: str, text2: str):
+    """Compute semantic similarity between two texts."""
+    try:
+        model = SentenceTransformer(config.EMBEDDINGS_MODEL)
+        embeddings = model.encode([text1, text2], convert_to_tensor=True)
+        similarity = util.pytorch_cos_sim(embeddings[0], embeddings[1])
+        return float(similarity.item())
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def tokenize_text(text: str, model_name: str = config.SENTIMENT_MODEL):
+    """Tokenize text and show tokens with IDs."""
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        encoding = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512)
+        
+        tokens = tokenizer.convert_ids_to_tokens(encoding["input_ids"][0])
+        token_ids = encoding["input_ids"][0].tolist()
+        attention_mask = encoding["attention_mask"][0].tolist()
+        
+        result = {
+            "tokens": tokens,
+            "token_ids": token_ids,
+            "attention_mask": attention_mask,
+            "num_tokens": len(tokens),
+        }
+        return result
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def format_tokenizer_output(tokenization_result):
+    """Format tokenization result for display."""
+    if "error" in tokenization_result:
+        return f"Error: {tokenization_result['error']}"
+    
+    tokens = tokenization_result["tokens"]
+    token_ids = tokenization_result["token_ids"]
+    
+    output = f"**Total Tokens:** {tokenization_result['num_tokens']}\n\n"
+    output += "| Token | Token ID | Attention Mask |\n"
+    output += "|-------|----------|----------------|\n"
+    
+    for token, tid, attn in zip(
+        tokens, 
+        token_ids, 
+        tokenization_result["attention_mask"]
+    ):
+        output += f"| {token} | {tid} | {attn} |\n"
+    
+    return output
+
+
+def format_ner_output(ner_results):
+    """Format NER results for display."""
+    if not ner_results:
+        return "No entities found"
+    
+    output = "| Entity | Type | Score |\n"
+    output += "|--------|------|-------|\n"
+    
+    for result in ner_results:
+        word = result.get("word", "")
+        entity_type = result.get("entity_group", result.get("entity", ""))
+        score = result.get("score", 0)
+        output += f"| {word} | {entity_type} | {score:.4f} |\n"
+    
+    return output