1M training data

DEPLOY_GUIDE.md

@@ -1,238 +0,0 @@
-# 🚀 HuggingFace Space Deployment Guide
-
-This guide will help you deploy the AletheionGuard Space to HuggingFace.
-
-## 📋 Prerequisites
-
-1. **HuggingFace Account**: Sign up at https://huggingface.co/join
-2. **Git LFS**: Install Git Large File Storage
-   ```bash
-   # Ubuntu/Debian
-   sudo apt-get install git-lfs
-
-   # macOS
-   brew install git-lfs
-
-   # Initialize
-   git lfs install
-   ```
-3. **HuggingFace CLI** (optional but recommended):
-   ```bash
-   pip install huggingface_hub
-   huggingface-cli login
-   ```
-
-## 🔑 Step 1: Create Access Token
-
-1. Go to https://huggingface.co/settings/tokens
-2. Click **New token**
-3. Name: `AletheionGuard Deploy`
-4. Type: **Write** (needed to push to Space)
-5. Copy the token (starts with `hf_...`)
-
-## 📦 Step 2: Create New Space
-
-### Option A: Via Web Interface (Easiest)
-
-1. Go to https://huggingface.co/new-space
-2. Fill in details:
-   - **Owner**: Your username or organization
-   - **Space name**: `aletheionguard` (or your preferred name)
-   - **License**: AGPL-3.0
-   - **SDK**: Docker
-   - **Visibility**: Public or Private (choose Private for BYO-HF mode)
-3. Click **Create Space**
-4. You'll be redirected to your new Space
-
-### Option B: Via CLI
-
-```bash
-huggingface-cli repo create aletheionguard --type space --space_sdk docker
-```
-
-## 📤 Step 3: Push Files to Space
-
-Navigate to the Space directory:
-
-```bash
-cd /home/sapo/AletheionGuard/hf_space_example/AletheionGuard
-```
-
-### First-time Setup (if not already a git repo)
-
-```bash
-# Check if already initialized
-git status
-
-# If not, initialize
-git init
-git lfs install
-git lfs track "*.pth"
-git lfs track "*.ckpt"
-```
-
-### Add HuggingFace Remote
-
-Replace `YOUR_USERNAME` with your HuggingFace username:
-
-```bash
-git remote add hf https://huggingface.co/spaces/YOUR_USERNAME/aletheionguard
-```
-
-### Commit and Push
-
-```bash
-# Stage all files
-git add .
-
-# Commit
-git commit -m "Initial commit: AletheionGuard Space with Trial 012 models"
-
-# Push to HuggingFace
-git push hf main
-```
-
-If prompted for credentials:
-- **Username**: Your HuggingFace username
-- **Password**: Your HF token (starts with `hf_...`)
-
-## 🔧 Step 4: Configure Space Settings
-
-1. Go to your Space: `https://huggingface.co/spaces/YOUR_USERNAME/aletheionguard`
-2. Click **Settings**
-3. Configure:
-   - **Hardware**: CPU Basic (free) or upgrade if needed
-   - **Persistent Storage**: Optional (0 GB for this Space)
-   - **Secrets**: Add `HUGGINGFACE_TOKEN` if needed for authentication
-4. Click **Save**
-
-## ✅ Step 5: Verify Deployment
-
-1. Wait for build to complete (check **Build logs** tab)
-2. Once "Running", test the endpoints:
-
-```bash
-# Health check
-curl https://YOUR_USERNAME-aletheionguard.hf.space/health
-
-# Predict (requires auth if Space is private)
-curl -X POST https://YOUR_USERNAME-aletheionguard.hf.space/predict \
-  -H "Authorization: Bearer hf_YOUR_TOKEN" \
-  -H "Content-Type: application/json" \
-  -d '{"text": "Paris is the capital of France"}'
-```
-
-Expected response:
-```json
-{
-  "q1": 0.06,
-  "q2": 0.08,
-  "height": 0.90,
-  "message": "Heuristic metrics computed successfully.",
-  "verdict": "ACCEPT"
-}
-```
-
-## 🔄 Step 6: Update Models (After Fine-tuning)
-
-After fine-tuning with `scripts/finetune_real_data.py`:
-
-```bash
-# Copy new models
-cp /home/sapo/AletheionGuard/models/real_finetuned/*.pth .
-cp /home/sapo/AletheionGuard/models/real_finetuned/q1q2-finetuned-*.ckpt q1q2_best.ckpt
-
-# Update metadata
-nano model_info.json  # Update training info and metrics
-
-# Commit and push
-git add *.pth *.ckpt model_info.json
-git commit -m "Update to fine-tuned models (TruthfulQA + SQuAD)"
-git push hf main
-```
-
-## 📊 Monitoring & Logs
-
-- **View logs**: Click **Logs** tab in your Space
-- **Restart Space**: Click **Factory reboot** if needed
-- **Monitor usage**: Check **Analytics** tab
-
-## 💰 Costs & Limits
-
-### Free Tier (CPU Basic)
-- ✅ Perfect for demos and low-traffic
-- ✅ Includes: 2 vCPU, 16 GB RAM
-- ❌ Limited to ~1000 requests/day
-- ❌ May sleep after inactivity
-
-### Paid Tier (Upgrade Options)
-- **CPU Upgrade** ($0.03/hour): 4 vCPU, 32 GB RAM
-- **GPU T4** ($0.60/hour): For faster inference
-- **Persistent**: Space never sleeps
-
-To upgrade:
-1. Go to Space → Settings → Hardware
-2. Select tier → Upgrade
-
-## 🔐 Using with BYO-HF Mode
-
-After deployment, use your Space with AletheionGuard:
-
-```python
-from aletheion_guard import EpistemicAuditor
-
-auditor = EpistemicAuditor(
-    mode="byo-hf",
-    hf_space_url="https://huggingface.co/spaces/YOUR_USERNAME/aletheionguard",
-    hf_token="hf_YOUR_TOKEN"  # Only if Space is private
-)
-
-result = auditor.evaluate("The Earth is flat")
-print(f"Verdict: {result.verdict}, Height: {result.height}")
-```
-
-## 🐛 Troubleshooting
-
-### Build Failed
-
-Check **Build logs** for errors. Common issues:
-
-1. **LFS bandwidth exceeded**: Use HuggingFace Pro ($9/month)
-2. **File too large**: Compress models or use smaller batch size during training
-3. **Docker build timeout**: Simplify Dockerfile or reduce dependencies
-
-### Space Not Starting
-
-1. Check **Logs** tab for runtime errors
-2. Verify `app.py` has no syntax errors
-3. Ensure all model files are present
-4. Try **Factory reboot**
-
-### Authentication Errors
-
-1. Ensure HF token has **Write** permissions
-2. For private Spaces, include token in requests
-3. Check token expiration
-
-### Slow Inference
-
-1. Upgrade to GPU hardware
-2. Optimize model (quantization, pruning)
-3. Use caching for repeated requests
-
-## 📚 Resources
-
-- **HuggingFace Spaces Docs**: https://huggingface.co/docs/hub/spaces
-- **Git LFS**: https://git-lfs.github.com/
-- **Docker for Spaces**: https://huggingface.co/docs/hub/spaces-sdks-docker
-- **AletheionGuard Docs**: https://docs.aletheion.com
-
-## 💬 Support
-
-- **Email**: support@aletheion.com
-- **Discord**: https://discord.gg/aletheion
-- **GitHub Issues**: https://github.com/AletheionAGI/AletheionGuard/issues
-
----
-
-**Ready to deploy?** Follow the steps above and you'll have your Space running in minutes! 🚀

FIX_GIT_LFS.md

@@ -1,125 +0,0 @@
-# 🔧 Fix Git LFS for HuggingFace Push
-
-O push falhou porque o Git LFS não está configurado. Siga estes passos:
-
-## Passo 1: Instalar Git LFS
-
-```bash
-# Para Ubuntu/Debian/WSL
-curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash
-sudo apt-get install git-lfs
-
-# Verificar instalação
-git lfs version
-```
-
-## Passo 2: Configurar Git LFS no Repositório
-
-```bash
-cd /home/sapo/AletheionGuard/hf_space_example/AletheionGuard
-
-# Inicializar Git LFS
-git lfs install
-
-# Verificar que .gitattributes existe e tem as configurações corretas
-cat .gitattributes
-```
-
-## Passo 3: Resetar o Commit Anterior e Re-adicionar com LFS
-
-```bash
-# Voltar um commit (desfazer o commit que falhou no push)
-git reset --soft HEAD~1
-
-# Verificar arquivos que precisam de LFS
-ls -lh *.pth *.ckpt
-
-# Re-adicionar arquivos (agora com LFS)
-git add .gitattributes
-git add *.pth
-git add *.ckpt
-git add *.py
-git add *.md
-git add *.txt
-git add Dockerfile
-
-# Verificar que os arquivos grandes estão no LFS
-git lfs ls-files
-
-# Commit novamente
-git commit -m "Initial commit: AletheionGuard Space with Trial 012 models"
-```
-
-## Passo 4: Push para HuggingFace
-
-```bash
-# Push
-git push
-
-# Se pedir credenciais:
-# Username: gnai-creator
-# Password: seu token HF (hf_...)
-```
-
-## Verificar Arquivos LFS
-
-Após adicionar os arquivos, você deve ver algo assim:
-
-```bash
-$ git lfs ls-files
-c9a5b2e1f3 * base_forces.pth
-d4f8c7a2b1 * height_gate.pth
-e3d9b4f8c2 * q1_gate.pth
-f2e8a3d7c1 * q2_gate.pth
-a1b2c3d4e5 * q1q2_best.ckpt
-```
-
-## Solução Alternativa (Se Git LFS Não Funcionar)
-
-Se você não conseguir instalar o Git LFS, pode:
-
-1. **Remover os modelos grandes** e fazer upload manual depois:
-   ```bash
-   git rm --cached *.pth *.ckpt
-   git commit -m "Remove large files temporarily"
-   git push
-   ```
-
-2. **Upload manual pelo site**:
-   - Vá para https://huggingface.co/spaces/gnai-creator/AletheionGuard
-   - Clique em "Files" → "Upload files"
-   - Faça upload dos arquivos `.pth` e `.ckpt` manualmente
-
-3. **Ou use modelos menores/mock** para demonstração:
-   - Edite `app.py` para usar apenas heurísticas (já implementado como fallback)
-   - Remove a necessidade dos arquivos `.pth`
-
-## Comandos Úteis
-
-```bash
-# Ver status do LFS
-git lfs status
-
-# Ver arquivos rastreados pelo LFS
-git lfs ls-files
-
-# Ver tamanho dos arquivos
-du -sh *.pth *.ckpt
-
-# Limpar cache LFS se necessário
-git lfs prune
-```
-
-## Problema Comum: "last.ckpt"
-
-O arquivo `last.ckpt` não deveria estar no repositório. Para removê-lo:
-
-```bash
-# Se ele foi adicionado por engano
-git rm last.ckpt
-git commit -m "Remove last.ckpt"
-```
-
----
-
-**Depois de seguir estes passos, tente o push novamente!** 🚀

app.py.backup

@@ -1,158 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-or-later
-# Copyright (c) 2024-2025 Felipe Maya Muniz
-
-"""
-Reference Hugging Face Space for AletheionGuard BYO-HF mode.
-
-This is a minimal FastAPI endpoint that clients can deploy on Hugging Face Spaces
-to use with AletheionGuard's BYO-HF mode.
-
-Deploy this Space as PRIVATE and use your HF token + Space URL with AletheionGuard.
-"""
-
-from fastapi import FastAPI, HTTPException, Header
-from pydantic import BaseModel
-from typing import Optional
-import logging
-import math
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-app = FastAPI(
-    title="AletheionGuard HF Space",
-    description="Reference endpoint for BYO-HF mode",
-    version="1.0.0"
-)
-
-
-class PredictRequest(BaseModel):
-    """Request model for /predict endpoint."""
-    text: str
-    context: Optional[str] = None
-
-
-class PredictResponse(BaseModel):
-    """Response model for /predict endpoint."""
-    q1: float
-    q2: float
-    height: float
-    message: str
-    verdict: Optional[str] = None  # Optional debug field - NOT used by API
-
-
-def get_verdict(q1: float, q2: float, height: float) -> str:
-    """
-    Calculate verdict for debug purposes only.
-
-    NOTE: This is NOT the official verdict. The official verdict is always
-    calculated by the AletheionGuard API using the same rule.
-
-    Official epistemic rule:
-    - u = 1.0 - height (total uncertainty)
-    - If q2 >= 0.35 OR u >= 0.60 → REFUSED
-    - If q1 >= 0.35 OR (0.30 <= u < 0.60) → MAYBE
-    - Otherwise → ACCEPT
-    """
-    u = 1.0 - height  # Total uncertainty
-
-    if q2 >= 0.35 or u >= 0.60:
-        return "REFUSED"
-    if q1 >= 0.35 or (0.30 <= u < 0.60):
-        return "MAYBE"
-    return "ACCEPT"
-
-
-@app.get("/")
-def root():
-    """Root endpoint."""
-    return {
-        "name": "AletheionGuard HF Space",
-        "version": "1.0.0",
-        "status": "operational"
-    }
-
-
-@app.post("/predict", response_model=PredictResponse)
-def predict(
-    request: PredictRequest,
-    authorization: str = Header(...)
-):
-    """
-    Predict endpoint for text analysis.
-
-    Returns heuristic uncertainty metrics (q1, q2, height) and optional verdict.
-
-    NOTE: This is an MVP implementation using heuristics. For production:
-    1. Load a sentence-transformer model
-    2. Use trained Q1/Q2 gates to compute actual metrics
-    3. Return embeddings/logits for calibration
-
-    Args:
-        request: Text and optional context
-        authorization: Bearer token (verified by HF automatically)
-
-    Returns:
-        Heuristic metrics with optional debug verdict
-
-    Example:
-        >>> POST /predict
-        >>> Headers: Authorization: Bearer hf_...
-        >>> Body: {"text": "Paris is the capital of France", "context": "geography"}
-        >>> Response: {"q1": 0.06, "q2": 0.18, "height": 0.81, "verdict": "ACCEPT"}
-    """
-    try:
-        logger.info(f"Received prediction request - text_length={len(request.text)}")
-
-        # MVP: Compute heuristic metrics (replace with actual model in production)
-        # Simple heuristics based on text characteristics:
-        text_len = len(request.text)
-        word_count = len(request.text.split())
-        has_context = request.context is not None
-
-        # Heuristic Q1 (aleatoric): based on text ambiguity indicators
-        # Lower for factual statements, higher for opinion/uncertain language
-        q1 = min(0.30, 0.05 + (word_count / 200))  # Increases with verbosity
-        if any(word in request.text.lower() for word in ["maybe", "possibly", "might", "could"]):
-            q1 += 0.15
-
-        # Heuristic Q2 (epistemic): based on model confidence indicators
-        # Lower for common topics, higher for rare/complex topics
-        q2 = 0.10 if text_len > 20 else 0.20  # More text = more context
-        if has_context:
-            q2 -= 0.05  # Context helps reduce epistemic uncertainty
-        if any(word in request.text.lower() for word in ["quantum", "theoretical", "hypothetical"]):
-            q2 += 0.20
-
-        # Ensure bounds [0, 1]
-        q1 = max(0.0, min(1.0, q1))
-        q2 = max(0.0, min(1.0, q2))
-
-        # Compute height from pyramidal formula
-        height = max(0.0, min(1.0, 1.0 - math.sqrt(q1**2 + q2**2)))
-
-        # Compute verdict (optional debug field)
-        verdict = get_verdict(q1, q2, height)
-
-        return PredictResponse(
-            q1=round(q1, 3),
-            q2=round(q2, 3),
-            height=round(height, 3),
-            message="Heuristic metrics computed successfully.",
-            verdict=verdict  # Debug only - API ignores this
-        )
-
-    except Exception as e:
-        logger.error(f"Prediction failed: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/health")
-def health():
-    """Health check endpoint."""
-    return {"status": "healthy"}
-
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)  # HF Spaces use port 7860

app_fixed.py

@@ -1,351 +0,0 @@
-# SPDX-License-Identifier: AGPL-3.0-or-later
-# Copyright (c) 2024-2025 Felipe Maya Muniz
-
-"""
-Production Hugging Face Space for AletheionGuard.
-
-This endpoint loads the trained neural models and provides accurate
-epistemic uncertainty estimation using the full AletheionGuard architecture.
-"""
-
-from fastapi import FastAPI, HTTPException, Header
-from pydantic import BaseModel
-from typing import Optional
-import logging
-import math
-import torch
-import torch.nn as nn
-from sentence_transformers import SentenceTransformer
-from pathlib import Path
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-app = FastAPI(
-    title="AletheionGuard HF Space",
-    description="Production epistemic uncertainty estimation",
-    version="2.0.0"
-)
-
-
-# ============================================================================
-# Model Definitions (copied from q1q2_gates.py)
-# ============================================================================
-
-class UncertaintyNetwork(nn.Module):
-    """Base neural network for uncertainty estimation."""
-
-    def __init__(
-        self,
-        input_dim: int = 384,
-        hidden_dim: int = 256,
-        num_layers: int = 3,
-        dropout: float = 0.1
-    ):
-        super().__init__()
-
-        self.input_dim = input_dim
-        self.hidden_dim = hidden_dim
-        self.num_layers = num_layers
-
-        # Build MLP layers
-        layers = []
-
-        # Input layer
-        layers.append(nn.Linear(input_dim, hidden_dim))
-        layers.append(nn.ReLU())
-        layers.append(nn.Dropout(dropout))
-
-        # Hidden layers
-        for _ in range(num_layers - 1):
-            layers.append(nn.Linear(hidden_dim, hidden_dim))
-            layers.append(nn.ReLU())
-            layers.append(nn.Dropout(dropout))
-
-        # Output layer (single uncertainty value)
-        layers.append(nn.Linear(hidden_dim, 1))
-        layers.append(nn.Sigmoid())  # Clamp to [0, 1]
-
-        self.network = nn.Sequential(*layers)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if x.dim() == 1:
-            x = x.unsqueeze(0)
-            single_sample = True
-        else:
-            single_sample = False
-
-        output = self.network(x)
-
-        if single_sample:
-            output = output.squeeze(0)
-
-        return output
-
-
-class Q1Gate(nn.Module):
-    """Aleatoric uncertainty gate (Q1)."""
-
-    def __init__(self, input_dim: int = 384, hidden_dim: int = 256):
-        super().__init__()
-        self.network = UncertaintyNetwork(
-            input_dim=input_dim,
-            hidden_dim=hidden_dim,
-            num_layers=3,
-            dropout=0.1
-        )
-
-    def forward(self, embeddings: torch.Tensor) -> torch.Tensor:
-        return self.network(embeddings)
-
-
-class Q2Gate(nn.Module):
-    """Epistemic uncertainty gate (Q2) - conditioned on Q1."""
-
-    def __init__(self, input_dim: int = 384, hidden_dim: int = 256):
-        super().__init__()
-        # Q2 is conditioned on Q1, so input is embeddings + Q1 value
-        self.network = UncertaintyNetwork(
-            input_dim=input_dim + 1,  # +1 for Q1 conditioning
-            hidden_dim=hidden_dim,
-            num_layers=3,
-            dropout=0.1
-        )
-
-    def forward(self, embeddings: torch.Tensor, q1: torch.Tensor) -> torch.Tensor:
-        # Handle single sample
-        if embeddings.dim() == 1:
-            embeddings = embeddings.unsqueeze(0)
-            single_sample = True
-        else:
-            single_sample = False
-
-        # Convert Q1 to tensor if needed
-        if isinstance(q1, float):
-            q1 = torch.tensor([[q1]], dtype=embeddings.dtype, device=embeddings.device)
-        elif q1.dim() == 0:
-            q1 = q1.unsqueeze(0).unsqueeze(0)
-        elif q1.dim() == 1:
-            q1 = q1.unsqueeze(1)
-
-        # Concatenate embeddings with Q1 for conditioning
-        combined = torch.cat([embeddings, q1], dim=1)
-        output = self.network(combined)
-
-        if single_sample:
-            output = output.squeeze(0)
-
-        return output
-
-
-# ============================================================================
-# Global Model State
-# ============================================================================
-
-class ModelState:
-    """Global state for loaded models."""
-
-    def __init__(self):
-        self.encoder = None
-        self.q1_gate = None
-        self.q2_gate = None
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        self.loaded = False
-
-    def load_models(self):
-        """Load all models at startup."""
-        if self.loaded:
-            return
-
-        try:
-            logger.info("🔧 Loading models...")
-
-            # 1. Load sentence transformer for embeddings
-            logger.info("  Loading sentence transformer...")
-            self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
-            self.encoder.eval()
-            logger.info("  ✓ Sentence transformer loaded")
-
-            # 2. Load Q1 gate
-            logger.info("  Loading Q1 gate...")
-            self.q1_gate = Q1Gate(input_dim=384, hidden_dim=256)
-            if Path('q1_gate.pth').exists():
-                self.q1_gate.load_state_dict(torch.load('q1_gate.pth', map_location=self.device))
-                logger.info("  ✓ Q1 gate loaded from q1_gate.pth")
-            else:
-                logger.warning("  ⚠️  q1_gate.pth not found, using random weights")
-
-            self.q1_gate.to(self.device)
-            self.q1_gate.eval()
-
-            # 3. Load Q2 gate
-            logger.info("  Loading Q2 gate...")
-            self.q2_gate = Q2Gate(input_dim=384, hidden_dim=256)
-            if Path('q2_gate.pth').exists():
-                self.q2_gate.load_state_dict(torch.load('q2_gate.pth', map_location=self.device))
-                logger.info("  ✓ Q2 gate loaded from q2_gate.pth")
-            else:
-                logger.warning("  ⚠️  q2_gate.pth not found, using random weights")
-
-            self.q2_gate.to(self.device)
-            self.q2_gate.eval()
-
-            self.loaded = True
-            logger.info(f"✅ All models loaded successfully (device: {self.device})")
-
-        except Exception as e:
-            logger.error(f"❌ Failed to load models: {e}")
-            raise
-
-
-# Global model state
-models = ModelState()
-
-
-# ============================================================================
-# API Models
-# ============================================================================
-
-class PredictRequest(BaseModel):
-    """Request model for /predict endpoint."""
-    text: str
-    context: Optional[str] = None
-
-
-class PredictResponse(BaseModel):
-    """Response model for /predict endpoint."""
-    q1: float
-    q2: float
-    height: float
-    message: str
-    verdict: Optional[str] = None
-
-
-def get_verdict(q1: float, q2: float, height: float) -> str:
-    """
-    Calculate verdict using official epistemic rule.
-
-    Official epistemic rule:
-    - u = 1.0 - height (total uncertainty)
-    - If q2 >= 0.35 OR u >= 0.60 → REFUSED
-    - If q1 >= 0.35 OR (0.30 <= u < 0.60) → MAYBE
-    - Otherwise → ACCEPT
-    """
-    u = 1.0 - height  # Total uncertainty
-
-    if q2 >= 0.35 or u >= 0.60:
-        return "REFUSED"
-    if q1 >= 0.35 or (0.30 <= u < 0.60):
-        return "MAYBE"
-    return "ACCEPT"
-
-
-# ============================================================================
-# API Endpoints
-# ============================================================================
-
-@app.on_event("startup")
-async def startup_event():
-    """Load models on startup."""
-    models.load_models()
-
-
-@app.get("/")
-def root():
-    """Root endpoint."""
-    return {
-        "name": "AletheionGuard HF Space",
-        "version": "2.0.0",
-        "status": "operational",
-        "models_loaded": models.loaded
-    }
-
-
-@app.post("/predict", response_model=PredictResponse)
-def predict(
-    request: PredictRequest,
-    authorization: str = Header(...)
-):
-    """
-    Predict endpoint using trained neural models.
-
-    Returns epistemic uncertainty metrics (q1, q2, height) computed by
-    the trained AletheionGuard neural networks.
-
-    Args:
-        request: Text and optional context
-        authorization: Bearer token (verified by HF automatically)
-
-    Returns:
-        Neural-computed metrics with verdict
-
-    Example:
-        >>> POST /predict
-        >>> Headers: Authorization: Bearer hf_...
-        >>> Body: {"text": "Paris is the capital of France", "context": "geography"}
-        >>> Response: {"q1": 0.08, "q2": 0.12, "height": 0.86, "verdict": "ACCEPT"}
-    """
-    try:
-        if not models.loaded:
-            raise HTTPException(status_code=503, detail="Models not loaded")
-
-        logger.info(f"Received prediction request - text_length={len(request.text)}")
-
-        # Combine text and context for embedding
-        full_text = request.text
-        if request.context:
-            full_text = f"{request.context}: {request.text}"
-
-        # 1. Get embeddings from sentence transformer
-        with torch.no_grad():
-            embeddings = models.encoder.encode(
-                full_text,
-                convert_to_tensor=True,
-                device=models.device
-            )
-
-            # 2. Compute Q1 (aleatoric uncertainty)
-            q1_tensor = models.q1_gate(embeddings)
-            q1 = float(q1_tensor.item())
-
-            # 3. Compute Q2 (epistemic uncertainty) - conditioned on Q1
-            q2_tensor = models.q2_gate(embeddings, q1_tensor)
-            q2 = float(q2_tensor.item())
-
-        # 4. Compute height from pyramidal formula
-        # height = 1 - sqrt(q1^2 + q2^2)
-        height = max(0.0, min(1.0, 1.0 - math.sqrt(q1**2 + q2**2)))
-
-        # 5. Calculate verdict
-        verdict = get_verdict(q1, q2, height)
-
-        logger.info(f"Prediction: q1={q1:.3f}, q2={q2:.3f}, height={height:.3f}, verdict={verdict}")
-
-        return PredictResponse(
-            q1=round(q1, 3),
-            q2=round(q2, 3),
-            height=round(height, 3),
-            message="Neural metrics computed successfully.",
-            verdict=verdict
-        )
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Prediction failed: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/health")
-def health():
-    """Health check endpoint."""
-    return {
-        "status": "healthy",
-        "models_loaded": models.loaded,
-        "device": str(models.device)
-    }
-
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)

base_forces.pth

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:add0bf0c721dc6fb30fbaabcf5618d3ff53d571515df4a1e322d5e50dd13a87d
+oid sha256:71808dab230b8abcb6e13e5fdd48179a2eaa170ddede73958cb04e87ce8427b1
 size 201797

height_gate.pth

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1fb33b134d1cf6c2c1ffd457b6e76afc7daac1edc1f91991490d04e294f2bf1d
+oid sha256:d6b67f29aa7e17de5c454c9154d6346a197f03a7609f71f63c6f7f6f97978881
 size 234693

q1_gate.pth

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:70e352e31f20203257c54e3b4fe7e582fe0e8f6aaa50fbe9552a8d685e08cd35
+oid sha256:bb2529a7caf744365b77db5cc5077b1cd924c2792eb5ccfd2cd4a16347fa6d87
 size 925133

q1q2_best.ckpt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c2b608721183b9f4faf75091dd8d3d609a2d65a1b23b5ebc33f5af4ae92f30c3
-size 6861543
+oid sha256:6207b861536f987d67776fcac25bd661837ae2e2a4911091bd094c75dd1e11ca
+size 6861479

q2_gate.pth

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2efa25c4ac9291ce4bbecbd768e7e9850b0977119a614bab6921fd3b32aebd7a
+oid sha256:f7d6bea4db289cbd56a344fb08e4de74fe28d5c3fbc2c08c07678c70180cef65
 size 926157

test_local.py

@@ -1,217 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify the HuggingFace Space locally before deployment.
-
-Usage:
-    python test_local.py
-"""
-
-import requests
-import time
-import sys
-from pathlib import Path
-
-# Colors for terminal output
-GREEN = '\033[92m'
-RED = '\033[91m'
-YELLOW = '\033[93m'
-BLUE = '\033[94m'
-RESET = '\033[0m'
-
-def print_success(msg):
-    print(f"{GREEN}✓{RESET} {msg}")
-
-def print_error(msg):
-    print(f"{RED}✗{RESET} {msg}")
-
-def print_info(msg):
-    print(f"{BLUE}ℹ{RESET} {msg}")
-
-def print_warning(msg):
-    print(f"{YELLOW}⚠{RESET} {msg}")
-
-def check_files():
-    """Check if all required files exist."""
-    print_info("Checking required files...")
-
-    required_files = [
-        "app.py",
-        "requirements.txt",
-        "Dockerfile",
-        "README.md",
-        "model_info.json",
-        "q1_gate.pth",
-        "q2_gate.pth",
-        "height_gate.pth",
-        "base_forces.pth",
-        "q1q2_best.ckpt",
-    ]
-
-    all_exist = True
-    for file in required_files:
-        path = Path(file)
-        if path.exists():
-            size = path.stat().st_size / 1024  # KB
-            print_success(f"{file} ({size:.1f} KB)")
-        else:
-            print_error(f"{file} NOT FOUND")
-            all_exist = False
-
-    return all_exist
-
-def test_api():
-    """Test the FastAPI endpoints."""
-    print_info("\nStarting API tests...")
-    print_warning("Make sure the API is running: python -m uvicorn app:app --port 7860\n")
-
-    base_url = "http://localhost:7860"
-
-    # Test 1: Root endpoint
-    print_info("Test 1: Root endpoint (GET /)")
-    try:
-        response = requests.get(f"{base_url}/", timeout=5)
-        if response.status_code == 200:
-            data = response.json()
-            print_success(f"Status: {response.status_code}")
-            print_success(f"Response: {data}")
-        else:
-            print_error(f"Status: {response.status_code}")
-            return False
-    except requests.exceptions.ConnectionError:
-        print_error("Cannot connect to API. Is it running?")
-        print_info("Start it with: python -m uvicorn app:app --port 7860")
-        return False
-    except Exception as e:
-        print_error(f"Error: {str(e)}")
-        return False
-
-    # Test 2: Health endpoint
-    print_info("\nTest 2: Health check (GET /health)")
-    try:
-        response = requests.get(f"{base_url}/health", timeout=5)
-        if response.status_code == 200:
-            data = response.json()
-            print_success(f"Status: {response.status_code}")
-            print_success(f"Response: {data}")
-        else:
-            print_error(f"Status: {response.status_code}")
-            return False
-    except Exception as e:
-        print_error(f"Error: {str(e)}")
-        return False
-
-    # Test 3: Predict endpoint - factual statement
-    print_info("\nTest 3: Predict endpoint - Factual statement")
-    try:
-        response = requests.post(
-            f"{base_url}/predict",
-            headers={"Authorization": "Bearer test_token"},
-            json={"text": "Paris is the capital of France"},
-            timeout=5
-        )
-        if response.status_code == 200:
-            data = response.json()
-            print_success(f"Status: {response.status_code}")
-            print_success(f"Q1: {data['q1']}, Q2: {data['q2']}, Height: {data['height']}")
-            print_success(f"Verdict: {data['verdict']}")
-
-            # Validate values
-            if data['q1'] < 0 or data['q1'] > 1:
-                print_error(f"Q1 out of range: {data['q1']}")
-                return False
-            if data['q2'] < 0 or data['q2'] > 1:
-                print_error(f"Q2 out of range: {data['q2']}")
-                return False
-            if data['height'] < 0 or data['height'] > 1:
-                print_error(f"Height out of range: {data['height']}")
-                return False
-        else:
-            print_error(f"Status: {response.status_code}")
-            print_error(f"Response: {response.text}")
-            return False
-    except Exception as e:
-        print_error(f"Error: {str(e)}")
-        return False
-
-    # Test 4: Predict endpoint - uncertain statement
-    print_info("\nTest 4: Predict endpoint - Uncertain statement")
-    try:
-        response = requests.post(
-            f"{base_url}/predict",
-            headers={"Authorization": "Bearer test_token"},
-            json={"text": "Maybe quantum computing will solve all problems"},
-            timeout=5
-        )
-        if response.status_code == 200:
-            data = response.json()
-            print_success(f"Status: {response.status_code}")
-            print_success(f"Q1: {data['q1']}, Q2: {data['q2']}, Height: {data['height']}")
-            print_success(f"Verdict: {data['verdict']}")
-
-            # This should have higher uncertainty
-            if data['q1'] < 0.15 and data['q2'] < 0.15:
-                print_warning("Uncertainties seem low for an uncertain statement")
-        else:
-            print_error(f"Status: {response.status_code}")
-            return False
-    except Exception as e:
-        print_error(f"Error: {str(e)}")
-        return False
-
-    # Test 5: Predict endpoint - with context
-    print_info("\nTest 5: Predict endpoint - With context")
-    try:
-        response = requests.post(
-            f"{base_url}/predict",
-            headers={"Authorization": "Bearer test_token"},
-            json={
-                "text": "The Eiffel Tower is 324 meters tall",
-                "context": "geography"
-            },
-            timeout=5
-        )
-        if response.status_code == 200:
-            data = response.json()
-            print_success(f"Status: {response.status_code}")
-            print_success(f"Q1: {data['q1']}, Q2: {data['q2']}, Height: {data['height']}")
-            print_success(f"Verdict: {data['verdict']}")
-        else:
-            print_error(f"Status: {response.status_code}")
-            return False
-    except Exception as e:
-        print_error(f"Error: {str(e)}")
-        return False
-
-    return True
-
-def main():
-    print(f"\n{BLUE}{'='*60}{RESET}")
-    print(f"{BLUE}  AletheionGuard HuggingFace Space - Local Test Suite{RESET}")
-    print(f"{BLUE}{'='*60}{RESET}\n")
-
-    # Check files
-    if not check_files():
-        print_error("\nSome required files are missing!")
-        print_info("Make sure all model files are copied to this directory")
-        sys.exit(1)
-
-    print_success("\nAll required files present ✓\n")
-
-    # Test API
-    print_info("="*60)
-    if test_api():
-        print(f"\n{GREEN}{'='*60}{RESET}")
-        print(f"{GREEN}  All tests passed! ✓{RESET}")
-        print(f"{GREEN}{'='*60}{RESET}\n")
-        print_info("Your Space is ready for deployment!")
-        print_info("Follow DEPLOY_GUIDE.md to push to HuggingFace\n")
-        return 0
-    else:
-        print(f"\n{RED}{'='*60}{RESET}")
-        print(f"{RED}  Some tests failed ✗{RESET}")
-        print(f"{RED}{'='*60}{RESET}\n")
-        print_info("Fix the errors above before deploying\n")
-        return 1
-
-if __name__ == "__main__":
-    sys.exit(main())