Upload model.py with huggingface_hub

model.py

@@ -0,0 +1,110 @@
+"""
+Xe AI Model Loader for Hugging Face
+Updated: July 21, 2026
+"""
+import json
+import numpy as np
+from pathlib import Path
+from huggingface_hub import hf_hub_download, list_repo_files
+
+
+class XeModel:
+    """Load and use the Xe AI model from Hugging Face."""
+    
+    def __init__(self, repo_id=None, local_path=None):
+        """
+        Initialize Xe model.
+        
+        Args:
+            repo_id: Hugging Face repo ID (e.g., "username/xe-ai")
+            local_path: Local path to model files (alternative to repo_id)
+        """
+        self.repo_id = repo_id
+        self.local_path = Path(local_path) if local_path else None
+        self.model_config = None
+        self.brain_data = None
+        
+        self._load_model()
+        self._load_brain()
+    
+    def _load_model(self):
+        """Load the neural network model."""
+        if self.repo_id:
+            model_path = hf_hub_download(repo_id=self.repo_id, filename="xe_model.json")
+        elif self.local_path:
+            model_path = str(self.local_path / "xe_model.json")
+        else:
+            raise ValueError("Either repo_id or local_path must be provided")
+        
+        with open(model_path, 'r') as f:
+            self.model_config = json.load(f)
+        
+        self.layer_dims = self.model_config["layer_dims"]
+        self.learning_rate = self.model_config["learning_rate"]
+        self.weights = [np.array(w) for w in self.model_config["layers"]]
+    
+    def _load_brain(self):
+        """Load the conversational brain data."""
+        if self.repo_id:
+            brain_path = hf_hub_download(repo_id=self.repo_id, filename="xe_brain.json")
+        elif self.local_path:
+            brain_path = str(self.local_path / "xe_brain.json")
+        else:
+            raise ValueError("Either repo_id or local_path must be provided")
+        
+        with open(brain_path, 'r') as f:
+            self.brain_data = json.load(f)
+    
+    def predict(self, x):
+        """
+        Make a prediction using the neural network.
+        
+        Args:
+            x: Input array of shape (batch_size, input_dim)
+            
+        Returns:
+            Output array of shape (batch_size, output_dim)
+        """
+        x = np.array(x, dtype=np.float32)
+        for i, layer in enumerate(self.weights):
+            x = np.dot(x, layer['weights']) + layer['bias']
+            if i < len(self.weights) - 1:
+                x = np.maximum(0, x)
+        return x
+    
+    def get_knowledge(self):
+        """Get the knowledge base from brain data."""
+        return self.brain_data.get("knowledge", {})
+    
+    def get_learned_responses(self):
+        """Get the learned responses."""
+        return self.brain_data.get("learned_responses", {})
+    
+    def get_conversations(self):
+        """Get conversation history."""
+        return self.brain_data.get("conversations", [])
+
+
+def load_model(repo_id, token=None):
+    """
+    Convenience function to load Xe model from Hugging Face.
+    
+    Args:
+        repo_id: Hugging Face repository ID
+        token: Hugging Face token (optional, for private repos)
+        
+    Returns:
+        XeModel instance
+    """
+    return XeModel(repo_id=repo_id)
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1:
+        model = XeModel(repo_id=sys.argv[1])
+        print(f"Loaded Xe model from {sys.argv[1]}")
+        print(f"Layer dimensions: {model.layer_dims}")
+        print(f"Knowledge keys: {list(model.get_knowledge().keys())}")
+    else:
+        print("Usage: python model.py <repo_id>")