feat: switch to deepseek model for token-free operation

app.py

@@ -4,6 +4,20 @@ import torch
 import gc
 from PIL import Image
 import io
+import logging
+import sys
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Add debug info to page
+debug_container = st.empty()
+
+def debug_info(msg):
+    logger.debug(msg)
+    if st.session_state.get('show_debug', False):
+        debug_container.info(msg)
 
 # Set page configuration
 st.set_page_config(
@@ -49,18 +63,59 @@ st.markdown("""
 </style>
 """, unsafe_allow_html=True)
 
+# Add debug toggle to sidebar
+def create_sidebar():
+    with st.sidebar:
+        st.image("https://raw.githubusercontent.com/streamlit/streamlit/develop/examples/streamlit_app_example.png", 
+                width=100)
+        st.title("🛠️ Settings")
+        
+        # Add debug toggle
+        st.session_state.show_debug = st.checkbox("Show Debug Info", value=False)
+        
+        task = st.selectbox(
+            "Select Task",
+            ["💻 Code Generation", "🖼️ Image Analysis", "📚 Concept Explanation"]
+        )
+        
+        st.markdown("---")
+        
+        if st.button("♻️ Clear Cache", use_container_width=True):
+            st.cache_resource.clear()
+            st.success("Cache cleared successfully!")
+        
+        st.markdown("""
+        ### 🌟 Pro Tips
+        - Use detailed descriptions
+        - Specify edge cases
+        - Include example inputs/outputs
+        """)
+        
+        return task.split()[1]  # Return without emoji
+
 @st.cache_resource
 def load_model():
     try:
+        debug_info("Loading model...")
         model_id = "deepseek-ai/deepseek-coder-1.3b-base"
         
+        debug_info(f"Initializing tokenizer from {model_id}")
         tokenizer = AutoTokenizer.from_pretrained(
             model_id,
             trust_remote_code=True,
-            padding_side='left'
+            padding_side='left',
+            truncation_side='left'
         )
-        tokenizer.pad_token = tokenizer.eos_token
         
+        # Validate tokenizer configuration
+        debug_info(f"Tokenizer pad_token: {tokenizer.pad_token}")
+        debug_info(f"Tokenizer vocab size: {len(tokenizer)}")
+        
+        if not hasattr(tokenizer, 'pad_token') or tokenizer.pad_token is None:
+            debug_info("Setting default pad token")
+            tokenizer.pad_token = '[PAD]'
+        
+        debug_info("Loading model weights...")
         model = AutoModelForCausalLM.from_pretrained(
             model_id,
             torch_dtype=torch.float32,
@@ -69,82 +124,101 @@ def load_model():
             max_memory={'cpu': '16GB'}
         )
         
+        # Validate model configuration
+        debug_info(f"Model device: {next(model.parameters()).device}")
+        debug_info(f"Model memory: {torch.cuda.max_memory_allocated() if torch.cuda.is_available() else 'CPU only'}")
+        
+        # Ensure model knows about pad token
+        model.config.pad_token_id = tokenizer.pad_token_id
+        model.config.eos_token_id = tokenizer.eos_token_id
         model.eval()
         torch.set_num_threads(8)
         gc.collect()
         return model, tokenizer
         
     except Exception as e:
+        logger.error(f"Model loading error: {str(e)}")
         st.error(f"Error loading model: {str(e)}")
         st.stop()
 
-def generate_response(prompt, image=None):
-    model, tokenizer = load_model()
-    
+def generate_response_streaming(prompt, model, tokenizer, placeholder):
     try:
+        debug_info("Starting text generation...")
+        debug_info(f"Input prompt length: {len(prompt)}")
+        
+        # Validate inputs
+        if not all([model, tokenizer, placeholder]):
+            raise ValueError("Missing required components")
+            
         code_prompt = f"""Write professional code based on the given requirements.
         Language: {prompt.split('code for:')[0] if 'code for:' in prompt else 'any'}
         Requirements: {prompt}
         
-        Here's the implementation:
-        ```"""
+        Here's the implementation:"""
         
+        # Create input tensors with proper attention masks
         inputs = tokenizer(
             code_prompt,
             return_tensors="pt",
             padding=True,
+            truncation=True,
             max_length=1024,
-            truncation=True
+            add_special_tokens=True,
+            return_attention_mask=True
         )
         
+        # Ensure input tensors are properly shaped
+        attention_mask = inputs['attention_mask']
+        input_ids = inputs['input_ids']
+        
+        generated_text = ""
         with torch.inference_mode():
-            outputs = model.generate(
-                inputs["input_ids"],
-                max_length=2048,  # Increased for longer code
-                temperature=0.5,   # More focused
-                top_p=0.95,
-                top_k=50,
-                repetition_penalty=1.2,
-                do_sample=True,
-                num_return_sequences=1,
-                pad_token_id=tokenizer.eos_token_id
-            )
+            while input_ids.shape[1] < 2048:
+                outputs = model.generate(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    max_new_tokens=1,  # Generate one token at a time
+                    pad_token_id=tokenizer.pad_token_id,
+                    eos_token_id=tokenizer.eos_token_id,
+                    do_sample=True,
+                    temperature=0.5,
+                    top_p=0.95,
+                    repetition_penalty=1.1,
+                )
+                
+                # Get next token and update tensors
+                next_token = outputs[:, -1:]
+                input_ids = torch.cat([input_ids, next_token], dim=1)
+                attention_mask = torch.ones_like(input_ids)
+                
+                # Update display
+                current_text = tokenizer.decode(input_ids[0], skip_special_tokens=True)
+                generated_text = current_text.replace(code_prompt, "").strip()
+                placeholder.code(generated_text)
+                
+                # Check for completion
+                if next_token[0, 0].item() == tokenizer.eos_token_id:
+                    break
+        
+        # Add validation checks during generation
+        if attention_mask.shape != input_ids.shape:
+            debug_info(f"Shape mismatch - attention: {attention_mask.shape}, ids: {input_ids.shape}")
             
-            response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-            # Clean up response
-            code = response.split("```")[1] if "```" in response else response
-            return code.strip()
+        debug_info(f"Generation complete. Output length: {len(generated_text)}")
+        return generated_text
             
     except Exception as e:
+        logger.error(f"Generation error: {str(e)}")
         return f"Error: {str(e)}"
 
-def create_sidebar():
-    with st.sidebar:
-        st.image("https://raw.githubusercontent.com/streamlit/streamlit/develop/examples/streamlit_app_example.png", 
-                width=100)
-        st.title("🛠️ Settings")
-        
-        task = st.selectbox(
-            "Select Task",
-            ["💻 Code Generation", "🖼️ Image Analysis", "📚 Concept Explanation"]
-        )
-        
-        st.markdown("---")
-        
-        if st.button("♻️ Clear Cache", use_container_width=True):
-            st.cache_resource.clear()
-            st.success("Cache cleared successfully!")
-        
-        st.markdown("""
-        ### 🌟 Pro Tips
-        - Use detailed descriptions
-        - Specify edge cases
-        - Include example inputs/outputs
-        """)
-        
-        return task.split()[1]  # Return without emoji
-
 def code_generation_ui():
+    debug_info("Initializing UI components")
+    
+    # Validate PROGRAMMING_LANGUAGES is defined
+    if 'PROGRAMMING_LANGUAGES' not in globals():
+        st.error("Programming languages configuration not found")
+        return
+    
     col1, col2 = st.columns([2, 1])
     
     with col1:
@@ -184,16 +258,21 @@ def code_generation_ui():
         generate = st.button("🚀 Generate Code", use_container_width=True)
     
     if generate and prompt:
-        with st.spinner("🔮 Generating your code..."):
-            options = {
-                "comments": add_comments,
-                "tests": include_tests,
-                "error_handling": error_handling
-            }
-            code = generate_enhanced_response(prompt, language, template, options)
+        debug_info(f"Generating code for language: {language}")
+        debug_info(f"Template: {template}")
+        debug_info(f"Options: comments={add_comments}, tests={include_tests}")
+        
+        st.markdown("### 📋 Generated Code")
+        
+        # Create a placeholder for streaming output
+        code_placeholder = st.empty()
+        
+        with st.spinner("🔮 Generating..."):
+            model, tokenizer = load_model()
+            code = generate_response_streaming(prompt, model, tokenizer, code_placeholder)
             
-            st.markdown("### 📋 Generated Code")
-            with st.expander("Show Code", expanded=True):
+            # After generation complete, show final version with copy/download buttons
+            with st.expander("Final Code", expanded=True):
                 st.code(code, language=language.lower())
                 
                 col1, col2 = st.columns([1, 1])
@@ -207,6 +286,17 @@ def code_generation_ui():
                 with col2:
                     st.button("📋 Copy to Clipboard")
 
+# Add global variables check
+if 'PROGRAMMING_LANGUAGES' not in globals():
+    PROGRAMMING_LANGUAGES = {
+        "Web Development": ["HTML", "CSS", "JavaScript", "TypeScript", "PHP"],
+        "Backend": ["Python", "Java", "C#", "Ruby", "Go", "Node.js"],
+        "Data & ML": ["Python", "R", "SQL", "Julia"],
+        "Mobile": ["Swift", "Kotlin", "Java", "React Native"],
+        "System": ["C", "C++", "Rust", "Shell"]
+    }
+    debug_info("Initialized PROGRAMMING_LANGUAGES")
+
 def main():
     task = create_sidebar()
     

requirements.txt

@@ -1,16 +1,28 @@
 # Core dependencies
 streamlit>=1.41.1
+watchdog>=3.0.0
+
+# Model and ML
 torch>=2.0.0
 transformers>=4.33.0
 accelerate>=0.21.0
+sentencepiece>=0.1.99
+einops>=0.6.1
+scikit-learn>=1.3.0
 
 # UI enhancements
+streamlit-option-menu>=0.3.2
 streamlit-ace>=0.1.1
 streamlit-extras>=0.3.0
 streamlit-code-editor>=0.1.6
 
-# Model dependencies
-sentencepiece>=0.1.99
+# Image processing
 Pillow>=9.0.0
-einops>=0.6.1
-scikit-learn
+
+# Performance optimizations
+rich>=13.5.2
+tqdm>=4.65.0
+numpy>=1.24.0
+
+# Memory management
+psutil>=5.9.0