Create app.py

app.py

@@ -0,0 +1,168 @@
+
+
+import gradio as gr
+import re
+
+# ---------- Dictionaries of words for each "layer" ----------
+# Layer 1: basic positive/negative detection
+positive_words = {"love", "great", "good", "amazing", "awesome", "happy"}
+negative_words = {"hate", "terrible", "awful", "bad", "horrible", "sad"}
+
+# Layer 2: sarcasm or contradictory cues
+sarcasm_cues = {"not!", "jk", "/s"}  # e.g. "The food was great, not!"
+
+# Layer 3: intensifiers
+intensifiers = {"very", "extremely", "so", "super", "really"}
+
+# ----------------------------------------------------------------
+# 1) Classification Layers
+# ----------------------------------------------------------------
+
+def layer_1_basic(text):
+    """
+    Layer 1:
+    - Count how many known positive words vs. negative words.
+    - If pos >= neg, label = "Positive", else "Negative"
+    """
+    words = re.findall(r"[a-zA-Z]+", text.lower())
+    pos_count = sum(1 for w in words if w in positive_words)
+    neg_count = sum(1 for w in words if w in negative_words)
+
+    label = "Positive" if pos_count >= neg_count else "Negative"
+    return label, pos_count, neg_count
+
+def layer_2_sarcasm_or_flip(text, prev_label):
+    """
+    Layer 2:
+    - Check for sarcasm cues (like "not!", "jk", "/s").
+    - If found, flip the classification from Layer 1.
+    """
+    text_lower = text.lower()
+    if any(cue in text_lower for cue in sarcasm_cues):
+        flipped = "Positive" if prev_label == "Negative" else "Negative"
+        return flipped + " (sarcasm-corrected)"
+    else:
+        return prev_label
+
+def layer_3_intensifiers(text, prev_label):
+    """
+    Layer 3:
+    - If there's an intensifier ("very", "extremely", "so", "super", "really"),
+      we add "(HIGH CONFIDENCE)" to the label.
+    """
+    text_lower = text.lower()
+    if any(i in text_lower for i in intensifiers):
+        return prev_label + " (HIGH CONFIDENCE)"
+    else:
+        return prev_label
+
+def deep_classify(text):
+    """
+    Pass text through 3 layers, returning a final classification
+    plus details about each layer.
+    """
+    # LAYER 1
+    layer1_label, pos_count, neg_count = layer_1_basic(text)
+
+    # LAYER 2
+    layer2_label = layer_2_sarcasm_or_flip(text, layer1_label)
+
+    # LAYER 3
+    final_label = layer_3_intensifiers(text, layer2_label)
+
+    return layer1_label, layer2_label, final_label, pos_count, neg_count
+
+# ----------------------------------------------------------------
+# 2) Gradio Demo
+# ----------------------------------------------------------------
+
+# Some sample statements from your original dropdown
+sample_statements = [
+    "I love this movie!",
+    "This place is awful.",
+    "The food was amazing, not!",
+    "I'm so happy right now.",
+    "Everything was terrible... JK!",
+    "I really hate slow service.",
+    "This is so good, I'm super impressed.",
+]
+
+def simulate_layers(sample_choice, custom_text):
+    """
+    1) If the user typed something in 'custom_text', use that.
+    2) Otherwise, use the selected 'sample_choice'.
+    3) Run the text through the 3-layer classification.
+    4) Return an HTML block describing each layer's result.
+    """
+    text_to_classify = ""
+    if custom_text.strip():
+        text_to_classify = custom_text.strip()
+    elif sample_choice:
+        text_to_classify = sample_choice
+    else:
+        return "<p style='color:red;'>Please provide a sentence.</p>"
+
+    layer1_label, layer2_label, final_label, pos_count, neg_count = deep_classify(text_to_classify)
+
+    # Build HTML explanation
+    html_output = f"""
+    <h3>Deep Learning Simulation</h3>
+    <p><b>Input Text:</b> {text_to_classify}</p>
+
+    <ol>
+      <li><b>Layer 1</b> checks positive vs. negative words (simple count).
+          <br>Positive words found: {pos_count}, Negative words found: {neg_count}
+          <br>Layer 1 Classification: <i>{layer1_label}</i>
+      </li>
+      <li><b>Layer 2</b> checks for sarcasm cues (like "not!", "jk", "/s").
+          <br>Result after sarcasm check: <i>{layer2_label}</i>
+      </li>
+      <li><b>Layer 3</b> looks for intensifiers ("very", "extremely", "so", "super", "really").
+          <br>Final Classification: <span style="color:blue; font-weight:bold;">{final_label}</span>
+      </li>
+    </ol>
+
+    <h4>How this relates to Deep Learning</h4>
+    <ul>
+      <li>In actual deep learning, each layer learns more complex
+          <i>features</i> automatically from data, rather than
+          using manually defined checks.</li>
+      <li>However, the <b>concept</b> of passing through multiple
+          layers to refine the result <i>is</i> how neural networks work.</li>
+    </ul>
+
+    <p><b>Observation:</b> This layered approach can handle nuances
+    like sarcasm or intensifiers better than a single rule or single-layer model.</p>
+    """
+    return html_output
+
+with gr.Blocks() as demo:
+    gr.Markdown("##Deep Learning (Layered Approach) Simulation")
+    gr.Markdown("Pick a sample statement **or** type your own, then click **Simulate**.")
+
+    with gr.Row():
+        sample_choice = gr.Dropdown(
+            label="Sample Statement",
+            choices=["(None)"] + sample_statements,
+            value="(None)",
+        )
+        custom_text = gr.Textbox(
+            label="Custom Text",
+            placeholder="Type your own statement here..."
+        )
+    simulate_button = gr.Button("Simulate Layers")
+    output = gr.HTML()
+
+    def simulate_wrapper(smpl, cstm):
+        # If the user picks "(None)", interpret that as an empty choice
+        if smpl == "(None)":
+            smpl = ""
+        return simulate_layers(smpl, cstm)
+
+    simulate_button.click(
+        fn=simulate_wrapper,
+        inputs=[sample_choice, custom_text],
+        outputs=[output]
+    )
+
+demo.launch()