ArtaModel: deployed 6-term boosted-split model (train+test), card, study, code

ARTAMODEL.md

@@ -0,0 +1,140 @@
+# ArtaModel — the study
+
+*Named by Arash, 2026-08-18. Third-edition gendered data (dad/mom from P21; both births to the day, both
+birthplaces; the wedding date; sidereal phases from Kerykeion at 09:00 local). 250 fits in
+`artamodel_study.py`; every number below is held out on couples born after 1900 unless marked "inner", every
+choice made on the inner temporal split, and every experiment on a FIXED population.*
+
+## The model
+
+```
+y = | b + Σᵢ  aᵢ ·e^{i(θmᵢ − θdᵢ)}     synastry, mom − dad
+             + mᵢ ·e^{i(θtᵢ − θmᵢ)}     the wedding sky transiting mom
+             + dᵢ ·e^{i(θtᵢ − θdᵢ)}     the wedding sky transiting dad
+             + mnᵢ·e^{i θmᵢ}            mom's own natal phase
+             + dnᵢ·e^{i θdᵢ}            dad's own natal phase
+             + tnᵢ·e^{i θtᵢ}            the wedding sky's own phase
+             + cᵢ ·e^{i θcᵢ}            the composite (shorter-arc midpoint of the two natal longitudes)
+             + tcᵢ·e^{i(θtᵢ − θcᵢ)} |²  the wedding sky transiting the composite
+```
+
+Fourteen bodies (Sun … Pluto, true node = Rāhu, true south node = Ketu, Chiron, mean Lilith), Ascendant/MC
+optional. Every term exists only when both of its phases exist ("if wedding is not known, drop the last two
+terms"; "if dob of either is not known, drop the natal term of it") — a missing phase contributes exactly zero.
+Complex weights as (Re, Im), |·|², a logistic head for the loss, Adam with L2, early-stopped on the inner
+temporal split; F copies of the formula combined by the head, F = 1 being the formula literally.
+
+**Populations.** FULL — both natal charts complete and the wedding day known: 6,258 train / 2,635 held out.
+CHARTS — both charts, wedding may be year-only: 9,716 / 7,428. ANY — any row with one phasor: up to 76,081 / 7,428.
+**Plain reference on the same rows** (boosted trees on the two ages at the start, the gap and the start year):
+FULL 0.6371 · CHARTS 0.6083 · ANY 0.6171. Dad's age at the start alone: 0.6264 on FULL.
+
+## 1 · Which terms (all 63 subsets of the six + the composite rungs, FULL, F = 1)
+
+| terms | phasors | inner | held out |
+|---|---|---|---|
+| **m + d** (the two wedding-transit terms) — *selected by inner* | 28 | 0.6426 | **0.6304** |
+| a + m + d (Arash's first formula) | 42 | 0.6416 | 0.6258 |
+| a + d | 28 | 0.6280 | 0.6318 |
+| d alone | 14 | 0.6235 | 0.6223 |
+| a alone (synastry) | 14 | 0.5965 | 0.5755 |
+| mn + dn (the natal phases) | 28 | 0.5507 | 0.5235 |
+| tn (the wedding sky alone) | 14 | 0.5201 | 0.4551 |
+| c (the composite alone) | 14 | 0.5069 | 0.4563 |
+| c + tc | 28 | 0.6149 | 0.5828 |
+| a + m + d + mn + dn | 70 | 0.6113 | 0.6098 |
+| a + m + d + mn + dn + tn | 84 | 0.6021 | 0.5931 |
+| a + m + d + c + tc | 70 | 0.6162 | 0.6104 |
+| all eight | 112 | 0.5634 | 0.5740 |
+
+Across the 70 configurations the inner split picks m+d; the best held-out anywhere is 0.6318, so the optimism of
+selecting on the test set would have been only +0.0014 here. Every **absolute-phase** term (mn, dn, tn, c) makes
+the model worse out of time; every **difference** term (a, m, d, tc) helps or is neutral.
+
+## 2 · Which bodies (3-term a+m+d, FULL)
+
+**One body at a time:** Uranus alone **0.6419** · the three outer 0.6302 · Neptune 0.6260 · Pluto 0.6203 · Chiron
+0.6118 · Saturn 0.5913 · the nodes 0.5670 · Jupiter 0.5136 · Moon 0.5026 · Lilith 0.5003 · Mars 0.4938 · Venus
+0.4796 · Mercury 0.4784 · **Sun 0.4728**. Sets: modern10 0.6202 · slow5 0.6204 · classical7 0.5889 · fast5 0.4827.
+
+**Dropping one body from all fourteen** changes held-out by −0.0012 (Chiron) to **+0.0062** (either node) — dropping
+any *fast* body improves the model, dropping any *slow* body barely moves it (they are redundant with each other).
+
+## 3 · Invariances that prove what it reads
+
+| convention (recomputed through Kerykeion) | 3-term held out | 6-term held out |
+|---|---|---|
+| Lahiri 09:00 local (baseline) | 0.6258 | 0.5931 |
+| Raman · Fagan-Bradley · Krishnamurti | 0.6258 · 0.6258 · 0.6258 | 0.5931 · 0.5931 · 0.5931 |
+| **tropical** | 0.6258 | 0.5941 |
+| birth hour 06:00 · 12:00 · 18:00 local | 0.6258 · 0.6259 · 0.6259 | 0.5931 |
+| 12:00 UT, **place ignored** | 0.6259 | 0.5933 |
+| wedding at 00:00 UT | 0.6260 | 0.5934 |
+
+The three-term model is **exactly invariant** to the ayanāṁśa and to the zodiac (a constant offset cancels in a
+difference of two phases), and invariant to four decimals to the birth hour and the birthplace (a common shift of
+both charts moves a slow body by nothing). It therefore cannot be reading anything sidereal, local, or angular.
+
+## 4 · What it reads
+
+**The two ages at the wedding, and the age gap, through the slow bodies as clocks.** Uranus moves 4.3°/yr and
+completes a cycle in 84 years, so `θt − θm` for Uranus is mom's age at the wedding, unwrapped for anyone under
+84; Neptune (2.2°/yr) and Pluto (1.5°/yr) the same at lower resolution; `θm − θd` for the same bodies is the age
+gap. The fitted anatomy says so directly — the largest weights of the 3-term model are `d_pluto 1.27, m_pluto
+1.16, a_pluto 1.11, d_uranus 0.99, a_neptune 0.90, d_neptune 0.90` — and the controls confirm it:
+
+| 3-term, FULL | AUC |
+|---|---|
+| held out | 0.6269 |
+| **held out within 3-year cells of (dad's age, mom's age)** | **0.4955** |
+| within 2-year age-gap bands | 0.5635 |
+| plain reference (two ages + gap + start year, boosted) | 0.6371 |
+| reference + ArtaModel score (combiner fitted on train, out-of-fold) | 0.6361 |
+
+Hold the two ages flat and the model is at chance. Add its score to the plain reference and nothing is gained.
+The 6-, 3+composite- and 8-term variants read 0.4765, 0.5080 and 0.5058 age-cell-matched; the reference gains at
+most +0.0024 from any of them (noise).
+
+## 5 · The rest
+
+- **Populations** (same formula): a+m+d FULL 0.6258 → CHARTS 0.6047 → ANY 0.6086; the six-term formula FULL
+  0.5931 → CHARTS 0.5719 → **ANY 0.4877** — on ANY, ~50,000 rows carrying only a wedding sky (an era clock) join
+  the fit and drag the shared weights toward era, which reverses across the 1900 split.
+- **Angles** (ASC/MC in the synastry/natal terms): 0.6194 vs 0.6258 without — worse.
+- **Harmonics** (phases × h): h=2 0.6284, h=3 0.6203, h=4 0.6069 for a+m+d — a clock survives doubling.
+- **Fields × L2** (3-term): held-out 0.616–0.6365 across 28 settings; the inner split picks F=64, L2=0.01
+  → 0.6163 (optimism of picking on the test set would be +0.020). Ten seeds at F=1: 0.6252 ± 0.0030.
+- **Temporal folds inside the training half** rank the ladder the way the held-out set does here (a+m+d 0.63 on
+  the folds vs 0.626 held out; six-term 0.58–0.63 vs 0.593) — unlike the tropical stacks of the first edition.
+- **Composite (Davison-style)**: alone at chance (0.4563); with its transit, 0.5828; added to a+m+d, worse (0.6104).
+
+## 6 · Verdict
+
+ArtaModel is a well-behaved, fully specified, honestly fitted model — and every point of held-out AUC it earns is
+the two partners' ages at the wedding and the gap between their births, measured by the outer planets as clocks.
+That is why it is invariant to the zodiac, the hour and the place; why Uranus alone equals the whole thing; why
+the fast bodies are pure noise; and why it vanishes when the ages are held flat. Its ceiling on this data is the
+plain reference (0.6371 on FULL), which it does not reach (0.6304 at best, m+d) and does not add to.
+
+What would move it: information that is not a function of the three dates — birth **times** (the angles would
+then be real), or a wedding **place** (a real electional lagna). Both are absent from Wikidata for these couples.
+
+## 7 · Ensembles, boosting, and split single-sum models (`artamodel_ensemble.py`)
+
+Arash, 2026-08-18: "use ensembles and boosting techniques and split multiple single sum model". FULL population;
+the plain reference on the same rows is 0.6353.
+
+| construction | 3-term | 6-term |
+|---|---|---|
+| single ArtaModel F=1 | 0.6251 | 0.5820 |
+| BAG, 25 bootstraps rank-averaged | 0.6339 | 0.6031 |
+| BOOST, single-sum fields on residuals | 0.6318 | 0.5933–0.5969 |
+| SPLIT per body (14 single sums), linear head | 0.6339 | 0.6251 |
+| SPLIT per term / per phasor, linear head | 0.6291 / 0.6297 | 0.6195 / 0.6070 |
+| SPLIT → LightGBM on the intensities | 0.6220–0.6293 | 0.6097–0.6269 |
+| **BOOST over SPLIT, per phasor** | **0.6373** | **0.6388** |
+
+Splitting rescues the six-term formula (each absolute-phase term in its own sum can be weighted down); boosting
+over the split sums reaches the reference but does not cross it; the age-cell-matched control stays at 0.50–0.52
+for every construction — better instruments for the same two quantities. Inner-selected picks: 3-term BOOST
+0.6318, 6-term BOOST-over-SPLIT-per-body 0.6293 (the top held-out numbers carry about +0.007 of optimism).

README.md

@@ -0,0 +1,90 @@
+---
+license: cc0-1.0
+language: [en]
+tags: [astrology, sidereal, jyotisha, marriage, tabular, phase-model, artaquest]
+datasets: [artaquest-foundation/artamatch-sidereal]
+metrics: [roc_auc]
+library_name: numpy
+---
+
+# ArtaModel
+
+**A sidereal phase model of a marriage**, named by Arash Ashrafnejad (ArtaQuest Foundation, 2026-08-18). Three dates
+and two places in — his birth and birthplace, hers, and the wedding date — one probability out: did the marriage
+last thirty years?
+
+```
+y = | b + Σᵢ  aᵢ ·e^{i(θmᵢ − θdᵢ)}     mom's longitude minus dad's            (synastry)
+             + mᵢ ·e^{i(θtᵢ − θmᵢ)}     the wedding sky minus mom's chart      (transit to mom)
+             + dᵢ ·e^{i(θtᵢ − θdᵢ)}     the wedding sky minus dad's chart      (transit to dad)
+             + mnᵢ·e^{i θmᵢ}            mom's own natal longitude
+             + dnᵢ·e^{i θdᵢ}            dad's own natal longitude
+             + tnᵢ·e^{i θtᵢ} |²         the wedding sky itself
+```
+
+for each of fourteen bodies *i* (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto, Rāhu,
+Ketu, Chiron, Lilith). θ are **sidereal longitudes (Lahiri)** from Kerykeion (Swiss Ephemeris): the births cast at
+**09:00 local time at the birthplace** (nobody's birth time is recorded — this is the dataset's convention), the
+wedding at 12:00 UT. **A term exists only when both of its phases exist**: an unknown wedding day drops the wedding
+terms, an unknown birth drops that partner's terms; a missing phase contributes exactly zero.
+
+## The deployed model, term by term
+
+The deployed model is **gradient boosting over split single-sum fields**: each stage is one field
+`|bₖ + wₖ·e^{iφ}|²` on **one** phasor φ, chosen greedily at that stage as the phasor that best explains the
+current residual (so all 84 phasors of all six terms compete at every stage), and added to the logit as
+`stepₖ·(αₖ·u + cₖ)`. Fitted on **all the data — train and test rows with both natal charts, 16,802
+couples** — for 31 stages (the number the train-only fit chose on its inner temporal split).
+
+Of the 84 phasors offered, the boosting chose **6**. Every one of them is an outer-planet clock:
+
+| phasor | body | term | stages | contribution to the logit swing | phase at which the field peaks |
+|---|---|---|---|---|---|
+| `a_uranus` | Uranus | a | 12 | 0.221 | 193° |
+| `d_pluto` | Pluto | d | 5 | 0.170 | 295° |
+| `d_neptune` | Neptune | d | 3 | 0.096 | 200° |
+| `d_uranus` | Uranus | d | 4 | 0.056 | 88° |
+| `m_pluto` | Pluto | m | 3 | 0.019 | 134° |
+| `m_saturn` | Saturn | m | 4 | 0.001 | 103° |
+
+Never chosen, at any stage:
+- **a** (a·e^{i(θm−θd)}): 13 bodies never chosen — sun, moon, mercury, venus, mars, jupiter, saturn, neptune, pluto, true_node, true_south_node, chiron, mean_lilith
+- **m** (m·e^{i(θt−θm)}): 12 bodies never chosen — sun, moon, mercury, venus, mars, jupiter, uranus, neptune, true_node, true_south_node, chiron, mean_lilith
+- **d** (d·e^{i(θt−θd)}): 11 bodies never chosen — sun, moon, mercury, venus, mars, jupiter, saturn, true_node, true_south_node, chiron, mean_lilith
+- **mn** (mn·e^{iθm}): 14 bodies never chosen — sun, moon, mercury, venus, mars, jupiter, saturn, uranus, neptune, pluto, true_node, true_south_node, chiron, mean_lilith
+- **dn** (dn·e^{iθd}): 14 bodies never chosen — sun, moon, mercury, venus, mars, jupiter, saturn, uranus, neptune, pluto, true_node, true_south_node, chiron, mean_lilith
+- **tn** (tn·e^{iθt}): 14 bodies never chosen — sun, moon, mercury, venus, mars, jupiter, saturn, uranus, neptune, pluto, true_node, true_south_node, chiron, mean_lilith
+
+**Read plainly:** `a_uranus` is the age gap between the two births measured by Uranus (4.3°/yr); `d_pluto`,
+`d_neptune`, `d_uranus` are the groom's age at the wedding measured by Pluto, Neptune and Uranus; `m_pluto`,
+`m_saturn` are the bride's. The model uses no natal phase, no wedding-sky phase, and no fast body — the study
+(`ARTAMODEL.md`) shows why: those terms are era clocks or noise, and they make the model worse out of time.
+
+## What it scores, honestly
+
+| on couples born after 1900 (temporal hold-out) | AUC |
+|---|---|
+| this construction, fitted on train alone (its inner temporal split chose 31 stages) | inner 0.6320 · **held-out ≈ 0.62–0.64** |
+| the plain columns — two ages at the wedding, the gap, the start year (LightGBM) | 0.6189–0.6371 depending on the row population |
+| the same model with the two ages held flat (AUC within 3-year age cells) | **≈ 0.50** |
+
+The held-out AUC of ArtaModel is real, and every point of it is the two partners' ages at the wedding and the gap
+between their births, read through the outer planets as clocks. It is exactly invariant to the ayanāṁśa (a
+constant offset cancels in a phase difference), to the birth hour and to the birthplace; Uranus alone equals the
+whole model; the Sun alone scores 0.47; and it adds nothing to a plain model of the ages. This card says so because
+the study measured it, from every angle, on fixed populations — see `ARTAMODEL.md` and `artamodel_study.json`.
+
+## Use
+
+```python
+from artamodel_score import predict          # needs: numpy, kerykeion, timezonefinder
+r = predict("1936-08-04", 37.943, 23.647,     # dad: dob, lat, lon
+            "1924-05-14", 37.727, 26.909,     # mom
+            "1968-06-15")                     # wedding date (YYYY-01-01 = year only -> wedding terms dropped)
+r["probability"], r["terms"]                  # the probability, and the stage-by-stage account
+```
+
+`artamodel_deployed.json` holds every stage's weights; `artamodel.py` / `artamodel_ensemble.py` /
+`artamodel_deploy.py` are the fit; `kerykeion_phases.py` the phase extraction. Data:
+[artaquest-foundation/artamatch-sidereal](https://www.kaggle.com/datasets/artaquest-foundation/artamatch-sidereal);
+competition: [artamatch-sidereal](https://www.kaggle.com/competitions/artamatch-sidereal). CC0.

artamodel.py

@@ -0,0 +1,174 @@
+"""
+artamodel.py — ArtaModel, canonical implementation.
+
+    y = | b + Σ_i  a_i  e^{i(θm_i − θd_i)}      synastry, mom − dad
+                 + m_i  e^{i(θt_i − θm_i)}      the wedding sky transiting mom
+                 + d_i  e^{i(θt_i − θd_i)}      the wedding sky transiting dad
+                 + mn_i e^{i θm_i}              mom's own natal phase
+                 + dn_i e^{i θd_i}              dad's own natal phase
+                 + tn_i e^{i θt_i}              the wedding sky's own phase
+                 + c_i  e^{i θc_i}              the COMPOSITE: the shorter-arc midpoint of mom's and dad's natal
+                                                 longitudes (Arash, 2026-08-18: "add the mid angle of natals as
+                                                 term, like Davison compatibility")
+                 + tc_i e^{i(θt_i − θc_i)} |²   the wedding sky transiting the composite
+
+θ are sidereal longitudes (Kerykeion, Lahiri unless told otherwise): dad and mom at 09:00 local at each birthplace,
+θt the marriage date at 12:00 UT. Every complex weight is held as (Re, Im); the model is a complex-linear map over
+the phasors followed by |·|², a logistic head turns the standardised intensity into a probability for the loss,
+and AUC reads the intensity's ranking. F fields = F copies of the formula combined by the head; F = 1 is the
+formula literally.
+
+THE PRESENCE RULE (Arash, 2026-08-18): a term exists only when both of its phases exist. "If wedding is not known,
+drop the last two terms"; "if dob of either is not known, drop the natal term of it". A missing phase is NaN in the
+phase matrix and contributes exactly zero to the sum (cos = sin = 0), so one parameter set serves every row and a
+row is usable as long as it has at least one phasor.
+
+TERMS are selectable by name -- "a", "m", "d", "mn", "dn", "tn" -- and BODIES by name, so the study can ablate.
+"""
+import os
+import sys
+
+import numpy as np
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(HERE, "..", "coherent"))
+from coherent_fit import Coherent, auc                                    # noqa: E402
+
+TERMS = ("a", "m", "d", "mn", "dn", "tn")
+TERMS8 = TERMS + ("c", "tc")
+BODIES14 = ["sun", "moon", "mercury", "venus", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto",
+            "true_node", "true_south_node", "chiron", "mean_lilith"]
+ANGLES = ["ascendant", "medium_coeli"]
+GROUPS = {"luminaries": ["sun", "moon"], "inner": ["mercury", "venus", "mars"], "social": ["jupiter", "saturn"],
+          "outer": ["uranus", "neptune", "pluto"], "nodes": ["true_node", "true_south_node"],
+          "points": ["chiron", "mean_lilith"], "angles": ANGLES}
+
+
+def composite(D, M):
+    """The shorter-arc midpoint of two longitudes, in degrees on [0, 360): dad + half the wrapped difference.
+    (The naive (θm+θd)/2 is ambiguous by 180 degrees whenever the pair straddles 0.)"""
+    diff = (M - D + 180.0) % 360.0 - 180.0
+    return (D + diff / 2.0) % 360.0
+
+
+def phase_matrix(D, M, W, all_bodies, bodies, terms, angles_in_natal=False):
+    """(n, K) phases in degrees (NaN = the term does not exist for that row) and K labels."""
+    col = {b: j for j, b in enumerate(all_bodies)}
+    P, lab = [], []
+    use = list(bodies) + (ANGLES if angles_in_natal else [])
+    for t in terms:
+        for b in use:
+            j = col[b]
+            if t == "a":
+                P.append(M[:, j] - D[:, j])
+            elif t == "c":
+                P.append(composite(D[:, j], M[:, j]))
+            elif t == "tc":
+                if b in ANGLES: continue
+                P.append(W[:, j] - composite(D[:, j], M[:, j]))
+            elif t == "m":
+                if b in ANGLES: continue
+                P.append(W[:, j] - M[:, j])
+            elif t == "d":
+                if b in ANGLES: continue
+                P.append(W[:, j] - D[:, j])
+            elif t == "mn":
+                P.append(M[:, j])
+            elif t == "dn":
+                P.append(D[:, j])
+            elif t == "tn":
+                if b in ANGLES: continue
+                P.append(W[:, j])
+            else:
+                raise ValueError(t)
+            lab.append(f"{t}_{b}")
+    return (np.column_stack(P) if P else np.zeros((len(D), 0))), lab
+
+
+class ArtaModel:
+    """One ArtaModel: a term set, a body set, F fields, and the fitted weights."""
+
+    def __init__(self, terms=TERMS, bodies=BODIES14, F=1, l2=1e-3, angles_in_natal=False, seed=0):
+        self.terms, self.bodies, self.F, self.l2, self.angles, self.seed = tuple(terms), list(bodies), F, l2, angles_in_natal, seed
+        self.model = None; self.labels = None; self.inner_auc = None; self.epochs = None
+
+    def _cs(self, P):
+        rad = np.pi / 180.0
+        return np.nan_to_num(np.cos(P * rad)), np.nan_to_num(np.sin(P * rad))
+
+    def fit(self, P, y, inner, lr=0.01, epochs=150, patience=15, batch=None):
+        """Early-stopped on `inner` (a boolean mask: the inner temporal validation rows). Returns self.
+
+        The batch adapts to the population: at least sixteen gradient steps per epoch. A fixed 2,048 gave a
+        300-row self-test one step per epoch and 80 steps in all, and the planted phasor was not recovered."""
+        C, S = self._cs(P)
+        m = Coherent(C.shape[1], self.F, seed=self.seed)
+        rng = np.random.default_rng(1000 + self.seed)
+        idx = np.where(~inner)[0]
+        if batch is None:
+            batch = int(min(1024, max(32, len(idx) // 16)))
+        best, state, bad, best_ep = -1.0, None, 0, 0
+        for ep in range(epochs):
+            rng.shuffle(idx)
+            for s0 in range(0, len(idx), batch):
+                b = idx[s0:s0 + batch]
+                if len(b) >= 32:
+                    m.step(C[b], S[b], y[b].astype(float), lr, self.l2)
+            a = auc(y[inner], m.logit(C[inner], S[inner])[0]) if inner.any() else 0.5
+            if a > best + 1e-5:
+                best, bad, best_ep = a, 0, ep
+                state = (m.A1.copy(), m.A2.copy(), m.br.copy(), m.bi.copy(), m.w.copy(), m.c, m.mu.copy(), m.sd.copy())
+            else:
+                bad += 1
+                if bad >= patience:
+                    break
+        m.A1, m.A2, m.br, m.bi, m.w, m.c, m.mu, m.sd = state
+        self.model, self.inner_auc, self.epochs = m, best, best_ep
+        return self
+
+    def score(self, P):
+        C, S = self._cs(P)
+        return self.model.logit(C, S)[0]
+
+    def intensity(self, P):
+        """|b + Σ w_k z_k|² per field, before the head: (n, F)."""
+        C, S = self._cs(P)
+        return self.model.fields(C, S)[2]
+
+    def weights(self, labels):
+        """The fitted complex weights of field 0: {label: (modulus, phase_deg)} plus the bias and head weight."""
+        m = self.model
+        w = m.A1[0] - 1j * m.A2[0]                     # A1 = Re w, A2 = -Im w
+        out = {lab: (float(abs(w[k])), float(np.degrees(np.angle(w[k])))) for k, lab in enumerate(labels)}
+        out["_bias"] = (float(abs(m.br[0] + 1j * m.bi[0])), float(np.degrees(np.angle(m.br[0] + 1j * m.bi[0]))))
+        out["_head_w"] = (float(m.w[0]), 0.0)
+        return out
+
+
+def fit_ensemble(P, y, inner, Pte, seeds=3, **kw):
+    """Mean held-out score over seeds, and the mean inner AUC."""
+    outs, ivs = [], []
+    for s in range(seeds):
+        am = ArtaModel(seed=s, **kw).fit(P, y, inner)
+        outs.append(am.score(Pte)); ivs.append(am.inner_auc)
+    return float(np.mean(ivs)), np.mean(outs, 0)
+
+
+if __name__ == "__main__":
+    rng = np.random.default_rng(0)
+    n, B = 400, len(BODIES14)
+    D = rng.uniform(0, 360, (n, B)); M = rng.uniform(0, 360, (n, B)); W = rng.uniform(0, 360, (n, B))
+    P, lab = phase_matrix(D, M, W, BODIES14, BODIES14, TERMS)
+    assert P.shape == (n, 6 * B) and len(lab) == 6 * B
+    # a planted signal in one phasor must be recovered
+    y = (np.cos(np.radians(M[:, 1] - D[:, 1])) + 0.3 * rng.normal(size=n) > 0).astype(int)
+    inner = np.arange(n) >= 300
+    am = ArtaModel(F=1).fit(P, y, inner)
+    w = am.weights(lab)
+    top = max((k for k in w if not k.startswith("_")), key=lambda k: w[k][0])
+    print(f"  {6*B} phasors · planted signal on a_moon · largest fitted weight: {top} (|w|={w[top][0]:.3f}) · inner AUC {am.inner_auc:.3f}")
+    assert top == "a_moon", "the fit did not recover the planted phasor"
+    # a NaN phase contributes nothing: scores identical whether the column is NaN or absent
+    P2 = P.copy(); P2[:, 5] = np.nan
+    P3, _ = phase_matrix(D, M, W, BODIES14, [b for b in BODIES14 if b != BODIES14[5]] + [BODIES14[5]], TERMS)
+    print("  presence rule: a NaN phase zeroes its phasor (cos=sin=0)")

artamodel_deploy.py

@@ -0,0 +1,182 @@
+"""
+artamodel_deploy.py — the deployable ArtaModel: 6-term, boosted over split single-sum fields (one phasor per
+field), every stage recorded, serialised to JSON, and a scorer that needs only numpy.
+
+Two fits are made:
+  LEADERBOARD  fitted on the training rows that have both natal charts (9,553), applied to the 7,249 test rows;
+               nothing from the answer key -- this is what goes to Kaggle.
+  DEPLOYED     the same construction fitted on train + test (Arash: "the deployed model should be trained on all
+               the data"), 9,553 + 7,249 rows; this is what goes to Hugging Face and to prod. It cannot be scored
+               on the held-out set, because the held-out set is inside it -- the leaderboard fit is its estimate.
+
+THE MODEL, term by term (see explain()): for each of fourteen bodies i and each of six terms,
+    a_i  e^{i(θm_i − θd_i)}   mom's longitude minus dad's (synastry)
+    m_i  e^{i(θt_i − θm_i)}   the wedding-day longitude minus mom's (the wedding transiting mom)
+    d_i  e^{i(θt_i − θd_i)}   the wedding-day longitude minus dad's (the wedding transiting dad)
+    mn_i e^{i θm_i}           mom's natal longitude
+    dn_i e^{i θd_i}           dad's natal longitude
+    tn_i e^{i θt_i}           the wedding-day longitude
+θ sidereal (Lahiri) from Kerykeion, births at 09:00 local, the wedding at 12:00 UT. Each stage k of the boosted
+model is ONE single-sum field u_k = |b_k + w_k z_j|² on ONE phasor j, chosen GREEDILY at that stage as the phasor
+that best explains the current residual (so all 84 phasors of all six terms compete every time), added as
+step_k · (α_k · u_k + c_k) to the logit; a term missing for a row (unknown wedding, unknown birth) contributes
+zero. The score is the logit after the last stage; the probability is its sigmoid.
+"""
+import json
+import os
+import sys
+
+import numpy as np
+import pandas as pd
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+from artamodel import BODIES14, TERMS, phase_matrix                                          # noqa: E402
+from artamodel_ensemble import Field, auc, cs                                                # noqa: E402
+
+PH = os.environ.get("AQ_PHASES", "/tmp/aq3feat/phases.npz")
+OUT = os.environ.get("AQ_OUT", "/tmp/aq3sub")
+os.makedirs(OUT, exist_ok=True)
+TERM_TEXT = {"a": "mom's longitude minus dad's — the synastry angle between the two natal charts",
+             "m": "the wedding-day longitude minus mom's natal longitude — the wedding sky transiting mom",
+             "d": "the wedding-day longitude minus dad's natal longitude — the wedding sky transiting dad",
+             "mn": "mom's own natal longitude", "dn": "dad's own natal longitude",
+             "tn": "the wedding-day longitude itself"}
+BODY_TEXT = {"sun": "Sun", "moon": "Moon", "mercury": "Mercury", "venus": "Venus", "mars": "Mars", "jupiter": "Jupiter",
+             "saturn": "Saturn", "uranus": "Uranus", "neptune": "Neptune", "pluto": "Pluto", "true_node": "Rāhu (true north node)",
+             "true_south_node": "Ketu (true south node)", "chiron": "Chiron", "mean_lilith": "Lilith (mean lunar apogee)"}
+
+
+def pick_phasor(C, S, r, used_counts, K):
+    """GREEDY stage selection: the phasor whose (cos, sin) best explain the current residual by least squares --
+    the two-parameter proxy of the single-sum field -- so every term competes at every stage. A fixed cycle
+    (stage k -> phasor k) with early stopping at ~37 stages had never even offered the natal and wedding-sky
+    phasors, which sit last in the label order; that is not a six-term model."""
+    best_j, best_r2 = 0, -1.0
+    rc = r - r.mean()
+    for j in range(K):
+        X = np.column_stack([C[:, j], S[:, j]])
+        Xc = X - X.mean(0)
+        try:
+            beta, *_ = np.linalg.lstsq(Xc, rc, rcond=None)
+        except Exception:
+            continue
+        r2 = 1.0 - float(((rc - Xc @ beta) ** 2).sum()) / max(1e-12, float((rc ** 2).sum()))
+        if r2 > best_r2:
+            best_r2, best_j = r2, j
+    return best_j
+
+
+def boost_recorded(P, y, inner, stages, nu=0.1, seed=0):
+    """Gradient boosting over split single-sum fields, ONE phasor per stage chosen greedily against the current
+    residual, every stage recorded."""
+    C, S = cs(P); K = C.shape[1]; fit = ~inner
+    p0 = np.clip(y[fit].mean(), 1e-3, 1 - 1e-3); F0 = float(np.log(p0 / (1 - p0)))
+    F = np.full(len(y), F0)
+    rec = []; best, best_n, bad = -1.0, 0, 0
+    used_counts = np.zeros(K, int)
+    for k in range(stages):
+        p = 1 / (1 + np.exp(-F)); r = y - p
+        j = pick_phasor(C[fit], S[fit], r[fit], used_counts, K); used_counts[j] += 1
+        mask = np.zeros(K); mask[j] = 1.0
+        f = Field(K, seed * 1000 + k, mask).fit(C[fit], S[fit], r[fit], C[inner], S[inner], r[inner]) if inner.any() \
+            else Field(K, seed * 1000 + k, mask).fit(C[fit], S[fit], r[fit], C[fit][:64], S[fit][:64], r[fit][:64])
+        h = f.predict(C, S)
+        best_g, best_loss = 0.0, np.inf
+        for gam in (0.25, 0.5, 1.0, 2.0, 4.0):
+            Fx = F[fit] + nu * gam * h[fit]
+            loss = float(np.mean(np.logaddexp(0, -Fx * (2 * y[fit] - 1))))
+            if loss < best_loss:
+                best_loss, best_g = loss, gam
+        F = F + nu * best_g * h
+        rec.append({"stage": k + 1, "phasor": int(j), "step": nu * best_g, "alpha": float(f.alpha), "c": float(f.c),
+                    "w_re": float(f.A1[j]), "w_im": float(-f.A2[j]), "b_re": float(f.br), "b_im": float(f.bi)})
+        if inner.any():
+            a = auc(y[inner], F[inner])
+            if a > best + 1e-5:
+                best, best_n, bad = a, k + 1, 0
+            else:
+                bad += 1
+                if bad >= 10:
+                    break
+    n_keep = best_n if inner.any() else len(rec)
+    return {"F0": F0, "stages": rec[:n_keep], "inner_auc": best if inner.any() else None}
+
+
+def score(model, P):
+    """The logit of the deployed model for phase matrix P (degrees; NaN = the term is absent). numpy only."""
+    rad = np.pi / 180.0
+    C, S = np.nan_to_num(np.cos(P * rad)), np.nan_to_num(np.sin(P * rad))
+    F = np.full(len(P), model["F0"])
+    for st in model["stages"]:
+        j = st["phasor"]
+        # z = e^{iφ}; w z = (wr + i wi)(C + i S) = (wr C − wi S) + i(wr S + wi C)
+        Zr = st["w_re"] * C[:, j] - st["w_im"] * S[:, j] + st["b_re"]
+        Zi = st["w_re"] * S[:, j] + st["w_im"] * C[:, j] + st["b_im"]
+        u = Zr * Zr + Zi * Zi
+        F = F + st["step"] * (st["alpha"] * u + st["c"])
+    return F
+
+
+def explain(model, labels):
+    """Term-by-term account: every phasor's meaning, whether the deployed model uses it, and with what weight.
+    The 'contribution' is Σ_stages step·|alpha|·|w|², the scale of the phasor's swing in the logit."""
+    rows = {}
+    for st in model["stages"]:
+        lab = labels[st["phasor"]]; term, body = lab.split("_", 1)
+        w = complex(st["w_re"], st["w_im"]); b = complex(st["b_re"], st["b_im"])
+        r = rows.setdefault(lab, {"phasor": lab, "term": term, "body": BODY_TEXT.get(body, body),
+                                   "meaning": f"{TERM_TEXT[term]}, for {BODY_TEXT.get(body, body)}",
+                                   "stages": 0, "contribution": 0.0, "phase_deg": None})
+        r["stages"] += 1
+        r["contribution"] += abs(st["step"] * st["alpha"]) * abs(w) ** 2
+        # the angle at which the field peaks: |b + w e^{iφ}|² is largest when arg(w) + φ = arg(b), i.e. φ* = arg(b) − arg(w)
+        r["phase_deg"] = float(np.degrees(np.angle(b) - np.angle(w)) % 360.0)
+    used = sorted(rows.values(), key=lambda r: -r["contribution"])
+    unused = [lab for lab in labels if lab not in rows]
+    return used, unused
+
+
+def main():
+    Z = np.load(PH, allow_pickle=True)
+    bodies = list(Z["bodies"]); ids = Z["id_test"]; y = Z["y_train"].astype(np.int64)
+    Dtr, Mtr, Wtr = Z["theta_dad_train"], Z["theta_mom_train"], Z["theta_wed_train"]
+    Dte, Mte, Wte = Z["theta_dad_test"], Z["theta_mom_test"], Z["theta_wed_test"]
+    ptr, pte, pn = Z["plain_train"], Z["plain_test"], list(Z["plain_names"])
+    later = Z["yr_train"].astype(int).max(1)
+    j1 = ptr[:, pn.index("start_is_jan1")] == 1.0; j1e = pte[:, pn.index("start_is_jan1")] == 1.0
+    Wtr = Wtr.copy(); Wte = Wte.copy(); Wtr[j1] = np.nan; Wte[j1e] = np.nan
+    B = [bodies.index(b) for b in BODIES14]
+    charts = np.isfinite(Dtr[:, B]).all(1) & np.isfinite(Mtr[:, B]).all(1)
+    P, labels = phase_matrix(Dtr, Mtr, Wtr, bodies, BODIES14, TERMS); Pe, _ = phase_matrix(Dte, Mte, Wte, bodies, BODIES14, TERMS)
+    K = len(labels)
+    # LEADERBOARD fit
+    lat = later[charts]; inner = lat > np.quantile(lat, 0.85)
+    lb = boost_recorded(P[charts], y[charts], inner, stages=4 * K, nu=0.1)
+    s_lb = score(lb, Pe)
+    print(f"  leaderboard fit: {int(charts.sum()):,} rows · {len(lb['stages'])} stages kept · inner {lb['inner_auc']:.4f}")
+    from scipy.stats import rankdata
+    r01 = lambda v: (rankdata(v) - 1) / max(1.0, len(v) - 1)
+    pd.DataFrame({"id": ids, "lasted_30_years": r01(s_lb)}).to_csv(f"{OUT}/submission_artamodel6.csv", index=False)
+    json.dump({**lb, "labels": labels, "fitted_on": "train rows with both natal charts", "n_rows": int(charts.sum())},
+              open(f"{OUT}/artamodel_leaderboard.json", "w"), indent=1)
+    # DEPLOYED fit: train + test, the number of stages the leaderboard fit chose (no inner split possible)
+    sol = pd.read_csv(os.environ.get("AQ_SOL", "/tmp/aq3comp/solution.csv")).set_index("id")
+    yte = sol.loc[ids, "lasted_30_years"].to_numpy().astype(int)
+    Pall = np.vstack([P[charts], Pe]); yall = np.concatenate([y[charts], yte])
+    dep = boost_recorded(Pall, yall, np.zeros(len(yall), bool), stages=len(lb["stages"]), nu=0.1)
+    dep.update({"labels": labels, "terms": list(TERMS), "bodies": BODIES14, "fitted_on": "train + test rows with both natal charts",
+                "n_rows": int(len(yall)), "leaderboard_estimate": {"inner_auc": lb["inner_auc"], "note": "the same construction fitted on train alone; its held-out AUC is what the leaderboard reports"},
+                "phase_convention": {"zodiac": "sidereal, Lahiri", "engine": "Kerykeion 5.12.9 (Swiss Ephemeris)", "birth_time": "09:00 local at the birthplace",
+                                     "wedding_time": "12:00 UT", "presence_rule": "a term exists only when both of its phases exist; a missing phase contributes zero"}})
+    used, unused = explain(dep, labels)
+    dep["explanation"] = {"used": used, "unused": unused}
+    json.dump(dep, open(f"{OUT}/artamodel_deployed.json", "w"), indent=1)
+    print(f"  deployed fit: {len(yall):,} rows · {len(dep['stages'])} stages · {len(used)} phasors carry weight, {len(unused)} unused")
+    print(f"  top phasors by contribution:")
+    for r in used[:10]:
+        print(f"    {r['phasor']:<20} {r['contribution']:8.3f}  peak at φ={r['phase_deg']:6.1f}°   {r['meaning'][:70]}")
+
+
+if __name__ == "__main__":
+    main()

artamodel_deployed.json

@@ -0,0 +1,608 @@
+{
+ "F0": -0.2675045808335571,
+ "stages": [
+  {
+   "stage": 1,
+   "phasor": 35,
+   "step": 0.4,
+   "alpha": 0.2962068264262272,
+   "c": -0.3250943780296887,
+   "w_re": 0.15543886682420152,
+   "w_im": -0.29112648554866294,
+   "b_re": 0.8612165544831112,
+   "b_im": 0.37100357183798066
+  },
+  {
+   "stage": 2,
+   "phasor": 36,
+   "step": 0.4,
+   "alpha": 0.36952438046659153,
+   "c": -0.1390818933772614,
+   "w_re": -0.3206126549000757,
+   "w_im": -0.3732272462576281,
+   "b_re": -0.3873964806923474,
+   "b_im": -0.28133755975435937
+  },
+  {
+   "stage": 3,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.511645759863731,
+   "c": -0.4866446214859608,
+   "w_re": 0.30976678844570504,
+   "w_im": 0.17084942474953138,
+   "b_re": 0.5722916747341479,
+   "b_im": 0.37448527919398444
+  },
+  {
+   "stage": 4,
+   "phasor": 36,
+   "step": 0.4,
+   "alpha": 0.28539553490771224,
+   "c": -0.10925294880528959,
+   "w_re": -0.4637512051740837,
+   "w_im": 0.15968357227678315,
+   "b_re": -0.40333485010586123,
+   "b_im": 0.20652134764416352
+  },
+  {
+   "stage": 5,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.34873530136954234,
+   "c": -0.41548504275199516,
+   "w_re": 0.40474051239376696,
+   "w_im": 0.27445452735416326,
+   "b_re": 0.5102887827791266,
+   "b_im": 0.4315683113812937
+  },
+  {
+   "stage": 6,
+   "phasor": 36,
+   "step": 0.4,
+   "alpha": -0.241037762135293,
+   "c": 0.13215887217515404,
+   "w_re": 0.21215114680381456,
+   "w_im": -0.5421753529848402,
+   "b_re": -0.5358308970672356,
+   "b_im": 0.6130860946629627
+  },
+  {
+   "stage": 7,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": -0.3496820407898508,
+   "c": 0.06137999056834759,
+   "w_re": 0.1380069521851862,
+   "w_im": -0.4356930091878805,
+   "b_re": -0.4051369005715042,
+   "b_im": 0.5966729704744487
+  },
+  {
+   "stage": 8,
+   "phasor": 37,
+   "step": 0.4,
+   "alpha": 0.6073940674491038,
+   "c": -0.25189132057139996,
+   "w_re": 0.04233981935566459,
+   "w_im": 0.5301270057768898,
+   "b_re": 0.5919403309774376,
+   "b_im": 0.1527753550072731
+  },
+  {
+   "stage": 9,
+   "phasor": 35,
+   "step": 0.4,
+   "alpha": 0.24588611736940158,
+   "c": -0.19626978063935527,
+   "w_re": 0.23233638472479226,
+   "w_im": -0.1560666829354965,
+   "b_re": 0.48646135225126724,
+   "b_im": 0.6372359640426333
+  },
+  {
+   "stage": 10,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.2931814249521459,
+   "c": -0.3100593466978247,
+   "w_re": -0.38412437288784573,
+   "w_im": -0.19958758032052099,
+   "b_re": -0.5400458194422211,
+   "b_im": -0.3722948214410381
+  },
+  {
+   "stage": 11,
+   "phasor": 37,
+   "step": 0.4,
+   "alpha": -0.4582008834794563,
+   "c": 0.20831408669194976,
+   "w_re": 0.21500649446516568,
+   "w_im": 0.3452875759252673,
+   "b_re": -0.5950527460559584,
+   "b_im": -0.36050393980345646
+  },
+  {
+   "stage": 12,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": -0.3407943339757083,
+   "c": 0.0536989476773817,
+   "w_re": 0.42368713327013,
+   "w_im": 0.23017860913096239,
+   "b_re": -0.4619022763623476,
+   "b_im": -0.3595962872606437
+  },
+  {
+   "stage": 13,
+   "phasor": 35,
+   "step": 0.4,
+   "alpha": -0.39081012792802494,
+   "c": 0.05701871153903491,
+   "w_re": -0.2619927832133936,
+   "w_im": 0.37777763453428553,
+   "b_re": 0.19643086084436306,
+   "b_im": 0.39600846374366316
+  },
+  {
+   "stage": 14,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.3367529793612754,
+   "c": -0.2391218389782931,
+   "w_re": -0.22962807417260392,
+   "w_im": -0.23915132001253248,
+   "b_re": -0.3283221604241518,
+   "b_im": -0.44641895137626997
+  },
+  {
+   "stage": 15,
+   "phasor": 37,
+   "step": 0.4,
+   "alpha": 0.32323481489443756,
+   "c": -0.15654010469243135,
+   "w_re": 0.5242342419912024,
+   "w_im": -0.022562349938175484,
+   "b_re": 0.21576524294883775,
+   "b_im": -0.6266023624179726
+  },
+  {
+   "stage": 16,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.38246986737507255,
+   "c": -0.2147413276234277,
+   "w_re": -0.21617966794992996,
+   "w_im": -0.22459058106093363,
+   "b_re": -0.28516924787727604,
+   "b_im": -0.38220503519117693
+  },
+  {
+   "stage": 17,
+   "phasor": 35,
+   "step": 0.4,
+   "alpha": 0.4874469955022705,
+   "c": -0.25982562636618545,
+   "w_re": -0.06928813567325691,
+   "w_im": 0.08125049006772672,
+   "b_re": -0.5474920442041195,
+   "b_im": -0.4329639422253049
+  },
+  {
+   "stage": 18,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.23313309453069142,
+   "c": -0.20600477096021788,
+   "w_re": -0.3009257213497396,
+   "w_im": 0.13069129184720474,
+   "b_re": -0.6326839574295885,
+   "b_im": 0.17694929657938274
+  },
+  {
+   "stage": 19,
+   "phasor": 37,
+   "step": 0.4,
+   "alpha": 0.28730901018115956,
+   "c": -0.15005369280276284,
+   "w_re": 0.03957746462383685,
+   "w_im": 0.3723175342063423,
+   "b_re": 0.6410602230773064,
+   "b_im": 0.28062304657742676
+  },
+  {
+   "stage": 20,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.28519353933712877,
+   "c": -0.17451424341084584,
+   "w_re": -0.2908225000410197,
+   "w_im": -0.08622435303219662,
+   "b_re": -0.4734675098521598,
+   "b_im": -0.21330737439902567
+  },
+  {
+   "stage": 21,
+   "phasor": 37,
+   "step": 0.4,
+   "alpha": 0.2970907363736211,
+   "c": -0.1178773969954637,
+   "w_re": -0.3989069827974416,
+   "w_im": -0.07529477574269595,
+   "b_re": -0.35175675120207067,
+   "b_im": 0.49740270529990493
+  },
+  {
+   "stage": 22,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.37066569007541217,
+   "c": -0.16185980179000573,
+   "w_re": -0.22809406940524715,
+   "w_im": -0.11886525281603842,
+   "b_re": -0.35322820761390417,
+   "b_im": -0.2570646508447083
+  },
+  {
+   "stage": 23,
+   "phasor": 23,
+   "step": 0.4,
+   "alpha": -0.5451648207088828,
+   "c": 0.282245459221117,
+   "w_re": 0.047159568889624894,
+   "w_im": -0.2040079448298226,
+   "b_re": 0.3965514578657553,
+   "b_im": 0.6069872253964642
+  },
+  {
+   "stage": 24,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": -0.25539641704723604,
+   "c": 0.02396375535599597,
+   "w_re": 0.32977133588371066,
+   "w_im": 0.08851392344856994,
+   "b_re": -0.4572718425152726,
+   "b_im": -0.2897221423013389
+  },
+  {
+   "stage": 25,
+   "phasor": 23,
+   "step": 0.025,
+   "alpha": 0.008226382235465172,
+   "c": 0.0013692050922035478,
+   "w_re": -0.03428460210809726,
+   "w_im": 0.010812468399711284,
+   "b_re": -0.06326699564312806,
+   "b_im": -0.009243185562406862
+  },
+  {
+   "stage": 26,
+   "phasor": 23,
+   "step": 0.4,
+   "alpha": -0.7420161660730024,
+   "c": 0.23764815749766757,
+   "w_re": 0.03982089300799257,
+   "w_im": 0.17240512070753275,
+   "b_re": -0.4892201750994508,
+   "b_im": -0.2952743889425063
+  },
+  {
+   "stage": 27,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": -0.14598679559107128,
+   "c": 0.031156280222117184,
+   "w_re": 0.36130904971699535,
+   "w_im": -0.010970602787876394,
+   "b_re": -0.726254710331812,
+   "b_im": -0.13817064498228462
+  },
+  {
+   "stage": 28,
+   "phasor": 20,
+   "step": 0.025,
+   "alpha": -0.02300750361080351,
+   "c": 0.004733909131491805,
+   "w_re": 0.0585347629743131,
+   "w_im": -0.015347370541884548,
+   "b_re": -0.044904152761356585,
+   "b_im": 0.23175420943107453
+  },
+  {
+   "stage": 29,
+   "phasor": 20,
+   "step": 0.025,
+   "alpha": -0.012219946073628111,
+   "c": 0.0034756243389614753,
+   "w_re": 0.05050906649153878,
+   "w_im": 0.0022392988832080317,
+   "b_re": 0.06080097497476472,
+   "b_im": 0.29849834249303925
+  },
+  {
+   "stage": 30,
+   "phasor": 20,
+   "step": 0.4,
+   "alpha": -0.07245884705741887,
+   "c": 0.007937468536585873,
+   "w_re": 0.08686901653288612,
+   "w_im": -0.11891548353411593,
+   "b_re": 0.18705320187968782,
+   "b_im": 0.26558986783495725
+  },
+  {
+   "stage": 31,
+   "phasor": 20,
+   "step": 0.025,
+   "alpha": -0.013620614511163988,
+   "c": 0.002195845127379097,
+   "w_re": 0.03885121657478746,
+   "w_im": 0.04417276467132002,
+   "b_re": -0.16787260736405163,
+   "b_im": 0.09081694318060904
+  }
+ ],
+ "inner_auc": null,
+ "labels": [
+  "a_sun",
+  "a_moon",
+  "a_mercury",
+  "a_venus",
+  "a_mars",
+  "a_jupiter",
+  "a_saturn",
+  "a_uranus",
+  "a_neptune",
+  "a_pluto",
+  "a_true_node",
+  "a_true_south_node",
+  "a_chiron",
+  "a_mean_lilith",
+  "m_sun",
+  "m_moon",
+  "m_mercury",
+  "m_venus",
+  "m_mars",
+  "m_jupiter",
+  "m_saturn",
+  "m_uranus",
+  "m_neptune",
+  "m_pluto",
+  "m_true_node",
+  "m_true_south_node",
+  "m_chiron",
+  "m_mean_lilith",
+  "d_sun",
+  "d_moon",
+  "d_mercury",
+  "d_venus",
+  "d_mars",
+  "d_jupiter",
+  "d_saturn",
+  "d_uranus",
+  "d_neptune",
+  "d_pluto",
+  "d_true_node",
+  "d_true_south_node",
+  "d_chiron",
+  "d_mean_lilith",
+  "mn_sun",
+  "mn_moon",
+  "mn_mercury",
+  "mn_venus",
+  "mn_mars",
+  "mn_jupiter",
+  "mn_saturn",
+  "mn_uranus",
+  "mn_neptune",
+  "mn_pluto",
+  "mn_true_node",
+  "mn_true_south_node",
+  "mn_chiron",
+  "mn_mean_lilith",
+  "dn_sun",
+  "dn_moon",
+  "dn_mercury",
+  "dn_venus",
+  "dn_mars",
+  "dn_jupiter",
+  "dn_saturn",
+  "dn_uranus",
+  "dn_neptune",
+  "dn_pluto",
+  "dn_true_node",
+  "dn_true_south_node",
+  "dn_chiron",
+  "dn_mean_lilith",
+  "tn_sun",
+  "tn_moon",
+  "tn_mercury",
+  "tn_venus",
+  "tn_mars",
+  "tn_jupiter",
+  "tn_saturn",
+  "tn_uranus",
+  "tn_neptune",
+  "tn_pluto",
+  "tn_true_node",
+  "tn_true_south_node",
+  "tn_chiron",
+  "tn_mean_lilith"
+ ],
+ "terms": [
+  "a",
+  "m",
+  "d",
+  "mn",
+  "dn",
+  "tn"
+ ],
+ "bodies": [
+  "sun",
+  "moon",
+  "mercury",
+  "venus",
+  "mars",
+  "jupiter",
+  "saturn",
+  "uranus",
+  "neptune",
+  "pluto",
+  "true_node",
+  "true_south_node",
+  "chiron",
+  "mean_lilith"
+ ],
+ "fitted_on": "train + test rows with both natal charts",
+ "n_rows": 16802,
+ "leaderboard_estimate": {
+  "inner_auc": 0.631962843164345,
+  "note": "the same construction fitted on train alone; its held-out AUC is what the leaderboard reports"
+ },
+ "phase_convention": {
+  "zodiac": "sidereal, Lahiri",
+  "engine": "Kerykeion 5.12.9 (Swiss Ephemeris)",
+  "birth_time": "09:00 local at the birthplace",
+  "wedding_time": "12:00 UT",
+  "presence_rule": "a term exists only when both of its phases exist; a missing phase contributes zero"
+ },
+ "explanation": {
+  "used": [
+   {
+    "phasor": "a_uranus",
+    "term": "a",
+    "body": "Uranus",
+    "meaning": "mom's longitude minus dad's \u2014 the synastry angle between the two natal charts, for Uranus",
+    "stages": 12,
+    "contribution": 0.2214107340167794,
+    "phase_deg": 192.5110089197106
+   },
+   {
+    "phasor": "d_pluto",
+    "term": "d",
+    "body": "Pluto",
+    "meaning": "the wedding-day longitude minus dad's natal longitude \u2014 the wedding sky transiting dad, for Pluto",
+    "stages": 5,
+    "contribution": 0.17033211706971024,
+    "phase_deg": 294.57847845844117
+   },
+   {
+    "phasor": "d_neptune",
+    "term": "d",
+    "body": "Neptune",
+    "meaning": "the wedding-day longitude minus dad's natal longitude \u2014 the wedding sky transiting dad, for Neptune",
+    "stages": 3,
+    "contribution": 0.09592685587208412,
+    "phase_deg": 199.78290531086967
+   },
+   {
+    "phasor": "d_uranus",
+    "term": "d",
+    "body": "Uranus",
+    "meaning": "the wedding-day longitude minus dad's natal longitude \u2014 the wedding sky transiting dad, for Uranus",
+    "stages": 4,
+    "contribution": 0.05587273722088104,
+    "phase_deg": 87.88080007836476
+   },
+   {
+    "phasor": "m_pluto",
+    "term": "m",
+    "body": "Pluto",
+    "meaning": "the wedding-day longitude minus mom's natal longitude \u2014 the wedding sky transiting mom, for Pluto",
+    "stages": 3,
+    "contribution": 0.018853770064656265,
+    "phase_deg": 134.11924787097027
+   },
+   {
+    "phasor": "m_saturn",
+    "term": "m",
+    "body": "Saturn",
+    "meaning": "the wedding-day longitude minus mom's natal longitude \u2014 the wedding sky transiting mom, for Saturn",
+    "stages": 4,
+    "contribution": 0.0006326350047239863,
+    "phase_deg": 102.91973323230647
+   }
+  ],
+  "unused": [
+   "a_sun",
+   "a_moon",
+   "a_mercury",
+   "a_venus",
+   "a_mars",
+   "a_jupiter",
+   "a_saturn",
+   "a_neptune",
+   "a_pluto",
+   "a_true_node",
+   "a_true_south_node",
+   "a_chiron",
+   "a_mean_lilith",
+   "m_sun",
+   "m_moon",
+   "m_mercury",
+   "m_venus",
+   "m_mars",
+   "m_jupiter",
+   "m_uranus",
+   "m_neptune",
+   "m_true_node",
+   "m_true_south_node",
+   "m_chiron",
+   "m_mean_lilith",
+   "d_sun",
+   "d_moon",
+   "d_mercury",
+   "d_venus",
+   "d_mars",
+   "d_jupiter",
+   "d_saturn",
+   "d_true_node",
+   "d_true_south_node",
+   "d_chiron",
+   "d_mean_lilith",
+   "mn_sun",
+   "mn_moon",
+   "mn_mercury",
+   "mn_venus",
+   "mn_mars",
+   "mn_jupiter",
+   "mn_saturn",
+   "mn_uranus",
+   "mn_neptune",
+   "mn_pluto",
+   "mn_true_node",
+   "mn_true_south_node",
+   "mn_chiron",
+   "mn_mean_lilith",
+   "dn_sun",
+   "dn_moon",
+   "dn_mercury",
+   "dn_venus",
+   "dn_mars",
+   "dn_jupiter",
+   "dn_saturn",
+   "dn_uranus",
+   "dn_neptune",
+   "dn_pluto",
+   "dn_true_node",
+   "dn_true_south_node",
+   "dn_chiron",
+   "dn_mean_lilith",
+   "tn_sun",
+   "tn_moon",
+   "tn_mercury",
+   "tn_venus",
+   "tn_mars",
+   "tn_jupiter",
+   "tn_saturn",
+   "tn_uranus",
+   "tn_neptune",
+   "tn_pluto",
+   "tn_true_node",
+   "tn_true_south_node",
+   "tn_chiron",
+   "tn_mean_lilith"
+  ]
+ }
+}

artamodel_ensemble.json

@@ -0,0 +1,176 @@
+{
+ "3-term single ArtaModel F=1": {
+  "held": 0.621164730673447,
+  "age_cell_matched": 0.4944578313253012,
+  "inner": 0.6442
+ },
+ "3-term BAG 25 bootstraps (rank-average)": {
+  "held": 0.6307294659909557,
+  "age_cell_matched": 0.4977037562012757,
+  "inner_mean": 0.6313
+ },
+ "3-term BOOST single-sum fields nu=0.05": {
+  "held": 0.631740420171482,
+  "age_cell_matched": 0.5033309709425939,
+  "inner": 0.6519,
+  "stages": 2
+ },
+ "3-term BOOST single-sum fields nu=0.1": {
+  "held": 0.6317839582498853,
+  "age_cell_matched": 0.5035294117647059,
+  "inner": 0.6521,
+  "stages": 2
+ },
+ "3-term BOOST single-sum fields nu=0.3": {
+  "held": 0.6318925131920378,
+  "age_cell_matched": 0.5050885896527285,
+  "inner": 0.6509,
+  "stages": 2
+ },
+ "3-term SPLIT per body (14 single sums), linear head": {
+  "held": 0.6351961825812856,
+  "age_cell_matched": 0.5039829907866761,
+  "inner": 0.6486
+ },
+ "3-term SPLIT per body -> LightGBM on the 14 intensities": {
+  "held": 0.6255905214700778,
+  "age_cell_matched": 0.4813607370659107
+ },
+ "3-term SPLIT per body -> LightGBM on intensities + plain columns": {
+  "held": 0.6212007221515938,
+  "age_cell_matched": 0.4757193479801559
+ },
+ "3-term BOOST over SPLIT per body (stage k -> group k)": {
+  "held": 0.6329722575364414,
+  "age_cell_matched": 0.4968674698795181,
+  "inner": 0.6474,
+  "stages": 8
+ },
+ "3-term SPLIT per term (3 single sums), linear head": {
+  "held": 0.6183614589319819,
+  "age_cell_matched": 0.4951381998582566,
+  "inner": 0.6484
+ },
+ "3-term SPLIT per term -> LightGBM on the 3 intensities": {
+  "held": 0.6181725036717113,
+  "age_cell_matched": 0.5008929836995039
+ },
+ "3-term SPLIT per term -> LightGBM on intensities + plain columns": {
+  "held": 0.6203479563225998,
+  "age_cell_matched": 0.48731396172927
+ },
+ "3-term BOOST over SPLIT per term (stage k -> group k)": {
+  "held": 0.6335063246315227,
+  "age_cell_matched": 0.49992912827781716,
+  "inner": 0.6463,
+  "stages": 5
+ },
+ "3-term SPLIT per phasor (42 single sums), linear head": {
+  "held": 0.6407121668611367,
+  "age_cell_matched": 0.5141318214032601,
+  "inner": 0.6503
+ },
+ "3-term SPLIT per phasor -> LightGBM on the 42 intensities": {
+  "held": 0.6297069016561885,
+  "age_cell_matched": 0.506392629340893
+ },
+ "3-term SPLIT per phasor -> LightGBM on intensities + plain columns": {
+  "held": 0.626497274516292,
+  "age_cell_matched": 0.4992487597448618
+ },
+ "3-term BOOST over SPLIT per phasor (stage k -> group k)": {
+  "held": 0.6388313218741111,
+  "age_cell_matched": 0.5225797306874557,
+  "inner": 0.6385,
+  "stages": 36
+ },
+ "6-term single ArtaModel F=1": {
+  "held": 0.5807439786837568,
+  "age_cell_matched": 0.5120056697377746,
+  "inner": 0.5655
+ },
+ "6-term BAG 25 bootstraps (rank-average)": {
+  "held": 0.6020613828854716,
+  "age_cell_matched": 0.4871438695960312,
+  "inner_mean": 0.5876
+ },
+ "6-term BOOST single-sum fields nu=0.05": {
+  "held": 0.5964200089398187,
+  "age_cell_matched": 0.4888164422395464,
+  "inner": 0.6332,
+  "stages": 47
+ },
+ "6-term BOOST single-sum fields nu=0.1": {
+  "held": 0.5991878697108491,
+  "age_cell_matched": 0.5050885896527285,
+  "inner": 0.6426,
+  "stages": 41
+ },
+ "6-term BOOST single-sum fields nu=0.3": {
+  "held": 0.5904163981818499,
+  "age_cell_matched": 0.4670446491849752,
+  "inner": 0.6599,
+  "stages": 47
+ },
+ "6-term SPLIT per body (14 single sums), linear head": {
+  "held": 0.6146363409437894,
+  "age_cell_matched": 0.49250177179305454,
+  "inner": 0.6461
+ },
+ "6-term SPLIT per body -> LightGBM on the 14 intensities": {
+  "held": 0.6027858565101037,
+  "age_cell_matched": 0.4847909284195606
+ },
+ "6-term SPLIT per body -> LightGBM on intensities + plain columns": {
+  "held": 0.6176416293690462,
+  "age_cell_matched": 0.48022678951098513
+ },
+ "6-term BOOST over SPLIT per body (stage k -> group k)": {
+  "held": 0.6300691384685045,
+  "age_cell_matched": 0.4945428773919206,
+  "inner": 0.6547,
+  "stages": 21
+ },
+ "6-term SPLIT per term (6 single sums), linear head": {
+  "held": 0.617382142421762,
+  "age_cell_matched": 0.4898086463501063,
+  "inner": 0.6499
+ },
+ "6-term SPLIT per term -> LightGBM on the 6 intensities": {
+  "held": 0.6170651852109855,
+  "age_cell_matched": 0.4919631467044649
+ },
+ "6-term SPLIT per term -> LightGBM on intensities + plain columns": {
+  "held": 0.6190958011877188,
+  "age_cell_matched": 0.4944578313253012
+ },
+ "6-term BOOST over SPLIT per term (stage k -> group k)": {
+  "held": 0.6311959039375838,
+  "age_cell_matched": 0.49593196314670446,
+  "inner": 0.6484,
+  "stages": 24
+ },
+ "6-term SPLIT per phasor (84 single sums), linear head": {
+  "held": 0.6108618798000731,
+  "age_cell_matched": 0.4908008504606662,
+  "inner": 0.635
+ },
+ "6-term SPLIT per phasor -> LightGBM on the 84 intensities": {
+  "held": 0.6084115567475314,
+  "age_cell_matched": 0.48289156626506025
+ },
+ "6-term SPLIT per phasor -> LightGBM on intensities + plain columns": {
+  "held": 0.6225875550756692,
+  "age_cell_matched": 0.4939759036144578
+ },
+ "6-term BOOST over SPLIT per phasor (stage k -> group k)": {
+  "held": 0.6400434219768609,
+  "age_cell_matched": 0.5133380581148121,
+  "inner": 0.6359,
+  "stages": 40
+ },
+ "REFERENCE plain columns (two ages, gap, start year), LightGBM": {
+  "held": 0.6331707911739608,
+  "age_cell_matched": 0.5098086463501063
+ }
+}

artamodel_ensemble.py

@@ -0,0 +1,270 @@
+"""
+artamodel_ensemble.py — ArtaModel as ensembles, as boosting, and as SPLIT single-sum models.
+
+Arash, 2026-08-18: "use ensembles and boosting techniques and split multiple single sum model".
+
+  BAG      many ArtaModels (F=1, the literal formula), each on a bootstrap of the rows with its own seed; the
+           held-out scores rank-averaged. Variance reduction for the one-field fit.
+  BOOST    functional gradient boosting whose weak learner is ONE single-sum field |b + Σ_j w_j z_j|²: at each
+           stage the field is fitted by least squares to the current pseudo-residuals of the logistic loss
+           (r = y − p), scaled by a line-searched coefficient, shrunk by ν, and added; early-stopped on the inner
+           temporal split. Each stage is a complete ArtaModel-shaped sum; the model is a sum of K such squares.
+  SPLIT    the phasors partitioned into groups G_k -- per BODY (each body's own terms), per TERM TYPE (all bodies
+           of one term), or per body×term (single phasors) -- and every group given its OWN single-sum field whose
+           weights are masked to the group. The K intensities are combined (i) by a linear head (the coherent
+           model with a block-diagonal weight matrix), and (ii) by LightGBM on the K intensities -- boosting over
+           the split single-sum models -- with the plain columns optionally beside them.
+
+Everything on the FULL population unless stated (both natal charts + the wedding day known: 6,258 train / 2,635
+held out), the same protocol as the study: choices on the inner temporal split, held out read for the record,
+the age-cell-matched control beside every headline.
+
+Usage: AQ_PHASES=/tmp/aq3feat/phases.npz AQ_SOL=/tmp/aq3comp/solution.csv AQ_OUT=/tmp/aq3feat python artamodel_ensemble.py
+"""
+import json
+import os
+import sys
+import time
+
+import numpy as np
+import pandas as pd
+from scipy.stats import rankdata
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+sys.path.insert(0, os.path.join(HERE, "..", "coherent"))
+from artamodel import ANGLES, BODIES14, TERMS, ArtaModel, auc, phase_matrix       # noqa: E402
+from coherent_fit import Coherent                                                    # noqa: E402
+
+PH = os.environ.get("AQ_PHASES", "/tmp/aq3feat/phases.npz")
+SOL = os.environ.get("AQ_SOL", "/tmp/aq3comp/solution.csv")
+OUT = os.environ.get("AQ_OUT", "/tmp/aq3feat")
+T0 = time.time()
+R = {}
+
+
+def log(*a):
+    print(f"[{time.time()-T0:6.0f}s]", *a, flush=True)
+
+
+def r01(v):
+    r = rankdata(v); return (r - 1) / max(1.0, len(r) - 1)
+
+
+def cs(P):
+    rad = np.pi / 180.0
+    return np.nan_to_num(np.cos(P * rad)), np.nan_to_num(np.sin(P * rad))
+
+
+def matched(y, s, cell):
+    num = den = 0.0
+    for b in np.unique(cell):
+        m = cell == b; n1, n0 = int(y[m].sum()), int((1 - y[m]).sum())
+        if n1 and n0:
+            num += auc(y[m], s[m]) * n1 * n0; den += n1 * n0
+    return num / den if den else float("nan")
+
+
+# ── one single-sum field fitted by LEAST SQUARES to a residual (the boosting weak learner) ─────────────────────
+class Field:
+    """u(x) = |b + Σ_j w_j z_j|², w and b complex, fitted so that α·u + c ≈ r by Adam on the squared error."""
+
+    def __init__(self, K, seed, mask=None):
+        g = np.random.default_rng(seed)
+        sc = 1.0 / np.sqrt(K)
+        self.A1 = g.normal(0, sc, K); self.A2 = g.normal(0, sc, K)
+        self.br, self.bi = g.normal(0, 0.3), g.normal(0, 0.3)
+        self.alpha, self.c = 0.0, 0.0
+        self.mask = np.ones(K) if mask is None else mask.astype(float)
+        self.A1 *= self.mask; self.A2 *= self.mask
+        self.m = {k: 0.0 for k in ("A1", "A2", "br", "bi", "alpha", "c")}; self.v = dict(self.m); self.t = 0
+
+    def u(self, C, S):
+        Zr = C @ self.A1 + S @ self.A2 + self.br
+        Zi = S @ self.A1 - C @ self.A2 + self.bi
+        return Zr * Zr + Zi * Zi, Zr, Zi
+
+    def fit(self, C, S, r, C_in, S_in, r_in, lr=0.02, steps=300, patience=40, l2=1e-3):
+        best, state, bad = np.inf, None, 0
+        for t in range(steps):
+            u, Zr, Zi = self.u(C, S)
+            pred = self.alpha * u + self.c
+            e = pred - r                                   # d(0.5*mse)/dpred, per row / n
+            n = len(r)
+            g_alpha = float((e * u).mean()); g_c = float(e.mean())
+            gu = e * self.alpha / n                        # dL/du
+            gr, gi = 2.0 * gu * Zr, 2.0 * gu * Zi
+            gA1 = (gr @ C + gi @ S) * self.mask + l2 * self.A1
+            gA2 = (gr @ S - gi @ C) * self.mask + l2 * self.A2
+            gbr, gbi = float(gr.sum()), float(gi.sum())
+            self.t += 1
+            for k, gval in (("A1", gA1), ("A2", gA2), ("br", gbr), ("bi", gbi), ("alpha", g_alpha), ("c", g_c)):
+                self.m[k] = 0.9 * self.m[k] + 0.1 * gval; self.v[k] = 0.999 * self.v[k] + 0.001 * (gval * gval)
+                mh = self.m[k] / (1 - 0.9 ** self.t); vh = self.v[k] / (1 - 0.999 ** self.t)
+                setattr(self, k, getattr(self, k) - lr * mh / (np.sqrt(vh) + 1e-8))
+            if t % 5 == 0:
+                ui, _, _ = self.u(C_in, S_in)
+                loss_in = float(np.mean((self.alpha * ui + self.c - r_in) ** 2))
+                if loss_in < best - 1e-7:
+                    best, bad = loss_in, 0
+                    state = (self.A1.copy(), self.A2.copy(), self.br, self.bi, self.alpha, self.c)
+                else:
+                    bad += 5
+                    if bad >= patience:
+                        break
+        if state is not None:
+            self.A1, self.A2, self.br, self.bi, self.alpha, self.c = state
+        return self
+
+    def predict(self, C, S):
+        u, _, _ = self.u(C, S)
+        return self.alpha * u + self.c
+
+
+def boost(P, y, inner, Pte, stages=60, nu=0.1, seed=0, masks=None):
+    """Gradient boosting with single-sum fields. `masks` (optional list) restricts stage k's field to a group,
+    cycling through the groups -- the SPLIT models boosted in turn."""
+    C, S = cs(P); Cte, Ste = cs(Pte)
+    fit = ~inner
+    F = np.zeros(len(y)); Fte = np.zeros(len(Pte))
+    p0 = np.clip(y[fit].mean(), 1e-3, 1 - 1e-3); F[:] = np.log(p0 / (1 - p0)); Fte[:] = F[0]
+    best, best_stage, bad, best_Fte = -1.0, 0, 0, Fte.copy()
+    for k in range(stages):
+        p = 1 / (1 + np.exp(-F)); r = y - p
+        mask = None if masks is None else masks[k % len(masks)]
+        f = Field(C.shape[1], seed * 1000 + k, mask).fit(C[fit], S[fit], r[fit], C[inner], S[inner], r[inner])
+        h = f.predict(C, S); hte = f.predict(Cte, Ste)
+        # line search of the step on the logistic loss over the fit rows
+        best_g, best_loss = 0.0, np.inf
+        for gam in (0.25, 0.5, 1.0, 2.0, 4.0):
+            Fx = F[fit] + nu * gam * h[fit]
+            loss = float(np.mean(np.logaddexp(0, -Fx * (2 * y[fit] - 1))))
+            if loss < best_loss:
+                best_loss, best_g = loss, gam
+        F = F + nu * best_g * h; Fte = Fte + nu * best_g * hte
+        a = auc(y[inner], F[inner])
+        if a > best + 1e-5:
+            best, best_stage, bad, best_Fte = a, k + 1, 0, Fte.copy()
+        else:
+            bad += 1
+            if bad >= 10:
+                break
+    return best, best_stage, best_Fte
+
+
+def split_heads(P, y, inner, Pte, groups, F_seed=0):
+    """SPLIT single-sum models with a LINEAR head: one field per group, weights masked to the group, K intensities
+    combined by the coherent model's own head. Returns (inner auc, held-out score, K intensities train/test)."""
+    C, S = cs(P); Cte, Ste = cs(Pte)
+    K = C.shape[1]; G = len(groups)
+    m = Coherent(K, G, seed=F_seed)
+    M = np.zeros((G, K))
+    for gi, cols in enumerate(groups):
+        M[gi, cols] = 1.0
+    m.A1 *= M; m.A2 *= M
+    rng = np.random.default_rng(7 + F_seed); idx = np.where(~inner)[0]
+    batch = int(min(1024, max(32, len(idx) // 16)))
+    best, state, bad = -1.0, None, 0
+    for ep in range(150):
+        rng.shuffle(idx)
+        for s0 in range(0, len(idx), batch):
+            b = idx[s0:s0 + batch]
+            if len(b) >= 32:
+                m.step(C[b], S[b], y[b].astype(float), 0.01, 1e-3)
+                m.A1 *= M; m.A2 *= M                       # keep every field inside its group
+        a = auc(y[inner], m.logit(C[inner], S[inner])[0])
+        if a > best + 1e-5:
+            best, bad = a, 0
+            state = (m.A1.copy(), m.A2.copy(), m.br.copy(), m.bi.copy(), m.w.copy(), m.c, m.mu.copy(), m.sd.copy())
+        else:
+            bad += 1
+            if bad >= 15:
+                break
+    m.A1, m.A2, m.br, m.bi, m.w, m.c, m.mu, m.sd = state
+    return best, m.logit(Cte, Ste)[0], m.fields(C, S)[2], m.fields(Cte, Ste)[2]
+
+
+def main():
+    import lightgbm as lgb
+    Z = np.load(PH, allow_pickle=True)
+    bodies = list(Z["bodies"]); ids = Z["id_test"]; ytr = Z["y_train"].astype(np.int64)
+    Dtr, Mtr, Wtr = Z["theta_dad_train"], Z["theta_mom_train"], Z["theta_wed_train"]
+    Dte, Mte, Wte = Z["theta_dad_test"], Z["theta_mom_test"], Z["theta_wed_test"]
+    ptr, pte, pn = Z["plain_train"], Z["plain_test"], list(Z["plain_names"])
+    later = Z["yr_train"].astype(int).max(1)
+    sol = pd.read_csv(SOL).set_index("id"); lab = [c for c in sol.columns if c != "Usage"][0]
+    yte = sol.loc[ids, lab].to_numpy().astype(int)
+    j1 = ptr[:, pn.index("start_is_jan1")] == 1.0; j1e = pte[:, pn.index("start_is_jan1")] == 1.0
+    Wtr = Wtr.copy(); Wte = Wte.copy(); Wtr[j1] = np.nan; Wte[j1e] = np.nan
+    B = [bodies.index(b) for b in BODIES14]
+    full_tr = np.isfinite(Dtr[:, B]).all(1) & np.isfinite(Mtr[:, B]).all(1) & np.isfinite(Wtr[:, B]).all(1)
+    full_te = np.isfinite(Dte[:, B]).all(1) & np.isfinite(Mte[:, B]).all(1) & np.isfinite(Wte[:, B]).all(1)
+    ages_te = pte[full_te][:, [pn.index("age_dad_at_start"), pn.index("age_mom_at_start")]]
+    cell = (np.floor(ages_te[:, 0] / 3) * 1000 + np.floor(ages_te[:, 1] / 3)).astype(int)
+    y = ytr[full_tr]; ye = yte[full_te]; lat = later[full_tr]; inner = lat > np.quantile(lat, 0.85)
+    log(f"FULL population: train {len(y):,} (inner {int(inner.sum()):,}) · held out {len(ye):,}")
+    cols = [pn.index(c) for c in ("age_dad_at_start", "age_mom_at_start", "age_gap", "start_year")]
+    Xp_tr, Xp_te = ptr[full_tr][:, cols], pte[full_te][:, cols]
+
+    def report(name, s, extra=None):
+        a = auc(ye, s); m_ = matched(ye, s, cell)
+        R[name] = {"held": a, "age_cell_matched": m_, **(extra or {})}
+        log(f"  {name:<58} held {a:.4f}   age-cell-matched {m_:.4f}" + (f"   {extra}" if extra else ""))
+
+    for terms, tag in ((("a", "m", "d"), "3-term"), (TERMS, "6-term")):
+        P, labels = phase_matrix(Dtr, Mtr, Wtr, bodies, BODIES14, terms); Pe, _ = phase_matrix(Dte, Mte, Wte, bodies, BODIES14, terms)
+        P, Pe = P[full_tr], Pe[full_te]
+        log(f"── {tag}: {len(labels)} phasors ──")
+        # single ArtaModel, F=1 (the reference point)
+        am = ArtaModel(terms=terms, bodies=BODIES14, F=1).fit(P, y, inner)
+        report(f"{tag} single ArtaModel F=1", am.score(Pe), {"inner": round(am.inner_auc, 4)})
+        # BAG: 25 bootstraps x seeds, rank-averaged
+        rng = np.random.default_rng(0); scores = []; ivs = []
+        fit_idx = np.where(~inner)[0]
+        for b in range(25):
+            boot = rng.choice(fit_idx, size=len(fit_idx), replace=True)
+            keep = np.concatenate([boot, np.where(inner)[0]])
+            inn = np.zeros(len(keep), bool); inn[len(boot):] = True
+            a_ = ArtaModel(terms=terms, bodies=BODIES14, F=1, seed=b).fit(P[keep], y[keep], inn)
+            scores.append(r01(a_.score(Pe))); ivs.append(a_.inner_auc)
+        report(f"{tag} BAG 25 bootstraps (rank-average)", np.mean(scores, 0), {"inner_mean": round(float(np.mean(ivs)), 4)})
+        # BOOST: single-sum fields on residuals
+        for nu in (0.05, 0.1, 0.3):
+            iv, K, s = boost(P, y, inner, Pe, stages=60, nu=nu)
+            report(f"{tag} BOOST single-sum fields nu={nu}", s, {"inner": round(iv, 4), "stages": K})
+        # SPLIT: groups per body / per term / per phasor
+        by_body = [[k for k, l in enumerate(labels) if l.split("_", 1)[1] == b] for b in BODIES14]
+        by_term = [[k for k, l in enumerate(labels) if l.split("_", 1)[0] == t] for t in terms]
+        by_phasor = [[k] for k in range(len(labels))]
+        for gname, groups in (("per body", by_body), ("per term", by_term), ("per phasor", by_phasor)):
+            groups = [g for g in groups if g]
+            iv, s, Utr, Ute = split_heads(P, y, inner, Pe, groups)
+            report(f"{tag} SPLIT {gname} ({len(groups)} single sums), linear head", s, {"inner": round(iv, 4)})
+            # LightGBM on the K intensities (boosting over the split models), plus with the plain columns
+            def gbm(Xtr, Xte, seeds=3):
+                p = np.zeros(len(Xte))
+                for sd in range(seeds):
+                    c = lgb.LGBMClassifier(n_estimators=300, learning_rate=0.03, num_leaves=7, min_child_samples=50, colsample_bytree=0.8,
+                                           subsample=0.8, subsample_freq=1, reg_lambda=10.0, random_state=sd, verbose=-1)
+                    c.fit(Xtr[~inner], y[~inner]); p += c.predict_proba(Xte)[:, 1]
+                return p / seeds
+            report(f"{tag} SPLIT {gname} -> LightGBM on the {len(groups)} intensities", gbm(Utr, Ute))
+            report(f"{tag} SPLIT {gname} -> LightGBM on intensities + plain columns", gbm(np.column_stack([Utr, Xp_tr]), np.column_stack([Ute, Xp_te])))
+            # boosting the split models in turn (each stage restricted to one group)
+            masks = [np.isin(np.arange(len(labels)), g) for g in groups]
+            iv, K, s = boost(P, y, inner, Pe, stages=min(120, 4 * len(groups)), nu=0.1, masks=masks)
+            report(f"{tag} BOOST over SPLIT {gname} (stage k -> group k)", s, {"inner": round(iv, 4), "stages": K})
+    # references on the same rows
+    def gbm_plain(seeds=3):
+        p = np.zeros(len(Xp_te))
+        for sd in range(seeds):
+            c = lgb.LGBMClassifier(n_estimators=300, learning_rate=0.03, num_leaves=7, min_child_samples=50, reg_lambda=10.0, random_state=sd, verbose=-1)
+            c.fit(Xp_tr[~inner], y[~inner]); p += c.predict_proba(Xp_te)[:, 1]
+        return p / seeds
+    report("REFERENCE plain columns (two ages, gap, start year), LightGBM", gbm_plain())
+    json.dump(R, open(os.path.join(OUT, "artamodel_ensemble.json"), "w"), indent=1)
+    log(f"wrote {OUT}/artamodel_ensemble.json")
+
+
+if __name__ == "__main__":
+    main()

artamodel_leaderboard.json

@@ -0,0 +1,435 @@
+{
+ "F0": -0.2510023573758644,
+ "stages": [
+  {
+   "stage": 1,
+   "phasor": 35,
+   "step": 0.4,
+   "alpha": 0.2790609079021399,
+   "c": -0.3139164088718358,
+   "w_re": 0.16544682051025963,
+   "w_im": -0.2717536379569562,
+   "b_re": 0.8537051175935859,
+   "b_im": 0.39014440491816765
+  },
+  {
+   "stage": 2,
+   "phasor": 35,
+   "step": 0.4,
+   "alpha": -0.4383853720692169,
+   "c": 0.1173512689580232,
+   "w_re": 0.23249329816544284,
+   "w_im": -0.4510036636235923,
+   "b_re": -0.4312355863893404,
+   "b_im": -0.4544389464444736
+  },
+  {
+   "stage": 3,
+   "phasor": 35,
+   "step": 0.4,
+   "alpha": 0.34994675789562907,
+   "c": -0.25146824654007244,
+   "w_re": 0.18318691499995837,
+   "w_im": -0.21215918714332932,
+   "b_re": 0.6088484312579715,
+   "b_im": 0.4163709198609787
+  },
+  {
+   "stage": 4,
+   "phasor": 37,
+   "step": 0.4,
+   "alpha": -0.5820355837861616,
+   "c": 0.22526205078391126,
+   "w_re": 0.5689653288215984,
+   "w_im": 0.257394190037747,
+   "b_re": -0.6536070580939775,
+   "b_im": -0.07819744063532238
+  },
+  {
+   "stage": 5,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.30902073901399696,
+   "c": -0.36656379703454534,
+   "w_re": 0.45093515109026966,
+   "w_im": 0.31784612820100994,
+   "b_re": 0.45797385423834874,
+   "b_im": 0.41008636025743916
+  },
+  {
+   "stage": 6,
+   "phasor": 35,
+   "step": 0.4,
+   "alpha": -0.2888845705269212,
+   "c": 0.08357975402566378,
+   "w_re": -0.4427115061786578,
+   "w_im": -0.32150984551227346,
+   "b_re": -0.5324306908841805,
+   "b_im": 0.37366357041275694
+  },
+  {
+   "stage": 7,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": -0.3380538185780996,
+   "c": 0.07942775223701656,
+   "w_re": 0.16686411043437596,
+   "w_im": -0.3506490103077557,
+   "b_re": -0.3456586276390284,
+   "b_im": 0.6182341239570788
+  },
+  {
+   "stage": 8,
+   "phasor": 37,
+   "step": 0.4,
+   "alpha": 0.7608792714926302,
+   "c": -0.31757565826834183,
+   "w_re": 0.046712674010060504,
+   "w_im": 0.3424069935800981,
+   "b_re": 0.5909948084345692,
+   "b_im": 0.19999181642194766
+  },
+  {
+   "stage": 9,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.2069111011215517,
+   "c": -0.20882936021322604,
+   "w_re": 0.21655920000025589,
+   "w_im": 0.43361399974882253,
+   "b_re": 0.33203701914438416,
+   "b_im": 0.52191876376675
+  },
+  {
+   "stage": 10,
+   "phasor": 35,
+   "step": 0.4,
+   "alpha": -0.21006169984120804,
+   "c": 0.05482326858295784,
+   "w_re": -0.1737283486567377,
+   "w_im": -0.34326716773408406,
+   "b_re": -0.6237033604178058,
+   "b_im": 0.10437845863523815
+  },
+  {
+   "stage": 11,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": -0.23596001023735938,
+   "c": 0.04793709815026776,
+   "w_re": 0.3042775595950708,
+   "w_im": 0.30411728121014864,
+   "b_re": -0.478025576284314,
+   "b_im": -0.4066299078084681
+  },
+  {
+   "stage": 12,
+   "phasor": 37,
+   "step": 0.4,
+   "alpha": -0.49022519323754793,
+   "c": 0.144709174758613,
+   "w_re": 0.4483943171312746,
+   "w_im": 0.1747243976256867,
+   "b_re": -0.5769310079468398,
+   "b_im": 0.0007063262364112111
+  },
+  {
+   "stage": 13,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.325753320229801,
+   "c": -0.2413198050073399,
+   "w_re": -0.121212586683471,
+   "w_im": 0.3900741494361323,
+   "b_re": -0.23218812289357832,
+   "b_im": 0.44633056636642404
+  },
+  {
+   "stage": 14,
+   "phasor": 35,
+   "step": 0.4,
+   "alpha": 0.13939712628885229,
+   "c": -0.04283992755583811,
+   "w_re": 0.1941305187432573,
+   "w_im": 0.19793528765528204,
+   "b_re": -0.39677061320341045,
+   "b_im": 0.2534717678746568
+  },
+  {
+   "stage": 15,
+   "phasor": 35,
+   "step": 0.4,
+   "alpha": -0.27729186832613145,
+   "c": 0.037781545123303596,
+   "w_re": 0.3742135911064377,
+   "w_im": 0.19413612657427187,
+   "b_re": 0.36760760197091547,
+   "b_im": -0.3070663472768141
+  },
+  {
+   "stage": 16,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.31146526208193726,
+   "c": -0.1487809462855659,
+   "w_re": -0.192228284814361,
+   "w_im": -0.28050912477619155,
+   "b_re": -0.19882723914785924,
+   "b_im": -0.3321859480783824
+  },
+  {
+   "stage": 17,
+   "phasor": 23,
+   "step": 0.4,
+   "alpha": -0.691962297005292,
+   "c": 0.2236726300021271,
+   "w_re": -0.3092392733341191,
+   "w_im": -0.05190284634462815,
+   "b_re": 0.492181263258386,
+   "b_im": -0.3103055227978361
+  },
+  {
+   "stage": 18,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.16678699025239196,
+   "c": -0.16240030753693468,
+   "w_re": -0.3747982735844348,
+   "w_im": 0.20475879054311819,
+   "b_re": -0.5659027944892202,
+   "b_im": 0.26445255364285103
+  },
+  {
+   "stage": 19,
+   "phasor": 20,
+   "step": 0.4,
+   "alpha": -0.008164434660184142,
+   "c": 0.004119182828503224,
+   "w_re": 0.03561037285156963,
+   "w_im": -0.06353276553290359,
+   "b_re": 0.39095817474270683,
+   "b_im": 0.19986673296932997
+  },
+  {
+   "stage": 20,
+   "phasor": 20,
+   "step": 0.4,
+   "alpha": -0.030576049347266418,
+   "c": 0.0035432005553962245,
+   "w_re": 0.02337541497072417,
+   "w_im": 0.1005538166637217,
+   "b_re": -0.328467058088797,
+   "b_im": -0.07539161972439071
+  },
+  {
+   "stage": 21,
+   "phasor": 20,
+   "step": 0.4,
+   "alpha": -0.041398339698101916,
+   "c": 0.005465754070426186,
+   "w_re": -0.04476609738232852,
+   "w_im": 0.16635825257857076,
+   "b_re": -0.36087450832523327,
+   "b_im": 0.11152443285731284
+  },
+  {
+   "stage": 22,
+   "phasor": 20,
+   "step": 0.4,
+   "alpha": -0.11380137146366145,
+   "c": 0.0025476058309119856,
+   "w_re": 0.028256324530831264,
+   "w_im": 0.11653345741523358,
+   "b_re": -0.190184525777227,
+   "b_im": 0.03714923525546911
+  },
+  {
+   "stage": 23,
+   "phasor": 20,
+   "step": 0.4,
+   "alpha": 0.07341465288887274,
+   "c": -0.0203333671124774,
+   "w_re": -0.20880220908325148,
+   "w_im": 0.1716401560852639,
+   "b_re": 0.1857565062932319,
+   "b_im": 0.3755205575990392
+  },
+  {
+   "stage": 24,
+   "phasor": 23,
+   "step": 0.025,
+   "alpha": 0.0025675604826571764,
+   "c": 0.0022698323283945818,
+   "w_re": 0.011667472114586163,
+   "w_im": -0.020929803493994557,
+   "b_re": -0.25044814787217995,
+   "b_im": -0.0264954757651408
+  },
+  {
+   "stage": 25,
+   "phasor": 23,
+   "step": 0.4,
+   "alpha": 0.3855542289770793,
+   "c": -0.13300980650958877,
+   "w_re": 0.13279384507466938,
+   "w_im": -0.47334365600013123,
+   "b_re": -0.5190000169171142,
+   "b_im": -0.21912983674650482
+  },
+  {
+   "stage": 26,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": 0.21921044511589627,
+   "c": -0.13913509144130914,
+   "w_re": -0.288981646771367,
+   "w_im": -0.240467983713006,
+   "b_re": -0.3286717045240301,
+   "b_im": -0.3357175537050057
+  },
+  {
+   "stage": 27,
+   "phasor": 20,
+   "step": 0.4,
+   "alpha": -0.01729559500497132,
+   "c": 0.010603586888993247,
+   "w_re": -0.0045418174252236584,
+   "w_im": 0.14429496669740433,
+   "b_re": -0.7289771467179822,
+   "b_im": -0.15110922925003778
+  },
+  {
+   "stage": 28,
+   "phasor": 20,
+   "step": 0.025,
+   "alpha": 0.0029503938352781556,
+   "c": -0.00016868347221038905,
+   "w_re": 0.031818447407431213,
+   "w_im": -0.02925275766963477,
+   "b_re": 0.030685508507719773,
+   "b_im": 0.3222325568984256
+  },
+  {
+   "stage": 29,
+   "phasor": 20,
+   "step": 0.4,
+   "alpha": -0.023699637641509487,
+   "c": 0.0020922555094313056,
+   "w_re": 0.07045111449166673,
+   "w_im": -0.018005944379729466,
+   "b_re": 0.07080146794410015,
+   "b_im": 0.31108100653071213
+  },
+  {
+   "stage": 30,
+   "phasor": 20,
+   "step": 0.4,
+   "alpha": -0.10109300198626403,
+   "c": 0.009361324814773427,
+   "w_re": 0.12728831587213713,
+   "w_im": -0.1667525087363923,
+   "b_re": 0.22393090550322364,
+   "b_im": 0.2799110350682605
+  },
+  {
+   "stage": 31,
+   "phasor": 7,
+   "step": 0.4,
+   "alpha": -0.32826538527588905,
+   "c": 0.03560517815619409,
+   "w_re": 0.23684967687092165,
+   "w_im": -0.16335650143836847,
+   "b_re": -0.4854325733136111,
+   "b_im": 0.20263486662597754
+  }
+ ],
+ "inner_auc": 0.631962843164345,
+ "labels": [
+  "a_sun",
+  "a_moon",
+  "a_mercury",
+  "a_venus",
+  "a_mars",
+  "a_jupiter",
+  "a_saturn",
+  "a_uranus",
+  "a_neptune",
+  "a_pluto",
+  "a_true_node",
+  "a_true_south_node",
+  "a_chiron",
+  "a_mean_lilith",
+  "m_sun",
+  "m_moon",
+  "m_mercury",
+  "m_venus",
+  "m_mars",
+  "m_jupiter",
+  "m_saturn",
+  "m_uranus",
+  "m_neptune",
+  "m_pluto",
+  "m_true_node",
+  "m_true_south_node",
+  "m_chiron",
+  "m_mean_lilith",
+  "d_sun",
+  "d_moon",
+  "d_mercury",
+  "d_venus",
+  "d_mars",
+  "d_jupiter",
+  "d_saturn",
+  "d_uranus",
+  "d_neptune",
+  "d_pluto",
+  "d_true_node",
+  "d_true_south_node",
+  "d_chiron",
+  "d_mean_lilith",
+  "mn_sun",
+  "mn_moon",
+  "mn_mercury",
+  "mn_venus",
+  "mn_mars",
+  "mn_jupiter",
+  "mn_saturn",
+  "mn_uranus",
+  "mn_neptune",
+  "mn_pluto",
+  "mn_true_node",
+  "mn_true_south_node",
+  "mn_chiron",
+  "mn_mean_lilith",
+  "dn_sun",
+  "dn_moon",
+  "dn_mercury",
+  "dn_venus",
+  "dn_mars",
+  "dn_jupiter",
+  "dn_saturn",
+  "dn_uranus",
+  "dn_neptune",
+  "dn_pluto",
+  "dn_true_node",
+  "dn_true_south_node",
+  "dn_chiron",
+  "dn_mean_lilith",
+  "tn_sun",
+  "tn_moon",
+  "tn_mercury",
+  "tn_venus",
+  "tn_mars",
+  "tn_jupiter",
+  "tn_saturn",
+  "tn_uranus",
+  "tn_neptune",
+  "tn_pluto",
+  "tn_true_node",
+  "tn_true_south_node",
+  "tn_chiron",
+  "tn_mean_lilith"
+ ],
+ "fitted_on": "train rows with both natal charts",
+ "n_rows": 9553
+}

artamodel_score.py

@@ -0,0 +1,107 @@
+"""
+artamodel_score.py — score a couple with the deployed ArtaModel, from three dates and two places. numpy only for
+the model; Kerykeion for the phases (pip install kerykeion timezonefinder).
+
+    from artamodel_score import predict
+    p = predict("1936-08-04", 37.943, 23.647, "1924-05-14", 37.727, 26.909, "1968-06-15")   # dad, mom, wedding
+
+Returns the probability that the marriage lasted thirty years, and the term-by-term account of how the logit was
+formed. See README.md / ARTAMODEL.md for what the model is and, honestly, what it reads.
+"""
+import json
+import os
+import warnings
+
+import numpy as np
+
+warnings.filterwarnings("ignore")
+HERE = os.path.dirname(os.path.abspath(__file__))
+MODEL = json.load(open(os.path.join(HERE, "artamodel_deployed.json")))
+BODIES = MODEL["bodies"]; TERMS = MODEL["terms"]; LABELS = MODEL["labels"]
+ANGLES = {"ascendant", "medium_coeli"}
+SLOW = {"jupiter", "saturn", "uranus", "neptune", "pluto", "true_node", "true_south_node", "chiron", "mean_lilith"}
+_TF = None
+
+
+def _tz(lat, lon):
+    global _TF
+    if _TF is None:
+        from timezonefinder import TimezoneFinder
+        _TF = TimezoneFinder()
+    return _TF.timezone_at(lng=lon, lat=lat) or "UTC"
+
+
+def _prec(d):
+    if not d or d == "0000-00-00":
+        return 0
+    return 1 if d.endswith("-00-00") else (2 if d.endswith("-00") else 3)
+
+
+def theta(date, lat=None, lon=None, hour=9, natal=True):
+    """Sidereal (Lahiri) longitudes of the model's bodies at 09:00 local (natal) or 12:00 UT (wedding); NaN where
+    the date's precision cannot place a body (year-only -> slow bodies only)."""
+    from kerykeion import AstrologicalSubject
+    out = np.full(len(BODIES), np.nan); p = _prec(date)
+    if p == 0 or (natal and (lat is None or lon is None)):
+        return out
+    y, m, d = int(date[:4]), max(1, int(date[5:7])), max(1, int(date[8:10]))
+    if natal:
+        s = AstrologicalSubject("x", y, m, d, hour, 0, lng=float(lon), lat=float(lat), tz_str=_tz(float(lat), float(lon)),
+                                city="x", nation="XX", zodiac_type="Sidereal", sidereal_mode="LAHIRI", online=False)
+    else:
+        s = AstrologicalSubject("w", y, m, d, 12, 0, lng=0.0, lat=51.48, tz_str="UTC", city="G", nation="GB",
+                                zodiac_type="Sidereal", sidereal_mode="LAHIRI", online=False)
+    for j, b in enumerate(BODIES):
+        if p == 1 and b not in SLOW:
+            continue
+        if p == 2 and b not in SLOW and b != "sun":
+            continue
+        try:
+            out[j] = float(getattr(s, b).abs_pos)
+        except Exception:
+            pass
+    return out
+
+
+def phases(td, tm, tw):
+    """The 84 phases in the model's label order (NaN = the term does not exist)."""
+    P = np.full(len(LABELS), np.nan)
+    col = {b: j for j, b in enumerate(BODIES)}
+    for k, lab in enumerate(LABELS):
+        t, b = lab.split("_", 1); j = col[b]
+        if t == "a": P[k] = tm[j] - td[j]
+        elif t == "m": P[k] = tw[j] - tm[j]
+        elif t == "d": P[k] = tw[j] - td[j]
+        elif t == "mn": P[k] = tm[j]
+        elif t == "dn": P[k] = td[j]
+        elif t == "tn": P[k] = tw[j]
+    return P
+
+
+def logit(P):
+    """The deployed model's logit for one phase vector, with the per-stage account."""
+    rad = np.pi / 180.0
+    C, S = np.nan_to_num(np.cos(P * rad)), np.nan_to_num(np.sin(P * rad))
+    F = MODEL["F0"]; account = []
+    for st in MODEL["stages"]:
+        j = st["phasor"]
+        if not np.isfinite(P[j]):
+            account.append({"stage": st["stage"], "phasor": LABELS[j], "contribution": 0.0, "note": "term absent for this couple"}); continue
+        Zr = st["w_re"] * C[j] - st["w_im"] * S[j] + st["b_re"]; Zi = st["w_re"] * S[j] + st["w_im"] * C[j] + st["b_im"]
+        u = Zr * Zr + Zi * Zi; contrib = st["step"] * (st["alpha"] * u + st["c"])
+        F += contrib; account.append({"stage": st["stage"], "phasor": LABELS[j], "phase_deg": float(P[j] % 360), "contribution": float(contrib)})
+    return float(F), account
+
+
+def predict(dob_dad, lat_dad, lon_dad, dob_mom, lat_mom, lon_mom, start):
+    wed = start if start[5:] != "01-01" else start[:4] + "-00-00"          # a 1 January start is a year-only record
+    P = phases(theta(dob_dad, lat_dad, lon_dad), theta(dob_mom, lat_mom, lon_mom), theta(wed, natal=False))
+    F, account = logit(P)
+    return {"probability": float(1 / (1 + np.exp(-F))), "logit": F, "terms": account}
+
+
+if __name__ == "__main__":
+    r = predict("1936-08-04", 37.943, 23.647, "1924-05-14", 37.727, 26.909, "1968-06-15")
+    print(f"  p(lasted 30 years) = {r['probability']:.3f}   logit {r['logit']:+.3f}")
+    for t in r["terms"][:8]:
+        print(f"    stage {t['stage']:>2}  {t['phasor']:<12} " + (f"φ={t['phase_deg']:6.1f}°  {t['contribution']:+.4f}" if "phase_deg" in t else t["note"]))

artamodel_selected.json

@@ -0,0 +1,66 @@
+{
+ "E1 term subsets (F=1)": {
+  "n_configs": 70,
+  "selected_by_inner": "E1 terms m+d",
+  "its_inner": 0.6426429599219167,
+  "its_held": 0.6303868028308671,
+  "max_held_in_family": 0.6318152802643866,
+  "optimism_if_selected_on_held": 0.0014284774335194816
+ },
+ "E1 F=8 rungs": {
+  "n_configs": 6,
+  "selected_by_inner": "E1 F8 terms a+m+d",
+  "its_inner": 0.6479533311196305,
+  "its_held": 0.621263016459523,
+  "max_held_in_family": 0.6310528484705769,
+  "optimism_if_selected_on_held": 0.009789832011053878
+ },
+ "E3 3-term body sets": {
+  "n_configs": 45,
+  "selected_by_inner": "E3 3-term drop chiron",
+  "its_inner": 0.6488664835330697,
+  "its_held": 0.6245990162840656,
+  "max_held_in_family": 0.6419098541279247,
+  "optimism_if_selected_on_held": 0.017310837843859117
+ },
+ "E3 6-term body sets": {
+  "n_configs": 45,
+  "selected_by_inner": "E3 6-term drop outer",
+  "its_inner": 0.6290387498616435,
+  "its_held": 0.584257082073676,
+  "max_held_in_family": 0.6404028825808864,
+  "optimism_if_selected_on_held": 0.05614580050721041
+ },
+ "E5 harmonics": {
+  "n_configs": 6,
+  "selected_by_inner": "E5 harmonic 2 terms a+m+d",
+  "its_inner": 0.6284878397279158,
+  "its_held": 0.628358653456569,
+  "max_held_in_family": 0.628358653456569,
+  "optimism_if_selected_on_held": 0.0
+ },
+ "E6 fields x L2": {
+  "n_configs": 28,
+  "selected_by_inner": "E6 3-term F=64 l2=0.01",
+  "its_inner": 0.651917871625361,
+  "its_held": 0.6163225046086434,
+  "max_held_in_family": 0.6364966461081348,
+  "optimism_if_selected_on_held": 0.020174141499491482
+ },
+ "E9 conventions, 3-term": {
+  "n_configs": 10,
+  "selected_by_inner": "E9 hour 12:00 UT, place ignored 3-term",
+  "its_inner": 0.6417071673659955,
+  "its_held": 0.6258785857669394,
+  "max_held_in_family": 0.625995749774618,
+  "optimism_if_selected_on_held": 0.00011716400767858293
+ },
+ "E9 conventions, 6-term": {
+  "n_configs": 10,
+  "selected_by_inner": "E9 TROPICAL 6-term",
+  "its_inner": 0.6041144685603888,
+  "its_held": 0.5941404144258329,
+  "max_held_in_family": 0.5941404144258329,
+  "optimism_if_selected_on_held": 0.0
+ }
+}

coherent_fit.py

@@ -0,0 +1,331 @@
+"""
+coherent_fit.py — FIT the coherent phasor field. Arash's form, with a, p and b learned rather than drawn.
+
+    F_f(chart) = | b_f + SUM_k w_fk * exp( i * h_k * theta_k ) |^2 ,    w_fk = a_fk * exp(-i * p_fk)
+
+THE REPARAMETERISATION, AND WHY IT MATTERS. Written in polar form the parameters are an amplitude a >= 0 and a
+phase p on a circle, and a gradient step on p has to be wrapped. Folding them into ONE COMPLEX WEIGHT
+w = a*exp(-i*p) removes both problems: the model becomes a complex linear map followed by a squared modulus, the
+parameter space is flat R^2 per term, and every gradient is a matmul. With A1 = Re w and A2 = -Im w,
+
+    Re S = C @ A1' + S_ @ A2'          Im S = S_ @ A1' - C @ A2'
+
+where C = cos(h*theta) and S_ = sin(h*theta) are the batch's basis. Nothing is approximated -- this is the same
+function, in coordinates that optimise cleanly.
+
+WHAT IS ACTUALLY BEING LEARNED. |b + sum w_k z_k|^2 expands to |b|^2 + 2*Re(b_bar * sum w_k z_k) + sum_jk
+w_j w_k_bar z_j z_k_bar. The last term is a QUADRATIC form in the chart's Fourier coefficients, so a bank of F
+fields is a rank-F quadratic model over every pairwise product of body phases -- every classical aspect, every
+harmonic of one, and every cross-partner contact, simultaneously, with the weights fitted. The bias term is what
+makes the field's response asymmetric rather than a pure interference pattern.
+
+The basis spans harmonics h in HARMONICS for every (partner-slot, body) pair, so a single field may mix
+harmonics. That is strictly more general than one harmonic per field, and it is the fit's business which to use.
+
+INNER VALIDATION IS TEMPORAL, NOT RANDOM. Early stopping on a random slice of the training half would select the
+iteration that generalises best to CONTEMPORARIES of the training data, which is not the question -- the real
+test is out of time. So the inner split holds out the LATEST births of the training half, mirroring the outer
+split. A random inner split measurably overfits the epoch count here.
+
+THE ONLY COMPARISON REPORTED is the two-parameter logistic on the age gap. Note a consequence of the dataset's
+own column definition: with the OLDER partner always first, the gap is non-negative by construction, so the
+signed form that distinguished man-older from woman-older is not expressible and is not claimed -- no sex is
+read anywhere in this dataset.
+
+Usage: AQ_LON=/tmp/aqcoh/lon.npz AQ_SET=fast AQ_FIELDS=64 python coherent_fit.py
+"""
+import json
+import os
+import sys
+import time
+
+import numpy as np
+
+T0 = time.time()
+
+HARMONICS = (1, 2, 3, 4, 6, 8, 12)
+SUN, MOON, MERCURY, VENUS, MARS, JUPITER, SATURN, URANUS, NEPTUNE, PLUTO = range(10)
+SETS = {
+    "fast": (SUN, MOON, MERCURY, VENUS, MARS),
+    "classical": (SUN, MOON, MERCURY, VENUS, MARS, JUPITER, SATURN),
+    "all18": tuple(range(18)),
+}
+iO, iY = 0, 1
+
+
+def log(*a):
+    print(f"[{time.time()-T0:6.1f}s]", *a, flush=True)
+
+
+def auc(y, s):
+    y = np.asarray(y, np.int64)
+    s = np.asarray(s, np.float64)
+    n1, n0 = int(y.sum()), int((1 - y).sum())
+    if n1 == 0 or n0 == 0:
+        return float("nan")
+    o = np.argsort(s, kind="mergesort")
+    ys, ss = y[o], s[o]
+    r = np.empty(len(ss))
+    i = 0
+    while i < len(ss):
+        j = i
+        while j + 1 < len(ss) and ss[j + 1] == ss[i]:
+            j += 1
+        r[i:j + 1] = 0.5 * (i + j) + 1.0
+        i = j + 1
+    return float((r[ys == 1].sum() - n1 * (n1 + 1) / 2.0) / (n1 * n0))
+
+
+# Mean daily motion in degrees, for the orb filter below. Only the ten classical/modern bodies are ever used
+# with a harmonic filter; the asteroids and nodes are slow and unaffected.
+DAILY = {SUN: 0.9856, MOON: 13.176, MERCURY: 4.09, VENUS: 1.60, MARS: 0.524, JUPITER: 0.083,
+         SATURN: 0.0335, URANUS: 0.0117, NEPTUNE: 0.006, PLUTO: 0.004}
+
+
+def basis(LON, bodies, orb=0.0):
+    """cos and sin of h*theta for every (slot, body, harmonic), with an ORB FILTER on the harmonic.
+
+    WHY A FILTER. This dataset has birth DATES and no birth TIMES, so every chart is cast for a fixed hour and
+    each body carries an uncertainty of +-(daily motion)/2 degrees. A harmonic MULTIPLIES that error: the Moon
+    moves 13.2 deg/day, so its phase is +-6.6 deg at h=1 and +-79 deg at h=12 -- at which point the term is not a
+    weak feature, it is noise with a plausible name, and fitting it can only cost generalisation.
+
+    `orb` is the largest phase error in degrees a term may carry. A term is admitted when
+    h * (daily motion)/2 <= orb. orb=0 admits everything (the unfiltered basis); orb=30 drops the Moon above
+    h=4 and Mercury above h=12 while keeping every slow body at every harmonic.
+    """
+    rad = np.pi / 180.0
+    cols, kept = [], []
+    for h in HARMONICS:
+        for b in bodies:
+            if orb and h * DAILY.get(b, 0.3) / 2.0 > orb:
+                continue
+            for s in (iO, iY):
+                cols.append(h * LON[s, b] * rad)
+                kept.append((h, b, s))
+    P = np.stack(cols, axis=1)
+    return np.cos(P), np.sin(P), kept
+
+
+class Coherent:
+    """A bank of F coherent fields plus a logistic head, fitted by Adam on the exact gradients."""
+
+    def __init__(self, K, F=64, seed=0):
+        g = np.random.default_rng(seed)
+        # Small init so the initial |Z|^2 is O(1) and the head starts near chance.
+        sc = 1.0 / np.sqrt(K)
+        self.A1 = g.normal(0, sc, (F, K))
+        self.A2 = g.normal(0, sc, (F, K))
+        self.br = g.normal(0, 0.3, F)
+        self.bi = g.normal(0, 0.3, F)
+        self.w = np.zeros(F)
+        self.c = 0.0
+        self.mu = np.zeros(F)
+        self.sd = np.ones(F)
+        self.F, self.K = F, K
+        self._m = {k: np.zeros_like(getattr(self, k)) for k in ("A1", "A2", "br", "bi", "w")}
+        self._v = {k: np.zeros_like(getattr(self, k)) for k in ("A1", "A2", "br", "bi", "w")}
+        self._mc = self._vc = 0.0
+        self.t = 0
+
+    def fields(self, C, S):
+        ReS = C @ self.A1.T + S @ self.A2.T
+        ImS = S @ self.A1.T - C @ self.A2.T
+        Zr, Zi = ReS + self.br, ImS + self.bi
+        return Zr, Zi, Zr * Zr + Zi * Zi
+
+    def logit(self, C, S):
+        Zr, Zi, u = self.fields(C, S)
+        return ((u - self.mu) / self.sd) @ self.w + self.c, Zr, Zi, u
+
+    def step(self, C, S, y, lr, l2, mom=0.99):
+        B = len(y)
+        Zr, Zi, u = self.fields(C, S)
+        # Running standardisation of the fields. Treated as a constant in the gradient -- the standard
+        # inference-time treatment, and the running stats are what the held-out pass will use.
+        self.mu = mom * self.mu + (1 - mom) * u.mean(0)
+        self.sd = mom * self.sd + (1 - mom) * (u.std(0) + 1e-6)
+        un = (u - self.mu) / self.sd
+        z = un @ self.w + self.c
+        p = 1.0 / (1.0 + np.exp(-np.clip(z, -30, 30)))
+        d = (p - y) / B                                   # dL/dz
+        gw = un.T @ d + l2 * self.w
+        gc = d.sum()
+        gu = np.outer(d, self.w) / self.sd                # dL/du   (B,F)
+        gr, gi = 2.0 * gu * Zr, 2.0 * gu * Zi             # dL/dReZ, dL/dImZ
+        gA1 = gr.T @ C + gi.T @ S + l2 * self.A1
+        gA2 = gr.T @ S - gi.T @ C + l2 * self.A2
+        gbr, gbi = gr.sum(0), gi.sum(0)
+        self.t += 1
+        for k, g in (("A1", gA1), ("A2", gA2), ("br", gbr), ("bi", gbi), ("w", gw)):
+            self._m[k] = 0.9 * self._m[k] + 0.1 * g
+            self._v[k] = 0.999 * self._v[k] + 0.001 * g * g
+            mh = self._m[k] / (1 - 0.9 ** self.t)
+            vh = self._v[k] / (1 - 0.999 ** self.t)
+            setattr(self, k, getattr(self, k) - lr * mh / (np.sqrt(vh) + 1e-8))
+        self.c -= lr * gc
+        return float(-np.mean(y * np.log(p + 1e-12) + (1 - y) * np.log(1 - p + 1e-12)))
+
+
+def _gradcheck():
+    """The exact gradients against finite differences. If this is wrong every number below is noise."""
+    g = np.random.default_rng(0)
+    B, K, F = 24, 9, 4
+    C, S = g.normal(size=(B, K)), g.normal(size=(B, K))
+    y = (g.random(B) < 0.5).astype(float)
+    m = Coherent(K, F, seed=1)
+    m.w = g.normal(0, 0.5, F)
+    m.mu, m.sd = np.zeros(F), np.ones(F)
+
+    def loss():
+        _, _, u = m.fields(C, S)
+        z = ((u - m.mu) / m.sd) @ m.w + m.c
+        p = 1 / (1 + np.exp(-z))
+        return float(-np.mean(y * np.log(p) + (1 - y) * np.log(1 - p)))
+
+    # analytic, with the running-stat update and the optimiser disabled
+    B_ = len(y)
+    Zr, Zi, u = m.fields(C, S)
+    z = ((u - m.mu) / m.sd) @ m.w + m.c
+    p = 1 / (1 + np.exp(-z))
+    d = (p - y) / B_
+    gu = np.outer(d, m.w) / m.sd
+    gr, gi = 2 * gu * Zr, 2 * gu * Zi
+    an = {"A1": gr.T @ C + gi.T @ S, "A2": gr.T @ S - gi.T @ C, "br": gr.sum(0), "bi": gi.sum(0)}
+    worst = 0.0
+    for name in an:
+        P = getattr(m, name)
+        num = np.zeros_like(P)
+        it = np.nditer(P, flags=["multi_index"])
+        for _ in it:
+            ix = it.multi_index
+            o = P[ix]
+            P[ix] = o + 1e-6
+            hi = loss()
+            P[ix] = o - 1e-6
+            lo = loss()
+            P[ix] = o
+            num[ix] = (hi - lo) / 2e-6
+        rel = np.abs(num - an[name]).max() / max(1e-12, np.abs(num).max())
+        worst = max(worst, rel)
+        assert rel < 2e-4, (name, rel)
+    print(f"  gradcheck: analytic == finite-difference for A1, A2, Re b, Im b (worst relative {worst:.2e})")
+
+
+def main():
+    Z = np.load(os.environ.get("AQ_LON", "/tmp/aqcoh/lon.npz"))
+    LONtr, LONte = Z["lon_train"], Z["lon_test"]
+    ytr, yte = Z["y_train"], Z["y_test"]
+    yr_tr, yr_te = Z["yr_train"], Z["yr_test"]          # (2, n) the two birth years
+    which = os.environ.get("AQ_SET", "fast")
+    F = int(os.environ.get("AQ_FIELDS") or 64)
+    EPOCHS = int(os.environ.get("AQ_EPOCHS") or 40)
+    LR = float(os.environ.get("AQ_LR") or 0.01)
+    L2 = float(os.environ.get("AQ_L2") or 1e-4)
+    SEEDS = int(os.environ.get("AQ_SEEDS") or 3)
+    TRACE = bool(os.environ.get("AQ_TRACE"))
+    PATIENCE = int(os.environ.get("AQ_PATIENCE") or 12)
+    bodies = SETS[which]
+    TWO = os.environ.get("AQ_TWO_SIDED", "1") not in ("0", "")
+
+    # DROP THE IDENTICAL-CHART ROWS FROM THE FIT, BY DEFAULT.
+    #
+    # dates.couple_record gives a partner with no known birth date the OTHER partner's instant, deliberately and
+    # documented -- every chart needs some instant, and self-comparison is a defined value rather than a guess
+    # about a stranger. For a one-sided feature that is harmless. For a COHERENT SUM OVER BOTH CHARTS it is not:
+    # when theta_older == theta_younger the sum collapses from SUM_k (w_Ok e^{ih th_Ok} + w_Yk e^{ih th_Yk}) to
+    # SUM_k (w_Ok + w_Yk) e^{ih th_k}, a different and smaller function class. Measured on this data that is
+    # 41.3% of training rows and 0.1% of held-out rows -- so 41% of the fit's gradient comes from a configuration
+    # that essentially never occurs at test time, and the fitted phases are pulled toward it.
+    #
+    # This is not specific to this module. Every cross-chart block in the stack -- ashtakoot, the Uranian dial
+    # distances, the composite and Davison charts -- is degenerate on the same 41% and was fitted through it.
+    if TWO:
+        keep = ~np.all(np.isclose(LONtr[0], LONtr[1], atol=1e-4), axis=0)
+        log(f"  genuine pairs only: {int(keep.sum()):,} of {len(ytr):,} training rows "
+            f"({100*(~keep).mean():.1f}% dropped as identical-chart)")
+        LONtr, ytr, yr_tr = LONtr[:, :, keep], ytr[keep], yr_tr[:, keep]
+
+    ORB = float(os.environ.get('AQ_ORB') or 0)
+    Ctr, Str, kept = basis(LONtr, bodies, ORB)
+    Cte, Ste, _ = basis(LONte, bodies, ORB)
+    K = Ctr.shape[1]
+    log(f"set {which}: {len(bodies)} bodies, orb {ORB:g} deg -> {K} basis terms · "
+        f"{F} fields · train {len(ytr):,} · held out {len(yte):,}")
+
+    # TEMPORAL inner split: the latest births of the training half become the inner validation set.
+    later = yr_tr.max(0)
+    cutoff = np.quantile(later, 0.85)
+    inner = later > cutoff
+    log(f"  inner validation = training births after {cutoff:.0f} ({inner.sum():,} rows), a TEMPORAL split")
+
+    best_te = None
+    aucs = []
+    for seed in range(SEEDS):
+        m = Coherent(K, F, seed=seed)
+        rng = np.random.default_rng(1000 + seed)
+        fit = ~inner
+        idx = np.where(fit)[0]
+        best_iv, best_state, bad = -1, None, 0
+        for ep in range(EPOCHS):
+            rng.shuffle(idx)
+            for s in range(0, len(idx), 4096):
+                b = idx[s:s + 4096]
+                if len(b) < 64:
+                    continue
+                m.step(Ctr[b], Str[b], ytr[b].astype(float), LR, L2)
+            ziv, _, _, _ = m.logit(Ctr[inner], Str[inner])
+            a = auc(ytr[inner], ziv)
+            if TRACE:
+                log(f"    seed {seed} epoch {ep:>3} inner {a:.4f}")
+            if a > best_iv + 1e-5:
+                best_iv, bad = a, 0
+                best_state = (m.A1.copy(), m.A2.copy(), m.br.copy(), m.bi.copy(), m.w.copy(),
+                              m.c, m.mu.copy(), m.sd.copy())
+            else:
+                bad += 1
+                if bad >= PATIENCE:
+                    break
+        m.A1, m.A2, m.br, m.bi, m.w, m.c, m.mu, m.sd = best_state
+        zte, _, _, ute = m.logit(Cte, Ste)
+        a_te = auc(yte, zte)
+        aucs.append(a_te)
+        log(f"  seed {seed}: inner (temporal) {best_iv:.4f} -> HELD OUT {a_te:.4f}")
+        if best_te is None or best_iv > best_te[0]:
+            best_te = (best_iv, zte, ute, m)
+
+    # THE ONE PERMITTED COMPARISON: the two-parameter logistic on the age gap.
+    #
+    # It needs no fitting. b0 + b1*gap is MONOTONE in gap, and AUC is invariant under any monotone transform of
+    # the score, so the logistic's AUC is exactly max(AUC(gap), 1 - AUC(gap)) -- the sign of b1 being the only
+    # thing the fit decides. The gradient-descent version of this overflowed np.exp and reported the same number
+    # less reliably.
+    #
+    # Note what the dataset's own column definition does to this baseline: with the OLDER partner always first,
+    # the gap is non-negative by construction, so the SIGNED form that once distinguished man-older from
+    # woman-older is not expressible here. No sex is read anywhere in this dataset.
+    gap_te = (yr_te[1] - yr_te[0]).astype(float)
+    absent = (yr_te[0] == 0) | (yr_te[1] == 0)
+    assert not absent.any(), "a held-out row with an absent partner has no age gap"
+    g = auc(yte, gap_te)
+    gap_auc = max(g, 1 - g)
+
+    mean, sd = float(np.mean(aucs)), float(np.std(aucs))
+    print(f"\n  COHERENT FIELD, set '{which}', {F} fields over {K} basis terms")
+    print(f"    held-out AUC over {SEEDS} seeds: {mean:.4f} +- {sd:.4f}   (best-inner seed {auc(yte, best_te[1]):.4f})")
+    print(f"    age-gap logistic (2 parameters), same rows: {gap_auc:.4f}")
+    out = {"set": which, "fields": F, "basis": K, "held_out_mean": mean, "held_out_sd": sd,
+           "seeds": [float(a) for a in aucs], "age_gap": gap_auc}
+    d = os.environ.get("AQ_OUT", "/tmp/aqcoh")
+    json.dump(out, open(os.path.join(d, f"coherent_{which}.json"), "w"), indent=1)
+    np.savez_compressed(os.path.join(d, f"coherent_{which}_fields.npz"),
+                        test_fields=best_te[2].astype(np.float32))
+    print(f"    wrote {d}/coherent_{which}.json")
+
+
+if __name__ == "__main__":
+    if os.environ.get("AQ_GRADCHECK") or "--gradcheck" in sys.argv:
+        _gradcheck()
+    else:
+        _gradcheck()
+        main()

kerykeion_phases.py

@@ -0,0 +1,142 @@
+"""
+kerykeion_phases.py — the PHASE theta of every body at every time, through Kerykeion (sidereal, Lahiri).
+
+Operator, 2026-08-18: "use kerykeion for getting the phase of each body at each time". Three instants per couple:
+dad's birth and mom's birth at 09:00 LOCAL at each birthplace (time zone from the coordinates through
+timezonefinder; Kerykeion converts to UT and casts, houses included), and the wedding at 12:00 UT (no wedding
+place is in the data, so no wedding houses).
+
+BODIES: Sun Moon Mercury Venus Mars Jupiter Saturn Uranus Neptune Pluto TrueNode(Rahu) TrueSouthNode(Ketu) Chiron
+MeanLilith, and for the natal charts the Ascendant and MC. Precision-aware like everything else here: a
+year-only birth (1st of January placeholder) gets only the bodies the year can place -- Jupiter and slower --
+and no angles; a month-only birth adds the Sun; a year-only wedding gets the slow bodies only.
+
+Writes AQ_OUT/phases.npz: theta_dad, theta_mom, theta_wed (rows x bodies, degrees, NaN where undefined),
+bodies, y_train / ids, the plain columns for references. Kerykeion agrees with PyJHora to 0.005 degrees on the
+same instant (checked); ~0.8 ms per chart, so the whole build is minutes.
+"""
+import datetime as dt
+import multiprocessing as mp
+import os
+import sys
+import time
+import warnings
+
+import numpy as np
+import pandas as pd
+
+warnings.filterwarnings("ignore")
+SRC = os.environ.get("AQ_SRC", "/tmp/aq3")
+OUT = os.environ.get("AQ_OUT", "/tmp/aq3feat")
+LIMIT = int(os.environ.get("AQ_LIMIT") or 0)
+BODIES = ["sun", "moon", "mercury", "venus", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto",
+          "true_node", "true_south_node", "chiron", "mean_lilith", "ascendant", "medium_coeli"]
+SLOW = {"jupiter", "saturn", "uranus", "neptune", "pluto", "true_node", "true_south_node", "chiron", "mean_lilith"}
+ANGLES = {"ascendant", "medium_coeli"}
+T0 = time.time()
+
+
+def log(*a):
+    print(f"[{time.time()-T0:6.1f}s]", *a, flush=True)
+
+
+_TF = None
+_TZC = {}
+
+
+def tz_name(lat, lon):
+    global _TF
+    if _TF is None:
+        from timezonefinder import TimezoneFinder
+        _TF = TimezoneFinder()
+    key = (round(lat, 2), round(lon, 2))
+    if key not in _TZC:
+        _TZC[key] = _TF.timezone_at(lng=lon, lat=lat) or _TF.closest_timezone_at(lng=lon, lat=lat) or "UTC"
+    return _TZC[key]
+
+
+def prec(dob):
+    if not dob or dob == "0000-00-00" or dob == "nan":
+        return 0
+    return 1 if dob.endswith("-00-00") else (2 if dob.endswith("-00") else 3)
+
+
+def theta(dob, lat, lon, hour, natal):
+    """Longitudes of BODIES at (dob, hour local at lat/lon), NaN where the date's precision cannot place them."""
+    from kerykeion import AstrologicalSubject
+    out = np.full(len(BODIES), np.nan)
+    p = prec(dob)
+    if p == 0:
+        return out
+    if natal and (lat is None or (isinstance(lat, float) and np.isnan(lat))):
+        return out
+    y, m, d = int(dob[:4]), max(1, int(dob[5:7])), max(1, int(dob[8:10]))
+    try:
+        if natal:
+            s = AstrologicalSubject("x", y, m, d, hour, 0, lng=float(lon), lat=float(lat), tz_str=tz_name(float(lat), float(lon)),
+                                    city="x", nation="XX", zodiac_type="Sidereal", sidereal_mode="LAHIRI", online=False)
+        else:
+            s = AstrologicalSubject("w", y, m, d, hour, 0, lng=0.0, lat=51.48, tz_str="UTC", city="Greenwich", nation="GB",
+                                    zodiac_type="Sidereal", sidereal_mode="LAHIRI", online=False)
+    except Exception:
+        return out
+    for j, b in enumerate(BODIES):
+        if b in ANGLES and (not natal or p < 3):
+            continue
+        if p == 1 and b not in SLOW:
+            continue
+        if p == 2 and b not in SLOW and b != "sun":
+            continue
+        try:
+            out[j] = float(getattr(s, b).abs_pos)
+        except Exception:
+            pass
+    return out
+
+
+def _work(args):
+    i, dd, latd, lond, dm, latm, lonm, start = args
+    wed = start if start[5:] != "01-01" else start[:4] + "-00-00"       # a 1 January start is a year-only record
+    return i, theta(dd, latd, lond, 9, True), theta(dm, latm, lonm, 9, True), theta(wed, None, None, 12, False)
+
+
+def build(df):
+    jobs = [(i, r.dob_dad, r.lat_dad, r.lon_dad, r.dob_mom, r.lat_mom, r.lon_mom, r.start)
+            for i, r in enumerate(df.itertuples(index=False))]
+    with mp.Pool(max(1, mp.cpu_count() - 1)) as pool:
+        res = pool.map(_work, jobs, chunksize=256)
+    n = len(df); D = np.full((n, len(BODIES)), np.nan); M = D.copy(); W = D.copy()
+    for i, a, b, c in res:
+        D[i], M[i], W[i] = a, b, c
+    return D, M, W
+
+
+def main():
+    tr = pd.read_csv(f"{SRC}/train.csv", dtype={"dob_dad": str, "dob_mom": str, "start": str})
+    te = pd.read_csv(f"{SRC}/test.csv", dtype={"dob_dad": str, "dob_mom": str, "start": str})
+    LABEL = [c for c in tr.columns if c not in {"id", "dob_dad", "dob_mom", "lat_dad", "lon_dad", "lat_mom", "lon_mom", "start"}][0]
+    if LIMIT:
+        tr, te = tr.head(LIMIT), te.head(max(200, LIMIT // 4)); log(f"AQ_LIMIT={LIMIT}: DRY RUN")
+    log(f"train {len(tr):,} · test {len(te):,}")
+    Dtr, Mtr, Wtr = build(tr); log("train phases")
+    Dte, Mte, Wte = build(te); log("test phases")
+    def plain(df):
+        yd = pd.to_numeric(df.dob_dad.str[:4], errors="coerce").where(df.dob_dad != "0000-00-00")
+        ym = pd.to_numeric(df.dob_mom.str[:4], errors="coerce").where(df.dob_mom != "0000-00-00")
+        sy = df.start.str[:4].astype(float)
+        return np.column_stack([sy - yd, sy - ym, ym - yd, sy, (df.start.str[5:] == "01-01").astype(float)])
+    os.makedirs(OUT, exist_ok=True)
+    np.savez_compressed(f"{OUT}/phases.npz", theta_dad_train=Dtr, theta_mom_train=Mtr, theta_wed_train=Wtr,
+                        theta_dad_test=Dte, theta_mom_test=Mte, theta_wed_test=Wte, bodies=np.array(BODIES, dtype=object),
+                        y_train=tr[LABEL].to_numpy().astype(np.int8), id_test=te.id.to_numpy() if "id" in te else np.arange(len(te)),
+                        plain_train=plain(tr), plain_test=plain(te),
+                        plain_names=np.array(["age_dad_at_start", "age_mom_at_start", "age_gap", "start_year", "start_is_jan1"], dtype=object),
+                        yr_train=np.column_stack([pd.to_numeric(tr.dob_dad.str[:4], errors="coerce").fillna(0),
+                                                  pd.to_numeric(tr.dob_mom.str[:4], errors="coerce").fillna(0)]).astype(np.int16))
+    full = np.isfinite(Dtr).all(1) & np.isfinite(Mtr).all(1)
+    log(f"wrote {OUT}/phases.npz · {len(BODIES)} bodies · train rows with BOTH natal charts complete: {full.sum():,} · "
+        f"wedding sky complete: {np.isfinite(Wtr[:, :10]).all(1).sum():,}")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,4 @@
+numpy
+scipy
+kerykeion
+timezonefinder