Deploy Gradio app with multiple files

app.py

@@ -0,0 +1,217 @@
+import gradio as gr
+import spaces
+from models import CodeModel
+from utils import format_code_response, parse_model_output
+import torch
+import os
+from typing import List, Dict, Any
+
+# Initialize the code model
+code_model = CodeModel()
+
+def chat_with_coder(message: str, history: List[Dict[str, str]], language: str = "python", temperature: float = 0.7) -> Dict[str, Any]:
+    """
+    Main chatbot function that handles coding queries with a 5B parameter model.
+    
+    Args:
+        message (str): User's input message
+        history (List[Dict[str, str]]): Chat history in OpenAI format
+        language (str): Target programming language
+        temperature (float): Generation temperature (0.0-1.0)
+    
+    Returns:
+        Dict[str, Any]: Updated chat history and response
+    """
+    try:
+        # Add context about coding capabilities
+        system_prompt = f"""You are an expert {language} programmer and AI coding assistant. 
+You help users with:
+- Writing and debugging {language} code
+- Code optimization and best practices
+- Explaining complex programming concepts
+- Code review and suggestions
+- Algorithm implementation
+
+Always provide clean, well-commented, and efficient code. Format code blocks properly with language specification."""
+        
+        # Prepare messages for the model
+        messages = [{"role": "system", "content": system_prompt}]
+        messages.extend(history)
+        messages.append({"role": "user", "content": message})
+        
+        # Generate response using the model
+        response = code_model.generate(
+            messages=messages,
+            temperature=temperature,
+            max_new_tokens=2048,
+            language=language
+        )
+        
+        # Parse and format the response
+        formatted_response = format_code_response(response)
+        
+        # Update chat history
+        new_history = history.copy()
+        new_history.append({"role": "user", "content": message})
+        new_history.append({"role": "assistant", "content": formatted_response})
+        
+        return {"choices": [{"message": {"content": formatted_response}}], "history": new_history}
+        
+    except Exception as e:
+        error_msg = f"I apologize, but I encountered an error: {str(e)}. Please try again or rephrase your question."
+        return {"choices": [{"message": {"content": error_msg}}], "history": history}
+
+def clear_chat():
+    """Clear the chat history."""
+    return {"choices": [{"message": {"content": "Hello! I'm your AI coding assistant powered by a 5B parameter language model. I can help you with Python, JavaScript, Java, C++, and many other programming languages. What would you like to code today?"}}], "history": []}
+
+def create_demo():
+    """Create the Gradio demo interface."""
+    
+    with gr.Blocks(
+        title="AI Coder - 5B Parameter Chatbot",
+        description="Powered by a 5B parameter language model with coding capabilities",
+        theme=gr.themes.Soft(),
+        css="""
+        .container {max-width: 1200px !important;}
+        .header {text-align: center; padding: 20px;}
+        .header h1 {color: #2d3748; margin-bottom: 10px;}
+        .header a {color: #3182ce; text-decoration: none; font-weight: bold;}
+        .header a:hover {text-decoration: underline;}
+        .coding-section {background: #f7fafc; border-radius: 8px; padding: 15px; margin: 10px 0;}
+        """
+    ) as demo:
+        
+        # Header
+        gr.HTML("""
+        <div class="header">
+            <h1>🤖 AI Coder - Powered by 5B Parameter Model</h1>
+            <p>Advanced AI chatbot with comprehensive coding features using a 5B parameter language model</p>
+            <p>Built with <a href="https://huggingface.co/spaces/akhaliq/anycoder" target="_blank">anycoder</a></p>
+        </div>
+        """)
+        
+        # Main chat interface
+        with gr.Row():
+            # Left column - Chat
+            with gr.Column(scale=3):
+                chatbot = gr.Chatbot(
+                    label="AI Coding Assistant",
+                    height=600,
+                    type="messages",
+                    avatar_images=(None, "🤖"),
+                    show_copy_button=True
+                )
+                
+                with gr.Row():
+                    msg = gr.Textbox(
+                        placeholder="Ask me to code something, debug code, or explain programming concepts...",
+                        lines=3,
+                        scale=4
+                    )
+                    send_btn = gr.Button("Send", variant="primary", scale=1)
+                
+                with gr.Row():
+                    clear_btn = gr.Button("Clear Chat", variant="secondary")
+            
+            # Right column - Controls
+            with gr.Column(scale=1):
+                gr.Markdown("### 🛠️ Coding Settings")
+                
+                language = gr.Dropdown(
+                    choices=[
+                        "python", "javascript", "java", "cpp", "c", "go", 
+                        "rust", "typescript", "php", "ruby", "swift", "kotlin",
+                        "sql", "html", "css", "bash", "powershell"
+                    ],
+                    value="python",
+                    label="Programming Language",
+                    info="Target language for code generation"
+                )
+                
+                temperature = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.7,
+                    step=0.1,
+                    label="Creativity (Temperature)",
+                    info="Lower for precise code, higher for creative solutions"
+                )
+                
+                with gr.Accordion("🎯 Quick Coding Prompts", open=False):
+                    gr.Examples(
+                        examples=[
+                            "Write a Python function to reverse a linked list",
+                            "Create a React component for a login form",
+                            "Debug this JavaScript code: [paste code]",
+                            "Explain Big O notation with code examples",
+                            "Write SQL queries for a user management system",
+                            "Create a binary search algorithm in C++"
+                        ],
+                        inputs=msg,
+                        examples_per_page=3
+                    )
+                
+                with gr.Accordion("🔧 Model Info", open=False):
+                    gr.Markdown(f"""
+                    **Model:** {code_model.model_name}
+                    **Parameters:** {code_model.parameter_count}
+                    **Max Context:** {code_model.max_length:,} tokens
+                    **Device:** {'CUDA' if torch.cuda.is_available() else 'CPU'}
+                    **Status:** {'✅ Ready' if code_model.is_loaded else '⏳ Loading...'}
+                    """)
+        
+        # Event handlers
+        def user(user_message, history):
+            return "", history + [{"role": "user", "content": user_message}]
+        
+        def bot(history, selected_language, temp):
+            if not history:
+                return history
+            
+            last_message = history[-1]["content"]
+            result = chat_with_coder(last_message, history[:-1], selected_language, temp)
+            return result["history"]
+        
+        # Wire up events
+        msg.submit(
+            user, 
+            [msg, chatbot], 
+            [msg, chatbot], 
+            queue=False
+        ).then(
+            bot,
+            [chatbot, language, temperature],
+            chatbot
+        )
+        
+        send_btn.click(
+            user,
+            [msg, chatbot],
+            [msg, chatbot],
+            queue=False
+        ).then(
+            bot,
+            [chatbot, language, temperature],
+            chatbot
+        )
+        
+        clear_btn.click(
+            clear_chat,
+            outputs=[chatbot]
+        )
+        
+        # Load initial message
+        chatbot.value = [{"role": "assistant", "content": "Hello! I'm your AI coding assistant powered by a 5B parameter language model. I can help you with Python, JavaScript, Java, C++, and many other programming languages. What would you like to code today?"}]
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_demo()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        share=False,
+        debug=True
+    )

models.py

@@ -0,0 +1,185 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from typing import List, Dict, Any, Optional
+import logging
+
+class CodeModel:
+    """5B Parameter coding model wrapper with optimized inference."""
+    
+    def __init__(self):
+        self.model_name = "bigcode/starcoder2-7b"  # 7B model (closest to 5B with excellent coding)
+        self.parameter_count = "7B"
+        self.max_length = 16384
+        self.tokenizer = None
+        self.model = None
+        self.pipeline = None
+        self.is_loaded = False
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.setup_model()
+    
+    def setup_model(self):
+        """Initialize and load the 5B+ parameter coding model."""
+        try:
+            print(f"Loading {self.model_name} model...")
+            
+            # Load tokenizer and model
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model_name,
+                trust_remote_code=True,
+                padding_side="left"
+            )
+            
+            # Set pad token if not present
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+            
+            # Load model with optimization
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto" if self.device == "cuda" else None,
+                trust_remote_code=True,
+                low_cpu_mem_usage=True
+            )
+            
+            # Create pipeline for easier inference
+            self.pipeline = pipeline(
+                "text-generation",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                device=0 if self.device == "cuda" else -1,
+                do_sample=True,
+                temperature=0.7,
+                top_p=0.95,
+                repetition_penalty=1.1,
+                max_new_tokens=2048,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+            
+            self.is_loaded = True
+            print(f"✅ {self.model_name} loaded successfully on {self.device}")
+            
+        except Exception as e:
+            print(f"❌ Error loading model: {e}")
+            self._fallback_model()
+    
+    def _fallback_model(self):
+        """Fallback to a smaller model if the main model fails to load."""
+        try:
+            print("Trying fallback model: microsoft/DialoGPT-medium")
+            self.model_name = "microsoft/DialoGPT-medium"
+            self.parameter_count = "345M"
+            self.max_length = 1024
+            
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+            
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto" if self.device == "cuda" else None
+            )
+            
+            self.pipeline = pipeline(
+                "text-generation",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                device=0 if self.device == "cuda" else -1,
+                max_new_tokens=512,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+            
+            self.is_loaded = True
+            print(f"✅ Fallback model loaded successfully")
+            
+        except Exception as e:
+            print(f"❌ Fallback model also failed: {e}")
+            self.is_loaded = False
+    
+    def generate(
+        self, 
+        messages: List[Dict[str, str]], 
+        temperature: float = 0.7,
+        max_new_tokens: int = 2048,
+        language: str = "python"
+    ) -> str:
+        """Generate response from the model."""
+        
+        if not self.is_loaded:
+            return "I'm sorry, the model is not loaded yet. Please try again in a moment."
+        
+        try:
+            # Convert chat format to text
+            if messages:
+                # Format as conversation
+                conversation = ""
+                for msg in messages:
+                    role = msg["role"]
+                    content = msg["content"]
+                    if role == "system":
+                        conversation += f"System: {content}\n\n"
+                    elif role == "user":
+                        conversation += f"Human: {content}\n"
+                    elif role == "assistant":
+                        conversation += f"Assistant: {content}\n"
+                
+                # Add specific coding instructions
+                if "write" in conversation.lower() or "code" in conversation.lower():
+                    conversation += f"\n\nPlease provide clean, well-commented {language} code with proper syntax and best practices."
+                
+                conversation += "\nAssistant:"
+            
+            # Generate response
+            with torch.no_grad():
+                if self.pipeline:
+                    # Use pipeline for generation
+                    outputs = self.pipeline(
+                        conversation,
+                        do_sample=True,
+                        temperature=temperature,
+                        top_p=0.95,
+                        repetition_penalty=1.1,
+                        max_new_tokens=max_new_tokens,
+                        pad_token_id=self.tokenizer.eos_token_id,
+                        eos_token_id=self.tokenizer.eos_token_id,
+                        return_full_text=False
+                    )
+                    
+                    if outputs and len(outputs) > 0:
+                        return outputs[0]["generated_text"].strip()
+                
+                # Fallback to direct model generation
+                inputs = self.tokenizer.encode(conversation, return_tensors="pt").to(self.device)
+                
+                with torch.no_grad():
+                    outputs = self.model.generate(
+                        inputs,
+                        do_sample=True,
+                        temperature=temperature,
+                        top_p=0.95,
+                        repetition_penalty=1.1,
+                        max_new_tokens=max_new_tokens,
+                        pad_token_id=self.tokenizer.eos_token_id,
+                        eos_token_id=self.tokenizer.eos_token_id,
+                        attention_mask=torch.ones_like(inputs)
+                    )
+                
+                # Decode response
+                response = self.tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)
+                return response.strip()
+                
+        except Exception as e:
+            logging.error(f"Generation error: {e}")
+            return f"I apologize, but I encountered an error while generating the response: {str(e)}"
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """Get information about the loaded model."""
+        return {
+            "model_name": self.model_name,
+            "parameter_count": self.parameter_count,
+            "max_length": self.max_length,
+            "device": self.device,
+            "is_loaded": self.is_loaded,
+            "vocab_size": len(self.tokenizer) if self.tokenizer else 0
+        }

requirements.txt

@@ -0,0 +1,21 @@
+gradio
+spaces
+transformers
+torch
+accelerate
+tokenizers
+datasets
+numpy
+pandas
+requests
+huggingface-hub
+python-multipart
+fastapi
+uvicorn
+peft
+bitsandbytes
+scipy
+matplotlib
+seaborn
+jupyter
+ipywidgets

utils.py

@@ -0,0 +1,262 @@
+import re
+from typing import Dict, List, Any, Optional
+import json
+
+def format_code_response(response: str) -> str:
+    """
+    Format and enhance code responses with proper syntax highlighting and structure.
+    
+    Args:
+        response (str): Raw model response
+        
+    Returns:
+        str: Formatted response with enhanced code blocks
+    """
+    if not response:
+        return "I'm sorry, I couldn't generate a response. Could you please rephrase your question?"
+    
+    # Detect and format code blocks
+    formatted_response = response
+    
+    # Enhance existing code blocks
+    code_block_pattern = r'```(\w+)?\n(.*?)```'
+    
+    def replace_code_block(match):
+        language = match.group(1) or "text"
+        code_content = match.group(2).strip()
+        
+        # Clean up the code content
+        code_content = clean_code_content(code_content, language)
+        
+        return f'```{language}\n{code_content}\n```'
+    
+    # Apply code block formatting
+    formatted_response = re.sub(code_block_pattern, replace_code_block, response, flags=re.DOTALL)
+    
+    # Add helpful tips for coding responses
+    if any(keyword in response.lower() for keyword in ['def ', 'function', 'class ', 'import ', 'from ']):
+        # This appears to be a code response, add a helpful note
+        formatted_response += "\n\n💡 **Tip:** You can copy this code directly and use it in your project. Don't forget to install any required dependencies!"
+    
+    # Add execution hints for certain languages
+    if 'python' in formatted_response.lower() and 'pip install' not in formatted_response.lower():
+        if any(module in formatted_response.lower() for module in ['requests', 'numpy', 'pandas', 'tensorflow', 'pytorch']):
+            formatted_response += "\n\n⚠️ **Note:** Some packages may need to be installed first. Check the imports and install any missing dependencies."
+    
+    return formatted_response
+
+def clean_code_content(code: str, language: str) -> str:
+    """
+    Clean and optimize code content for better readability.
+    
+    Args:
+        code (str): Raw code content
+        language (str): Programming language
+        
+    Returns:
+        str: Cleaned code content
+    """
+    # Remove excessive whitespace
+    lines = code.split('\n')
+    cleaned_lines = []
+    prev_empty = False
+    
+    for line in lines:
+        # Skip completely empty lines at the start
+        if not line.strip() and not cleaned_lines:
+            continue
+        
+        # Normalize indentation
+        cleaned_line = line.rstrip()
+        cleaned_lines.append(cleaned_line)
+        
+        prev_empty = not line.strip()
+    
+    # Limit excessive empty lines
+    result_lines = []
+    empty_count = 0
+    
+    for line in cleaned_lines:
+        if not line.strip():
+            empty_count += 1
+            if empty_count <= 2:  # Max 2 consecutive empty lines
+                result_lines.append(line)
+        else:
+            empty_count = 0
+            result_lines.append(line)
+    
+    return '\n'.join(result_lines)
+
+def parse_model_output(output: str) -> Dict[str, Any]:
+    """
+    Parse and extract structured information from model output.
+    
+    Args:
+        output (str): Raw model output
+        
+    Returns:
+        Dict[str, Any]: Structured information about the response
+    """
+    result = {
+        "raw_output": output,
+        "has_code": False,
+        "code_language": None,
+        "code_blocks": [],
+        "suggestions": [],
+        "explanations": []
+    }
+    
+    # Extract code blocks
+    code_pattern = r'```(\w+)?\n(.*?)```'
+    code_matches = re.findall(code_pattern, output, re.DOTALL)
+    
+    if code_matches:
+        result["has_code"] = True
+        for lang, code in code_matches:
+            result["code_blocks"].append({
+                "language": lang or "text",
+                "content": code.strip()
+            })
+            if not result["code_language"]:
+                result["code_language"] = lang
+    
+    # Extract explanations (lines that don't contain code)
+    lines = output.split('\n')
+    for line in lines:
+        line = line.strip()
+        if line and not line.startswith('```') and not any(keyword in line.lower() for keyword in ['def ', 'class ', 'import ', 'from ', '{', '}', '(', ')', ';', 'console.log', 'print(']):
+            if len(line) > 20:  # Only substantial lines
+                result["explanations"].append(line)
+    
+    return result
+
+def format_error_message(error: Exception, user_message: str = "") -> str:
+    """
+    Format error messages in a user-friendly way.
+    
+    Args:
+        error (Exception): The caught exception
+        user_message (str): The original user message
+        
+    Returns:
+        str: Formatted error message
+    """
+    error_type = type(error).__name__
+    error_msg = str(error)
+    
+    # Common error patterns and helpful responses
+    if "CUDA" in error_msg and "out of memory" in error_msg.lower():
+        helpful_msg = "I'm experiencing memory limitations. Please try a shorter message or simpler request."
+    elif "timeout" in error_msg.lower():
+        helpful_msg = "The request is taking too long. Please try with a shorter prompt."
+    elif "connection" in error_msg.lower() or "network" in error_msg.lower():
+        helpful_msg = "I'm having trouble connecting to the model. Please check your connection and try again."
+    else:
+        helpful_msg = "I'm encountering a technical issue. Please try rephrasing your question or try again later."
+    
+    return f"❌ {helpful_msg}\n\n**Technical details:** {error_type}: {error_msg}"
+
+def extract_coding_concepts(text: str) -> List[str]:
+    """
+    Extract programming concepts and keywords from text.
+    
+    Args:
+        text (str): Input text
+        
+    Returns:
+        List[str]: List of detected programming concepts
+    """
+    programming_concepts = [
+        'algorithm', 'data structure', 'complexity', 'recursion', 'iteration',
+        'object-oriented', 'functional programming', 'design pattern', 'api',
+        'database', 'sql', 'nosql', 'testing', 'debugging', 'optimization',
+        'performance', 'security', 'authentication', 'authorization',
+        'microservices', 'serverless', 'docker', 'kubernetes', 'devops',
+        'machine learning', 'data science', 'web scraping', 'automation'
+    ]
+    
+    text_lower = text.lower()
+    detected_concepts = []
+    
+    for concept in programming_concepts:
+        if concept in text_lower:
+            detected_concepts.append(concept)
+    
+    return detected_concepts
+
+def create_example_prompts() -> Dict[str, List[str]]:
+    """Create example prompts organized by category."""
+    return {
+        "Beginner": [
+            "Write a Python function to calculate factorial",
+            "Create a simple HTML page with a login form",
+            "Explain what variables are in programming"
+        ],
+        "Intermediate": [
+            "Write a binary search algorithm in JavaScript",
+            "Create a REST API endpoint in Flask",
+            "Explain the difference between arrays and linked lists"
+        ],
+        "Advanced": [
+            "Implement a concurrent web scraper in Python",
+            "Design a database schema for an e-commerce system",
+            "Optimize this SQL query for better performance"
+        ],
+        "Debugging": [
+            "Debug this Python code: [code]",
+            "Why is my JavaScript function returning undefined?",
+            "Help me fix this SQL syntax error"
+        ],
+        "Code Review": [
+            "Review this function for best practices",
+            "How can I make this code more efficient?",
+            "What security issues do you see in this code?"
+        ]
+    }
+
+def validate_code_syntax(code: str, language: str) -> Dict[str, Any]:
+    """
+    Basic syntax validation for generated code.
+    
+    Args:
+        code (str): Code to validate
+        language (str): Programming language
+        
+    Returns:
+        Dict[str, Any]: Validation results
+    """
+    validation_result = {
+        "is_valid": True,
+        "issues": [],
+        "suggestions": []
+    }
+    
+    # Basic validation rules
+    if language == "python":
+        # Check for basic Python syntax issues
+        if code.count('(') != code.count(')'):
+            validation_result["issues"].append("Unbalanced parentheses")
+            validation_result["is_valid"] = False
+        
+        if code.count('{') != code.count('}'):
+            validation_result["issues"].append("Unbalanced braces")
+            validation_result["is_valid"] = False
+        
+        # Common suggestions
+        if 'def ' in code and ':' not in code:
+            validation_result["suggestions"].append("Function definitions should end with a colon")
+        
+        if 'import ' in code and '\n' not in code:
+            validation_result["suggestions"].append("Consider organizing imports at the top of the file")
+    
+    elif language in ["javascript", "typescript"]:
+        # Check for common JS syntax issues
+        if code.count('{') != code.count('}'):
+            validation_result["issues"].append("Unbalanced curly braces")
+            validation_result["is_valid"] = False
+        
+        if code.count('(') != code.count(')'):
+            validation_result["issues"].append("Unbalanced parentheses")
+            validation_result["is_valid"] = False
+    
+    return validation_result