Upload app.py with huggingface_hub

app.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-OpenLLM Realistic Demo App - Generates actual text based on prompts
+OpenLLM Real Models App - Uses actual trained models from Hugging Face
 """
 
 import gradio as gr
@@ -8,44 +8,56 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 import json
-import random
 import logging
-import re
+import sentencepiece as spm
+from pathlib import Path
+from typing import Dict, Any, Optional
+from huggingface_hub import snapshot_download
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-class RealisticGPT(nn.Module):
-    """Realistic GPT model for demo text generation"""
-    
-    def __init__(self, vocab_size=1000, n_layer=2, n_head=4, n_embd=128):
+class GPTConfig:
+    """GPT model configuration"""
+    def __init__(self, vocab_size=32000, n_layer=6, n_head=8, n_embd=512,
+                 block_size=1024, dropout=0.1, bias=True):
+        self.vocab_size = vocab_size
+        self.n_layer = n_layer
+        self.n_head = n_head
+        self.n_embd = n_embd
+        self.block_size = block_size
+        self.dropout = dropout
+        self.bias = bias
+
+class GPT(nn.Module):
+    """GPT-style transformer model"""
+    def __init__(self, config):
         super().__init__()
-        self.config = type('Config', (), {
-            'vocab_size': vocab_size,
-            'n_layer': n_layer,
-            'n_head': n_head,
-            'n_embd': n_embd,
-            'block_size': 256
-        })()
+        assert config.vocab_size is not None
+        assert config.block_size is not None
+        self.config = config
         
         self.transformer = nn.ModuleDict(dict(
-            wte = nn.Embedding(vocab_size, n_embd),
-            wpe = nn.Embedding(256, n_embd),
-            drop = nn.Dropout(0.1),
+            wte = nn.Embedding(config.vocab_size, config.n_embd),
+            wpe = nn.Embedding(config.block_size, config.n_embd),
+            drop = nn.Dropout(config.dropout),
             h = nn.ModuleList([nn.TransformerEncoderLayer(
-                d_model=n_embd,
-                nhead=n_head,
-                dim_feedforward=4 * n_embd,
-                dropout=0.1,
+                d_model=config.n_embd,
+                nhead=config.n_head,
+                dim_feedforward=4 * config.n_embd,
+                dropout=config.dropout,
                 batch_first=True
-            ) for _ in range(n_layer)]),
-            ln_f = nn.LayerNorm(n_embd),
+            ) for _ in range(config.n_layer)]),
+            ln_f = nn.LayerNorm(config.n_embd),
         ))
-        self.lm_head = nn.Linear(n_embd, vocab_size)
+        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=config.bias)
         
-        # Initialize with random weights
+        # Initialize weights
         self.apply(self._init_weights)
+        for pn, p in self.named_parameters():
+            if pn.endswith('c_proj.weight'):
+                torch.nn.init.normal_(p, mean=0.0, std=0.02/math.sqrt(2 * config.n_layer))
     
     def _init_weights(self, module):
         if isinstance(module, nn.Linear):
@@ -56,9 +68,11 @@ class RealisticGPT(nn.Module):
             torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
     
     def forward(self, idx, targets=None):
+        device = idx.device
         b, t = idx.size()
-        pos = torch.arange(0, t, dtype=torch.long, device=idx.device).unsqueeze(0)
+        assert t <= self.config.block_size, f"Cannot forward sequence of length {t}, block size is only {self.config.block_size}"
         
+        pos = torch.arange(0, t, dtype=torch.long, device=device).unsqueeze(0)
         tok_emb = self.transformer.wte(idx)
         pos_emb = self.transformer.wpe(pos)
         x = self.transformer.drop(tok_emb + pos_emb)
@@ -75,232 +89,241 @@ class RealisticGPT(nn.Module):
             loss = None
         
         return logits, loss
+    
+    def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None, top_p=None, do_sample=True):
+        for _ in range(max_new_tokens):
+            idx_cond = idx if idx.size(1) <= self.config.block_size else idx[:, -self.config.block_size:]
+            logits, _ = self(idx_cond)
+            logits = logits[:, -1, :] / temperature
+            
+            if top_k is not None:
+                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+                logits[logits < v[:, [-1]]] = -float('Inf')
+            
+            if top_p is not None:
+                sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+                cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
+                sorted_indices_to_remove = cumulative_probs > top_p
+                sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+                sorted_indices_to_remove[..., 0] = 0
+                indices_to_remove = sorted_indices_to_remove.scatter(1, sorted_indices, sorted_indices_to_remove)
+                logits[indices_to_remove] = -float('Inf')
+            
+            probs = F.softmax(logits, dim=-1)
+            if do_sample:
+                idx_next = torch.multinomial(probs, num_samples=1)
+            else:
+                _, idx_next = torch.topk(probs, k=1, dim=-1)
+            
+            idx = torch.cat((idx, idx_next), dim=1)
+        
+        return idx
 
-class RealisticInferenceEngine:
-    """Realistic inference engine that generates actual text"""
+class RealOpenLLMInference:
+    """Real OpenLLM inference engine using actual trained models"""
     
     def __init__(self):
         self.models = {}
+        self.tokenizers = {}
         self.current_model = None
         
-        # Model configurations with different personalities
+        # Real model configurations from Hugging Face
         self.model_configs = {
-            "demo-4k": {
-                "name": "Demo Model (4k steps)",
-                "description": "Demo model simulating 4,000 training steps - Basic responses",
-                "steps": 4000,
-                "personality": "basic"
+            "openllm-small-extended-4k": {
+                "name": "OpenLLM Small (4k steps)",
+                "description": "Real model trained for 4,000 steps - Early training stage",
+                "hf_repo": "lemms/openllm-small-extended-4k",
+                "training_steps": 4000,
+                "parameters": "35.8M"
             },
-            "demo-6k": {
-                "name": "Demo Model (6k steps)", 
-                "description": "Demo model simulating 6,000 training steps - Improved coherence",
-                "steps": 6000,
-                "personality": "coherent"
+            "openllm-small-extended-6k": {
+                "name": "OpenLLM Small (6k steps)",
+                "description": "Real model trained for 6,000 steps - Improved coherence (Perplexity: 816.040)",
+                "hf_repo": "lemms/openllm-small-extended-6k",
+                "training_steps": 6000,
+                "parameters": "35.8M"
             },
-            "demo-7k": {
-                "name": "Demo Model (7k steps)",
-                "description": "Demo model simulating 7,000 training steps - Enhanced quality",
-                "steps": 7000,
-                "personality": "enhanced"
+            "openllm-small-extended-7k": {
+                "name": "OpenLLM Small (7k steps)",
+                "description": "Real model trained for 7,000 steps - Enhanced quality (Loss: 2.100, Perplexity: 8.200)",
+                "hf_repo": "lemms/openllm-small-extended-7k",
+                "training_steps": 7000,
+                "parameters": "35.8M"
             },
-            "demo-8k": {
-                "name": "Demo Model (8k steps)",
-                "description": "Demo model simulating 8,000 training steps - Sophisticated understanding",
-                "steps": 8000,
-                "personality": "sophisticated"
+            "openllm-small-extended-8k": {
+                "name": "OpenLLM Small (8k steps)",
+                "description": "Real model trained for 8,000 steps - Sophisticated understanding",
+                "hf_repo": "lemms/openllm-small-extended-8k",
+                "training_steps": 8000,
+                "parameters": "35.8M"
             },
-            "demo-9k": {
-                "name": "Demo Model (9k steps)",
-                "description": "Demo model simulating 9,000 training steps - Best performing model",
-                "steps": 9000,
-                "personality": "expert"
+            "openllm-small-extended-9k": {
+                "name": "OpenLLM Small (9k steps)",
+                "description": "Real model trained for 9,000 steps - Best performing model",
+                "hf_repo": "lemms/openllm-small-extended-9k",
+                "training_steps": 9000,
+                "parameters": "35.8M"
             }
         }
         
-        logger.info("🚀 Realistic OpenLLM Inference Engine initialized")
+        logger.info("🚀 Real OpenLLM Inference Engine initialized")
     
-    def load_model(self, model_id: str) -> bool:
-        """Load a demo model"""
+    def load_model_from_hf(self, model_id: str) -> bool:
+        """Load a real model from Hugging Face"""
         try:
             config = self.model_configs.get(model_id)
             if not config:
                 logger.error(f"❌ Unknown model ID: {model_id}")
                 return False
             
-            logger.info(f"📥 Loading demo model: {model_id}")
+            logger.info(f"📥 Loading real model from HF: {config['hf_repo']}")
+            
+            # Download model from Hugging Face
+            local_dir = snapshot_download(
+                repo_id=config['hf_repo'],
+                repo_type="model",
+                local_dir=f"temp_{model_id}",
+                allow_patterns=["*.pt", "*.json", "*.model", "*.bin"]
+            )
+            
+            logger.info(f"✅ Downloaded model to: {local_dir}")
+            
+            # Load model and tokenizer
+            success = self._load_model_and_tokenizer(local_dir, model_id)
+            if success:
+                self.current_model = model_id
+                logger.info(f"✅ Successfully loaded real model: {model_id}")
+                return True
+            else:
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to load real model from HF {model_id}: {e}")
+            return False
+    
+    def _load_model_and_tokenizer(self, model_dir: str, model_id: str) -> bool:
+        """Load model and tokenizer from local directory"""
+        try:
+            model_path = Path(model_dir)
+            
+            # Load model configuration
+            config_file = model_path / "config.json"
+            if config_file.exists():
+                with open(config_file, 'r') as f:
+                    config_data = json.load(f)
+                model_config = GPTConfig(**config_data.get('model_config', {}))
+            else:
+                # Default configuration for OpenLLM small models
+                model_config = GPTConfig(
+                    vocab_size=32000,
+                    n_layer=6,
+                    n_head=8,
+                    n_embd=512,
+                    block_size=1024,
+                    dropout=0.1,
+                    bias=True
+                )
+            
+            # Load model weights
+            model_file = model_path / "model.pt"
+            if not model_file.exists():
+                model_file = model_path / "pytorch_model.bin"
             
-            # Create a demo model
-            model = RealisticGPT()
-            model.eval()
-            self.models[model_id] = model
-            self.current_model = model_id
+            if model_file.exists():
+                model = GPT(model_config)
+                checkpoint = torch.load(model_file, map_location='cpu')
+                
+                # Handle different checkpoint formats
+                if 'model' in checkpoint:
+                    model.load_state_dict(checkpoint['model'])
+                else:
+                    model.load_state_dict(checkpoint)
+                
+                model.eval()
+                self.models[model_id] = model
+            else:
+                logger.error(f"❌ Model file not found in {model_dir}")
+                return False
+            
+            # Load tokenizer
+            tokenizer_file = model_path / "tokenizer.model"
+            if tokenizer_file.exists():
+                tokenizer = spm.SentencePieceProcessor()
+                tokenizer.load(str(tokenizer_file))
+                self.tokenizers[model_id] = tokenizer
+            else:
+                logger.error(f"❌ Tokenizer file not found in {model_dir}")
+                return False
             
-            logger.info(f"✅ Successfully loaded demo model: {model_id}")
             return True
             
         except Exception as e:
-            logger.error(f"❌ Failed to load demo model {model_id}: {e}")
+            logger.error(f"❌ Failed to load model and tokenizer: {e}")
             return False
     
-    def generate_realistic_text(self, prompt: str, max_length: int = 100, 
-                              temperature: float = 0.7, top_k: int = 50, 
-                              top_p: float = 0.9) -> str:
-        """Generate realistic text based on prompt and parameters"""
+    def generate_text(self, prompt: str, max_length: int = 100,
+                     temperature: float = 0.7, top_k: int = 50,
+                     top_p: float = 0.9) -> str:
+        """Generate text using the loaded real model"""
         if not self.current_model or self.current_model not in self.models:
             return "❌ No model loaded. Please select a model first."
         
         try:
-            config = self.model_configs[self.current_model]
-            personality = config['personality']
+            model = self.models[self.current_model]
+            tokenizer = self.tokenizers[self.current_model]
             
-            # Clean and analyze the prompt
-            prompt_lower = prompt.lower().strip()
+            # Tokenize input
+            input_ids = tokenizer.encode(prompt)
+            input_tensor = torch.tensor([input_ids], dtype=torch.long)
             
-            # Generate contextually appropriate responses based on prompt type
-            if "capital" in prompt_lower and "france" in prompt_lower:
-                response = self._generate_capital_response(prompt, personality, temperature)
-            elif "weather" in prompt_lower:
-                response = self._generate_weather_response(prompt, personality, temperature)
-            elif "hello" in prompt_lower or "hi" in prompt_lower:
-                response = self._generate_greeting_response(prompt, personality, temperature)
-            elif "explain" in prompt_lower or "what is" in prompt_lower:
-                response = self._generate_explanation_response(prompt, personality, temperature)
-            elif "story" in prompt_lower or "write" in prompt_lower:
-                response = self._generate_story_response(prompt, personality, temperature)
-            else:
-                response = self._generate_general_response(prompt, personality, temperature)
+            # Generate text
+            with torch.no_grad():
+                output_ids = model.generate(
+                    input_tensor,
+                    max_new_tokens=max_length,
+                    temperature=temperature,
+                    top_k=top_k,
+                    top_p=top_p,
+                    do_sample=True
+                )
             
-            # Adjust response length based on max_length parameter
-            if max_length < 50:
-                response = response[:max_length] + "..."
-            elif max_length > 200:
-                response += " " + self._generate_continuation(prompt, personality, temperature)
+            # Decode output
+            generated_text = tokenizer.decode(output_ids[0].tolist())
             
-            # Add parameter effects
-            if temperature > 1.2:
-                response += " [Creative mode: Higher temperature allows for more varied and imaginative responses]"
-            elif temperature < 0.5:
-                response += " [Focused mode: Lower temperature produces more deterministic and precise output]"
+            # Remove the input prompt from the output
+            if generated_text.startswith(prompt):
+                generated_text = generated_text[len(prompt):].strip()
             
-            return response
+            return generated_text
             
         except Exception as e:
             error_msg = f"❌ Generation failed: {str(e)}"
             logger.error(error_msg)
             return error_msg
-    
-    def _generate_capital_response(self, prompt: str, personality: str, temperature: float) -> str:
-        """Generate response about capitals"""
-        base_response = "The capital of France is Paris."
-        
-        if personality == "basic":
-            return base_response
-        elif personality == "coherent":
-            return f"{base_response} Paris is a beautiful city known for its culture and history."
-        elif personality == "enhanced":
-            return f"{base_response} Paris, the City of Light, is renowned for its art, fashion, gastronomy, and culture. It's home to iconic landmarks like the Eiffel Tower and the Louvre Museum."
-        elif personality == "sophisticated":
-            return f"{base_response} Paris, often called the City of Light, serves as France's political, economic, and cultural center. It's famous for its rich history, world-class museums, and distinctive architecture."
-        else:  # expert
-            return f"{base_response} Paris, the capital and largest city of France, is a global center for art, fashion, gastronomy, and culture. Located in northern France, it's known for its iconic landmarks, museums, and distinctive Haussmann architecture."
-    
-    def _generate_weather_response(self, prompt: str, personality: str, temperature: float) -> str:
-        """Generate weather-related response"""
-        if personality == "basic":
-            return "The weather varies depending on location and time of year."
-        elif personality == "coherent":
-            return "Weather conditions can change throughout the day. It's best to check local forecasts for accurate information."
-        elif personality == "enhanced":
-            return "Weather patterns are influenced by various factors including temperature, humidity, pressure systems, and geographical location. Local weather services provide the most accurate forecasts."
-        elif personality == "sophisticated":
-            return "Weather is a complex atmospheric phenomenon influenced by temperature, humidity, air pressure, wind patterns, and geographical features. Meteorological services use advanced models to predict weather conditions."
-        else:  # expert
-            return "Weather encompasses atmospheric conditions including temperature, humidity, precipitation, wind, and visibility. Modern meteorology uses sophisticated computer models, satellite data, and ground observations to provide accurate forecasts."
-    
-    def _generate_greeting_response(self, prompt: str, personality: str, temperature: float) -> str:
-        """Generate greeting response"""
-        greetings = {
-            "basic": "Hello! How can I help you today?",
-            "coherent": "Hello there! I'm here to assist you with any questions or tasks you might have.",
-            "enhanced": "Hello! I'm ready to help you with information, explanations, or creative tasks. What would you like to know?",
-            "sophisticated": "Greetings! I'm here to provide assistance, answer questions, or engage in meaningful conversation. How may I be of service?",
-            "expert": "Hello! I'm designed to help with a wide range of tasks including information retrieval, creative writing, problem-solving, and engaging discussions. What would you like to explore?"
-        }
-        return greetings.get(personality, greetings["basic"])
-    
-    def _generate_explanation_response(self, prompt: str, personality: str, temperature: float) -> str:
-        """Generate explanation response"""
-        if personality == "basic":
-            return "I can help explain various topics. Could you please provide more specific details about what you'd like me to explain?"
-        elif personality == "coherent":
-            return "I'm happy to provide explanations on a wide range of subjects. Please let me know what specific topic or concept you'd like me to clarify."
-        elif personality == "enhanced":
-            return "I can offer detailed explanations across many fields including science, history, technology, and more. What specific topic would you like me to explain?"
-        elif personality == "sophisticated":
-            return "I'm capable of providing comprehensive explanations on diverse subjects, from scientific concepts to historical events. Please specify what you'd like me to elucidate."
-        else:  # expert
-            return "I can deliver thorough explanations across multiple domains including science, technology, history, philosophy, and current events. What specific topic would you like me to explore in detail?"
-    
-    def _generate_story_response(self, prompt: str, personality: str, temperature: float) -> str:
-        """Generate story response"""
-        if personality == "basic":
-            return "I can help you create stories. What kind of story would you like me to write?"
-        elif personality == "coherent":
-            return "I'd be happy to help you write a story. Could you tell me what genre or theme you have in mind?"
-        elif personality == "enhanced":
-            return "I can create engaging stories in various genres including fantasy, mystery, science fiction, and more. What type of story interests you?"
-        elif personality == "sophisticated":
-            return "I'm capable of crafting compelling narratives across multiple genres with rich character development and intricate plots. What kind of story would you like me to create?"
-        else:  # expert
-            return "I can compose sophisticated narratives with complex characters, detailed world-building, and engaging plotlines across various genres. What type of story would you like me to develop?"
-    
-    def _generate_general_response(self, prompt: str, personality: str, temperature: float) -> str:
-        """Generate general response"""
-        if personality == "basic":
-            return f"That's an interesting question about '{prompt[:30]}...'. I can help you explore this topic further."
-        elif personality == "coherent":
-            return f"Your question about '{prompt[:30]}...' is quite engaging. Let me provide some helpful information on this subject."
-        elif personality == "enhanced":
-            return f"Your inquiry regarding '{prompt[:30]}...' shows thoughtful consideration. I'd be happy to share relevant insights and information."
-        elif personality == "sophisticated":
-            return f"Your question about '{prompt[:30]}...' demonstrates intellectual curiosity. I can offer comprehensive analysis and detailed information on this topic."
-        else:  # expert
-            return f"Your inquiry concerning '{prompt[:30]}...' reflects deep thinking. I can provide thorough analysis, multiple perspectives, and detailed information to help you understand this topic better."
-    
-    def _generate_continuation(self, prompt: str, personality: str, temperature: float) -> str:
-        """Generate continuation text"""
-        continuations = {
-            "basic": "This topic has many interesting aspects to explore.",
-            "coherent": "There are several important points to consider when discussing this subject.",
-            "enhanced": "This subject encompasses various fascinating dimensions that are worth exploring in detail.",
-            "sophisticated": "This topic involves multiple complex factors that require careful consideration and analysis.",
-            "expert": "This subject encompasses numerous intricate aspects that benefit from comprehensive examination and thoughtful discussion."
-        }
-        return continuations.get(personality, continuations["basic"])
 
-# Initialize the realistic inference engine
-inference_engine = RealisticInferenceEngine()
+# Initialize the real inference engine
+inference_engine = RealOpenLLMInference()
 
 def load_model_info(model_id: str) -> str:
     """Get information about a specific model"""
     config = inference_engine.model_configs.get(model_id)
     if config:
-        return f"**{config['name']}**\n\n{config['description']}"
+        return f"**{config['name']}**\n\n{config['description']}\n\n**Parameters:** {config['parameters']}\n**Training Steps:** {config['training_steps']:,}"
     return "❌ Model not found"
 
-def generate_text_interface(model_id: str, prompt: str, max_length: int, 
+def generate_text_interface(model_id: str, prompt: str, max_length: int,
                           temperature: float, top_k: int, top_p: float) -> str:
     """Gradio interface function for text generation"""
     try:
         # Load model if not already loaded
         if model_id not in inference_engine.models:
-            logger.info(f"🔄 Loading model: {model_id}")
-            success = inference_engine.load_model(model_id)
+            logger.info(f"🔄 Loading real model: {model_id}")
+            success = inference_engine.load_model_from_hf(model_id)
             if not success:
-                return f"❌ Failed to load model: {model_id}"
+                return f"❌ Failed to load real model: {model_id}"
         
         # Generate text
-        result = inference_engine.generate_realistic_text(
+        result = inference_engine.generate_text(
             prompt=prompt,
             max_length=max_length,
             temperature=temperature,
@@ -320,27 +343,29 @@ def create_interface():
     """Create the Gradio interface"""
     
     with gr.Blocks(
-        title="🚀 OpenLLM Realistic Demo Space",
+        title="🚀 OpenLLM Real Models Space",
         theme=gr.themes.Soft()
     ) as interface:
         
         # Header
         gr.Markdown("""
-        # 🚀 OpenLLM Realistic Demo Space
+        # 🚀 OpenLLM Real Models Space
         
-        Welcome to the OpenLLM Realistic Demo Space! This interface generates actual text responses based on your prompts.
+        Welcome to the OpenLLM Real Models Space! This interface uses **actual trained models** from Hugging Face.
         
-        ## 🎯 Demo Models
+        ## 🎯 Real Trained Models
         
-        We provide **5 different demo models** with varying response quality:
+        We provide **5 different real models** with varying training steps:
         
-        | Model | Training Steps | Response Quality |
-        |-------|---------------|------------------|
-        | **Demo 4k** | 4,000 | Basic responses |
-        | **Demo 6k** | 6,000 | Improved coherence |
-        | **Demo 7k** | 7,000 | Enhanced quality |
-        | **Demo 8k** | 8,000 | Sophisticated understanding |
-        | **Demo 9k** | 9,000 | Expert-level responses |
+        | Model | Training Steps | Parameters | Performance |
+        |-------|---------------|------------|-------------|
+        | **4k Model** | 4,000 | 35.8M | Early training stage |
+        | **6k Model** | 6,000 | 35.8M | Improved coherence (Perplexity: 816.040) |
+        | **7k Model** | 7,000 | 35.8M | Enhanced quality (Loss: 2.100, Perplexity: 8.200) |
+        | **8k Model** | 8,000 | 35.8M | Sophisticated understanding |
+        | **9k Model** | 9,000 | 35.8M | Best performing model |
+        
+        **These are real GPT-style transformer models trained on Wikipedia passages from the SQuAD dataset.**
         
         ---
         """)
@@ -350,14 +375,14 @@ def create_interface():
                 # Model selection
                 model_dropdown = gr.Dropdown(
                     choices=list(inference_engine.model_configs.keys()),
-                    value="demo-9k",
+                    value="openllm-small-extended-9k",
                     label="🎯 Select Model",
-                    info="Choose the demo model to use"
+                    info="Choose the real trained model to use"
                 )
                 
                 # Model information display
                 model_info = gr.Markdown(
-                    value=load_model_info("demo-9k"),
+                    value=load_model_info("openllm-small-extended-9k"),
                     label="📋 Model Information"
                 )
                 
@@ -443,19 +468,28 @@ def create_interface():
         
         ## 🔧 Technical Details
         
-        - **Architecture**: GPT-style transformer decoder (demo)
-        - **Model Size**: Small demo models for testing
-        - **Framework**: PyTorch with realistic text generation
+        - **Architecture**: GPT-style transformer decoder
+        - **Model Size**: Small (6 layers, 8 heads, 512 embedding dim)
+        - **Vocabulary**: 32k tokens (SentencePiece BPE)
+        - **Training Data**: Wikipedia passages from SQuAD dataset
+        - **Framework**: PyTorch with real trained models
         - **Gradio Version**: 4.44.1 (latest)
-        - **Status**: Realistic demo mode - generates actual responses
         
-        **This demo generates contextually appropriate responses based on your input prompts.**
+        **These models generate actual text based on their training on Wikipedia content.**
+        
+        **Model Sources:**
+        - [4k Model](https://huggingface.co/lemms/openllm-small-extended-4k)
+        - [6k Model](https://huggingface.co/lemms/openllm-small-extended-6k)
+        - [7k Model](https://huggingface.co/lemms/openllm-small-extended-7k)
+        - [8k Model](https://huggingface.co/lemms/openllm-small-extended-8k)
+        - [9k Model](https://huggingface.co/lemms/openllm-small-extended-9k)
         """)
     
     return interface
 
 # Create and launch the interface
 if __name__ == "__main__":
+    import math
     interface = create_interface()
     interface.launch(
         server_name="0.0.0.0",