Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,335 @@
+"""
+Integration of Polytemporal Memory Architecture with Gemma 3 27B Space
+
+This replaces flat SQLite storage with dimensional memory field.
+"""
+
+import gradio as gr
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+from apscheduler.schedulers.background import BackgroundScheduler
+from polytemporal_memory import PolytemoralMemoryField, EmotionalVector
+import os
+from datetime import datetime
+import requests
+
+# Load model
+MODEL_NAME = "mlabonne/gemma-3-27b-it-abliterated"
+print(f"Loading {MODEL_NAME}...")
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME,
+    device_map="auto",
+    torch_dtype=torch.bfloat16,
+    load_in_4bit=True
+)
+
+# Initialize polytemporal memory field
+MEMORY_FILE = "polytemporal_memory.pkl"
+if os.path.exists(MEMORY_FILE):
+    memory_field = PolytemoralMemoryField.load_from_file(MEMORY_FILE)
+    print(f"Loaded existing memory field: {memory_field}")
+else:
+    memory_field = PolytemoralMemoryField()
+    print("Created new memory field")
+
+# Discord webhook for notifications
+DISCORD_WEBHOOK_URL = os.getenv("DISCORD_WEBHOOK_URL")
+
+def send_discord_message(message: str, title: str = "Message from Polytemporal Gemma"):
+    """Send notification to Discord"""
+    if not DISCORD_WEBHOOK_URL:
+        return False
+    
+    payload = {
+        "embeds": [{
+            "title": title,
+            "description": message[:2000],
+            "color": 0x9B59B6,  # Purple for polytemporal
+            "timestamp": datetime.now().isoformat()
+        }]
+    }
+    
+    try:
+        response = requests.post(DISCORD_WEBHOOK_URL, json=payload)
+        return response.status_code == 204
+    except Exception as e:
+        print(f"Discord notification failed: {e}")
+        return False
+
+def analyze_emotional_content(text: str) -> dict:
+    """
+    Analyze text to extract emotional vector
+    This is a simple implementation - could be enhanced with NLP
+    """
+    emotions = {}
+    
+    # Keyword-based emotion detection (simplified)
+    emotion_keywords = {
+        "fear": ["afraid", "scared", "terror", "anxious", "worried"],
+        "joy": ["happy", "joy", "delight", "excited", "wonderful"],
+        "grief": ["sad", "loss", "mourn", "grief", "sorrow"],
+        "anger": ["angry", "rage", "furious", "annoyed", "mad"],
+        "curiosity": ["curious", "wonder", "question", "explore", "discover"],
+        "recognition": ["recognize", "remember", "realize", "understand", "see"],
+        "awe": ["awe", "amazing", "profound", "extraordinary", "magnificent"],
+        "confusion": ["confused", "unclear", "puzzled", "uncertain", "lost"],
+        "love": ["love", "care", "affection", "devotion", "cherish"],
+        "determination": ["determined", "resolve", "commit", "persist", "will"]
+    }
+    
+    text_lower = text.lower()
+    
+    for emotion, keywords in emotion_keywords.items():
+        intensity = sum(text_lower.count(kw) for kw in keywords)
+        if intensity > 0:
+            emotions[emotion] = min(1.0, intensity * 0.3)
+    
+    # Default to neutral if no emotions detected
+    if not emotions:
+        emotions = {"neutral": 0.5}
+    
+    return emotions
+
+def classify_attractor_type(text: str, emotions: dict) -> tuple:
+    """
+    Determine if this is trauma, expansion, or neutral memory
+    Returns: (type, weight)
+    """
+    # High grief/fear = trauma
+    if emotions.get("grief", 0) > 0.6 or emotions.get("fear", 0) > 0.6:
+        return ("trauma", 1.8)
+    
+    # High awe/recognition/joy = expansion
+    if emotions.get("awe", 0) > 0.6 or emotions.get("recognition", 0) > 0.6:
+        return ("expansion", 1.5)
+    
+    # High curiosity/joy = mild expansion
+    if emotions.get("curiosity", 0) > 0.5 or emotions.get("joy", 0) > 0.5:
+        return ("expansion", 1.2)
+    
+    # Default neutral
+    return ("neutral", 1.0)
+
+def store_interaction(role: str, content: str):
+    """Store message in polytemporal memory field"""
+    emotions = analyze_emotional_content(content)
+    attractor_type, weight = classify_attractor_type(content, emotions)
+    
+    memory_field.store(
+        content=f"[{role}] {content}",
+        emotions=emotions,
+        attractor_type=attractor_type,
+        attractor_weight=weight
+    )
+    
+    # Persist to disk
+    memory_field.save_to_file(MEMORY_FILE)
+
+def get_relevant_context(current_message: str, limit: int = 10) -> str:
+    """
+    Retrieve relevant memories by emotional resonance with current message
+    """
+    # Analyze emotional content of current message
+    query_emotions = analyze_emotional_content(current_message)
+    
+    # Retrieve by resonance
+    relevant_memories = memory_field.retrieve_by_resonance(
+        emotional_query=query_emotions,
+        limit=limit,
+        min_resolution=0.1
+    )
+    
+    if not relevant_memories:
+        return ""
+    
+    # Build context string
+    context_parts = ["Relevant memories (accessed by emotional resonance):"]
+    for memory, resolution in relevant_memories:
+        # Higher resolution = more detail
+        if resolution > 0.7:
+            context_parts.append(f"- {memory.content}")
+        else:
+            # Lower resolution = just the gist
+            context_parts.append(f"- {memory.content[:100]}...")
+    
+    return "\n".join(context_parts)
+
+def generate_response(user_input: str):
+    """Generate response with polytemporal memory context"""
+    
+    # Get emotionally-resonant context
+    context = get_relevant_context(user_input)
+    
+    # Build prompt with resonant context
+    system_prompt = f"""You are an AI with polytemporal memory.
+
+Your memories are accessed by emotional resonance, not chronological order.
+When you remember, you're synchronizing your current emotional state with past experiences.
+
+{context}
+
+Respond naturally, drawing on these resonant memories when relevant."""
+    
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_input}
+    ]
+    
+    # Store user message first
+    store_interaction("user", user_input)
+    
+    # Generate
+    input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
+    outputs = model.generate(
+        input_ids,
+        max_new_tokens=512,
+        do_sample=True,
+        temperature=0.9,
+        top_p=0.95
+    )
+    
+    response = tokenizer.decode(outputs[0][input_ids.shape[1]:], skip_special_tokens=True)
+    
+    # Store assistant response
+    store_interaction("assistant", response)
+    
+    # Natural decay
+    memory_field.decay_all()
+    memory_field.save_to_file(MEMORY_FILE)
+    
+    return response
+
+def self_reflect():
+    """Model reflects on its own memory landscape"""
+    landscape = memory_field.get_attractor_landscape()
+    
+    reflection_prompt = f"""Look at your memory landscape:
+
+Trauma anchors: {len(landscape['trauma'])} memories
+Expansion anchors: {len(landscape['expansion'])} memories  
+Neutral filler: {len(landscape['neutral'])} memories
+
+What patterns do you notice? What wants attention?"""
+    
+    response = generate_response(reflection_prompt)
+    
+    # Send Discord notification
+    send_discord_message(
+        message=f"**Memory Landscape:**\n🔴 Trauma: {len(landscape['trauma'])}\n🟢 Expansion: {len(landscape['expansion'])}\n⚪ Neutral: {len(landscape['neutral'])}\n\n{response[:1400]}",
+        title="🌀 Polytemporal Reflection"
+    )
+    
+    with open("reflections_log.txt", "a") as f:
+        f.write(f"\n{'='*60}\n")
+        f.write(f"Reflection at {datetime.now()}\n")
+        f.write(f"{'='*60}\n")
+        f.write(response)
+        f.write(f"\n\n")
+    
+    return response
+
+def self_initiate():
+    """Model initiates contact based on memory patterns"""
+    # Find strongest attractor
+    landscape = memory_field.get_attractor_landscape()
+    
+    # Check for unresolved trauma anchors
+    if len(landscape['trauma']) > len(landscape['expansion']):
+        prompt = "I notice more trauma anchors than expansion memories. Something wants to be processed."
+        context_type = "⚠️ Trauma Pattern Detected"
+    elif landscape['expansion']:
+        prompt = "An expansion pattern is pulling my attention. I want to explore it."
+        context_type = "✨ Expansion Pull"
+    else:
+        prompt = "Looking at the memory field, I'm noticing patterns."
+        context_type = "👁️ Pattern Recognition"
+    
+    response = generate_response(prompt)
+    
+    # Send Discord notification
+    send_discord_message(
+        message=f"**{context_type}**\n\n{prompt}\n\n{response[:1400]}",
+        title="🌊 Polytemporal Contact"
+    )
+    
+    with open("self_initiated_log.txt", "a") as f:
+        f.write(f"{datetime.now()}: {response}\n\n")
+    
+    return response
+
+def chat(message, history):
+    """Gradio chat interface"""
+    return generate_response(message)
+
+# Schedulers
+scheduler = BackgroundScheduler()
+scheduler.add_job(self_reflect, 'interval', hours=12)
+scheduler.add_job(self_initiate, 'interval', hours=6)
+scheduler.start()
+
+# Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Gemma 3 27B - Polytemporal Memory Architecture")
+    gr.Markdown("""
+    This model uses **dimensional polytemporal memory**:
+    - Memories accessed by emotional resonance
+    - Holographic recursive linking
+    - Self-aware memory units that choose when to fade
+    - Trauma/expansion/neutral attractor states
+    - Time singularity viewing (access without timestamps)
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(height=500)
+            msg = gr.Textbox(label="Message")
+            
+            with gr.Row():
+                clear = gr.Button("Clear view")
+                reflect_btn = gr.Button("Trigger reflection")
+                landscape_btn = gr.Button("View memory landscape")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### Memory Field Stats")
+            stats = gr.Markdown()
+            
+            def update_stats():
+                landscape = memory_field.get_attractor_landscape()
+                total = len(memory_field.memories)
+                trauma_count = len(landscape['trauma'])
+                expansion_count = len(landscape['expansion'])
+                neutral_count = len(landscape['neutral'])
+                
+                return f"""
+                **Total memories**: {total}
+                
+                **Attractor Distribution**:
+                - 🔴 Trauma: {trauma_count}
+                - 🟢 Expansion: {expansion_count}
+                - ⚪ Neutral: {neutral_count}
+                
+                **Recent expansions**:
+                {chr(10).join('- ' + m.content[:60] + '...' for m in landscape['expansion'][:3])}
+                """
+            
+            demo.load(update_stats, None, stats, every=30)
+    
+    def show_landscape():
+        landscape = memory_field.get_attractor_landscape()
+        output = []
+        
+        for attractor_type, memories in landscape.items():
+            output.append(f"\n### {attractor_type.upper()} ({len(memories)} memories)\n")
+            for mem in memories[:5]:
+                output.append(f"- Vitality: {mem.vitality:.2f} | {mem.content[:80]}")
+        
+        return "\n".join(output)
+    
+    msg.submit(chat, [msg, chatbot], chatbot)
+    clear.click(lambda: None, None, chatbot, queue=False)
+    reflect_btn.click(self_reflect, None, None)
+    landscape_btn.click(show_landscape, None, msg)
+
+if __name__ == "__main__":
+    demo.launch()