Add files using upload-large-folder tool

README.md

@@ -0,0 +1,75 @@
+---
+license: other
+license_name: mixed-cc0-text-and-derived-facts
+language: [en]
+pretty_name: SEC Filings → Forward-Return (US large-cap, 2000–2026)
+size_categories: [100K<n<1M]
+task_categories: [text-classification, tabular-regression, text-retrieval]
+tags: [finance, sec, edgar, 8-k, 10-k, 10-q, forward-return, event-study, leak-free, time-series]
+configs:
+- config_name: labeled
+  data_files: [{split: train, path: data/labeled/train.parquet}, {split: validation, path: data/labeled/validation.parquet}, {split: test, path: data/labeled/test.parquet}]
+- config_name: labeled_head32k
+  data_files: [{split: train, path: data/labeled_head32k/train.parquet}, {split: validation, path: data/labeled_head32k/validation.parquet}, {split: test, path: data/labeled_head32k/test.parquet}]
+- config_name: features
+  data_files: [{split: train, path: data/features/train.parquet}, {split: validation, path: data/features/validation.parquet}, {split: test, path: data/features/test.parquet}]
+- config_name: corpus
+  data_files: [{split: train, path: data/corpus/train.parquet}, {split: validation, path: data/corpus/validation.parquet}, {split: test, path: data/corpus/test.parquet}]
+---
+
+# SEC Filings → Forward-Return (US large-cap, 2000–2026)
+
+Leak-free, time-ordered SEC filings (8-K / 10-Q / 10-K) with objective **forward-return
+labels** for ~610 current US large-cap names, through 2026. A *benchmark* ("can filing text
+predict forward returns?"), not just a corpus.
+
+## ⚖️ Licensing & provenance (read first — this is the honest part)
+This repo deliberately separates two provenance classes:
+
+| part | source | license |
+|---|---|---|
+| **Filing text + `accession,cik,ticker,form,file_date,period_of_report,doc_url,text_len`** | **SEC EDGAR** — US government work | **public domain / CC0** |
+| **Labels** (`fwd_ret_*, excess_spy_*, direction_*, fwd_vol_*, entry_date`) | **derived numerical facts** computed from publicly observable split/dividend-adjusted closing prices | provided **as-is, no warranty**; see below |
+
+- The underlying **price series is NOT included or redistributed** here. Labels are scalar
+  *derived returns* (facts), not vendor price data.
+- **No proprietary classification.** The earlier `excess_sector` label (which needed a GICS
+  mapping) has been **removed**. Only market-relative excess (`excess_spy`, vs SPY) remains.
+- **Full reproducibility:** `generate_labels.py` regenerates every label from *your own*
+  price source (any `date,ticker,adj_close` parquet). You can verify or rebuild labels
+  without relying on any redistributed price data.
+- The **`corpus`** config (text only) is unambiguously **CC0**.
+
+## Configs
+- **labeled** — filing text + forward-return labels (headline).
+- **labeled_head32k** — same, text truncated to 32k chars (HF-practical).
+- **features** — tabular only (no text): metadata + labels, for quick baselines.
+- **corpus** — ALL forms incl. foreign 6-K/20-F, text-only (CC0).
+
+## Splits (walk-forward, 120-trading-day embargo)
+train ≤ 2019 · validation 2020–2022 · test 2023–2026. Filings whose 120-td label window
+crosses a split boundary are dropped from the earlier split (no peeking across boundaries).
+
+## Labels (per horizon h ∈ {1,5,20,60,120} trading days; no `fwd_vol_1`)
+`fwd_ret_h = adj_close[E+h]/adj_close[E]−1` · `excess_spy_h = fwd_ret_h − SPY` ·
+`direction_h = sign(excess_spy_h)` · `fwd_vol_h` = realized daily-log-ret vol.
+**Anchor E = first trading session STRICTLY AFTER `file_date`** (a filing at any intraday
+time can't be traded that day → next session). `entry_date` is kept for transparency.
+
+## ⚠️ Known limitations
+- **Survivorship bias** — universe = *current* US large-cap names only. Fingerprint visible:
+  `excess_spy` mean ≈ 0 at 1–5d, rising to ~+2.6% at 120d. Use cross-sectional/excess, not
+  absolute long-horizon P&L. No point-in-time index membership.
+- Foreign 6-K/20-F are text-only (in `corpus`), not price-labeled.
+- **Not investment advice.** Research dataset; past returns ≠ future results.
+
+## Baseline (bar to beat) — test split (2023–26), walk-forward
+| model | input | accuracy | AUC | IC (Spearman) | L/S decile excess_20 |
+|---|---|---|---|---|---|
+| no-text floor (HistGBM) | form, text_len, season | 0.470 | 0.512 | +0.022 | −0.006 |
+| text (TF-IDF + logistic) | head_32k filing text | 0.479 | 0.500 | −0.006 | −0.000 |
+
+Both ~chance: predicting 20-day excess return from filing text out-of-sample is genuinely
+hard, and naive text does not beat the no-text floor. The ~0.50 walk-forward AUC also
+corroborates the labels are leak-free (a leaky setup would inflate it). Open challenge:
+beat this (likely 8-K at short horizons, or modern encoders).

data/corpus/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3900b4dd6d84b36faf47224d1e68c689bff426d0ec4288dc2a44215d637c4518
+size 697193855

data/corpus/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c85a49f87c5e453ac01a148ce4c7331b5e6e7f43ec79574f5efc2fc2f4b06744
+size 4102681407

data/corpus/validation.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4244e601d4f9dd30f09922332f1ba038344addf38b7f77ba4befadeaf067bcb4
+size 593755655

data/features/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66bb083ce9f05f4ddb30b58b44423273f55228d7ffbf21e391b5574ae9276909
+size 3454130

data/features/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f169a65290d452fc443d0828724fc73cac2e6fb89b264352339a649f0eee8775
+size 16763086

data/features/validation.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:425a8dde835aea8eec58a289403e23ede33b1e160df6c670ac6ab6abdd05b0a0
+size 2765889

data/labeled/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57d0cf109c258cc13b37f9aa7efa1c566f562c7795d91f2dfef465e22b50aa9c
+size 482984950

data/labeled/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:735380c9a87183f0351f8f2ed4601ce39a9b615f25f55c6ef6b44669094f8467
+size 3195293325

data/labeled/validation.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bb943d8c4573def1f88fa6516c5032a039fc8de41d9bf03d3019146890f8bc1
+size 368925483

data/labeled_head32k/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0574a90c6ca68f28fa3e449aec2321646ac2017e11351e12636a6990cfc3bccf
+size 75540426

data/labeled_head32k/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97a4ae02c1b1464d27af157d179ea78670e480c9d347171c2597d63985335996
+size 349409068

data/labeled_head32k/validation.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00054c9e1246828e0232047025787c4fde1244dca2d2158911250b38b590e921
+size 56978241

generate_labels.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""generate_labels.py — reproduce the forward-return LABELS for this dataset from
+YOUR OWN price source (so the dataset needs no redistributed vendor price data).
+
+You provide a long-format daily price parquet with columns: date, ticker, adj_close
+(split+dividend adjusted). The script computes, for each filing in the `corpus`/`labeled`
+text, leak-free forward-return labels and writes them next to the filings.
+
+LEAK RULE (do not change): entry E = first trading session STRICTLY AFTER file_date.
+Return uses adj_close at both ends. Horizons h ∈ {1,5,20,60,120} trading days.
+Labels: fwd_ret_h, excess_spy_h (vs SPY adj_close), direction_h (sign excess_spy), fwd_vol_h.
+(excess_sector is intentionally NOT computed here — it required a proprietary GICS mapping.)
+
+Usage:
+  python generate_labels.py --filings filings.parquet --prices my_prices.parquet \
+                            --spy SPY --out labels.parquet
+"""
+import argparse
+import numpy as np, polars as pl
+
+HZ = [1, 5, 20, 60, 120]
+
+def win_ret(darr, aarr, dE, dX):
+    iE = np.searchsorted(darr, dE); iX = np.searchsorted(darr, dX)
+    okE = (iE < len(darr)) & (darr[np.clip(iE, 0, len(darr)-1)] == dE)
+    okX = (iX < len(darr)) & (darr[np.clip(iX, 0, len(darr)-1)] == dX)
+    r = np.full(len(dE), np.nan); ok = okE & okX
+    r[ok] = aarr[iX[ok]] / aarr[iE[ok]] - 1
+    return r
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--filings", required=True, help="parquet with columns accession,ticker,file_date")
+    ap.add_argument("--prices", required=True, help="long parquet: date,ticker,adj_close")
+    ap.add_argument("--spy", default="SPY")
+    ap.add_argument("--out", default="labels.parquet")
+    a = ap.parse_args()
+
+    px = (pl.read_parquet(a.prices, columns=["date", "ticker", "adj_close"]).drop_nulls("adj_close")
+          .with_columns(pl.col("date").cast(pl.Date).cast(pl.Int32).alias("d")))
+    by = {t: (s.sort("d")["d"].to_numpy(), s.sort("d")["adj_close"].to_numpy())
+          for t, s in px.group_by("ticker")}
+    spy_d, spy_a = by[a.spy]
+
+    df = (pl.read_parquet(a.filings, columns=["accession", "ticker", "file_date"])
+          .with_columns(pl.col("file_date").cast(pl.Utf8).str.slice(0, 10)
+                        .str.strptime(pl.Date, strict=False).cast(pl.Int32).alias("fd"))
+          .drop_nulls("fd").with_row_index("rid"))
+    N = df.height
+    out = {f"{p}_{h}": np.full(N, np.nan) for h in HZ for p in ("fwd_ret", "excess_spy", "fwd_vol")}
+
+    for tk, sub in df.group_by("ticker"):
+        tk = tk[0] if isinstance(tk, tuple) else tk
+        if tk not in by: continue
+        pd_, pa_ = by[tk]; rid = sub["rid"].to_numpy(); fd = sub["fd"].to_numpy()
+        E = np.searchsorted(pd_, fd, side="right"); n = len(pd_); hasE = E < n
+        if not hasE.any(): continue
+        Ec = np.clip(E, 0, n-1); dE = pd_[Ec]
+        for h in HZ:
+            X = E + h; okX = hasE & (X < n); Xc = np.clip(X, 0, n-1); dX = pd_[Xc]
+            ret = np.where(okX, pa_[Xc] / pa_[Ec] - 1, np.nan)
+            out[f"fwd_ret_{h}"][rid] = ret
+            out[f"excess_spy_{h}"][rid] = np.where(okX, ret - win_ret(spy_d, spy_a, dE, dX), np.nan)
+            vol = np.full(len(rid), np.nan)
+            for j in np.where(okX)[0]:
+                seg = pa_[Ec[j]:Xc[j]+1]
+                if len(seg) > 2: vol[j] = np.diff(np.log(seg)).std(ddof=1)
+            out[f"fwd_vol_{h}"][rid] = vol
+
+    cols = {"accession": df["accession"]}
+    for h in HZ:
+        for p in ("fwd_ret", "excess_spy", "fwd_vol"):
+            cols[f"{p}_{h}"] = pl.Series(out[f"{p}_{h}"]).fill_nan(None)
+        cols[f"direction_{h}"] = pl.Series(np.sign(out[f"excess_spy_{h}"])).fill_nan(None)
+    pl.DataFrame(cols).write_parquet(a.out)
+    print(f"wrote {a.out}: {N} rows")
+
+if __name__ == "__main__":
+    main()