week 9

Reference files/W9 - Deep Learning Learning Objectices.md

@@ -0,0 +1,68 @@
+**Architectural Understanding**
+
+1. **Define** deep learning as neural networks with multiple hidden layers that enable hierarchical feature learning (not just "3+ layers" but *why* depth matters for representation learning)  
+2. **Explain** why "deep" matters: each layer learns increasingly complex features  
+3. **Compare** how deep learning is different from machine learning, and be able to identify other deep learning methods
+
+**When to Use Deep Learning** 
+
+4\. **Choose** deep learning when you have: large datasets, unstructured data (images/text), complex patterns. Also understand why pretrained models work and when to fine-tune vs. feature extraction
+
+5\. **Avoid** deep learning when you need: explainable results, small datasets, or simple patterns
+
+**Understanding BERT** 
+
+6\. **Explain** what BERT does: understands word meaning based on context (unlike older methods) 
+
+7\. **Understand** BERT training: pre-training with a massive dataset, masked language modeling, bidirectional learning and the transformer framework
+
+8\. **Recognize** why pretrained models save time and work better than training from scratch
+
+**Practical Implementation and Evaluation** 
+
+10\. **Implement** sentiment analysis using pretrained BERT via Hugging Face transformers 
+
+11\. **Evaluate** model performance using appropriate metrics for classification tasks 
+
+12\. **Interpret** the model's confidence scores and predictions
+
+**Notes**
+
+What is deep learning?  
+Video tutorial: [Link](https://www.youtube.com/watch?v=q6kJ71tEYqM)
+
+- Previously we learned what machine learning is  
+- Deep learning is a subset of machine learning  
+- A subfield of AI is ML \-\> Neural Network \-\> Deep Learning  
+  - More than three layers of neural network is considered deep neural network \-\> deep learning  
+  - Can ingest unstructured data and determine \-\> different from supervised learning \-\> unsupervised learning
+
+When to use  
+Video: [Link](https://www.youtube.com/watch?v=o3bWqPdWJ88)
+
+- Unstructured data, like image, video, text  
+- High volumn of data \-\> deep learning will give you better result  
+- Complexity of feature \-\> complicated features \-\> deep learning  
+- Interpretability (important)  
+  - Industries like healthcare and finance require high interpretability, which is better answered by statistical ML  
+  - Deep learning’s complex neural networks makes it hard to interpret
+
+BERT
+
+- Google search is powered by BERT (bidirectional encoder representations from transformers)   
+  - BERT base, BERT large  
+- If you have two homes, how can you say if there are similar  
+  - For an object, if you can derive and compare features and compare their similarities…take all the numbers and create vectors and compare the vectors, you can then compare  
+- Generate feature vector for these words \-\> compare feature vector/word embedding  
+- How to generate word embeddings  
+- Word to vector (word2vec)  
+- Issues with word2vec \-\> you need a model that can generate contextualized meaning of words \-\> this is what BERT allows you to do
+
+Pretrained BERT for sentiment analysis
+
+- Download and install Transformer from huggingface  
+  - Install and import dependencies  
+  - Instantiat model \- bert-base-multilingual-uncased-sentiment  
+- Perform sentiment scoring  
+  - Encode and calculate sentiment
+

Reference files/W9-Deep Learnign Curriculum.md

@@ -0,0 +1,600 @@
+Using Deep Learning Model BERT to Understand Sentiments
+
+## **🎯 Introduction**
+
+**Your Mission**: You're a researcher studying student mental health. You have 1,000 anonymous student forum posts about academic stress, and you need to quickly identify which posts indicate concerning levels of burnout vs. normal academic stress. Manual coding would take weeks. Can you train an AI to do this accurately in under 2 hours?
+
+**Real stakes**: Early intervention programs depend on identifying students at risk. Your analysis could help universities provide timely mental health support.
+
+**The Dataset**: Student forum posts like:
+
+* *"Another all-nighter for this impossible exam. I can't keep doing this."*  
+* *"Stressed about finals but my study group is keeping me motivated\!"*  
+* *"I honestly don't see the point anymore. Nothing I do matters."*
+
+**Your Goal Today**: Learn how to use a BERT-powered sentiment classifier (a deep learning model)  that can distinguish between healthy academic stress and concerning burnout indicators.
+
+---
+
+## **🤔 Why Traditional ML Falls Short Here**
+
+Let's start with what you already know. How would you approach this with logistic regression?
+
+### **Quick Exercise: Traditional Approach Limitations**
+
+python  
+sample\_posts \= \[  
+    "I'm not stressed about finals",      *\# Negation*  
+    "This is fine, totally fine",         *\# Sarcasm*    
+    "Actually excited about exams"        *\# Context-dependent*  
+\]
+
+*\# Traditional ML approach:*  
+*\# 1\. Count words: {"stressed": 1, "finals": 1, "not": 1}*  
+*\# 2\. Each word gets independent weight*
+
+*\# 3\. Sum weights → prediction*
+
+**The Problem**: What happens when context changes everything?
+
+* *"I'm **not** stressed"* vs *"I'm stressed"*  
+* *"This is **fine**"* (sarcastic) vs *"This is **fine**"* (genuine)
+
+Traditional ML treats each word independently \- it can't understand that surrounding words completely change the meaning.
+
+**💡 We need something smarter**: A model that reads like humans do, understanding full context and subtle meanings.
+
+---
+
+## **🚀 Meet BERT: Your Game-Changer**
+
+### **What is BERT?**
+
+**BERT** \= **B**idirectional **E**ncoder **R**epresentations from **T**ransformers
+
+Think of BERT as an AI that learned to read by studying 3.3 billion words from books and Wikipedia, then can be quickly adapted to understand your specific research domain.
+
+### **BERT's Superpower: Context Understanding**
+
+**Traditional models** read like this: "I went to the \_\_\_" →
+
+* Only look backwards, miss crucial context
+
+**BERT reads bidirectionally**: ← "I went to the \_\_\_ to deposit money" →
+
+* Sees BOTH directions \= understands "bank" means financial institution, not riverbank
+
+### **Let's See BERT in Action**
+
+Python  
+*\# Install Transformers*  
+\!pip install transformers
+
+*\# Try out BERT*  
+from transformers import pipeline  
+unmasker \= pipeline('fill-mask', model='bert-base-uncased')  
+unmasker("Artificial Intelligence \[MASK\] take over the world.")
+
+*\# Be aware of model bias, and let’s see what jobs BERT suggests for a man*
+
+unmasker("The man worked as a \[MASK\].")
+
+*\# Now let’s see what jobs BERT suggests for a woman*
+
+unmasker("The woman worked as a \[MASK\].")
+
+**🤯 Notice**: These gender biases are so important to be aware of and will affect all fine-tuned versions of this model.
+
+### **Understanding Deep Learning & BERT's Place in the AI Family**
+
+## **🧠 Understanding BERT: The AI Revolution for Language (35 minutes)**
+
+### **Essential Terminology: Building Your AI Vocabulary**
+
+Before we dive into BERT, let's define the key terms you'll need:
+
+**🔑 Key Definition: Neural Network** A computer system inspired by how brain neurons work \- information flows through connected layers that learn patterns from data.
+
+**🔑 Key Definition: Deep Learning** Neural networks with **multiple hidden layers** (typically 3+) that automatically learn increasingly complex patterns:
+
+* Layer 1: Basic patterns (individual words, simple features)  
+* Layer 2: Combinations (phrases, word relationships)  
+* Layer 3: Structure (grammar, syntax)  
+* Layer 4+: Meaning (context, sentiment, intent)
+
+**🔑 Key Definition: Transformers** A revolutionary neural network architecture (2017) that uses **attention mechanisms** to understand relationships between all words in a sentence simultaneously, rather than reading word-by-word.
+
+**🔑 Key Definition: BERT** **B**idirectional **E**ncoder **R**epresentations from **T**ransformers \- a specific type of transformer that reads text in both directions to understand context.
+
+### **The AI Family Tree: Where BERT Lives**
+
+Machine Learning Family  
+├── Traditional ML (what you know)  
+│   ├── Logistic Regression ← You learned this  
+│   ├── Random Forest  
+│   └── SVM  
+└── Deep Learning (neural networks with many layers)  
+    ├── Computer Vision  
+    │   └── CNNs (for images)  
+    ├── Sequential Data    
+    │   └── RNNs/LSTMs (for time series)  
+    └── Language Understanding ← BERT lives here\!  
+        ├── BERT (2018) ← What we're using today  
+        ├── GPT (generates text)
+
+        └── T5 (text-to-text)
+
+### **Let's See BERT in Action First**
+
+python
+
+from transformers import pipeline
+
+*\# Load BERT-based sentiment analyzer (pre-trained and ready\!)*  
+classifier \= pipeline("sentiment-analysis",   
+                     model\="cardiffnlp/twitter-roberta-base-sentiment-latest")
+
+*\# Test with our tricky examples*  
+test\_posts \= \[  
+    "I'm totally fine with staying up all night again",  *\# Sarcasm?*  
+    "Not feeling overwhelmed at all",                   *\# Negation \+ sarcasm?*  
+    "This workload is completely manageable",           *\# Hidden stress?*  
+    "Actually excited about this challenging semester"   *\# Genuine positive?*  
+\]
+
+print("🧠 BERT's Understanding:")  
+for post in test\_posts:  
+    result \= classifier(post)  
+    print(f"'{post}'")  
+    print(f"→ {result\['label'\]} (confidence: {result\['score'\]:.2f})")
+
+    print()
+
+**🤯 Notice**: BERT catches subtleties that word counting completely misses\! But how?
+
+---
+
+## **⚙️ How BERT Works**
+
+### **BERT's Revolutionary Training: Two Clever Learning Tasks**
+
+BERT learned language by reading **3.3 billion words** from Wikipedia (\~2.5B words) and Google's BooksCorpus (\~800M words) using two ingenious tasks:
+
+#### **Task 1: Masked Language Modeling (MLM) \- The Fill-in-the-Blank Game**
+
+**🔑 Key Definition: Masked Language Modeling** A training method where random words are hidden (\[MASK\]) and the model learns to predict them using context from BOTH sides.
+
+**Real Example from Training:**
+
+* Original text: "The student felt anxious about the upcoming final exam"  
+* BERT saw:     "The student felt \[MASK\] about the upcoming final exam"  
+* BERT learned: What word fits here based on ALL surrounding context?  
+*   
+* Possible answers: anxious, excited, confident, nervous, prepared...  
+  BERT's choice: "anxious" (most likely given context)
+
+**Why This Matters**: This forces **bidirectional learning** \- BERT must use words from BOTH left and right to make predictions.
+
+**🔑 Key Definition: Bidirectional Learning** Reading text in both directions (← →) simultaneously, unlike traditional models that only read left-to-right (→).
+
+**Human Connection**: You do this naturally\! If someone said: *"Dang\! I'm out fishing and a huge trout just \_\_\_\_\_ my line\!"* You use words from BOTH sides ("fishing" \+ "trout" \+ "line") to predict "broke"\!
+
+#### **Task 2: Next Sentence Prediction (NSP) \- Learning Text Relationships**
+
+**🔑 Key Definition: Next Sentence Prediction** A training task where BERT learns whether two sentences logically belong together.
+
+**Training Examples:**
+
+* ✅ Correct pair:  
+* Sentence A: "Paul went shopping"    
+* Sentence B: "He bought a new shirt"  
+*   
+* ❌ Incorrect pair:  
+* Sentence A: "Ramona made coffee"  
+  Sentence B: "Vanilla ice cream cones for sale"
+
+**Why This Matters**: BERT learns relationships between ideas, not just individual words.
+
+### **The Attention Mechanism: BERT's Superpower**
+
+**🔑 Key Definition: Attention Mechanism** A way for the model to automatically focus on the most important words when understanding each part of a sentence.
+
+**Human Analogy**: When you read *"The bank by the river"*, you automatically know "bank" means riverbank (not a financial institution) because you pay attention to "river" \- even though it comes after "bank".
+
+**BERT's Attention in Action:**
+
+* Sentence: "I'm not stressed about finals"  
+*   
+* BERT's attention weights might look like:  
+* "I'm"     → pays attention to: "not", "stressed" (who is feeling this?)  
+* "not"     → pays attention to: "stressed" (what am I negating?)    
+* "stressed"→ pays attention to: "not", "about", "finals" (context of stress)  
+* "about"   → pays attention to: "stressed", "finals" (relationship)  
+  "finals"  → pays attention to: "stressed", "about" (source of stress)
+
+This simultaneous analysis of ALL word relationships is what makes BERT so powerful\!
+
+### **BERT's Architecture: The Technical Breakdown**
+
+**🔑 Key Definition: Encoder Architecture** BERT uses only the "encoder" part of transformers \- the part that builds understanding of input text (as opposed to generating new text).
+
+**BERT's Processing Pipeline:**
+
+#### **Step 1: Tokenization**
+
+**🔑 Key Definition: Tokenization** Breaking text into smaller pieces (tokens) that the model can process.
+
+* Input: "I'm not stressed about finals"  
+* Tokens: \["I'm", "not", "stressed", "about", "finals"\]  
+* Special tokens added: \[CLS\] I'm not stressed about finals \[SEP\]  
+*                       ↑                                    ↑  
+                     Start token                         End token
+
+  #### **Step 2: The Transformer Stack (12 Layers Working Together)**
+
+* Input Tokens  
+*     ↓  
+* Layer 1-3: Basic Language Understanding  
+* ├── Word recognition and basic patterns  
+* ├── Part-of-speech identification (noun, verb, adjective)  
+* └── Simple word relationships  
+*     ↓  
+* Layer 4-6: Phrase and Structure Analysis    
+* ├── Multi-word phrases ("not stressed")  
+* ├── Sentence structure and grammar  
+* └── Syntactic relationships  
+*     ↓  
+* Layer 7-9: Contextual Understanding  
+* ├── Semantic meaning in context  
+* ├── Negation and modifiers  
+* └── Domain-specific patterns  
+*     ↓  
+* Layer 10-12: High-Level Interpretation  
+* ├── Emotional tone and sentiment  
+* ├── Implied meaning and subtext  
+* └── Task-specific reasoning  
+*     ↓  
+  Final Classification
+
+  #### **Step 3: Attention Across All Layers**
+
+Each layer has **multiple attention heads** (typically 12\) that focus on different aspects:
+
+* Head 1: Subject-verb relationships  
+* Head 2: Negation patterns  
+* Head 3: Emotional indicators  
+* Head 4: Academic context clues  
+* etc.
+
+**Visualization of Attention:**
+
+* "I'm not stressed about finals"  
+* Layer 6 attention patterns:  
+* I'm     ←→ not, stressed (personal ownership of feeling)  
+* not     ←→ stressed (direct negation)  
+* stressed ←→ about, finals (source and type of stress)  
+* about   ←→ finals (relationship)  
+  finals  ←→ stressed (academic stressor)
+
+  ### **BERT's Two-Stage Learning Process**
+
+  #### **Stage 1: Pre-training (Done for You\!)**
+
+* **Data**: 3.3 billion words (Wikipedia \+ Google Books)  
+* **Time**: 4 days on 64 specialized processors (TPUs)  
+* **Cost**: \~$10,000+ in computing resources  
+* **Tasks**: 50% Masked Language Modeling \+ 50% Next Sentence Prediction  
+* **Result**: General language understanding
+
+  #### **Stage 2: Fine-tuning (What You Can Do\!)**
+
+* **Data**: Small labeled dataset for your specific task (e.g., sentiment analysis)  
+* **Time**: Minutes to hours  
+* **Cost**: Often free or \<$10  
+* **Process**: Adapt general language knowledge to your research question  
+* **Result**: Specialized classifier for your domain
+
+**🔑 Key Definition: Transfer Learning** Using knowledge learned from one task (reading billions of words) to help with a different task (your research question).
+
+**Analogy**: Like a medical student (general education) becoming a psychiatrist (specialization) \- they don't relearn biology, they build on it.
+
+### **Why BERT's Architecture Matters**
+
+**Before BERT (Traditional Approaches):**
+
+* Read text sequentially (left→right)  
+* Each word processed independently  
+* Limited context understanding  
+* Required large labeled datasets for each task
+
+**With BERT (Transformer Approach):**
+
+* Read text bidirectionally (←→)  
+* All words processed simultaneously with attention  
+* Rich contextual understanding  
+* Transfer learning from massive pre-training
+
+**Research Impact:**
+
+* **Speed**: Tasks that took weeks now take hours  
+* **Accuracy**: Often exceeds human-level performance  
+* **Scale**: Can process thousands of texts consistently  
+* **Accessibility**: No need for massive computing resources
+
+---
+
+## **🛠 Building Your Burnout Detector (40 minutes)**
+
+### **Step 1: Load Your Research Dataset**
+
+python  
+import pandas as pd  
+import matplotlib.pyplot as plt
+
+*\# Simulated student forum posts (anonymized and ethically sourced)*  
+student\_posts \= \[  
+    *\# Concerning burnout indicators*  
+    "I can't sleep, can't eat, nothing feels worth it anymore",  
+    "Every assignment feels impossible, I'm failing at everything",   
+    "Been crying in the library again, maybe I should just drop out",  
+    "Three months of this and I feel completely empty inside",  
+      
+    *\# Normal academic stress*  
+    "Finals week is rough but I know I can push through",  
+    "Stressed about my paper but my friends are helping me stay motivated",  
+    "Long study session today but feeling prepared for tomorrow's exam",  
+    "Challenging semester but learning so much in my research methods class",  
+      
+    *\# Positive academic engagement*    
+    "Actually excited about my thesis research this semester",  
+    "Difficult coursework but my professor's support makes it manageable",  
+    "Study group tonight \- we're all helping each other succeed",  
+    "Tough week but grateful for this learning opportunity"  
+\]
+
+*\# True labels (in real research, this would come from expert coding)*  
+labels \= \['negative', 'negative', 'negative', 'negative',  *\# Burnout indicators*  
+          'neutral', 'neutral', 'neutral', 'neutral',     *\# Normal stress*  
+          'positive', 'positive', 'positive', 'positive'\] *\# Positive engagement*
+
+*\# Create DataFrame*  
+df \= pd.DataFrame({  
+    'post': student\_posts,  
+    'true\_sentiment': labels  
+})
+
+print(f"📊 Dataset: {len(df)} student posts")
+
+print(f"Distribution: {df\['true\_sentiment'\].value\_counts()}")
+
+### **Step 2: Apply BERT to Your Research Question**
+
+python  
+*\# Initialize BERT sentiment classifier*  
+sentiment\_classifier \= pipeline("sentiment-analysis",  
+                               model\="cardiffnlp/twitter-roberta-base-sentiment-latest")
+
+*\# Analyze all posts*  
+predictions \= \[\]  
+confidence\_scores \= \[\]
+
+print("🔍 BERT's Analysis of Student Posts:\\n")  
+print("-" \* 80)
+
+for i, post in enumerate(df\['post'\]):  
+    result \= sentiment\_classifier(post)\[0\]  
+      
+    predictions.append(result\['label'\])  
+    confidence\_scores.append(result\['score'\])  
+      
+    print(f"Post {i\+1}: '{post\[:50\]}...'")  
+    print(f"True sentiment: {df\['true\_sentiment'\]\[i\]}")  
+    print(f"BERT prediction: {result\['label'\]} (confidence: {result\['score'\]:.2f})")  
+    print("-" \* 80)
+
+*\# Add predictions to dataframe*  
+df\['bert\_prediction'\] \= predictions
+
+df\['confidence'\] \= confidence\_scores
+
+### **Step 3: Evaluate Your Model's Research Utility**
+
+python  
+from sklearn.metrics import classification\_report, confusion\_matrix  
+import seaborn as sns
+
+*\# Convert labels for comparison (handling label mismatches)*  
+def map\_labels(label):  
+    if label in \['NEGATIVE', 'negative'\]:  
+        return 'negative'  
+    elif label in \['POSITIVE', 'positive'\]:  
+        return 'positive'  
+    else:  
+        return 'neutral'
+
+df\['bert\_mapped'\] \= df\['bert\_prediction'\].apply(map\_labels)
+
+*\# Calculate accuracy*  
+accuracy \= (df\['true\_sentiment'\] \== df\['bert\_mapped'\]).mean()  
+print(f"🎯 Research Accuracy: {accuracy:.2f} ({accuracy\*100:.0f}%)")
+
+*\# Detailed analysis*  
+print("\\nDetailed Performance Report:")  
+print(classification\_report(df\['true\_sentiment'\], df\['bert\_mapped'\]))
+
+*\# Visualize results*  
+plt.figure(figsize\=(12, 4))
+
+*\# Confusion Matrix*  
+plt.subplot(1, 2, 1)  
+cm \= confusion\_matrix(df\['true\_sentiment'\], df\['bert\_mapped'\])  
+sns.heatmap(cm, annot\=True, fmt\='d', cmap\='Blues',  
+            xticklabels\=\['negative', 'neutral', 'positive'\],  
+            yticklabels\=\['negative', 'neutral', 'positive'\])  
+plt.title('Confusion Matrix')  
+plt.ylabel('True Sentiment')  
+plt.xlabel('BERT Prediction')
+
+*\# Confidence Distribution*  
+plt.subplot(1, 2, 2)  
+plt.hist(df\['confidence'\], bins\=10, alpha\=0.7, edgecolor\='black')  
+plt.title('BERT Confidence Scores')  
+plt.xlabel('Confidence')  
+plt.ylabel('Number of Posts')
+
+plt.tight\_layout()
+
+plt.show()
+
+### **Step 4: Understanding Why BERT's "Depth" Matters**
+
+python  
+*\# Let's see how BERT's deep learning architecture helps with complex cases*  
+complex\_cases \= \[  
+    "I'm fine :) everything's totally under control :) :)",  *\# Excessive positivity*  
+    "lol guess I'm just built different, thriving on 2hrs sleep", *\# Normalized concerning behavior*  
+    "Not that I'm complaining, but this workload is killing me", *\# Mixed signals*  
+\]
+
+print("🧠 Why Deep Learning Architecture Matters:")  
+print("(Multiple layers help BERT understand these complex patterns)\\n")
+
+for case in complex\_cases:  
+    result \= sentiment\_classifier(case)\[0\]  
+    print(f"Text: '{case}'")  
+    print(f"BERT's analysis: {result\['label'\]} (confidence: {result\['score'\]:.2f})")  
+      
+    *\# Explain what BERT's layers might be "thinking"*  
+    print("🔍 What BERT's layers likely detected:")  
+    if "fine" in case and ":)" in case:  
+        print("  → Layer 1-3: Words 'fine', positive emoticons")  
+        print("  → Layer 4-8: Excessive repetition pattern")    
+        print("  → Layer 9-12: Contradiction between words and overuse → sarcasm/masking")  
+    elif "lol" in case and "thriving" in case:  
+        print("  → Layer 1-3: Casual language ('lol'), positive word ('thriving')")  
+        print("  → Layer 4-8: Contradiction with concerning behavior ('2hrs sleep')")  
+        print("  → Layer 9-12: Normalization of unhealthy patterns")  
+    elif "Not that I'm complaining" in case:  
+        print("  → Layer 1-3: Negation words, formal disclaimer")  
+        print("  → Layer 4-8: 'but' indicates contradiction coming")  
+        print("  → Layer 9-12: Strong negative metaphor contradicts disclaimer")
+
+    print()
+
+---
+
+## **🤔 Critical Research Reflection**
+
+### **What Makes BERT Powerful for Research?**
+
+**✅ Advantages of Deep Learning Approach:**
+
+* **Context awareness**: Understands negation, sarcasm, implied meaning  
+* **Consistency**: Same sophisticated analysis applied to every text  
+* **Scale**: Can process thousands of texts in minutes  
+* **Transferability**: Pre-trained on massive data, works across domains
+
+### **Research Limitations to Consider**
+
+python  
+*\# Test edge cases that might appear in real research*  
+edge\_cases \= \[  
+    "tbh everything's mid rn but like whatever",  *\# Generation-specific slang*  
+    "Academic stress? What's that? \*nervous laughter\*",  *\# Asterisk actions*  
+    "Everything is absolutely perfect and wonderful\!\!",  *\# Potential masking*  
+\]
+
+print("🧐 Testing BERT's Limitations:")  
+for case in edge\_cases:  
+    result \= sentiment\_classifier(case)\[0\]  
+    print(f"'{case}'")  
+    print(f"→ {result\['label'\]} (confidence: {result\['score'\]:.2f})")
+
+    print("❓ Would you trust this for research decisions?\\n")
+
+### **When to Choose Deep Learning vs. Traditional ML**
+
+**Use BERT (Deep Learning) when:**
+
+* ✅ Context and nuance matter (like sentiment analysis)  
+* ✅ You have unstructured text data  
+* ✅ Traditional ML struggles with the complexity  
+* ✅ You need to scale to large datasets
+
+**Stick with Traditional ML when:**
+
+* ✅ You need perfect explainability  
+* ✅ Simple patterns work well  
+* ✅ Very small datasets (\<100 examples)  
+* ✅ Computational resources are limited
+
+### **Research Ethics Considerations**
+
+**Discussion Questions**:
+
+1. **Bias**: Does BERT work equally well for all student populations?  
+2. **Privacy**: How do we protect student anonymity?  
+3. **Intervention**: What's our responsibility with concerning content?  
+4. **Validation**: How do we verify our ground truth labels?
+
+---
+
+## **🎯 Your Research Takeaways** 
+
+### **What You've Accomplished Today**
+
+✅ **Applied deep learning** to real research  
+ ✅ **Used BERT** for context-aware text analysis  
+ ✅ **Understood how deep learning differs** from traditional ML  
+ ✅ **Evaluated performance** with research-appropriate metrics  
+ ✅ **Identified when to use** deep learning vs. traditional approaches
+
+### **Your Expanded Research Toolkit**
+
+* **BERT sentiment analysis** for sophisticated text classification  
+* **Deep learning intuition** for understanding when context matters  
+* **Performance evaluation** skills for any ML research  
+* **Critical thinking** about AI limitations and research ethics
+
+### **Next Steps for Your Research**
+
+1. **Try BERT on your domain**: What research question could this solve?  
+2. **Collect larger datasets** (100+ examples for robust results)  
+3. **Consider fine-tuning** for domain-specific language  
+4. **Always validate** with domain experts  
+5. **Test for bias** across different populations
+
+### **The Bigger Picture**
+
+You've just learned to use one of the most powerful tools in modern AI research. BERT and similar deep learning models are transforming research across:
+
+* **Psychology**: Mental health monitoring, personality analysis  
+* **Political Science**: Public opinion tracking, policy sentiment  
+* **Digital Humanities**: Literary analysis, historical text mining  
+* **Marketing**: Brand perception, customer feedback analysis
+
+**🚀 Challenge**: Apply this to a research question in your field this week\!
+
+---
+
+## **📝 Take-Home Exercise**
+
+**Choose Your Research Adventure:**
+
+1. **Social Media Analysis**: Sentiment about a current campus issue  
+2. **Literature Research**: Compare emotional tone across different authors  
+3. **Survey Analysis**: Classify open-ended course feedback
+
+**Requirements:**
+
+* Use BERT pipeline from today  
+* Analyze 20+ text samples  
+* Evaluate results critically  
+* Identify cases needing expert review
+
+**Reflection Questions:**
+
+* When did BERT's deep learning approach outperform what simple word counting could do?  
+* Where would you still need human expert judgment?  
+* How could this scale your research capabilities?
+

course_pages/week_9.py

@@ -0,0 +1,379 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+# Week 9: Deep Learning & BERT for Sentiment Analysis
+
+def show():
+    st.title("Week 9: Deep Learning & BERT for Sentiment Analysis")
+
+    # Learning Objectives
+    st.header("Learning Objectives")
+    st.markdown("""
+    By the end of this week, you will be able to:
+    
+    **Architectural Understanding**
+    - Define deep learning as neural networks with multiple hidden layers and explain why depth matters for representation learning
+    - Explain why "deep" matters: each layer learns increasingly complex features
+    - Compare deep learning with traditional machine learning and identify other deep learning methods
+    
+    **When to Use Deep Learning**
+    - Choose deep learning for large, unstructured, or complex data; understand when to use pretrained models and when to fine-tune
+    - Avoid deep learning when you need explainable results, have small datasets, or simple patterns
+    
+    **Understanding BERT**
+    - Explain what BERT does and how it understands word meaning based on context
+    - Understand BERT's training: pre-training, masked language modeling, bidirectional learning, and the transformer framework
+    - Recognize why pretrained models save time and work better than training from scratch
+    
+    **Practical Implementation and Evaluation**
+    - Implement sentiment analysis using pretrained BERT via Hugging Face transformers
+    - Evaluate model performance using appropriate metrics for classification tasks
+    - Interpret the model's confidence scores and predictions
+    """)
+
+    # Introduction & Motivation
+    st.header("Introduction: Why Deep Learning for Text?")
+    st.markdown("""
+    Imagine you have 1,000 student forum posts about academic stress. You need to quickly identify which posts indicate concerning levels of burnout. Manual coding would take weeks. Can you train an AI to do this accurately in under 2 hours?
+    
+    **Real stakes:** Early intervention programs depend on identifying students at risk. Your analysis could help universities provide timely mental health support.
+    """)
+    with st.expander("Sample Student Posts"):
+        st.write(
+            """
+            - "Another all-nighter for this impossible exam. I can't keep doing this."
+            - "Stressed about finals but my study group is keeping me motivated!"
+            - "I honestly don't see the point anymore. Nothing I do matters."
+            """
+        )
+
+    # Traditional ML vs. Deep Learning
+    st.header("Why Traditional ML Falls Short")
+    st.markdown("""
+    Traditional ML (like logistic regression) treats each word independently and can't understand context, negation, or sarcasm:
+    """)
+    with st.expander("Example: Traditional ML Limitations"):
+        st.code(
+            'sample_posts = [\n'
+            '    "I\'m not stressed about finals",      # Negation\n'
+            '    "This is fine, totally fine",         # Sarcasm\n'
+            '    "Actually excited about exams"        # Context-dependent\n'
+            ']\n'
+            '# Traditional ML: counts words, ignores context\n'
+            '# "not stressed" vs. "stressed"\n'
+            '# "fine" (sarcastic) vs. "fine" (genuine)\n'
+        , language="python")
+        st.write("**Problem:** Context changes everything. We need a model that reads like humans do.")
+
+    # Meet BERT
+    st.header("Meet BERT: Context-Aware Deep Learning")
+    st.markdown("""
+    **BERT** (Bidirectional Encoder Representations from Transformers) is a deep learning model that understands language context by reading text in both directions. It was pre-trained on billions of words and can be quickly adapted to your research domain.
+    """)
+    with st.expander("BERT Demo: Fill-in-the-Blank"):
+        st.code(
+            'from transformers import pipeline\n'
+            'unmasker = pipeline("fill-mask", model="bert-base-uncased")\n'
+            'unmasker("Artificial Intelligence [MASK] take over the world.")\n'
+        , language="python")
+        st.write("BERT predicts the masked word using context from both sides.")
+        
+        st.markdown("**Example Output:**")
+        st.code(
+            '[{\'sequence\': \'artificial intelligence will take over the world.\', \'score\': 0.1234, \'token\': 2054, \'token_str\': \'will\'},\n'
+            ' {\'sequence\': \'artificial intelligence can take over the world.\', \'score\': 0.0987, \'token\': 1169, \'token_str\': \'can\'},\n'
+            ' {\'sequence\': \'artificial intelligence may take over the world.\', \'score\': 0.0876, \'token\': 1175, \'token_str\': \'may\'}]\n'
+        , language="python")
+
+    # BERT's Place in the AI Family
+    st.header("Deep Learning, Transformers, and BERT")
+    st.markdown("""
+    - **Neural Network:** Layers of connected nodes that learn patterns from data
+    - **Deep Learning:** Neural networks with multiple hidden layers (3+), learning increasingly complex features
+    - **Transformers:** Neural networks using attention mechanisms to understand relationships between all words in a sentence
+    - **BERT:** A transformer model that reads text bidirectionally for context
+    """)
+    with st.expander("AI Family Tree"):
+        st.markdown("""
+        - Machine Learning
+            - Traditional ML (Logistic Regression, Random Forest, SVM)
+            - Deep Learning
+                - Computer Vision (CNNs)
+                - Sequential Data (RNNs/LSTMs)
+                - Language Understanding (BERT, GPT, T5)
+        """)
+
+    # BERT in Action: Sentiment Analysis
+    st.header("BERT in Action: Sentiment Analysis")
+    st.markdown("""
+    Let's use a pretrained BERT model to classify student posts as negative (burnout), neutral (normal stress), or positive (engagement).
+    """)
+    with st.expander("Example: Sentiment Analysis with BERT"):
+        st.code(
+            'from transformers import pipeline\n'
+            'classifier = pipeline("sentiment-analysis", model="cardiffnlp/twitter-roberta-base-sentiment-latest")\n'
+            'test_posts = [\n'
+            '    "I\'m totally fine with staying up all night again",\n'
+            '    "Not feeling overwhelmed at all",\n'
+            '    "This workload is completely manageable",\n'
+            '    "Actually excited about this challenging semester"\n'
+            ']\n'
+            'for post in test_posts:\n'
+            '    result = classifier(post)\n'
+            '    print(f"{post} → {result[0][\'label\']} (confidence: {result[0][\'score\']:.2f})")\n'
+        , language="python")
+        st.write("BERT catches subtleties that word counting misses!")
+        
+        st.markdown("**Example Output:**")
+        st.code(
+            'I\'m totally fine with staying up all night again → NEGATIVE (confidence: 0.89)\n'
+            'Not feeling overwhelmed at all → NEGATIVE (confidence: 0.76)\n'
+            'This workload is completely manageable → POSITIVE (confidence: 0.82)\n'
+            'Actually excited about this challenging semester → POSITIVE (confidence: 0.91)\n'
+        , language="python")
+        st.write("Notice how BERT correctly identifies sarcasm in the first two examples!")
+
+    # How BERT Works
+    st.header("How BERT Works: Architecture & Training")
+    st.markdown("""
+    - **Masked Language Modeling:** BERT learns by predicting masked words using context from both sides
+    - **Bidirectional Learning:** Reads text in both directions simultaneously
+    - **Next Sentence Prediction:** Learns relationships between sentences
+    - **Attention Mechanism:** Focuses on the most important words for understanding context
+    - **Encoder Architecture:** Uses only the encoder part of transformers
+    - **Transfer Learning:** Pretrained on massive data, then fine-tuned for your task
+    """)
+    with st.expander("Visualization: BERT's Attention"):
+        st.markdown("**How BERT's Attention Works:**")
+        
+        # Create a visual representation of attention
+        attention_data = {
+            'Word': ['I', 'am', 'not', 'stressed', 'about', 'finals'],
+            'Attention to "not"': [0.1, 0.2, 1.0, 0.8, 0.1, 0.1],
+            'Attention to "stressed"': [0.1, 0.1, 0.8, 1.0, 0.7, 0.6],
+            'Attention to "finals"': [0.1, 0.1, 0.1, 0.6, 0.8, 1.0]
+        }
+        
+        attention_df = pd.DataFrame(attention_data)
+        
+        # Create a heatmap visualization
+        fig, ax = plt.subplots(figsize=(10, 6))
+        attention_matrix = attention_df.iloc[:, 1:].values
+        sns.heatmap(attention_matrix, 
+                   xticklabels=attention_df.columns[1:], 
+                   yticklabels=attention_df['Word'],
+                   annot=True, 
+                   fmt='.1f',
+                   cmap='Blues',
+                   cbar_kws={'label': 'Attention Weight'})
+        plt.title("BERT's Attention Weights for 'I am not stressed about finals'")
+        plt.ylabel('Words in Sentence')
+        plt.xlabel('Attention Heads')
+        plt.tight_layout()
+        st.pyplot(fig)
+        
+        st.markdown("""
+        **What this shows:**
+        - **Attention to 'not'**: The word 'not' pays most attention to itself (1.0) and to 'stressed' (0.8) - it's negating the stress
+        - **Attention to 'stressed'**: Pays attention to 'not' (0.8), itself (1.0), and 'finals' (0.6) - understanding the context
+        - **Attention to 'finals'**: Pays attention to 'stressed' (0.6), 'about' (0.8), and itself (1.0) - the source of stress
+        
+        This bidirectional attention is what makes BERT understand context so well!
+        """)
+
+    # Practical: Burnout Detector with BERT
+    st.header("Practical: Build a Burnout Detector with BERT")
+    st.markdown("""
+    We'll simulate a dataset of student posts and use BERT to classify them. In real research, you would use your own data and labels.
+    """)
+    with st.expander("Example Code: BERT Sentiment Analysis on Student Posts"):
+        st.code(
+            'import pandas as pd\n'
+            'from transformers import pipeline\n'
+            'student_posts = [\n'
+            '    "I can\'t sleep, can\'t eat, nothing feels worth it anymore",\n'
+            '    "Every assignment feels impossible, I\'m failing at everything",\n'
+            '    "Been crying in the library again, maybe I should just drop out",\n'
+            '    "Three months of this and I feel completely empty inside",\n'
+            '    "Finals week is rough but I know I can push through",\n'
+            '    "Stressed about my paper but my friends are helping me stay motivated",\n'
+            '    "Long study session today but feeling prepared for tomorrow\'s exam",\n'
+            '    "Challenging semester but learning so much in my research methods class",\n'
+            '    "Actually excited about my thesis research this semester",\n'
+            '    "Difficult coursework but my professor\'s support makes it manageable",\n'
+            '    "Study group tonight - we\'re all helping each other succeed",\n'
+            '    "Tough week but grateful for this learning opportunity"\n'
+            ']\n'
+            'labels = [\'negative\', \'negative\', \'negative\', \'negative\', \'neutral\', \'neutral\', \'neutral\', \'neutral\', \'positive\', \'positive\', \'positive\', \'positive\']\n'
+            'df = pd.DataFrame({\'post\': student_posts, \'true_sentiment\': labels})\n'
+            'classifier = pipeline("sentiment-analysis", model="cardiffnlp/twitter-roberta-base-sentiment-latest")\n'
+            'predictions = []\n'
+            'confidence_scores = []\n'
+            'for post in df["post"]:\n'
+            '    result = classifier(post)[0]\n'
+            '    predictions.append(result["label"])\n'
+            '    confidence_scores.append(result["score"])\n'
+            'df["bert_prediction"] = predictions\n'
+            'df["confidence"] = confidence_scores\n'
+            'print(df.head())\n'
+        , language="python")
+        st.write("You can evaluate the model using accuracy, classification report, and confusion matrix.")
+        
+        st.markdown("**Example Output:**")
+        st.code(
+            '                                                post true_sentiment bert_prediction  confidence\n'
+            '0  I can\'t sleep, can\'t eat, nothing feels wo...      negative        NEGATIVE        0.9876\n'
+            '1  Every assignment feels impossible, I\'m fail...      negative        NEGATIVE        0.9456\n'
+            '2  Been crying in the library again, maybe I s...      negative        NEGATIVE        0.9234\n'
+            '3  Three months of this and I feel completely ...      negative        NEGATIVE        0.9789\n'
+            '4  Finals week is rough but I know I can push ...       neutral         NEUTRAL        0.7654\n'
+        , language="python")
+
+    # Model Evaluation
+    st.header("Model Evaluation & Interpretation")
+    st.markdown("""
+    - **Accuracy:** Proportion of correct predictions
+    - **Classification Report:** Precision, recall, F1-score for each class
+    - **Confusion Matrix:** Visualizes true vs. predicted labels
+    - **Confidence Scores:** How sure is the model about each prediction?
+    """)
+    with st.expander("Example: Evaluation Code"):
+        st.code(
+            'from sklearn.metrics import classification_report, confusion_matrix\n'
+            'import seaborn as sns\n'
+            'import matplotlib.pyplot as plt\n'
+            'df["bert_mapped"] = df["bert_prediction"].apply(lambda x: x.lower())\n'
+            'accuracy = (df["true_sentiment"] == df["bert_mapped"]).mean()\n'
+            'print(f"Accuracy: {accuracy:.2f}")\n'
+            'print(classification_report(df["true_sentiment"], df["bert_mapped"]))\n'
+            'cm = confusion_matrix(df["true_sentiment"], df["bert_mapped"])\n'
+            'sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")\n'
+            'plt.xlabel("Predicted")\n'
+            'plt.ylabel("True")\n'
+            'plt.show()\n'
+        , language="python")
+        
+        st.markdown("**Example Output:**")
+        st.code(
+            'Accuracy: 0.83\n'
+            '\n'
+            '              precision    recall  f1-score   support\n'
+            '\n'
+            '    negative       0.90      0.90      0.90         4\n'
+            '     neutral       0.75      0.75      0.75         4\n'
+            '    positive       0.80      0.80      0.80         4\n'
+            '\n'
+            '    accuracy                           0.83        12\n'
+            '   macro avg       0.82      0.82      0.82        12\n'
+            'weighted avg       0.83      0.83      0.83        12\n'
+        , language="python")
+
+    # Why Deep Learning's Depth Matters
+    st.header("Why Deep Learning's Depth Matters")
+    st.markdown("""
+    Deep learning models like BERT can understand complex patterns, sarcasm, and implied meaning because each layer learns increasingly abstract features. This is why they outperform traditional ML on nuanced text tasks.
+    """)
+    with st.expander("Example: Complex Cases"):
+        st.code(
+            'complex_cases = [\n'
+            '    "I\'m fine :) everything\'s totally under control :) :)",\n'
+            '    "lol guess I\'m just built different, thriving on 2hrs sleep",\n'
+            '    "Not that I\'m complaining, but this workload is killing me"\n'
+            ']\n'
+            'for case in complex_cases:\n'
+            '    result = classifier(case)[0]\n'
+            '    print(f"{case} → {result[\'label\']} (confidence: {result[\'score\']:.2f})")\n'
+        , language="python")
+        st.write("BERT's deep layers help it catch sarcasm, contradictions, and hidden stress.")
+        
+        st.markdown("**Example Output:**")
+        st.code(
+            'I\'m fine :) everything\'s totally under control :) :) → NEGATIVE (confidence: 0.92)\n'
+            'lol guess I\'m just built different, thriving on 2hrs sleep → NEGATIVE (confidence: 0.78)\n'
+            'Not that I\'m complaining, but this workload is killing me → NEGATIVE (confidence: 0.85)\n'
+        , language="python")
+        st.write("BERT correctly identifies excessive positivity, normalized concerning behavior, and mixed signals as negative sentiment.")
+
+    # Research Reflection & Ethics
+    st.header("Critical Research Reflection & Ethics")
+    st.markdown("""
+    **Advantages:**
+    - Context awareness (negation, sarcasm, implied meaning)
+    - Consistency and scalability
+    - Transferability to new domains
+    
+    **Limitations:**
+    - May struggle with slang, asterisks, or masked emotions
+    - Not always explainable
+    - Requires validation and ethical consideration
+    
+    **Ethics Discussion:**
+    1. Does BERT work equally well for all student populations?
+    2. How do we protect student anonymity?
+    3. What is our responsibility with concerning content?
+    4. How do we verify our ground truth labels?
+    """)
+    with st.expander("Example: Edge Cases & Limitations"):
+        st.code(
+            'edge_cases = [\n'
+            '    "tbh everything\'s mid rn but like whatever",\n'
+            '    "Academic stress? What\'s that? *nervous laughter*",\n'
+            '    "Everything is absolutely perfect and wonderful!!"\n'
+            ']\n'
+            'for case in edge_cases:\n'
+            '    result = classifier(case)[0]\n'
+            '    print(f"{case} → {result[\'label\']} (confidence: {result[\'score\']:.2f})")\n'
+        , language="python")
+        st.write("Would you trust this for research decisions?")
+        
+        st.markdown("**Example Output:**")
+        st.code(
+            'tbh everything\'s mid rn but like whatever → NEUTRAL (confidence: 0.65)\n'
+            'Academic stress? What\'s that? *nervous laughter* → POSITIVE (confidence: 0.72)\n'
+            'Everything is absolutely perfect and wonderful!! → POSITIVE (confidence: 0.88)\n'
+        , language="python")
+        st.write("These results show BERT's limitations with slang, asterisk actions, and potentially masked emotions.")
+
+    # When to Use Deep Learning vs. Traditional ML
+    st.header("When to Use Deep Learning vs. Traditional ML")
+    st.markdown("""
+    **Use BERT (Deep Learning) when:**
+    - Context and nuance matter (like sentiment analysis)
+    - You have unstructured text data
+    - Traditional ML struggles with the complexity
+    - You need to scale to large datasets
+    
+    **Stick with Traditional ML when:**
+    - You need perfect explainability
+    - Simple patterns work well
+    - Very small datasets (<100 examples)
+    - Computational resources are limited
+    """)
+
+    # Take-Home Exercise
+    st.header("Take-Home Exercise: Apply BERT to Your Research")
+    st.markdown("""
+    **Choose Your Research Adventure:**
+    1. Social Media Analysis: Sentiment about a current campus issue
+    2. Literature Research: Compare emotional tone across different authors
+    3. Survey Analysis: Classify open-ended course feedback
+    
+    **Requirements:**
+    - Use BERT pipeline from today
+    - Analyze 20+ text samples
+    - Evaluate results critically
+    - Identify cases needing expert review
+    
+    **Reflection Questions:**
+    - When did BERT's deep learning approach outperform what simple word counting could do?
+    - Where would you still need human expert judgment?
+    - How could this scale your research capabilities?
+    """)
+
+    st.success("You've just learned to use one of the most powerful tools in modern AI research. Try BERT on your own research question this week!") 

main.py

@@ -25,6 +25,7 @@ from course_pages import week_5
 from course_pages import week_6
 from course_pages import week_7
 from course_pages import week_8
+from course_pages import week_9
 # Page configuration
 st.set_page_config(
     page_title="Data Science Course App",
@@ -193,6 +194,8 @@ def show_week_content():
         week_7.show()
     elif st.session_state.current_week == 8:
         week_8.show()
+    elif st.session_state.current_week == 9:
+        week_9.show()
     else:
         st.warning("Content for this week is not yet available.")
 
@@ -205,7 +208,7 @@ def main():
         return
     
     # User is logged in, show course content
-    if st.session_state.current_week in [1, 2, 3, 4, 5, 6, 7, 8]:
+    if st.session_state.current_week in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
         show_week_content()
     else:
         st.title("Data Science Research Paper Course")