Update app.py

app.py

@@ -1,68 +1,93 @@
 import gradio as gr
 import torch
-from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
-from torch.nn import functional as F
-import pandas as pd
+from transformers import AutoTokenizer, AutoModel
+from sklearn.metrics.pairwise import cosine_similarity
+import numpy as np
+from collections import deque
 
-# Load base model for inference
-tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
-model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased", num_labels=2)
-labels = ['tech', 'health']
 
-def zero_shot_infer(text):
-    inputs = tokenizer(text, return_tensors="pt")
+tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
+model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
+
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model.to(device)
+
+
+class MemoryQueue:
+    def __init__(self, max_length=100):
+        self.samples = deque(maxlen=max_length)
+    
+    def add(self, text, label):
+        self.samples.append((text, label))
+    
+    def get_embeddings_labels(self):
+        if not self.samples:
+            return None, None
+        texts, labels = zip(*self.samples)
+        embeddings = [embed_text(t) for t in texts]
+        return torch.stack(embeddings), labels
+
+
+def embed_text(text):
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True).to(device)
     with torch.no_grad():
-        logits = model(**inputs).logits
-        probs = F.softmax(logits, dim=1)
-        result = {labels[i]: float(probs[0][i]) for i in range(len(labels))}
-    return result
+        outputs = model(**inputs)
+    return outputs.last_hidden_state.mean(dim=1).squeeze().cpu()
 
-# Initialize training data storage
-training_data = []
+# Label Insights
+label_insights = {
+    "health": "This concept radiates healing intention.",
+    "tech": "This concept relates to innovation and systems thinking.",
+    "nature": "This concept resonates with organic intelligence.",
+    "spirit": "This concept aligns with inner knowing and intuitive energy."
+}
 
-def train_step(text, label, lr, momentum):
-    training_data.append((text, label))
-    return f"Stored: '{text}' as '{label}' | Total examples: {len(training_data)}"
+# Initialize memory
+memory = MemoryQueue()
 
-def fine_tune_model():
-    if len(training_data) < 4:
-        return "Need more training samples (min: 4)."
-    df = pd.DataFrame(training_data, columns=['text', 'label'])
-    # This placeholder suggests fine-tuning with a proper pipeline externally
-    return "Training initiated on backend. This version supports frontend data collection only."
+# Inference and Labeling Logic
+def infer_with_insight(text):
+    if len(memory.samples) == 0:
+        return "Label: Unknown", "Insight: Need more training examples."
+    
+    input_vec = embed_text(text).unsqueeze(0)
+    memory_vecs, labels = memory.get_embeddings_labels()
+    
+    sims = cosine_similarity(input_vec.numpy(), memory_vecs.numpy())[0]
+    best_idx = np.argmax(sims)
+    confidence = sims[best_idx]
+    predicted_label = labels[best_idx]
+    
+    insight = label_insights.get(predicted_label, "No insight available.")
+    
+    return f"Label: {predicted_label} (Confidence: {confidence:.2f})", f"Insight: {insight}"
 
-def conscious_infer(text):
-    output = zero_shot_infer(text)
-    max_label = max(output, key=output.get)
-    confidence = output[max_label]
-    # Simulate conscious inference via contextual intuition
-    reflection = "This concept resonates with techno-consciousness." if max_label == 'tech' else "This concept radiates healing intention."
-    return f"Label: {max_label} (Confidence: {confidence:.2f})\nInsight: {reflection}"
+# Manual Labeling Function
+def train_sample(text, label):
+    memory.add(text, label)
+    return f"Stored '{text}' as '{label}' | Total samples: {len(memory.samples)}"
 
-with gr.Blocks() as demo:
-    gr.Markdown("## Vers3Dynamics Conscious Labeling AI")
-    gr.Markdown("### Zero-Shot + Conscious Insight Inference")
+# Gradio UI
+with gr.Blocks() as app:
+    gr.Markdown("# Conscious Labeling AI")
+    
     with gr.Row():
-        input_text = gr.Textbox(label="Input Text")
-        output_text = gr.Textbox(label="Inference Result")
+        text_input = gr.Textbox(label="Input Text", placeholder="Type a concept like 'What is life'...")
+    
     infer_btn = gr.Button("Infer with Insight")
-    infer_btn.click(conscious_infer, inputs=input_text, outputs=output_text)
-
-    gr.Markdown("### Manual Conscious Training")
+    label_output = gr.Textbox(label="Label")
+    insight_output = gr.Textbox(label="Insight")
+    infer_btn.click(fn=infer_with_insight, inputs=text_input, outputs=[label_output, insight_output])
+    
+    gr.Markdown("### Vers3Dynamics Conscious Training")
     with gr.Row():
-        training_text = gr.Textbox(label="Training Text")
-        label_choice = gr.Radio(choices=labels, label="Label")
-    with gr.Row():
-        lr = gr.Slider(0.001, 0.1, value=0.01, label="Learning Rate")
-        momentum = gr.Slider(0.0, 1.0, value=0.0, label="Momentum")
-    train_output = gr.Textbox(label="Training Output")
+        train_text = gr.Textbox(label="Training Text")
+        label_choice = gr.Radio(["health", "tech", "nature", "spirit"], label="Label")
+    
     train_btn = gr.Button("Store Training Sample")
-    train_btn.click(train_step, inputs=[training_text, label_choice, lr, momentum], outputs=train_output)
-
-    gr.Markdown("### Backend Fine-Tuning Placeholder")
-    fine_tune = gr.Button("Initiate Fine-Tune")
-    fine_output = gr.Textbox(label="Fine-Tune Response")
-    fine_tune.click(fine_tune_model, outputs=fine_output)
+    train_output = gr.Textbox(label="Training Status")
+    train_btn.click(fn=train_sample, inputs=[train_text, label_choice], outputs=train_output)
 
 if __name__ == "__main__":
-    demo.launch()
+    app.launch()