Update app.py

app.py

@@ -5,290 +5,141 @@ matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 from sklearn.metrics.pairwise import cosine_similarity
 from sentence_transformers import SentenceTransformer
+from sklearn.decomposition import PCA
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 
-# Load model
+# مدل زبانی برای تحلیل معنایی جملات
 model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
 
-# Psychological analysis function
-def psychological_analysis(text):
-    rules = [
-        {
-            "keywords": ["guilt", "remorse"],
-            "aspect": "Moral guilt",
-            "followed": "Helps in personal growth, emotional release, and reconciliation.",
-            "ignored": "Can lead to chronic anxiety, regret, or depression."
-        },
-        {
-            "keywords": ["freedom", "free will"],
-            "aspect": "Freedom & Will",
-            "followed": "Encourages autonomy and a sense of responsibility.",
-            "ignored": "May result in feelings of helplessness or existential crisis."
-        },
-        {
-            "keywords": ["altruism", "help", "others"],
-            "aspect": "Altruism",
-            "followed": "Improves social bonding and personal satisfaction.",
-            "ignored": "May cause loneliness or self-centered thinking."
-        },
-        {
-            "keywords": ["anxiety", "fear"],
-            "aspect": "Anxiety & Fear",
-            "followed": "Leads to caution and preparedness.",
-            "ignored": "Might cause mental blocks, phobia, or stress disorders."
-        },
-        {
-            "keywords": ["reason", "logic"],
-            "aspect": "Rationality",
-            "followed": "Supports wise decision-making and clarity.",
-            "ignored": "Can result in poor judgments and emotional impulses."
-        }
+# داده‌های مربوط به مکاتب فلسفی
+school_data = {
+    "Stoicism": [
+        "The key to happiness is accepting things we cannot control.",
+        "Virtue is the only good.",
+        "Live according to nature."
+    ],
+    "Existentialism": [
+        "Existence precedes essence.",
+        "Man is nothing else but what he makes of himself.",
+        "Life has no inherent meaning; we create our own meaning."
+    ],
+    "Rationalism": [
+        "Reason is the chief source of knowledge.",
+        "I think, therefore I am.",
+        "Innate ideas exist prior to experience."
+    ],
+    "Empiricism": [
+        "Knowledge comes only from sensory experience.",
+        "The mind is a blank slate at birth.",
+        "All ideas originate in experience."
     ]
-
-    results = []
-    lower_text = text.lower()
-
-    for rule in rules:
-        if any(keyword in lower_text for keyword in rule["keywords"]):
-            results.append({
-                "aspect": rule["aspect"],
-                "followed": rule["followed"],
-                "ignored": rule["ignored"]
-            })
-
-    return results
-
-# Dummy: Semantic Plot
-def create_semantic_plot(user_vec, best_match):
-    fig, ax = plt.subplots()
-    ax.set_title(f"Semantic Positioning: {best_match}")
-    ax.scatter(user_vec[0][0], user_vec[0][1], color='blue')
-    ax.text(user_vec[0][0], user_vec[0][1], f"{best_match}", fontsize=12)
-    ax.set_xlim(-1, 1)
-    ax.set_ylim(-1, 1)
-    ax.grid(True)
-    return fig
-
-# Dummy: Conceptual Graph
-def generate_concept_graph():
-    fig, ax = plt.subplots()
-    ax.set_title("Conceptual Map (Placeholder)")
-    ax.text(0.5, 0.5, "Key concepts will be mapped here.", ha='center', va='center', fontsize=12)
-    ax.axis('off')
-    return fig
-
-# Smarter Reflection Response
-def philosophical_response(text, school=None):
-    if school == "Existentialism":
-        return f"Your sentence reflects existential freedom, perhaps inviting thought on authenticity and the burden of choice."
-    elif school == "Stoicism":
-        return f"This seems to align with Stoic resilience and inner control, possibly invoking the dichotomy of control."
-    return f"This sentence echoes a philosophical sentiment. Possibly about meaning, freedom, or virtue: \"{text}\""
-
-# Knowledge Base
-KNOWLEDGE_BASE = {
-    "Existentialism": {
-        "icon": "🌌",
-        "color": "#4E79A7",
-        "philosophers": ["Jean-Paul Sartre", "Albert Camus", "Friedrich Nietzsche"],
-        "texts": [
-            "Existence precedes essence",
-            "Man is condemned to be free",
-            "What does not kill me makes me stronger"
-        ],
-        "timeline": [1943, 1942, 1889],
-        "psychology": {
-            "positive": ["Deep self-awareness", "Radical responsibility", "Authenticity"],
-            "negative": ["Existential anxiety", "Meaning crisis", "Freedom overwhelm"],
-            "solution": ["Logotherapy", "Existential group therapy", "Creative expression"]
-        },
-        "key_concepts": ["Freedom", "Authenticity", "Absurd", "Angst"]
-    },
-    "Stoicism": {
-        "icon": "🪨",
-        "color": "#59A14F",
-        "philosophers": ["Marcus Aurelius", "Epictetus", "Seneca"],
-        "texts": [
-            "The obstacle is the way",
-            "You have power over your mind—not outside events",
-            "We suffer more in imagination than in reality"
-        ],
-        "timeline": [180, 135, 65],
-        "psychology": {
-            "positive": ["Inner peace", "Resilience", "Emotional control"],
-            "negative": ["Emotional suppression", "Detachment", "Fatalism"],
-            "solution": ["Cognitive therapy", "Mindfulness meditation", "Negative visualization"]
-        },
-        "key_concepts": ["Virtue", "Dichotomy of Control", "Amor Fati", "Memento Mori"]
-    }
 }
 
-# Precompute vectors
-for school in KNOWLEDGE_BASE:
-    try:
-        texts = KNOWLEDGE_BASE[school]["texts"]
-        KNOWLEDGE_BASE[school]["vectors"] = np.array(model.encode(texts))
-    except:
-        KNOWLEDGE_BASE[school]["vectors"] = np.random.rand(len(texts), 384)
-
-# Timeline generator
-def generate_timeline():
-    try:
-        fig = make_subplots(rows=1, cols=1)
-        entries = []
-        for school, data in KNOWLEDGE_BASE.items():
-            for name, year in zip(data["philosophers"], data["timeline"]):
-                entries.append({
-                    "year": year,
-                    "name": name,
-                    "school": school,
-                    "color": data["color"],
-                    "icon": data["icon"]
-                })
-        entries.sort(key=lambda x: x["year"])
-        for entry in entries:
-            fig.add_trace(go.Scatter(
-                x=[entry["year"]],
-                y=[0],
-                mode="markers+text",
-                marker=dict(size=20, color=entry["color"]),
-                name=f"{entry['icon']} {entry['name']}",
-                text=f"{entry['icon']} {entry['name']}",
-                hoverinfo="text",
-                hovertext=f"<b>{entry['name']}</b><br>{entry['school']}<br>{entry['year']} CE",
-                textposition="top center"
-            ))
-        fig.update_layout(
-            title="🕰️ Philosophical Timeline",
-            xaxis_title="Year",
-            showlegend=False,
-            height=300,
-            margin=dict(l=20, r=20, t=40, b=20),
-            plot_bgcolor='rgba(0,0,0,0)',
-            xaxis=dict(showgrid=True, gridcolor='lightgray'),
-            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
-        )
-        return fig
-    except:
-        return go.Figure()
+# داده‌های زمانی و پروفایل روانشناختی
+school_profiles = {
+    "Stoicism": {"timeline": "3rd century BCE – 3rd century CE", "profile": "Calm, Resilient, Virtue-centered"},
+    "Existentialism": {"timeline": "19th – 20th century", "profile": "Individualistic, Authentic, Anxious"},
+    "Rationalism": {"timeline": "17th – 18th century", "profile": "Logical, Abstract, Confident"},
+    "Empiricism": {"timeline": "17th – 18th century", "profile": "Practical, Observational, Experimental"}
+}
 
-# Text analysis
+# تابع تحلیل و یافتن مکتب فلسفی
 def analyze_text(text):
-    try:
-        if not text.strip():
-            return "**🚨 Please enter a valid philosophical text.**", None, generate_timeline(), generate_concept_graph(), "", "", ""
-
-        user_vec = model.encode([text])
-        best_match = None
-        highest_score = -1
-
-        for school, data in KNOWLEDGE_BASE.items():
-            sims = cosine_similarity(user_vec, data["vectors"])
-            score = np.max(sims)
-            if score > highest_score:
-                highest_score = score
-                best_match = school
-
-        school_data = KNOWLEDGE_BASE[best_match]
-        psych = school_data["psychology"]
-        semantic_plot = create_semantic_plot(user_vec, best_match)
-        timeline = generate_timeline()
-        concept_map = generate_concept_graph()
-        reflect = philosophical_response(text, school=best_match)
+    if not text.strip():
+        return "Please enter a philosophical text.", None, None, None, None, None
+    
+    user_vec = model.encode([text])[0]
+
+    best_school = None
+    best_score = -1
+    best_match = ""
+
+    for school, quotes in school_data.items():
+        for quote in quotes:
+            quote_vec = model.encode([quote])[0]
+            score = cosine_similarity([user_vec], [quote_vec])[0][0]
+            if score > best_score:
+                best_score = score
+                best_school = school
+                best_match = quote
+
+    # گراف مفهومی (Conceptual Map)
+    semantic_plot = create_semantic_plot(user_vec, best_match, best_school)
+
+    # بازگشت خروجی‌ها
+    return (
+        best_school,
+        f"{best_score:.2f}",
+        school_profiles[best_school]["profile"],
+        school_profiles[best_school]["timeline"],
+        best_match,
+        semantic_plot
+    )
+
+# تابع رسم گراف مفهومی
+def create_semantic_plot(user_vec, best_quote, best_school):
+    ref_quotes = school_data[best_school]
+    quote_vecs = model.encode(ref_quotes)
+    labels = [f"Ref {i+1}" for i in range(len(ref_quotes))]
+
+    all_vecs = np.vstack([user_vec, quote_vecs])
+    pca = PCA(n_components=2)
+    reduced_vecs = pca.fit_transform(all_vecs)
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(
+        x=[reduced_vecs[0][0]],
+        y=[reduced_vecs[0][1]],
+        mode='markers+text',
+        text=["User Input"],
+        name="User Input",
+        textposition="top center",
+        marker=dict(size=14, symbol='circle', color='blue')
+    ))
+
+    fig.add_trace(go.Scatter(
+        x=reduced_vecs[1:, 0],
+        y=reduced_vecs[1:, 1],
+        mode='markers+text',
+        text=labels,
+        name="Reference Quotes",
+        textposition="top center",
+        marker=dict(size=12, symbol='square', color='orange')
+    ))
+
+    fig.update_layout(title="🧭 Conceptual Map", showlegend=False)
+    return fig
 
-        # Psychological profile (new)
-        psych_profile = psychological_analysis(text)
-        psych_output = ""
-        if psych_profile:
-            for item in psych_profile:
-                psych_output += f"- **{item['aspect']}**\n  • If followed: {item['followed']}\n  • If ignored: {item['ignored']}\n\n"
-        else:
-            psych_output = "No clear psychological indicators found."
+# رابط کاربری با Gradio
+with gr.Blocks(title="Philosophical Analyzer") as demo:
+    gr.Markdown("## 📝 Enter Philosophical Text")
+    input_text = gr.Textbox(lines=4, placeholder="Type or paste a philosophical text...")
 
-        report = f"""
-        <div>
-        <h2>{school_data['icon']} Philosophical School: <span style="color:{school_data['color']};">{best_match}</span></h2>
-        <p><strong>🧠 Confidence Score:</strong> {round(highest_score*100, 2)}%</p>
-        <p><strong>🔑 Key Concepts:</strong> {', '.join(school_data.get('key_concepts', []))}</p>
-        <h3>🧬 Psychological Effects</h3>
-        <ul>
-        <li><strong>Positive:</strong> {', '.join(psych["positive"])}</li>
-        <li><strong>Negative:</strong> {', '.join(psych["negative"])}</li>
-        <li><strong>Suggested Approaches:</strong> {', '.join(psych["solution"])}</li>
-        </ul>
-        <h3>🔍 Interpretation:</h3>
-        <blockquote>{reflect}</blockquote>
-        </div>
-        """
+    submit_btn = gr.Button("Analyze")
 
-        related = "### 🎓 Related Philosophers\n" + "\n".join([f"- {name}" for name in school_data["philosophers"]])
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 🕰️ Philosophy Timeline")
+            timeline = gr.Textbox(label="Timeline")
 
-        return report, semantic_plot, timeline, concept_map, related, best_match, round(highest_score*100, 2), psych_output
+            gr.Markdown("### 🧠 Philosophical School Detected:")
+            school = gr.Textbox(label="School")
 
-    except Exception as e:
-        print("Error:", e)
-        return "**⚠️ Unexpected error occurred. Try again.**", None, generate_timeline(), generate_concept_graph(), "", "", "", ""
+            gr.Markdown("### 📈 Similarity Score:")
+            score = gr.Textbox(label="Similarity")
 
-# UI
-def build_ui():
-    with gr.Blocks() as demo:
-        gr.Markdown("# 🌌 Philosophy Insight Engine")
-        with gr.Row():
-            with gr.Column(scale=2):
-                text_input = gr.Textbox(
-                    label="📜 Enter Philosophical Text",
-                    lines=4,
-                    placeholder="e.g. 'Man is condemned to be free'"
-                )
-                analyze_btn = gr.Button("🔍 Analyze Text")
-                clear_btn = gr.Button("🧹 Clear")
-                gr.Examples(
-                    examples=[
-                        ["Man is condemned to be free."],
-                        ["The obstacle is the way."],
-                        ["We suffer more in imagination than in reality."]
-                    ],
-                    inputs=text_input
-                )
-            with gr.Column(scale=1):
-                semantic_plot = gr.Plot(label="🗺️ Semantic Space")
+            gr.Markdown("### 🧬 Psychological Profile:")
+            profile = gr.Textbox(label="Profile")
 
-        with gr.Tabs():
-            with gr.TabItem("📝 Report"):
-                analysis_output = gr.HTML()
-            with gr.TabItem("🕰️ Timeline"):
-                timeline_output = gr.Plot()
-            with gr.TabItem("🧭 Concept Map"):
-                concept_map_output = gr.Plot()
-            with gr.TabItem("🎓 Philosophers"):
-                related_philosophers = gr.Markdown()
+        with gr.Column():
+            conceptual_map = gr.Plot(label="🧭 Conceptual Map")
 
-        # پایین سمت چپ (با اضافه کردن سه خروجی جدید برای روانشناسی و ...) یک ردیف جدید:
-        with gr.Row():
-            with gr.Column():
-                school_output = gr.Markdown(label="🧠 Philosophical School Detected:")
-                similarity_output = gr.Markdown(label="Similarity Score:")
-                psychological_output = gr.Markdown(label="Psychological Profile:")
+    with gr.Accordion("🧾 Most Similar Reference Quote", open=False):
+        best_quote = gr.Textbox(label="Closest Match")
 
-        analyze_btn.click(
-            analyze_text,
-            inputs=text_input,
-            outputs=[
-                analysis_output, semantic_plot, timeline_output, concept_map_output, related_philosophers,
-                school_output, similarity_output, psychological_output
-            ]
-        )
-        clear_btn.click(
-            lambda: ["", None, None, None, "", "", "", ""],
-            outputs=[
-                text_input, semantic_plot, timeline_output, concept_map_output, related_philosophers,
-                school_output, similarity_output, psychological_output
-            ]
-        )
-    return demo
+    submit_btn.click(fn=analyze_text, inputs=input_text,
+                     outputs=[school, score, profile, timeline, best_quote, conceptual_map])
 
-# Run
-if __name__ == "__main__":
-    demo = build_ui()
-    demo.launch(share=True)
+# اجرا
+demo.launch()