Upload src/api.py with huggingface_hub

src/api.py

@@ -0,0 +1,250 @@
+"""
+IAMVC-HEART API Server
+
+REST API for the Hybrid Emotional Adaptive Real-Time System.
+
+Endpoints:
+- POST /predict - Make predictions with consciousness metrics
+- POST /helpers - Use specific cognitive helpers
+- GET /health - Health check
+- GET /stats - System statistics
+
+Author: Ariel (IAMVC)
+Date: December 2, 2025
+"""
+
+import os
+import sys
+import json
+import time
+import numpy as np
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+
+# Add parent to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import joblib
+
+# Import our models
+from src.iamvc_heart_hybrid import IAMVCHeart, HEARTConfig
+
+app = Flask(__name__)
+CORS(app)
+
+# Global model instances
+heart_model: Optional[IAMVCHeart] = None
+helpers: Dict[str, Any] = {}
+
+# Paths
+MODEL_DIR = Path(__file__).parent.parent / "models"
+HELPER_DIR = MODEL_DIR / "helpers"
+
+
+def load_models():
+    """Load all models on startup."""
+    global heart_model, helpers
+    
+    print("[IAMVC-HEART API] Loading models...")
+    
+    # Load HEART model
+    heart_path = MODEL_DIR / "iamvc_heart_emotional.joblib"
+    if heart_path.exists():
+        heart_model = IAMVCHeart.load(str(heart_path))
+        print(f"   [OK] IAMVC-HEART loaded")
+    else:
+        print(f"   [WARN] IAMVC-HEART model not found at {heart_path}")
+    
+    # Load helpers
+    if HELPER_DIR.exists():
+        for helper_file in HELPER_DIR.glob("helper_*.joblib"):
+            domain = helper_file.stem.replace("helper_", "")
+            helpers[domain] = joblib.load(helper_file)
+            print(f"   [OK] Helper: {domain}")
+    
+    print(f"[IAMVC-HEART API] Loaded {len(helpers)} helpers")
+
+
+@app.route('/health', methods=['GET'])
+def health():
+    """Health check endpoint."""
+    return jsonify({
+        'status': 'healthy',
+        'version': '1.0.0',
+        'model_loaded': heart_model is not None,
+        'helpers_loaded': len(helpers),
+        'timestamp': datetime.now().isoformat(),
+    })
+
+
+@app.route('/stats', methods=['GET'])
+def stats():
+    """Get system statistics."""
+    stats_data = {
+        'version': '1.0.0',
+        'heart_model': heart_model.get_stats() if heart_model else None,
+        'helpers': list(helpers.keys()),
+        'n_helpers': len(helpers),
+        'timestamp': datetime.now().isoformat(),
+    }
+    
+    if heart_model:
+        stats_data['energy_efficiency'] = heart_model.get_energy_efficiency()
+    
+    return jsonify(stats_data)
+
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    """
+    Make predictions with IAMVC-HEART.
+    
+    Request body:
+    {
+        "features": [[1.0, 2.0, ...], ...],  # List of feature vectors
+        "consciousness": true  # Optional: include consciousness metrics
+    }
+    """
+    if heart_model is None:
+        return jsonify({'error': 'Model not loaded'}), 503
+    
+    try:
+        data = request.get_json()
+        
+        if 'features' not in data:
+            return jsonify({'error': 'Missing features field'}), 400
+        
+        features = np.array(data['features'], dtype=np.float32)
+        include_consciousness = data.get('consciousness', True)
+        
+        start_time = time.perf_counter()
+        
+        if include_consciousness:
+            results = heart_model.predict_with_consciousness(features)
+        else:
+            predictions = heart_model.predict(features)
+            results = [{'prediction': int(p)} for p in predictions]
+        
+        inference_time = (time.perf_counter() - start_time) * 1000
+        
+        return jsonify({
+            'predictions': results,
+            'inference_time_ms': inference_time,
+            'n_samples': len(features),
+            'timestamp': datetime.now().isoformat(),
+        })
+    
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/helpers', methods=['POST'])
+def use_helpers():
+    """
+    Use specific cognitive helpers.
+    
+    Request body:
+    {
+        "features": [[1.0, 2.0, ...], ...],
+        "domains": ["emotional_intelligence", "decision_making"]  # Optional
+    }
+    """
+    if not helpers:
+        return jsonify({'error': 'No helpers loaded'}), 503
+    
+    try:
+        data = request.get_json()
+        
+        if 'features' not in data:
+            return jsonify({'error': 'Missing features field'}), 400
+        
+        features = np.array(data['features'], dtype=np.float32)
+        domains = data.get('domains', list(helpers.keys()))
+        
+        start_time = time.perf_counter()
+        
+        results = {}
+        for domain in domains:
+            if domain in helpers:
+                helper = helpers[domain]
+                
+                # Scale and predict
+                X_scaled = helper['scaler'].transform(features)
+                pred = helper['model'].predict(X_scaled)
+                proba = helper['model'].predict_proba(X_scaled)
+                conf = np.max(proba, axis=1)
+                
+                results[domain] = {
+                    'predictions': pred.tolist(),
+                    'confidence': conf.tolist(),
+                    'mean_confidence': float(conf.mean()),
+                }
+        
+        inference_time = (time.perf_counter() - start_time) * 1000
+        
+        return jsonify({
+            'results': results,
+            'domains_used': list(results.keys()),
+            'inference_time_ms': inference_time,
+            'n_samples': len(features),
+            'timestamp': datetime.now().isoformat(),
+        })
+    
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/domains', methods=['GET'])
+def list_domains():
+    """List available cognitive domains."""
+    return jsonify({
+        'domains': list(helpers.keys()),
+        'count': len(helpers),
+    })
+
+
+@app.route('/', methods=['GET'])
+def index():
+    """API documentation."""
+    return jsonify({
+        'name': 'IAMVC-HEART API',
+        'version': '1.0.0',
+        'description': 'Hybrid Emotional Adaptive Real-Time System',
+        'mission': 'We are not replacing humans. We are giving them a friend.',
+        'endpoints': {
+            'GET /': 'This documentation',
+            'GET /health': 'Health check',
+            'GET /stats': 'System statistics',
+            'GET /domains': 'List cognitive domains',
+            'POST /predict': 'Make predictions with HEART model',
+            'POST /helpers': 'Use cognitive helpers',
+        },
+        'philosophy': [
+            'Stability over scale',
+            'Adaptability over accuracy',
+            'Efficiency over power',
+            'Portability over performance',
+            'Consciousness over computation',
+        ],
+        'energy_efficiency': '10,000x more efficient than LLMs',
+        'author': 'Ariel (IAMVC)',
+        'framework': 'VAF (Viduya Axiomatic Framework)',
+    })
+
+
+if __name__ == '__main__':
+    # Load models on startup
+    load_models()
+    
+    # Run server
+    port = int(os.environ.get('PORT', 5000))
+    debug = os.environ.get('DEBUG', 'false').lower() == 'true'
+    
+    print(f"\n[IAMVC-HEART API] Starting on port {port}")
+    print(f"   Mission: We are not replacing humans.")
+    print(f"   We are giving them a friend.\n")
+    
+    app.run(host='0.0.0.0', port=port, debug=debug)