Update app.py

app.py

@@ -1,252 +1,292 @@
 import gradio as gr
 import torch
-from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
-from peft import PeftModel
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from huggingface_hub import login
 import os
-from typing import Tuple, Optional
+import subprocess
+import sys
 
-# Configuration
-class Config:
-    MODEL_PATH = "navidfalah/3ai"  # Your HF model repo
-    BASE_MODEL = "mistralai/Mistral-7B-Instruct-v0.1"  # Mistral base model
-    ADAPTER_PATH = "./model"  # Local adapter path if needed
-    MAX_NEW_TOKENS = 2000
-    TEMPERATURE = 0.7
-    TOP_P = 0.9
-    MAX_INPUT_LENGTH = 1024
-    
-# Global variables for model and tokenizer
-model = None
-tokenizer = None
+print("Starting 3AI application...")
 
-def load_model() -> Tuple[Optional[object], Optional[object]]:
-    """Load the fine-tuned satisfaction analysis model."""
-    global model, tokenizer
-    
-    if model is not None and tokenizer is not None:
-        return model, tokenizer
-    
+# Install required dependencies
+print("Installing required dependencies...")
+try:
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "sentencepiece", "protobuf", "peft", "--quiet"])
+    print("Dependencies installed successfully!")
+except Exception as e:
+    print(f"Warning: Could not install dependencies: {e}")
+
+# Import PEFT after installation
+try:
+    from peft import PeftModel, PeftConfig
+    print("PEFT imported successfully!")
+except ImportError as e:
+    print(f"Could not import PEFT: {e}")
+    print("Trying to install PEFT again...")
     try:
-        print("🔄 Loading Mistral model and tokenizer...")
-        
-        # Load tokenizer from base model (Mistral)
-        tokenizer = AutoTokenizer.from_pretrained(Config.BASE_MODEL)
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
-            tokenizer.padding_side = "right"
-        
-        # Quantization config for efficient inference
-        bnb_config = BitsAndBytesConfig(
-            load_in_4bit=True,
-            bnb_4bit_use_double_quant=True,
-            bnb_4bit_quant_type="nf4",
-            bnb_4bit_compute_dtype=torch.float16
-        )
-        
-        # Load base Mistral model
-        base_model = AutoModelForCausalLM.from_pretrained(
-            Config.BASE_MODEL,
-            quantization_config=bnb_config,
-            device_map="auto",
-            trust_remote_code=True,
-            torch_dtype=torch.float16
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "peft", "--force-reinstall"])
+        from peft import PeftModel, PeftConfig
+        print("PEFT installed and imported successfully!")
+    except Exception as e2:
+        print(f"Failed to install PEFT: {e2}")
+        print("Continuing without PEFT - will try alternative approach")
+        PeftModel = None
+        PeftConfig = None
+
+# Login using the secret token
+token = os.getenv("HF_TOKEN")
+if token:
+    login(token=token)
+    print("Successfully logged in to Hugging Face!")
+
+# Use your own Hugging Face model
+original_mistral_model = "navidfalah/3ai"  # Your model on Hugging Face
+adapter_path = "./model"  # Your local LoRA adapter directory (if available)
+
+print(f"Loading original Mistral tokenizer from {original_mistral_model}...")
+try:
+    # First try: Load with slow tokenizer from your model
+    tokenizer = AutoTokenizer.from_pretrained(
+        original_mistral_model,
+        use_fast=False,  # Use slow tokenizer to avoid issues
+        force_download=True,  # Force fresh download
+        resume_download=False
+    )
+    print("Your model tokenizer loaded successfully!")
+except Exception as e:
+    print(f"Error loading tokenizer from your model: {e}")
+    try:
+        # Second try: Use original Mistral tokenizer
+        tokenizer = AutoTokenizer.from_pretrained(
+            "mistralai/Mistral-7B-Instruct-v0.1",
+            use_fast=False
         )
-        
-        # Try loading adapter from HF repo first
+        print("Original Mistral tokenizer loaded successfully!")
+    except Exception as e2:
+        print(f"Error with original Mistral: {e2}")
         try:
-            model = PeftModel.from_pretrained(
-                base_model,
-                Config.MODEL_PATH,
-                is_trainable=False
+            # Third try: Use different Mistral model version
+            print("Trying Mistral-7B-Instruct-v0.2...")
+            tokenizer = AutoTokenizer.from_pretrained(
+                "mistralai/Mistral-7B-Instruct-v0.2",
+                use_fast=False
             )
-            print("✅ Loaded model from Hugging Face repo")
-        except:
-            # Fallback to local adapter if available
-            if os.path.exists(Config.ADAPTER_PATH):
-                model = PeftModel.from_pretrained(
-                    base_model,
-                    Config.ADAPTER_PATH,
-                    is_trainable=False
+            print("Mistral v0.2 tokenizer loaded successfully!")
+        except Exception as e3:
+            print(f"Error with Mistral v0.2: {e3}")
+            try:
+                # Fourth try: Use compatible tokenizer
+                print("Trying compatible tokenizer...")
+                tokenizer = AutoTokenizer.from_pretrained(
+                    "microsoft/DialoGPT-medium",
+                    use_fast=False
                 )
-                print("✅ Loaded model from local adapter")
-            else:
-                raise Exception("Could not load adapter from HF or local path")
-        
-        model.eval()
-        print("✅ Mistral-7B model loaded successfully!")
-        return model, tokenizer
-        
-    except Exception as e:
-        print(f"❌ Error loading model: {e}")
-        return None, None
+                print("Compatible tokenizer loaded successfully!")
+            except Exception as e4:
+                print(f"Error with compatible tokenizer: {e4}")
+                try:
+                    # Fifth try: Use GPT-2 as fallback
+                    print("Using GPT-2 as fallback...")
+                    tokenizer = AutoTokenizer.from_pretrained("gpt2")
+                    print("GPT-2 tokenizer loaded successfully!")
+                except Exception as e5:
+                    print(f"Cannot load any tokenizer: {e5}")
+                    print("Exiting - cannot proceed without tokenizer")
+                    exit(1)
+
+# Ensure tokenizer has proper tokens
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
 
-def analyze_satisfaction(user_input: str) -> str:
-    """Generate satisfaction analysis based on user input text."""
+print(f"Loading your model from {original_mistral_model}...")
+try:
+    # Load your model from Hugging Face
+    base_model = AutoModelForCausalLM.from_pretrained(
+        original_mistral_model,
+        torch_dtype=torch.float16,
+        device_map="auto",
+        low_cpu_mem_usage=True
+    )
+    print("Your model loaded successfully!")
     
-    # Load model if not already loaded
-    model, tokenizer = load_model()
+    # Check if PEFT is available and try to load local adapter
+    if PeftModel is not None and PeftConfig is not None:
+        try:
+            print(f"Trying to load local LoRA adapter from {adapter_path}...")
+            model = PeftModel.from_pretrained(
+                base_model,
+                adapter_path,
+                torch_dtype=torch.float16
+            )
+            print("Local LoRA adapter loaded successfully!")
+        except Exception as adapter_error:
+            print(f"Could not load local adapter: {adapter_error}")
+            print("Using your base model without additional adapter")
+            model = base_model
+    else:
+        print("PEFT not available - using your base model")
+        model = base_model
     
-    if model is None or tokenizer is None:
-        return "❌ Error: Could not load the model. Please try again later."
+except Exception as e:
+    print(f"Error loading your model: {e}")
+    print("Trying to load original Mistral as fallback...")
+    try:
+        # Fallback to original Mistral
+        base_model = AutoModelForCausalLM.from_pretrained(
+            "mistralai/Mistral-7B-Instruct-v0.1",
+            torch_dtype=torch.float16,
+            device_map="auto",
+            low_cpu_mem_usage=True
+        )
+        print("Fallback Mistral model loaded!")
+        model = base_model
+    except Exception as e2:
+        print(f"Cannot load any model: {e2}")
+        print("Exiting - cannot proceed without model")
+        exit(1)
+
+def chat_function(message):
+    if not message or not message.strip():
+        return "Please enter a message."
     
-    if not user_input.strip():
-        return "⚠️ Please enter some text describing your life situation or what you'd like analyzed."
+    # Clean and limit input
+    message = message.strip()
+    if len(message) > 500:
+        return "Message too long! Please keep it under 500 characters."
     
     try:
+        # Use flexible prompt format based on tokenizer type
+        if hasattr(tokenizer, 'chat_template') or 'mistral' in tokenizer.name_or_path.lower():
+            # Use Mistral format if it's actually Mistral
+            prompt = f"<s>[INST] {message} [/INST]"
+        else:
+            # Use simple format for other tokenizers
+            prompt = f"User: {message}\nAssistant:"
+        
         # Tokenize input
         inputs = tokenizer(
-            user_input, 
-            return_tensors="pt", 
+            prompt, 
+            return_tensors='pt', 
             truncation=True, 
-            max_length=Config.MAX_INPUT_LENGTH
+            max_length=400,
+            padding=True
         )
+        input_ids = inputs['input_ids']
+        attention_mask = inputs.get('attention_mask', None)
         
-        # Move to GPU if available
-        if torch.cuda.is_available():
-            inputs = {k: v.to(model.device) for k, v in inputs.items()}
+        # Move to model device
+        device = next(model.parameters()).device
+        input_ids = input_ids.to(device)
+        if attention_mask is not None:
+            attention_mask = attention_mask.to(device)
         
         # Generate response
         with torch.no_grad():
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            
             outputs = model.generate(
-                **inputs,
-                max_new_tokens=Config.MAX_NEW_TOKENS,
-                temperature=Config.TEMPERATURE,
-                top_p=Config.TOP_P,
+                input_ids,
+                max_new_tokens=200,
+                temperature=0.7,
                 do_sample=True,
-                pad_token_id=tokenizer.eos_token_id,
-                eos_token_id=tokenizer.eos_token_id
+                top_p=0.9,
+                pad_token_id=tokenizer.pad_token_id if tokenizer.pad_token_id else tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                attention_mask=attention_mask,
+                repetition_penalty=1.1
             )
         
-        # Decode response
-        full_response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        # Extract and clean response
+        if outputs.shape[1] > input_ids.shape[1]:
+            response_ids = outputs[0][input_ids.shape[1]:]
+            response = tokenizer.decode(response_ids, skip_special_tokens=True)
+        else:
+            response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+            response = response.replace(prompt, "").strip()
         
-        # Extract generated text (remove input prompt)
-        generated_text = full_response[len(user_input):].strip()
+        # Clean up response
+        response = response.strip()
         
-        # Format the output
-        formatted_output = "## 📊 Life Satisfaction Analysis\n\n"
-        formatted_output += generated_text
+        # Remove prompt artifacts
+        for artifact in ["[/INST]", "[INST]", "Assistant:", "User:", "Human:"]:
+            if artifact in response:
+                response = response.split(artifact)[-1].strip()
         
-        return formatted_output
+        # Remove input if it appears in response
+        if message.lower() in response.lower():
+            response = response.replace(message, "").strip()
+        
+        # Ensure reasonable length
+        if len(response) > 800:
+            response = response[:800] + "..."
+        
+        # Fallback if empty
+        if len(response.strip()) < 3:
+            response = "I understand. How can I help you?"
+            
+        return response
         
     except Exception as e:
-        return f"❌ Error during analysis: {str(e)}"
+        return f"Error: {str(e)}"
 
-# Example prompts for users
-EXAMPLE_PROMPTS = [
-    "I'm a 29-year-old professional feeling burned out at work. My health is okay but I rarely exercise. Financially stable but not saving much. Great relationship with my partner. What's my life satisfaction score?",
-    "Rate my life satisfaction: Work is stressful (3/10), health is good (7/10), finances are tight (4/10), relationships are excellent (9/10). Give me a comprehensive analysis.",
-    "Analyze my satisfaction: Career going well, making good money, but no time for friends or hobbies. Always tired and stressed. How can I improve?",
-    "I'm happy with my job and relationships but struggling with debt and health issues. Need advice on balancing everything.",
-    "Just graduated, starting my career, living paycheck to paycheck, single but happy, very healthy and active. Analyze my life satisfaction."
-]
+def clear_chat():
+    return ""
 
-# Gradio Interface
-def create_interface():
-    """Create the Gradio interface."""
+# Simple custom CSS
+css = """
+.gradio-container {
+    max-width: 700px !important;
+    margin: auto !important;
+}
+"""
+
+# Create interface
+with gr.Blocks(title="3AI - Text Generation", css=css, theme=gr.themes.Default()) as demo:
+    # Header
+    gr.Markdown("""
+    # 🤖 3AI Text Generator
+    *Simple text-to-text generation with your navidfalah/3ai model*
+    """)
     
-    with gr.Blocks(title="Life Satisfaction Analysis", theme=gr.themes.Soft()) as demo:
-        gr.Markdown(
-            """
-            # 🌟 AI Life Satisfaction Analyzer
-            
-            This AI-powered tool analyzes your life satisfaction based on your description of your current situation.
-            Simply describe your life circumstances, challenges, and satisfaction levels across different areas.
-            
-            **The AI will analyze:**
-            - Overall life satisfaction score
-            - Balance across life domains (work, health, finances, relationships)
-            - Personalized recommendations for improvement
-            - Action plans and strategies
-            """
-        )
-        
-        with gr.Row():
-            with gr.Column():
-                # Input section
-                input_text = gr.Textbox(
-                    label="📝 Describe Your Current Life Situation",
-                    placeholder="Tell me about your work, health, finances, relationships, and any other aspects of your life you'd like analyzed. You can include satisfaction ratings (1-10) or just describe how you feel about each area.",
-                    lines=8,
-                    max_lines=15
-                )
-                
-                with gr.Row():
-                    analyze_btn = gr.Button("🔍 Analyze My Life Satisfaction", variant="primary", scale=2)
-                    clear_btn = gr.Button("🗑️ Clear", scale=1)
-                
-                # Examples section
-                gr.Markdown("### 💡 Example Inputs")
-                example_dropdown = gr.Dropdown(
-                    choices=EXAMPLE_PROMPTS,
-                    label="Select an example to try:",
-                    interactive=True
-                )
-                
-        with gr.Row():
-            with gr.Column():
-                # Output section
-                output = gr.Markdown(label="Analysis Results")
-        
-        # Event handlers
-        analyze_btn.click(
-            fn=analyze_satisfaction,
-            inputs=input_text,
-            outputs=output
-        )
-        
-        clear_btn.click(
-            fn=lambda: ("", ""),
-            inputs=[],
-            outputs=[input_text, output]
+    # Input
+    with gr.Row():
+        input_text = gr.Textbox(
+            placeholder="Enter your text here...", 
+            label="Input Text",
+            lines=2,
+            max_lines=3
         )
-        
-        example_dropdown.change(
-            fn=lambda x: x,
-            inputs=example_dropdown,
-            outputs=input_text
-        )
-        
-        # Tips section
-        with gr.Accordion("📖 Tips for Best Results", open=False):
-            gr.Markdown(
-                """
-                **How to get the most accurate analysis:**
-                
-                1. **Be specific** about your situation in each life area
-                2. **Include ratings** (1-10) if you want quantified analysis
-                3. **Mention your age** and life stage for context
-                4. **Describe challenges** you're facing
-                5. **Share your goals** or what you'd like to improve
-                
-                **Example format:**
-                - Work: [Your situation and satisfaction level]
-                - Health: [Physical and mental wellness status]
-                - Finances: [Financial situation and concerns]
-                - Relationships: [Social and romantic relationships]
-                - Personal: [Hobbies, growth, fulfillment]
-                """
-            )
-        
-        # Footer
-        gr.Markdown(
-            """
-            ---
-            💡 **Disclaimer:** This AI tool provides general insights based on the information you provide. 
-            For professional advice, please consult qualified experts in relevant fields.
-            
-            🔒 **Privacy:** Your input is processed in real-time and not stored.
-            """
+    
+    # Generate button
+    with gr.Row():
+        generate_btn = gr.Button("Generate", variant="primary", size="lg")
+    
+    # Output
+    with gr.Row():
+        output_text = gr.Textbox(
+            label="Generated Text",
+            lines=6,
+            max_lines=10,
+            interactive=False,
+            placeholder="Generated text will appear here..."
         )
     
-    return demo
+    # Event handlers
+    generate_btn.click(
+        fn=chat_function,
+        inputs=input_text,
+        outputs=output_text
+    )
+    
+    input_text.submit(
+        fn=chat_function,
+        inputs=input_text,
+        outputs=output_text
+    )
+    
+    # Footer
+    gr.Markdown("---\n*navidfalah/3ai • Simple Text Generation*")
 
-# Launch the app
 if __name__ == "__main__":
-    # Load model on startup
-    print("🚀 Starting Life Satisfaction Analysis Tool...")
-    load_model()
-    
-    # Create and launch interface
-    demo = create_interface()
     demo.launch()