Add inline comments, comment linking, unlimited tables/levels

- New 'comment' label (N key) with cell-to-cell linking mode for inline footnotes
- Extract Excel native comments from cells (orange triangle indicator in UI)
- Smart comment attribution in chunks: notes on headers, values, metadata, attributes
- Remove artificial limits on table count (was T9) and header levels (was L9)
- Multi-digit keyboard input for T and L (e.g. T12, L15) with 500ms buffer
- has_comment and has_inline_note GNN features
- Updated LABELING_GUIDE.md and in-app help (EN/PL) with comment instructions

Made-with: Cursor

LABELING_GUIDE.md

@@ -45,9 +45,9 @@ Each sheet can contain one or more **tables** (separate data grids). You must te
 Set the active table before labeling cells:
 
 - Click a table button in the **Table** bar, or
-- Press **T** then a digit **0**–**9**.
+- Press **T** then type the table number (e.g. **T** **1** **2** for T12).
 
-To add more tables, click the **[+]** button. The system supports up to T9.
+To add more tables, click the **[+]** button. There is no limit on the number of tables.
 
 Every cell you label is stamped with the currently active table ID. If you label a cell as `value` while T2 is active, that cell belongs to table 2.
 
@@ -62,7 +62,7 @@ Row and column headers can have multiple levels of hierarchy. The **Level** bar
 Set the active level:
 
 - Click a level button in the **Level** bar, or
-- Press **L** then a digit **1**–**9**.
+- Press **L** then type the level number (e.g. **L** **1** **2** for L12).
 
 To add more levels, click the **[+]** button.
 
@@ -439,8 +439,8 @@ Before pressing Enter, quickly verify:
 | **E** | Label as empty |
 | **J** | Label as junk (discarded from chunks) |
 | **X** | Clear label |
-| **T** then **0**–**9** | Set active table |
-| **L** then **1**–**9** | Set active header level |
+| **T** then digits | Set active table (e.g. T, 1, 2 for T12) |
+| **L** then digits | Set active header level (e.g. L, 5 for L5) |
 | **Esc** | Cancel comment linking |
 | **Enter** | Save & load next sheet |
 | **Shift+click** | Range select |
@@ -496,9 +496,9 @@ Każdy arkusz może zawierać jedną lub więcej **tabel** (oddzielnych siatek d
 Ustaw aktywną tabelę przed labelowaniem:
 
 - Kliknij przycisk tabeli w pasku **Table**, lub
-- Naciśnij **T**, potem cyfrę **0**–**9**.
+- Naciśnij **T**, potem wpisz numer tabeli (np. **T** **1** **2** dla T12).
 
-Aby dodać więcej tabel, kliknij **[+]**. System obsługuje do T9.
+Aby dodać więcej tabel, kliknij **[+]**. Nie ma limitu liczby tabel.
 
 Każda etykietowana komórka otrzymuje ID aktywnej tabeli. Jeśli oznaczysz komórkę jako `value` przy aktywnym T2, ta komórka trafia do tabeli 2.
 
@@ -513,7 +513,7 @@ Nagłówki wierszy i kolumn mogą mieć wiele poziomów hierarchii. Pasek **Leve
 Ustaw aktywny poziom:
 
 - Kliknij przycisk w pasku **Level**, lub
-- Naciśnij **L**, potem cyfrę **1**–**9**.
+- Naciśnij **L**, potem wpisz numer poziomu (np. **L** **1** **2** dla L12).
 
 Aby dodać więcej poziomów, kliknij **[+]**.
 
@@ -890,8 +890,8 @@ Przed naciśnięciem Enter szybko sprawdź:
 | **E** | Oznacz jako empty (pusta) |
 | **J** | Oznacz jako junk (śmieć, odrzucone z chunków) |
 | **X** | Wyczyść etykietę |
-| **T** potem **0**–**9** | Ustaw aktywną tabelę |
-| **L** potem **1**–**9** | Ustaw aktywny poziom nagłówka |
+| **T** potem cyfry | Ustaw aktywną tabelę (np. T, 1, 2 dla T12) |
+| **L** potem cyfry | Ustaw aktywny poziom nagłówka (np. L, 5 dla L5) |
 | **Esc** | Anuluj linkowanie komentarza |
 | **Enter** | Zapisz i wczytaj następny arkusz |
 | **Shift+klik** | Zaznaczanie zakresu |

chunk_builder.py

@@ -102,18 +102,35 @@ def _header_text_with_comment(cell: dict | None) -> str:
     return text
 
 
+def _find_row_header_for_header_row(
+    row: int, col: int, by_coord: dict, by_label: dict, by_table: dict,
+    table_id: int,
+) -> str:
+    """Scan left from a column header cell to find its row header on the same row."""
+    for scan_c in range(col - 1, -1, -1):
+        lbl = by_label.get((row, scan_c), "")
+        tbl = by_table.get((row, scan_c), 0)
+        if table_id != 0 and tbl != 0 and tbl != table_id:
+            break
+        if is_row_header(lbl):
+            return _header_text_with_comment(by_coord.get((row, scan_c)))
+    return ""
+
+
 def _collect_col_headers(
     row: int, col: int, by_coord: dict, by_label: dict, by_table: dict,
     table_id: int, *, direction: str = "up", max_row: int = 0,
 ) -> list[str]:
     """Walk along a column to collect column headers, outermost first.
 
+    Same-level headers are concatenated with ", ".  When a row header sits
+    on the same row as a column header it is prefixed as "row_hdr: col_hdr".
+
     *direction* controls the scan axis: ``"up"`` (default, classic layout) or
-    ``"down"`` (headers sit below data).  When scanning in the non-default
-    direction we skip data cells instead of stopping at them, because the
-    headers are expected to be on the far side of the data region.
+    ``"down"`` (headers sit below data).
     """
-    headers = []
+    headers_by_level: dict[int, list[str]] = defaultdict(list)
+
     if direction == "down":
         scan_range = range(row + 1, max_row)
     else:
@@ -129,14 +146,20 @@ def _collect_col_headers(
         if direction == "up" and is_row_header(lbl):
             break
         if is_col_header(lbl):
+            level = header_level(lbl)
             cell = by_coord.get((scan_r, col))
             text = _header_text_with_comment(cell)
             if text:
-                headers.append(text)
+                row_hdr = _find_row_header_for_header_row(
+                    scan_r, col, by_coord, by_label, by_table, table_id,
+                )
+                entry = f"{row_hdr}: {text}" if row_hdr else text
+                headers_by_level[level].append(entry)
 
-    if direction == "up":
-        headers.reverse()
-    return headers
+    result = []
+    for level in sorted(headers_by_level.keys(), reverse=True):
+        result.append(", ".join(headers_by_level[level]))
+    return result
 
 
 def _collect_row_headers(

features.py

@@ -24,6 +24,17 @@ FORMULA_TYPES = ["sum", "average", "count", "vlookup", "hlookup",
 FTYPE_TO_IDX = {ft: i + 1 for i, ft in enumerate(FORMULA_TYPES)}
 
 
+_FOOTNOTE_MARKERS = {"*", "**", "***", "†", "‡", "§", "¶", "||"}
+
+_UNIT_INDICATORS_WORD = {
+    "usd", "eur", "pln", "jpy", "gbp", "chf", "cad", "aud", "cny", "krw",
+    "mln", "tys", "bln", "trn",
+    "millions", "thousands", "billions", "units",
+    "bps", "pp", "kg", "mt", "mwh", "gwh", "kwh",
+}
+_UNIT_INDICATORS_SUBSTR = {"p.p.", "000s"}
+
+
 def _content_features(value: str) -> dict:
     """String-level features for a cell value."""
     n = len(value)
@@ -32,6 +43,14 @@ def _content_features(value: str) -> dict:
             "is_empty": True, "is_numeric": False, "is_date": False,
             "string_length": 0, "digit_ratio": 0.0, "letter_ratio": 0.0,
             "upper_ratio": 0.0, "has_special_chars": False, "word_count": 0,
+            "starts_footnote": False, "has_footnote_ref": False,
+            "ends_colon": False, "has_parenthetical": False,
+            "is_all_caps": False, "has_numbering": False,
+            "has_unit": False, "char_diversity": 0.0,
+            "special_char_ratio": 0.0, "line_count": 1,
+            "token_len_var": 0.0, "leading_spaces": 0,
+            "starts_paren": False, "ends_paren": False,
+            "has_internal_colon": False,
         }
 
     digits = sum(c.isdigit() for c in value)
@@ -51,6 +70,42 @@ def _content_features(value: str) -> dict:
     )
     is_date = bool(date_pattern.search(value))
 
+    val_stripped = value.strip()
+    val_lower = value.lower().strip()
+
+    starts_footnote = (val_stripped in _FOOTNOTE_MARKERS
+                       or any(val_stripped.startswith(m) for m in _FOOTNOTE_MARKERS))
+    has_footnote_ref = bool(
+        re.search(r"\[\d+\]|\(\d+\)|\[[a-z]\]|[\u00B9\u00B2\u00B3\u2070-\u2079]", value))
+    ends_colon = val_stripped.endswith(":")
+    has_parenthetical = bool(re.search(r"\([a-zA-Z%][a-zA-Z0-9% .,]*\)", value))
+
+    letter_chars = [ch for ch in value if ch.isalpha()]
+    is_all_caps = len(letter_chars) > 0 and all(ch.isupper() for ch in letter_chars)
+
+    has_numbering = bool(
+        re.match(r"^(\d{1,3}[\.\)]\s|[a-zA-Z][\.\)]\s|[ivxIVX]+[\.\)]\s)", val_stripped))
+
+    val_lower_words = set(re.findall(r"[a-z0-9.]+", val_lower))
+    has_unit = (bool(val_lower_words & _UNIT_INDICATORS_WORD)
+                or any(u in val_lower for u in _UNIT_INDICATORS_SUBSTR)
+                or any(sym in value for sym in ("$", "£", "€", "¥", "₩", "₽", "zł")))
+
+    char_diversity = len(set(value)) / n
+    special_chars = sum(1 for ch in value if not ch.isalnum() and not ch.isspace())
+    special_char_ratio = special_chars / n
+    line_count = value.count("\n") + 1
+
+    words = value.split()
+    if len(words) > 1:
+        wlens = [len(w) for w in words]
+        mean_wl = sum(wlens) / len(wlens)
+        token_len_var = sum((wl - mean_wl) ** 2 for wl in wlens) / len(wlens)
+    else:
+        token_len_var = 0.0
+
+    leading_spaces = len(value) - len(value.lstrip(" "))
+
     return {
         "is_empty": False,
         "is_numeric": is_numeric,
@@ -60,7 +115,22 @@ def _content_features(value: str) -> dict:
         "letter_ratio": letters / n,
         "upper_ratio": uppers / max(letters, 1),
         "has_special_chars": bool(re.search(r"[^\w\s.,%-]", value)),
-        "word_count": len(value.split()),
+        "word_count": len(words),
+        "starts_footnote": starts_footnote,
+        "has_footnote_ref": has_footnote_ref,
+        "ends_colon": ends_colon,
+        "has_parenthetical": has_parenthetical,
+        "is_all_caps": is_all_caps,
+        "has_numbering": has_numbering,
+        "has_unit": has_unit,
+        "char_diversity": char_diversity,
+        "special_char_ratio": special_char_ratio,
+        "line_count": line_count,
+        "token_len_var": token_len_var,
+        "leading_spaces": leading_spaces,
+        "starts_paren": val_stripped.startswith("("),
+        "ends_paren": val_stripped.endswith(")"),
+        "has_internal_colon": ":" in value and not val_stripped.endswith(":"),
     }
 
 

models.py

@@ -28,7 +28,7 @@ from torch_geometric.nn import GATConv, GCNConv
 
 from label_utils import NUM_CLASSES
 
-EDGE_TYPE_DIM = 3
+EDGE_TYPE_DIM = 21  # 5 edge types (one-hot) + 16 relative position encoding
 
 
 # ═══════════════════════════════════════════════════════════════════════════

notes.md

@@ -389,7 +389,7 @@ This run adds:
   - Group C — keywords (11 new): kw_total, kw_sum_avg, kw_date_time, kw_note_source, kw_unnamed, kw_ref_error, kw_asterisk, kw_na, kw_item_desc, kw_financial, kw_month
 - **Total input dim**: 56 structural + 768 embeddings = 824
 
-Feature index map in `_cell_features()`:
+Feature index map in `_cell_features()` (as of run 2, before textual expansion):
 - [0-2] position (3d)
 - [3-11] content stats (9d)
 - [12-27] formatting (16d: 8 original + 8 new)
@@ -398,6 +398,20 @@ Feature index map in `_cell_features()`:
 - [44-54] keywords (11d)
 - [55] merge span (1d)
 
+**Run 3 expansion (2026-04-04):** added 15 textual/punctuation features (total: 71 structural + 768 embeddings = 839-d). Keywords also expanded to multilingual matching. Updated index map:
+- [0-2] position (3d)
+- [3-11] content stats (9d)
+- [12-27] formatting (16d)
+- [28-31] formula (4d)
+- [32-43] content type (12d)
+- [44-54] keywords (11d, now multilingual: total/sum/avg/date/source/month keywords match 15+ languages)
+- [55] merge span (1d)
+- [56-70] textual / punctuation features (15d): starts_footnote, has_footnote_ref, ends_colon, has_parenthetical, is_all_caps, has_numbering, has_unit, char_diversity, special_char_ratio, line_count, token_len_var, leading_spaces, starts_paren, ends_paren, has_internal_colon
+
+Scientific basis for the new features: Koci et al. (IC3K 2016) selected 43 features for cell classification including STARTS WITH SPECIAL?, CONTAINS COLON?, IS UPPER CASE?, CONTAINS PUNCTUATIONS?, and WORDS LIKE TOTAL? (48/49 positive cases were Metadata). Ghasemi-Gol et al. (KAIS 2021) showed content-only features transfer better cross-domain than stylistic features. TUTA (Wang & Dong et al., 2021) built the first table-specific vocabulary. Multilingual keywords sourced from Excel-Translator (excel-translator.de) and Aspose.Cells GlobalizationSettings. Footnote marker conventions follow APA/Chicago standard sequence: *, †, ‡, §, ¶, ||.
+
+New ablation variant `"no_textual"` added to `train_compare.py` FEATURE_GROUPS to measure the contribution of indices [56-70].
+
 ### Setup
 
 Identical to first run except for input features:
@@ -453,9 +467,122 @@ Best individual model: GAT fold 0 (chunk F1 = 1.000), promoted to `data/models/b
 
 7. **Feature expansion + embeddings provide a consistent improvement** across all architectures and both metrics. The combined delta is largest for models without graph structure (MLP), suggesting the new features encode neighborhood-level signal that GNNs can partially learn from structure alone.
 
+## Run 4: Full dataset + textual features (2026-04-05)
+
+### What changed from Run 3
+
+- **25 more labeled sheets** added to dataset (94 usable, up from 69)
+- **276,651 labeled cells** (up from ~91K in Run 3)
+- E5 embeddings regenerated for all 95 files (24 new + 71 existing)
+- Same 71 structural features (including textual/punctuation features and multilingual keywords from Run 3)
+- Total input dim: 839 (71 structural + 768 embeddings)
+- Same training config: 5-fold CV, seed 42, 100 epochs, Adam lr=1e-3, cosine schedule
+
+### Per-sheet mean results (94 sheets, 5-fold CV)
+
+| Arch | L1 Acc | L1 Macro F1 | L3 ARI | L4 Chunk F1 | L4 Content EM | Params |
+|------|--------|-------------|--------|-------------|---------------|--------|
+| GAT  | 0.802 ± 0.204 | 0.664 ± 0.251 | 0.379 ± 0.389 | 0.787 ± 0.337 | 0.090 ± 0.282 | 582K |
+| GCN  | 0.811 ± 0.196 | 0.667 ± 0.239 | 0.338 ± 0.371 | 0.795 ± 0.332 | 0.074 ± 0.252 | 233K |
+| MLP  | 0.812 ± 0.198 | 0.643 ± 0.246 | 0.336 ± 0.360 | 0.812 ± 0.312 | 0.096 ± 0.294 | 216K |
+
+Per-fold chunk F1:
+
+| Fold | GAT   | GCN   | MLP   |
+|------|-------|-------|-------|
+| 0    | 0.867 | 0.866 | 0.919 |
+| 1    | 0.723 | 0.752 | 0.819 |
+| 2    | 0.796 | 0.804 | 0.798 |
+| 3    | 0.761 | 0.754 | 0.685 |
+| 4    | 0.791 | 0.799 | 0.841 |
+
+Statistical significance: no pairwise comparisons are significant (MLP vs GAT p=0.16, MLP vs GCN p=0.19).
+
+Best individual model: MLP fold 0 (chunk F1 = 0.919), promoted to `data/models/best_model.pt`.
+
+### Cross-run comparison
+
+| Metric | Run 1 (24f, no emb, 69 sheets) | Run 3 (71f + emb, 69 sheets) | Run 4 (71f + emb, 94 sheets) | Delta Run3→4 |
+|--------|--------------------------------|------------------------------|------------------------------|-------------|
+| GAT Macro F1 | 0.588 | 0.632 | 0.664 | +0.032 |
+| GCN Macro F1 | 0.595 | 0.613 | 0.667 | +0.054 |
+| MLP Macro F1 | 0.544 | 0.599 | 0.643 | +0.044 |
+| GAT Chunk F1 | 0.785 | 0.837 | 0.787 | -0.050 |
+| GCN Chunk F1 | 0.805 | 0.810 | 0.795 | -0.015 |
+| MLP Chunk F1 | 0.784 | 0.837 | 0.812 | -0.025 |
+
+### Observations
+
+1. **Macro F1 improved across all architectures** (+0.032 to +0.054 vs Run 3). The 25 additional sheets provide more diverse training examples, improving generalization on rare classes. GCN benefits most (+0.054).
+
+2. **Chunk F1 decreased slightly** (-0.015 to -0.050 vs Run 3). This is expected: the new sheets include complex multi-table layouts from a single multi-sheet workbook (17 sheets from `1lU94qWhkzftOvuY97incFADLaV30LgWV`), which increase the difficulty of the test folds. The model now evaluates on harder, more realistic data.
+
+3. **Val accuracy improved substantially**: fold 0-1 achieve 93-95% accuracy (vs 67-83% in Run 2). The larger training set helps convergence.
+
+4. **MLP is now the best architecture** on chunk F1 (0.812), overtaking GAT (0.787) and GCN (0.795). With 71 rich features + embeddings, the per-node signal is strong enough that graph message passing adds minimal value. MLP also has the fewest parameters (216K).
+
+5. **ARI remains low** (0.34-0.38), indicating table assignment is still the weakest part of the pipeline. This is consistent across all architectures and likely requires explicit table-boundary detection improvements.
+
+6. **Content exact match remains very low** (0.07-0.10). Position-based chunk matching succeeds but exact content reproduction is still poor, suggesting chunk text generation needs improvement independent of classification accuracy.
+
+7. **Training artifacts**: all 15 model checkpoints saved in `data/experiments/`, full 4-level per-sheet metrics available, model ranking in `model_ranking.json`, results accessible via `/api/train/experiments` and `/train` dashboard.
+
+## Architecture analysis: why macro F1 is stuck at 0.64 (2026-04-05)
+
+### The graph structure adds almost no value (currently)
+
+MLP (no graph edges at all) matches GAT and GCN on both chunk F1 and macro F1 across all runs. This is the single most important diagnostic finding: the edges as currently constructed are not providing useful signal. Three root causes:
+
+1. **Spatial edges are 4-neighbor only.** Each GNN layer extends the receptive field by exactly 1 cell. With 3 layers, a cell can "see" at most 3 hops away. A column header at row 1 cannot influence a data cell at row 40 — the information would need 39 hops to arrive, but the model has only 3. This is why value/attribute cells get confused with row_header — the model literally cannot see the header.
+
+2. **GCN ignores edge types.** Only GAT uses the edge-type one-hot (spatial vs sheet-to-table). GCN aggregates uniformly. Since edge types carry structural information (is this a grid neighbor or a metadata-to-table link?), GCN discards a key signal.
+
+3. **Hierarchical edges are not used for message passing.** The ground-truth header-to-data edges are built (`hier_edge_index`) but only used as targets for a secondary link-prediction head. They are NOT added to `edge_index` for convolution. The model must discover hierarchy from local spatial adjacency alone — which is asking it to solve the problem as a side effect of solving it.
+
+### No row/column reasoning
+
+Spreadsheets have a fundamental property: cells in the same column usually share a semantic role (all values under the same col_header). Same for rows. The current architecture has no mechanism to exploit this — a cell only sees its 4 immediate neighbors, not its entire row or column.
+
+### Class imbalance is poorly handled
+
+`value` (39%) + `attribute` (55%) = 94% of cells. Weighted cross-entropy scales the loss but doesn't change the learning dynamics. The model can minimize total loss by perfecting the dominant classes. Rare classes like `junk` (0.06%), `col_header_3` (0.002%), `comment` (0.19%) have near-zero F1 because the gradient signal from their loss is drowned out. Focal loss (Lin et al., 2017) addresses this by down-weighting easy/well-classified examples — giving near-zero loss for confident correct predictions, so gradient budget is spent on hard misclassifications.
+
+### The 0.64 macro F1 is not an accuracy problem
+
+Val accuracy per fold is 0.88-0.95. Macro F1 averages F1 across all 13 classes equally. When 4-5 classes have F1 near zero (because they have <100 training examples or the model never predicts them), the average drops to ~0.64 even though dominant classes are classified well.
+
+### Existing but untested: global attention models
+
+Two architectures already exist in `models.py` but have never been trained on the full dataset:
+- **GraphTransformerModel** (GPS-style): local GAT + full global self-attention per layer. Every cell attends to every other cell, giving the model the ability to directly link headers to distant data cells.
+- **SequenceTransformerModel**: standard Transformer encoder in row-major order with 2D sinusoidal positional encoding. Also provides global attention.
+
+These should be tested first before adding new edge types, as they may already provide the long-range connectivity the model lacks.
+
+### Proposed architectural improvements (priority order)
+
+1. **Test graph_transformer and seq_transformer** — zero code changes, may already show significant gains from global attention.
+
+2. **Focal loss** — replace weighted CE. Expected to lift rare-class F1 significantly (BAT, ICML 2024 showed up to 46% improvement over class reweighting for graph imbalance).
+
+3. **Row/column edges** — add edges connecting all cells in the same row and all cells in the same column (within a table). More targeted than full global attention (O(rows + cols) vs O(n^2)). Tag with new edge types EDGE_TYPE_ROW and EDGE_TYPE_COL. This directly models the "cells in a column share a header" pattern.
+
+4. **Relative position encoding on edges** — instead of absolute (row, col) node features, encode relative offsets (row_dst - row_src, col_dst - col_src) as sinusoidal edge features. The model learns "the cell 1 row above tends to be a header" rather than "row 0 cells tend to be headers."
+
+5. **Larger hidden_dim** (128 → 256) — current encoder compresses 839-d input to 128-d, losing ~85% of information immediately.
+
+6. **Hierarchical edges in the conv graph** — during training (where labels are known), add ground-truth hierarchical edges as additional message-passing paths, not just as link-prediction targets.
+
+### References for these improvements
+
+- **TUTA** (Wang & Dong et al., 2021) uses tree-based attention with spatial + hierarchical position. The row/column edge proposal follows the same intuition.
+- **Focal loss** (Lin et al., ICCV 2017) originally for object detection; applied to graphs by BAT (ICML 2024).
+- **GPS** (Rampášek et al., NeurIPS 2022) — General, Powerful, Scalable graph transformers. Our `GraphTransformerModel` follows this design.
+- **Relative position bias** is standard in modern Transformers (ALiBi, RoPE, Swin Transformer). For graphs, encoding relative positions as edge features is the natural equivalent.
+
 ## Plotting / figure-generation caveat
 
-`plot_results.py` now has `data/experiments/all_results.json` from the second training run (expanded features + embeddings).
+`plot_results.py` now has `data/experiments/all_results.json` from Run 4 (94 sheets, full features + embeddings).
 
 Still missing:
 

predict.py

@@ -72,13 +72,21 @@ def load_model(version: Optional[str] = None) -> Optional[SpreadsheetGNN]:
         cfg = checkpoint["config"]
         num_classes = cfg.get("num_classes", 9)
 
+        from models import EDGE_TYPE_DIM as _current_etd
+        saved_etd = cfg.get("edge_type_dim", 3)
+        import models as _models_mod
+        _old_etd = _models_mod.EDGE_TYPE_DIM
+        _models_mod.EDGE_TYPE_DIM = saved_etd
+
         model = SpreadsheetGNN(
             in_dim=cfg["in_dim"],
             hidden_dim=cfg["hidden_dim"],
             num_classes=num_classes,
         )
+        _models_mod.EDGE_TYPE_DIM = _old_etd
         model.load_state_dict(checkpoint["model_state_dict"], strict=False)
         model.eval()
+        model._edge_type_dim = saved_etd
 
         if "cell_labels" in checkpoint:
             output_labels = checkpoint["cell_labels"]
@@ -357,7 +365,8 @@ def predict_sheet(
         return None
 
     edge_index = torch.tensor(edges, dtype=torch.long)
-    edge_attr = torch.zeros(edge_index.size(1), EDGE_TYPE_DIM)
+    model_etd = getattr(model, "_edge_type_dim", EDGE_TYPE_DIM)
+    edge_attr = torch.zeros(edge_index.size(1), model_etd)
     edge_attr[:, 0] = 1.0
 
     h = model(x, edge_index, edge_attr)

static/index.html

@@ -322,7 +322,7 @@
       lbl_junk: "Junk",
       lbl_clear: "Clear",
       link_banner_text: "Click the cell this comment refers to (or press Esc to cancel)",
-      hint: 'Click to select \u00b7 <kbd>Shift</kbd>+click for range \u00b7 <kbd>Ctrl/Cmd</kbd>+click to toggle \u00b7 <kbd>R</kbd>=RowHdr \u00b7 <kbd>C</kbd>=ColHdr (at active level) \u00b7 <kbd>N</kbd>=Comment \u00b7 <kbd>J</kbd>=Junk \u00b7 <kbd>T</kbd>+<kbd>0\u20119</kbd> table \u00b7 <kbd>L</kbd>+<kbd>1\u20119</kbd> level \u00b7 <kbd>Enter</kbd> = Save & Next',
+      hint: 'Click to select \u00b7 <kbd>Shift</kbd>+click for range \u00b7 <kbd>Ctrl/Cmd</kbd>+click to toggle \u00b7 <kbd>R</kbd>=RowHdr \u00b7 <kbd>C</kbd>=ColHdr (at active level) \u00b7 <kbd>N</kbd>=Comment \u00b7 <kbd>J</kbd>=Junk \u00b7 <kbd>T</kbd>+digits = table \u00b7 <kbd>L</kbd>+digits = level \u00b7 <kbd>Enter</kbd> = Save & Next',
       error_prefix: "Error: ",
       save_error: "Save error: ",
       help_title: "Labeling Guide",
@@ -369,7 +369,7 @@
       lbl_junk: "Śmieć",
       lbl_clear: "Wyczy\u015b\u0107",
       link_banner_text: "Kliknij kom\u00f3rk\u0119, do kt\u00f3rej odnosi si\u0119 ten komentarz (lub naci\u015bnij Esc, aby anulowa\u0107)",
-      hint: 'Kliknij, aby zaznaczy\u0107 \u00b7 <kbd>Shift</kbd>+klik = zakres \u00b7 <kbd>Ctrl/Cmd</kbd>+klik = prze\u0142\u0105cz \u00b7 <kbd>R</kbd>=NagWier \u00b7 <kbd>C</kbd>=NagKol (na aktywnym poziomie) \u00b7 <kbd>N</kbd>=Komentarz \u00b7 <kbd>J</kbd>=Śmieć \u00b7 <kbd>T</kbd>+<kbd>0\u20119</kbd> tabela \u00b7 <kbd>L</kbd>+<kbd>1\u20119</kbd> poziom \u00b7 <kbd>Enter</kbd> = Zapisz i dalej',
+      hint: 'Kliknij, aby zaznaczy\u0107 \u00b7 <kbd>Shift</kbd>+klik = zakres \u00b7 <kbd>Ctrl/Cmd</kbd>+klik = prze\u0142\u0105cz \u00b7 <kbd>R</kbd>=NagWier \u00b7 <kbd>C</kbd>=NagKol (na aktywnym poziomie) \u00b7 <kbd>N</kbd>=Komentarz \u00b7 <kbd>J</kbd>=Śmieć \u00b7 <kbd>T</kbd>+cyfry = tabela \u00b7 <kbd>L</kbd>+cyfry = poziom \u00b7 <kbd>Enter</kbd> = Zapisz i dalej',
       error_prefix: "B\u0142\u0105d: ",
       save_error: "B\u0142\u0105d zapisu: ",
       help_title: "Instrukcja labelowania",
@@ -424,16 +424,16 @@
 
   function colHeaderColor(level) {
     const base = [255, 235, 156];
-    const step = Math.min(level - 1, 8);
-    const darken = step * 18;
-    return `rgb(${base[0] - darken}, ${base[1] - darken * 1.2 | 0}, ${base[2] - darken * 2 | 0})`;
+    const cycle = (level - 1) % 12;
+    const darken = cycle * 14;
+    return `rgb(${Math.max(base[0] - darken, 80)}, ${Math.max(base[1] - (darken * 1.2 | 0), 60)}, ${Math.max(base[2] - (darken * 2 | 0), 20)})`;
   }
 
   function rowHeaderColor(level) {
     const base = [244, 176, 132];
-    const step = Math.min(level - 1, 8);
-    const darken = step * 16;
-    return `rgb(${base[0] - darken}, ${base[1] - darken * 1.3 | 0}, ${base[2] - darken * 1.5 | 0})`;
+    const cycle = (level - 1) % 12;
+    const darken = cycle * 12;
+    return `rgb(${Math.max(base[0] - darken, 80)}, ${Math.max(base[1] - (darken * 1.3 | 0), 50)}, ${Math.max(base[2] - (darken * 1.5 | 0), 20)})`;
   }
 
   /* ── State ─────────────────────────────────────────────────────────── */
@@ -595,10 +595,14 @@
   const dynamicStyle = document.createElement("style");
   document.head.appendChild(dynamicStyle);
 
+  function tableColor(i) {
+    return TABLE_COLORS[i % TABLE_COLORS.length];
+  }
+
   function refreshDynamicCSS() {
     let css = "";
-    for (let i = 0; i < TABLE_COLORS.length; i++) {
-      const c = TABLE_COLORS[i];
+    for (let i = 0; i <= maxTableId; i++) {
+      const c = tableColor(i);
       css += `.t${i}-active{border-color:${c}!important;background:${c}!important}\n`;
       css += `.tid-${i}{background:${c}}\n`;
     }
@@ -626,11 +630,9 @@
     addBtn.textContent = "+";
     addBtn.title = t("add_table");
     addBtn.addEventListener("click", () => {
-      if (maxTableId < 9) {
-        maxTableId++;
-        renderTableBar();
-        setActiveTable(maxTableId);
-      }
+      maxTableId++;
+      renderTableBar();
+      setActiveTable(maxTableId);
     });
     tableBar.appendChild(addBtn);
   }
@@ -670,13 +672,11 @@
     addBtn.textContent = "+";
     addBtn.title = t("add_level");
     addBtn.addEventListener("click", () => {
-      if (maxLevel < 9) {
-        maxLevel++;
-        refreshDynamicCSS();
-        renderLevelBar();
-        renderLegend();
-        setActiveLevel(maxLevel);
-      }
+      maxLevel++;
+      refreshDynamicCSS();
+      renderLevelBar();
+      renderLegend();
+      setActiveLevel(maxLevel);
     });
     levelBar.appendChild(addBtn);
   }
@@ -1046,6 +1046,22 @@
   /* ── Keyboard labeling ─────────────────────────────────────────────── */
   let waitingForTableNum = false;
   let waitingForLevelNum = false;
+  let digitBuffer = "";
+  let digitTimer = null;
+
+  function flushTableDigits() {
+    const n = parseInt(digitBuffer);
+    digitBuffer = "";
+    digitTimer = null;
+    if (!isNaN(n) && n >= 0) setActiveTable(n);
+  }
+
+  function flushLevelDigits() {
+    const n = parseInt(digitBuffer);
+    digitBuffer = "";
+    digitTimer = null;
+    if (!isNaN(n) && n >= 1) setActiveLevel(n);
+  }
 
   const SIMPLE_LABELS = {
     v: "value",
@@ -1060,37 +1076,47 @@
   document.addEventListener("keydown", (e) => {
     if (e.target.tagName === "INPUT" || e.target.tagName === "TEXTAREA") return;
 
-    // T + digit for table selection
+    // T + digits for table selection (multi-digit: T12, T25, etc.)
     if (waitingForTableNum) {
-      waitingForTableNum = false;
-      const n = parseInt(e.key);
-      if (!isNaN(n) && n >= 0 && n <= 9) {
+      if (/^\d$/.test(e.key)) {
         e.preventDefault();
-        setActiveTable(n);
+        digitBuffer += e.key;
+        clearTimeout(digitTimer);
+        digitTimer = setTimeout(flushTableDigits, 500);
         return;
       }
+      clearTimeout(digitTimer);
+      flushTableDigits();
+      waitingForTableNum = false;
     }
     if (e.key === "t" && !e.shiftKey && !e.altKey && !e.ctrlKey && !e.metaKey) {
       e.preventDefault();
       waitingForTableNum = true;
       waitingForLevelNum = false;
+      digitBuffer = "";
+      clearTimeout(digitTimer);
       return;
     }
 
-    // L + digit for level selection
+    // L + digits for level selection (multi-digit: L10, L12, etc.)
     if (waitingForLevelNum) {
-      waitingForLevelNum = false;
-      const n = parseInt(e.key);
-      if (!isNaN(n) && n >= 1 && n <= 9) {
+      if (/^\d$/.test(e.key)) {
         e.preventDefault();
-        setActiveLevel(n);
+        digitBuffer += e.key;
+        clearTimeout(digitTimer);
+        digitTimer = setTimeout(flushLevelDigits, 500);
         return;
       }
+      clearTimeout(digitTimer);
+      flushLevelDigits();
+      waitingForLevelNum = false;
     }
     if (e.key === "l" && !e.shiftKey && !e.altKey && !e.ctrlKey && !e.metaKey) {
       e.preventDefault();
       waitingForLevelNum = true;
       waitingForTableNum = false;
+      digitBuffer = "";
+      clearTimeout(digitTimer);
       return;
     }
 
@@ -1579,8 +1605,8 @@ Your labels are used for: <strong>(1)</strong> training a graph neural network t
 <ul>
 <li><strong>T0</strong> = sheet-level (titles, notes for the whole sheet).</li>
 <li><strong>T1, T2, &hellip;</strong> = individual tables.</li>
-<li>Set active table: click in the <strong>Table</strong> bar or <kbd>T</kbd> + digit <kbd>0</kbd>&ndash;<kbd>9</kbd>.</li>
-<li>Click <strong>[+]</strong> to add more tables (up to T9).</li>
+<li>Set active table: click in the <strong>Table</strong> bar or <kbd>T</kbd> + digits (e.g. <kbd>T</kbd><kbd>1</kbd><kbd>2</kbd> for T12).</li>
+<li>Click <strong>[+]</strong> to add more tables (no limit).</li>
 </ul>
 <p class="warn">T0 cells do NOT produce chunks. Only T1+ cells generate data. Never put value/attribute/header cells in T0.</p>
 
@@ -1590,7 +1616,7 @@ Your labels are used for: <strong>(1)</strong> training a graph neural network t
 <li><strong>L1</strong> = innermost (most specific, closest to data). Start here.</li>
 <li><strong>L2</strong> = broader grouping that contains L1.</li>
 <li><strong>L3, L4, &hellip;</strong> = even broader.</li>
-<li>Set level: click in the <strong>Level</strong> bar or <kbd>L</kbd> + digit <kbd>1</kbd>&ndash;<kbd>9</kbd>.</li>
+<li>Set level: click in the <strong>Level</strong> bar or <kbd>L</kbd> + digits (e.g. L12).</li>
 </ul>
 
 <h4>Row headers (R) &mdash; multi-level (horizontal)</h4>
@@ -1710,8 +1736,8 @@ Examples: <code>*estimated</code>, <code>see note 3</code>, <code>revised Q3</co
 <tr><td><kbd>E</kbd></td><td>Label as empty</td></tr>
 <tr><td><kbd>J</kbd></td><td>Label as junk (discarded from chunks)</td></tr>
 <tr><td><kbd>X</kbd></td><td>Clear label</td></tr>
-<tr><td><kbd>T</kbd> + <kbd>0</kbd>&ndash;<kbd>9</kbd></td><td>Set active table</td></tr>
-<tr><td><kbd>L</kbd> + <kbd>1</kbd>&ndash;<kbd>9</kbd></td><td>Set active level</td></tr>
+<tr><td><kbd>T</kbd> + digits</td><td>Set active table (e.g. T12)</td></tr>
+<tr><td><kbd>L</kbd> + digits</td><td>Set active level (e.g. L5)</td></tr>
 <tr><td><kbd>Esc</kbd></td><td>Cancel comment linking</td></tr>
 <tr><td><kbd>Enter</kbd></td><td>Save &amp; load next sheet</td></tr>
 <tr><td><kbd>Shift</kbd>+click</td><td>Range select</td></tr>
@@ -1756,8 +1782,8 @@ Twoje etykiety służą do: <strong>(1)</strong> trenowania sieci neuronowej prz
 <ul>
 <li><strong>T0</strong> = poziom arkusza (tytuły, notatki dla całego arkusza).</li>
 <li><strong>T1, T2, &hellip;</strong> = poszczeg&oacute;lne tabele.</li>
-<li>Ustaw aktywną tabelę: kliknij w pasku <strong>Table</strong> lub <kbd>T</kbd> + cyfra <kbd>0</kbd>&ndash;<kbd>9</kbd>.</li>
-<li>Kliknij <strong>[+]</strong>, aby dodać więcej (do T9).</li>
+<li>Ustaw aktywną tabelę: kliknij w pasku <strong>Table</strong> lub <kbd>T</kbd> + cyfry (np. <kbd>T</kbd><kbd>1</kbd><kbd>2</kbd> dla T12).</li>
+<li>Kliknij <strong>[+]</strong>, aby dodać więcej (bez limitu).</li>
 </ul>
 <p class="warn">Kom&oacute;rki T0 NIE generują chunk&oacute;w. Tylko T1+ generuje dane. Nigdy nie umieszczaj value/attribute/header w T0.</p>
 
@@ -1767,7 +1793,7 @@ Twoje etykiety służą do: <strong>(1)</strong> trenowania sieci neuronowej prz
 <li><strong>L1</strong> = najbardziej szczeg&oacute;łowy (najbliższy danych). Zacznij tutaj.</li>
 <li><strong>L2</strong> = szersze grupowanie obejmujące L1.</li>
 <li><strong>L3, L4, &hellip;</strong> = jeszcze szersze grupowania.</li>
-<li>Ustaw poziom: kliknij w pasku <strong>Level</strong> lub <kbd>L</kbd> + cyfra <kbd>1</kbd>&ndash;<kbd>9</kbd>.</li>
+<li>Ustaw poziom: kliknij w pasku <strong>Level</strong> lub <kbd>L</kbd> + cyfry (np. L12).</li>
 </ul>
 
 <h4>Nagł&oacute;wki wierszy (R) &mdash; wielopoziomowe (poziome)</h4>
@@ -1887,8 +1913,8 @@ Przykłady: <code>*dane szacunkowe</code>, <code>patrz nota 3</code>, <code>skor
 <tr><td><kbd>E</kbd></td><td>Oznacz jako empty (pusta)</td></tr>
 <tr><td><kbd>J</kbd></td><td>Oznacz jako junk (śmieć, odrzucone z chunków)</td></tr>
 <tr><td><kbd>X</kbd></td><td>Wyczyść etykietę</td></tr>
-<tr><td><kbd>T</kbd> + <kbd>0</kbd>&ndash;<kbd>9</kbd></td><td>Ustaw aktywną tabelę</td></tr>
-<tr><td><kbd>L</kbd> + <kbd>1</kbd>&ndash;<kbd>9</kbd></td><td>Ustaw aktywny poziom</td></tr>
+<tr><td><kbd>T</kbd> + cyfry</td><td>Ustaw aktywną tabelę (np. T12)</td></tr>
+<tr><td><kbd>L</kbd> + cyfry</td><td>Ustaw aktywny poziom (np. L5)</td></tr>
 <tr><td><kbd>Esc</kbd></td><td>Anuluj linkowanie komentarza</td></tr>
 <tr><td><kbd>Enter</kbd></td><td>Zapisz i wczytaj następny</td></tr>
 <tr><td><kbd>Shift</kbd>+klik</td><td>Zaznaczanie zakresu</td></tr>

train_baseline.py

@@ -43,6 +43,12 @@ FEATURE_COLS = [
     "neighbor_right_empty", "neighbor_right_numeric", "neighbor_right_type",
     "empty_neighbor_count", "numeric_neighbor_count",
     "at_top_edge", "at_left_edge", "at_bottom_edge", "at_right_edge",
+    # textual / punctuation features
+    "starts_footnote", "has_footnote_ref", "ends_colon", "has_parenthetical",
+    "is_all_caps", "has_numbering", "has_unit",
+    "char_diversity", "special_char_ratio", "line_count",
+    "token_len_var", "leading_spaces",
+    "starts_paren", "ends_paren", "has_internal_colon",
 ]
 
 

train_compare.py

@@ -38,6 +38,7 @@ from train_gnn import (
     load_all_graphs,
     compute_class_weights,
     sample_negative_edges,
+    FocalLoss,
 )
 from evaluate import evaluate_sheet, evaluate_ablation_variant
 
@@ -103,7 +104,7 @@ def _train_one(
     device: torch.device,
     num_epochs: int = 100,
     lr: float = 1e-3,
-    hidden_dim: int = 128,
+    hidden_dim: int = 256,
     feature_mask: torch.Tensor | None = None,
     run_name: str = "",
 ) -> dict:
@@ -117,7 +118,7 @@ def _train_one(
 
     optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=1e-4)
     scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)
-    cw = class_weights.to(device)
+    focal_loss_fn = FocalLoss(alpha=class_weights, gamma=2.0).to(device)
 
     best_acc = 0.0
     best_state = None
@@ -134,7 +135,7 @@ def _train_one(
 
             mask = g.train_mask
             node_loss = (
-                F.cross_entropy(model.classify_nodes(h)[mask], g.y[mask], weight=cw)
+                focal_loss_fn(model.classify_nodes(h)[mask], g.y[mask])
                 if mask.sum() > 0 else torch.tensor(0.0, device=device)
             )
 
@@ -283,32 +284,37 @@ def paired_bootstrap_test(
 # Feature ablation masks
 # ═══════════════════════════════════════════════════════════════════════════
 
-STRUCTURAL_DIM = 56
+STRUCTURAL_DIM = 71
 
-# Feature index ranges within the 56-d structural vector:
+# Feature index ranges within the 71-d structural vector:
 #   [0-2]   position (3)
 #   [3-11]  content stats (9)
 #   [12-27] formatting (16)
 #   [28-31] formula (4)
 #   [32-43] content type (12)
-#   [44-54] keywords (11)
+#   [44-54] keywords (11, multilingual)
 #   [55]    merge span (1)
+#   [56-70] textual / punctuation features (15)
 _POS = list(range(0, 3))
 _CONTENT = list(range(3, 12))
 _FORMAT = list(range(12, 28))
 _FORMULA = list(range(28, 32))
 _CTYPE = list(range(32, 44))
 _KEYWORDS = list(range(44, 56))
+_TEXTUAL = list(range(56, 71))
 _EMBED = list(range(STRUCTURAL_DIM, STRUCTURAL_DIM + 768))
 
+_ALL_STRUCT = _POS + _CONTENT + _FORMAT + _FORMULA + _CTYPE + _KEYWORDS + _TEXTUAL
+
 FEATURE_GROUPS = {
     "full": None,
     "no_text_embed": list(range(STRUCTURAL_DIM)),
-    "no_formatting": _POS + _CONTENT + _FORMULA + _CTYPE + _KEYWORDS + _EMBED,
-    "no_formula": _POS + _CONTENT + _FORMAT + _CTYPE + _KEYWORDS + _EMBED,
-    "no_position": _CONTENT + _FORMAT + _FORMULA + _CTYPE + _KEYWORDS + _EMBED,
-    "no_keywords": _POS + _CONTENT + _FORMAT + _FORMULA + _CTYPE + _EMBED,
-    "no_content_type": _POS + _CONTENT + _FORMAT + _FORMULA + _KEYWORDS + _EMBED,
+    "no_formatting": _POS + _CONTENT + _FORMULA + _CTYPE + _KEYWORDS + _TEXTUAL + _EMBED,
+    "no_formula": _POS + _CONTENT + _FORMAT + _CTYPE + _KEYWORDS + _TEXTUAL + _EMBED,
+    "no_position": _CONTENT + _FORMAT + _FORMULA + _CTYPE + _KEYWORDS + _TEXTUAL + _EMBED,
+    "no_keywords": _POS + _CONTENT + _FORMAT + _FORMULA + _CTYPE + _TEXTUAL + _EMBED,
+    "no_content_type": _POS + _CONTENT + _FORMAT + _FORMULA + _KEYWORDS + _TEXTUAL + _EMBED,
+    "no_textual": _POS + _CONTENT + _FORMAT + _FORMULA + _CTYPE + _KEYWORDS + _EMBED,
     "structural_only": list(range(STRUCTURAL_DIM)),
     "embeddings_only": _EMBED,
 }
@@ -342,7 +348,9 @@ def run_experiments(
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     print(f"Device: {device}")
 
-    graphs = load_all_graphs()
+    has_attention = any(a in architectures for a in ("graph_transformer", "seq_transformer"))
+    max_nodes = 5000 if has_attention else 0
+    graphs = load_all_graphs(max_nodes=max_nodes)
     if len(graphs) < 2:
         print(f"Need >= 2 labeled sheets, found {len(graphs)}.")
         return {}
@@ -420,8 +428,9 @@ def run_experiments(
                 exp_dir.mkdir(parents=True, exist_ok=True)
                 torch.save({
                     "model_state_dict": model.state_dict(),
-                    "config": {"in_dim": in_dim, "hidden_dim": 128,
-                               "num_classes": NUM_CLASSES},
+                    "config": {"in_dim": in_dim, "hidden_dim": 256,
+                               "num_classes": NUM_CLASSES,
+                               "edge_type_dim": EDGE_TYPE_DIM},
                     "cell_labels": CELL_LABELS,
                     "arch": arch,
                 }, exp_dir / "best_model.pt")

train_gnn.py

@@ -10,7 +10,9 @@ Text embeddings (from embed_text.py) are concatenated with structural features.
 from __future__ import annotations
 
 import json
+import math
 import random
+import re
 from collections import defaultdict
 from pathlib import Path
 from typing import Optional, Tuple
@@ -31,35 +33,173 @@ from label_utils import (
     normalize_label, is_known_label, clamp_header_level,
 )
 
-STRUCTURAL_FEAT_DIM = 56
-EDGE_TYPE_DIM = 3
+STRUCTURAL_FEAT_DIM = 71
+EDGE_TYPE_DIM = 21  # 5 edge types (one-hot) + 16 relative position encoding
 EMBED_DIM = 768
 
 EDGE_TYPE_SPATIAL = 0
 EDGE_TYPE_HIERARCHICAL = 1
 EDGE_TYPE_SHEET_TO_TABLE = 2
+EDGE_TYPE_ROW = 3
+EDGE_TYPE_COL = 4
+
+
+class FocalLoss(torch.nn.Module):
+    """Focal loss (Lin et al., ICCV 2017) with per-class alpha weights.
+
+    FL(p_t) = -alpha_t * (1 - p_t)^gamma * log(p_t)
+
+    When gamma=0 this reduces to weighted cross-entropy.
+    """
+
+    def __init__(self, alpha: torch.Tensor | None = None, gamma: float = 2.0,
+                 reduction: str = "mean"):
+        super().__init__()
+        self.gamma = gamma
+        self.reduction = reduction
+        self.register_buffer("alpha", alpha)
+
+    def forward(self, logits: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
+        ce_loss = F.cross_entropy(logits, targets, reduction="none")
+        p_t = torch.exp(-ce_loss)
+        focal_weight = (1 - p_t) ** self.gamma
+        if self.alpha is not None:
+            alpha_t = self.alpha.to(logits.device)[targets]
+            focal_weight = alpha_t * focal_weight
+        loss = focal_weight * ce_loss
+        if self.reduction == "mean":
+            return loss.mean()
+        elif self.reduction == "sum":
+            return loss.sum()
+        return loss
 
 
 # ═══════════════════════════════════════════════════════════════════════════
 # Data loading
 # ═══════════════════════════════════════════════════════════════════════════
 
-_MONTH_ABBREVS = {"jan", "feb", "mar", "apr", "may", "jun",
-                   "jul", "aug", "sep", "oct", "nov", "dec"}
+_MONTH_ABBREVS = {
+    # English
+    "jan", "feb", "mar", "apr", "may", "jun",
+    "jul", "aug", "sep", "oct", "nov", "dec",
+    # German
+    "mär", "mai", "okt", "dez",
+    # French
+    "janv", "févr", "mars", "avr", "juin", "juil", "août", "sept", "déc",
+    # Spanish
+    "ene", "abr", "ago", "dic",
+    # Polish
+    "sty", "lut", "kwi", "maj", "cze", "lip", "sie", "wrz", "paź", "lis", "gru",
+}
+
+_KW_TOTAL = {
+    # English
+    "total", "subtotal", "grand total",
+    # German
+    "gesamt", "summe", "zwischensumme", "insgesamt",
+    # French
+    "sous-total", "somme",
+    # Spanish / Portuguese / Catalan
+    "suma", "subtotal",
+    # Portuguese
+    "soma",
+    # Italian
+    "totale", "subtotale", "somma",
+    # Polish
+    "razem", "podsuma", "ogółem", "łącznie",
+    # Dutch
+    "totaal", "subtotaal", "som",
+    # Russian
+    "итого", "всего", "сумма",
+    # Japanese
+    "合計", "小計", "総計",
+    # Chinese
+    "合计", "小计", "总计",
+    # Korean
+    "합계", "소계", "총계",
+    # Turkish
+    "toplam", "ara toplam",
+    # Czech
+    "celkem", "součet",
+    # Swedish / Finnish
+    "totalt", "yhteensä",
+}
+
+_KW_SUM_AVG = {
+    # English
+    "sum", "average", "avg", "mean", "count",
+    # German
+    "durchschnitt", "mittelwert", "anzahl",
+    # French
+    "moyenne", "nombre",
+    # Spanish
+    "promedio", "media", "cuenta",
+    # Polish
+    "średnia", "liczba",
+    # Russian
+    "среднее", "количество",
+    # Japanese / Chinese
+    "平均",
+}
+
+_KW_DATE_TIME = {
+    # English
+    "date", "year", "month", "quarter",
+    # German
+    "datum", "jahr", "monat", "quartal",
+    # French
+    "année", "mois", "trimestre",
+    # Spanish
+    "fecha", "año", "mes",
+    # Polish
+    "data", "rok", "miesiąc", "kwartał",
+    # Russian
+    "дата", "год", "месяц", "квартал",
+    # Japanese
+    "日付", "年", "月", "四半期",
+    # Chinese
+    "日期", "季度",
+}
+
+_KW_NOTE_SOURCE = {
+    # English
+    "note", "notes", "source", "*see", "footnote", "remark",
+    # German
+    "quelle", "anmerkung", "hinweis", "fußnote",
+    # French
+    "remarque",
+    # Spanish
+    "fuente", "nota", "observación",
+    # Polish
+    "źródło", "uwaga", "przypis",
+    # Russian
+    "источник", "примечание", "сноска",
+}
+
+_UNIT_INDICATORS_WORD = {
+    "usd", "eur", "pln", "jpy", "gbp", "chf", "cad", "aud", "cny", "krw",
+    "mln", "tys", "bln", "trn",
+    "millions", "thousands", "billions", "units",
+    "bps", "pp", "kg", "mt", "mwh", "gwh", "kwh",
+}
+_UNIT_INDICATORS_SUBSTR = {"p.p.", "000s"}
+
+_FOOTNOTE_MARKERS = {"*", "**", "***", "†", "‡", "§", "¶", "||"}
 
 
 def _cell_features(cell: dict, max_row: int, max_col: int,
                    median_font_size: float = 11.0) -> list[float]:
     """Build a fixed-size numeric feature vector for a cell node.
 
-    56 dimensions total:
+    71 dimensions total:
       [0-2]   position (3)
       [3-11]  content stats (9)
       [12-27] formatting (16)
       [28-31] formula (4)
       [32-43] content type (12)
-      [44-54] keywords (11)
+      [44-54] keywords (11, multilingual)
       [55]    merge span (1)
+      [56-70] textual / punctuation features (15)
 
     Does NOT include table_id, is_sheet_metadata, or header_level — those
     are ground-truth labels and would cause leakage if used as input features.
@@ -110,11 +250,11 @@ def _cell_features(cell: dict, max_row: int, max_col: int,
     colspan = min(cell.get("colspan", 1), 20) / 20.0
     is_merge_origin = float(cell.get("is_merge_origin", False))
 
-    # --- Group C: keywords ---
-    kw_total = float(any(w in val_lower for w in ("total", "subtotal", "grand total")))
-    kw_sum_avg = float(any(w in val_lower for w in ("sum", "average", "avg", "mean", "count")))
-    kw_date_time = float(any(w in val_lower for w in ("date", "year", "month", "quarter")))
-    kw_note_source = float(any(w in val_lower for w in ("note", "notes", "source", "*see")))
+    # --- Group C: keywords (now multilingual) ---
+    kw_total = float(any(w in val_lower for w in _KW_TOTAL))
+    kw_sum_avg = float(any(w in val_lower for w in _KW_SUM_AVG))
+    kw_date_time = float(any(w in val_lower for w in _KW_DATE_TIME))
+    kw_note_source = float(any(w in val_lower for w in _KW_NOTE_SOURCE))
     kw_unnamed = float("unnamed:" in val_lower)
     kw_ref_error = float(any(w in val_lower for w in ("#ref!", "#n/a", "#value!", "#div!")))
     kw_asterisk = float(val_lower.startswith("*"))
@@ -124,6 +264,48 @@ def _cell_features(cell: dict, max_row: int, max_col: int,
         "amount", "price", "cost", "revenue", "profit", "loss", "net", "gross")))
     kw_month = float(any(m in val_lower.split() for m in _MONTH_ABBREVS))
 
+    # --- Group D: textual / punctuation features ---
+    val_stripped = val.strip()
+
+    starts_footnote = float(val_stripped in _FOOTNOTE_MARKERS
+                            or any(val_stripped.startswith(m) for m in _FOOTNOTE_MARKERS))
+
+    has_footnote_ref = float(bool(
+        re.search(r"\[\d+\]|\(\d+\)|\[[a-z]\]|[\u00B9\u00B2\u00B3\u2070-\u2079]", val)))
+
+    ends_colon = float(val_stripped.endswith(":"))
+
+    has_parenthetical = float(bool(
+        re.search(r"\([a-zA-Z%][a-zA-Z0-9% .,]*\)", val)))
+
+    letters_in_val = [ch for ch in val if ch.isalpha()]
+    is_all_caps = float(len(letters_in_val) > 0 and all(ch.isupper() for ch in letters_in_val))
+
+    has_numbering = float(bool(
+        re.match(r"^(\d{1,3}[\.\)]\s|[a-zA-Z][\.\)]\s|[ivxIVX]+[\.\)]\s)", val_stripped)))
+
+    val_lower_words = set(re.findall(r"[a-z0-9.]+", val_lower))
+    has_unit = float(bool(val_lower_words & _UNIT_INDICATORS_WORD)
+                     or any(u in val_lower for u in _UNIT_INDICATORS_SUBSTR)
+                     or any(sym in val for sym in ("$", "£", "€", "¥", "₩", "₽", "zł")))
+
+    n = len(val)
+    char_diversity = len(set(val)) / max(n, 1)
+    special_chars = sum(1 for ch in val if not ch.isalnum() and not ch.isspace())
+    special_char_ratio = special_chars / max(n, 1)
+    line_count = min(val.count("\n") + 1, 10) / 10.0
+
+    words = val.split()
+    if len(words) > 1:
+        wlens = [len(w) for w in words]
+        mean_wl = sum(wlens) / len(wlens)
+        token_len_var = sum((wl - mean_wl) ** 2 for wl in wlens) / len(wlens)
+        token_len_var = min(token_len_var, 100.0) / 100.0
+    else:
+        token_len_var = 0.0
+
+    leading_spaces = float(len(val) - len(val.lstrip(" "))) / 10.0
+
     return [
         # [0-2] position (3)
         r / max(max_row, 1),
@@ -169,7 +351,7 @@ def _cell_features(cell: dict, max_row: int, max_col: int,
         has_nf,
         nf_number, nf_date, nf_currency, nf_percent,
         is_merge_origin,
-        # [44-54] keywords (11)
+        # [44-54] keywords (11, now multilingual)
         kw_total,
         kw_sum_avg,
         kw_date_time,
@@ -183,6 +365,22 @@ def _cell_features(cell: dict, max_row: int, max_col: int,
         kw_month,
         # [55] merge span (1)
         (rowspan + colspan) / 2.0,
+        # [56-70] textual / punctuation features (15)
+        starts_footnote,
+        has_footnote_ref,
+        ends_colon,
+        has_parenthetical,
+        is_all_caps,
+        has_numbering,
+        has_unit,
+        char_diversity,
+        special_char_ratio,
+        line_count,
+        token_len_var,
+        leading_spaces,
+        float(val_stripped.startswith("(")),
+        float(val_stripped.endswith(")")),
+        float(":" in val and not val_stripped.endswith(":")),
     ]
 
 
@@ -240,6 +438,61 @@ def _build_spatial_edges(
     return [src, dst], edge_types
 
 
+def _build_row_col_edges(
+    cells: list[dict], idx_map: dict, table_groups: dict[int, set],
+    max_k: int = 32,
+) -> Tuple[list[list[int]], list[int]]:
+    """Connect cells sharing the same row or column within a table.
+
+    For groups with <=max_k cells, creates all pairwise edges.
+    For larger groups, connects each cell to max_k nearest neighbors
+    plus the first/last cell in the group.
+    """
+    table_rows: dict[int, dict[int, list]] = defaultdict(lambda: defaultdict(list))
+    table_cols: dict[int, dict[int, list]] = defaultdict(lambda: defaultdict(list))
+
+    for c in cells:
+        key = (c["row"], c["col"])
+        if key not in idx_map:
+            continue
+        tid = c.get("table", 0)
+        if tid == 0:
+            continue
+        table_rows[tid][c["row"]].append(idx_map[key])
+        table_cols[tid][c["col"]].append(idx_map[key])
+
+    src, dst, edge_types = [], [], []
+
+    def _add_edges(node_ids: list[int], etype: int):
+        n = len(node_ids)
+        if n <= 1:
+            return
+        if n <= max_k:
+            for i in range(n):
+                for j in range(i + 1, n):
+                    src.append(node_ids[i]); dst.append(node_ids[j]); edge_types.append(etype)
+                    src.append(node_ids[j]); dst.append(node_ids[i]); edge_types.append(etype)
+        else:
+            for i in range(n):
+                lo = max(0, i - max_k // 2)
+                hi = min(n, i + max_k // 2 + 1)
+                targets = set(range(lo, hi))
+                targets.add(0)
+                targets.add(n - 1)
+                targets.discard(i)
+                for j in targets:
+                    src.append(node_ids[i]); dst.append(node_ids[j]); edge_types.append(etype)
+
+    for tid in table_rows:
+        for row_nodes in table_rows[tid].values():
+            _add_edges(row_nodes, EDGE_TYPE_ROW)
+    for tid in table_cols:
+        for col_nodes in table_cols[tid].values():
+            _add_edges(col_nodes, EDGE_TYPE_COL)
+
+    return [src, dst], edge_types
+
+
 def _build_hierarchical_ground_truth(
     cells: list[dict], idx_map: dict, table_groups: dict[int, set]
 ) -> Tuple[list[list[int]], list[int]]:
@@ -454,28 +707,59 @@ def json_to_pyg(filepath: Path) -> Optional[Data]:
     # Spatial edges (within-table — used for GNN message passing)
     spatial_edges, spatial_types = _build_spatial_edges(all_cells, idx_map, table_groups)
 
+    # Row/column edges (within-table — long-range connectivity)
+    rc_edges, rc_types = _build_row_col_edges(all_cells, idx_map, table_groups)
+
     # Hierarchical edges (within-table)
     hier_edges, hier_types = _build_hierarchical_ground_truth(all_cells, idx_map, table_groups)
 
     # Sheet-to-table edges
     s2t_edges, s2t_types = _build_sheet_to_table_edges(all_cells, idx_map, table_groups)
 
-    # Combine all edges for GNN message passing
-    all_src = spatial_edges[0] + s2t_edges[0]
-    all_dst = spatial_edges[1] + s2t_edges[1]
-    all_types = spatial_types + s2t_types
+    # Combine all edges for GNN message passing:
+    # spatial + row/col + sheet-to-table + hierarchical (ground-truth during training)
+    all_src = spatial_edges[0] + rc_edges[0] + s2t_edges[0] + hier_edges[0]
+    all_dst = spatial_edges[1] + rc_edges[1] + s2t_edges[1] + hier_edges[1]
+    all_types = spatial_types + rc_types + s2t_types + hier_types
 
     if not all_src:
         return None
 
     edge_index = torch.tensor([all_src, all_dst], dtype=torch.long)
 
-    # Edge type features (one-hot)
-    edge_type_tensor = torch.zeros(len(all_types), EDGE_TYPE_DIM)
-    for i, et in enumerate(all_types):
-        edge_type_tensor[i, et] = 1.0
+    # Edge features: one-hot type + sinusoidal relative position encoding (vectorized)
+    num_edges = len(all_types)
+    edge_type_onehot = torch.zeros(num_edges, 5)
+    et_arr = torch.tensor(all_types, dtype=torch.long)
+    edge_type_onehot.scatter_(1, et_arr.unsqueeze(1), 1.0)
+
+    # Vectorized coordinate lookup for relative position encoding
+    node_rows = torch.zeros(len(all_cells), dtype=torch.float)
+    node_cols = torch.zeros(len(all_cells), dtype=torch.float)
+    for i, c in enumerate(all_cells):
+        node_rows[i] = c["row"]
+        node_cols[i] = c["col"]
+
+    src_t = torch.tensor(all_src, dtype=torch.long)
+    dst_t = torch.tensor(all_dst, dtype=torch.long)
+    dr = node_rows[dst_t] - node_rows[src_t]
+    dc = node_cols[dst_t] - node_cols[src_t]
+
+    REL_PE_DIM = 16
+    half = REL_PE_DIM // 4
+    div_term = torch.exp(
+        torch.arange(0, half, dtype=torch.float) * -(math.log(10000.0) / max(half, 1))
+    )
+    rel_pe = torch.cat([
+        torch.sin(dr.unsqueeze(-1) * div_term),
+        torch.cos(dr.unsqueeze(-1) * div_term),
+        torch.sin(dc.unsqueeze(-1) * div_term),
+        torch.cos(dc.unsqueeze(-1) * div_term),
+    ], dim=1)
+
+    edge_type_tensor = torch.cat([edge_type_onehot, rel_pe], dim=1)
 
-    # Hierarchical ground truth for edge prediction training
+    # Hierarchical ground truth for edge prediction training (separate from conv edges)
     if hier_edges[0]:
         hier_edge_index = torch.tensor(hier_edges, dtype=torch.long)
     else:
@@ -513,13 +797,23 @@ def json_to_pyg(filepath: Path) -> Optional[Data]:
     )
 
 
-def load_all_graphs() -> list[Data]:
-    """Load all labeled JSONs as PyG Data objects."""
+def load_all_graphs(max_nodes: int = 5000) -> list[Data]:
+    """Load all labeled JSONs as PyG Data objects.
+
+    Sheets with more than ``max_nodes`` cells are skipped to keep memory
+    bounded for attention-based models.  Set max_nodes=0 to disable.
+    """
     graphs = []
+    skipped = 0
     for fp in sorted(config.LABELED_DIR.glob("*.json")):
         g = json_to_pyg(fp)
         if g is not None:
+            if max_nodes > 0 and g.num_nodes > max_nodes:
+                skipped += 1
+                continue
             graphs.append(g)
+    if skipped:
+        print(f"  Skipped {skipped} graphs with >{max_nodes} nodes")
     return graphs
 
 
@@ -573,7 +867,8 @@ def sample_negative_edges(num_nodes: int, positive_edges: torch.Tensor, num_neg:
     return torch.tensor([neg_src, neg_dst], dtype=torch.long)
 
 
-def train_epoch(model, graphs, optimizer, device, class_weights=None):
+def train_epoch(model, graphs, optimizer, device, class_weights=None,
+                focal_loss_fn=None):
     model.train()
     total_node_loss = 0
     total_edge_loss = 0
@@ -587,11 +882,13 @@ def train_epoch(model, graphs, optimizer, device, class_weights=None):
         edge_attr = g.edge_attr if hasattr(g, "edge_attr") and g.edge_attr is not None else None
         h = model(g.x, g.edge_index, edge_attr)
 
-        # --- node classification loss (class-weighted) ---
         node_logits = model.classify_nodes(h)
         mask = g.train_mask
         if mask.sum() > 0:
-            node_loss = F.cross_entropy(node_logits[mask], g.y[mask], weight=cw)
+            if focal_loss_fn is not None:
+                node_loss = focal_loss_fn(node_logits[mask], g.y[mask])
+            else:
+                node_loss = F.cross_entropy(node_logits[mask], g.y[mask], weight=cw)
         else:
             node_loss = torch.tensor(0.0, device=device)
 
@@ -705,9 +1002,10 @@ def train_model(num_epochs: int = 100, lr: float = 1e-3, skip_predict: bool = Fa
 
     print(f"Train graphs: {len(train_graphs)}, Val graphs: {len(val_graphs)}")
 
-    model = SpreadsheetGNN(in_dim=in_dim, hidden_dim=128).to(device)
+    model = SpreadsheetGNN(in_dim=in_dim, hidden_dim=256).to(device)
     optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=1e-4)
     scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)
+    focal_loss_fn = FocalLoss(alpha=class_weights, gamma=2.0).to(device)
 
     best_val_acc = 0
     best_state = None
@@ -716,6 +1014,7 @@ def train_model(num_epochs: int = 100, lr: float = 1e-3, skip_predict: bool = Fa
         random.shuffle(train_graphs)
         node_loss, edge_loss, table_loss = train_epoch(
             model, train_graphs, optimizer, device, class_weights,
+            focal_loss_fn=focal_loss_fn,
         )
         scheduler.step()
 
@@ -742,7 +1041,8 @@ def train_model(num_epochs: int = 100, lr: float = 1e-3, skip_predict: bool = Fa
     version = _next_model_version()
     checkpoint = {
         "model_state_dict": model.state_dict(),
-        "config": {"in_dim": in_dim, "hidden_dim": 128, "num_classes": NUM_CLASSES},
+        "config": {"in_dim": in_dim, "hidden_dim": 256, "num_classes": NUM_CLASSES,
+                   "edge_type_dim": EDGE_TYPE_DIM},
         "cell_labels": CELL_LABELS,
         "version": version,
         "num_training_sheets": len(graphs),