Sync from GitHub (preserve manual model files)

StreamlitApp/StreamlitApp.py

@@ -156,30 +156,6 @@ if st.sidebar.button("Clear All Fields"):
         st.stop()
 
 
-def _prefill_peptide_viz_sequence() -> str:
-    """Best-effort sequence for Visualize Peptide: optimized result → optimize input → analyze → Predict top."""
-    out = st.session_state.get("optimize_output")
-    if out and len(out) >= 3:
-        improved = str(out[2] or "").strip()
-        if improved:
-            return improved
-    oi = (st.session_state.get("optimize_input") or "").strip()
-    if oi:
-        return oi
-    ai = (st.session_state.get("analyze_input") or "").strip()
-    if ai:
-        return ai
-    preds = st.session_state.get("predictions") or []
-    top = choose_top_candidate(preds)
-    if top and top.get("Sequence"):
-        return str(top["Sequence"]).strip()
-    pi = st.session_state.get("predict_input_widget", "") or ""
-    lines = [ln.strip() for ln in pi.splitlines() if ln.strip()]
-    if lines:
-        return lines[0]
-    return ""
-
-
 # Load model once 
 model = load_model()
 
@@ -460,6 +436,29 @@ elif page == "Analyze":
         ax.legend(loc='lower center', bbox_to_anchor=(0.85, 1.15), ncol=2, fontsize=7)
         st.pyplot(fig, use_container_width=False)
 
+        st.divider()
+        st.subheader("Most similar known AMP")
+        st.caption(
+            f"Compared to **{len(KNOWN_AMPS)}** unique AMP sequences (label = 1 in `Data/ampData.csv`)."
+        )
+        seq_sim = str(st.session_state.analyze_input or "").strip()
+        seq_clean_sim = "".join(c for c in seq_sim.upper() if not c.isspace())
+        if seq_clean_sim:
+            match_seq, sim_score = find_most_similar(seq_clean_sim)
+            if match_seq is not None:
+                st.write(f"**Best match:** `{match_seq}`")
+                st.write(f"**Similarity score:** **{sim_score:.3f}** (position match / max length)")
+                if sim_score > 0.6:
+                    st.success("High similarity to a known AMP in the reference set.")
+                elif sim_score > 0.3:
+                    st.warning("Moderate similarity — interpret with care.")
+                else:
+                    st.error("Low similarity — sequence is distant from reference AMPs.")
+            else:
+                st.warning("Could not compute similarity.")
+        else:
+            st.caption("Run analysis with a sequence to compare against known AMPs.")
+
         st.divider()
         # Analysis Summary
         st.subheader("Analysis Summary")
@@ -611,25 +610,19 @@ elif page == "Visualize Peptide":
         "and functional residue map."
     )
 
-    if not (st.session_state.get("visualize_peptide_input") or "").strip():
-        sug = _prefill_peptide_viz_sequence()
-        if sug:
-            st.session_state.visualize_peptide_input = sug
-
     st.checkbox("Auto-run when sequence changes", value=False, key="viz_peptide_auto_run")
 
     st.text_input(
         "Peptide sequence",
         key="visualize_peptide_input",
-        placeholder="One-letter amino-acid sequence",
-        help="When empty, your last optimized / analyzed / predicted sequence is filled in automatically.",
+        placeholder="Paste or type a one-letter amino-acid sequence",
     )
 
     seq_viz = (st.session_state.get("visualize_peptide_input") or "").strip()
     clean_viz = "".join(c for c in seq_viz.upper() if not c.isspace())
     if not clean_viz:
         st.session_state.viz_peptide_last_computed = ""
-        st.info("Enter a sequence above (or navigate from Predict / Analyze / Optimize to auto-fill when empty).")
+        st.info("Enter a sequence above, then click **Run visualization** (or enable **Auto-run**).")
     else:
         run_viz = st.button("Run visualization", type="primary", key="viz_peptide_run_btn")
         auto_on = bool(st.session_state.get("viz_peptide_auto_run"))
@@ -641,7 +634,7 @@ elif page == "Visualize Peptide":
             need_compute = True
 
         if need_compute:
-            with st.spinner("Building 3D view, helical wheel, and similarity search..."):
+            with st.spinner("Building 3D view and helical wheel..."):
                 st.session_state.viz_peptide_last_computed = clean_viz
 
         if clean_viz == st.session_state.get("viz_peptide_last_computed"):
@@ -669,7 +662,9 @@ elif page == "Visualize Peptide":
 
             with col_r:
                 st.subheader("Helical wheel")
-                st.caption("Circular α-helix projection: hydrophobic vs charged faces (approximate).")
+                st.caption(
+                    "Radial spokes per residue, black connectors along the sequence, colored disks (same scheme as 3D)."
+                )
                 fig_wheel = plot_helical_wheel(clean_viz)
                 st.pyplot(fig_wheel, use_container_width=True)
                 plt.close(fig_wheel)
@@ -683,23 +678,6 @@ elif page == "Visualize Peptide":
             with st.expander("Map · legend", expanded=False):
                 st.markdown(COMPACT_MAP_LEGEND)
 
-            st.subheader("Most similar known AMP")
-            st.caption(
-                f"Compared to **{len(KNOWN_AMPS)}** unique AMP sequences (label = 1 in `Data/ampData.csv`)."
-            )
-            match_seq, sim_score = find_most_similar(clean_viz)
-            if match_seq is not None:
-                st.write(f"**Best match:** `{match_seq}`")
-                st.write(f"**Similarity score:** **{sim_score:.3f}** (position match / max length)")
-                if sim_score > 0.6:
-                    st.success("High similarity to a known AMP in the reference set.")
-                elif sim_score > 0.3:
-                    st.warning("Moderate similarity — interpret with care.")
-                else:
-                    st.error("Low similarity — sequence is distant from reference AMPs.")
-            else:
-                st.warning("Could not compute similarity (empty sequence after cleaning).")
-
         elif clean_viz != (st.session_state.get("viz_peptide_last_computed") or ""):
             st.caption("Click **Run visualization** or enable **Auto-run** to update the figures.")
 
@@ -806,9 +784,9 @@ PeptideAI is a lightweight Streamlit app for exploring antimicrobial peptide (AM
 
 It uses a trained neural network to estimate whether a peptide is likely to be antimicrobial, then helps you interpret and improve candidates:
 - **Predict**: batch predictions from multi-line or FASTA input, length warnings, persisted results, top-candidate highlight, and CSV export.
-- **Analyze**: single-sequence numerical & textual analysis — AMP prediction, composition, physicochemical table + radar, and exportable report (no 3D on this page).
+- **Analyze**: single-sequence numerical & textual analysis — AMP prediction, composition, physicochemical table + radar, similarity to known AMPs, and exportable report (no 3D on this page).
 - **Optimize**: guided sequence optimization with mutation heatmap, step table, and confidence vs. step plot.
-- **Visualize Peptide**: one sequence with consistent coloring across functional map, helical wheel, and optional 3D approximation, plus similarity to known AMPs.
+- **Visualize Peptide**: one sequence with consistent coloring across functional map, detailed helical wheel, and optional 3D approximation.
 - **Visualize t-SNE**: upload many sequences, embed with the model, run t-SNE, and explore clusters with filters and hover metadata.
 - **About**: this overview and disclaimer.
 

StreamlitApp/utils/peptide_extras.py

@@ -152,14 +152,14 @@ def get_residue_color(aa: str) -> str:
 
 
 def residue_color_mpl(aa: str) -> str:
-    """Matplotlib-compatible hex colors matching `get_residue_color` categories."""
+    """Matplotlib-compatible hex colors matching `get_residue_color` categories (high-contrast for plots)."""
     cat = get_residue_color(aa)
     return {
-        "blue": "#4169E1",
-        "red": "#E74C3C",
-        "green": "#27AE60",
-        "gray": "#95A5A6",
-    }.get(cat, "#95A5A6")
+        "blue": "#1D4ED8",
+        "red": "#DC2626",
+        "green": "#16A34A",
+        "gray": "#57534E",
+    }.get(cat, "#57534E")
 
 
 HELIX_WHEEL_LEGEND_MARKDOWN: str = """
@@ -178,7 +178,8 @@ COMPACT_3D_LEGEND: str = (
     "Helix trace is an approximation, not an experimental structure."
 )
 COMPACT_WHEEL_LEGEND: str = (
-    "**100°** per residue. Cationic (blue) and hydrophobic (green) faces often matter for membrane-active helices."
+    "**Radial lines:** each residue around the wheel. **Black segments:** connect residue i → i+1 in sequence order "
+    "(classic helical-wheel “star” pattern). **Colors** match 3D: **blue** K,R,H · **red** D,E · **green** hydrophobic · **gray** other."
 )
 COMPACT_MAP_LEGEND: str = (
     "Same scheme as 3D and wheel: charged vs hydrophobic distribution along the sequence."
@@ -187,8 +188,8 @@ COMPACT_MAP_LEGEND: str = (
 
 def plot_helical_wheel(sequence: str, figsize: Tuple[float, float] = (6.2, 6.2)) -> Any:
     """
-    Amphipathic-style helical wheel (matplotlib polar). Colors match 3D / HTML maps.
-    Uses dark text for contrast on all wedge colors (avoids white-on-light issues in Streamlit).
+    Detailed helical wheel (matplotlib polar): radial spokes, sequence-order connectors (i→i+1),
+    and colored residue disks — same chemistry classes as 3D / HTML maps (high-contrast colors).
     """
     import matplotlib.pyplot as plt
     from matplotlib import patheffects as pe
@@ -198,54 +199,94 @@ def plot_helical_wheel(sequence: str, figsize: Tuple[float, float] = (6.2, 6.2))
     fig, ax = plt.subplots(figsize=figsize, subplot_kw={"projection": "polar"})
     fig.patch.set_facecolor("white")
     if n == 0:
-        ax.set_facecolor("#f5f5f5")
+        ax.set_facecolor("#ffffff")
         ax.set_title("Helical wheel (empty sequence)", pad=12)
         return fig
 
-    ax.set_facecolor("#f5f5f5")
+    ax.set_facecolor("#ffffff")
 
     angles_deg = np.array([i * 100.0 for i in range(n)], dtype=float) % 360.0
     angles_rad = np.deg2rad(angles_deg)
-    width = np.deg2rad(min(360.0 / max(n, 1) * 0.92, 0.45))
-    r0, r1 = 0.35, 1.0
-    fs = max(7, min(12, int(240 / max(n, 1))))
-    for i, aa in enumerate(clean):
+    r_inner, r_ring = 0.06, 0.88
+    fs = max(7, min(11, int(220 / max(n, 1))))
+    pt_size = float(np.clip(8000.0 / max(n, 1), 130.0, 420.0))
+
+    ax.set_theta_zero_location("N")
+    ax.set_theta_direction(-1)
+
+    # Radial spokes (residue positions)
+    for i in range(n):
         th = angles_rad[i]
-        color = residue_color_mpl(aa)
-        ax.bar(th, r1 - r0, width=width, bottom=r0, color=color, edgecolor="#222222", linewidth=0.5, align="center")
+        ax.plot(
+            [th, th],
+            [r_inner, r_ring],
+            color="#1a1a1a",
+            linewidth=0.65,
+            alpha=0.45,
+            zorder=1,
+        )
+
+    # Sequence-order connections (straight chords in the plane — classic wheel “star”)
+    for i in range(n - 1):
+        ax.plot(
+            [angles_rad[i], angles_rad[i + 1]],
+            [r_ring, r_ring],
+            color="#0a0a0a",
+            linewidth=1.05,
+            solid_capstyle="round",
+            zorder=2,
+        )
+
+    colors = [residue_color_mpl(aa) for aa in clean]
+    ax.scatter(
+        angles_rad,
+        np.full(n, r_ring),
+        s=pt_size,
+        c=colors,
+        edgecolors="#111111",
+        linewidths=1.2,
+        zorder=4,
+    )
+
+    for i, aa in enumerate(clean):
         t = ax.text(
-            th,
-            (r0 + r1) / 2.0,
+            angles_rad[i],
+            r_ring,
             aa,
             ha="center",
             va="center",
             fontsize=fs,
-            color="#111111",
+            color="#0a0a0a",
             fontweight="bold",
+            zorder=5,
         )
-        t.set_path_effects([pe.withStroke(linewidth=2.5, foreground="white")])
+        t.set_path_effects([pe.withStroke(linewidth=2.2, foreground="white")])
 
-    ax.set_theta_zero_location("N")
-    ax.set_theta_direction(-1)
-    ax.set_ylim(0, 1.05)
+    ax.set_ylim(0, 1.0)
     ax.set_yticklabels([])
     ax.set_xticklabels([])
     ax.grid(False)
-    ax.set_title("Helical wheel (α-helix projection, approximate)", pad=14, fontsize=11, color="#111111")
+    ax.set_title(
+        "Helical wheel (α-helix, 100°/residue) — spokes + sequence connectors",
+        pad=14,
+        fontsize=11,
+        color="#111111",
+    )
     return fig
 
 
 def get_residue_style(aa: str) -> str:
+    """Inline styles for sequence map — colors aligned with wheel / 3D categories (high contrast)."""
     positive = ["K", "R", "H"]
     negative = ["D", "E"]
     hydrophobic = ["A", "V", "I", "L", "M", "F", "W", "Y"]
     if aa in positive:
-        return "background-color: blue; color: white; padding: 2px;"
+        return "background-color: #1D4ED8; color: #ffffff; padding: 2px 3px; border-radius: 2px;"
     if aa in negative:
-        return "background-color: red; color: white; padding: 2px;"
+        return "background-color: #DC2626; color: #ffffff; padding: 2px 3px; border-radius: 2px;"
     if aa in hydrophobic:
-        return "background-color: green; color: white; padding: 2px;"
-    return "background-color: lightgray; padding: 2px;"
+        return "background-color: #16A34A; color: #ffffff; padding: 2px 3px; border-radius: 2px;"
+    return "background-color: #57534E; color: #ffffff; padding: 2px 3px; border-radius: 2px;"
 
 
 def build_importance_map_html(sequence: str) -> str: