feat(data): resolve multitaste via the Taste column; keep sour/salty as rules

Parse the granular Taste column (positive-wins) → resolves 172/176 multitaste rows; sour/salty stay rules via RULE_TASTES; clean stale artifacts. Verified end to end.

Author: rvnminers-A-and-N

training/build_taste_dataset.py

@@ -103,19 +103,67 @@ def _row(ik, cs, source, labels=None, multitaste=0.0):
     return rec
 
 
+# Intensity modifiers stripped when parsing the granular 'Taste' column.
+_MODIFIERS = {"slightly", "very", "extremely", "mildly", "highly", "faintly",
+              "weakly", "strongly"}
+
+
+def parse_taste_column(val):
+    """Granular ChemTastesDB 'Taste' value -> per-taste 1/0 for basic tastes.
+
+    Handles compounds (Sweet/Bitter, Non-sweet; Bitter, Salty/Umami), intensity
+    modifiers (Slightly bitter -> bitter), and negations (Non-sweet -> sweet=0),
+    positive-wins within the row. Non-basic descriptors (cooling, pungent,
+    astringent, ...) are ignored — they're chemesthesis, not basic taste.
+    """
+    s = str(val).strip().lower()
+    if s in ("", "nan"):
+        return {}
+    if s == "tasteless":
+        return {t: 0.0 for t in BASIC}
+    for d in (";", ","):
+        s = s.replace(d, "/")
+    pos, neg = set(), set()
+    for tok in s.split("/"):
+        tok = tok.strip()
+        negated = tok.startswith("non-") or tok.startswith("non ")
+        if negated:
+            tok = tok[3:].lstrip("- ").strip()
+        tok = " ".join(w for w in tok.split() if w not in _MODIFIERS).strip()
+        if tok in BASIC:
+            (neg if negated else pos).add(tok)
+    out = {t: 1.0 for t in pos}
+    for t in neg:
+        if t not in pos:
+            out[t] = 0.0
+    return out
+
+
 def load_chemtastes(path):
     if not path.exists():
         print(f"  [skip] {path}")
         return pd.DataFrame()
     df = pd.read_excel(path)
     sc = _find(df, ["canonical smiles", "smiles"])
     cc = _find(df, ["class taste", "taste class", "class", "taste"])
+    cols = {c.lower().strip(): c for c in df.columns}
+    tc = cols.get("taste")  # granular multi-label column, if present
     rows = []
     for _, r in df.iterrows():
         ik, cs = canon(r[sc])
         if ik is None:
             continue
         labels, mt = chemtastes_labels(r[cc])
+        if tc is not None and tc != cc:
+            # Merge the granular 'Taste' multi-labels (positive-wins) so multitaste
+            # rows (Sweet/Bitter, Salty/Umami, ...) resolve into concrete labels.
+            fine = parse_taste_column(r[tc])
+            for t in BASIC:
+                vals = [labels.get(t), fine.get(t)]
+                if 1.0 in vals:
+                    labels[t] = 1.0
+                elif 0.0 in vals:
+                    labels[t] = 0.0
         rows.append(_row(ik, cs, "chemtastes", labels, mt))
     print(f"  chemtastes: {len(rows)}")
     return pd.DataFrame(rows)

training/export_onnx.py

@@ -24,6 +24,10 @@
 SRC = Path("taste_models")     # produced by train_taste.py
 OUT = Path("onnx_models")
 OUT.mkdir(exist_ok=True)
+# Clear stale exports so a removed/renamed head doesn't leave an orphan .onnx
+# alongside a manifest that no longer references it.
+for _stale in OUT.glob("*.onnx"):
+    _stale.unlink()
 FP_BITS, FP_RADIUS, INPUT_NAME = 2048, 2, "fp"
 
 if not SRC.exists() or not list(SRC.glob("*_rf.joblib")):

training/train_taste.py

@@ -2,10 +2,10 @@
 train_taste.py — taste heads (multi-taste) + sweetness-intensity regressor.
 
 Reads the merged dataset from build_taste_dataset.py and trains one binary
-RandomForest per taste that clears the data thresholds. Sweet/bitter/umami
-will train; sour/salty are auto-skipped (too few labels) and handled by the
-acidity rule in predict.py instead. If you add more sour/umami data later,
-they upgrade themselves on the next run — no code change.
+RandomForest per structure-driven taste (sweet/bitter/umami). Sour and salty
+are validated RULES in predict.py (sourness is a pH/solution property, saltiness
+a cation property), never trained — by design, not just data volume. Add more
+sweet/bitter/umami data and those heads sharpen on the next run.
 
 Even with everything merged this trains in minutes on the R620 CPU. The
 multi-day budget is the aroma model (train_odor.py), not this.
@@ -27,6 +27,9 @@
 from sklearn.metrics import roc_auc_score, r2_score
 
 BASIC = ["sweet", "bitter", "umami", "sour", "salty"]
+# Sour and salty are validated RULES by design (pH/solution and cation properties),
+# handled in predict.py and never trained — regardless of how much data accrues.
+RULE_TASTES = {"sour", "salty"}
 FP_BITS, FP_RADIUS = 2048, 2
 # Below this, a taste is too thin for an HONEST head, so it's skipped and
 # handled by rule/flag instead. It's not a hard exclusion: add more data (more
@@ -37,6 +40,10 @@
 MIN_POS, MIN_NEG = 80, 80
 OUT = Path("taste_models")
 OUT.mkdir(exist_ok=True)
+# Clear stale heads first, so a taste that no longer trains (e.g. now rule-handled)
+# can't leave an orphan .joblib that export_onnx would pick up.
+for _stale in OUT.glob("*_rf.joblib"):
+    _stale.unlink()
 
 # Acidic-group SMARTS — used both for the sour rule and to VALIDATE it against
 # whatever labeled sour compounds exist (so that data isn't wasted either).
@@ -73,6 +80,9 @@ def train_classifiers(master):
         yv = y[mask].astype(int).values
         Xv = X_all[mask]
         pos, neg = int((yv == 1).sum()), int((yv == 0).sum())
+        if taste in RULE_TASTES:
+            print(f"  {taste:7s} RULE by design (pos={pos}, neg={neg}) -> handled in predict.py")
+            continue
         if pos < MIN_POS or neg < MIN_NEG:
             print(f"  {taste:7s} SKIP (pos={pos}, neg={neg}) -> handled by rule/omitted")
             continue