"""Derive reproducible analytical features from the normalized works table. Two streaming passes over the works parts: pass 1 build the group statistics that need the whole corpus (citation distributions per publication_year x field, per-topic and per-field yearly publication counts). pass 2 attach the derived columns and rewrite each part in place. Every derived value has a deterministic definition (see METHODOLOGY.md); no values are invented or produced by a language model. """ from __future__ import annotations import bisect import math from pathlib import Path import pyarrow as pa import pyarrow.parquet as pq from common import ensure_dirs, get_logger, load_config, p, utc_now, write_json from schema import TOPIC_GROWTH, TOPIC_YEAR_COUNTS, WORKS_BASE, WORKS_FULL BATCH = 50000 def _year_counts(pairs): d: dict[int, int] = {} for y, n in pairs: d[y] = d.get(y, 0) + n return d def _growth(series: dict[int, int], y0: int, y1: int, threshold: float, min_late: int): span = y1 - y0 half = max(1, span // 2) early_years = range(y0, y0 + half) late_years = range(y1 - half + 1, y1 + 1) early = sum(series.get(y, 0) for y in early_years) late = sum(series.get(y, 0) for y in late_years) ratio = (late + 1.0) / (early + 1.0) n = len(list(late_years)) or 1 early_avg = max(early / max(len(list(early_years)), 1), 1e-9) late_avg = late / n cagr = (late_avg / early_avg) ** (1.0 / max(span, 1)) - 1.0 if early_avg > 0 else 0.0 ys = sorted(series) slope = 0.0 if len(ys) >= 2: mx = sum(ys) / len(ys) my = sum(series[y] for y in ys) / len(ys) num = sum((y - mx) * (series[y] - my) for y in ys) den = sum((y - mx) ** 2 for y in ys) or 1.0 slope = num / den emerging = bool(ratio >= threshold and late >= min_late and late > early) return early, late, float(ratio), float(cagr), float(slope), emerging def run(cfg: dict | None = None) -> dict: cfg = cfg or load_config() ensure_dirs(cfg) logger = get_logger("diversa.derive", p(cfg, "logs") / "pipeline.log") parts_dir = p(cfg, "parts") / "works" out_dir = p(cfg, "parts") / "works_full" out_dir.mkdir(parents=True, exist_ok=True) files = sorted(parts_dir.glob("*.parquet")) if not files: raise SystemExit("no normalized works parts found; run normalize first") percent_group = tuple(cfg["features"]["citation_percentile_group"]) hi_pct = cfg["features"]["high_impact_percentile"] threshold = cfg["features"]["emerging_growth_threshold"] halflife = cfg["features"]["recency_halflife_years"] y0, y1 = cfg["scope"]["year_start"], cfg["scope"]["year_end"] logger.info("derive pass 1/2: scanning %d works parts", len(files)) group_vals: dict[tuple, list[int]] = {} topic_series: dict[str, dict[int, int]] = {} topic_names: dict[str, str] = {} field_series: dict[str, dict[int, int]] = {} max_year = y0 total = 0 for f in files: pf = pq.ParquetFile(f) cols = [c for c in ["publication_year", "field_id", "primary_topic_id", "primary_topic_name", "cited_by_count"] if c in pf.schema_arrow.names] for batch in pf.iter_batches(batch_size=BATCH, columns=cols): d = batch.to_pydict() for i in range(len(d["publication_year"])): total += 1 yr = d["publication_year"][i] fld = d["field_id"][i] tid = d["primary_topic_id"][i] cbc = d["cited_by_count"][i] or 0 if yr is None: continue max_year = max(max_year, yr) key_parts = [] for g in percent_group: key_parts.append(yr if g == "publication_year" else fld) group_vals.setdefault(tuple(key_parts), []).append(cbc) if tid: topic_series.setdefault(tid, {})[yr] = topic_series.setdefault(tid, {}).get(yr, 0) + 1 topic_names.setdefault(tid, d["primary_topic_name"][i]) if fld: field_series.setdefault(fld, {})[yr] = field_series.setdefault(fld, {}).get(yr, 0) + 1 n_groups = sum(len(v) for v in group_vals.values()) for k in group_vals: group_vals[k].sort() logger.info("pass 1 complete: %s works, %d percentile groups, %d topics", f"{total:,}", len(group_vals), len(topic_series)) field_growth = {fid: _growth(series, y0, y1, threshold, 1) for fid, series in field_series.items()} topic_growth = {tid: _growth(series, y0, y1, threshold, 50) for tid, series in topic_series.items()} min_late_topic = 50 trows = [] grows = [] for tid, series in topic_series.items(): for y in sorted(series): trows.append({"topic_id": tid, "topic_name": topic_names.get(tid), "publication_year": y, "works_count": series[y]}) early, late, ratio, cagr, slope, emerging = topic_growth[tid] grows.append({"topic_id": tid, "topic_name": topic_names.get(tid), "first_year": min(series), "last_year": max(series), "early_count": early, "late_count": late, "growth_ratio": ratio, "cagr": cagr, "trend_slope": slope, "emerging_topic_flag": emerging}) pq.write_table(pa.Table.from_pylist(trows, schema=TOPIC_YEAR_COUNTS), p(cfg, "analytics") / "topic_year_counts.parquet", compression="zstd") pq.write_table(pa.Table.from_pylist(grows, schema=TOPIC_GROWTH), p(cfg, "analytics") / "topic_growth.parquet", compression="zstd") logger.info("derive pass 2/2: writing enriched works") written = 0 for f in files: pf = pq.ParquetFile(f) out_f = out_dir / f.name writer = None try: for batch in pf.iter_batches(batch_size=BATCH): rows = batch.to_pylist() out_rows = [] for r in rows: yr = r.get("publication_year") fld = r.get("field_id") tid = r.get("primary_topic_id") cbc = r.get("cited_by_count") or 0 age = float(max_year - yr) if yr is not None else None cpy = (cbc / age) if age and age > 0 else (float(cbc) if age == 0 else None) rec = r.get("recent_citations_3y") velocity = (rec / 3.0) if rec is not None else None pct = None if yr is not None: key_parts = [] for g in percent_group: key_parts.append(yr if g == "publication_year" else fld) vals = group_vals.get(tuple(key_parts)) if vals: pct = 100.0 * bisect.bisect_right(vals, cbc) / len(vals) recency = math.exp(-age / halflife) if age is not None else None fg = field_growth.get(fld) tg = topic_growth.get(tid) r2 = dict(r) r2.update({ "paper_age_years": age, "citations_per_year": cpy, "citation_velocity": velocity, "international_collaboration": (r.get("country_count") or 0) >= 2, "multi_institutional": (r.get("institution_count") or 0) >= 2, "publication_recency_score": recency, "citation_percentile": pct, "high_impact_flag": (pct is not None and pct >= hi_pct), "research_growth_score": fg[2] if fg else None, "topic_growth_score": tg[2] if tg else None, "emerging_topic_flag": bool(tg[5]) if tg else False, }) out_rows.append(r2) tbl = pa.Table.from_pylist(out_rows, schema=WORKS_FULL) if writer is None: writer = pq.ParquetWriter(out_f, WORKS_FULL, compression="zstd") writer.write_table(tbl) written += len(out_rows) finally: if writer is not None: writer.close() logger.info("derive done: %s enriched rows -> %s", f"{written:,}", out_dir) summary = { "works_enriched": written, "max_publication_year": max_year, "percentile_groups": len(group_vals), "topics": len(topic_series), "emerging_topics": int(sum(1 for v in topic_growth.values() if v[5])), "finished_at": utc_now(), } write_json(p(cfg, "checkpoints") / "derive_stats.json", summary) return summary if __name__ == "__main__": run()