changes

README.md

@@ -14,7 +14,7 @@ Backend API for the CBT Companion mental health support app.
 ## Features
 
 - 🔐 User authentication (register/login)
-- 🧠 Cognitive distortion classification (TinyBERT)
+- 🧠 Cognitive distortion classification (LLM-based)
 - 💬 Therapeutic conversations (Groq LLaMA 3.3)
 - 🚨 Crisis detection and flagging
 - 📊 User statistics tracking

app.py

@@ -6,7 +6,6 @@ Hosted on HuggingFace Spaces
 
 from flask import Flask, request, jsonify
 from flask_cors import CORS
-from classifier import DistortionClassifier
 from groq_client import GroqClient
 from database import get_db
 from auth import register_user, login_user, token_required
@@ -27,7 +26,6 @@ app.register_blueprint(wearable_bp)
 app.register_blueprint(admin_bp)
 
 # Initialize components
-classifier = DistortionClassifier()
 groq_client = GroqClient(api_key=os.environ.get("GROQ_API_KEY"))
 
 
@@ -198,8 +196,8 @@ def chat():
         beck_data = db.get_beck_session(session_id)
 
         if not beck_data:
-            # First message - check if distorted
-            classification = classifier.classify(user_message)
+            # First message - check if distorted using LLM
+            classification = groq_client.classify_distortion(user_message)
 
             if classification["group"] == "G0":
                 # No distortion - supportive listening

classifier.py

@@ -1,142 +0,0 @@
-"""
-Cognitive Distortion Classifier
-Uses TinyBERT model from HuggingFace
-"""
-
-import torch
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-import torch.nn.functional as F
-
-
-class DistortionClassifier:
-    """
-    Classifies text into cognitive distortion groups.
-    
-    Groups:
-    - G0: No Distortion
-    - G1: Binary & Global Evaluation (All-or-nothing, Labeling)
-    - G2: Overgeneralized Beliefs (Overgeneralization, Mind Reading, Fortune-telling)
-    - G3: Attentional Bias (Mental Filter, Magnification)
-    - G4: Self-Referential Reasoning (Emotional Reasoning, Personalization, Should statements)
-    """
-    
-    MODEL_NAME = "santa47/cbt-distortion-classifier-bert"
-    
-    def __init__(self):
-        print(f"Loading classifier from {self.MODEL_NAME}...")
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        print(f"Using device: {self.device}")
-        
-        self.tokenizer = AutoTokenizer.from_pretrained(self.MODEL_NAME)
-        self.model = AutoModelForSequenceClassification.from_pretrained(self.MODEL_NAME)
-        self.model.to(self.device)
-        self.model.eval()
-        
-        # Label mapping
-        self.id_to_label = {
-            0: "G0",
-            1: "G1", 
-            2: "G2",
-            3: "G3",
-            4: "G4"
-        }
-        
-        self.label_info = {
-            "G0": {
-                "name": "No Distortion Detected",
-                "description": "Healthy, balanced thinking",
-                "distortions": []
-            },
-            "G1": {
-                "name": "Binary & Global Evaluation",
-                "description": "All-or-nothing thinking patterns",
-                "distortions": ["All-or-nothing thinking", "Labeling"]
-            },
-            "G2": {
-                "name": "Overgeneralized Beliefs",
-                "description": "Making broad conclusions from limited evidence",
-                "distortions": ["Overgeneralization", "Mind Reading", "Fortune-telling"]
-            },
-            "G3": {
-                "name": "Attentional & Salience Bias",
-                "description": "Focusing on negatives, ignoring positives",
-                "distortions": ["Mental Filter", "Magnification"]
-            },
-            "G4": {
-                "name": "Self-Referential & Emotion-Driven",
-                "description": "Letting emotions drive conclusions",
-                "distortions": ["Emotional Reasoning", "Personalization", "Should statements"]
-            }
-        }
-        
-        print("✅ Classifier loaded successfully!")
-    
-    def classify(self, text: str) -> dict:
-        """
-        Classify text into a distortion group.
-        
-        Args:
-            text: Input text to classify
-            
-        Returns:
-            dict with group, confidence, and group info
-        """
-        # Tokenize
-        inputs = self.tokenizer(
-            text,
-            return_tensors="pt",
-            truncation=True,
-            max_length=512,
-            padding=True
-        )
-        inputs = {k: v.to(self.device) for k, v in inputs.items()}
-        
-        # Predict
-        with torch.no_grad():
-            outputs = self.model(**inputs)
-            logits = outputs.logits
-            probabilities = F.softmax(logits, dim=-1)
-            
-            predicted_class = torch.argmax(probabilities, dim=-1).item()
-            confidence = probabilities[0][predicted_class].item()
-        
-        # Get group label
-        group = self.id_to_label.get(predicted_class, "G0")
-        group_info = self.label_info.get(group, {})
-        
-        return {
-            "group": group,
-            "confidence": round(confidence, 4),
-            "group_name": group_info.get("name", "Unknown"),
-            "description": group_info.get("description", ""),
-            "distortions": group_info.get("distortions", []),
-            "all_probabilities": {
-                self.id_to_label[i]: round(probabilities[0][i].item(), 4)
-                for i in range(len(self.id_to_label))
-            }
-        }
-    
-    def get_group_info(self, group: str) -> dict:
-        """Get detailed info about a distortion group."""
-        return self.label_info.get(group, {})
-
-
-# Test if run directly
-if __name__ == "__main__":
-    classifier = DistortionClassifier()
-    
-    test_texts = [
-        "I failed my exam. I'll never succeed at anything.",
-        "My friend didn't text back. She must hate me.",
-        "I made one mistake so the whole project is ruined.",
-        "I feel anxious so something bad must be happening.",
-        "I had a nice day today and enjoyed my lunch."
-    ]
-    
-    print("\n🧪 Testing classifier:\n")
-    for text in test_texts:
-        result = classifier.classify(text)
-        print(f"Text: {text[:50]}...")
-        print(f"  → {result['group']}: {result['group_name']}")
-        print(f"  → Confidence: {result['confidence']}")
-        print()

groq_client.py

@@ -279,6 +279,118 @@ Respond as Aria for the {current_state} state."""
             print(f"Agent 3 error: {e}")
             return f"You've done really good work here, {user_name}. 💙"
 
+    # ==================== COGNITIVE DISTORTION CLASSIFIER ====================
+
+    def classify_distortion(self, text: str) -> dict:
+        """
+        Classify text into cognitive distortion groups using LLM.
+
+        Groups:
+        - G0: No Distortion
+        - G1: Binary & Global Evaluation (All-or-nothing, Labeling)
+        - G2: Overgeneralized Beliefs (Overgeneralization, Mind Reading, Fortune-telling)
+        - G3: Attentional Bias (Mental Filter, Magnification)
+        - G4: Self-Referential Reasoning (Emotional Reasoning, Personalization, Should statements)
+
+        Args:
+            text: User's thought to classify
+
+        Returns:
+            dict with group, confidence, group_name, description, and distortions
+        """
+        system_prompt = """You are a cognitive distortion classifier for CBT (Cognitive Behavioral Therapy).
+
+Analyze the user's thought and classify it into ONE of these groups:
+
+G0: No Distortion - Healthy, balanced thinking
+G1: Binary & Global Evaluation - All-or-nothing thinking, Labeling
+G2: Overgeneralized Beliefs - Overgeneralization, Mind Reading, Fortune-telling
+G3: Attentional & Salience Bias - Mental Filter, Magnification/Minimization
+G4: Self-Referential & Emotion-Driven - Emotional Reasoning, Personalization, Should statements
+
+Examples:
+- "I failed my exam. I'll never succeed at anything." → G1 (all-or-nothing)
+- "My friend didn't text back. She must hate me." → G2 (mind reading)
+- "Everything in my life is terrible." → G3 (mental filter)
+- "I feel anxious so something bad must be happening." → G4 (emotional reasoning)
+- "I had a nice day today and enjoyed my lunch." → G0 (no distortion)
+
+Respond ONLY in JSON format:
+{
+  "group": "G0/G1/G2/G3/G4",
+  "confidence": 0.85,
+  "reasoning": "Brief explanation of why this classification"
+}"""
+
+        user_prompt = f'Classify this thought: "{text}"'
+
+        try:
+            response = self.client.chat.completions.create(
+                model=self.MODEL,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.3,
+                max_tokens=200,
+                response_format={"type": "json_object"}
+            )
+
+            result = json.loads(response.choices[0].message.content)
+            group = result.get("group", "G0")
+
+            # Group information
+            label_info = {
+                "G0": {
+                    "name": "No Distortion Detected",
+                    "description": "Healthy, balanced thinking",
+                    "distortions": []
+                },
+                "G1": {
+                    "name": "Binary & Global Evaluation",
+                    "description": "All-or-nothing thinking patterns",
+                    "distortions": ["All-or-nothing thinking", "Labeling"]
+                },
+                "G2": {
+                    "name": "Overgeneralized Beliefs",
+                    "description": "Making broad conclusions from limited evidence",
+                    "distortions": ["Overgeneralization", "Mind Reading", "Fortune-telling"]
+                },
+                "G3": {
+                    "name": "Attentional & Salience Bias",
+                    "description": "Focusing on negatives, ignoring positives",
+                    "distortions": ["Mental Filter", "Magnification"]
+                },
+                "G4": {
+                    "name": "Self-Referential & Emotion-Driven",
+                    "description": "Letting emotions drive conclusions",
+                    "distortions": ["Emotional Reasoning", "Personalization", "Should statements"]
+                }
+            }
+
+            group_info = label_info.get(group, label_info["G0"])
+
+            return {
+                "group": group,
+                "confidence": round(result.get("confidence", 0.8), 4),
+                "group_name": group_info["name"],
+                "description": group_info["description"],
+                "distortions": group_info["distortions"],
+                "reasoning": result.get("reasoning", "")
+            }
+
+        except Exception as e:
+            print(f"Classification error: {e}")
+            # Default to G0 (no distortion) on error
+            return {
+                "group": "G0",
+                "confidence": 0.5,
+                "group_name": "No Distortion Detected",
+                "description": "Healthy, balanced thinking",
+                "distortions": [],
+                "reasoning": "Classification failed, defaulting to G0"
+            }
+
     # ==================== SUPPORTIVE RESPONSE (G0 - No Distortion) ====================
 
     def generate_supportive_response(

requirements.txt

@@ -5,8 +5,6 @@ gunicorn==21.2.0
 
 # AI/ML
 numpy<2
-transformers==4.36.0
-torch==2.1.0
 httpx>=0.27.0,<0.28.0
 groq>=0.11.0
 

test_beck_protocol.py

@@ -5,16 +5,20 @@ Run this to verify the 3-agent system works
 
 import os
 from groq_client import GroqClient
-from classifier import DistortionClassifier
 
 # Test the components
 def test_classifier():
-    """Test that classifier still works for binary detection"""
+    """Test LLM-based cognitive distortion classification"""
     print("=" * 60)
-    print("TEST 1: CLASSIFIER (Binary Detection)")
+    print("TEST 1: LLM CLASSIFIER (Cognitive Distortion Detection)")
     print("=" * 60)
 
-    classifier = DistortionClassifier()
+    api_key = os.environ.get("GROQ_API_KEY")
+    if not api_key:
+        print("❌ GROQ_API_KEY not set - skipping classifier test")
+        return
+
+    client = GroqClient(api_key)
 
     test_cases = [
         ("I had a nice day today", "G0"),
@@ -23,12 +27,13 @@ def test_classifier():
     ]
 
     for text, expected in test_cases:
-        result = classifier.classify(text)
+        result = client.classify_distortion(text)
         print(f"\nText: {text[:50]}...")
         print(f"  Predicted: {result['group']} ({result['confidence']:.2%})")
+        print(f"  Reasoning: {result.get('reasoning', 'N/A')}")
         print(f"  Expected: {expected}")
 
-    print("\n✅ Classifier test complete\n")
+    print("\n✅ LLM Classifier test complete\n")
 
 
 def test_agent1():