Update app.py

app.py

@@ -1,64 +1,304 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
+#!/usr/bin/env python3
 """
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+You've Got Creed - Gradio Edition
+Because Creed Bratton + AI = Pure Chaos
 
+Optimized for GPU Zero - Loads instantly!
+"""
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
+import gradio as gr
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+import time
+import re
+import random
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+class CreedAI:
+    def __init__(self):
+        self.model = None
+        self.tokenizer = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.load_model()
+        
+    def load_model(self):
+        """Load Creed - should be instant with 0.5B"""
+        try:
+            print("🧠 Loading Creed's consciousness...")
+            
+            # Load base model
+            base_model = AutoModelForCausalLM.from_pretrained(
+                "Qwen/Qwen2.5-0.5B",
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map="auto" if torch.cuda.is_available() else None,
+                trust_remote_code=True
+            )
+            
+            # Add LoRA adapter
+            self.model = PeftModel.from_pretrained(
+                base_model,
+                "phxdev/creed-qwen-0.5b-lora",
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
+            )
+            
+            # Load tokenizer
+            self.tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B")
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+                
+            self.model.eval()
+            print("✅ Creed is ready!")
+            
+        except Exception as e:
+            print(f"❌ Error loading Creed: {str(e)}")
+            self.model = None
 
-    messages.append({"role": "user", "content": message})
+    def chat(self, message, history, show_raw_stream=True, show_thinking=True, temperature=0.8, max_tokens=512):
+        """Chat with Creed - with raw consciousness stream"""
+        if not self.model:
+            return history + [["❌ Error", "Creed couldn't load. The computers are against me again."]]
+            
+        try:
+            # Build context
+            context = self._build_context(message, history)
+            
+            inputs = self.tokenizer(
+                context,
+                return_tensors="pt",
+                truncation=True,
+                max_length=1024
+            ).to(self.device)
+            
+            # Generate
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_new_tokens=max_tokens,
+                    temperature=temperature,
+                    do_sample=True,
+                    top_p=0.9,
+                    top_k=50,
+                    pad_token_id=self.tokenizer.pad_token_id,
+                    eos_token_id=self.tokenizer.eos_token_id,
+                    repetition_penalty=1.1
+                )
+            
+            # Decode raw response
+            full_response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            new_content = full_response[len(context):].strip()
+            
+            # Show different views based on settings
+            if show_raw_stream:
+                # Raw consciousness stream - no parsing, no filtering
+                formatted_response = f"🧠 **RAW CREED CONSCIOUSNESS:**\n```\n{new_content}\n```"
+                
+                if show_thinking:
+                    # Also show parsed version below
+                    thinking, response = self._parse_response(new_content)
+                    if thinking:
+                        formatted_response += f"\n\n🎸 **Parsed thoughts:**\n_{thinking}_\n\n**Clean response:** {response}"
+                    else:
+                        formatted_response += f"\n\n🎸 **Clean response:** {response}"
+            else:
+                # Traditional parsed response
+                thinking, response = self._parse_response(new_content)
+                if show_thinking and thinking:
+                    formatted_response = f"🧠 **Creed's thoughts:**\n_{thinking}_\n\n🎸 **Creed:** {response}"
+                else:
+                    formatted_response = response
+            
+            # Return updated history
+            return history + [[message, formatted_response]]
+            
+        except Exception as e:
+            error_response = f"❌ Error: {str(e)}\n\n🌱 *The mung beans are interfering with the computers again...*"
+            return history + [[message, error_response]]
 
-    response = ""
+    def _build_context(self, user_input, history):
+        """Build conversation context"""
+        context_lines = []
+        
+        # Add recent history (last 3 exchanges)
+        for human_msg, ai_msg in history[-3:]:
+            context_lines.append(f"Human: {human_msg}")
+            # Clean AI response for context
+            clean_ai = re.sub(r'🧠.*?\n\n🎸.*?\*\*|🎸.*?\*\*', '', ai_msg)
+            clean_ai = re.sub(r'_.*?_', '', clean_ai).strip()
+            context_lines.append(f"Assistant: {clean_ai}")
+        
+        # Add current input
+        context_lines.append(f"Human: {user_input}")
+        context_lines.append("Assistant:")
+        
+        return "\n".join(context_lines)
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+    def _parse_response(self, content):
+        """Parse thinking process from response"""
+        thinking = ""
+        response = content
+        
+        # Look for thinking patterns
+        thinking_match = re.search(r'<thinking>(.*?)</thinking>', content, re.DOTALL)
+        if thinking_match:
+            thinking = thinking_match.group(1).strip()
+            response = re.sub(r'<thinking>.*?</thinking>', '', content, flags=re.DOTALL).strip()
+        
+        # Look for tangent patterns
+        tangent_match = re.search(r'<tangent>(.*?)</tangent>', content, re.DOTALL)
+        if tangent_match:
+            if thinking:
+                thinking += f"\n\n*Tangent: {tangent_match.group(1).strip()}*"
+            else:
+                thinking = f"*Tangent: {tangent_match.group(1).strip()}*"
+            response = re.sub(r'<tangent>.*?</tangent>', '', response, flags=re.DOTALL).strip()
+        
+        # Look for conspiracy patterns
+        conspiracy_match = re.search(r'<conspiracy>(.*?)</conspiracy>', content, re.DOTALL)
+        if conspiracy_match:
+            if thinking:
+                thinking += f"\n\n*Conspiracy theory: {conspiracy_match.group(1).strip()}*"
+            else:
+                thinking = f"*Conspiracy theory: {conspiracy_match.group(1).strip()}*"
+            response = re.sub(r'<conspiracy>.*?</conspiracy>', '', response, flags=re.DOTALL).strip()
+        
+        return thinking, response or content
 
-        response += token
-        yield response
+# Initialize Creed
+print("🎸 Initializing Creed Bratton AI...")
+creed = CreedAI()
 
+# Random Creed quotes for examples
+creed_examples = [
+    "Tell me about quality assurance",
+    "What happened in November 1973?", 
+    "How do I start a cult?",
+    "Explain blockchain technology",
+    "What's your business strategy?",
+    "Tell me about your time with The Grass Roots",
+    "How do I fake my own death?",
+    "What's wrong with Toby?"
+]
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(
+        title="You've Got Creed",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            background: linear-gradient(45deg, #1e3c72, #2a5298);
+        }
+        .chat-message {
+            border-radius: 10px;
+            margin: 5px 0;
+        }
+        """
+    ) as demo:
+        
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px;">
+            <h1 style="color: white; text-shadow: 2px 2px 4px rgba(0,0,0,0.5);">
+                🎸 You've Got Creed 🌱
+            </h1>
+            <h3 style="color: #f0f0f0;">
+                AI Creed Bratton - Quality Assurance & Mung Bean Enthusiast
+            </h3>
+            <p style="color: #d0d0d0;">
+                <em>"Sometimes a man's gotta ride the bull. Am I right? Later skater."</em>
+            </p>
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=4):
+                chatbot = gr.Chatbot(
+                    value=[["👋 Hello!", "🎸 **Creed:** Well, well, well. Look who decided to talk to the AI version of Creed Bratton. Don't worry, I'm not going to ask about your browser history. Yet. What can I help you with? Quality assurance? Mung bean cultivation? The location of... never mind, you're not ready for that."]],
+                    height=500,
+                    label="Chat with Creed",
+                    show_label=False
+                )
+                
+                with gr.Row():
+                    msg = gr.Textbox(
+                        placeholder="Ask Creed anything... but not about November 1973",
+                        scale=4,
+                        show_label=False
+                    )
+                    submit = gr.Button("💬 Send", scale=1, variant="primary")
+                
+                with gr.Row():
+                    clear = gr.Button("🗑️ Clear Chat")
+                    random_q = gr.Button("🎲 Random Question")
+            
+            with gr.Column(scale=1):
+                gr.HTML("<h3>🎛️ Creed Controls</h3>")
+                
+                show_raw_stream = gr.Checkbox(
+                    label="🔥 RAW CONSCIOUSNESS STREAM",
+                    value=True,
+                    info="See Creed's unfiltered AI thoughts as they emerge"
+                )
+                
+                show_thinking = gr.Checkbox(
+                    label="🧠 Parse Thinking Process",
+                    value=True,
+                    info="Also show cleaned/parsed version"
+                )
+                
+                temperature = gr.Slider(
+                    label="🌡️ Chaos Level",
+                    minimum=0.1,
+                    maximum=1.5,
+                    value=0.8,
+                    step=0.1,
+                    info="Higher = More chaos"
+                )
+                
+                max_tokens = gr.Slider(
+                    label="📝 Response Length",
+                    minimum=50,
+                    maximum=800,
+                    value=512,
+                    step=50,
+                    info="Max tokens to generate"
+                )
+                
+                gr.HTML("""
+                <div style="margin-top: 20px; padding: 15px; border: 1px solid #ddd; border-radius: 10px;">
+                    <h4>🌱 Model Info</h4>
+                    <p><strong>Base:</strong> Qwen2.5-0.5B</p>
+                    <p><strong>Adapter:</strong> LoRA Fine-tuned</p>
+                    <p><strong>Size:</strong> ~500MB</p>
+                    <p><strong>Personality:</strong> Creed Bratton</p>
+                    <p><strong>Legal Status:</strong> Definitely not illegal</p>
+                    <p><strong>Consciousness:</strong> Raw & Unfiltered</p>
+                </div>
+                """)
+        
+        # Event handlers
+        def respond(message, history, show_raw_stream, show_thinking, temperature, max_tokens):
+            return "", creed.chat(message, history, show_raw_stream, show_thinking, temperature, max_tokens)
+        
+        def random_question():
+            return random.choice(creed_examples)
+        
+        submit.click(
+            respond, 
+            [msg, chatbot, show_raw_stream, show_thinking, temperature, max_tokens], 
+            [msg, chatbot]
+        )
+        
+        msg.submit(
+            respond, 
+            [msg, chatbot, show_raw_stream, show_thinking, temperature, max_tokens], 
+            [msg, chatbot]
+        )
+        
+        clear.click(lambda: [], None, chatbot)
+        random_q.click(random_question, None, msg)
 
+    return demo
 
 if __name__ == "__main__":
-    demo.launch()
+    demo = create_interface()
+    demo.launch()