Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app files
+COPY app.py .
+COPY README.md .
+
+# Expose Streamlit port
+EXPOSE 7860
+
+# Run Streamlit
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -1,10 +1,76 @@
+# ⚡ Legion Coder
+
+**A 44M Parameter Transformer for Code Generation**
+
+[![Made with by DEATH LEGION](https://img.shields.io/badge/MADE%20WITH%20BY-DEATH%20LEGION-ff0040?style=for-the-badge)](https://huggingface.co/dineth554/legion-coder-8m)
+[![Powered by nvdya-kit](https://img.shields.io/badge/POWERED%20BY-nvdya--kit-7c4dff?style=for-the-badge)]()
+
 ---
-title: Legion Coder
-emoji: 😻
-colorFrom: red
-colorTo: indigo
-sdk: docker
-pinned: false
+
+## 🚀 About
+
+Legion Coder is a compact yet powerful 44M parameter transformer model optimized for coding tasks. Built with precision by **DEATH LEGION** and powered by **nvdya-kit**, this model delivers high-quality code generation in a lightweight package.
+
+## ✨ Features
+
+- 📝 **Clean Code Generation** - PEP 8 compliant Python and more
+- 🐛 **Debug Assistance** - Help identify and fix code issues
+- 📚 **Code Explanation** - Understand complex programming concepts
+- 💡 **Multi-language Support** - Python, JavaScript, and more
+- ⚡ **Fast Inference** - Optimized for CPU deployment
+
+## 📊 Model Specifications
+
+| Attribute | Value |
+|-----------|-------|
+| **Parameters** | 44,341,632 (~44M) |
+| **Architecture** | GPT-style Transformer |
+| **Hidden Size** | 576 |
+| **Layers** | 13 |
+| **Attention Heads** | 16 |
+| **Context Length** | 1,024 tokens |
+| **Vocabulary** | 16,000 tokens |
+| **Format** | Safetensors |
+
+## 🎯 Use Cases
+
+- **Code Completion** - Finish partial code snippets
+- **Function Generation** - Create functions from descriptions
+- **Debugging** - Find and fix errors in code
+- **Learning** - Get explanations for programming concepts
+- **Prototyping** - Quickly generate code scaffolding
+
+## 🛠️ Technical Details
+
+### Training Data
+- Python code from The Stack v2 dataset
+- GitHub code repositories (filtered for quality)
+- Code-specific preprocessing for indentation and special tokens
+
+### Training Procedure
+- **Optimizer**: AdamW
+- **Learning Rate**: 5e-4 with cosine decay
+- **Batch Size**: 4 with gradient accumulation
+- **Training Steps**: 10,000
+- **Precision**: float32 (CPU-optimized)
+
+## 📝 License
+
+This model is released under the **MIT License**.
+
+## 🔗 Links
+
+- **Model Repository**: [dineth554/legion-coder-8m](https://huggingface.co/dineth554/legion-coder-8m)
+- **Space**: This Space
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<div align="center">
+
+### 🔥 MADE WITH BY DEATH LEGION 🔥
+
+**Powered by nvdya-kit**
+
+*© 2024 DEATH LEGION. All rights reserved.*
+
+</div>

app.py

@@ -0,0 +1,598 @@
+"""
+Legion Coder - Hugging Face Space
+A powerful coding assistant powered by the Legion Coder 8M model.
+
+MADE WITH BY DEATH LEGION
+Powered by nvdya-kit
+"""
+
+import os
+import sys
+import torch
+import streamlit as st
+import math
+from typing import List, Dict, Tuple
+
+# Page config with custom branding
+st.set_page_config(
+    page_title="Legion Coder | DEATH LEGION",
+    page_icon="⚡",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Enhanced Custom CSS with DEATH LEGION branding
+st.markdown("""
+<style>
+@import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;600;700&family=Inter:wght@400;500;600;700&display=swap');
+
+.main {
+    font-family: 'Inter', sans-serif;
+    background: linear-gradient(135deg, #0a0a0f 0%, #1a1a2e 50%, #16213e 100%);
+    min-height: 100vh;
+}
+
+/* Header Styling */
+.header-container {
+    background: linear-gradient(90deg, #ff0040 0%, #ff4081 50%, #7c4dff 100%);
+    padding: 2rem;
+    border-radius: 16px;
+    margin-bottom: 2rem;
+    box-shadow: 0 10px 40px rgba(255, 0, 64, 0.3);
+}
+
+.header-title {
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 2.5rem;
+    font-weight: 700;
+    color: #ffffff;
+    text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+    margin: 0;
+}
+
+.header-subtitle {
+    font-size: 1.1rem;
+    color: rgba(255,255,255,0.9);
+    margin-top: 0.5rem;
+}
+
+.branding-badge {
+    display: inline-block;
+    background: rgba(0,0,0,0.3);
+    padding: 0.3rem 0.8rem;
+    border-radius: 20px;
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: #ff4081;
+    margin-top: 0.5rem;
+    border: 1px solid rgba(255,64,129,0.3);
+}
+
+/* Chat Styling */
+.stChatMessage {
+    padding: 1.2rem;
+    border-radius: 12px;
+    margin-bottom: 1rem;
+    border: 1px solid rgba(255,255,255,0.1);
+}
+
+.stChatMessage.user {
+    background: linear-gradient(135deg, #1e3a5f 0%, #2d5a87 100%);
+    margin-left: 20%;
+    margin-right: 0;
+}
+
+.stChatMessage.assistant {
+    background: linear-gradient(135deg, #2d1b4e 0%, #4a1c6b 100%);
+    margin-left: 0;
+    margin-right: 20%;
+}
+
+/* Code Block Styling */
+pre {
+    background: #0d1117 !important;
+    border: 1px solid #30363d !important;
+    border-radius: 8px !important;
+    padding: 1rem !important;
+}
+
+code {
+    font-family: 'JetBrains Mono', monospace !important;
+    font-size: 0.9rem !important;
+}
+
+/* Sidebar Styling */
+.css-1d391kg {
+    background: linear-gradient(180deg, #1a1a2e 0%, #16213e 100%);
+}
+
+/* Input Styling */
+.stTextInput > div > div > input {
+    background: rgba(255,255,255,0.05);
+    border: 1px solid rgba(255,255,255,0.1);
+    border-radius: 8px;
+    color: white;
+}
+
+/* Button Styling */
+.stButton > button {
+    background: linear-gradient(90deg, #ff0040 0%, #ff4081 100%);
+    color: white;
+    border: none;
+    border-radius: 8px;
+    padding: 0.5rem 1.5rem;
+    font-weight: 600;
+    transition: all 0.3s ease;
+}
+
+.stButton > button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 5px 20px rgba(255, 0, 64, 0.4);
+}
+
+/* Footer */
+.footer {
+    text-align: center;
+    padding: 2rem;
+    color: rgba(255,255,255,0.5);
+    font-size: 0.85rem;
+    border-top: 1px solid rgba(255,255,255,0.1);
+    margin-top: 3rem;
+}
+
+.footer-brand {
+    color: #ff4081;
+    font-weight: 600;
+}
+</style>
+""", unsafe_allow_html=True)
+
+
+# System prompt
+SYSTEM_PROMPT = """You are Legion Coder, an expert coding assistant powered by DEATH LEGION and nvdya-kit. Your purpose is to help users write clean, efficient, and well-documented code.
+
+Guidelines:
+- Write code that follows best practices and PEP 8 style guidelines
+- Include helpful comments explaining complex logic
+- Provide complete, runnable code examples
+- Explain your approach before showing code when helpful
+- If asked to debug, identify the issue and provide the corrected code
+
+Always wrap code blocks in triple backticks with the appropriate language identifier."""
+
+
+# Model classes (same as original)
+class MultiHeadAttention(torch.nn.Module):
+    def __init__(self, d_model, num_heads, dropout=0.1):
+        super().__init__()
+        assert d_model % num_heads == 0
+        self.d_model = d_model
+        self.num_heads = num_heads
+        self.d_k = d_model // num_heads
+        self.W_q = torch.nn.Linear(d_model, d_model, bias=False)
+        self.W_k = torch.nn.Linear(d_model, d_model, bias=False)
+        self.W_v = torch.nn.Linear(d_model, d_model, bias=False)
+        self.W_o = torch.nn.Linear(d_model, d_model, bias=False)
+        self.dropout = torch.nn.Dropout(dropout)
+
+    def forward(self, x, mask=None):
+        batch_size, seq_len, _ = x.shape
+        Q = self.W_q(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
+        K = self.W_k(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
+        V = self.W_v(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
+        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
+        if mask is not None:
+            scores = scores.masked_fill(mask == 0, float('-inf'))
+        attn_weights = torch.nn.functional.softmax(scores, dim=-1)
+        attn_weights = self.dropout(attn_weights)
+        context = torch.matmul(attn_weights, V)
+        context = context.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model)
+        return self.W_o(context)
+
+
+class FeedForward(torch.nn.Module):
+    def __init__(self, d_model, d_ff, dropout=0.1):
+        super().__init__()
+        self.linear1 = torch.nn.Linear(d_model, d_ff, bias=False)
+        self.linear2 = torch.nn.Linear(d_ff, d_model, bias=False)
+        self.dropout = torch.nn.Dropout(dropout)
+
+    def forward(self, x):
+        x = self.linear1(x)
+        x = torch.nn.functional.gelu(x)
+        x = self.dropout(x)
+        x = self.linear2(x)
+        return x
+
+
+class TransformerBlock(torch.nn.Module):
+    def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
+        super().__init__()
+        self.attention = MultiHeadAttention(d_model, num_heads, dropout)
+        self.feed_forward = FeedForward(d_model, d_ff, dropout)
+        self.norm1 = torch.nn.LayerNorm(d_model)
+        self.norm2 = torch.nn.LayerNorm(d_model)
+        self.dropout = torch.nn.Dropout(dropout)
+
+    def forward(self, x, mask=None):
+        attn_output = self.attention(self.norm1(x), mask)
+        x = x + self.dropout(attn_output)
+        ff_output = self.feed_forward(self.norm2(x))
+        x = x + self.dropout(ff_output)
+        return x
+
+
+class LegionCoderModel(torch.nn.Module):
+    def __init__(self, vocab_size=16000, d_model=576, num_layers=13, num_heads=16, d_ff=1152, max_seq_len=1024, dropout=0.1, pad_token_id=0):
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.d_model = d_model
+        self.max_seq_len = max_seq_len
+        self.pad_token_id = pad_token_id
+        self.token_embedding = torch.nn.Embedding(vocab_size, d_model)
+        self.position_embedding = torch.nn.Embedding(max_seq_len, d_model)
+        self.blocks = torch.nn.ModuleList([TransformerBlock(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)])
+        self.norm = torch.nn.LayerNorm(d_model)
+        self.lm_head = torch.nn.Linear(d_model, vocab_size, bias=False)
+        self.lm_head.weight = self.token_embedding.weight
+        self.dropout = torch.nn.Dropout(dropout)
+        self._init_weights()
+
+    def _init_weights(self):
+        for module in self.modules():
+            if isinstance(module, torch.nn.Linear):
+                torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+                if module.bias is not None:
+                    torch.nn.init.zeros_(module.bias)
+            elif isinstance(module, torch.nn.Embedding):
+                torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+
+    def _create_causal_mask(self, seq_len, device):
+        mask = torch.triu(torch.ones(seq_len, seq_len, device=device), diagonal=1)
+        return mask == 0
+
+    def forward(self, input_ids, attention_mask=None, labels=None):
+        batch_size, seq_len = input_ids.shape
+        device = input_ids.device
+        positions = torch.arange(0, seq_len, device=device).unsqueeze(0).expand(batch_size, -1)
+        token_embeds = self.token_embedding(input_ids)
+        pos_embeds = self.position_embedding(positions)
+        x = self.dropout(token_embeds + pos_embeds)
+        causal_mask = self._create_causal_mask(seq_len, device)
+        if attention_mask is not None:
+            attention_mask = attention_mask.unsqueeze(1).unsqueeze(2)
+            causal_mask = causal_mask.unsqueeze(0).unsqueeze(0) & attention_mask
+        for block in self.blocks:
+            x = block(x, causal_mask)
+        x = self.norm(x)
+        logits = self.lm_head(x)
+        loss = None
+        if labels is not None:
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            loss_fct = torch.nn.CrossEntropyLoss(ignore_index=-100)
+            loss = loss_fct(shift_logits.view(-1, self.vocab_size), shift_labels.view(-1))
+        return {'logits': logits, 'loss': loss}
+
+    def generate(self, input_ids, max_length=100, temperature=1.0, top_k=50, top_p=0.95, pad_token_id=0, eos_token_id=2):
+        self.eval()
+        batch_size = input_ids.shape[0]
+        device = input_ids.device
+        with torch.no_grad():
+            for _ in range(max_length):
+                if input_ids.shape[1] > self.max_seq_len:
+                    input_ids = input_ids[:, -self.max_seq_len:]
+                outputs = self.forward(input_ids)
+                logits = outputs['logits']
+                next_token_logits = logits[:, -1, :] / temperature
+                if top_k > 0:
+                    indices_to_remove = next_token_logits < torch.topk(next_token_logits, top_k)[0][..., -1, None]
+                    next_token_logits[indices_to_remove] = float('-inf')
+                if top_p < 1.0:
+                    sorted_logits, sorted_indices = torch.sort(next_token_logits, descending=True)
+                    cumulative_probs = torch.cumsum(torch.nn.functional.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)
+                    next_token_logits[indices_to_remove] = float('-inf')
+                probs = torch.nn.functional.softmax(next_token_logits, dim=-1)
+                next_token = torch.multinomial(probs, num_samples=1)
+                input_ids = torch.cat([input_ids, next_token], dim=1)
+                if (next_token == eos_token_id).all():
+                    break
+        return input_ids
+
+
+# Tokenizer class
+class LegionCoderTokenizer:
+    SPECIAL_TOKENS = {
+        '<|pad|>': 0,
+        '<|eos|>': 1,
+        '<|unk|>': 2,
+        '<|system|>': 3,
+        '<|user|>': 4,
+        '<|assistant|>': 5,
+        '<|code|>': 6,
+        '<|comment|>': 7,
+        '<|indent|>': 8,
+        '<|newline|>': 9,
+        '<|tab|>': 10,
+        '<|space|>': 11,
+    }
+
+    def __init__(self, vocab_size=16000):
+        self.vocab_size = vocab_size
+        self.vocab = {}
+        self.inverse_vocab = {}
+        self.merges = []
+        self._init_special_tokens()
+
+    def _init_special_tokens(self):
+        for token, idx in self.SPECIAL_TOKENS.items():
+            self.vocab[token] = idx
+            self.inverse_vocab[idx] = token
+
+    def encode(self, text, add_special_tokens=True):
+        import re
+        text = text.replace('\t', ' <|tab|> ')
+        text = re.sub(r' {4,}', ' <|indent|> ', text)
+        text = text.replace('\n', ' <|newline|> ')
+
+        tokens = []
+        if add_special_tokens:
+            tokens.append(self.SPECIAL_TOKENS['<|user|>'])
+
+        words = text.split()
+        for word in words:
+            word_tokens = list(word) + ['</w>']
+            i = 0
+            while i < len(word_tokens):
+                for j in range(len(word_tokens), i, -1):
+                    substr = ''.join(word_tokens[i:j])
+                    if substr in self.vocab:
+                        tokens.append(self.vocab[substr])
+                        i = j
+                        break
+                else:
+                    tokens.append(self.SPECIAL_TOKENS['<|unk|>'])
+                    i += 1
+
+        if add_special_tokens:
+            tokens.append(self.SPECIAL_TOKENS['<|eos|>'])
+
+        return tokens
+
+    def decode(self, token_ids, skip_special_tokens=True):
+        tokens = []
+        for idx in token_ids:
+            if idx in self.inverse_vocab:
+                token = self.inverse_vocab[idx]
+                if skip_special_tokens and token.startswith('<|') and token.endswith('|>'):
+                    continue
+                tokens.append(token)
+
+        text = ''.join(tokens)
+        text = text.replace('</w>', ' ')
+        text = text.replace('<|newline|>', '\n')
+        text = text.replace('<|tab|>', '\t')
+        text = text.replace('<|indent|>', '    ')
+        text = text.replace('<|space|>', ' ')
+
+        return text.strip()
+
+    @classmethod
+    def load(cls, path):
+        import json
+        with open(f"{path}/vocab.json", 'r') as f:
+            vocab = json.load(f)
+        with open(f"{path}/merges.txt", 'r') as f:
+            merges = [tuple(line.strip().split()) for line in f if line.strip()]
+        with open(f"{path}/tokenizer_config.json", 'r') as f:
+            config = json.load(f)
+
+        tokenizer = cls(vocab_size=config['vocab_size'])
+        tokenizer.vocab = vocab
+        tokenizer.inverse_vocab = {v: k for k, v in vocab.items()}
+        tokenizer.merges = merges
+        return tokenizer
+
+
+def count_parameters(model):
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+
+@st.cache_resource
+def load_model():
+    """Load model from HuggingFace Hub."""
+    with st.spinner("⚡ Initializing Legion Coder..."):
+        try:
+            from huggingface_hub import hf_hub_download
+            import json
+
+            repo_id = "dineth554/legion-coder-8m"
+            cache_dir = "/tmp/model_cache"
+            os.makedirs(cache_dir, exist_ok=True)
+
+            # Download files
+            model_path = hf_hub_download(repo_id=repo_id, filename="model.safetensors", cache_dir=cache_dir)
+            config_path = hf_hub_download(repo_id=repo_id, filename="config.json", cache_dir=cache_dir)
+            vocab_path = hf_hub_download(repo_id=repo_id, filename="vocab.json", cache_dir=cache_dir)
+            merges_path = hf_hub_download(repo_id=repo_id, filename="merges.txt", cache_dir=cache_dir)
+            tok_config_path = hf_hub_download(repo_id=repo_id, filename="tokenizer_config.json", cache_dir=cache_dir)
+
+            model_dir = os.path.dirname(model_path)
+            st.success(f"✅ Loaded from HuggingFace Hub: {repo_id}")
+        except Exception as e:
+            st.error(f"❌ Could not load from Hub: {e}")
+            return None, None
+
+        # Load tokenizer
+        tokenizer = LegionCoderTokenizer.load(model_dir)
+
+        # Create model with expanded architecture
+        model = LegionCoderModel(
+            vocab_size=16000,
+            d_model=576,
+            num_layers=13,
+            num_heads=16,
+            d_ff=1152,
+            max_seq_len=1024,
+            dropout=0.1
+        )
+
+        # Load weights
+        from safetensors.torch import load_file
+        state_dict = load_file(os.path.join(model_dir, 'model.safetensors'))
+        model.load_state_dict(state_dict, strict=False)
+        model.eval()
+
+        param_count = count_parameters(model)
+        st.success(f"✅ Model ready! {param_count:,} parameters ({param_count/1e6:.1f}M)")
+
+        return model, tokenizer
+
+
+def generate_response(model, tokenizer, messages, max_length=200):
+    """Generate response from the model."""
+    # Format conversation
+    prompt = ""
+    for msg in messages:
+        if msg['role'] == 'system':
+            prompt += f"<|system|>\n{msg['content']}\n"
+        elif msg['role'] == 'user':
+            prompt += f"<|user|>\n{msg['content']}\n"
+        elif msg['role'] == 'assistant':
+            prompt += f"<|assistant|>\n{msg['content']}\n"
+
+    prompt += "<|assistant|>\n"
+
+    # Encode
+    input_ids = torch.tensor([tokenizer.encode(prompt, add_special_tokens=False)], dtype=torch.long)
+
+    # Generate
+    with torch.no_grad():
+        generated = model.generate(
+            input_ids,
+            max_length=max_length,
+            temperature=0.8,
+            top_p=0.95,
+            top_k=50
+        )
+
+    # Decode
+    output = tokenizer.decode(generated[0].tolist(), skip_special_tokens=True)
+
+    # Extract only the assistant's response
+    if "<|assistant|>" in output:
+        parts = output.split("<|assistant|>")
+        if len(parts) > 1:
+            return parts[-1].strip()
+
+    return output.strip()
+
+
+def main():
+    """Main Streamlit app."""
+    # Header with DEATH LEGION branding
+    st.markdown("""
+    <div class="header-container">
+        <h1 class="header-title">⚡ LEGION CODER</h1>
+        <p class="header-subtitle">A 44M Parameter Transformer for Code Generation</p>
+        <div class="branding-badge">🔥 MADE WITH BY DEATH LEGION 🔥</div>
+        <div class="branding-badge" style="margin-left: 10px;">⚡ POWERED BY nvdya-kit ⚡</div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Load model
+    model, tokenizer = load_model()
+
+    if model is None or tokenizer is None:
+        st.error("❌ Failed to load model. Please check the logs.")
+        return
+
+    # Initialize chat history
+    if "messages" not in st.session_state:
+        st.session_state.messages = [
+            {"role": "system", "content": SYSTEM_PROMPT}
+        ]
+
+    # Display chat messages
+    for msg in st.session_state.messages:
+        if msg["role"] != "system":
+            with st.chat_message(msg["role"]):
+                st.markdown(msg["content"])
+
+    # Chat input
+    if prompt := st.chat_input("Ask me to write code, debug, or explain programming concepts..."):
+        # Add user message
+        st.session_state.messages.append({"role": "user", "content": prompt})
+
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+        # Generate response
+        with st.chat_message("assistant"):
+            with st.spinner("⚡ Legion Coder is thinking..."):
+                response = generate_response(model, tokenizer, st.session_state.messages)
+                st.markdown(response)
+
+        # Add assistant message
+        st.session_state.messages.append({"role": "assistant", "content": response})
+
+    # Sidebar info with enhanced branding
+    with st.sidebar:
+        st.markdown("""
+        <div style="text-align: center; padding: 1rem 0; border-bottom: 2px solid #ff0040; margin-bottom: 1.5rem;">
+            <h2 style="color: #ff0040; margin: 0; font-family: 'JetBrains Mono', monospace;">⚡ LEGION CODER</h2>
+            <p style="color: #888; font-size: 0.8rem; margin: 0.5rem 0;">DEATH LEGION Presents</p>
+        </div>
+        """, unsafe_allow_html=True)
+
+        st.markdown("""
+        ### 🚀 About
+        **Legion Coder** is a compact yet powerful 44M parameter transformer model
+        optimized for coding tasks.
+
+        ### ✨ Features
+        - Clean, efficient code generation
+        - PEP 8 compliant Python
+        - Helpful comments and explanations
+        - Debug assistance
+        - Multi-language support
+
+        ### 📊 Model Specs
+        | Attribute | Value |
+        |-----------|-------|
+        | Parameters | 44,341,632 |
+        | Hidden Size | 576 |
+        | Layers | 13 |
+        | Attention Heads | 16 |
+        | Context Length | 1,024 tokens |
+        """, unsafe_allow_html=True)
+
+        st.markdown("""
+        <div style="background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%); 
+                    padding: 1rem; border-radius: 12px; border: 1px solid #ff0040; margin-top: 1.5rem;">
+            <h4 style="color: #ff4081; margin: 0 0 0.5rem 0;">🔥 DEATH LEGION</h4>
+            <p style="color: #888; font-size: 0.85rem; margin: 0;">Crafted with precision and power by the DEATH LEGION team.</p>
+            <p style="color: #7c4dff; font-size: 0.8rem; margin: 0.5rem 0 0 0;">⚡ Powered by nvdya-kit</p>
+        </div>
+        """, unsafe_allow_html=True)
+
+        if st.button("🗑️ Clear Chat", use_container_width=True):
+            st.session_state.messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+            st.rerun()
+
+    # Footer with branding
+    st.markdown("""
+    <div class="footer">
+        <p><span class="footer-brand">🔥 MADE WITH BY DEATH LEGION 🔥</span></p>
+        <p>⚡ Powered by nvdya-kit | Legion Coder 8M v1.0</p>
+        <p style="font-size: 0.75rem; color: #666;">© 2024 DEATH LEGION. All rights reserved.</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+if __name__ == '__main__':
+    main()

requirements.txt

@@ -0,0 +1,5 @@
+streamlit>=1.28.0
+torch>=2.0.0
+safetensors>=0.4.0
+huggingface-hub>=0.19.0
+numpy>=1.24.0