Update my_pages/ica.py

my_pages/ica.py

@@ -3,82 +3,70 @@ import matplotlib.pyplot as plt
 import numpy as np
 
 def render():
-    st.title("ICA Triangle")
+    st.title("Intentional / Conventional / Arbitrary Triangle")
 
-    if "weights" not in st.session_state:
-        st.session_state.weights = {
-            "Intentional": 0.33,
-            "Conventional": 0.33,
-            "Arbitrary": 0.34
-        }
+    # Initialize state for slider values
+    if "intentional" not in st.session_state:
+        st.session_state.intentional = 0.33
+        st.session_state.conventional = 0.33
+        st.session_state.arbitrary = 0.34
 
-    # Which one to adjust
-    control_choice = st.radio(
-        "Select dimension to adjust",
-        ["Intentional", "Conventional", "Arbitrary"],
-        horizontal=True
-    )
-
-    # Current values
-    w = st.session_state.weights
-    current_value = w[control_choice]
-
-    # Slider for selected one
-    new_value = st.slider(control_choice, 0.0, 1.0, current_value, 0.01)
-
-    # Adjust others proportionally
-    diff = new_value - current_value
-    others = [k for k in w.keys() if k != control_choice]
-    total_other = w[others[0]] + w[others[1]]
+    # Sliders for each dimension
+    new_intentional = st.slider("Intentional", 0.0, 1.0, st.session_state.intentional, 0.01)
+    new_conventional = st.slider("Conventional", 0.0, 1.0, st.session_state.conventional, 0.01)
+    new_arbitrary = st.slider("Arbitrary", 0.0, 1.0, st.session_state.arbitrary, 0.01)
 
-    if total_other > 0:
-        w[others[0]] -= diff * (w[others[0]] / total_other)
-        w[others[1]] -= diff * (w[others[1]] / total_other)
+    # Update button
+    if st.button("Update Point"):
+        total = new_intentional + new_conventional + new_arbitrary
+        if total == 0:
+            total = 1  # avoid div by zero
+        st.session_state.intentional = new_intentional / total
+        st.session_state.conventional = new_conventional / total
+        st.session_state.arbitrary = new_arbitrary / total
 
-    w[control_choice] = new_value
+    # Plot triangle
+    fig, ax = plt.subplots(figsize=(5, 5))
 
-    # Clamp small floating point errors
-    for k in w:
-        w[k] = max(0.0, min(1.0, round(w[k], 4)))
+    # Triangle vertices
+    vertices = np.array([[0.5, np.sqrt(3)/2], [0, 0], [1, 0]])  # Intentional, Conventional, Arbitrary
+    labels = ["Intentional", "Conventional", "Arbitrary"]
 
-    # Normalize back to sum=1
-    total = sum(w.values())
-    if total != 0:
-        for k in w:
-            w[k] = round(w[k] / total, 4)
+    # Draw triangle
+    ax.plot([vertices[0][0], vertices[1][0]], [vertices[0][1], vertices[1][1]], 'k-')
+    ax.plot([vertices[1][0], vertices[2][0]], [vertices[1][1], vertices[2][1]], 'k-')
+    ax.plot([vertices[2][0], vertices[0][0]], [vertices[2][1], vertices[0][1]], 'k-')
 
-    # Triangle vertices
-    vertices = np.array([
-        [0.5, np.sqrt(3)/2],  # Intentional
-        [0, 0],               # Conventional
-        [1, 0]                # Arbitrary
-    ])
+    # Add labels
+    for i, label in enumerate(labels):
+        ax.text(vertices[i][0], vertices[i][1] + 0.05, label, ha='center', fontsize=12, fontweight='bold')
 
-    # Point from barycentric coords
+    # Convert (intentional, conventional, arbitrary) to XY coords
     point = (
-        w["Intentional"] * vertices[0] +
-        w["Conventional"] * vertices[1] +
-        w["Arbitrary"] * vertices[2]
+        st.session_state.conventional + 0.5 * st.session_state.intentional,
+        (np.sqrt(3)/2) * st.session_state.intentional
     )
 
-    # Plot
-    fig, ax = plt.subplots()
-    ax.plot(*np.append(vertices, [vertices[0]], axis=0).T, 'k-')
-    ax.scatter(vertices[:,0], vertices[:,1], c=["blue", "green", "red"], s=100)
-    ax.text(*vertices[0], "Intentional", ha="center", va="bottom")
-    ax.text(*vertices[1], "Conventional", ha="right", va="top")
-    ax.text(*vertices[2], "Arbitrary", ha="left", va="top")
-    ax.scatter(point[0], point[1], c="orange", s=200, zorder=5)
-    ax.set_aspect("equal")
-    ax.axis("off")
+    # Plot point
+    ax.scatter(point[0], point[1], color='red', s=100, zorder=5)
 
+    ax.set_aspect('equal')
+    ax.axis('off')
     st.pyplot(fig)
 
-    # Display interpretation
-    closest = max(w.items(), key=lambda x: x[1])[0]
-    if closest == "Arbitrary":
-        st.info("Example: Random seeds — a truly arbitrary decision.")
-    elif closest == "Intentional":
-        st.info("Example: Ethical constraints — a fully intentional choice.")
-    elif closest == "Conventional":
-        st.info("Example: Industry standard preprocessing — a conventional decision.")
+    # Display property based on dominant dimension
+    dominant = max(
+        ("Intentional", st.session_state.intentional),
+        ("Conventional", st.session_state.conventional),
+        ("Arbitrary", st.session_state.arbitrary),
+        key=lambda x: x[1]
+    )[0]
+
+    descriptions = {
+        "Intentional": "Example: Carefully designed rules.",
+        "Conventional": "Example: Following industry standards.",
+        "Arbitrary": "Example: Random seeds."
+    }
+
+    st.subheader(f"Dominant property: {dominant}")
+    st.write(descriptions[dominant])