Upload folder using huggingface_hub

README.md

@@ -4,10 +4,10 @@ emoji: 🛩️
 colorFrom: blue
 colorTo: purple
 sdk: gradio
-sdk_version: "5.47.2"
+sdk_version: 4
 app_file: app.py
 pinned: false
 ---
 
-Interactive app that selects a transport wing from a candidate set, renders PNG + interactive 3D + STL,
+Interactive app that selects a transport wing, renders PNG + interactive 3D + STL,
 validates from an optional polar, and adds an LLM explanation.

app.py

@@ -564,52 +564,162 @@ def _topk_table_and_parallel(plans: List[Dict], probs: np.ndarray, k: int, objec
 
 # ---------------------- LLM: top-k grounded explanation (NEW) ----------------------
 # (Imports here to avoid import-time failures if transformers isn't available)
+# try:
+#     from transformers import AutoTokenizer, AutoModelForCausalLM
+# except Exception:
+#     AutoTokenizer, AutoModelForCausalLM = None, None
+
+# _LOCAL_LLM_ID = os.getenv("LOCAL_LLM_ID", "Qwen/Qwen2.5-1.5B-Instruct")
+# _tok = None
+# _llm = None
+# if AutoTokenizer is not None and AutoModelForCausalLM is not None:
+#     try:
+#         _tok = AutoTokenizer.from_pretrained(_LOCAL_LLM_ID)
+#         _llm = AutoModelForCausalLM.from_pretrained(
+#             _LOCAL_LLM_ID,
+#             device_map="auto",
+#             dtype=torch.float16 if torch.cuda.is_available() else torch.float32,  # (not torch_dtype)
+#         )
+#     except Exception as _e:
+#         _tok, _llm = None, None
+#         print("[WARN] LLM not loaded:", _e)
+
+# def _format_val(x):
+#     if isinstance(x, float):
+#         return f"{x:.3f}"
+#     return str(x)
+
+# def _build_topk_context(best_row: Dict, rivals_df: pd.DataFrame, cols: List[str]) -> str:
+#     parts = []
+#     best_bits = [f"{c}={_format_val(best_row[c])}" for c in cols if c in best_row]
+#     parts.append("Best: " + ", ".join(best_bits) + f", score={_format_val(best_row.get('score', ''))}")
+#     if rivals_df is not None and not rivals_df.empty:
+#         r = min(4, len(rivals_df))
+#         for i in range(r):
+#             row = rivals_df.iloc[i].to_dict()
+#             bits = [f"{c}={_format_val(row[c])}" for c in cols if c in row]
+#             parts.append(f"Rival{ i+1 }: " + ", ".join(bits) + f", score={_format_val(row.get('score',''))}")
+#     return "\n".join(parts)
+
+# def _llm_compare_and_explain(objective: str, best_row: Dict, rivals_df: pd.DataFrame) -> str:
+#     """
+#     Output exactly two short paragraphs:
+#       1) 'Why this candidate:' — justify top-1 vs rivals using only feature names from context
+#       2) 'Objective link:' — how those features help optimize the requested coefficient
+#     """
+#     if _tok is None or _llm is None:
+#         return ("Why this candidate: The top candidate aligns better with the objective using span/aspect ratio, taper, and washout than nearby rivals.\n"
+#                 "Objective link: These features shape lift distribution and drag in a way consistent with the chosen coefficient optimization.")
+#     cols = ["span_m", "taper", "aspect_ratio", "mac_m", "washout_deg"]
+#     ctx = _build_topk_context(best_row, rivals_df, cols)
+
+#     sys_msg = (
+#         "You are an aerospace engineering assistant. "
+#         "Use ONLY the provided context lines (feature names) to justify the selection. "
+#         "Do not invent numbers; if referencing a quantity, use its feature name only."
+#     )
+#     user_msg = (
+#         f"Objective: {objective}\n"
+#         "Context lines (these are the only values you may rely on):\n"
+#         f"{ctx}\n\n"
+#         "Write exactly two short paragraphs (1–2 sentences each):\n"
+#         "Paragraph 1 must start with 'Why this candidate:' and compare the best to rivals using feature names.\n"
+#         "Paragraph 2 must start with 'Objective link:' and use the features and objective to describe its real world performance/use case.\n"
+#         "Do not add bullet points or any numbers not present in the context."
+#     )
+#     messages = [
+#         {"role": "system", "content": sys_msg},
+#         {"role": "user",   "content": user_msg},
+#     ]
+#     try:
+#         prompt = _tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+#     except Exception:
+#         # Fallback for tokenizers without chat template
+#         prompt = sys_msg + "\n\n" + user_msg
+
+#     inputs = _tok(prompt, return_tensors="pt").to(_llm.device)
+#     with torch.no_grad():
+#         out_ids = _llm.generate(
+#             **inputs,
+#             max_new_tokens=220,
+#             temperature=0.2,
+#             top_p=0.9,
+#             do_sample=True,
+#             repetition_penalty=1.05,
+#         )
+#     text = _tok.decode(out_ids[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True).strip()
+
+#     # Keep just the two paragraphs starting with required prefixes
+#     lines = [l.strip() for l in text.splitlines() if l.strip()]
+#     joined = " ".join(lines)
+#     if "Why this candidate:" not in joined:
+#         joined = "Why this candidate: The top candidate presents a feature mix (aspect ratio, taper, washout) that better aligns with the objective than rivals. " + joined
+#     if "Objective link:" not in joined:
+#         joined += " Objective link: Those features influence lift distribution and drag in a way that supports the optimization."
+#     chunks = []
+#     for tag in ["Why this candidate:", "Objective link:"]:
+#         idx = joined.find(tag)
+#         if idx >= 0:
+#             end_candidates = [joined.find(t2, idx+1) for t2 in ["Why this candidate:", "Objective link:"] if joined.find(t2, idx+1) >= 0]
+#             end = min(end_candidates) if end_candidates else len(joined)
+#             chunks.append(joined[idx:end].strip())
+#     if len(chunks) >= 2:
+#         return chunks[0] + "\n" + chunks[1]
+#     return joined
+
+# ---------------------- LLM: top-k grounded explanation ----------------------
+import os
+import torch
+
 try:
     from transformers import AutoTokenizer, AutoModelForCausalLM
 except Exception:
     AutoTokenizer, AutoModelForCausalLM = None, None
 
 _LOCAL_LLM_ID = os.getenv("LOCAL_LLM_ID", "Qwen/Qwen2.5-1.5B-Instruct")
-_tok = None
-_llm = None
-if AutoTokenizer is not None and AutoModelForCausalLM is not None:
+_LLM_LOAD_ERR = None
+_tok, _llm = None, None
+
+def _try_load_llm():
+    global _tok, _llm, _LLM_LOAD_ERR
+    if (_tok is not None) and (_llm is not None):
+        return True
+    if AutoTokenizer is None or AutoModelForCausalLM is None:
+        _LLM_LOAD_ERR = "transformers not available"
+        return False
     try:
         _tok = AutoTokenizer.from_pretrained(_LOCAL_LLM_ID)
+        # On Spaces CPU: be explicit — CPU + float32
+        torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
         _llm = AutoModelForCausalLM.from_pretrained(
             _LOCAL_LLM_ID,
-            device_map="auto",
-            dtype=torch.float16 if torch.cuda.is_available() else torch.float32,  # (not torch_dtype)
+            torch_dtype=torch_dtype,
         )
-    except Exception as _e:
+        if not torch.cuda.is_available():
+            _llm = _llm.to("cpu")
+        return True
+    except Exception as e:
         _tok, _llm = None, None
-        print("[WARN] LLM not loaded:", _e)
+        _LLM_LOAD_ERR = f"{type(e).__name__}: {e}"
+        print("[WARN] LLM not loaded:", _LLM_LOAD_ERR)
+        return False
 
 def _format_val(x):
-    if isinstance(x, float):
-        return f"{x:.3f}"
-    return str(x)
+    return f"{x:.3f}" if isinstance(x, float) else str(x)
 
-def _build_topk_context(best_row: Dict, rivals_df: pd.DataFrame, cols: List[str]) -> str:
+def _build_topk_context(best_row, rivals_df, cols):
     parts = []
     best_bits = [f"{c}={_format_val(best_row[c])}" for c in cols if c in best_row]
     parts.append("Best: " + ", ".join(best_bits) + f", score={_format_val(best_row.get('score', ''))}")
     if rivals_df is not None and not rivals_df.empty:
-        r = min(4, len(rivals_df))
-        for i in range(r):
+        for i in range(min(4, len(rivals_df))):
             row = rivals_df.iloc[i].to_dict()
             bits = [f"{c}={_format_val(row[c])}" for c in cols if c in row]
             parts.append(f"Rival{ i+1 }: " + ", ".join(bits) + f", score={_format_val(row.get('score',''))}")
     return "\n".join(parts)
 
-def _llm_compare_and_explain(objective: str, best_row: Dict, rivals_df: pd.DataFrame) -> str:
-    """
-    Output exactly two short paragraphs:
-      1) 'Why this candidate:' — justify top-1 vs rivals using only feature names from context
-      2) 'Objective link:' — how those features help optimize the requested coefficient
-    """
-    if _tok is None or _llm is None:
-        return ("Why this candidate: The top candidate aligns better with the objective using span/aspect ratio, taper, and washout than nearby rivals.\n"
-                "Objective link: These features shape lift distribution and drag in a way consistent with the chosen coefficient optimization.")
+def _llm_compare_and_explain(objective: str, best_row: dict, rivals_df: "pd.DataFrame") -> str:
+    ok = _try_load_llm()
     cols = ["span_m", "taper", "aspect_ratio", "mac_m", "washout_deg"]
     ctx = _build_topk_context(best_row, rivals_df, cols)
 
@@ -627,17 +737,23 @@ def _llm_compare_and_explain(objective: str, best_row: Dict, rivals_df: pd.DataF
         "Paragraph 2 must start with 'Objective link:' and use the features and objective to describe its real world performance/use case.\n"
         "Do not add bullet points or any numbers not present in the context."
     )
-    messages = [
-        {"role": "system", "content": sys_msg},
-        {"role": "user",   "content": user_msg},
-    ]
+
+    if not ok:
+        # Show the real reason in the UI so you can diagnose Spaces vs Colab.
+        reason = _LLM_LOAD_ERR or "unknown"
+        return ("Why this candidate: The top candidate aligns better with the objective using span/aspect ratio, taper, and washout than nearby rivals.\n"
+                f"Objective link: (LLM fallback) {reason}. Features still indicate a lift/drag balance consistent with the selected objective.")
+
+    messages = [{"role": "system", "content": sys_msg}, {"role": "user", "content": user_msg}]
     try:
         prompt = _tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
     except Exception:
-        # Fallback for tokenizers without chat template
         prompt = sys_msg + "\n\n" + user_msg
 
-    inputs = _tok(prompt, return_tensors="pt").to(_llm.device)
+    inputs = _tok(prompt, return_tensors="pt")
+    if torch.cuda.is_available():
+        inputs = inputs.to(_llm.device)
+
     with torch.no_grad():
         out_ids = _llm.generate(
             **inputs,
@@ -647,25 +763,25 @@ def _llm_compare_and_explain(objective: str, best_row: Dict, rivals_df: pd.DataF
             do_sample=True,
             repetition_penalty=1.05,
         )
-    text = _tok.decode(out_ids[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True).strip()
+    # slice off the prompt
+    start = inputs["input_ids"].shape[1]
+    text = _tok.decode(out_ids[0, start:], skip_special_tokens=True).strip()
 
-    # Keep just the two paragraphs starting with required prefixes
+    # Normalize to the two required paragraphs:
     lines = [l.strip() for l in text.splitlines() if l.strip()]
     joined = " ".join(lines)
     if "Why this candidate:" not in joined:
         joined = "Why this candidate: The top candidate presents a feature mix (aspect ratio, taper, washout) that better aligns with the objective than rivals. " + joined
     if "Objective link:" not in joined:
         joined += " Objective link: Those features influence lift distribution and drag in a way that supports the optimization."
-    chunks = []
+    parts = []
     for tag in ["Why this candidate:", "Objective link:"]:
-        idx = joined.find(tag)
-        if idx >= 0:
-            end_candidates = [joined.find(t2, idx+1) for t2 in ["Why this candidate:", "Objective link:"] if joined.find(t2, idx+1) >= 0]
-            end = min(end_candidates) if end_candidates else len(joined)
-            chunks.append(joined[idx:end].strip())
-    if len(chunks) >= 2:
-        return chunks[0] + "\n" + chunks[1]
-    return joined
+        i = joined.find(tag)
+        if i >= 0:
+            j = min([x for x in (joined.find("Why this candidate:", i+1), joined.find("Objective link:", i+1)) if x != -1] + [len(joined)])
+            parts.append(joined[i:j].strip())
+    return "\n".join(parts[:2]) if parts else joined
+
 
 # --------------------- Quick validation (proxy) ---------------------
 def _interp_cl_cd(polar: Dict, alpha_deg: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: