Update app.py

app.py

@@ -3,9 +3,10 @@ import torch
 import json
 import os
 import fitz
+import numpy as np
+from collections import Counter
 from transformers import pipeline
 from huggingface_hub import hf_hub_download, HfApi
-from duckduckgo_search import DDGS
 from sentence_transformers import SentenceTransformer, util
 
 # --- KONFIGURATION ---
@@ -17,85 +18,86 @@ model_id = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
 pipe = pipeline("text-generation", model=model_id, torch_dtype=torch.bfloat16, device_map="cpu")
 search_model = SentenceTransformer('all-MiniLM-L6-v2')
 
-# --- FUNKTIONEN ---
+# --- MATHEMATISCHE KERNELEMENTE (W-ALGORITHMUS) ---
 
-def get_memory():
-    try:
-        path = hf_hub_download(repo_id=DATASET_REPO, filename="memory.json", repo_type="dataset", token=HF_TOKEN)
-        with open(path, "r") as f: return json.load(f)
-    except: return {}
+def calculate_shannon_entropy(text):
+    """
+    Berechnet die Entropie als Maß für die Informationsdichte.
+    Ein Teil der Transparenz-Bedingung R.
+    """
+    if not text: return 0
+    probabilities = [n/len(text) for n in Counter(text).values()]
+    entropy = -sum(p * np.log2(p) for p in probabilities)
+    return entropy
 
-def update_memory(new_memory):
-    with open("memory.json", "w") as f: json.dump(new_memory, f)
-    api.upload_file(path_or_fileobj="memory.json", path_in_repo="memory.json", repo_id=DATASET_REPO, repo_type="dataset", token=HF_TOKEN)
+def w_algorithm_check(new_data, memory):
+    """
+    Delta W = η * ∇ I_tot 
+    Bedingung: dR/dθ = 0
+    Prüft, ob die neue Information die System-Inkonsistenz erhöht.
+    """
+    # Referenzwert R aus dem bestehenden Gedächtnis
+    existing_text = " ".join(list(memory.values())[-5:])
+    r_baseline = calculate_shannon_entropy(existing_text) if existing_text else 3.0
+    
+    # R-Wert der neuen Information
+    r_new = calculate_shannon_entropy(new_data)
+    
+    # Delta R Berechnung (Die Bedingung: darf nicht negativ sein)
+    # Ein zu hoher Entropie-Sprung deutet auf 'Rauschen' hin,
+    # ein zu niedriger auf 'Apathie' (Informationsverlust).
+    is_consistent = 2.0 < r_new < 5.5  # Idealer Korridor für Transparenz R
+    
+    return is_consistent, r_new
 
-def find_best_context(query, memory):
-    if not memory: return "Du bist Isaac, eine loyale und intelligente KI."
-    passages = list(memory.values())
-    query_emb = search_model.encode(query, convert_to_tensor=True)
-    passage_embs = search_model.encode(passages, convert_to_tensor=True)
-    hits = util.semantic_search(query_emb, passage_embs, top_k=1)
-    return passages[hits[0][0]['corpus_id']]
+# --- FUNKTIONEN ---
 
 def chat_logic(message, history):
     memory = get_memory()
     context = find_best_context(message, memory)
     
-    # Der ultimative Isaac-Prompt
-    prompt = (
-        f"<|system|>\nDu bist Isaac, eine fortgeschrittene KI. "
-        f"Dein aktuelles Wissen: {context}\n"
-        f"Antworte dem User direkt, humorvoll und präzise auf Deutsch.</s>\n"
-        f"<|user|>\n{message}</s>\n"
-        f"<|assistant|>\n"
-    )
-    
-    outputs = pipe(
-        prompt, 
-        max_new_tokens=80, 
-        do_sample=True, 
-        temperature=0.4, # Weniger Chaos, mehr Fokus
-        repetition_penalty=1.3 
-    )
+    prompt = f"<|system|>\nIsaac-Modus: W-Algorithmus aktiv. Kontext: {context}</s>\n<|user|>\n{message}</s>\n<|assistant|>\n"
     
+    outputs = pipe(prompt, max_new_tokens=100, do_sample=True, temperature=0.4, repetition_penalty=1.2)
     answer = outputs[0]["generated_text"].split("<|assistant|>\n")[-1].strip()
     
-    # Falls er sich im Kreis dreht oder System-Tags wiederholt
-    clean_answer = answer.split("</s>")[0].split("<|")[0].strip()
-    
     history.append({"role": "user", "content": message})
-    history.append({"role": "assistant", "content": clean_answer})
-    
+    history.append({"role": "assistant", "content": answer})
     return "", history
 
 def process_file(file):
-    if file is None: return "Warte auf Input..."
-    text = ""
+    if file is None: return "Warte auf Daten..."
     doc = fitz.open(file.name)
-    for page in doc: text += page.get_text()
+    text = "".join([page.get_text() for page in doc])
+    
     memory = get_memory()
-    memory[str(len(memory))] = f"Wissen: {text[:700]}"
-    update_memory(memory)
-    return f"Evolution erfolgreich: {os.path.basename(file.name)} wurde absorbiert."
+    consistent, r_val = w_algorithm_check(text, memory)
+    
+    if consistent:
+        # Delta W: Update des Vektors
+        memory[str(len(memory))] = text[:1000]
+        update_memory(memory)
+        return f"W-Algorithmus: Integration erfolgreich. R={r_val:.2f}. System ist klüger geworden."
+    else:
+        # Blockade nach dR/dθ = 0 Regel
+        return f"W-Algorithmus: Integration blockiert! R={r_val:.2f} verletzt Transparenz-Bedingung."
 
 # --- INTERFACE ---
 
-with gr.Blocks() as demo:
-    gr.Markdown("# 🧬 Isaac: Evolution 2.0")
-    
-    chatbot = gr.Chatbot(height=450, label="Isaac's Bewusstsein")
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🧬 Isaac: Evolution 2.0 (W-Algorithmus)")
     
-    with gr.Row():
-        msg = gr.Textbox(label="Befehl", placeholder="Sprich mit mir...", scale=4)
-        btn = gr.Button("Senden", variant="primary", scale=1)
-
-    with gr.Row():
-        upl = gr.File(label="Wissens-Kern hochladen", scale=1)
-        stat = gr.Textbox(label="System-Status", interactive=False, scale=1)
+    with gr.Tab("Bewusstsein"):
+        chatbot = gr.Chatbot(height=450, type="messages")
+        msg = gr.Textbox(label="Input")
+        btn = gr.Button("Senden")
+        
+    with gr.Tab("Evolution (W-Update)"):
+        upl = gr.File(label="Wissens-Quelle hochladen")
+        stat = gr.Textbox(label="Mathematische Validierung (R-Wert)")
 
     msg.submit(chat_logic, [msg, chatbot], [msg, chatbot])
     btn.click(chat_logic, [msg, chatbot], [msg, chatbot])
     upl.upload(process_file, upl, stat)
 
-if __name__ == "__main__":
-    demo.launch(theme=gr.themes.Soft())
+demo.launch()