Create app.py

app.py

@@ -0,0 +1,1092 @@
+"""
+Visible LLM - A Language Model built with TensorFlow
+Trained on veda.txt
+"""
+
+import os
+import json
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+from flask import Flask, request, jsonify, render_template_string
+import re
+import pickle
+from datetime import datetime
+
+# ============================================================
+# CONFIGURATION
+# ============================================================
+
+class VisibleConfig:
+    """Configuration for Visible LLM"""
+    MODEL_NAME = "Visible"
+    VERSION = "1.0.0"
+    
+    # Model Architecture
+    VOCAB_SIZE = 10000
+    EMBEDDING_DIM = 256
+    NUM_HEADS = 8
+    NUM_LAYERS = 6
+    FF_DIM = 512
+    MAX_SEQ_LENGTH = 128
+    DROPOUT_RATE = 0.1
+    
+    # Training
+    BATCH_SIZE = 32
+    EPOCHS = 50
+    LEARNING_RATE = 0.0001
+    WARMUP_STEPS = 4000
+    
+    # Paths
+    DATA_FILE = "veda.txt"
+    MODEL_DIR = "models"
+    MODEL_PATH = "models/visible_model"
+    TOKENIZER_PATH = "models/visible_tokenizer.pkl"
+    CONFIG_PATH = "models/visible_config.json"
+
+
+# ============================================================
+# CUSTOM TOKENIZER
+# ============================================================
+
+class VisibleTokenizer:
+    """Custom tokenizer for Visible LLM"""
+    
+    def __init__(self, vocab_size=10000):
+        self.vocab_size = vocab_size
+        self.word_to_idx = {}
+        self.idx_to_word = {}
+        self.vocab = []
+        
+        # Special tokens
+        self.pad_token = "<PAD>"
+        self.unk_token = "<UNK>"
+        self.start_token = "<START>"
+        self.end_token = "<END>"
+        
+        self.pad_token_id = 0
+        self.unk_token_id = 1
+        self.start_token_id = 2
+        self.end_token_id = 3
+    
+    def _preprocess_text(self, text):
+        """Clean and preprocess text"""
+        text = text.lower()
+        text = re.sub(r'[^\w\s\.\,\!\?\;\:\'\"\-]', '', text)
+        text = re.sub(r'\s+', ' ', text)
+        return text.strip()
+    
+    def _tokenize(self, text):
+        """Split text into tokens"""
+        text = self._preprocess_text(text)
+        # Simple word-level tokenization with punctuation handling
+        tokens = re.findall(r'\w+|[^\w\s]', text)
+        return tokens
+    
+    def fit(self, texts):
+        """Build vocabulary from texts"""
+        print("Building vocabulary...")
+        word_counts = {}
+        
+        for text in texts:
+            tokens = self._tokenize(text)
+            for token in tokens:
+                word_counts[token] = word_counts.get(token, 0) + 1
+        
+        # Sort by frequency
+        sorted_words = sorted(word_counts.items(), key=lambda x: x[1], reverse=True)
+        
+        # Build vocabulary with special tokens
+        self.vocab = [self.pad_token, self.unk_token, self.start_token, self.end_token]
+        self.vocab.extend([word for word, _ in sorted_words[:self.vocab_size - 4]])
+        
+        self.word_to_idx = {word: idx for idx, word in enumerate(self.vocab)}
+        self.idx_to_word = {idx: word for idx, word in enumerate(self.vocab)}
+        
+        print(f"Vocabulary size: {len(self.vocab)}")
+        return self
+    
+    def encode(self, text, max_length=None, add_special_tokens=True):
+        """Encode text to token ids"""
+        tokens = self._tokenize(text)
+        
+        if add_special_tokens:
+            tokens = [self.start_token] + tokens + [self.end_token]
+        
+        token_ids = [self.word_to_idx.get(token, self.unk_token_id) for token in tokens]
+        
+        if max_length:
+            if len(token_ids) > max_length:
+                token_ids = token_ids[:max_length]
+            else:
+                token_ids.extend([self.pad_token_id] * (max_length - len(token_ids)))
+        
+        return token_ids
+    
+    def decode(self, token_ids, skip_special_tokens=True):
+        """Decode token ids to text"""
+        special_ids = {self.pad_token_id, self.start_token_id, self.end_token_id}
+        
+        tokens = []
+        for idx in token_ids:
+            if skip_special_tokens and idx in special_ids:
+                continue
+            if idx == self.unk_token_id and skip_special_tokens:
+                tokens.append("<?>")
+            else:
+                tokens.append(self.idx_to_word.get(idx, self.unk_token))
+        
+        # Join tokens properly
+        text = ' '.join(tokens)
+        # Fix punctuation spacing
+        text = re.sub(r'\s+([.,!?;:])', r'\1', text)
+        return text
+    
+    def save(self, path):
+        """Save tokenizer to file"""
+        with open(path, 'wb') as f:
+            pickle.dump({
+                'vocab': self.vocab,
+                'vocab_size': self.vocab_size
+            }, f)
+        print(f"Tokenizer saved to {path}")
+    
+    def load(self, path):
+        """Load tokenizer from file"""
+        with open(path, 'rb') as f:
+            data = pickle.load(f)
+            self.vocab = data['vocab']
+            self.vocab_size = data['vocab_size']
+            self.word_to_idx = {word: idx for idx, word in enumerate(self.vocab)}
+            self.idx_to_word = {idx: word for idx, word in enumerate(self.vocab)}
+        print(f"Tokenizer loaded from {path}")
+        return self
+    
+    def __len__(self):
+        return len(self.vocab)
+
+
+# ============================================================
+# TRANSFORMER COMPONENTS
+# ============================================================
+
+class PositionalEncoding(layers.Layer):
+    """Positional encoding layer"""
+    
+    def __init__(self, max_seq_length, embed_dim, **kwargs):
+        super().__init__(**kwargs)
+        self.max_seq_length = max_seq_length
+        self.embed_dim = embed_dim
+        
+        # Create positional encoding matrix
+        position = np.arange(max_seq_length)[:, np.newaxis]
+        div_term = np.exp(np.arange(0, embed_dim, 2) * -(np.log(10000.0) / embed_dim))
+        
+        pe = np.zeros((max_seq_length, embed_dim))
+        pe[:, 0::2] = np.sin(position * div_term)
+        pe[:, 1::2] = np.cos(position * div_term)
+        
+        self.positional_encoding = tf.constant(pe, dtype=tf.float32)
+    
+    def call(self, x):
+        seq_length = tf.shape(x)[1]
+        return x + self.positional_encoding[:seq_length, :]
+    
+    def get_config(self):
+        config = super().get_config()
+        config.update({
+            'max_seq_length': self.max_seq_length,
+            'embed_dim': self.embed_dim
+        })
+        return config
+
+
+class TransformerBlock(layers.Layer):
+    """Transformer decoder block"""
+    
+    def __init__(self, embed_dim, num_heads, ff_dim, dropout_rate=0.1, **kwargs):
+        super().__init__(**kwargs)
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.ff_dim = ff_dim
+        self.dropout_rate = dropout_rate
+        
+        self.attention = layers.MultiHeadAttention(
+            num_heads=num_heads,
+            key_dim=embed_dim // num_heads,
+            dropout=dropout_rate
+        )
+        self.ffn = keras.Sequential([
+            layers.Dense(ff_dim, activation='gelu'),
+            layers.Dropout(dropout_rate),
+            layers.Dense(embed_dim)
+        ])
+        self.layernorm1 = layers.LayerNormalization(epsilon=1e-6)
+        self.layernorm2 = layers.LayerNormalization(epsilon=1e-6)
+        self.dropout1 = layers.Dropout(dropout_rate)
+        self.dropout2 = layers.Dropout(dropout_rate)
+    
+    def causal_attention_mask(self, seq_length):
+        """Create causal mask for autoregressive attention"""
+        mask = tf.linalg.band_part(tf.ones((seq_length, seq_length)), -1, 0)
+        return mask
+    
+    def call(self, x, training=False):
+        seq_length = tf.shape(x)[1]
+        causal_mask = self.causal_attention_mask(seq_length)
+        
+        # Self-attention with causal mask
+        attention_output = self.attention(
+            query=x,
+            value=x,
+            key=x,
+            attention_mask=causal_mask,
+            training=training
+        )
+        attention_output = self.dropout1(attention_output, training=training)
+        x = self.layernorm1(x + attention_output)
+        
+        # Feed-forward network
+        ffn_output = self.ffn(x)
+        ffn_output = self.dropout2(ffn_output, training=training)
+        x = self.layernorm2(x + ffn_output)
+        
+        return x
+    
+    def get_config(self):
+        config = super().get_config()
+        config.update({
+            'embed_dim': self.embed_dim,
+            'num_heads': self.num_heads,
+            'ff_dim': self.ff_dim,
+            'dropout_rate': self.dropout_rate
+        })
+        return config
+
+
+# ============================================================
+# VISIBLE LLM MODEL
+# ============================================================
+
+class VisibleLLM:
+    """Visible Language Model"""
+    
+    def __init__(self, config=None):
+        self.config = config or VisibleConfig()
+        self.tokenizer = None
+        self.model = None
+        self.history = None
+    
+    def build_model(self, vocab_size=None):
+        """Build the Transformer model"""
+        vocab_size = vocab_size or self.config.VOCAB_SIZE
+        
+        print(f"\n{'='*50}")
+        print(f"Building {self.config.MODEL_NAME} LLM")
+        print(f"{'='*50}")
+        
+        # Input layer
+        inputs = layers.Input(shape=(None,), dtype=tf.int32, name="input_ids")
+        
+        # Token embedding
+        token_embedding = layers.Embedding(
+            input_dim=vocab_size,
+            output_dim=self.config.EMBEDDING_DIM,
+            name="token_embedding"
+        )(inputs)
+        
+        # Positional encoding
+        x = PositionalEncoding(
+            self.config.MAX_SEQ_LENGTH,
+            self.config.EMBEDDING_DIM,
+            name="positional_encoding"
+        )(token_embedding)
+        
+        # Dropout
+        x = layers.Dropout(self.config.DROPOUT_RATE)(x)
+        
+        # Transformer blocks
+        for i in range(self.config.NUM_LAYERS):
+            x = TransformerBlock(
+                embed_dim=self.config.EMBEDDING_DIM,
+                num_heads=self.config.NUM_HEADS,
+                ff_dim=self.config.FF_DIM,
+                dropout_rate=self.config.DROPOUT_RATE,
+                name=f"transformer_block_{i}"
+            )(x)
+        
+        # Final layer normalization
+        x = layers.LayerNormalization(epsilon=1e-6, name="final_layernorm")(x)
+        
+        # Output projection
+        outputs = layers.Dense(vocab_size, name="output_projection")(x)
+        
+        self.model = keras.Model(inputs=inputs, outputs=outputs, name=self.config.MODEL_NAME)
+        
+        # Compile model
+        self.model.compile(
+            optimizer=keras.optimizers.Adam(learning_rate=self.config.LEARNING_RATE),
+            loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
+            metrics=['accuracy']
+        )
+        
+        self.model.summary()
+        return self.model
+    
+    def load_data(self, file_path=None):
+        """Load and preprocess training data"""
+        file_path = file_path or self.config.DATA_FILE
+        
+        print(f"\nLoading data from {file_path}...")
+        
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Data file not found: {file_path}")
+        
+        with open(file_path, 'r', encoding='utf-8') as f:
+            text = f.read()
+        
+        # Split into sentences/chunks
+        sentences = re.split(r'[.!?]+', text)
+        sentences = [s.strip() for s in sentences if len(s.strip()) > 10]
+        
+        print(f"Loaded {len(sentences)} text segments")
+        return sentences
+    
+    def prepare_training_data(self, texts):
+        """Prepare data for training"""
+        print("\nPreparing training data...")
+        
+        # Initialize and fit tokenizer
+        self.tokenizer = VisibleTokenizer(vocab_size=self.config.VOCAB_SIZE)
+        self.tokenizer.fit(texts)
+        
+        # Create training sequences
+        input_sequences = []
+        target_sequences = []
+        
+        for text in texts:
+            token_ids = self.tokenizer.encode(
+                text,
+                max_length=self.config.MAX_SEQ_LENGTH + 1,
+                add_special_tokens=True
+            )
+            
+            if len([t for t in token_ids if t != 0]) > 3:  # Skip very short sequences
+                input_sequences.append(token_ids[:-1])
+                target_sequences.append(token_ids[1:])
+        
+        X = np.array(input_sequences)
+        y = np.array(target_sequences)
+        
+        print(f"Training samples: {len(X)}")
+        print(f"Input shape: {X.shape}")
+        print(f"Target shape: {y.shape}")
+        
+        return X, y
+    
+    def train(self, data_file=None, epochs=None, batch_size=None):
+        """Train the model"""
+        epochs = epochs or self.config.EPOCHS
+        batch_size = batch_size or self.config.BATCH_SIZE
+        
+        # Load and prepare data
+        texts = self.load_data(data_file)
+        X, y = self.prepare_training_data(texts)
+        
+        # Build model
+        self.build_model(vocab_size=len(self.tokenizer))
+        
+        # Create model directory
+        os.makedirs(self.config.MODEL_DIR, exist_ok=True)
+        
+        # Callbacks
+        callbacks = [
+            keras.callbacks.ModelCheckpoint(
+                filepath=self.config.MODEL_PATH,
+                save_best_only=True,
+                monitor='loss',
+                mode='min'
+            ),
+            keras.callbacks.EarlyStopping(
+                monitor='loss',
+                patience=5,
+                restore_best_weights=True
+            ),
+            keras.callbacks.ReduceLROnPlateau(
+                monitor='loss',
+                factor=0.5,
+                patience=3,
+                min_lr=1e-7
+            ),
+            keras.callbacks.TensorBoard(
+                log_dir=f'logs/{datetime.now().strftime("%Y%m%d-%H%M%S")}'
+            )
+        ]
+        
+        print(f"\n{'='*50}")
+        print(f"Training {self.config.MODEL_NAME}")
+        print(f"{'='*50}")
+        print(f"Epochs: {epochs}")
+        print(f"Batch Size: {batch_size}")
+        print(f"{'='*50}\n")
+        
+        # Train
+        self.history = self.model.fit(
+            X, y,
+            epochs=epochs,
+            batch_size=batch_size,
+            callbacks=callbacks,
+            validation_split=0.1
+        )
+        
+        # Save tokenizer
+        self.tokenizer.save(self.config.TOKENIZER_PATH)
+        
+        # Save config
+        self.save_config()
+        
+        print(f"\n{'='*50}")
+        print(f"Training Complete!")
+        print(f"Model saved to: {self.config.MODEL_PATH}")
+        print(f"Tokenizer saved to: {self.config.TOKENIZER_PATH}")
+        print(f"{'='*50}\n")
+        
+        return self.history
+    
+    def save_config(self):
+        """Save model configuration"""
+        config_dict = {
+            'model_name': self.config.MODEL_NAME,
+            'version': self.config.VERSION,
+            'vocab_size': len(self.tokenizer),
+            'embedding_dim': self.config.EMBEDDING_DIM,
+            'num_heads': self.config.NUM_HEADS,
+            'num_layers': self.config.NUM_LAYERS,
+            'ff_dim': self.config.FF_DIM,
+            'max_seq_length': self.config.MAX_SEQ_LENGTH,
+            'trained_on': datetime.now().isoformat()
+        }
+        
+        with open(self.config.CONFIG_PATH, 'w') as f:
+            json.dump(config_dict, f, indent=2)
+    
+    def load_model(self, model_path=None, tokenizer_path=None):
+        """Load a trained model"""
+        model_path = model_path or self.config.MODEL_PATH
+        tokenizer_path = tokenizer_path or self.config.TOKENIZER_PATH
+        
+        print(f"Loading model from {model_path}...")
+        
+        # Load tokenizer
+        self.tokenizer = VisibleTokenizer()
+        self.tokenizer.load(tokenizer_path)
+        
+        # Load model with custom objects
+        custom_objects = {
+            'PositionalEncoding': PositionalEncoding,
+            'TransformerBlock': TransformerBlock
+        }
+        
+        self.model = keras.models.load_model(model_path, custom_objects=custom_objects)
+        print("Model loaded successfully!")
+        
+        return self
+    
+    def generate(self, prompt, max_length=100, temperature=0.7, top_k=50, top_p=0.9):
+        """Generate text from a prompt"""
+        if self.model is None or self.tokenizer is None:
+            raise ValueError("Model not loaded. Call load_model() first.")
+        
+        # Encode prompt
+        input_ids = self.tokenizer.encode(prompt, add_special_tokens=True)
+        input_ids = input_ids[:-1]  # Remove end token for generation
+        
+        generated_ids = list(input_ids)
+        
+        for _ in range(max_length):
+            # Prepare input
+            current_input = np.array([generated_ids[-self.config.MAX_SEQ_LENGTH:]])
+            
+            # Get predictions
+            predictions = self.model.predict(current_input, verbose=0)
+            next_token_logits = predictions[0, -1, :]
+            
+            # Apply temperature
+            next_token_logits = next_token_logits / temperature
+            
+            # Apply top-k filtering
+            if top_k > 0:
+                indices_to_remove = np.argsort(next_token_logits)[:-top_k]
+                next_token_logits[indices_to_remove] = float('-inf')
+            
+            # Apply top-p (nucleus) filtering
+            if top_p < 1.0:
+                sorted_indices = np.argsort(next_token_logits)[::-1]
+                sorted_logits = next_token_logits[sorted_indices]
+                cumulative_probs = np.cumsum(tf.nn.softmax(sorted_logits).numpy())
+                
+                sorted_indices_to_remove = cumulative_probs > top_p
+                sorted_indices_to_remove[1:] = sorted_indices_to_remove[:-1].copy()
+                sorted_indices_to_remove[0] = False
+                
+                indices_to_remove = sorted_indices[sorted_indices_to_remove]
+                next_token_logits[indices_to_remove] = float('-inf')
+            
+            # Sample from distribution
+            probs = tf.nn.softmax(next_token_logits).numpy()
+            next_token_id = np.random.choice(len(probs), p=probs)
+            
+            # Stop if end token
+            if next_token_id == self.tokenizer.end_token_id:
+                break
+            
+            generated_ids.append(next_token_id)
+        
+        # Decode generated text
+        generated_text = self.tokenizer.decode(generated_ids, skip_special_tokens=True)
+        
+        return generated_text
+    
+    def chat(self, user_input, max_length=100, temperature=0.7):
+        """Interactive chat with the model"""
+        response = self.generate(
+            prompt=user_input,
+            max_length=max_length,
+            temperature=temperature
+        )
+        return response
+
+
+# ============================================================
+# FLASK WEB APPLICATION
+# ============================================================
+
+app = Flask(__name__)
+visible_llm = None
+
+# HTML Template
+HTML_TEMPLATE = """
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Visible LLM</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+            min-height: 100vh;
+            color: #fff;
+        }
+        
+        .container {
+            max-width: 900px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        
+        header {
+            text-align: center;
+            padding: 40px 0;
+        }
+        
+        h1 {
+            font-size: 3em;
+            background: linear-gradient(90deg, #00d2ff, #3a7bd5);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            margin-bottom: 10px;
+        }
+        
+        .subtitle {
+            color: #888;
+            font-size: 1.1em;
+        }
+        
+        .chat-container {
+            background: rgba(255, 255, 255, 0.05);
+            border-radius: 20px;
+            padding: 30px;
+            margin-top: 20px;
+            backdrop-filter: blur(10px);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        
+        .messages {
+            height: 400px;
+            overflow-y: auto;
+            padding: 20px;
+            margin-bottom: 20px;
+            border-radius: 15px;
+            background: rgba(0, 0, 0, 0.3);
+        }
+        
+        .message {
+            margin-bottom: 15px;
+            padding: 15px 20px;
+            border-radius: 15px;
+            max-width: 80%;
+            animation: fadeIn 0.3s ease;
+        }
+        
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(10px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        
+        .user-message {
+            background: linear-gradient(135deg, #3a7bd5, #00d2ff);
+            margin-left: auto;
+            text-align: right;
+        }
+        
+        .bot-message {
+            background: rgba(255, 255, 255, 0.1);
+            margin-right: auto;
+        }
+        
+        .input-area {
+            display: flex;
+            gap: 15px;
+        }
+        
+        #userInput {
+            flex: 1;
+            padding: 15px 20px;
+            border: none;
+            border-radius: 15px;
+            background: rgba(255, 255, 255, 0.1);
+            color: #fff;
+            font-size: 1em;
+            outline: none;
+            transition: all 0.3s ease;
+        }
+        
+        #userInput:focus {
+            background: rgba(255, 255, 255, 0.15);
+            box-shadow: 0 0 20px rgba(0, 210, 255, 0.2);
+        }
+        
+        #userInput::placeholder {
+            color: #888;
+        }
+        
+        button {
+            padding: 15px 30px;
+            border: none;
+            border-radius: 15px;
+            background: linear-gradient(135deg, #3a7bd5, #00d2ff);
+            color: #fff;
+            font-size: 1em;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+        
+        button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 10px 30px rgba(0, 210, 255, 0.3);
+        }
+        
+        button:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+            transform: none;
+        }
+        
+        .settings {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+            gap: 15px;
+            margin-bottom: 20px;
+            padding: 20px;
+            background: rgba(0, 0, 0, 0.2);
+            border-radius: 15px;
+        }
+        
+        .setting-group {
+            display: flex;
+            flex-direction: column;
+            gap: 5px;
+        }
+        
+        .setting-group label {
+            font-size: 0.9em;
+            color: #888;
+        }
+        
+        .setting-group input[type="range"] {
+            width: 100%;
+        }
+        
+        .setting-value {
+            text-align: center;
+            font-size: 0.9em;
+            color: #00d2ff;
+        }
+        
+        .status {
+            text-align: center;
+            padding: 10px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+        }
+        
+        .status.ready {
+            background: rgba(0, 255, 0, 0.1);
+            color: #00ff00;
+        }
+        
+        .status.loading {
+            background: rgba(255, 255, 0, 0.1);
+            color: #ffff00;
+        }
+        
+        .status.error {
+            background: rgba(255, 0, 0, 0.1);
+            color: #ff0000;
+        }
+        
+        .loading-spinner {
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 2px solid #fff;
+            border-radius: 50%;
+            border-top-color: transparent;
+            animation: spin 1s linear infinite;
+        }
+        
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>🔮 Visible</h1>
+            <p class="subtitle">Intelligent Language Model powered by TensorFlow</p>
+        </header>
+        
+        <div class="chat-container">
+            <div id="status" class="status loading">Checking model status...</div>
+            
+            <div class="settings">
+                <div class="setting-group">
+                    <label>Temperature</label>
+                    <input type="range" id="temperature" min="0.1" max="2" step="0.1" value="0.7">
+                    <span class="setting-value" id="tempValue">0.7</span>
+                </div>
+                <div class="setting-group">
+                    <label>Max Length</label>
+                    <input type="range" id="maxLength" min="10" max="200" step="10" value="100">
+                    <span class="setting-value" id="lengthValue">100</span>
+                </div>
+                <div class="setting-group">
+                    <label>Top-K</label>
+                    <input type="range" id="topK" min="1" max="100" step="1" value="50">
+                    <span class="setting-value" id="topKValue">50</span>
+                </div>
+                <div class="setting-group">
+                    <label>Top-P</label>
+                    <input type="range" id="topP" min="0.1" max="1" step="0.1" value="0.9">
+                    <span class="setting-value" id="topPValue">0.9</span>
+                </div>
+            </div>
+            
+            <div class="messages" id="messages">
+                <div class="message bot-message">
+                    Hello! I am Visible, your AI assistant. Ask me anything!
+                </div>
+            </div>
+            
+            <div class="input-area">
+                <input type="text" id="userInput" placeholder="Type your message..." autocomplete="off">
+                <button id="sendBtn" onclick="sendMessage()">Send</button>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        // Update setting values display
+        document.querySelectorAll('input[type="range"]').forEach(input => {
+            input.addEventListener('input', function() {
+                document.getElementById(this.id + 'Value' === 'temperatureValue' ? 'tempValue' : 
+                    this.id === 'maxLength' ? 'lengthValue' : 
+                    this.id === 'topK' ? 'topKValue' : 'topPValue').textContent = this.value;
+            });
+        });
+        
+        // Fix the value display IDs
+        document.getElementById('temperature').addEventListener('input', function() {
+            document.getElementById('tempValue').textContent = this.value;
+        });
+        document.getElementById('maxLength').addEventListener('input', function() {
+            document.getElementById('lengthValue').textContent = this.value;
+        });
+        document.getElementById('topK').addEventListener('input', function() {
+            document.getElementById('topKValue').textContent = this.value;
+        });
+        document.getElementById('topP').addEventListener('input', function() {
+            document.getElementById('topPValue').textContent = this.value;
+        });
+        
+        // Check status
+        async function checkStatus() {
+            try {
+                const response = await fetch('/api/status');
+                const data = await response.json();
+                const statusEl = document.getElementById('status');
+                
+                if (data.model_loaded) {
+                    statusEl.className = 'status ready';
+                    statusEl.textContent = '✓ Model Ready - ' + data.model_name;
+                } else {
+                    statusEl.className = 'status error';
+                    statusEl.textContent = '✗ Model not loaded. Please train the model first.';
+                }
+            } catch (e) {
+                document.getElementById('status').className = 'status error';
+                document.getElementById('status').textContent = '✗ Server connection failed';
+            }
+        }
+        
+        checkStatus();
+        
+        // Send message
+        async function sendMessage() {
+            const input = document.getElementById('userInput');
+            const message = input.value.trim();
+            
+            if (!message) return;
+            
+            const messagesDiv = document.getElementById('messages');
+            const sendBtn = document.getElementById('sendBtn');
+            
+            // Add user message
+            messagesDiv.innerHTML += `<div class="message user-message">${message}</div>`;
+            input.value = '';
+            
+            // Disable button and show loading
+            sendBtn.disabled = true;
+            sendBtn.innerHTML = '<span class="loading-spinner"></span>';
+            
+            // Scroll to bottom
+            messagesDiv.scrollTop = messagesDiv.scrollHeight;
+            
+            try {
+                const response = await fetch('/api/generate', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        prompt: message,
+                        max_length: parseInt(document.getElementById('maxLength').value),
+                        temperature: parseFloat(document.getElementById('temperature').value),
+                        top_k: parseInt(document.getElementById('topK').value),
+                        top_p: parseFloat(document.getElementById('topP').value)
+                    })
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    messagesDiv.innerHTML += `<div class="message bot-message">${data.response}</div>`;
+                } else {
+                    messagesDiv.innerHTML += `<div class="message bot-message" style="color: #ff6b6b">Error: ${data.error}</div>`;
+                }
+            } catch (e) {
+                messagesDiv.innerHTML += `<div class="message bot-message" style="color: #ff6b6b">Error: Failed to connect to server</div>`;
+            }
+            
+            // Re-enable button
+            sendBtn.disabled = false;
+            sendBtn.innerHTML = 'Send';
+            
+            // Scroll to bottom
+            messagesDiv.scrollTop = messagesDiv.scrollHeight;
+        }
+        
+        // Handle Enter key
+        document.getElementById('userInput').addEventListener('keypress', function(e) {
+            if (e.key === 'Enter') {
+                sendMessage();
+            }
+        });
+    </script>
+</body>
+</html>
+"""
+
+
+@app.route('/')
+def home():
+    """Render the main chat interface"""
+    return render_template_string(HTML_TEMPLATE)
+
+
+@app.route('/api/status')
+def status():
+    """Get model status"""
+    global visible_llm
+    return jsonify({
+        'model_loaded': visible_llm is not None and visible_llm.model is not None,
+        'model_name': VisibleConfig.MODEL_NAME,
+        'version': VisibleConfig.VERSION
+    })
+
+
+@app.route('/api/generate', methods=['POST'])
+def generate():
+    """Generate text from prompt"""
+    global visible_llm
+    
+    if visible_llm is None or visible_llm.model is None:
+        return jsonify({
+            'success': False,
+            'error': 'Model not loaded. Please train the model first.'
+        })
+    
+    try:
+        data = request.json
+        prompt = data.get('prompt', '')
+        max_length = data.get('max_length', 100)
+        temperature = data.get('temperature', 0.7)
+        top_k = data.get('top_k', 50)
+        top_p = data.get('top_p', 0.9)
+        
+        response = visible_llm.generate(
+            prompt=prompt,
+            max_length=max_length,
+            temperature=temperature,
+            top_k=top_k,
+            top_p=top_p
+        )
+        
+        return jsonify({
+            'success': True,
+            'response': response,
+            'prompt': prompt
+        })
+    
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        })
+
+
+@app.route('/api/train', methods=['POST'])
+def train_model():
+    """Train the model (API endpoint)"""
+    global visible_llm
+    
+    try:
+        data = request.json or {}
+        epochs = data.get('epochs', 50)
+        batch_size = data.get('batch_size', 32)
+        
+        visible_llm = VisibleLLM()
+        visible_llm.train(epochs=epochs, batch_size=batch_size)
+        
+        return jsonify({
+            'success': True,
+            'message': 'Training complete!'
+        })
+    
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        })
+
+
+# ============================================================
+# COMMAND LINE INTERFACE
+# ============================================================
+
+def main():
+    """Main entry point"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Visible LLM - Language Model')
+    parser.add_argument('--train', action='store_true', help='Train the model')
+    parser.add_argument('--serve', action='store_true', help='Start web server')
+    parser.add_argument('--chat', action='store_true', help='Interactive chat mode')
+    parser.add_argument('--epochs', type=int, default=50, help='Number of training epochs')
+    parser.add_argument('--batch-size', type=int, default=32, help='Batch size')
+    parser.add_argument('--data', type=str, default='veda.txt', help='Training data file')
+    parser.add_argument('--port', type=int, default=5000, help='Server port')
+    
+    args = parser.parse_args()
+    
+    global visible_llm
+    
+    if args.train:
+        print("\n" + "="*60)
+        print("VISIBLE LLM - TRAINING MODE")
+        print("="*60 + "\n")
+        
+        visible_llm = VisibleLLM()
+        VisibleConfig.DATA_FILE = args.data
+        visible_llm.train(epochs=args.epochs, batch_size=args.batch_size)
+        
+    elif args.chat:
+        print("\n" + "="*60)
+        print("VISIBLE LLM - CHAT MODE")
+        print("="*60 + "\n")
+        
+        visible_llm = VisibleLLM()
+        visible_llm.load_model()
+        
+        print("Chat with Visible (type 'quit' to exit)\n")
+        
+        while True:
+            user_input = input("You: ").strip()
+            if user_input.lower() in ['quit', 'exit', 'q']:
+                print("Goodbye!")
+                break
+            
+            if user_input:
+                response = visible_llm.chat(user_input)
+                print(f"Visible: {response}\n")
+    
+    elif args.serve:
+        print("\n" + "="*60)
+        print("VISIBLE LLM - WEB SERVER MODE")
+        print("="*60 + "\n")
+        
+        # Try to load existing model
+        visible_llm = VisibleLLM()
+        try:
+            visible_llm.load_model()
+            print("Model loaded successfully!")
+        except Exception as e:
+            print(f"Could not load model: {e}")
+            print("Please train the model first with: python app.py --train")
+            visible_llm = None
+        
+        print(f"\nStarting server on http://localhost:{args.port}")
+        app.run(host='0.0.0.0', port=args.port, debug=False)
+    
+    else:
+        # Default: show help
+        parser.print_help()
+        print("\n" + "="*60)
+        print("QUICK START:")
+        print("="*60)
+        print("1. Train the model:    python app.py --train --data veda.txt")
+        print("2. Start web server:   python app.py --serve")
+        print("3. Interactive chat:   python app.py --chat")
+        print("="*60 + "\n")
+
+
+if __name__ == '__main__':
+    main()