Upload 5 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+banner.png filter=lfs diff=lfs merge=lfs -text

AgGPT21.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ee462d86bdd3f9ae980836dc5ea91d2d0b308777c6fa5c7a229a05f30c8015c
+size 16629913

AgGPT21.py

@@ -0,0 +1,276 @@
+import os
+import random
+from collections import Counter
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from tqdm import tqdm
+import glob
+
+MODEL_FILE = "AgGPT21.pt"
+DATA_FOLDER = "training_corpora/"
+
+SEED = 42
+random.seed(SEED)
+torch.manual_seed(SEED)
+
+SEQ_LEN = 64
+STRIDE = 64
+EMBED_SIZE = 128
+HIDDEN_SIZE = 128
+NUM_LAYERS = 1
+DROPOUT = 0.2
+
+BATCH_SIZE = 8
+EPOCHS = 6
+LR = 2e-3
+WEIGHT_DECAY = 1e-4
+CLIP_NORM = 1.0
+
+GENERATE_LENGTH = 200
+DATA_PERCENT = 0.1
+MAX_TOKENS = 1_000_000
+MAX_VOCAB = 30000
+
+TEMPERATURE = 0.9
+TOP_K = 50
+TOP_P = 0.9
+
+if torch.backends.mps.is_available():
+    DEVICE = torch.device("mps")
+elif torch.cuda.is_available():
+    DEVICE = torch.device("cuda")
+else:
+    DEVICE = torch.device("cpu")
+
+def build_vocab_and_ids(folder_path, percent=1.0, max_tokens=None, max_vocab=None):
+    """Build vocabulary and token IDs from all text files in a folder."""
+    all_words = []
+    
+    # Get all .txt files in the folder
+    txt_files = glob.glob(os.path.join(folder_path, "*.txt"))
+    if not txt_files:
+        raise FileNotFoundError(f"No .txt files found in {folder_path}")
+    
+    print(f"Found {len(txt_files)} training files")
+    
+    # Limit number of files to process based on percent
+    if percent < 1.0:
+        num_files_to_use = max(1, int(len(txt_files) * percent))
+        txt_files = txt_files[:num_files_to_use]
+        print(f"Using {percent*100}% of files: {num_files_to_use}/{len(glob.glob(os.path.join(folder_path, '*.txt')))} files")
+    
+    # Read and combine selected files
+    for file_path in sorted(txt_files):
+        print(f"Reading {os.path.basename(file_path)}...")
+        with open(file_path, "r", encoding="utf-8") as f:
+            text = f.read().lower()
+            # Split by whitespace and filter out empty strings
+            words = [w for w in text.split() if w]
+            all_words.extend(words)
+    
+    print(f"Total words loaded: {len(all_words):,}")
+    
+    if max_tokens is not None:
+        all_words = all_words[:max_tokens]
+        print(f"Truncated to max_tokens: {len(all_words):,} words")
+    
+    counts = Counter(all_words)
+    if max_vocab is not None:
+        keep = max(1, max_vocab - 1)
+        common = [w for w, _ in counts.most_common(keep) if w != "<unk>"]
+        vocab = ["<unk>"] + common
+    else:
+        vocab = ["<unk>"] + [w for w in counts if w != "<unk>"]
+    
+    stoi = {w: i for i, w in enumerate(vocab)}
+    itos = {i: w for w, i in stoi.items()}
+    ids = [stoi.get(w, 0) for w in all_words]
+    
+    print(f"Vocabulary size: {len(vocab):,}")
+    return vocab, stoi, itos, ids
+
+class WordDataset(Dataset):
+    def __init__(self, ids, seq_len, stride=None):
+        self.ids = ids
+        self.seq_len = seq_len
+        self.stride = stride or seq_len
+        self.n = max(0, (len(self.ids) - self.seq_len - 1) // self.stride + 1)
+    def __len__(self):
+        return self.n
+    def __getitem__(self, idx):
+        start = idx * self.stride
+        x = torch.tensor(self.ids[start:start + self.seq_len], dtype=torch.long)
+        y = torch.tensor(self.ids[start + 1:start + self.seq_len + 1], dtype=torch.long)
+        return x, y
+
+class WordRNN(nn.Module):
+    def __init__(self, vocab_size, embed_size=EMBED_SIZE, hidden_size=HIDDEN_SIZE, num_layers=NUM_LAYERS, dropout=DROPOUT):
+        super().__init__()
+        self.embed = nn.Embedding(vocab_size, embed_size)
+        self.drop = nn.Dropout(dropout)
+        self.gru = nn.GRU(embed_size, hidden_size, num_layers=num_layers, batch_first=True)
+        self.proj = None
+        if hidden_size != embed_size:
+            self.proj = nn.Linear(hidden_size, embed_size, bias=False)
+        out_size = embed_size if self.proj else hidden_size
+        self.fc = nn.Linear(out_size, vocab_size, bias=False)
+        self.fc.weight = self.embed.weight
+    def forward(self, x, hidden=None):
+        e = self.drop(self.embed(x))
+        out, h = self.gru(e, hidden)
+        out = self.drop(out)
+        if self.proj is not None:
+            out = self.proj(out)
+        logits = self.fc(out)
+        return logits, h
+
+def count_parameters(model):
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+def evaluate(model, dataloader, device, use_amp):
+    model.eval()
+    criterion = nn.CrossEntropyLoss(ignore_index=0)
+    total_loss = 0.0
+    with torch.no_grad():
+        for x, y in dataloader:
+            x = x.to(device)
+            y = y.to(device)
+            with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp):
+                logits, _ = model(x)
+                loss = criterion(logits.view(-1, logits.size(-1)), y.view(-1))
+            total_loss += loss.item()
+    return total_loss / max(1, len(dataloader))
+
+def train(model, train_loader, val_loader, epochs, lr, device, weight_decay, clip_norm, stoi, itos):
+    model.to(device)
+    opt = optim.AdamW(model.parameters(), lr=lr, weight_decay=weight_decay)
+    criterion = nn.CrossEntropyLoss(ignore_index=0)
+    use_amp = device.type in {"mps", "cuda"}
+    best_val = float("inf")
+    patience = 2
+    epochs_no_improve = 0
+    print(f"Train batches per epoch: {len(train_loader)} | Val batches: {len(val_loader)}")
+    epoch_bar = tqdm(range(epochs), desc="Epochs")
+    for epoch in epoch_bar:
+        model.train()
+        total_loss = 0.0
+        batch_bar = tqdm(train_loader, desc=f"Train {epoch+1}/{epochs}", leave=False)
+        for x, y in batch_bar:
+            x = x.to(device)
+            y = y.to(device)
+            opt.zero_grad()
+            with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp):
+                logits, _ = model(x)
+                loss = criterion(logits.view(-1, logits.size(-1)), y.view(-1))
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), clip_norm)
+            opt.step()
+            total_loss += loss.item()
+        batch_bar.close()
+        train_loss = total_loss / max(1, len(train_loader))
+        val_loss = evaluate(model, val_loader, device, use_amp)
+        epoch_bar.set_postfix(train=f"{train_loss:.4f}", val=f"{val_loss:.4f}")
+        if val_loss < best_val - 1e-4:
+            best_val = val_loss
+            epochs_no_improve = 0
+            torch.save({"model_state": model.state_dict(), "stoi": stoi, "itos": itos}, MODEL_FILE)
+        else:
+            epochs_no_improve += 1
+            if epochs_no_improve >= patience:
+                print("Early stopping.")
+                break
+    ckpt = torch.load(MODEL_FILE, map_location=device)
+    model.load_state_dict(ckpt["model_state"])
+    return model
+
+def _sample_next_id(probs_1d, top_k=None, top_p=None, temperature=1.0, forbid_ids=None):
+    probs = probs_1d.clone()
+    if forbid_ids:
+        for i in forbid_ids:
+            if 0 <= i < probs.numel():
+                probs[i] = 0
+    if temperature != 1.0:
+        logits = torch.log(probs + 1e-9) / temperature
+        probs = torch.softmax(logits, dim=-1)
+    if probs.sum() <= 0:
+        probs = torch.ones_like(probs)
+        if forbid_ids:
+            for i in forbid_ids:
+                if 0 <= i < probs.numel():
+                    probs[i] = 0
+        probs = probs / probs.sum()
+    if top_k is not None and top_k > 0:
+        k = min(top_k, probs.size(-1))
+        values, indices = torch.topk(probs, k)
+        values = values / values.sum()
+        idx = indices[torch.multinomial(values, 1)]
+        return idx.item()
+    if top_p is not None and 0 < top_p < 1.0:
+        sorted_probs, sorted_indices = torch.sort(probs, descending=True)
+        cumulative = torch.cumsum(sorted_probs, dim=-1)
+        keep_mask = cumulative <= top_p
+        keep = int(keep_mask.nonzero()[-1].item()) + 1 if keep_mask.any() else 1
+        sorted_probs = sorted_probs[:keep]
+        sorted_indices = sorted_indices[:keep]
+        sorted_probs = sorted_probs / sorted_probs.sum()
+        idx_pos = torch.multinomial(sorted_probs, 1)
+        return sorted_indices[idx_pos].item()
+    probs = probs / probs.sum()
+    return torch.multinomial(probs, 1).item()
+
+def generate_text(model, stoi, itos, prompt, length=GENERATE_LENGTH, seq_len=SEQ_LEN, device=DEVICE, temperature=TEMPERATURE, top_k=TOP_K, top_p=TOP_P):
+    model.to(device)
+    model.eval()
+    words = prompt.lower().split()
+    ids = [stoi.get(w, 0) for w in words]
+    context = ids[-seq_len:] if len(ids) >= seq_len else [0] * (seq_len - len(ids)) + ids
+    input_ids = torch.tensor(context, dtype=torch.long).unsqueeze(0).to(device)
+    hidden = None
+    generated = words.copy()
+    use_amp = device.type in {"mps", "cuda"}
+    with torch.no_grad():
+        gen_bar = tqdm(range(length), desc="Generating", leave=False)
+        for _ in gen_bar:
+            with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp):
+                logits, hidden = model(input_ids, hidden)
+                probs = torch.softmax(logits[:, -1, :], dim=-1).squeeze(0)
+            next_id = _sample_next_id(probs, top_k=top_k, top_p=top_p, temperature=temperature, forbid_ids=[0])
+            next_word = itos.get(next_id, "<unk>")
+            generated.append(next_word)
+            input_ids = torch.tensor([[next_id]], dtype=torch.long).to(device)
+    return " ".join(generated)
+
+if __name__ == "__main__":
+    if os.path.exists(MODEL_FILE):
+        ckpt = torch.load(MODEL_FILE, map_location=DEVICE)
+        stoi = ckpt["stoi"]
+        itos = ckpt["itos"]
+        model = WordRNN(len(stoi))
+        model.load_state_dict(ckpt["model_state"])
+        print(f"Loaded model {MODEL_FILE} | device={DEVICE} | params={count_parameters(model):,}")
+    else:
+        if not os.path.exists(DATA_FOLDER):
+            raise FileNotFoundError(f"Training folder not found: {DATA_FOLDER}")
+        vocab, stoi, itos, ids = build_vocab_and_ids(DATA_FOLDER, percent=DATA_PERCENT, max_tokens=MAX_TOKENS, max_vocab=MAX_VOCAB)
+        print(f"Vocab size: {len(vocab):,} | Tokens used: {len(ids):,} | device={DEVICE}")
+        val_tokens = max(SEQ_LEN * 5, int(0.05 * len(ids)))
+        train_ids = ids[:-val_tokens]
+        val_ids = ids[-val_tokens:]
+        train_dataset = WordDataset(train_ids, SEQ_LEN, stride=STRIDE)
+        val_dataset = WordDataset(val_ids, SEQ_LEN, stride=STRIDE)
+        train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)
+        val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False, drop_last=True)
+        model = WordRNN(len(vocab))
+        print(f"Model params: {count_parameters(model):,}")
+        model = train(model, train_loader, val_loader, EPOCHS, LR, DEVICE, WEIGHT_DECAY, CLIP_NORM, stoi, itos)
+        torch.save({"model_state": model.state_dict(), "stoi": stoi, "itos": itos}, MODEL_FILE)
+        print(f"Saved {MODEL_FILE}")
+    
+    print("\n=== AgGPT-21 Demo ===")
+    prompts = ["hello world", "how are you", "once upon a time", "tell me about"]
+    for p in prompts:
+        print(f"\nPrompt: {p}")
+        print(f"Generated: {generate_text(model, stoi, itos, p)}")
+    print("\nTraining complete! Use chat.py for interactive conversation.")

README.md

@@ -1,3 +1,241 @@
----
-license: mit
----
+# 🤖 AgGPT-21
+
+![AgGPT-21 Banner](banner.png)
+
+A powerful and lightweight GPT-style language model built with PyTorch, featuring word-level tokenization and GRU-based architecture.
+
+## ✨ Features
+
+- **🧠 Intelligent Architecture**: GRU-based neural network with embedding layers
+- **📚 Multi-File Training**: Trains on multiple corpus files automatically
+- **⚡ Optimized Performance**: Supports GPU (CUDA), Apple Silicon (MPS), and CPU
+- **🎛️ Flexible Generation**: Configurable temperature, top-k, and top-p sampling
+- **💬 Interactive Chat**: Beautiful command-line chat interface
+- **🔄 Early Stopping**: Prevents overfitting with validation-based early stopping
+- **📊 Progress Tracking**: Real-time training progress with tqdm
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+```bash
+pip install torch tqdm
+```
+
+### Training the Model
+
+1. **Prepare your training data**: Place your text files in the `training_corpora/` folder
+2. **Start training**:
+   ```bash
+   python AgGPT21.py
+   ```
+
+The model will automatically:
+- Load all `.txt` files from `training_corpora/`
+- Build vocabulary from your data
+- Train with validation split and early stopping
+- Save the trained model as `AgGPT21.pt`
+
+### Interactive Chat
+
+Once trained, start chatting with your model:
+
+```bash
+python chat.py
+```
+
+## 📁 Project Structure
+
+```
+AgGPT-21-2/
+├── banner.png              # Project banner image
+├── AgGPT21.py              # Main training script
+├── chat.py                 # Interactive chat interface
+├── README.md               # This file
+├── AgGPT21.pt              # Trained model (generated after training)
+└── training_corpora/       # Training data folder
+    ├── corpora_000.txt     # Training file 1
+    ├── corpora_001.txt     # Training file 2
+    ├── ...                 # More training files
+    └── corpora_041.txt     # Training file N
+```
+
+## ⚙️ Configuration
+
+### Model Hyperparameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `SEQ_LEN` | 64 | Sequence length for training |
+| `EMBED_SIZE` | 128 | Embedding dimension |
+| `HIDDEN_SIZE` | 128 | GRU hidden dimension |
+| `NUM_LAYERS` | 1 | Number of GRU layers |
+| `DROPOUT` | 0.2 | Dropout rate |
+
+### Training Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `BATCH_SIZE` | 8 | Training batch size |
+| `EPOCHS` | 6 | Maximum training epochs |
+| `LR` | 2e-3 | Learning rate |
+| `WEIGHT_DECAY` | 1e-4 | L2 regularization |
+| `CLIP_NORM` | 1.0 | Gradient clipping |
+
+### Generation Settings
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `TEMPERATURE` | 0.9 | Sampling temperature (0.1-2.0) |
+| `TOP_K` | 50 | Top-k sampling limit |
+| `TOP_P` | 0.9 | Nucleus sampling threshold |
+| `GENERATE_LENGTH` | 200 | Default generation length |
+
+## 🎮 Chat Commands
+
+In the interactive chat mode, you can use these commands:
+
+- **Basic Chat**: Just type your message
+- **`quit`/`exit`/`bye`**: End the conversation
+- **`help`**: Show available commands
+- **`clear`**: Clear the screen
+- **`model`**: Display model information
+- **`temp X`**: Set temperature (e.g., `temp 0.8`)
+- **`length X`**: Set response length (e.g., `length 150`)
+
+## 🧪 Example Usage
+
+### Training Example
+
+```python
+# Train the model (automatic multi-file loading)
+python AgGPT21.py
+```
+
+Output:
+```
+Found 42 training files
+Reading corpora_000.txt...
+Reading corpora_001.txt...
+...
+Total words loaded: 2,847,392
+Vocabulary size: 30,000
+Tokens used: 1,000,000 | device=mps
+Model params: 4,099,200
+Train batches per epoch: 1,562 | Val batches: 79
+Epochs: 100%|████████████| 6/6 [05:23<00:00, 53.92s/it, train=2.1847, val=2.3456]
+Saved AgGPT21.pt
+```
+
+### Chat Example
+
+```
+👤 You: Tell me about artificial intelligence
+
+🤖 AgGPT-21: Artificial intelligence is a fascinating field that focuses on creating systems capable of performing tasks that typically require human intelligence. These systems can learn from data, recognize patterns, make decisions, and solve complex problems. AI has applications in many areas including natural language processing, computer vision, robotics, and machine learning...
+```
+
+## 🔧 Advanced Usage
+
+### Custom Vocabulary Size
+
+```python
+MAX_VOCAB = 50000  # Increase vocabulary size
+```
+
+### Training on Subset of Data
+
+```python
+DATA_PERCENT = 0.5  # Use only 50% of available data
+MAX_TOKENS = 500_000  # Limit to 500k tokens
+```
+
+### Multi-GPU Training
+
+```python
+# The model automatically detects and uses available accelerators:
+# - CUDA (NVIDIA GPUs)
+# - MPS (Apple Silicon)
+# - CPU (fallback)
+```
+
+## 📊 Model Architecture
+
+```
+Input → Embedding → Dropout → GRU → Dropout → [Projection] → Linear → Output
+   ↑        ↓                    ↓                              ↓
+ Token    Vector              Hidden                        Logits
+  IDs   (128-dim)            States                     (Vocab-size)
+```
+
+**Key Features:**
+- **Weight Tying**: Output layer shares weights with embedding layer
+- **Gradient Clipping**: Prevents exploding gradients
+- **Mixed Precision**: Automatic FP16 on supported devices
+- **Early Stopping**: Validation-based training termination
+
+## 🎯 Performance Tips
+
+1. **GPU Acceleration**: Use CUDA or MPS for faster training
+2. **Batch Size**: Increase if you have more memory
+3. **Sequence Length**: Longer sequences capture more context
+4. **Vocabulary**: Smaller vocab = faster training, larger vocab = better coverage
+5. **Data Quality**: Clean, relevant training data improves results
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+**"No .txt files found"**
+- Ensure your training files are in `training_corpora/` with `.txt` extension
+
+**"CUDA out of memory"**
+- Reduce `BATCH_SIZE` or `SEQ_LEN`
+- Use `DATA_PERCENT < 1.0` to train on less data
+
+**"Model file not found"**
+- Train the model first with `python AgGPT21.py`
+- Ensure `AgGPT21.pt` exists in the project directory
+
+## 📈 Training Data Format
+
+Your training files should be plain text. The model will automatically:
+- Convert to lowercase
+- Split on whitespace
+- Handle special tokens like `<pad>`, `<eos>`, etc.
+- Build vocabulary from all files combined
+
+Example format:
+```
+user: how are you today
+<pad>
+ai: I'm doing well, thank you for asking! How are you?
+<eos>
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your improvements
+4. Test thoroughly
+5. Submit a pull request
+
+## 📄 License
+
+This project is open source. Feel free to use, modify, and distribute as needed.
+
+## 🙋‍♂️ Support
+
+If you encounter issues or have questions:
+
+1. Check the troubleshooting section
+2. Review your training data format
+3. Ensure all dependencies are installed
+4. Verify your PyTorch installation supports your hardware
+
+---
+
+**Made with ❤️ for the AI community**
+
+*AgGPT-21 - Where conversation meets intelligence.*

chat.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""
+AgGPT-21 Interactive Chat Interface
+A conversational interface for the trained AgGPT-21 model.
+"""
+
+import os
+import sys
+import torch
+from AgGPT21 import WordRNN, generate_text, MODEL_FILE, DEVICE
+
+def load_model():
+    """Load the trained AgGPT-21 model."""
+    if not os.path.exists(MODEL_FILE):
+        print(f"❌ Model file '{MODEL_FILE}' not found!")
+        print("Please train the model first by running: python AgGPT21.py")
+        sys.exit(1)
+    
+    try:
+        print("🔄 Loading AgGPT-21 model...")
+        ckpt = torch.load(MODEL_FILE, map_location=DEVICE)
+        stoi = ckpt["stoi"]
+        itos = ckpt["itos"]
+        model = WordRNN(len(stoi))
+        model.load_state_dict(ckpt["model_state"])
+        model.eval()
+        
+        # Count parameters
+        param_count = sum(p.numel() for p in model.parameters() if p.requires_grad)
+        print(f"✅ Model loaded successfully!")
+        print(f"   • Parameters: {param_count:,}")
+        print(f"   • Vocabulary size: {len(stoi):,}")
+        print(f"   • Device: {DEVICE}")
+        print()
+        
+        return model, stoi, itos
+    except Exception as e:
+        print(f"❌ Error loading model: {e}")
+        sys.exit(1)
+
+def print_banner():
+    """Display the AgGPT-21 banner."""
+    banner = """
+╔══════════════════════════════════════════════════════════════════════╗
+║                            🤖 AgGPT-21 🤖                           ║
+║                      Interactive Chat Interface                      ║
+║                                                                      ║
+║  • Type your message and press Enter to chat                        ║
+║  • Use 'quit', 'exit', or 'bye' to end the conversation            ║
+║  • Use 'help' for more options                                      ║
+╚══════════════════════════════════════════════════════════════════════╝
+    """
+    print(banner)
+
+def print_help():
+    """Display help information."""
+    help_text = """
+🔧 AgGPT-21 Chat Commands:
+• Just type your message to chat with the AI
+• 'quit', 'exit', 'bye' - End the conversation
+• 'help' - Show this help message
+• 'clear' - Clear the screen
+• 'model' - Show model information
+• 'temp X' - Set temperature (e.g., 'temp 0.8')
+• 'length X' - Set response length (e.g., 'length 150')
+
+🎛️ Current Settings:
+• Temperature: Controls creativity (0.1-2.0, default: 0.9)
+• Length: Number of words to generate (50-500, default: 200)
+    """
+    print(help_text)
+
+def main():
+    """Main chat loop."""
+    print_banner()
+    
+    # Load the model
+    model, stoi, itos = load_model()
+    
+    # Chat settings
+    temperature = 0.9
+    length = 200
+    top_k = 50
+    top_p = 0.9
+    
+    print("💬 Chat started! Type your message below:")
+    print("="*70)
+    
+    while True:
+        try:
+            # Get user input
+            user_input = input("\n👤 You: ").strip()
+            
+            if not user_input:
+                continue
+            
+            # Handle commands
+            user_lower = user_input.lower()
+            
+            if user_lower in ['quit', 'exit', 'bye']:
+                print("\n👋 Goodbye! Thanks for chatting with AgGPT-21!")
+                break
+            
+            elif user_lower == 'help':
+                print_help()
+                continue
+            
+            elif user_lower == 'clear':
+                os.system('clear' if os.name == 'posix' else 'cls')
+                print_banner()
+                continue
+            
+            elif user_lower == 'model':
+                param_count = sum(p.numel() for p in model.parameters() if p.requires_grad)
+                print(f"\n🤖 Model Information:")
+                print(f"   • Parameters: {param_count:,}")
+                print(f"   • Vocabulary: {len(stoi):,} words")
+                print(f"   • Device: {DEVICE}")
+                print(f"   • Temperature: {temperature}")
+                print(f"   • Max length: {length}")
+                continue
+            
+            elif user_lower.startswith('temp '):
+                try:
+                    new_temp = float(user_lower.split()[1])
+                    if 0.1 <= new_temp <= 2.0:
+                        temperature = new_temp
+                        print(f"🌡️ Temperature set to {temperature}")
+                    else:
+                        print("❌ Temperature must be between 0.1 and 2.0")
+                except (IndexError, ValueError):
+                    print("❌ Invalid temperature. Use: temp 0.8")
+                continue
+            
+            elif user_lower.startswith('length '):
+                try:
+                    new_length = int(user_lower.split()[1])
+                    if 50 <= new_length <= 500:
+                        length = new_length
+                        print(f"📏 Response length set to {length} words")
+                    else:
+                        print("❌ Length must be between 50 and 500")
+                except (IndexError, ValueError):
+                    print("❌ Invalid length. Use: length 150")
+                continue
+            
+            # Generate AI response
+            print(f"\n🤖 AgGPT-21 (thinking...)", end="", flush=True)
+            
+            try:
+                response = generate_text(
+                    model=model,
+                    stoi=stoi,
+                    itos=itos,
+                    prompt=user_input,
+                    length=length,
+                    temperature=temperature,
+                    top_k=top_k,
+                    top_p=top_p,
+                    device=DEVICE
+                )
+                
+                # Clean up the response (remove the original prompt)
+                response_words = response.split()
+                prompt_words = user_input.lower().split()
+                
+                # Find where the new content starts
+                if len(response_words) > len(prompt_words):
+                    ai_response = " ".join(response_words[len(prompt_words):])
+                else:
+                    ai_response = response
+                
+                print(f"\r🤖 AgGPT-21: {ai_response}")
+                
+            except Exception as e:
+                print(f"\r❌ Error generating response: {e}")
+        
+        except KeyboardInterrupt:
+            print("\n\n👋 Chat interrupted. Goodbye!")
+            break
+        except Exception as e:
+            print(f"\n❌ Unexpected error: {e}")
+
+if __name__ == "__main__":
+    main()