Refresh: 33,289 places + search_impressions_decile ML target; fix viewer config path

Rebuilt from the current catalog (GitHub audiala/open-data 4a652d5). Adds search_impressions_decile (Google Web impressions decile, 2026-07-03..2026-09-25). Config path now data/audiala-places.csv so the dataset viewer works.

README.md

@@ -20,22 +20,28 @@ tags:
   - wikidata
   - multilingual
   - geospatial
+  - tabular
+  - benchmark
+task_categories:
+  - tabular-classification
+  - tabular-regression
 size_categories:
   - 10K<n<100K
 configs:
   - config_name: default
     data_files:
       - split: train
-        path: audiala-places.csv
+        path: data/audiala-places.csv
 ---
 
 # Audiala Places — Curated Multilingual Travel POIs
 
-33,148 travel points of interest across 93 countries, each with a Wikidata
+33,289 travel points of interest across 93 countries, each with a Wikidata
 QID, WGS84 coordinates, names in 11 languages, a type/category slug, fame
-signals (Wikidata PageRank + sitelink count), and a link to a published
-travel guide on [audiala.com](https://audiala.com) in each of the 11
-languages.
+signals (Wikidata PageRank + sitelink count), a link to a published travel
+guide on [audiala.com](https://audiala.com) in each of the 11 languages, and
+an ML target: `search_impressions_decile`, how visible each place's guides
+are in Google Search.
 
 **The curation filter is editorial:** a place is included if and only if
 Audiala has published a full travel guide for it. This dataset is
@@ -60,9 +66,26 @@ One row per Wikidata entity. Provided as CSV (flat columns) and GeoJSON
 | `wikidata_pagerank` | float | Wikidata PageRank (danker all-wiki run); empty for ~17 % of rows |
 | `sitelinks` | int | Count of Wikimedia project pages linked to the entity |
 | `url_en` … `url_ru` | string | Canonical audiala.com guide URL per language (native-script paths for hi/zh/ja/ru) |
+| `search_impressions_decile` | int | **ML target.** Google Web impressions of the place's guide pages (11 languages summed, 2026-07-03 → 2026-09-25) as a relative decile: `0` = none (177 rows), `1` lowest … `10` highest (~3,311 rows each) |
+
+## ML task: predict search visibility
+
+Given open facts about a travel place, predict how often its guide pages
+appear in Google Search. The target mixes real search demand with how well
+Audiala's pages rank, so it measures search visibility, not a place's global
+popularity. It is ordinal: use Spearman or quadratic weighted kappa, and hold
+out whole cities or countries to test generalization.
+
+**Baseline** (gradient-boosted trees on sitelinks, PageRank, category,
+country, coordinates, article tier and number of language URLs; 5-fold CV):
+Spearman **0.49**, exact decile **13.6 %** (chance ≈ 9 %), within ±1
+**40.6 %**. Sitelinks alone reach Spearman 0.45. The multilingual names and
+geography are largely untapped. Raw impressions, clicks, CTR and positions
+are not published.
 
 ## Intended uses
 
+- Tabular ML benchmark: predict `search_impressions_decile` from open features.
 - Ranking / recommending travel destinations (fame signals included).
 - Multilingual POI name lookup keyed by Wikidata QID.
 - Map layers of curated (guide-backed) attractions.
@@ -71,14 +94,16 @@ One row per Wikidata entity. Provided as CSV (flat columns) and GeoJSON
 ## Limitations
 
 - **Not exhaustive.** Coverage = Audiala's published-guide catalog; skewed
-  toward the US, Western Europe, and India, clustered around ~1,200 cities.
+  toward the US, Western Europe, and India, clustered around ~1,360 cities.
   Absence means "no guide yet", not "not notable".
 - **Category is best-effort** (~87 % Wikidata-typed, rest heuristic;
   `building` and `attraction` are weak classes).
-- A **small long tail of QID mis-mappings** may remain (188 detectable ones
+- A **small long tail of QID mis-mappings** may remain (207 detectable ones
   were removed at build time). Reports welcome.
-- Guide URLs were 99.7 % live (HTTP 200) on a 330-URL random sample at
-  build time; retired pages return 410.
+- Guide URLs were 100 % live (HTTP 200) on a 300-URL random sample at
+  build time (2026-09-28); retired pages return 410.
+- The search target covers one summer window (2026-07-03 → 2026-09-25), so
+  seasonal places are skewed.
 - Fame signals are snapshots and drift as Wikidata evolves.
 
 ## License and attribution

build/add_search_target.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""Add the `search_impressions_decile` ML target to the Audiala Places dataset.
+
+The target answers one question per place: how often did its audiala.com
+guide pages appear in Google Web search results (impressions), relative to
+every other place in the dataset? It is derived from Audiala's private Google Search Console bulk
+export and published only as a relative decile, never as raw volumes.
+
+Definition
+----------
+- Window: a fixed date range of Google Search Console *Web* impressions
+  (the range is recorded in the README and in `--window-label`).
+- Per place: impressions summed over all of its `url_<lang>` pages, after
+  folding `#fragment` URLs and slug redirects into the canonical page (the
+  same canonicalization as audiala-hugo/scripts/ctr_deficit_panel.py).
+- `search_impressions_decile`: 0 when the place had no impressions in the window;
+  otherwise 1 (lowest) to 10 (highest), by rank among places with at least
+  one impression. Ties are broken by rank order, so deciles are equal-sized.
+
+Clicks, CTR and ranking position are deliberately not published.
+
+Input GSC JSON: {"<lang>/<country>/<city>/<place>": {"impressions": int, ...}}
+as produced by `fetch_bq_pages` + `canonicalize_pages` in the SEO panel script.
+
+Usage:
+    python3 build/add_search_target.py --gsc-json PATH --window-label 2026-07-03..2026-09-25
+"""
+import argparse
+import csv
+import json
+import unicodedata
+from pathlib import Path
+from urllib.parse import unquote
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent
+LANGUAGES = ["en", "fr", "de", "es", "pt", "it", "hi", "zh", "cs", "ja", "ru"]
+SITE_BASE = "https://audiala.com/"
+TARGET = "search_impressions_decile"
+LEGACY_TARGETS = {"search_demand_decile"}
+
+
+def url_key(url: str) -> str:
+    path = url[len(SITE_BASE):] if url.startswith(SITE_BASE) else url
+    return unicodedata.normalize("NFC", unquote(path)).strip("/")
+
+
+def gsc_key(path: str) -> str:
+    return unicodedata.normalize("NFC", unquote(path)).strip("/")
+
+
+def deciles(values: dict[str, int]) -> dict[str, int]:
+    """0 for zero impressions; 1..10 equal-sized rank buckets among the rest."""
+    out = {k: 0 for k, v in values.items() if v <= 0}
+    ranked = sorted((k for k, v in values.items() if v > 0), key=lambda k: values[k])
+    n = len(ranked)
+    for i, k in enumerate(ranked):
+        out[k] = min(10, i * 10 // n + 1)
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    ap.add_argument("--gsc-json", required=True)
+    ap.add_argument("--window-label", required=True)
+    ap.add_argument("--data-dir", default=str(REPO_ROOT / "data"))
+    args = ap.parse_args()
+
+    data_dir = Path(args.data_dir)
+    gsc = {gsc_key(k): int(v.get("impressions") or 0)
+           for k, v in json.load(open(args.gsc_json, encoding="utf-8")).items()}
+
+    csv_path = data_dir / "audiala-places.csv"
+    with open(csv_path, encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        fields = [c for c in reader.fieldnames if c != TARGET and c not in LEGACY_TARGETS]
+        rows = list(reader)
+
+    demand = {}
+    matched_pages = 0
+    for r in rows:
+        total = 0
+        for lang in LANGUAGES:
+            u = r.get(f"url_{lang}")
+            if u:
+                imp = gsc.get(url_key(u), 0)
+                matched_pages += imp > 0
+                total += imp
+        demand[r["wikidata_id"]] = total
+    dec = deciles(demand)
+
+    with open(csv_path, "w", encoding="utf-8", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=fields + [TARGET])
+        w.writeheader()
+        for r in rows:
+            r[TARGET] = dec[r["wikidata_id"]]
+            w.writerow({k: r[k] for k in fields + [TARGET]})
+
+    geo_path = data_dir / "audiala-places.geojson"
+    geo = json.load(open(geo_path, encoding="utf-8"))
+    for feat in geo["features"]:
+        qid = feat["properties"]["wikidata_id"]
+        for legacy in LEGACY_TARGETS:
+            feat["properties"].pop(legacy, None)
+        feat["properties"][TARGET] = dec.get(qid, 0)
+    with open(geo_path, "w", encoding="utf-8") as f:
+        json.dump(geo, f, ensure_ascii=False, separators=(",", ":"))
+
+    nonzero = sum(1 for v in demand.values() if v > 0)
+    print(f"window {args.window_label}: {len(rows)} places, {nonzero} with impressions "
+          f"({nonzero / len(rows):.1%}), {matched_pages} language pages matched")
+    counts = {d: sum(1 for v in dec.values() if v == d) for d in range(11)}
+    print("decile counts:", counts)
+
+
+if __name__ == "__main__":
+    main()

build/build_dataset.py

@@ -84,6 +84,7 @@ from pathlib import Path
 
 import psycopg2
 import psycopg2.extras
+import psycopg2.errors
 import requests
 from anyascii import anyascii
 
@@ -534,6 +535,7 @@ WHERE a.language = 'en'
   AND NOT EXISTS (SELECT 1 FROM places p2
                   WHERE p2.wikidata_id = a.wikidata_id
                     AND p2.place_kind = 'non_tourism')
+  AND a.wikidata_id = ANY(%s)
 """
 
 PER_LANG_SQL = """
@@ -541,6 +543,7 @@ SELECT wikidata_id, language, name, city, country
 FROM articles
 WHERE (structured_content IS NOT NULL OR report IS NOT NULL)
   AND wikidata_id ~ '^Q[1-9][0-9]*$'
+  AND wikidata_id = ANY(%s)
 """
 
 TRANSLATIONS_SQL = """
@@ -550,6 +553,45 @@ WHERE wikidata_id = ANY(%s)
 """
 
 
+CANDIDATES_SQL = """
+SELECT DISTINCT wikidata_id
+FROM articles
+WHERE language = 'en'
+  AND (structured_content IS NOT NULL OR report IS NOT NULL)
+  AND wikidata_id ~ '^Q[1-9][0-9]*$'
+"""
+
+
+def fetch_batched(conn, sql: str, qids: list[str], batch_size: int = 2000,
+                  retries: int = 4) -> list[dict]:
+    """Run `sql` (which must end with a `wikidata_id = ANY(%s)` filter) in
+    short, independent read-only transactions.
+
+    Hot-standby replicas cancel long-running snapshots that conflict with WAL
+    replay ("canceling statement due to conflict with recovery"). Small
+    batches keep every snapshot short; a cancelled batch is retried.
+    """
+    out: list[dict] = []
+    for i in range(0, len(qids), batch_size):
+        batch = qids[i:i + batch_size]
+        for attempt in range(retries):
+            try:
+                cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+                cur.execute(sql, (batch,))
+                rows = cur.fetchall()
+                cur.close()
+                conn.rollback()  # end the read-only transaction
+                out.extend(rows)
+                break
+            except (psycopg2.errors.SerializationFailure,
+                    psycopg2.errors.QueryCanceled):
+                conn.rollback()
+                if attempt == retries - 1:
+                    raise
+                time.sleep(2 * (attempt + 1))
+    return out
+
+
 # ---------------------------------------------------------------------------
 # Main build
 # ---------------------------------------------------------------------------
@@ -571,17 +613,21 @@ def main():
 
     print("1/6 querying core rows (published EN articles + best place + pagerank)...")
     conn = connect_db()
-    cur = conn.cursor(name="core", cursor_factory=psycopg2.extras.RealDictCursor)
-    cur.itersize = 5000
-    cur.execute(CORE_SQL + (f" LIMIT {int(args.limit)}" if args.limit else ""))
+    cur = conn.cursor()
+    cur.execute(CANDIDATES_SQL)
+    candidates = sorted((r[0] for r in cur.fetchall()), key=lambda q: int(q[1:]))
+    cur.close()
+    conn.rollback()
+    if args.limit:
+        candidates = candidates[:int(args.limit)]
+    print(f"    {len(candidates)} candidate QIDs")
     core: dict[str, dict] = {}
     dropped_no_coords = 0
-    for r in cur:
+    for r in fetch_batched(conn, CORE_SQL, candidates):
         if r["latitude"] is None or r["longitude"] is None:
             dropped_no_coords += 1
             continue
         core[r["wikidata_id"]] = dict(r)
-    cur.close()
     print(f"    {len(core)} places with coordinates ({dropped_no_coords} dropped: no coords)")
 
     qids = sorted(core, key=lambda q: int(q[1:]))
@@ -591,21 +637,18 @@ def main():
     cur.execute(TRANSLATIONS_SQL, (qids,))
     translations = {r["wikidata_id"]: r for r in cur.fetchall()}
     cur.close()
+    conn.rollback()
     print(f"    {len(translations)} translation rows")
 
     print("3/6 querying per-language article rows for URL derivation...")
-    cur = conn.cursor(name="perlang", cursor_factory=psycopg2.extras.RealDictCursor)
-    cur.itersize = 20000
-    cur.execute(PER_LANG_SQL)
     urls: dict[str, dict[str, str]] = collections.defaultdict(dict)
-    for r in cur:
+    for r in fetch_batched(conn, PER_LANG_SQL, qids):
         qid, lang = r["wikidata_id"], r["language"]
         if qid not in core or lang not in LANGUAGES:
             continue
         permalink = build_permalink(lang, r["country"], r["city"], r["name"], qid)
         # Canonical site URLs carry NO trailing slash (trailing-slash 301s away).
         urls[qid][lang] = f"{SITE_BASE}/{permalink}"
-    cur.close()
     conn.close()
     print(f"    URLs computed for {len(urls)} places")
 

data/audiala-places.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:55a48e5e60844fb58c6da0f811c72aa962dc3b871870e1534e26739f9f11dd84
-size 40487080
+oid sha256:e21c7e92357ea062db51445baaaef1fa45fedb24cf095b72b520199f86b2b47c
+size 40673872

data/audiala-places.geojson

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0599da91e186a9b42527eabbbc3445e2601857d24c3337b2148e0da781c8655e
-size 55325878
+oid sha256:c536ef046e2bfd751bc13d3166a81d9dd315f357e8f86f3a9eac2f68ed2086f3
+size 56507429