Créer des masques d’adjacence macro pour l’attention des actifs
Résumé
Cet utilitaire construit une matrice d’adjacence booléenne entre actifs à partir d’étiquettes de groupe et de liens facultatifs entre groupes. Les actifs affectés au même groupe macro sont reliés entre eux, et chaque lien fourni entre groupes relie dans les deux sens tous les membres des deux groupes. Des liens réflexifs facultatifs permettent à chaque actif de prêter attention à lui-même. Les actifs sans correspondance sont affectés à un groupe inconnu et sont donc reliés aux autres actifs sans correspondance.
Une deuxième fonction convertit la matrice d’adjacence en masque d’attention en marquant comme interdites les paires non adjacentes. Le code vérifie que la matrice d’entrée est carrée avant la conversion. Cela offre un moyen simple d’encoder une hypothèse préalable de regroupement macro dans un modèle d’attention, mais l’utilitaire n’estime pas les groupes ni les relations à partir des données de marché, et son utilité dépend de la qualité et de l’actualité du mappage et des liens entre groupes fournis. Le document présente des détails d’implémentation, plutôt que des résultats empiriques ou une évaluation de trading.
Idées clés
- Les actifs d’un même groupe sont reliés entre eux dans la matrice d’adjacence.
- Les liens entre groupes relient symétriquement chaque actif d’un groupe à chaque actif de l’autre.
- Un paramètre permet d’inclure ou d’exclure les auto-liens.
- Les actifs non associés à un groupe partagent un groupe inconnu et sont donc reliés entre eux.
- Le masque d’attention interdit chaque paire d’actifs non adjacents.
Étiquettes
Texte intégral
# graph.py
```py
"""Macroeconomic graph prior utilities.
Builds an asset-level adjacency matrix from macro group labels and
cross-group edges for adjacency-masked attention in DeePM.
"""
from __future__ import annotations
from collections.abc import Iterable, Sequence
from dataclasses import dataclass
import numpy as np
@dataclass(frozen=True, slots=True)
class MacroGraph:
"""Asset-level macro graph."""
assets: list[str]
groups: list[str]
adjacency: np.ndarray # Boolean (N, N)
def build_macro_adjacency(
*,
assets: Sequence[str],
asset_to_group: dict[str, str],
cross_group_edges: Iterable[tuple[str, str]] = (),
include_self_loops: bool = True,
) -> MacroGraph:
"""Build a boolean adjacency matrix from group labels and group edges.
Parameters
----------
assets: Asset identifiers matching the price panel columns.
asset_to_group: Mapping from asset -> macro group label.
cross_group_edges: Undirected (group_a, group_b) edges.
include_self_loops: If True, sets A[i,i] = True.
"""
assets_list = [str(a) for a in assets]
groups = [str(asset_to_group.get(a, "UNKNOWN")) for a in assets_list]
n = len(assets_list)
adj = np.zeros((n, n), dtype=bool)
if include_self_loops:
np.fill_diagonal(adj, True)
group_to_indices: dict[str, list[int]] = {}
for i, g in enumerate(groups):
group_to_indices.setdefault(g, []).append(i)
for indices in group_to_indices.values():
idx = np.array(indices, dtype=int)
adj[np.ix_(idx, idx)] = True
for g1, g2 in cross_group_edges:
idx1 = group_to_indices.get(g1, [])
idx2 = group_to_indices.get(g2, [])
if not idx1 or not idx2:
continue
a = np.array(idx1, dtype=int)
b = np.array(idx2, dtype=int)
adj[np.ix_(a, b)] = True
adj[np.ix_(b, a)] = True
return MacroGraph(assets=assets_list, groups=groups, adjacency=adj)
def adjacency_to_attn_mask(adjacency: np.ndarray) -> np.ndarray:
"""Convert boolean adjacency to attention mask (True = disallowed)."""
if adjacency.ndim != 2 or adjacency.shape[0] != adjacency.shape[1]:
raise ValueError("adjacency must be square (N,N)")
return ~adjacency
```Reproduit dans son intégralité avec attribution, conformément à la licence de la source. Licence: MIT
Ce résumé a été rédigé par l’agent de recherche de Stratmill à partir de la source originale ; il n’en est pas une copie.