Update app.py

app.py

@@ -6,8 +6,8 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 import xgboost as xgb
-from rdkit import Chem
-from rdkit import DataStructs
+import plotly.express as px
+from rdkit import Chem, DataStructs
 from rdkit.Chem import Descriptors, rdFingerprintGenerator
 from rdkit.Chem import RDConfig
 import sys
@@ -59,12 +59,11 @@ def get_mff_features(smiles):
     desc = [Descriptors.MolWt(mol), Descriptors.MolLogP(mol), Descriptors.TPSA(mol), Descriptors.NumValenceElectrons(mol), 0.0]
     return np.concatenate([mff, np.array(desc)])
 
-# --- 4. PREDICT TAB LOGIC ---
+# --- 4. PREDICT & BATCH LOGIC ---
 def predict_ui(app_choice, smiles):
     if not smiles: return "Please enter a SMILES string."
     feats = get_mff_features(smiles)
     if feats is None: return "Invalid p-SMILES"
-    
     if app_choice == "Structural (Strength)":
         res = np.expm1(strength_model.predict(feats.reshape(1, -1)))[0]
         return f"Predicted Yield Strength: {res:.4f} GPa"
@@ -78,67 +77,55 @@ def predict_ui(app_choice, smiles):
 def batch_predict(app_choice, file_obj):
     try:
         filename = file_obj.name
-        # --- NEW: Support for both CSV and Excel ---
         if filename.endswith('.csv'):
-            try:
-                df = pd.read_csv(filename, encoding='utf-8', on_bad_lines='skip')
-            except UnicodeDecodeError:
-                df = pd.read_csv(filename, encoding='latin1', on_bad_lines='skip')
+            try: df = pd.read_csv(filename, encoding='utf-8', on_bad_lines='skip')
+            except UnicodeDecodeError: df = pd.read_csv(filename, encoding='latin1', on_bad_lines='skip')
         elif filename.endswith(('.xls', '.xlsx')):
-            # Added engine='openpyxl' for better compatibility
             df = pd.read_excel(filename, engine='openpyxl')
-        else:
-            err_path = tempfile.NamedTemporaryFile(delete=False, suffix=".txt").name
-            with open(err_path, "w") as f: f.write("Unsupported format. Please upload .csv or .xlsx")
-            return None, err_path
+        else: return None, "Unsupported format"
 
-        # MODIFIED: Look for 'smile' OR 'smiles' (handles your SMILES.xlsx)
         s_col = next((c for c in df.columns if 'smile' in c.lower()), None)
-        
-        if not s_col:
-            err_path = tempfile.NamedTemporaryFile(delete=False, suffix=".txt").name
-            with open(err_path, "w") as f: 
-                f.write(f"Error: Could not find SMILES column. Found: {df.columns.tolist()}")
-            return None, err_path
+        if not s_col: return None, "No SMILES column found"
         
         results = []
         for s in df[s_col]:
             feats = get_mff_features(str(s))
             if feats is not None:
-                if app_choice == "Structural (Strength)":
-                    p = np.expm1(strength_model.predict(feats.reshape(1, -1)))[0]
-                elif app_choice == "Battery (Tg)":
-                    p = tg_model.predict(feats.reshape(1, -1))[0]
-                else:
-                    p = degrad_model.predict(feats.reshape(1, -1))[0]
+                if app_choice == "Structural (Strength)": p = np.expm1(strength_model.predict(feats.reshape(1, -1)))[0]
+                elif app_choice == "Battery (Tg)": p = tg_model.predict(feats.reshape(1, -1))[0]
+                else: p = degrad_model.predict(feats.reshape(1, -1))[0]
                 results.append(p)
-            else:
-                results.append(np.nan)
+            else: results.append(np.nan)
         
         df[f'Predicted_{app_choice}'] = results
         output_path = tempfile.NamedTemporaryFile(delete=False, suffix=".csv").name
         df.to_csv(output_path, index=False)
         return df.head(10), output_path
-
-    except Exception as e:
-        err_path = tempfile.NamedTemporaryFile(delete=False, suffix=".txt").name
-        with open(err_path, "w") as f: f.write(f"Error processing file: {str(e)}")
-        return None, err_path
+    except Exception as e: return None, str(e)
 
 # --- 5. AUTONOMOUS DESIGN LOGIC ---
-from rdkit import DataStructs
+def get_status_icon(val, target, is_higher_better=True):
+    margin = target * 0.1 # 10% Margin for Yellow status
+    if is_higher_better:
+        if val >= target: return "🟢"
+        if val >= (target - margin): return "🟡"
+        return "🔴"
+    else: # Lower is better (SA Score)
+        if val <= target: return "🟢"
+        if val <= (target + margin): return "🟡"
+        return "🔴"
 
 def generate_and_screen(num_to_gen):
     candidates = []
-    generated_fps = [] # Track fingerprints for diversity check
-    
-    # We will generate slightly more than requested to account for diversity filtering
-    max_attempts = num_to_gen * 5 
+    generated_fps = []
+    max_attempts = num_to_gen * 15 
     attempts = 0
     
+    # Benchmarks
+    T_STRENGTH, T_TG, T_DEG, T_SA = 0.075, 120.0, 0.30, 5.0
+
     while len(candidates) < num_to_gen and attempts < max_attempts:
         attempts += 1
-        # 1. Generation (Same GRU logic)
         input_seq = torch.tensor([[char_to_int['<SOS>']]])
         h, generated = None, ""
         for _ in range(100):
@@ -150,124 +137,121 @@ def generate_and_screen(num_to_gen):
         
         mol = Chem.MolFromSmiles(generated.replace('*', 'C'))
         if mol:
-            # --- NEW: Diversity Check ---
+            # Diversity Check (Tanimoto Filtering)
             fp = rdFingerprintGenerator.GetMorganGenerator(radius=2).GetFingerprint(mol)
-            is_diverse = True
-            for prev_fp in generated_fps:
-                sim = DataStructs.TanimotoSimilarity(fp, prev_fp)
-                if sim > 0.7: # Diversity threshold: skip if >70% similar to existing
-                    is_diverse = False
-                    break
-            if not is_diverse: continue
+            if any(DataStructs.TanimotoSimilarity(fp, prev_fp) > 0.7 for prev_fp in generated_fps): continue
             
-            # 2. Predictions
             feats = get_mff_features(generated)
-            s_raw = strength_model.predict(feats.reshape(1, -1))[0]
-            s = np.expm1(s_raw)
+            s = np.expm1(strength_model.predict(feats.reshape(1, -1))[0])
             d = degrad_model.predict(feats.reshape(1, -1))[0]
             t = tg_model.predict(feats.reshape(1, -1))[0]
             sa = sascorer.calculateScore(mol) if sascorer else 5.0
 
-            # --- NEW: Uncertainty Estimate (Standard Error Simulation) ---
-            # Using a 5% heuristic error common in polymer XGBoost models
-            s_err = s * 0.05 
-            t_err = 10.5 # +/- 10 degrees is standard for Tg models
-            
-            # --- NEW: Confidence Calculation ---
-            # How many benchmarks does it pass even when considering the error?
-            passes = 0
-            if (s - s_err) > 0.075: passes += 1
-            if (t - t_err) > 120.0: passes += 1
-            if d > 0.303: passes += 1
-            if sa < 5.0: passes += 1
+            # Uncertainty Estimates
+            s_err, t_err, d_err = s * 0.05, 10.5, 0.05
             
+            # Confidence Calculation
+            passes = sum([(s-s_err) > T_STRENGTH, (t-t_err) > T_TG, (d-d_err) > T_DEG, sa < T_SA])
             conf_pct = (passes / 4) * 100
-
             status = "Excellent" if passes >= 3 else "Review" if passes == 2 else "Bad"
             
             generated_fps.append(fp)
             candidates.append({
                 "p-SMILES": generated,
-                "Strength (GPa)": f"{s:.3f} ± {s_err:.3f}",
-                "Tg (°C)": f"{t:.1f} ± {t_err:.1f}",
-                "Degradability": round(d, 3),
-                "SA Score": round(sa, 2),
+                "Strength (GPa)": f"{get_status_icon(s, T_STRENGTH)} {s:.3f} ± {s_err:.3f}",
+                "Tg (°C)": f"{get_status_icon(t, T_TG)} {t:.1f} ± {t_err:.1f}",
+                "Degradability": f"{get_status_icon(d, T_DEG)} {d:.2f} ± {d_err:.2f}",
+                "SA Score": f"{get_status_icon(sa, T_SA, False)} {sa:.2f}",
                 "Confidence": f"{conf_pct:.0f}%",
-                "Classification": status
+                "Classification": status,
+                "_s": s, "_t": t # Raw for plotting
             })
             
     df = pd.DataFrame(candidates)
     output_path = tempfile.NamedTemporaryFile(delete=False, suffix=".csv").name
     df.to_csv(output_path, index=False)
-    return df, output_path
+    
+    # Pareto Front Viz
+    fig = px.scatter(df, x="_s", y="_t", color="Classification", 
+                     hover_data=["p-SMILES"], labels={"_s": "Strength (GPa)", "_t": "Tg (°C)"},
+                     title="Pareto Front Exploration: Strength vs Thermal Stability",
+                     template="plotly_white")
+    
+    return df.drop(columns=["_s", "_t"]), output_path, fig
 
 def calculate_universal_rank(df):
     if df is None or df.empty: return None, None
-    def norm(col): return (col - col.min()) / (col.max() - col.min() + 1e-6)
-    s_norm, t_norm, d_norm = norm(df['Strength (GPa)']), norm(df['Tg (°C)']), norm(df['Degradability'])
-    sa_norm = 1 - norm(df['SA Score'])
-    df['Universal Rank Score'] = ((s_norm + t_norm + d_norm + sa_norm) / 4).round(4)
+    def clean(x): return float(str(x).split(' ')[1])
+    
+    s_norm = (df['Strength (GPa)'].apply(clean) - 0.01) / (0.15 - 0.01)
+    t_norm = (df['Tg (°C)'].apply(clean) - 50) / (300 - 50)
+    d_norm = df['Degradability'].apply(clean)
+    sa_val = df['SA Score'].apply(clean)
+    
+    # Continuous SA Penalty
+    sa_penalty = np.exp(-0.4 * (sa_val - 1)) 
+
+    df['Universal Rank Score'] = ((s_norm + t_norm + d_norm + sa_penalty) / 4).round(4)
     df = df.sort_values(by="Universal Rank Score", ascending=False)
+    
     output_path = tempfile.NamedTemporaryFile(delete=False, suffix=".csv").name
     df.to_csv(output_path, index=False)
     return df, output_path
 
 # --- 6. GRADIO INTERFACE ---
 with gr.Blocks(title="PolymerDesignAI") as demo:
-    gr.Markdown("<center><h1>🧪 PolymerDesignAI: Multi-Application Pipeline</h1></center>")
+    gr.Markdown("<center><h1>🧪 PolymerDesignAI: Advanced Scientific Discovery</h1></center>")
     
     with gr.Tab("Predict"):
         gr.Markdown("### Forward Property Prediction")
         with gr.Row():
             with gr.Column():
-                pred_mode = gr.Radio(["Structural (Strength)", "Battery (Tg)", "Biomedical (Degradability)"], value="Structural (Strength)", label="Select Property")
-                smiles_in = gr.Textbox(label="Enter p-SMILES manually", placeholder="*CC*")
-                gr.Examples(examples=[["*CCCCCCNC(=O)NCCCCCCNC(=O)S*"], ["*Oc1ccc(C(C)(C)c2ccc(OC(=O)NCCCCCCNC(*)=O)cc2)cc1"], ["*[Se]c1ccc(C(=O)Nc2ccc(NC(=O)CCCCCCCC(=O)Nc3ccc(*)cc3)cc2)cc1"]], inputs=smiles_in, label="Quick Select Options")
+                pred_mode = gr.Radio(["Structural (Strength)", "Battery (Tg)", "Biomedical (Degradability)"], 
+                                     value="Structural (Strength)", label="Select Property")
+                sm_in = gr.Textbox(label="Enter p-SMILES", placeholder="*CC*")
+                gr.Examples(examples=[["*CCCCCCNC(=O)NCCCCCCNC(=O)S*"], ["*Oc1ccc(C(C)(C)c2ccc(OC(=O)NCCCCCCNC(*)=O)cc2)cc1"]], inputs=sm_in)
                 pred_btn = gr.Button("Predict Single", variant="primary")
                 res_label = gr.Label(label="Prediction Result")
             with gr.Column():
                 gr.Markdown("#### Batch Processing")
-                file_in = gr.File(label="Upload CSV with 'SMILES' column")
+                file_in = gr.File(label="Upload CSV/XLSX")
                 batch_btn = gr.Button("Run Batch Prediction")
-                batch_df = gr.DataFrame(label="Preview (Top 10)")
-                file_out = gr.File(label="Download Full Results")
-        pred_btn.click(predict_ui, [pred_mode, smiles_in], res_label)
-        batch_btn.click(batch_predict, [pred_mode, file_in], [batch_df, file_out])
+                batch_df = gr.DataFrame(); batch_file = gr.File()
+        pred_btn.click(predict_ui, [pred_mode, sm_in], res_label)
+        batch_btn.click(batch_predict, [pred_mode, file_in], [batch_df, batch_file])
 
     with gr.Tab("Autonomous Design"):
         gr.Markdown("### Integrated Generation + Screening")
         with gr.Row():
             with gr.Column():
-                gr.Markdown("""**Application Targets:**
-                * **Structural (Aerospace)**: Optimizing for High Yield Strength.
-                * **Battery Electrolytes**: Optimizing for High Glass Transition Temperature (Tg).
-                * **Biomedical**: Optimizing for High Degradability score.
+                gr.Markdown("""**Application Mapping:**
+                * **Aerospace Mode**: Optimized Yield Strength.
+                * **Battery Mode**: Optimized Glass Transition (Tg).
+                * **Biomedical Mode**: Optimized Degradability.
                 
                 **🧪 Universal Benchmarks:**
-                * Strength > 0.075 GPa
-                * Tg > 120°C
-                * Degradability > 0.303
-                * SA < 5.0""")
+                * Strength > 0.075 GPa | Tg > 120°C
+                * Degradability > 0.30 | SA < 5.0""")
             with gr.Column():
-                gr.Markdown("""**📊 Classification Logic:**
-                * **✅ Excellent**: Passes **3 or 4** benchmarks simultaneously.
-                * **⚠️ Review**: Passes exactly **2** benchmarks.
-                * **❌ Bad**: Passes **0 or 1** benchmark. (Fails 3+ targets)""")
+                gr.Markdown("""**📊 Status Key:**
+                * 🟢 Pass | 🟡 Near Threshold (10%) | 🔴 Fail
+                * **✅ Excellent**: Passes 3+ benchmarks with Uncertainty margin.""")
         
         with gr.Row():
             num = gr.Slider(1, 50, 10, step=1, label="Quantity to Generate")
             run = gr.Button("Run Design Pipeline", variant="primary")
             
-        results_df = gr.DataFrame(label="AI-Generated Candidates")
+        pareto_plot = gr.Plot(label="Pareto Frontier")
+        results_df = gr.DataFrame(label="AI-Generated Candidates (Ranked by Score)")
         
         gr.Markdown("### Multi-Objective Ranking")
-        gr.Markdown(r"""**Universal Rank Score Formula:** $$\text{Rank Score} = \frac{(\text{Norm. Strength}) + (\text{Norm. Tg}) + (\text{Norm. Deg.}) + (1 - \text{Norm. SA})}{4}$$
-        *This score identifies the best 'Total Package' polymers across all three goals.* """)
+        gr.Markdown(r"""**Universal Rank Score Formula:** Includes **Continuous SA Penalty** for feasibility.
+        *This score identifies the best 'Total Package' polymers.* """)
         
         rank_btn = gr.Button("Calculate Universal Rank Score", variant="secondary")
         csv_out = gr.File(label="Download Full Results")
         
-        run.click(generate_and_screen, num, [results_df, csv_out])
+        run.click(generate_and_screen, num, [results_df, csv_out, pareto_plot])
         rank_btn.click(calculate_universal_rank, results_df, [results_df, csv_out])
 
 demo.launch(auth=(os.environ.get("app_user"), os.environ.get("app_pass")), ssr_mode=False)