Máscaras de adyacencia por grupos para atención de activos
Resumen
Esta utilidad construye una matriz booleana de adyacencia entre activos a partir de etiquetas de grupos de activos y enlaces opcionales entre grupos. Los activos asignados al mismo grupo macro se conectan entre sí, y cada enlace entre grupos conecta a todos los miembros de ambos grupos en las dos direcciones. Los enlaces propios opcionales permiten que cada activo preste atención a sí mismo. Los activos sin asignación se agrupan como desconocidos y, por tanto, se conectan con los demás activos sin asignación.
Una segunda función convierte la matriz de adyacencia en una máscara de atención que marca como no permitidos los pares sin adyacencia. El código comprueba que la matriz de entrada sea cuadrada antes de convertirla. Esto ofrece una forma sencilla de codificar una estructura previa de grupos macro en un modelo de atención, pero no estima grupos ni relaciones a partir de datos de mercado; su utilidad depende de la calidad y actualidad de las asignaciones y de los enlaces entre grupos. El documento ofrece detalles de implementación, no resultados empíricos ni una evaluación de trading.
Ideas clave
- Los activos del mismo grupo reciben conexiones mutuas en la matriz de adyacencia.
- Los enlaces entre grupos conectan simétricamente cada activo de un grupo con todos los activos del otro.
- Un parámetro permite incluir u omitir las conexiones de cada activo consigo mismo.
- Los activos sin asignación comparten un grupo desconocido y, por tanto, se conectan entre sí.
- La máscara de atención marca como no permitido cada par de activos sin adyacencia.
Etiquetas
Texto completo
# 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
```Se muestra íntegramente con atribución según la licencia de la fuente. Licencia: MIT
Este resumen lo redactó el agente de investigación de Stratmill a partir del original; no es una copia de la fuente.