From 4c774a3ab24c79f2d1d87925cd76b7c4ff031f98 Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Wed, 12 Aug 2026 16:25:31 -0400 Subject: [PATCH 01/14] MultiOrderModel now holds HigherOrderGraph in its layers --- src/pathpyG/__init__.py | 2 + src/pathpyG/core/multi_order_model.py | 69 +++++++++++++++++++-------- 2 files changed, 50 insertions(+), 21 deletions(-) diff --git a/src/pathpyG/__init__.py b/src/pathpyG/__init__.py index 4c365455..c4c23c9a 100644 --- a/src/pathpyG/__init__.py +++ b/src/pathpyG/__init__.py @@ -8,6 +8,7 @@ __version__ = get_version("pathpyG") from pathpyG.core.graph import Graph +from pathpyG.core.higher_order_graph import HigherOrderGraph from pathpyG.core.index_map import IndexMap from pathpyG.core.multi_order_model import MultiOrderModel from pathpyG.core.path_data import PathData @@ -21,6 +22,7 @@ __all__ = [ "Graph", + "HigherOrderGraph", "TemporalGraph", "EventGraph", "PathData", diff --git a/src/pathpyG/core/multi_order_model.py b/src/pathpyG/core/multi_order_model.py index 542156ac..88d068f7 100644 --- a/src/pathpyG/core/multi_order_model.py +++ b/src/pathpyG/core/multi_order_model.py @@ -17,11 +17,10 @@ lift_order_edge_index_weighted, ) from pathpyG.core.event_graph import EventGraph -from pathpyG.core.graph import Graph +from pathpyG.core.higher_order_graph import HigherOrderGraph from pathpyG.core.index_map import IndexMap from pathpyG.core.path_data import PathData from pathpyG.core.temporal_graph import TemporalGraph -from pathpyG.utils.dbgnn import generate_bipartite_edge_index logger = logging.getLogger("root") @@ -31,13 +30,17 @@ class MultiOrderModel: This class stores multiple higher-order De Bruijn graphs as layers in a dictionary. Each layer corresponds to a De Bruijn graph of order k, where k is the key in the dictionary. - Each graph layer is represented as a [pathpyG.Graph][] object. + Each graph layer is represented as a + [HigherOrderGraph][pathpyG.core.higher_order_graph.HigherOrderGraph] object, layer 1 + included. Each layer therefore knows its own order and the first-order nodes it was + built from, so results can be projected back onto entities without the caller keeping + track of it. This class provides methods to search for the optimal order of the model based on likelihood ratio tests, as well as methods to compute the log-likelihood of observed paths given the model. Attributes: - layers (dict[int, Graph]): A dictionary mapping the order k to the corresponding - higher-order De Bruijn graph of order k. + layers (dict[int, HigherOrderGraph]): A dictionary mapping the order k to the + corresponding higher-order De Bruijn graph of order k. Examples: Example where the optimal order is 1: @@ -56,11 +59,15 @@ class MultiOrderModel: >>> m = MultiOrderModel.from_path_data(paths, max_order=2) >>> print(m.estimate_order(paths, max_order=2)) 2 + + Each layer knows the first-order path that each of its nodes represents: + >>> print(m.layers[2].order, m.layers[2].nodes) + 2 [('a', 'c'), ('b', 'c'), ('c', 'd'), ('c', 'e')] """ def __init__(self) -> None: """Initialize an empty MultiOrderModel.""" - self.layers: dict[int, Graph] = {} + self.layers: dict[int, HigherOrderGraph] = {} def __str__(self) -> str: """Return a string representation of the higher-order graph.""" @@ -88,7 +95,8 @@ def iterate_lift_order( edge_weight: torch.Tensor | None = None, aggr: str = "src", save: bool = True, - ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None, Graph | None]: + n_first_order: Optional[int] = None, + ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None, HigherOrderGraph | None]: """Lift order by one and save the result in the layers dictionary of the object. This is a helper function that should not be called directly. @@ -103,6 +111,8 @@ def iterate_lift_order( k: The order of the graph that should be computed. aggr: The aggregation method to use. One of "src", "dst", "max", "mul". save: Whether to compute the aggregated graph and later save it in the layers dictionary. + n_first_order: The number of first-order nodes the node sequences refer to. + Defaults to the number of IDs in `mapping`. """ # Lift order if edge_weight is None: @@ -115,8 +125,13 @@ def iterate_lift_order( # Aggregate if save: - gk = aggregate_edge_index(ho_index, node_sequence, edge_weight) - gk.mapping = IndexMap([tuple(mapping.to_ids(v.cpu())) for v in gk.data.node_sequence]) + gk = HigherOrderGraph.from_aggregated( + ho_index, + node_sequence, + first_order_mapping=mapping, + edge_weight=edge_weight, + n_first_order=n_first_order, + ) else: gk = None return ho_index, node_sequence, edge_weight, gk @@ -156,10 +171,13 @@ def from_temporal_graph( else: edge_weight = torch.ones(edge_index.size(1), device=edge_index.device) if cached or max_order == 1: - m.layers[1] = aggregate_edge_index( - edge_index=edge_index, node_sequence=node_sequence, edge_weight=edge_weight + m.layers[1] = HigherOrderGraph.from_aggregated( + edge_index=edge_index, + node_sequence=node_sequence, + edge_weight=edge_weight, + first_order_mapping=g.mapping, + n_first_order=g.n, ) - m.layers[1].mapping = g.mapping if max_order > 1: node_sequence = torch.cat([node_sequence[edge_index[0]], node_sequence[edge_index[1]][:, -1:]], dim=1) @@ -171,11 +189,12 @@ def from_temporal_graph( # Aggregate if cached or max_order == 2: - m.layers[2] = aggregate_edge_index( - edge_index=edge_index, node_sequence=node_sequence, edge_weight=edge_weight - ) - m.layers[2].mapping = IndexMap( - [tuple(g.mapping.to_ids(v.cpu())) for v in m.layers[2].data.node_sequence] + m.layers[2] = HigherOrderGraph.from_aggregated( + edge_index=edge_index, + node_sequence=node_sequence, + edge_weight=edge_weight, + first_order_mapping=g.mapping, + n_first_order=g.n, ) for k in range(3, max_order + 1): @@ -186,6 +205,7 @@ def from_temporal_graph( edge_weight=edge_weight, aggr="src", save=cached or k == max_order, + n_first_order=g.n, ) if cached or k == max_order: m.layers[k] = gk # type: ignore[assignment] @@ -251,17 +271,24 @@ def from_path_data( elif mode == "propagation": aggr = "src" - m.layers[1] = aggregate_edge_index(edge_index=edge_index, node_sequence=node_sequence, edge_weight=edge_weight) - m.layers[1].mapping = path_data.mapping + g1 = aggregate_edge_index(edge_index=edge_index, node_sequence=node_sequence, edge_weight=edge_weight) + g1.mapping = path_data.mapping + # Nodes that are not traversed by any path are not part of the aggregated graph, + # so the first-order node set can be larger than the order-1 layer. + n_first_order = max(path_data.mapping.num_ids(), g1.n) + m.layers[1] = HigherOrderGraph.from_aggregated_graph( + g1, first_order_mapping=path_data.mapping, n_first_order=n_first_order + ) for k in range(2, max_order + 1): edge_index, node_sequence, edge_weight, gk = MultiOrderModel.iterate_lift_order( edge_index=edge_index, node_sequence=node_sequence, - mapping=m.layers[1].mapping, + mapping=path_data.mapping, edge_weight=edge_weight, aggr=aggr, save=cached or k == max_order, + n_first_order=n_first_order, ) if cached or k == max_order: m.layers[k] = gk # type: ignore[assignment] @@ -563,7 +590,7 @@ def to_dbgnn_data(self, max_order: int = 2, mapping: str = "last") -> Data: edge_index_max_order = g_max_order.data.edge_index edge_weight = g.data.edge_weight edge_weight_max_order = g_max_order.data.edge_weight - bipartite_edge_index = generate_bipartite_edge_index(g, g_max_order, mapping=mapping, device=edge_index.device) + bipartite_edge_index = g_max_order.bipartite_edge_index(g, mapping=mapping, device=edge_index.device) if g.data.y is not None: y = g.data.y From 59bfa8b695f9adc587ce180810ff96077297fc1d Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Wed, 12 Aug 2026 16:59:02 -0400 Subject: [PATCH 02/14] added missing HigherOrderGraph class --- src/pathpyG/core/higher_order_graph.py | 521 +++++++++++++++++++++++++ 1 file changed, 521 insertions(+) create mode 100644 src/pathpyG/core/higher_order_graph.py diff --git a/src/pathpyG/core/higher_order_graph.py b/src/pathpyG/core/higher_order_graph.py new file mode 100644 index 00000000..56b7bebc --- /dev/null +++ b/src/pathpyG/core/higher_order_graph.py @@ -0,0 +1,521 @@ +"""Higher-order De Bruijn graph representation and related operations.""" + +from __future__ import annotations + +import logging +from typing import Optional, Union + +import torch +from torch_geometric import EdgeIndex +from torch_geometric.data import Data +from torch_geometric.utils import coalesce + +from pathpyG.algorithms.lift_order import aggregate_edge_index, lift_order_edge_index_weighted +from pathpyG.core.event_graph import EventGraph +from pathpyG.core.graph import Graph +from pathpyG.core.index_map import IndexMap +from pathpyG.core.path_data import PathData +from pathpyG.core.temporal_graph import TemporalGraph + +logger = logging.getLogger("root") + + +class HigherOrderGraph(Graph): + """A De Bruijn graph of order `k`, whose nodes are paths of `k` first-order nodes. + + Where a [`Graph`][pathpyG.Graph] has one node per entity and an + [`EventGraph`][pathpyG.core.event_graph.EventGraph] has one node per observed + interaction, a `HigherOrderGraph` has one node per *distinct* path of length `k` + in the underlying first-order graph. Repeated observations of the same path are + aggregated into an `edge_weight`, so timestamps are no longer represented: this + is a model of how paths flow rather than a record of what happened. + + Order 1 is the degenerate case and is simply the weighted first-order graph, with + plain node IDs rather than tuples. + + Info: + In addition to the attributes of [`Graph`][pathpyG.Graph], the `data` object holds: + + - `node_sequence`: [Tensor][torch.Tensor] of shape `(num_nodes, order)`, the + first-order node indices making up the path each higher-order node represents. + - `edge_weight`: [Tensor][torch.Tensor] with the aggregated weight of each transition. + - `inverse_idx`: [Tensor][torch.Tensor] mapping each row of the *pre-aggregation* + node sequence to the index of the higher-order node it was merged into. + + Attributes: + data (Data): PyG Data object containing edges and attributes. + mapping (IndexMap): Mapping from higher-order node IDs (tuples, for order > 1) to indices. + first_order_mapping (IndexMap): Mapping of the underlying first-order node IDs to indices. + n_first_order (int): Number of first-order nodes the higher-order nodes are built from. + + Examples: + >>> import pathpyG as pp + >>> from pathpyG.core.higher_order_graph import HigherOrderGraph + >>> g = pp.Graph.from_edge_list([("a", "c"), ("c", "d")]) + >>> h = HigherOrderGraph.from_graph(g) + >>> print(h.order, h.nodes) + 1 ['a', 'c', 'd'] + """ + + def __init__( + self, + data: Data, + order: Optional[int] = None, + first_order_mapping: Optional[IndexMap] = None, + n_first_order: Optional[int] = None, + mapping: Optional[IndexMap] = None, + ) -> None: + """Create a HigherOrderGraph from a `Data` object carrying a `node_sequence`. + + Args: + data: PyG `Data` object with an `edge_index` and a `node_sequence` of shape + `(num_nodes, order)`. For order 1, the `node_sequence` may be omitted and + is then taken to be the identity. + order: Expected order `k`. If given, it is validated against the width of the + node sequence; if omitted, the order is inferred from it. + first_order_mapping: Mapping of the underlying first-order node IDs. Defaults + to an empty mapping. + n_first_order: Number of first-order nodes. Defaults to the number of IDs in + `first_order_mapping`, or the largest index in the node sequence plus one. + mapping: Mapping of higher-order node IDs to indices. For order > 1 this must + use tuple IDs; for order 1 it must not. + + Raises: + ValueError: If the order, the node sequence, and the mapping disagree, or if + the node sequence refers to first-order nodes that do not exist. + """ + if "node_sequence" not in data and order not in (None, 1): + raise ValueError(f"A HigherOrderGraph of order {order} requires a `node_sequence` node attribute.") + + if isinstance(data.edge_index, EdgeIndex): + # `Graph.__init__` re-sorts the edge index and reindexes every edge attribute by + # the returned permutation - but `EdgeIndex.sort_by` returns `None` for an index + # already known to be sorted, and `attr[None]` would add a dimension. Higher-order + # graphs are routinely built from already-aggregated (hence sorted) data, so hand + # the base class a plain tensor and let it derive a real permutation. + data.edge_index = data.edge_index.as_tensor() + + super().__init__(data, mapping=mapping) + + # `Graph` creates an identity node sequence if none is given, so `self.order` + # (inherited: the width of the node sequence) is now well-defined. + if order is not None and order != self.order: + raise ValueError(f"order={order} does not match node sequence of width {self.order}") + + if first_order_mapping is not None: + self.first_order_mapping = first_order_mapping + elif self.order == 1: + # For order 1 the higher-order nodes *are* the first-order nodes. + self.first_order_mapping = self.mapping + else: + self.first_order_mapping = IndexMap() + + if n_first_order is not None: + self._n_first_order = int(n_first_order) + elif self.first_order_mapping.has_ids: + self._n_first_order = self.first_order_mapping.num_ids() + elif self.data.node_sequence.numel() > 0: + self._n_first_order = int(self.data.node_sequence.max().item()) + 1 + else: + self._n_first_order = 0 + + self._validate() + + def _validate(self) -> None: + """Check that order, node sequence, mapping and first-order node set agree.""" + if self.data.node_sequence.numel() > 0: + max_idx = int(self.data.node_sequence.max().item()) + if max_idx >= self._n_first_order: + raise ValueError( + f"node sequence refers to first-order node {max_idx}, " + f"but there are only {self._n_first_order} first-order nodes" + ) + + if self.mapping.has_ids: + # Higher-order nodes are paths and are identified by tuples; first-order + # nodes are entities and are identified by plain IDs. + if self.mapping.has_tuple_ids != (self.order > 1): + raise ValueError( + f"a mapping for a graph of order {self.order} must " + f"{'use' if self.order > 1 else 'not use'} tuple IDs" + ) + if self.mapping.num_ids() != self.n: + logger.warning( + "mapping has %s IDs but graph has %s nodes", self.mapping.num_ids(), self.n + ) + + @staticmethod + def _validate_order(order: int) -> None: + """Reject orders for which no De Bruijn graph is defined.""" + if order < 1: + logger.error("order must be at least 1, got %s", order) + raise ValueError(f"order must be at least 1, got {order}") + + @staticmethod + def _build_mapping(node_sequence: torch.Tensor, first_order_mapping: IndexMap) -> IndexMap: + """Build the higher-order `IndexMap` naming each node by the path it represents.""" + # TODO: Is it better to have a single HigherOrderMapping class? + order = node_sequence.size(1) + if node_sequence.size(0) == 0: + # An order beyond the longest observed path yields a graph without nodes, + # and `IndexMap` cannot be built from an empty list of IDs. + return IndexMap() + if order == 1: + # Order-1 node indices are first-order node indices, so the mapping carries over. + return first_order_mapping + if first_order_mapping.has_ids: + return IndexMap([tuple(first_order_mapping.to_ids(v.cpu())) for v in node_sequence]) + return IndexMap([tuple(v.tolist()) for v in node_sequence]) + + @classmethod + def from_aggregated( + cls, + edge_index: torch.Tensor, + node_sequence: torch.Tensor, + first_order_mapping: Optional[IndexMap] = None, + edge_weight: Optional[torch.Tensor] = None, + n_first_order: Optional[int] = None, + aggr: str = "sum", + ) -> HigherOrderGraph: + """Aggregate a (possibly duplicated) higher-order edge index into a De Bruijn graph. + + This is the single place where higher-order nodes get their identity: duplicate + node sequences are merged, edge weights are aggregated, and the higher-order + `IndexMap` naming each node by its path is built. + + Args: + edge_index: Edge index whose nodes are indices into `node_sequence`. + node_sequence: Tensor of shape `(num_nodes, order)` with the first-order path + each (not yet aggregated) node represents. + first_order_mapping: Mapping of the underlying first-order node IDs. + edge_weight: Weight of each edge prior to aggregation. Defaults to ones. + n_first_order: Number of first-order nodes, including isolated ones. + aggr: Reduction used for the edge weights. One of "sum", "mean", "min", "max". + + Returns: + HigherOrderGraph: The aggregated higher-order graph. + """ + if isinstance(edge_index, torch.Tensor) and hasattr(edge_index, "as_tensor"): + edge_index = edge_index.as_tensor() + + order = node_sequence.size(1) + if first_order_mapping is None: + first_order_mapping = IndexMap() + if n_first_order is None: + if first_order_mapping.has_ids: + n_first_order = first_order_mapping.num_ids() + else: + n_first_order = int(node_sequence.max().item()) + 1 if node_sequence.numel() > 0 else 0 + + data = aggregate_edge_index(edge_index, node_sequence, edge_weight, aggr=aggr).data + + if order == 1 and n_first_order > data.num_nodes: + # Order-1 indices are first-order indices, so first-order nodes that are not + # traversed by any path are simply isolated nodes of the order-1 graph. + data.num_nodes = n_first_order + data.node_sequence = torch.arange(n_first_order, device=edge_index.device).unsqueeze(1) + + return cls( + data, + order=order, + first_order_mapping=first_order_mapping, + n_first_order=n_first_order, + mapping=cls._build_mapping(data.node_sequence, first_order_mapping), + ) + + @classmethod + def from_aggregated_graph( + cls, + g: Graph, + first_order_mapping: Optional[IndexMap] = None, + n_first_order: Optional[int] = None, + ) -> HigherOrderGraph: + """Adopt an already-aggregated [`Graph`][pathpyG.Graph] as a higher-order graph. + + Used to give the layers computed by a multi-order model their proper type. The + underlying `data` object is shared, not copied. + + Args: + g: Aggregated graph carrying a `node_sequence` of shape `(num_nodes, order)`. + first_order_mapping: Mapping of the underlying first-order node IDs. + n_first_order: Number of first-order nodes. + + Returns: + HigherOrderGraph: The same graph, typed as a higher-order graph. + """ + if isinstance(g, HigherOrderGraph): + return g + return cls( + g.data, + first_order_mapping=first_order_mapping, + n_first_order=n_first_order, + mapping=g.mapping, + ) + + @classmethod + def from_graph(cls, g: Graph, weight: str = "edge_weight") -> HigherOrderGraph: + """Create the order-1 graph corresponding to a first-order graph. + + Multi-edges are coalesced into a single weighted edge. + + Args: + g: First-order graph. + weight: Name of the edge attribute to use as edge weight. If absent, each + edge counts once. + + Returns: + HigherOrderGraph: A higher-order graph of order 1. + """ + edge_index = g.data.edge_index.as_tensor() + if weight in g.data: + edge_weight = g.data[weight] + else: + edge_weight = torch.ones(edge_index.size(1), device=edge_index.device) + node_sequence = torch.arange(g.n, device=edge_index.device).unsqueeze(1) + + return cls.from_aggregated( + edge_index, + node_sequence, + first_order_mapping=g.mapping, + edge_weight=edge_weight, + n_first_order=g.n, + ) + + @classmethod + def from_temporal_graph( + cls, + g: TemporalGraph, + order: int = 1, + delta: float | int = 1, + weight: str = "edge_weight", + ) -> HigherOrderGraph: + """Create the De Bruijn graph of order `k` for time-respecting paths in a temporal graph. + + Order 1 is simply the weighted static graph and ignores `delta`; for higher orders + the nodes are the time-respecting paths of `k` nodes, i.e. those whose consecutive + interactions are at most `delta` apart. Orders above 2 are reached by repeatedly + lifting the *unaggregated* data, so the edge weights count observed paths rather + than being implied by lower-order statistics (unlike [`lift`][pathpyG.HigherOrderGraph.lift]). + + Args: + g: The temporal graph. + order: The order `k` of the graph to compute. + delta: The maximum time difference between two consecutive interactions of a path. + weight: The edge attribute of `g` to use as edge weight. + + Returns: + HigherOrderGraph: A higher-order graph of order `order`. It has no nodes if + there is no time-respecting path of that length. + + Examples: + >>> import pathpyG as pp + >>> t = pp.TemporalGraph.from_edge_list([("a", "c", 1), ("c", "d", 2)]) + >>> print(pp.HigherOrderGraph.from_temporal_graph(t, order=2, delta=1).nodes) + [('a', 'c'), ('c', 'd')] + """ + cls._validate_order(order) + # Imported here because `MultiOrderModel` builds `HigherOrderGraph` layers itself. + from pathpyG.core.multi_order_model import MultiOrderModel + + return MultiOrderModel.from_temporal_graph( + g, delta=delta, max_order=order, weight=weight, cached=False + ).layers[order] + + @classmethod + def from_path_data(cls, path_data: PathData, order: int = 1, mode: str = "propagation") -> HigherOrderGraph: + """Create the De Bruijn graph of order `k` modelling paths in [`PathData`][pathpyG.PathData]. + + Args: + path_data: The observed paths. + order: The order `k` of the graph to compute. + mode: The process that we assume. Either "diffusion" or "propagation". + + Returns: + HigherOrderGraph: A higher-order graph of order `order`. It has no nodes if + no observed path is that long. + + Examples: + >>> import pathpyG as pp + >>> paths = pp.PathData(pp.IndexMap(list("acd"))) + >>> paths.append_walk(("a", "c", "d"), weight=2) + >>> print(pp.HigherOrderGraph.from_path_data(paths, order=2).nodes) + [('a', 'c'), ('c', 'd')] + """ + cls._validate_order(order) + from pathpyG.core.multi_order_model import MultiOrderModel + + return MultiOrderModel.from_path_data(path_data, max_order=order, mode=mode, cached=False).layers[order] + + @classmethod + def from_event_graph(cls, eg: EventGraph, order: int = 2) -> HigherOrderGraph: + """Aggregate an [`EventGraph`][pathpyG.core.event_graph.EventGraph] into an order-`k` graph. + + For the default order 2, every event whose underlying `(u, v)` pair is the same + collapses into a single second-order node, and repeated continuations become an + edge weight. Timestamps and the time window `delta` are not represented in the + result. Other orders are computed from the time-respecting paths that the event + graph encodes, which for orders above 2 means lifting its continuations further. + + Args: + eg: The second-order temporal event graph to aggregate. + order: The order `k` of the graph to compute. + + Returns: + HigherOrderGraph: A higher-order graph of order `order`. It has no nodes if + there is no time-respecting path of that length. + """ + if order != 2: + cls._validate_order(order) + from pathpyG.core.multi_order_model import MultiOrderModel + + return MultiOrderModel.from_event_graph(eg, max_order=order, cached=False).layers[order] + + edge_index = eg.data.edge_index.as_tensor() + # Each continuation carries the weight of the event it starts from, matching the + # "src" aggregation used when building order-2 layers from a temporal graph. + edge_weight = torch.ones(edge_index.size(1), device=edge_index.device) + + return cls.from_aggregated( + edge_index, + eg.data.node_sequence, + first_order_mapping=eg.first_order_mapping, + edge_weight=edge_weight, + n_first_order=eg.n_first_order, + ) + + def lift(self, aggr: str = "src") -> HigherOrderGraph: + """Return the De Bruijn graph of order `k + 1` obtained by lifting this graph. + + Nodes of the result are the edges of this graph, i.e. the paths of length `k + 1` + that exist in this graph's topology. + + Warning: + This lifts an *aggregated* graph, so the resulting edge weights are those + implied by the order-`k` statistics rather than counts of observed paths of + length `k + 1`. To fit a layer to observations, use + [`MultiOrderModel`][pathpyG.MultiOrderModel], which lifts the unaggregated data. + + Args: + aggr: Aggregation used for the lifted edge weights. One of "src", "dst", + "max", "mul" or "add". + + Returns: + HigherOrderGraph: A higher-order graph of order `k + 1`. + """ + edge_index = self.data.edge_index.as_tensor() + if "edge_weight" in self.data: + edge_weight = self.data.edge_weight + else: + edge_weight = torch.ones(edge_index.size(1), device=edge_index.device) + + ho_index, ho_weight = lift_order_edge_index_weighted( + edge_index, edge_weight=edge_weight, num_nodes=self.n, aggr=aggr + ) + node_sequence = torch.cat( + [self.data.node_sequence[edge_index[0]], self.data.node_sequence[edge_index[1]][:, -1:]], dim=1 + ) + + return HigherOrderGraph.from_aggregated( + ho_index, + node_sequence, + first_order_mapping=self.first_order_mapping, + edge_weight=ho_weight, + n_first_order=self.n_first_order, + ) + + def to_first_order(self, mode: str = "last") -> Graph: + """Project the higher-order graph back onto the first-order nodes. + + Each higher-order node is replaced by one of the first-order nodes of its path, + and the weights of higher-order edges mapping to the same first-order edge are + summed. First-order nodes not traversed by any path remain as isolated nodes. + + Args: + mode: Which first-order node of the path represents it. Either "last" or "first". + + Returns: + Graph: A weighted first-order graph. + """ + if mode == "last": + projection = self.data.node_sequence[:, -1] + elif mode == "first": + projection = self.data.node_sequence[:, 0] + else: + raise ValueError(f"Unknown mode {mode}. Only 'last' and 'first' are accepted.") + + edge_index = projection[self.data.edge_index.as_tensor()] + if "edge_weight" in self.data: + edge_weight = self.data.edge_weight + else: + edge_weight = torch.ones(edge_index.size(1), device=edge_index.device) + edge_index, edge_weight = coalesce( + edge_index, edge_attr=edge_weight, num_nodes=self.n_first_order, reduce="sum" + ) + + return Graph( + Data(edge_index=edge_index, edge_weight=edge_weight, num_nodes=self.n_first_order), + mapping=self.first_order_mapping, + ) + + def bipartite_edge_index( + self, + first_order_graph: Optional[Graph] = None, + mapping: str = "last", + device: Optional[torch.device] = None, + ) -> torch.Tensor: + """Return the edge index connecting higher-order nodes to first-order nodes. + + Used by the [DBGNN][pathpyG.nn.dbgnn.DBGNN] model to pass messages from + higher-order node representations to first-order ones. Unlike the free function + [`generate_bipartite_edge_index`][pathpyG.utils.dbgnn.generate_bipartite_edge_index], + this works for any order: "last" refers to the last node of the path, whatever + its length. + + Args: + first_order_graph: The first-order graph. Optional; accepted so that call + sites read symmetrically, and used only for its device. + mapping: Which first-order nodes to connect to. One of "last", "first" or "both". + device: Device on which to create the tensor. + + Returns: + torch.Tensor: Edge index of shape `(2, ยท)`, higher-order nodes in the first row. + """ + if device is None: + device = first_order_graph.device if first_order_graph is not None else self.device + + node_sequence = self.data.node_sequence + ho_idx = torch.arange(self.n, device=device) + + if mapping == "last": + fo_idx = node_sequence[:, -1].to(device) + elif mapping == "first": + fo_idx = node_sequence[:, 0].to(device) + elif mapping == "both": + fo_idx = torch.cat([node_sequence[:, 0], node_sequence[:, -1]]).to(device) + ho_idx = torch.cat([ho_idx, ho_idx]) + else: + raise ValueError(f"Unknown mapping {mapping}. Only 'last', 'first' and 'both' are accepted.") + + return torch.stack([ho_idx, fo_idx]) + + @property + def n_first_order(self) -> int: + """Number of first-order nodes underlying the higher-order nodes.""" + return self._n_first_order + + def node_id(self, idx: int) -> Union[str, int, tuple]: + """Return the first-order path represented by the higher-order node `idx`.""" + seq = self.data.node_sequence[idx] + if self.order == 1: + return self.first_order_mapping.to_id(int(seq[0].item())) + if self.first_order_mapping.has_ids: + return tuple(self.first_order_mapping.to_ids(seq.cpu()).tolist()) + return tuple(seq.tolist()) + + def __str__(self) -> str: + """Return a human-readable summary of the higher-order graph.""" + s = ( + f"Higher-order graph of order {self.order} with {self.n} nodes and {self.m} edges\n" + f"(over {self.n_first_order} first-order nodes)\n" + ) + return s + "\n".join(super().__str__().split("\n")[1:]) From 304fe5779e938c26cf93135b9670cd4670cf7636 Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Thu, 13 Aug 2026 08:06:07 -0400 Subject: [PATCH 03/14] removed some uneeded checks (base constructor already does these) --- src/pathpyG/core/higher_order_graph.py | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/src/pathpyG/core/higher_order_graph.py b/src/pathpyG/core/higher_order_graph.py index 56b7bebc..7d3b6a0f 100644 --- a/src/pathpyG/core/higher_order_graph.py +++ b/src/pathpyG/core/higher_order_graph.py @@ -6,7 +6,6 @@ from typing import Optional, Union import torch -from torch_geometric import EdgeIndex from torch_geometric.data import Data from torch_geometric.utils import coalesce @@ -87,14 +86,6 @@ def __init__( if "node_sequence" not in data and order not in (None, 1): raise ValueError(f"A HigherOrderGraph of order {order} requires a `node_sequence` node attribute.") - if isinstance(data.edge_index, EdgeIndex): - # `Graph.__init__` re-sorts the edge index and reindexes every edge attribute by - # the returned permutation - but `EdgeIndex.sort_by` returns `None` for an index - # already known to be sorted, and `attr[None]` would add a dimension. Higher-order - # graphs are routinely built from already-aggregated (hence sorted) data, so hand - # the base class a plain tensor and let it derive a real permutation. - data.edge_index = data.edge_index.as_tensor() - super().__init__(data, mapping=mapping) # `Graph` creates an identity node sequence if none is given, so `self.order` @@ -195,9 +186,6 @@ def from_aggregated( Returns: HigherOrderGraph: The aggregated higher-order graph. """ - if isinstance(edge_index, torch.Tensor) and hasattr(edge_index, "as_tensor"): - edge_index = edge_index.as_tensor() - order = node_sequence.size(1) if first_order_mapping is None: first_order_mapping = IndexMap() From b76281bf6a79cc768da8331e76f3b234c2ef41f8 Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Thu, 13 Aug 2026 08:10:42 -0400 Subject: [PATCH 04/14] removed unused utils.dbgnn module --- src/pathpyG/core/higher_order_graph.py | 6 ++-- src/pathpyG/utils/dbgnn.py | 46 -------------------------- tests/nn/test_dbgnn.py | 5 ++- 3 files changed, 4 insertions(+), 53 deletions(-) delete mode 100644 src/pathpyG/utils/dbgnn.py diff --git a/src/pathpyG/core/higher_order_graph.py b/src/pathpyG/core/higher_order_graph.py index 7d3b6a0f..a5301215 100644 --- a/src/pathpyG/core/higher_order_graph.py +++ b/src/pathpyG/core/higher_order_graph.py @@ -454,10 +454,8 @@ def bipartite_edge_index( """Return the edge index connecting higher-order nodes to first-order nodes. Used by the [DBGNN][pathpyG.nn.dbgnn.DBGNN] model to pass messages from - higher-order node representations to first-order ones. Unlike the free function - [`generate_bipartite_edge_index`][pathpyG.utils.dbgnn.generate_bipartite_edge_index], - this works for any order: "last" refers to the last node of the path, whatever - its length. + higher-order node representations to first-order ones. This works for any order: + "last" refers to the last node of the path, whatever its length. Args: first_order_graph: The first-order graph. Optional; accepted so that call diff --git a/src/pathpyG/utils/dbgnn.py b/src/pathpyG/utils/dbgnn.py deleted file mode 100644 index a70ad8a7..00000000 --- a/src/pathpyG/utils/dbgnn.py +++ /dev/null @@ -1,46 +0,0 @@ -"""Utils for DBGNN models.""" - -from typing import Optional - -import torch - -from pathpyG.core.graph import Graph - - -def generate_bipartite_edge_index( - g: Graph, g2: Graph, mapping: str = "last", device: Optional[torch.device] = None -) -> torch.Tensor: - """Generate edge_index for bipartite graph connecting nodes of a second-order graph to first-order nodes. - - The mapping strategy determines to which first-order nodes the second-order nodes are connected: - - "last": Connects each second-order node to the last node in its sequence. - - "first": Connects each second-order node to the first node in its sequence. - - "both": Connects each second-order node to both the first and last nodes in its sequence. - - !!! warning "Only for Second-Order Graphs" - This function is intended to be used with second-order graphs only. - It does not support the use of higher-order graphs, such as third-order graphs or beyond. - - Args: - g (Graph): The first-order graph. - g2 (Graph): The second-order graph. - mapping (str, optional): The mapping strategy to use. Options are "last", "first", or "both". Defaults to "last". - device (torch.device, optional): The device to place the tensor on. Defaults to None. - - Returns: - torch.Tensor: The edge_index tensor for the bipartite graph. - """ - if mapping == "last": - bipartide_edge_index = torch.tensor([list(range(g2.n)), [v[1] for v in g2.data.node_sequence]], device=device) - elif mapping == "first": - bipartide_edge_index = torch.tensor([list(range(g2.n)), [v[0] for v in g2.data.node_sequence]], device=device) - else: - bipartide_edge_index = torch.tensor( - [ - list(range(g2.n)) + list(range(g2.n)), - [v[0] for v in g2.data.node_sequence] + [v[1] for v in g2.data.node_sequence], - ], - device=device, - ) - - return bipartide_edge_index diff --git a/tests/nn/test_dbgnn.py b/tests/nn/test_dbgnn.py index 0de6d8a4..418f8084 100644 --- a/tests/nn/test_dbgnn.py +++ b/tests/nn/test_dbgnn.py @@ -5,7 +5,6 @@ from pathpyG.core.multi_order_model import MultiOrderModel from pathpyG.nn.dbgnn import DBGNN -from pathpyG.utils.dbgnn import generate_bipartite_edge_index def test_bipartite_edge_index(simple_walks): @@ -17,13 +16,13 @@ def test_bipartite_edge_index(simple_walks): print(g2.data.edge_index) print(g2.mapping) - bipartite_edge_index = generate_bipartite_edge_index(g, g2, mapping="last") + bipartite_edge_index = g2.bipartite_edge_index(g, mapping="last") print(bipartite_edge_index) # ensure that A,C and B,C are mapped to C, C,D is mapped to D and C,E is mapped to E assert equal(bipartite_edge_index, tensor([[0, 1, 2, 3], [2, 2, 3, 4]])) - bipartite_edge_index = generate_bipartite_edge_index(g, g2, mapping="first") + bipartite_edge_index = g2.bipartite_edge_index(g, mapping="first") print(bipartite_edge_index) # ensure that A,C is mapped A, B,C is mapped to B, and C,D and C,E are mapped to C From e2e4f712db863ac5d9b30b6003978461d2d614ef Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Thu, 13 Aug 2026 08:15:01 -0400 Subject: [PATCH 05/14] removed duplicated logic in HigherOrderGraph's order 2 branch; now delegating to MultiOrderModel --- src/pathpyG/core/higher_order_graph.py | 33 +++++++++----------------- tests/core/test_event_graph.py | 30 +++++++++++++++++++++++ 2 files changed, 41 insertions(+), 22 deletions(-) diff --git a/src/pathpyG/core/higher_order_graph.py b/src/pathpyG/core/higher_order_graph.py index a5301215..85ec9e51 100644 --- a/src/pathpyG/core/higher_order_graph.py +++ b/src/pathpyG/core/higher_order_graph.py @@ -338,11 +338,14 @@ def from_path_data(cls, path_data: PathData, order: int = 1, mode: str = "propag def from_event_graph(cls, eg: EventGraph, order: int = 2) -> HigherOrderGraph: """Aggregate an [`EventGraph`][pathpyG.core.event_graph.EventGraph] into an order-`k` graph. - For the default order 2, every event whose underlying `(u, v)` pair is the same - collapses into a single second-order node, and repeated continuations become an - edge weight. Timestamps and the time window `delta` are not represented in the - result. Other orders are computed from the time-respecting paths that the event - graph encodes, which for orders above 2 means lifting its continuations further. + The nodes are the time-respecting paths of `k` first-order nodes that the event + graph encodes: events sharing the same underlying path collapse into a single + higher-order node, and repeated continuations become an edge weight. Timestamps + and the time window `delta` are not represented in the result. + + Equivalent to [`from_temporal_graph`][pathpyG.HigherOrderGraph.from_temporal_graph] + on the underlying temporal graph with the event graph's `delta`, but reuses the + already-computed continuations instead of lifting the temporal graph again. Args: eg: The second-order temporal event graph to aggregate. @@ -352,24 +355,10 @@ def from_event_graph(cls, eg: EventGraph, order: int = 2) -> HigherOrderGraph: HigherOrderGraph: A higher-order graph of order `order`. It has no nodes if there is no time-respecting path of that length. """ - if order != 2: - cls._validate_order(order) - from pathpyG.core.multi_order_model import MultiOrderModel - - return MultiOrderModel.from_event_graph(eg, max_order=order, cached=False).layers[order] - - edge_index = eg.data.edge_index.as_tensor() - # Each continuation carries the weight of the event it starts from, matching the - # "src" aggregation used when building order-2 layers from a temporal graph. - edge_weight = torch.ones(edge_index.size(1), device=edge_index.device) + cls._validate_order(order) + from pathpyG.core.multi_order_model import MultiOrderModel - return cls.from_aggregated( - edge_index, - eg.data.node_sequence, - first_order_mapping=eg.first_order_mapping, - edge_weight=edge_weight, - n_first_order=eg.n_first_order, - ) + return MultiOrderModel.from_event_graph(eg, max_order=order, cached=False).layers[order] def lift(self, aggr: str = "src") -> HigherOrderGraph: """Return the De Bruijn graph of order `k + 1` obtained by lifting this graph. diff --git a/tests/core/test_event_graph.py b/tests/core/test_event_graph.py index 94dbf523..039bc734 100644 --- a/tests/core/test_event_graph.py +++ b/tests/core/test_event_graph.py @@ -7,6 +7,7 @@ from torch_geometric.data import Data from pathpyG.core.event_graph import EventGraph +from pathpyG.core.higher_order_graph import HigherOrderGraph from pathpyG.core.index_map import IndexMap from pathpyG.core.multi_order_model import MultiOrderModel from pathpyG.core.temporal_graph import TemporalGraph @@ -218,6 +219,35 @@ def test_multi_order_model_construction(event_graph, temporal_graph): ) +def test_higher_order_graph_from_weighted_event_graph(temporal_graph): + """Aggregating an EventGraph respects the edge weights of the temporal graph. + + Regression test: order 2 used to count each continuation once instead of carrying + the weight of the event it starts from, so it disagreed with the temporal-graph + route for every order but 2. + """ + temporal_graph.data.edge_weight = torch.tensor([2.0, 5.0, 11.0, 7.0]) + event_graph = EventGraph.from_temporal_graph(temporal_graph, delta=DELTA) + + for k in (1, 2, 3): + from_eg = HigherOrderGraph.from_event_graph(event_graph, order=k) + from_tg = MultiOrderModel.from_temporal_graph(temporal_graph, delta=DELTA, max_order=k).layers[k] + + assert from_eg.order == k + assert from_eg.nodes == from_tg.nodes + assert torch.equal( + from_eg.data.edge_index.as_tensor(), + from_tg.data.edge_index.as_tensor(), + ) + assert torch.equal(from_eg.data.edge_weight, from_tg.data.edge_weight) + + # The weights must actually reflect the temporal graph, not just agree with each other. + order_2 = HigherOrderGraph.from_event_graph(event_graph, order=2) + assert order_2.nodes == [("a", "b"), ("b", "c"), ("b", "d"), ("c", "e")] + # (a,b)->(b,c) carries the weight of event (a->b)@1, (b,c)->(c,e) that of (b->c)@2 + assert order_2.data.edge_weight.tolist() == [2.0, 5.0] + + def test_to_device(event_graph): """Moving an EventGraph moves its underlying TemporalGraph too.""" moved = event_graph.to(torch.device("cpu")) From 018b6831869ad18bbb651cd0e56e265cba11991f Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Thu, 13 Aug 2026 08:18:26 -0400 Subject: [PATCH 06/14] added two helper functions to algorithms to reduce code duplication --- src/pathpyG/algorithms/lift_order.py | 51 ++++++++++++++++++++++++++ src/pathpyG/core/higher_order_graph.py | 9 ++--- src/pathpyG/core/multi_order_model.py | 15 +++----- 3 files changed, 60 insertions(+), 15 deletions(-) diff --git a/src/pathpyG/algorithms/lift_order.py b/src/pathpyG/algorithms/lift_order.py index 1b2269b9..1d95e4b2 100644 --- a/src/pathpyG/algorithms/lift_order.py +++ b/src/pathpyG/algorithms/lift_order.py @@ -106,6 +106,57 @@ def lift_order_edge_index_weighted( return ho_index, ho_edge_weight +def lift_node_sequence(edge_index: torch.Tensor, node_sequence: torch.Tensor) -> torch.Tensor: + """Extend node sequences by one order along an edge index. + + Each edge `(u, v)` of the (k-1)-th order graph becomes a node of the k-th order graph, + representing the path of `u` followed by the last first-order node of `v`. + + Args: + edge_index: A **sorted** edge index tensor of shape (2, num_edges). + node_sequence: The node sequences of the (k-1)-th order graph, of shape (num_nodes, k-1). + + Returns: + The node sequences of the k-th order graph, of shape (num_edges, k). + """ + return torch.cat([node_sequence[edge_index[0]], node_sequence[edge_index[1]][:, -1:]], dim=1) + + +def lift_order_step( + edge_index: torch.Tensor, + node_sequence: torch.Tensor, + edge_weight: torch.Tensor | None = None, + aggr: str = "src", +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None]: + """Lift an edge index together with its node sequences by one order. + + Combines the line-graph transformation of the edge index with the corresponding + extension of the node sequences, so that the result again describes a graph whose + nodes are paths of first-order nodes. The result is **not** aggregated: duplicate + node sequences are left for [`aggregate_edge_index`][pathpyG.algorithms.lift_order.aggregate_edge_index] + (or [`HigherOrderGraph.from_aggregated`][pathpyG.HigherOrderGraph.from_aggregated]) to merge. + + Args: + edge_index: A **sorted** edge index tensor of shape (2, num_edges). + node_sequence: The node sequences of the (k-1)-th order graph. + edge_weight: The edge weights of the (k-1)-th order graph. If None, the lifted + graph is returned without weights. + aggr: The aggregation method for the edge weights. One of "src", "dst", "max", + "mul" or "add". Ignored if `edge_weight` is None. + + Returns: + A tuple of the lifted edge index, the lifted node sequences and the aggregated + edge weights (None if `edge_weight` was None). + """ + if edge_weight is None: + ho_index = lift_order_edge_index(edge_index, num_nodes=node_sequence.size(0)) + else: + ho_index, edge_weight = lift_order_edge_index_weighted( + edge_index, edge_weight=edge_weight, num_nodes=node_sequence.size(0), aggr=aggr + ) + return ho_index, lift_node_sequence(edge_index, node_sequence), edge_weight + + def aggregate_edge_index( edge_index: torch.Tensor, node_sequence: torch.Tensor, edge_weight: torch.Tensor | None = None, aggr: str = "sum" ) -> Graph: diff --git a/src/pathpyG/core/higher_order_graph.py b/src/pathpyG/core/higher_order_graph.py index 85ec9e51..1403bd5a 100644 --- a/src/pathpyG/core/higher_order_graph.py +++ b/src/pathpyG/core/higher_order_graph.py @@ -9,7 +9,7 @@ from torch_geometric.data import Data from torch_geometric.utils import coalesce -from pathpyG.algorithms.lift_order import aggregate_edge_index, lift_order_edge_index_weighted +from pathpyG.algorithms.lift_order import aggregate_edge_index, lift_order_step from pathpyG.core.event_graph import EventGraph from pathpyG.core.graph import Graph from pathpyG.core.index_map import IndexMap @@ -385,11 +385,8 @@ def lift(self, aggr: str = "src") -> HigherOrderGraph: else: edge_weight = torch.ones(edge_index.size(1), device=edge_index.device) - ho_index, ho_weight = lift_order_edge_index_weighted( - edge_index, edge_weight=edge_weight, num_nodes=self.n, aggr=aggr - ) - node_sequence = torch.cat( - [self.data.node_sequence[edge_index[0]], self.data.node_sequence[edge_index[1]][:, -1:]], dim=1 + ho_index, node_sequence, ho_weight = lift_order_step( + edge_index, self.data.node_sequence, edge_weight=edge_weight, aggr=aggr ) return HigherOrderGraph.from_aggregated( diff --git a/src/pathpyG/core/multi_order_model.py b/src/pathpyG/core/multi_order_model.py index 88d068f7..1da9fd33 100644 --- a/src/pathpyG/core/multi_order_model.py +++ b/src/pathpyG/core/multi_order_model.py @@ -13,8 +13,9 @@ from pathpyG.algorithms.lift_order import ( aggregate_edge_index, aggregate_node_attributes, + lift_node_sequence, lift_order_edge_index, - lift_order_edge_index_weighted, + lift_order_step, ) from pathpyG.core.event_graph import EventGraph from pathpyG.core.higher_order_graph import HigherOrderGraph @@ -115,13 +116,9 @@ def iterate_lift_order( Defaults to the number of IDs in `mapping`. """ # Lift order - if edge_weight is None: - ho_index = lift_order_edge_index(edge_index, num_nodes=node_sequence.size(0)) - else: - ho_index, edge_weight = lift_order_edge_index_weighted( - edge_index, edge_weight=edge_weight, num_nodes=node_sequence.size(0), aggr=aggr - ) - node_sequence = torch.cat([node_sequence[edge_index[0]], node_sequence[edge_index[1]][:, -1:]], dim=1) + ho_index, node_sequence, edge_weight = lift_order_step( + edge_index, node_sequence, edge_weight=edge_weight, aggr=aggr + ) # Aggregate if save: @@ -180,7 +177,7 @@ def from_temporal_graph( ) if max_order > 1: - node_sequence = torch.cat([node_sequence[edge_index[0]], node_sequence[edge_index[1]][:, -1:]], dim=1) + node_sequence = lift_node_sequence(edge_index, node_sequence) if event_graph is None: edge_index = EventGraph.build_edge_index(g, delta) else: From 2768cfea808083161f04d8f05715a0921fbdd8bf Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Thu, 13 Aug 2026 09:51:17 -0400 Subject: [PATCH 07/14] removed unhelpful comment --- src/pathpyG/core/higher_order_graph.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/pathpyG/core/higher_order_graph.py b/src/pathpyG/core/higher_order_graph.py index 1403bd5a..7fb7fc08 100644 --- a/src/pathpyG/core/higher_order_graph.py +++ b/src/pathpyG/core/higher_order_graph.py @@ -302,7 +302,6 @@ def from_temporal_graph( [('a', 'c'), ('c', 'd')] """ cls._validate_order(order) - # Imported here because `MultiOrderModel` builds `HigherOrderGraph` layers itself. from pathpyG.core.multi_order_model import MultiOrderModel return MultiOrderModel.from_temporal_graph( From cb7bd2febc02e0c00b4c6818a148a8392a533e42 Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Thu, 13 Aug 2026 10:07:43 -0400 Subject: [PATCH 08/14] comments --- src/pathpyG/core/higher_order_graph.py | 34 +++----------------------- src/pathpyG/core/multi_order_model.py | 3 +-- 2 files changed, 5 insertions(+), 32 deletions(-) diff --git a/src/pathpyG/core/higher_order_graph.py b/src/pathpyG/core/higher_order_graph.py index 7fb7fc08..2cb79773 100644 --- a/src/pathpyG/core/higher_order_graph.py +++ b/src/pathpyG/core/higher_order_graph.py @@ -22,11 +22,9 @@ class HigherOrderGraph(Graph): """A De Bruijn graph of order `k`, whose nodes are paths of `k` first-order nodes. - Where a [`Graph`][pathpyG.Graph] has one node per entity and an - [`EventGraph`][pathpyG.core.event_graph.EventGraph] has one node per observed - interaction, a `HigherOrderGraph` has one node per *distinct* path of length `k` + A `HigherOrderGraph` has one node per distinct path of length `k` in the underlying first-order graph. Repeated observations of the same path are - aggregated into an `edge_weight`, so timestamps are no longer represented: this + aggregated into an `edge_weight`. Timestamps are not represented: this is a model of how paths flow rather than a record of what happened. Order 1 is the degenerate case and is simply the weighted first-order graph, with @@ -170,10 +168,6 @@ def from_aggregated( ) -> HigherOrderGraph: """Aggregate a (possibly duplicated) higher-order edge index into a De Bruijn graph. - This is the single place where higher-order nodes get their identity: duplicate - node sequences are merged, edge weights are aggregated, and the higher-order - `IndexMap` naming each node by its path is built. - Args: edge_index: Edge index whose nodes are indices into `node_sequence`. node_sequence: Tensor of shape `(num_nodes, order)` with the first-order path @@ -220,9 +214,6 @@ def from_aggregated_graph( ) -> HigherOrderGraph: """Adopt an already-aggregated [`Graph`][pathpyG.Graph] as a higher-order graph. - Used to give the layers computed by a multi-order model their proper type. The - underlying `data` object is shared, not copied. - Args: g: Aggregated graph carrying a `node_sequence` of shape `(num_nodes, order)`. first_order_mapping: Mapping of the underlying first-order node IDs. @@ -282,8 +273,7 @@ def from_temporal_graph( Order 1 is simply the weighted static graph and ignores `delta`; for higher orders the nodes are the time-respecting paths of `k` nodes, i.e. those whose consecutive interactions are at most `delta` apart. Orders above 2 are reached by repeatedly - lifting the *unaggregated* data, so the edge weights count observed paths rather - than being implied by lower-order statistics (unlike [`lift`][pathpyG.HigherOrderGraph.lift]). + lifting the unaggregated data. Args: g: The temporal graph. @@ -337,14 +327,8 @@ def from_path_data(cls, path_data: PathData, order: int = 1, mode: str = "propag def from_event_graph(cls, eg: EventGraph, order: int = 2) -> HigherOrderGraph: """Aggregate an [`EventGraph`][pathpyG.core.event_graph.EventGraph] into an order-`k` graph. - The nodes are the time-respecting paths of `k` first-order nodes that the event - graph encodes: events sharing the same underlying path collapse into a single - higher-order node, and repeated continuations become an edge weight. Timestamps - and the time window `delta` are not represented in the result. - Equivalent to [`from_temporal_graph`][pathpyG.HigherOrderGraph.from_temporal_graph] - on the underlying temporal graph with the event graph's `delta`, but reuses the - already-computed continuations instead of lifting the temporal graph again. + on the underlying temporal graph with the event graph's `delta`. Args: eg: The second-order temporal event graph to aggregate. @@ -365,12 +349,6 @@ def lift(self, aggr: str = "src") -> HigherOrderGraph: Nodes of the result are the edges of this graph, i.e. the paths of length `k + 1` that exist in this graph's topology. - Warning: - This lifts an *aggregated* graph, so the resulting edge weights are those - implied by the order-`k` statistics rather than counts of observed paths of - length `k + 1`. To fit a layer to observations, use - [`MultiOrderModel`][pathpyG.MultiOrderModel], which lifts the unaggregated data. - Args: aggr: Aggregation used for the lifted edge weights. One of "src", "dst", "max", "mul" or "add". @@ -438,10 +416,6 @@ def bipartite_edge_index( ) -> torch.Tensor: """Return the edge index connecting higher-order nodes to first-order nodes. - Used by the [DBGNN][pathpyG.nn.dbgnn.DBGNN] model to pass messages from - higher-order node representations to first-order ones. This works for any order: - "last" refers to the last node of the path, whatever its length. - Args: first_order_graph: The first-order graph. Optional; accepted so that call sites read symmetrically, and used only for its device. diff --git a/src/pathpyG/core/multi_order_model.py b/src/pathpyG/core/multi_order_model.py index 1da9fd33..6f75f843 100644 --- a/src/pathpyG/core/multi_order_model.py +++ b/src/pathpyG/core/multi_order_model.py @@ -34,8 +34,7 @@ class MultiOrderModel: Each graph layer is represented as a [HigherOrderGraph][pathpyG.core.higher_order_graph.HigherOrderGraph] object, layer 1 included. Each layer therefore knows its own order and the first-order nodes it was - built from, so results can be projected back onto entities without the caller keeping - track of it. + built from. This class provides methods to search for the optimal order of the model based on likelihood ratio tests, as well as methods to compute the log-likelihood of observed paths given the model. From 4112444d0ca6b0620ca2923c1e5f89d860d5bb07 Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Thu, 13 Aug 2026 10:30:03 -0400 Subject: [PATCH 09/14] explanatory note --- src/pathpyG/core/higher_order_graph.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/pathpyG/core/higher_order_graph.py b/src/pathpyG/core/higher_order_graph.py index 2cb79773..b856a0c2 100644 --- a/src/pathpyG/core/higher_order_graph.py +++ b/src/pathpyG/core/higher_order_graph.py @@ -285,6 +285,11 @@ def from_temporal_graph( HigherOrderGraph: A higher-order graph of order `order`. It has no nodes if there is no time-respecting path of that length. + Note: + Each call rebuilds the whole chain of lifts from order 1. To obtain several + orders, build a [`MultiOrderModel`][pathpyG.MultiOrderModel] with + `cached=True` once and read its `layers` instead. + Examples: >>> import pathpyG as pp >>> t = pp.TemporalGraph.from_edge_list([("a", "c", 1), ("c", "d", 2)]) @@ -311,6 +316,11 @@ def from_path_data(cls, path_data: PathData, order: int = 1, mode: str = "propag HigherOrderGraph: A higher-order graph of order `order`. It has no nodes if no observed path is that long. + Note: + Each call rebuilds the whole chain of lifts from order 1. To obtain several + orders, build a [`MultiOrderModel`][pathpyG.MultiOrderModel] with + `cached=True` once and read its `layers` instead. + Examples: >>> import pathpyG as pp >>> paths = pp.PathData(pp.IndexMap(list("acd"))) @@ -337,6 +347,11 @@ def from_event_graph(cls, eg: EventGraph, order: int = 2) -> HigherOrderGraph: Returns: HigherOrderGraph: A higher-order graph of order `order`. It has no nodes if there is no time-respecting path of that length. + + Note: + Each call rebuilds the whole chain of lifts from order 1. To obtain several + orders, build a [`MultiOrderModel`][pathpyG.MultiOrderModel] with + `cached=True` once and read its `layers` instead. """ cls._validate_order(order) from pathpyG.core.multi_order_model import MultiOrderModel From 809b49581a0935088573fe7a1210dbf5b21d774a Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Wed, 2 Sep 2026 12:17:18 -0400 Subject: [PATCH 10/14] from_aggregated -> aggregate renaming --- src/pathpyG/core/higher_order_graph.py | 6 +++--- src/pathpyG/core/multi_order_model.py | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/pathpyG/core/higher_order_graph.py b/src/pathpyG/core/higher_order_graph.py index b856a0c2..997dcbe1 100644 --- a/src/pathpyG/core/higher_order_graph.py +++ b/src/pathpyG/core/higher_order_graph.py @@ -157,7 +157,7 @@ def _build_mapping(node_sequence: torch.Tensor, first_order_mapping: IndexMap) - return IndexMap([tuple(v.tolist()) for v in node_sequence]) @classmethod - def from_aggregated( + def aggregate( cls, edge_index: torch.Tensor, node_sequence: torch.Tensor, @@ -252,7 +252,7 @@ def from_graph(cls, g: Graph, weight: str = "edge_weight") -> HigherOrderGraph: edge_weight = torch.ones(edge_index.size(1), device=edge_index.device) node_sequence = torch.arange(g.n, device=edge_index.device).unsqueeze(1) - return cls.from_aggregated( + return cls.aggregate( edge_index, node_sequence, first_order_mapping=g.mapping, @@ -381,7 +381,7 @@ def lift(self, aggr: str = "src") -> HigherOrderGraph: edge_index, self.data.node_sequence, edge_weight=edge_weight, aggr=aggr ) - return HigherOrderGraph.from_aggregated( + return HigherOrderGraph.aggregate( ho_index, node_sequence, first_order_mapping=self.first_order_mapping, diff --git a/src/pathpyG/core/multi_order_model.py b/src/pathpyG/core/multi_order_model.py index 6f75f843..30d02a1d 100644 --- a/src/pathpyG/core/multi_order_model.py +++ b/src/pathpyG/core/multi_order_model.py @@ -121,7 +121,7 @@ def iterate_lift_order( # Aggregate if save: - gk = HigherOrderGraph.from_aggregated( + gk = HigherOrderGraph.aggregate( ho_index, node_sequence, first_order_mapping=mapping, @@ -167,7 +167,7 @@ def from_temporal_graph( else: edge_weight = torch.ones(edge_index.size(1), device=edge_index.device) if cached or max_order == 1: - m.layers[1] = HigherOrderGraph.from_aggregated( + m.layers[1] = HigherOrderGraph.aggregate( edge_index=edge_index, node_sequence=node_sequence, edge_weight=edge_weight, @@ -185,7 +185,7 @@ def from_temporal_graph( # Aggregate if cached or max_order == 2: - m.layers[2] = HigherOrderGraph.from_aggregated( + m.layers[2] = HigherOrderGraph.aggregate( edge_index=edge_index, node_sequence=node_sequence, edge_weight=edge_weight, From 7cb6e1bab4f9006b5c4e43d08c9fd226b5107bcb Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Thu, 3 Sep 2026 07:07:40 -0400 Subject: [PATCH 11/14] workflow for release; version bump to v1.0.0rc1 --- .github/workflows/release.yml | 48 +++++++++++++++++++++++++++++++++++ pyproject.toml | 2 +- 2 files changed, 49 insertions(+), 1 deletion(-) create mode 100644 .github/workflows/release.yml diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 00000000..3740c3a4 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,48 @@ +name: Release + +on: + push: + branches: + - main + workflow_dispatch: + +jobs: + + release: + runs-on: ubuntu-latest + + environment: + name: pypi + permissions: + id-token: write + contents: write + + steps: + - name: Checkout repository + uses: actions/checkout@v5 + + - name: Install uv + uses: astral-sh/setup-uv@v8.3.2 + with: + python-version: "3.13" + + - name: Build sdist and wheel + run: uv build + + - name: Publish to PyPI + run: uv publish --trusted-publishing always + + - name: Create release tag + # Adding a `--prerelease` flag in `gh release create` makes the release not + # show up as the latest stable release. + run: | + version="$(uv version --short)" + if uv run --no-project --with packaging python -c \ + "import sys; from packaging.version import Version; sys.exit(0 if Version('${version}').is_prerelease else 1)"; then + prerelease="--prerelease" + else + prerelease="" + fi + gh release create "v${version}" --title "v${version}" --generate-notes ${prerelease} + env: + GH_TOKEN: ${{ github.token }} diff --git a/pyproject.toml b/pyproject.toml index cb4fa23a..97c3acc5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -20,7 +20,7 @@ classifiers = [ "Environment :: GPU :: NVIDIA CUDA :: 11.8", ] requires-python = ">=3.10" # We are using `match` statements -version = "0.2.0" +version = "v1.0.0rc1" dependencies = [ 'singledispatchmethod', # Adds decorator that allows to use different methods for different types of arguments (similar to method overloading in Java) 'zstandard', # Compression library From 65fee1b2158fa44e388250f317d37e1b44daf5d1 Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Thu, 3 Sep 2026 13:13:22 -0400 Subject: [PATCH 12/14] some tweaks in basic concepts notebook --- docs/tutorial/basic_concepts.ipynb | 22 ++++++---------------- 1 file changed, 6 insertions(+), 16 deletions(-) diff --git a/docs/tutorial/basic_concepts.ipynb b/docs/tutorial/basic_concepts.ipynb index cef2f819..0596b456 100644 --- a/docs/tutorial/basic_concepts.ipynb +++ b/docs/tutorial/basic_concepts.ipynb @@ -899,9 +899,7 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "To simplify access to attribute values, the `Graph` class provides getter and setter functions that allow to access attribute values based on node identifiers. To access the feature `node_feature` of node `a`, we can write:" - ] + "source": "To simplify access to attribute values, the `Graph` class provides getter and setter functions that allow to access attribute values based on node identifiers. To access the feature `node_class` of node `a`, we can write:" }, { "cell_type": "code", @@ -919,9 +917,7 @@ "output_type": "execute_result" } ], - "source": [ - "g['node_class', 'a']" - ] + "source": "g['node_class', 'a']" }, { "cell_type": "markdown", @@ -1071,9 +1067,7 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "By passing the name of the attribute, we can use edge attributes in the creation of the adjacency matrix. To create a sparse, weighted adjacency matrix that uses the `edge_weight` attribute of our graph object we can simply write:" - ] + "source": "By passing the name of the attribute, we can use edge attributes in the creation of the adjacency matrix. To create a dense, weighted adjacency matrix that uses the `edge_weight` attribute of our graph object we can simply write:" }, { "cell_type": "code", @@ -1154,7 +1148,7 @@ "source": [ "It is often convenient, to coalesce multi-edges into weighted single-edges, i.e. in the example above we may prefer a graph where each edge occurs once in the edge index, but the edge `a->b` has a weight attribute of two, while the two other edges have one.\n", "\n", - "In `pathpyG` we can do this by turning a graph into a weighted graph, which will coalesce edges and add an edge weight attribute that counts multi-edges in the original istance." + "In `pathpyG` we can do this by turning a graph into a weighted graph, which will coalesce edges and add an `edge_weight` attribute that counts multi-edges in the original instance." ] }, { @@ -1784,9 +1778,7 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "Note that the `pp.io.graph_to_df` function only includes `edge`-level data. To also include `node`-level attributes, you need to create a separate `DataFrame` for those attributes." - ] + "source": "Note that the `pp.io.graph_to_df` function only includes `edge`-level data. To also include `node`-level attributes, you need to create a separate `DataFrame` for those attributes. A specially-named column `v` of this `DataFrame` should contain node labels (or use a column called `index` for integer node index)." }, { "cell_type": "code", @@ -1837,9 +1829,7 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "Similarly, you can also add additional edge attributes from a `DataFrame` using the `add_edge_attributes` function:" - ] + "source": "Similarly, you can also add additional edge attributes from a `DataFrame` using the `add_edge_attributes` function. Specially-named columns `v` and `w` of this `DataFrame` indicate the start-end of the edge respectively." }, { "cell_type": "code", From c4321d6e776013c25ca2e57e7d88fc304401bef6 Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Tue, 8 Sep 2026 12:36:19 -0400 Subject: [PATCH 13/14] notebook fixes up to (half of) path data notebook --- docs/tutorial/manim_tutorial.ipynb | 50 ++- docs/tutorial/netzschleuder.ipynb | 248 +++++-------- docs/tutorial/paths_higher_order.ipynb | 102 ++---- docs/tutorial/temporal_graphs.ipynb | 475 ++++++++----------------- docs/tutorial/visualisation.ipynb | 475 ++++++++----------------- 5 files changed, 426 insertions(+), 924 deletions(-) diff --git a/docs/tutorial/manim_tutorial.ipynb b/docs/tutorial/manim_tutorial.ipynb index baeecd12..2f24db1a 100644 --- a/docs/tutorial/manim_tutorial.ipynb +++ b/docs/tutorial/manim_tutorial.ipynb @@ -114,7 +114,7 @@ "name": "stderr", "output_type": "stream", "text": [ - " \r" + " " ] }, { @@ -122,7 +122,7 @@ "text/html": [ "\n", " \n", " " @@ -137,7 +137,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -162,23 +162,23 @@ "execution_count": 5, "id": "8e80f87a", "metadata": { - "tags": [ - "skip-execution" - ] + "tags": [ + "skip-execution" + ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " \r" + " " ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Animation saved to /tmp/tmp27x6c4lg/temporal_graph_manim.gif\n", + "Animation saved to /tmp/tmpp1_aikeg/temporal_graph_manim.gif\n", "Files in temp dir: ['temporal_graph_manim.gif']\n" ] } @@ -219,17 +219,17 @@ "cell_type": "code", "execution_count": 6, "id": "26a31185", - "metadata": { - "tags": [ - "skip-execution" - ] - }, + "metadata": { + "tags": [ + "skip-execution" + ] + }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - " \r" + " " ] }, { @@ -237,7 +237,7 @@ "text/html": [ "\n", " \n", " " @@ -252,7 +252,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -351,7 +351,7 @@ "name": "stderr", "output_type": "stream", "text": [ - " \r" + " " ] }, { @@ -359,7 +359,7 @@ "text/html": [ "\n", " \n", " " @@ -374,7 +374,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 10, @@ -393,19 +393,11 @@ " delta=500, # Each time step is 500 ms\n", ")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "39d425ad", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "pathpyg", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -419,7 +411,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.18" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/docs/tutorial/netzschleuder.ipynb b/docs/tutorial/netzschleuder.ipynb index 2cb17cf8..db1f0105 100644 --- a/docs/tutorial/netzschleuder.ipynb +++ b/docs/tutorial/netzschleuder.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -31,7 +31,7 @@ "source": [ "## Motivation and Learning Objectives\n", "\n", - "Access to a large number of graphs with different topological characteristics and from different domains is crucial for the development and evaluation of graph learning methods. Tousands of graph data sets are available scattered throughout the web, possibly using different data formats and with missing information on their actual origin. Addressing this issue the [Netschleuder Online Repository](https://networks.skewed.de/) by Tiago Peixoto provides a single repository of graphs in a single format, including descriptions, citations, and node-/edge- or graph-level meta-data. To facilitate the development of graph learning techniques, pathpyG provides a feature that allows to directly read networks from the netzschleuder repository via an API.\n", + "Access to a large number of graphs with different topological characteristics and from different domains is crucial for the development and evaluation of graph learning methods. Thousands of graph data sets are available scattered throughout the web, possibly using different data formats and with missing information on their actual origin. Addressing this issue the [Netschleuder Online Repository](https://networks.skewed.de/) by Tiago Peixoto provides a single repository of graphs in a single format, including descriptions, citations, and node-/edge- or graph-level meta-data. To facilitate the development of graph learning techniques, pathpyG provides a feature that allows to directly read networks from the netzschleuder repository via an API.\n", "\n", "In this brief unit, we will learn how we can retrieve network records and graph data from the netzschleuder repository. We will further demonstrate how we can conveniently apply a Graph Neural Network to predict node-level categories contained in the meta-data.\n", "\n", @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -78,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -125,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -139,40 +139,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -656,7 +635,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -697,7 +676,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -711,40 +690,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -1230,7 +1188,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1238,7 +1196,7 @@ "output_type": "stream", "text": [ "tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 2, 1, 1, 2, 1, 2, 1, 2, 2,\n", - " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], device='cuda:0')\n" + " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])\n" ] } ], @@ -1255,7 +1213,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -1263,7 +1221,7 @@ "output_type": "stream", "text": [ "tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1,\n", - " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], device='cuda:0')\n" + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])\n" ] } ], @@ -1281,7 +1239,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1295,40 +1253,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -1801,10 +1738,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 10, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1817,12 +1754,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For convenience, let us shift the group labels to binary values 0 and 1: " + "We can apply custom colors to the two binary groups of nodes:" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1836,40 +1773,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -2362,7 +2278,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -2386,7 +2302,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -2405,7 +2321,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -2419,7 +2335,7 @@ ")" ] }, - "execution_count": 14, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -2443,7 +2359,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -2460,12 +2376,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2504,7 +2420,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -2513,7 +2429,7 @@ "1.0" ] }, - "execution_count": 17, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -2533,12 +2449,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2579,7 +2495,7 @@ ], "metadata": { "kernelspec": { - "display_name": "pathpyg", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -2593,7 +2509,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.18" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/docs/tutorial/paths_higher_order.ipynb b/docs/tutorial/paths_higher_order.ipynb index 0b8960eb..48aae73b 100644 --- a/docs/tutorial/paths_higher_order.ipynb +++ b/docs/tutorial/paths_higher_order.ipynb @@ -31,7 +31,7 @@ "source": [ "## Motivation and Learning Objective\n", "\n", - "While `pathpyG` is useful to handle and visualize static graphs - as the name suggests - its main advantage is that it facilitates the analysis of time series data that can be used to calculate **paths** in a graph. As we shall see in the following tutorial, there are various situations in which naturally have access to data on paths, including data on (random) walks or trajectories, traces of dynamical processes giving rise to node sequences or directed acyclic graphs, or time-respecting paths in temporal graphs. ``pathpyG` can be used to model patterns in such data based on higher-order De Bruijn graph models.\n", + "While `pathpyG` is useful to handle and visualize static graphs - as the name suggests - its main advantage is that it facilitates the analysis of time series data that can be used to calculate **paths** in a graph. As we shall see in the following tutorial, there are various situations in which we naturally have access to data on paths, including data on (random) walks or trajectories, traces of dynamical processes giving rise to node sequences or directed acyclic graphs, or time-respecting paths in temporal graphs. `pathpyG` can be used to model patterns in such data based on higher-order De Bruijn graph models.\n", "\n", "In this first unit, we will show how `pathpyG` supports to represent data on paths in graphs. Like graphs, such data are internally stored as tensors, which facilitates GPU-based operations to create higher-order De Bruijn graphs.\n", "\n", @@ -78,40 +78,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -748,7 +727,7 @@ "source": [ "We can actually see a collection of walks as a higher-order generalization of the usual way to define graphs as a collection of dyadic edges (which are simply walks of length one). From this point of view, a standard static (weighted) graph is simply a first-order model of node sequences, which only considers the frequency at which edges are traversed. \n", "\n", - "To generate such a first-order model, we can use the class `MultiOderModel` and use the first-layer of the model, which is simply a weighted static graph where edge weights count the number of times each edge is traversed by a path. We will explain the class `MultiOrderModel`, which generalizes this concept to higher-order graph models for any order $k$ in a moment. For now, we can just use it to generate a first-order weighted graph as follows.\n", + "To generate such a first-order model, we can use the class `MultiOrderModel` and use the first-layer of the model, which is simply a weighted static graph where edge weights count the number of times each edge is traversed by a path. We will explain the class `MultiOrderModel`, which generalizes this concept to higher-order graph models for any order $k$ in a moment. For now, we can just use it to generate a first-order weighted graph as follows.\n", "\n", "The generated graph is again based on a `pyG.Data` object that contains an edge_index and edge weights. As we can see, for the example above the edge_index is just a concatenation of the edge indices of individual walks, where the node indices have been mapped to the correct nodes." ] @@ -778,40 +757,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -4456,7 +4414,7 @@ ], "metadata": { "kernelspec": { - "display_name": "pathpyg", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -4470,7 +4428,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.18" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/docs/tutorial/temporal_graphs.ipynb b/docs/tutorial/temporal_graphs.ipynb index 6ba57852..275c8dd2 100644 --- a/docs/tutorial/temporal_graphs.ipynb +++ b/docs/tutorial/temporal_graphs.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 72, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 73, "metadata": {}, "outputs": [], "source": [ @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 74, "metadata": {}, "outputs": [ { @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 75, "metadata": {}, "outputs": [ { @@ -126,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 76, "metadata": {}, "outputs": [ { @@ -155,7 +155,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 77, "metadata": {}, "outputs": [ { @@ -187,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 78, "metadata": {}, "outputs": [ { @@ -219,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 79, "metadata": {}, "outputs": [ { @@ -245,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 80, "metadata": {}, "outputs": [ { @@ -271,7 +271,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 81, "metadata": {}, "outputs": [ { @@ -335,7 +335,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 82, "metadata": {}, "outputs": [ { @@ -349,40 +349,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -988,7 +967,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 83, "metadata": {}, "outputs": [ { @@ -997,7 +976,7 @@ "Data(edge_index=[2, 10], time=[10], num_nodes=4)" ] }, - "execution_count": 12, + "execution_count": 83, "metadata": {}, "output_type": "execute_result" } @@ -1008,7 +987,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 84, "metadata": {}, "outputs": [ { @@ -1026,7 +1005,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 85, "metadata": {}, "outputs": [ { @@ -1050,7 +1029,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 86, "metadata": {}, "outputs": [ { @@ -1077,7 +1056,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 87, "metadata": {}, "outputs": [ { @@ -1113,16 +1092,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We are often interested in time-respecting paths in a temporal graph. A time-respecting path consists of a sequence of nodes $v_0,...,v_l$ where consecutive nodes are connected by time-stamped edges that occur (i) in the right temporal ordering, and (ii) within a maximum time difference of $\\delta\\in \\N$. \n", + "We are often interested in time-respecting paths in a temporal graph. A time-respecting path consists of a sequence of nodes $v_0,...,v_l$ where consecutive nodes are connected by time-stamped edges that occur (i) in the right temporal ordering, and (ii) within a maximum time difference of $\\delta\\in N$.\n", "\n", - "To calculate time-respecting paths in a temporal graph, we can construct a directed acyclic graph (DAG), where each time-stamped edge $(u,v;t)$ in the temporal graph is represented by a node and two nodes representing time-stamped edges $(u,v;t_1)$ and $(v,w;t_2)$ are connected by an edge iff $0 < t_2-t_1 \\leq \\delta$. This implies that (i) each edge in the resulting DAG represents a time-respecting path of length two, and (ii) time-respecting paths of any lenghts are represented by paths in this DAG.\n", + "To calculate time-respecting paths in a temporal graph, we can construct a directed acyclic graph (DAG), where each time-stamped edge $(u,v;t)$ in the temporal graph is represented by a node and two nodes representing time-stamped edges $(u,v;t_1)$ and $(v,w;t_2)$ are connected by an edge iff $0 < t_2-t_1 \\leq \\delta$. This implies that (i) each edge in the resulting DAG represents a time-respecting path of length two, and (ii) time-respecting paths of any lengths are represented by paths in this DAG.\n", "\n", "We can construct such a DAG using the function `pp.core.event_graph.EventGraph.build_edge_index`, which returns an edge_index. We can pass this to the constructor of a `Graph` object, which we can use to visualize the resulting DAG." ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 88, "metadata": {}, "outputs": [], "source": [ @@ -1132,7 +1111,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 89, "metadata": {}, "outputs": [ { @@ -1146,40 +1125,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -1660,7 +1618,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For $\\delta=1$, this DAG with three connected components tells us that the underlying temporal graph has the following time-respecting paths (of different lengths):" + "For $\\delta=1$, this DAG with four connected components tells us that the underlying temporal graph has the following time-respecting paths (of different lengths):" ] }, { @@ -1703,7 +1661,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 90, "metadata": {}, "outputs": [], "source": [ @@ -1713,7 +1671,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 91, "metadata": {}, "outputs": [ { @@ -1751,7 +1709,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 92, "metadata": {}, "outputs": [ { @@ -1765,40 +1723,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -2290,7 +2227,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 93, "metadata": {}, "outputs": [ { @@ -2321,7 +2258,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 94, "metadata": {}, "outputs": [ { @@ -2340,14 +2277,14 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 95, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "created temporary directory /tmp/tmpll_zqpnk\n" + "created temporary directory /tmp/tmpqglashxz\n" ] }, { @@ -2361,40 +2298,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -3003,12 +2919,12 @@ "source": [ "## Temporal Centralities in Empirical Temporal Networks\n", "\n", - "`pathpyG`'s ability to calculate (shortest) time-respecting paths enables us to calulate different notions of temporal centralities for nodes in empirial temporal networks. We can download an empirical temporal graph from Netzschleuder:" + "`pathpyG`'s ability to calculate (shortest) time-respecting paths enables us to calulate different notions of temporal centralities for nodes in empirical temporal networks. We can download an empirical temporal graph from Netzschleuder:" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 96, "metadata": {}, "outputs": [ { @@ -3057,7 +2973,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 97, "metadata": {}, "outputs": [], "source": [ @@ -3067,14 +2983,14 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 109, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{0: 356.4, 1: 390.5, 2: 385.0, 3: 392.33333333333337, 4: 378.4, 5: 399.66666666666663, 6: 374.0, 7: 352.0, 8: 357.5, 9: 352.0, 10: 297.0, 11: 0.0, 12: 374.0, 13: 366.66666666666663, 14: 352.0, 15: 407.0, 16: 363.0, 17: 352.0, 18: 385.0, 19: 348.33333333333337, 20: 174.16666666666666, 21: 145.5666666666667, 22: 159.50000000000003}\n" + "{0: 308.0, 1: 374.0, 2: 374.0, 3: 374.0, 4: 363.0, 5: 396.0, 6: 352.0, 7: 308.0, 8: 319.0, 9: 286.0, 10: 176.0, 11: 0.0, 12: 352.0, 13: 345.4, 14: 330.0, 15: 396.0, 16: 330.0, 17: 319.0, 18: 374.0, 19: 297.0, 20: 22.0, 21: 22.0, 22: 22.0}\n" ] }, { @@ -3088,40 +3004,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -3729,7 +3624,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 99, "metadata": {}, "outputs": [], "source": [ @@ -3739,7 +3634,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 100, "metadata": {}, "outputs": [ { @@ -3760,40 +3655,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -4401,7 +4275,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 101, "metadata": {}, "outputs": [], "source": [ @@ -4411,14 +4285,14 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 102, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "defaultdict(. at 0x7f71be74b520>, {np.int64(0): 25.49506219995845, np.int64(9): 16.45944229302354, np.int64(10): 7.0646313362884605, np.int64(8): 10.16539885356489, np.int64(15): 18.70808072720025, np.int64(7): 2.5893301614085957, np.int64(5): 2.9692172804080914, np.int64(19): 8.975171000727638, np.int64(16): 0.7515158959863081, np.int64(18): 25.805683205683206, np.int64(17): 4.9153382565147306, np.int64(4): 17.320833765556717, np.int64(6): 2.1058097733020373, np.int64(12): 3.688175274115717, np.int64(1): 32.60701972686802, np.int64(2): 3.8280206113998165, np.int64(14): 2.9724179092311167, np.int64(3): 5.4875089420452685, np.int64(13): 6.091342786717137, np.int64(11): 1.7763568394002505e-15})\n" + "defaultdict(. at 0x7cef5c55d440>, {np.int64(0): 25.49506219995845, np.int64(9): 16.45944229302354, np.int64(10): 7.0646313362884605, np.int64(8): 10.16539885356489, np.int64(15): 18.70808072720025, np.int64(7): 2.5893301614085957, np.int64(5): 2.9692172804080914, np.int64(19): 8.975171000727638, np.int64(16): 0.7515158959863081, np.int64(18): 25.805683205683206, np.int64(17): 4.9153382565147306, np.int64(4): 17.320833765556717, np.int64(6): 2.1058097733020373, np.int64(12): 3.688175274115717, np.int64(1): 32.60701972686802, np.int64(2): 3.8280206113998165, np.int64(14): 2.9724179092311167, np.int64(3): 5.4875089420452685, np.int64(13): 6.091342786717137, np.int64(11): 1.7763568394002505e-15})\n" ] }, { @@ -4432,40 +4306,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -5066,7 +4919,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 110, "metadata": {}, "outputs": [], "source": [ @@ -5076,14 +4929,14 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 111, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "defaultdict(. at 0x7f71ba8e5990>, {np.int64(0): 9.71445146547012e-15, np.int64(3): 1.999999999999984, np.int64(13): 0.99999999999998, np.int64(1): 1.0000000000000135, np.int64(12): -1.0047518372857667e-14, np.int64(18): 1.500000000000005, np.int64(7): 1.5543122344752192e-15, np.int64(8): -1.199040866595169e-14, np.int64(4): -1.4474532683550478e-14, np.int64(17): 0.4999999999999865, np.int64(2): 1.9999999999999858, np.int64(14): 1.0000000000000062, np.int64(5): 0.999999999999996, np.int64(16): 2.609024107869118e-15, np.int64(15): 0.9999999999999972, np.int64(6): -2.220446049250313e-16, np.int64(9): 1.0519363158323358e-14, np.int64(10): 3.3306690738754696e-15, np.int64(11): 0.0, np.int64(19): -1.1018963519404679e-14})\n" + "defaultdict(. at 0x7cef583e4360>, {np.int64(0): 9.71445146547012e-15, np.int64(3): 1.999999999999984, np.int64(13): 0.99999999999998, np.int64(1): 1.0000000000000135, np.int64(12): -1.0047518372857667e-14, np.int64(18): 1.500000000000005, np.int64(7): 1.5543122344752192e-15, np.int64(8): -1.199040866595169e-14, np.int64(4): -1.4474532683550478e-14, np.int64(17): 0.4999999999999865, np.int64(2): 1.9999999999999858, np.int64(14): 1.0000000000000062, np.int64(5): 0.999999999999996, np.int64(16): 2.609024107869118e-15, np.int64(15): 0.9999999999999972, np.int64(6): -2.220446049250313e-16, np.int64(9): 1.0519363158323358e-14, np.int64(10): 3.3306690738754696e-15, np.int64(11): 0.0, np.int64(19): -1.1018963519404679e-14})\n" ] }, { @@ -5097,40 +4950,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -5728,18 +5560,11 @@ "node_size = {v: 15 * (x / max(bw.values())) for v, x in bw.items()}\n", "pp.plot(t_baboons, node_size=node_size, node_color=t_baboons.nodes);" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "pathpyg", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -5753,7 +5578,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.18" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/docs/tutorial/visualisation.ipynb b/docs/tutorial/visualisation.ipynb index 7da06af2..1a0e98cb 100644 --- a/docs/tutorial/visualisation.ipynb +++ b/docs/tutorial/visualisation.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -54,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -73,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 14, "metadata": { "scrolled": true }, @@ -89,40 +89,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -609,7 +588,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -618,7 +597,7 @@ "'Our graph has 3 nodes and 2 edges.'" ] }, - "execution_count": 4, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -638,7 +617,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -652,40 +631,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -1190,12 +1148,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkMAAAI/CAYAAAB02d0hAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgAAQlNJREFUeJzt3Xd4ZPld5/tPJZVUyjlnqVstqaUOk4NnbMM1j8EPGHu9Tviyyz54zRru83BZLsEGYxswsNwNBG+4C2szeACzC7axvQSHGU/upE7qVs45x8p17h893Z7TknpaUqlOVZ336x9PfU/VOV+pe1yf+Z3f+f0chmEYAgAAsCmn1Q0AAABYiTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABsjTAEAABszW11AwAAwBpra2vq6+tTX1+feq5c1fLKqsLhkDI8GSovL1X3yZM6fvy4WltblZOTY3W7R8ZhGIZhdRMAACAxYrGYXnnlFT3zpWf10iuvKiM7V66sHGXm5ivDmyWH06lYLKagf0vBjTXFAlsK+7f0A297Wh98//t16tQpORwOq3+MuCIMAQBgE88995w++9u/o+WNTeVU1KmyoUVuT8abfi4U8GtmdEBbc5Oqq6rQr3/iV3X69OkEdJwYhCEAANLc6uqqPvc7v6v//a3vqKLtlIoraw40umMYhubGhrU4fF3vf8+P6+d+9uPy+XxH0HFiEYYAAEhjfX19+ujPfFxBj0/1HafvayTozYQCfo1ePa8Sn0f/7T9/XtXV1XHo1DqEIQAA0tT169f1Ux/9mHJqW1RR3xL384/3XZNrY1Ff+JP/T3V1dXE/f6IQhgAASEOjo6P64Ed+Utk1rSqvazyy60wO9MqztaRnn/kzlZSUHNl1jhJhCACANBOJRPTBD/+E5kIO1R7rPPLrDV85rzMtNfqD//gfU/JJMxZdBAAgzfyPL3xBwzPzqmntSMj16jtO6cVzl/SNb3wjIdeLN0aGAABII2NjY3r3+96vxgefUlZOXsKuu7a0oIUbF/TNr31FhYWFCbtuPDAyBABAGvnSs3+hzOLKhAYhScovLpWycvW1r30todeNB8IQAABpYmtrS3/zla+qsumYJdcvrmvWF//8S4pGo5Zc/6AIQwAApIl//Md/lLJyEj4qdFtBSblWtvx69dVXLbn+QRGGAABIEy+89LJ8ReWWXd/hcMhbUKrzFy5Y1sNBEIYAAEgTV65eU16RtWv95BQU68LFHkt72C+31Q0AAIDDW19f1+zcnDpPPnKgz9947QUN9Lwm/9aGMn05anvgMR0/++i+z5NXVKIb576rWCwmpzM1xlwIQwAApIHZ2Vl5fdlyOl0H+nx2foHe/v5/KV9uvubGR/Tdv/6CCsurVFZTv6/zeLN8CoRCWl9fV0FBwYF6SbTUiGwAAOCeQqGQHI6Df63XHe9Udl6BHA6HKuqbVNnYqvnx4X2fx+FwyOl0KRQKHbiXRGNkCACANHDYW1Ij13t049wL2lpblWEYiobDysk/2OKJhpE6t8gkwhAAAGnB5/MpEj7YaMzW+qpe/vr/1Fvf93+qvK5RTqdLz/2vZ3SQPSpisaiikYiysrIO1IsVUie2AQCAPdXU1MiIhhUOBvb92UgoJMlQpi9HDodDU0N9mhkZPFAfW2urqigvU3Z29oE+bwVGhgAASANut1utra1aX15UcWXNvj6bX1Kmjkef1rf+4r/LiMVU3XpCNS1tB+pjfXlRp06ePNBnrUIYAgAgTZw91a2vPn9u32FIkrqf/AF1P/kDh+7Bv7asM92HP08icZsMAIA08fa3vU3+pRkZB5nsEwfRSFiBlXk99dRTllz/oAhDAACkibNnz6qqrERLM5OWXH9mdEgPnT2juro6S65/UIQhAADShMPh0E/+xIe1ND6Y8NEhw4hpY2ZMP/GhDyb0uvFAGAIAII38yI/8iEpysjQ3tv8FEw9jou+6TjQ36LHHHkvodeOBMAQAQBrJzMzU537zM1oc7lXQv52Qa26urWh7dky/+ZlPy+U62HYgViIMAQCQZrq7u/WR979Pw5deUSwaPdJrRUIhjV1+VT//cx9Xff3+9jFLFoQhAADS0M/+7Mf1SPcJDVx4UbHY0QSiSDikgXPP60ff8XZ94AMfOJJrJAJhCACANOTxePT7v/d7erC9Vf2vPneglanvJbC1qf5XvqN3vu1JffITn5DD4Yjr+RPJYVi1GAEAADhy4XBYv/fvfl9/9Td/q7LWLpXVNhzqfIZhaHq4T6tjA/roT/2kPvrTP53SQUgiDAEAYAvnz5/Xr3zy17QajKm8qU15xaX7CjGGYWh5bloLw32qLSvUb3/2M2prO9iWHcmGMAQAgE1sb2/rL/7yL/XMl57Vuj+k7PIaFZRWKDuvQE7nzpkzsWhUm6vLWlmY0fb8lMpLivSTH/6Q3v3ud8vj8VjwExwNwhAAADYTjUb10ksv6W+/+jX1XL6ihcVFZeXmy5nhleSQjJii4aACG+uqrKjQ2TOn9eM/9qM6e/Zsyt8S2w1hCAAAGxmbmVNhXq7ysn13aqurqxocHNT6+roikYg8Ho8KCgrU0tKi3NxcC7tNDMIQAAA2EQyF9TfffUGxWExFeXmqryxXS22VPG631a1ZikfrAQCwiYm5BcViMUnS8vq6rgwMWdxRciAMAQBgE+Ozc6bXVaUlth8VkghDAADYwnYgqLmlFVOtvrLcom6SC2EIAAAbGJ+dl6HvTxP2uN2qKi22sKPkQRgCAMAGxu66RVZTVip3Cu4wfxQIQwAApLnNbb+WVtdMtfrKMou6ST6EIQAA0tzYjHlUyOvJUHlxkUXdJB/CEAAAacwwDI3eFYZqK0rl2mX7DbviNwEAQBpbXt/Q2uamqdbAU2QmhCEAANLY8OSM6XV2VpZKCwusaSZJEYYAAEhTkWhUozOzplpTdUVabrZ6GIQhAADS1MTsvMKRyJ3XDjnUVF1lYUfJiTAEAECaGpoy3yIrLy5UdlamRd0kL8IQAABpaGNrW/PL5u03mmsYFdoNYQgAgDQ0fNeokNeToZqyEou6SW6EIQAA0kwsFtsRhhqqyuVi+41dEYYAAEgz04tL8geDphq3yPZGGAIAIM3cvbZQcX6eCnJzLOom+RGGAABII/5gUFMLi6Yao0L3RhgCACCNjEzNyjCMO69dLpfq2X7jnghDAACkCcMwNDQ5barVVZTJ43Zb1FFqIAwBAJAmFlZWtbG9bapxi+zNEYYAAEgTd684nZedrdKCfIu6SR2EIQAA0kA4EtH47Lyp1lRdyaas94EwBABAGhibmVM0Gr3z2uFwqLG6wsKOUgdhCACANHD3xOnq0hJleb0WdZNaCEMAAKS4xdU1La2tm2pMnL5/hCEAAFJc3+iE6bUvM1OVJUUWdZN6CEMAAKSwLX9A43PmidOtddVyOvmKv1/8pgAASGF9YxM7Vpxuqam2sKPUQxgCACBFhSORHROnm6sr5c3wWNRRaiIMAQCQooanZhSORO68dsih4/W1FnaUmghDAACkoFgstmPidHVZiXKzfRZ1lLoIQwAApKCphUVt+v2mWlsDo0IHQRgCACAF3bxrVKgoL0+lhQXWNJPiCEMAAKSYpdV1LaysmmptDbXsQ3ZAhCEAAFLMzdFx02tfZqZqK8os6ib1EYYAAEghey2y6GKRxQPjNwcAQArpH59kkcU4IwwBAJAiwpGIBiemTDUWWTw8whAAACmCRRaPBmEIAIAUwCKLR4cwBABACmCRxaNDGAIAIMkZhqHe4TFTjUUW44cwBABAkpteWNLS2rqpdpxFFuOGMAQAQBIzDENXBodNtRyfT/Usshg3hCEAAJLY5PyiVtY3TLWTzQ1ysshi3PCbBAAgSRmGoWuDI6ZaXna26ivLLeooPRGGAABIUpPzC1rZMI8KdTIqFHf8NgEASEKGYejKgHlUKD8nW3XMFYo7whAAAElofHZea5ubplpncyOjQkeA3ygAAEkmFovp2tDdo0I5jAodEcIQAABJ5tao0JapdrKlkXWFjghhCACAJBKLxXT1rifICnNzVVtealFH6Y8wBABAEhmbmdPG9rap1smo0JEiDAEAkCRisZiuDo2aaoV5uaopK7GmIZsgDAEAkCRGZ+a0edeoUFdLE6NCR4wwBABAEojGYjtWmy7Oz1NVabFFHdkHYQgAgCQwMjWrTb/fVOMJssQgDAEAYLFINLpjXaHignxVljAqlAiEIQAALHZzdFzbgYCp1sWoUMIQhgAAsNB2IKDe4TFTraywQBXFRRZ1ZD+EIQAALHS5f1iRaPTOa4ccOtN2jFGhBCIMAQBgkcXVNY1Mz5hqTTWVKsrPtagjeyIMAQBgAcMwdOHmgKnmcbvV1dpkUUf2RRgCAMACozNzWlpdM9U6mxuV5fVa1JF9EYYAAEiwcCSinr5BUy3H59Ox+hqLOrI3whAAAAnWOzImfzBoqp1pa5HLydeyFfitAwCQQJt+v26OjJtqFcVFqi5lM1arEIYAAEignr4hRWOxO68dDofOtLXyKL2FCEMAACTI3PKKxmfnTLXW2moV5OZY1BEkwhAAAAkRi8V08Yb5UfoMj0cnW3iU3mqEIQAAEmB4akYrGxumWldLk7wZHos6wm2EIQAAjlgoHNaVgWFTLT8nRy21VRZ1hDciDAEAcMSuDY0qEAqZamfaWuTkUfqkwJ8CAABHaGV9Q31jE6ZadVmJKkuKLeoIdyMMAQBwRGKxmF65dkOGYdypOZ1OnT7eamFXuBthCACAI3JjdFwr6+ZJ0yca65SX7bOoI+yGMAQAwBFY29zStcERUy0/J1udTQ3WNIQ9EYYAAIizWCymV6/dMK80LYce7jwhl8tlYWfYDWEIAIA4G5iY0uLqmql2vKFWJQX5FnWEeyEMAQAQR5vbfvX0D5lqOT6fulpZaTpZEYYAAIgTwzD02vWbikajpvrDnW1yc3ssaRGGAACIk6HJGc0uLZtqLbXVKi8qtKgj3A/CEAAAcbAdCOhSn3kjVl9mpk4fb7GoI9wvwhAAAIdkGIbO9fYpHImY6g91HJfH7baoK9wvwhAAAIc0NjOnqflFU62xqlJVpSUWdYT9IAwBAHAIgWBIF26Yb49lZmTodBu3x1IFYQgAgEO4cKNfwbB5R/oH2o8rMyPDoo6wX4QhAAAOaGJuQWOzc6ZabXmZ6irKLOoIB0EYAgDgALb8Ab167YapluHx6IH2YxZ1hIMiDAEAsE+xWEwvXbmuUDhsqp9ta1WW12tRVzgowhAAAPt0dWhECyurplpteZkaqiqsaQiHQhgCAGAfZheX1Ts0ZqplZ2Xp4c42ORwOi7rCYRCGAAC4T/5gUC9d7ZUh407N4XDo8e4OZXg8FnaGwyAMAQBwHwzD0MtXehUIBk31U8daVFKQb1FXiAfCEAAA96F3eGzHJqxVpcVqa6i1qCPEC2EIAIA3Mb+yqiuDw6ZalterRzrbmSeUBghDAADcQzAU1kuXr8sw3jBPSA491t2hTC+rTKcDwhAAAHswDEOvXOvVdiBgqne2NKi8qNCirhBvhCEAAPbQPz65Yzf6sqJCdTQ1WNMQjgRhCACAXSytretS36Cp5vVk6LGuDjmdfH2mE/40AQC4SzgS0YuXrysWi5nqj3a1y5fJdhvphjAEAMAbGIah167d1Ob2tql+orFeVaXFFnWFo0QYAgDgDa4Pj2psds5UKy7IV1drk0Ud4agRhgAAeN347LyuDJjXE/K43Xq8u0Mu5gmlLf5kAQDQrQnTL1/tNdUccuixrg7lZGVZ1BUSgTAEALC97UBAz1+8omg0aqqfbmtRdVmJRV0hUQhDAABbi0Sjev7iVfnv2oC1uaZKx+vZd8wOCEMAANu6vRP98vq6qV5WVKgH2o+z75hNEIYAALZ1dXBEE3PzplqOz6cnTnUyYdpG+JMGANjS6PSsrg2NmGoet1tPnelSZgYbsNoJYQgAYDuLq2t69doNU83hcOiJU53Kz8m2qCtYhTAEALCVLX9Az1+6quhdW22cbTumyhJWmLYjwhAAwDbCkYiev3hFgbueHGutrdGx+hqLuoLVCEMAAFu4/eTYysaGqV5RXKQzJ1ot6grJgDAEALCFnv4hTc4vmGp52dl6vJsnx+yOP30AQNq7PjSqGyNjplqGx6O3nOmSN8NjUVdIFoQhAEBa6x+b1OWBIVPt9pNjedk+i7pCMiEMAQDS1vDUjM7f6NtRf7jzhCqKiyzoCMmIMAQASEtjM3N69eqNHfWzJ46pqbrSgo6QrAhDAIC0M72wqJev9sqQYap3tTax+Sp2IAwBANLK3PKKvnfpqmJ3LarY3livjqYGa5pCUiMMAQDSxtLqup67cHnH6tKttTXqPtbMLvTYFWEIAJAWVjY29Z0LPYpEo6Z6Y1WlHmg/RhDCnghDAICUt761re+c71EoHDbVa8vL9HBnG0EI90QYAgCktE2/X98+d2nHfmOVJcV6rKtdTlaXxpvgbwgAIGX5g0F9+1yPtgMBU72ssEBPnj4pl8tlUWdIJYQhAEBKCoRC+va5Hm1ub5vqRXl5eupst9wEIdwnt9UNAACwX9uBgL5zvkdrm1umen5Ojp5+oFseN19vuH/8bQEApJSNrW19+3yPtvx+Uz3H59NbHzilzIwMizpDqiIMAQBSxsr6hr5z4fKOydK+zEy97cFT8mV6LeoMqYwwBABICfMrq3ruwmWFIxFTPS87W2994JSyszIt6gypjjAEAEh60wtL+l7PVUXvWlCxMC9Xbz17Splebo3h4AhDAICkNjYzp5ev9u7Ya6yssEBPnWWyNA6Pv0EAgKQ1ODGlc9f7duw+X1VaoidOdfL4POKCMAQASErXh0d1uX9oR72hqkIPd56Qi5WlESeEIQBAUjEMQz39Q7oxMrbj2LG6Gp09waariC/CEAAgacRiMZ3v7dfg5NSOY53NjTrZ0kgQQtwRhgAASSEai+nlK70an53bcexMW6vaGuos6Ap2QBgCAFguEArpxZ5rmlteMdUdcuihzjY111RZ1BnsgDAEALDU6samnr94RZt3ba/hdDr1eHeHasvLLOoMdkEYAgBYZmJuQS9fua7IXYspul0uveV0lypKiizqDHZCGAIAJJxhGLo+PKorA8M7jmV5vXrL6S4VF+RZ0BnsiDAEAEiocCSiV6/d3HWidHF+np483cWGq0gowhAAIGG2/AE9f+mKVtY3dhxrrKrUQx3H5WJVaSQYYQgAkBDzK6t64dJVBUIhU90hh063teh4fS1rCMEShCEAwJEbnJjW+Rt9OzZb9bjdery7U1WlxRZ1BhCGAABHKBaL6WLfoPrHJnYcy8vO1pOnTyo/J9uCzoDvIwwBAI5EMBTWi5evaXZpecexypJiPd7doQyPx4LOADPCEAAg7lY2NvW9S1e1ub2941hbQ51OHWuWk13nkSQIQwCAuDEMQ/3jk+rpG1T0rvlBLqdTD3W0qbG60qLugN0RhgAAcREIhvTKtV5NLyztOJbl9erJ0ydVUpBvQWfAvRGGAACHNr2wpFeu3VAgGNxx7NZCiifly8y0oDPgzRGGAAAHFo1GdXlgWDdHx3c93tZQp+7WJhZSRFIjDAEADmRtc0svXb6ulY2dq0lner16pPME6wchJRCGAAD7YhiGBiemdbFvQNG7dpuXpKrSEj3SeUKZ3gwLugP2jzAEALhvgVBIr127qcn5hR3HXE6nTh9vVWtdNdtqIKUQhgAA92V2aVkvX+mVf5dJ0vk5OXqsu0OFuTkWdAYcDmEIAHBP0VhMVweGdWNkXIaMHceP1dXo1PEWuZkkjRRFGAIA7GllfUOvXrup5fX1Hce8ngw9fLJNNWWlFnQGxA9hCACwQzgS0bWhUd0cHZdh7BwNqigu0iMn2+XL9FrQHRBfhCEAgMn0wqLO9fZry+/fcczpdKq7tVltDbVMkkbaIAwBACRJ24GgLt4c0Pjs3K7H87Kz9VhXh4rycxPcGXC0CEMAYHOGYWhgYkqX+4cUjkR2HHc6nWpvrFdHUz0rSSMtEYYAwMZWNjb12vWbWlpd2/V4WWGBHuxoU35OdoI7AxKHMAQANhSJRnVtcEQ39pggneHx6PTxFjVVVzI3CGmPMAQANjO9sKTzvX3a3GWCtCQ1VlXq9PEWttOAbRCGAMAm/MGgLt4c1NjM7K7Hc3w+PdR+XBUlRQnuDLAWYQgA0lw0GlX/+JSuDY3sOUH6RGOdOpoaWEUatkQYAoA0ZRiGRqdndXlgWNuBwK7vKS0s0ENMkIbNEYYAIM0YhqGZxWVd7h/SysbGru/xuN06fbxVzTVMkAYIQwCQRpbW1nW5f0izS8t7vqe+skJn2lqU5WUrDUAiDAFAWtjc9uvywPCek6OlW2sGnTreopKC/AR2BiQ/whAApLBAKKTrQ6MamJhSLBbb9T35OTk6daxZVaXF3BIDdkEYAoAUFIlG1Tc6od6RsV2fEJMkX2amTrY0qrGqQk6nM8EdAqmDMAQAKSQWi2l4alZXB4flDwZ3fY/H7VZ7U72O19fyqDxwHwhDAJACorGYxmfmdH14TOtbW7u+x+l06lhdjdqb6pWZwerRwP0iDAFAEgtHIhqanNHN0fE91wpyyKH6qnJ1tTYpJysrwR0CqY8wBABJKBAKqX9sUv3jkwqFw3u+r6K4SKePt6gwLzeB3QHphTAEAElk0+/XzdEJDU1OKxqN7vm+wrxcnT7Wwj5iQBwQhgAgCaxsbOrGyJjGZuZkGMae7ystLNCJxjpVl5bwmDwQJ4QhALCIYRhaWFlV78i4phcW7/neqtIStTfVq6ywIDHNATZCGAKABDMMQ1MLi+odHtPi6tqe73M4HGqorNCJxjoV5OYksEPAXghDAJAg4UhEYzNz6hub0Nrm7o/HS5LL5VJLTZXaGuqUnZWZwA4BeyIMAcARMgxDy2sbGpqc1ujMrCL3mBTt9WToWH21WutqWCcISCDCEABbi0SjevXqDQXDYT11pkuuOK3YHAqHNTozp6GJaa1sbNzzvb7MTJ1orFNTdaU8bv5vGUg0/q0DYFuRaFTPXbis/vFJedxuHauvUU1Z6YHPZxiGFlfXNDg5rfHZ+Xs+Gi/d2kC1vbFOdZXlcrF3GGAZwhAAWwpHInr+4hX1j09qfHZeJQX5Gp+dP1AYCobCGpme1dDktNY2N+/5XoccqiorVmtttSpL2EUeSAaEIQC2E45E9NzFKxoYn9TU/KIqS4q0uLquibkFRaLR+9rc1DAMza+samhyWhOz84rGYvd8f3ZWlpprKtVUXSlfJpOigWRCGAKQMJubm7pw4YJu3LypSz2X1T8wKL/fL8MwlJGRoerqKp3p7lZHR7u6u7tVU1MT9x5uB6H+sUlNLyyqvrJcvkyvFlfXtbG1rZnFZdWW7z06FAiG7owC7bVh6m0Oh0M1ZaVqrqlSRXGhnNwKA5KSw7jXUqcAEAf9/f36qy//tf72a38nV1a2nFm5ys4vVE5BkdyeDDkcDkUjEfk317Wxsqiof0v+1UU9eOa0PvzBD+jxxx+XOw4Ti8ORyOtzhKY0vbCohqryO6M0M4tLkhx65GS7Hu/u2PG5ibkFjc3MaXZp+Z4rREtSjs93ZxQoy+s9dN8AjhZhCMCRWVxc1Gd/87f03RdfUnZZjSoajykr+/4WD4xGwpodG9LG7ITKCnL1m5/+DZ0+ffrAvYQjEX33wmUNjE9qemHJFIQkaTsQ0PjsgjqaG/Setz0pSZpeWNLYzJymFxbf9DaY0+lUbVmpmmurVF5UyFwgIIUQhgDEnWEY+uY3v6nP/Pbn5MwrUd2JU3IdcGTHMAzNjY9ocei6PvDed+tnP/5x+Xy+fZ1jZxCqkC/TPGJjGIb6xiZVUpCnhqoKBYKhe64JdFtedrZaaqvUUFXB2kBAiiIMAYirWCymz/3O7+rLX/k7VXecVUFpeVzOGwr4NXLlnOpL8vVfPv/HKi4uvq/PhSMRfed8jwYmpjSzRxC6bWZxWasbm8rOylRdRdme53S5XKotL1VLTZVKCwsYBQJSHGEIQNwYhqFP/can9bV/+o5aH3xKnjjPlzEMQ6PXLqrQHdUX/uS/v2kguhOExqc0s3jvICRJ24GgRqZmZEhqb6wzTXh2Op2qLClSfUW5qstKWBwRSCOEIQBx85/+4A/1p89+WccfeavcR3TL6FYguqCqnAw988UvyLtH4AqFw/rOhcsaHJ/S7OKy6qvK7xmEbp+7b2xShmGoqrRYBTk5KisqUH1lhWrLS+XN8BzFjwTAYjznCSAuLl26pD/5s2fU8uCTRxaEpNd3cu88q9H5Zf3x5//zru+5Owg1VL95ELp97vycbHncLhXn5+lHn35cb3/ojFpqqwhCQBojDAE4NL/fr1/+xCdV0twpb9b+JjcfhMPhUEPXQ/ril57VlStXTMdC4fDrt8Ym7wSh/Tzenp+TrXAkKsMw5HHHZ58yAMmNMATg0P70C1/Qkj+i8rrGhF3Tm+VTUWO7Pvmp37iz7s/3g9CU5hZX9h2EJCnLmyGn06H1rW1NLywdResAkgxhCMChBINBPfOlZ1V9rDPhT1VVNDRrYmZeFy5cUDgS0bfP3QpC0wuLqiorPtCj7rdvla1tbml8dv4IugaQbHgcAsChfPvb31bY4VFOQVHCr+1wOJRTUaNnvvSsSqtrNbe8oq1AQFmZXk0vLGlidl4ej0dej1sZHo8yPG55PR5leDzyeNxy7hHe8nOyNTo9p6mFRYUjEZ4cA9IcT5MBOJSP/It/qemAUxX1Tfv63N9+/vd09u0/rNpj7Ye6fjgYVN8L/1t///WvaX59U6sbW1rf2tbm9rZC4YiC4bBC4YhC4bDpn6PRqDymgHQrMHk9bnk8Hg2MT6mmrET/xyMPqL4yPmslAUhO/OcOgAOLRCK6evWajj35Q5b14PF6lZmTr8GBAT3++ON36oZhyB8MamPbr40tvza2t7W5fet/N7b9CoXDCoVuh6WwAsGw1ja3FQqHFYlG5XA47twqIwwB6Y0wBODARkZG5MrwyuPNfPM3HyFHZrZu3rxpCkMOh0O+zEz5MjNVXlRoev+toBS6FYy2/Np8PSDdDku3R5Ci0ajWt7YT/eMASDDCEIAD6+vrkzs778CfX1uc09WXvq2NlWWVVtXqkXe+R77c/Z/Pl1+oC5d69FP3+f5bQckrX6Z3z6C0ub2tTX9AxfkH//kApAaeJgNwYMvLy5Lr4IsRDl65oMff9c/1no//kjJzcvXS3335QOfJ9OVobn7hwH280e2gVFZUqKbqSuXnZMflvACSF2EIwIGFQiHpEI/Tt55+SPnFpXJ7MnT66R/S3PiwttfX9n0ep8t1qxcAOADCEIADcx/ykfPsvII7/5yVnSOny63tzfV9n8eIxQ7dCwD7IgwBNmAYhja2thWOROJ63ry8PDmiBz/n1vrqnX8ObG0qFo3Il7P/OTqhoF8FBfkH7gOAvfGfUoAN9I1N6tz1m3I4HfJ5vcrxZSnX51Nu9q3/vfU6Sxme/c3/aWlpUdS/eeC+BnvOqbblhHx5Bbr03b9XWW2DfHn7DzWbq8s6/Y6nDtwHAHsjDAE2sbHt18Tc/I6VmG+vzuzxuJWV4VVOdpby3hCQboel3XZtb2lpUWBrQ9FIRK4D3KZqPnlGL3ztL7WxsqySqlo9/iPvO9DPZvi31H7ixIE+CwCEIcAG6ipKlZudJYfDocqSIhmGoWAorEAwqLXNrTsLDWa4b29b4ZE34/v/nOF2K9Obodxs3+sB6VZIqi4rUUN9ndYW51RUUb2vnn7sY/9WktT52FsP9bPFYlH515fV1tZ2qPMAsC/CEGADtxcenJxbVCgcVsku82uisditVZlf38IiEAppfevWAoSRSFQe9/e3rfBmeJSdmaX2pnr9sx9/t/7wC8/uOwzFy/zEqNqPH1NNTY0l1weQ+ghDgE3UVZRrcGJaS2vru4Yhl9OpLK9XWV7vjmNvDEqzS8vaCgSUn5OjypIinXjXu/Tv/+CPFPRvy5vlS8SPYrI2Pap/+yu/mPDrAkgfPE0G2MTtW2X+YHDfT5W5nE5lZmRoyx+Qw+FQY1WlHuvqUENVhQoKCvTOH3qHpgZ6j6jzva0uzMmrmN761sPdagNgb4QhwCZ8mZmqKC5Srs+ntc2tfX3WMAzNLC5r0x9QU1WlHu/uUGvd92+LffxnPqbo2rzWl+KzCvT9iEYimuq9qF/+xV9QRkZGwq4LIP0QhgAbKSsslMft2lcYMgehCj3W3aGWWvP8oIqKCv3q//OLmrh2XrFoNN5t72r8Ro+eePCM3vnOdybkegDSF2EISHOBUEiDE1P6p9cu6nL/oJbWN7QdCCoUfvNbZbeD0JY/oObqSj3W3bkjCN32rne9S489cFpDPa/IMIx4/xgmc+PDcmyu6Nc++Qk5DrEdCABIksM46v/XApBw4UhEk/OLGpuZ08zikimcDE/NKBgKq7Qwf9eJ1LcZhqHpxSVt+4Nqqq7UY90daq6puud1t7a29K9++qMaWVxT86mH5XDE/7+35idGtTZ6Q3/63/6L2tvb435+APZDGALSRCwW0+zSioanZjS1sKjoHrerllbXNbeyKq/HvWe4uTsIPX6qU03VlffVx8bGhn7mZ39ON8dn1NT9kDzezAP/THf3NNl/XeHFKf3Xz/+ROjs743JeACAMASluOxDQ0OSMhiantR0I3NdnJucWtbq5qWN11Tu24DAMQ9MLS9oO7D8I3eb3+/X7/++/119/5asqa+1SWW3Dvj5/t+31NY1dfU2ttdX63G99Vg0NhzsfALwRYQhIQbFYTNOLSxqcmNbMwpIM3ftfY5fTqarSEjVUlauypFjfvXBZ53v7lOX1qrTw+7fK7gShYFBNVZV64lSnGvcZhN7o3Llz+tVf+3WtBCIqrm1WcWX1vm6dba6taG50QKGVef3cz/xrfeiDH2R3egBxRxgCUsim36+hyWkNT87IHwze8723t96oryhXTXmpPG8IEf3jk/rWaxe1sLKmltpbt8oMw9DUwpL8t4PQ6ZNqrKo4dM/b29v65je/qS888+eanJ1XZlG5cgpLlFdYLK8v2zQBOhIOaWNlSevLiwqsLMgTC+t97/1x/bP3vlfV1dascA0g/RGGgCQXjcU0Nb+ooclpzS4uv+koUGFurpprqlRXWabMPdbf8QeD+l/f/p56h8fUWlctj9utqYVFBYJhNVZVxC0IvZFhGOrp6dHz3/ueLvZc1o2bNxUKR+XyeORwOBSLRBSLhNXY2KBTXV165OGH9PTTT8u7y4rYABBPhCEgSW1sbd8aBZqeVeBNRoHcLpcaKivUXFulorzc+3rc/FuvXdS53n5leT239iILhtVUXaEnTp1UQ5yD0G4Mw9D8/Lz8fr9isZgyMjJUWlpK+AGQcNx8B5JINBrV5PyiBiemNLe88qbvL87PU3NNteory0y3we5HXUW5+senNDE3r8yMDDVVV+jJ012qryw/aPv74nA4VF6emGsBwL0QhoAkEAqHNTAxpb6xyTcdBfK43WqsqlBzTZUK83IPfM3a8lLlZWcpOzNT9ZXlevL0yYQFIQBIJoQhwELbgaD6xiY0ODH1ppunlhYWqKWmSrUVZXK7XIe+dqY3Q/WVFXI6nXqsq4MgBMC2mDMEWGB9a1s3R8Y1PD2jWCy25/syPB41VVequaZK+TnZce8jFospEo3uWGsIAOyEMAQk0NLaunqHxzQ5t3DPp8LKigpvjQKVl8oVh1EgAMDeuE0GHDHDMDS7tKze4bF7Top2yKHaijKdaKxTcX5eAjsEAHsjDAFHJBaLaWJuQb0jY1pZ39jzfU6nU01VlWprrFNeti+BHQIAJMIQEHeRaFQjU7O6MTKmTb9/z/d53G611lbrWH2tfJmsrQMAViEMAXESjUY1MDGl3uExBUKhPd+X6fWqrb5WLbVVTFwGgCRAGAIOyTAMjc7M6crAsLbuMRKU6/PpRGOdGqsqmBQNAEmEMAQcwsziknr6hrSysfecoKK8PLU31aumrERO5/3v2A4ASAzCEHAAy2sb6ukf1OzS8p7vqSguUntTvcqLCu9rrzAAgDUIQ8A+bG77dXlgWGMzs3u+p6ywQKeOt6ikID+BnQEADoowBNyHQCik60OjGpiY2nPF6PycbHUfa1Z1aQkjQQCQQghDwD1EolH1jU6od2Rsz73DsrxenWxpUlN1BXOCACAFEYaAXcRiMQ1Pzerq4LD8e+wi73G71d5Ur+P1tXHZOBUAYA3CEHCX6YUlXeob0Nrm1q7HnU6njtXVqL2pXpkZGQnuDgAQb4Qh4HX+YFAXbwxobHZuz/c0VFWoq7VJOVlZCewMAHCUCEOwPcMwNDgxrZ7+wT3nBVUUF+nUsRYV5ecmuDsAwFEjDMHWVjc29dr1m1pcXdv1eGFerk4da1ZlSXGCOwMAJAphCLYUiUZ1fWhUvSNjMgxjx/EMj0enjrWouaaSx+QBIM0RhmA7M4tLOne9b88d5RurKnX6eIsyvUyOBgA7IAzBNvzBoC7eHNxz9egcn08PtR9XRUlRgjsDAFiJMIS0ZxiGhiandalv9wnSTqdTJxrr1NHUwHpBAGBDhCGktbXNLb12/aYWVlZ3PV5aWKAH24+rIDcnsY0BAJIGYQhpKRqL3ZkgvdteYh63W6ePtzJBGgBAGEL6Wd/a1kuXr2t5fX3X4/WVFTrT1qIsrzfBnQEAkhFhCGnDMAwNT83o/I1+RaPRHcdzsrL0YMdx1gwCAJgQhpAWgqGwzvX2aXyXrTQcDofaG+vV0cwEaQDAToQhpLz55RW9dKVX24HAjmN52dl6vLtDhXlsowEA2B1hCCkrGovp2tCIeofGZGjnKtIttdU609bKaBAA4J4IQ0hJm9t+vXjlupZ22VMsw+PRw50nVFteakFnAIBUQxhCyhmZntX53r5dF1AsLyrUo13t8mVmWtAZACAVEYaQMsKRiM719ml0eud2Gg6HQ12tTTrRUCen02lBdwCAVEUYQkpYWFnVy1d6d91cNcfn0+NdHSouyLOgMwBAqiMMIakZhqHe4TFdGRyWYeycJN1UXaWzJ1rlcfNXGQBwMHyDIGmFIxG9cvWGJubmdxzzuN16qKNN9ZXlFnQGAEgnhCEkpU2/X9+7eFUrGxs7jpUWFujRrnblZGVZ0BkAIN0QhpB05pdX9ELPNQVCIVPdIYc6WxrV0VTPJGkAQNwQhpBUBiemdP5G/46d5j1ut5441cm+YgCAuCMMISlEYzFdujmg/vHJHcfysrP1ljNdysv2WdAZACDdEYZguUAopBd7rmlueWXHsarSYj3W1aEMj8eCzgAAdkAYgqVWNzb1/MUru64f1N5Yr67WJuYHAQCOFGEIlpmYW9DLV64rEo2a6i6nUw91nlBjVYVFnQEA7IQwhIQzDEPXh0d1ZWB4x7Esr1dvOd3FatIAgIQhDCGhwpGIXr12U+OzczuOFRfk68lTJ+XL9FrQGQDArghDSJhAMKTvXOjRyvrOhRQbqyv1UPtxuVwuCzoDANgZYQgJsen36zvnerSxvW2qO+TQ6bYWHa+vlcPhsKg7AICdEYZw5NY2t/Sd8z3aDgRMdY/brce7O1VVykKKAADrEIZwpJbW1vXd85cVDJu31sjJytJTZ7uVn5NtUWcAANxCGMKRmVte0XMXLu94dD4/J0dvfeAUE6UBAEmBMIQjMTm/oBd7ril61x5jxQX5evpMt7wZrCgNAEgOhCHE3cjUjF65dkOGYZjqFcVFevL0SXnc/LUDACQPvpUQV31jE7pwo39Hvba8TI91tfPoPAAg6RCGEBeGYeja0IiuDo7sONZUXaWHOo6zxxgAICkRhnBohmHows0B9Y9N7DjW1lCn08dbWEMIAJC0CEM4lFgsplev3dTI9MyOY92tzWpvqicIAQCSGmEIBxaNRvXC5Wuaml801R1y6Gz7MR2rq7GoMwAA7h9hCAcSjcX0vZ5rml64Kwg5HHr0ZLsaqios6gwAgP0hDGHfYrGYXrnSuyMIuZxOPXn6pKpKSyzqDACA/SMMYV8Mw9C53j6Nzc6Z6h63W0+d6VJZUaFFnQEAcDCEIdw3wzB08eaAhianTXWXy6Wnz3artLDAmsYAADgEFn7Bfbs6OKK+ux6fdzqdeup0F0EIAJCyCEO4L73DY7o2ZF5Q0eFw6IlTnaooKbKoKwAADo8whDc1MD6lnv5BU82hW0+N1ZSVWtQVAADxQRjCPY1Mz+p8b9+O+oMdx3l8HgCQFghD2NPE3LxeudorQ+bd58+0taqlttqirgAAiC/CEHY1vbCkFy9fl2GYg9DJlia1NdRZ1BUAAPFHGMIO88sr+l7PVcViMVO9raFOnc0N1jQFAMARIQzBZGltXc9dvKJoNGqqt9RUs/s8ACAtEYZwx/rWtr57/rLCkYipXl9ZoQfajxGEAABpiTAESVIwFNZzFy4rGA6Z6jVlpXrk5Ak5nfxVAQCkJ77hoGgsphcvX9PG9rapXlFcpMe7O+QiCAEA0hjfcjZnGIYu3OjX7NKyqV6Yl6snT5+Uy+WyqDMAABKDMGRz/eOTGpyYMtUyvV49daZLHjf7+AIA0h9hyMamF5Z08caAqeZ6feNVX2amRV0BAJBYhCGbWtvc0ouXr+1YXfqRk+0qLsizqCsAABKPMGRDgVBIz13Y+Qj9yZZG1VeWW9QVAADWIAzZTDQW0wuXrmrT7zfV6yvK1dncaFFXAABYhzBkI4Zh6Nz1Ps2vrJrqxfl5evjkCRZVBADYEmHIRm6OTmh4atpU82Vm6snTXXLzCD0AwKYIQzYxNb+onr5BU83lcuktp7vky/Ra1BUAANYjDNnAysbmrk+OPdbVrqL8XIu6AgAgORCG0lwgeOvJschdu9B3tzartrzMoq4AAEgehKE0ZhiGXr7aq+1AwFRvqKpQe1O9RV0BAJBcCENp7MbIuGYWl0y1koJ8PdzRxpNjAAC8jjCUphZX13R5YMhUy/R62XwVAIC7EIbSUDAU1ouXr8swvj9h2iGHHjvZriwvT44BAPBGhKE0YxiGXrt+U1t3rTDd3lyvipIii7oCACB5EYbSzMDElCbm5k21ssICnWSrDQAAdkUYSiMr6xu6eHPAVPN6MvRYd4ecTv6oAQDYDd+QaSIcieiFnmuKxWKm+iMnT8iXmWlRVwAAJD/CUBowDEPnevu0sb1tqrc11Km6rMSirgAASA2EoTQwMj2r0elZU604P0/dx5ot6ggAgNRBGEpxa5tbOtfbZ6p53G493t0pF/OEAAB4U3xbprBINKoXeq4pete+Yw91tCnHl2VRVwAApBbCUAq7eHNAa5ubplpLbbXqK8st6ggAgNRDGEpRYzNzGpyYMtUKcnN0pq3Voo4AAEhNhKEU5A8Gd8wTcrlcery7U272HQMAYF8IQynowo0BhcJhU+3B9uPKz8m2qCMAAFIXYSjFTMzNa3x2zlSrqyhXU3WlRR0BAJDaCEMpJBgK61xvv6nm9WTogRPHLOoIAIDURxhKIRf7BhQIBk21sydalenNsKgjAABSH2EoRUwvLGlkasZUqyot4TF6AAAOiTCUAsKRiF67ftNU87jdeqjjuBwOh0VdAQCQHghDKaCnb0jbgYCpdvp4C7vRAwAQB4ShJDe3vKKBiUlTraK4SM01VRZ1BABAeiEMJbFINKpXr5lvj7lcLj3U0cbtMQAA4oQwlMSuDAxrc3vbVOtubWYTVgAA4ogwlKSWVtfVNzphqpUU5OtYXbVFHQEAkJ4IQ0koGo3qlWs3ZMi4U3M5nXq484ScTv7IAACIJ75Zk9D14TGtbW6aap3Njew9BgDAESAMJZmVjU1dHx411QrzctXWWGdNQwAApDnCUBIxDEMXevtkGN+/PeZwOPRI5wm5uD0GAMCR4Bs2iYzPzmt+ZdVUa2+qV2FerjUNAQBgA4ShJBGJRnWpb9BUy87KUmdTgzUNAQBgE4ShJHFzdHzXLTdcLpdFHQEAYA+EoSSwHQjo+vCYqVZWVKja8lKLOgIAwD4IQ0mgp39I0Wj0zmuHHDrb1sqWGwAAJABhyGKLq2sanZ411Zprq5g0DQBAghCGLGQYhi7c6DfVPG63ulqaLOoIAAD7IQxZaHR6Vktr66bayZZGZXozLOoIAAD7IQxZJByJqKd/yFTL9fnUWldjUUcAANgTYcgivcNj8geDptrZE62sNA0AQILxzWuBzW2/bo6Om2qVJcWqKi2xqCMAAOyLMGSBS32DisZid147HA6daWu1sCMAAOyLMJRgc8srmpibN9WO1dUoPyfboo4AALA3wlACxWKxHY/Sez0Z6mxutKgjAABAGEqg4akZrW5smmonWxvlzfBY1BEAACAMJUg0GtW1oVFTrSA3Ry01VdY0BAAAJBGGEmZocmbHrvRnjrfKyaP0AABYim/iBIhEo7o+PGqqlRcVqqKkyJqGAADAHYShBBicmN6xwOLJFiZNAwCQDAhDRywSjap3ZMxUqyguUllRoUUdAQCANyIMHbGB8SkFGBUCACBpEYaOUDgS0Y27RoUqS4pVWlhgTUMAAGAHwtAR6h+fVCAUMtW6Wpos6gYAAOyGMHREwpGIbo5MmGpVpSUqLsizqCMAALAbwtAR6R+bVDBsHhVirhAAAMmHMHQEQuGwboyOm2o1ZaUqzmdUCACAZEMYOgJ9Y5MKhcOmGqNCAAAkJ8JQnAVDYd28a1SotrxMhXm5FnUEAADuhTAUZ31jEwpHIqZaJ6NCAAAkLcJQHAVDYfWNmZ8gq6soV2FujkUdAQCAN0MYiqObo+OmUSGHHMwVAgAgyRGG4iQU3mVUqLJc+TnZFnUEAADuB2EoTgYnphWJRu+8dsihzuYG6xoCAAD3hTAUB9FYTP3jk6ZabUUZo0IAAKQAwlAcTM4taDsQMNXaGmot6gYAAOwHYeiQDMPYsa5QSUG+SgryLeoIAADsB2HokBZW17S0tm6qtTXUWdQNAADYL8LQIfWNmp8gy87KUk1ZiUXdAACA/SIMHcLG1rYm5xZMteP1NXI6+bUCAJAq+NY+hL7xSRky7rz2uN1qrqmysCMAALBfhKEDCoXDGp6cNtWaa6rkcbst6ggAABwEYeiAhiZndiyyeKy+xsKOAADAQRCGDiAWi+3YeqO2okw5WVkWdQQAAA6KMHQAE7sssnicUSEAAFISYWifdltksbggX6WFBdY0BAAADoUwtE+7LrJYz9YbAACkKsLQPu22yGJtealF3QAAgMMiDO3D5rafRRYBAEgzfIvvQ9/YxI5FFpuqKy3sCAAAHBZh6D5FolENT82Yas01VcrweCzqCAAAxANh6D5Nzi0oHImYasfqeJweAIBURxi6T0N3bb1RUVykHB+LLAIAkOoIQ/dhc9uvueUVU425QgAApAfC0H0YmjKPCmV4PDxODwBAmiAMvYlYLKaRqVlTraGyXC6Xy6KOAABAPBGG3sTs0vKOfciaa6os6gYAAMQbYehNDE2aH6cvystTYV6uRd0AAIB4IwzdQyAY0uS8ecXpphomTgMAkE4IQ/cwMj0rw/j+itMup1MNleUWdgQAAOKNMLQHwzA0fNdTZLUVZaw4DQBAmiEM7WFxdU1rm1umGhOnAQBIP4ShPdy9D1mOz6eywgJrmgEAAEeGMLSLcCSisZk5U625ulIOh8OijgAAwFEhDO1ibGZekWj0zmuHHGpk+w0AANISYWgXd0+criwtli/Ta1E3AADgKBGG7rK2uaXF1TVTjYnTAACkL8LQXYYmzaNCmV6vqkqLLeoGAAAcNcLQG8RiMY3eNXG6sapCLie/JgAA0hXf8m8wv7yqQDBoqjUxcRoAgLRGGHqDu0eFCvNylZ+TbVE3AAAgEQhDr4tGo5qYmzfVGiorLOoGAAAkCmHoddOLywpHIqZaXUWZRd0AAIBEIQy9bvyuW2RlhQXKzsq0qBsAAJAohCHd2n5jcmHRVKurLLeoGwAAkEiEIUlT84uKvnH7DYdDdeXcIgMAwA4IQ9r5FFlFcZEyvRkWdQMAABLJ9mHIMAy5nE7TjvQN3CIDAMA2HIZhGFY3kSiGYSgUCsnlcsnlcpkCUDAU1sTcvMZn5/Xk6ZPyuN0WdgoAABIlbcOQYRjq6enRlStXdOFSj65ev67FhUUZhiE5JI/Ho5bmZp3u7lbXyU49+uijKi5mDzIAAOwm7cLQxsaGvvGNb+iLf/6sZheXlJFfrKzcAuUWlciXkyenyyXDiCkSCmljdVkby4uKbG8otL6sH3z7W/X+971Pp06dMo0aAQCA9JU2YcgwDH3961/Xb/7O7yqWka2imkYVVVTfd6gJBfyaGR3Q1tykHjzVpU/92idVWcm+ZAAApLu0CEPz8/P61Kc/o5cv9Kim8wHlF5ce+FyxWFTjN64otDSjX/qFn9e73/1uRokAAEhjKR+GBgcH9a8++jGFM/NU194tlys+E5/Xlxc1cfWcfvyHf0i/8su/JJfLFZfzAgCA5JLSYWhoaEgf+Rc/JW9Fvaqajsf9/OFgUAPnntcPv/0t+vSnPsUIEQAAaShl1xlaWlrST/30vz6yICRJHq9Xxx5+Sl//p+f0h3/0R0dyDQAAYK2UDEOGYeizv/XbCmZkH1kQus3tyVDzA0/oT774jK5cuXKk1wIAAImXkmHoH/7hH/TdF19RQ8eZhFzPm+VTUWO7fvkTn1QgEEjINQEAQGKkXBgKBoP6zG99TlUdZ+RK4CrRFQ3Nmt8I6EvPPpuwawIAgKOXcmHoW9/6lkIOtwpLKxJ6XYfDoYqWdn3xmS8pEokk9NoAAODopFQYMgxD/+PPnlF+dYMl188vLtVmKKIXXnjBkusDAID4S6kwNDw8rIHhUZVW11vWQ25Fnf7yy39t2fUBAEB8pVQY6u3tlTevUE6ndW0XlVeq5/IVpfDyTAAA4A1SKgxduXpN7qxcS3vIzM6VPxjUzMyMpX0AAID4SNzjWHFw6fJl5RUVH/jz4WBAPc//gyYH+xQK+JVXVKK3vPuDys4ruO9zOBwOZeYWqL+/X1VVVQfuBQAAJIeUCkPLyyvKa6k98Odf/sb/VCQc1js+/FFl5eRoZX5WLrdn3+dxeDK0urp64D4AAEDySKnbZOFw+MAbpvq3NjXR36uHf+jH5MvNk8PhVFF5lTJ92fs+l8PhVDgcPlAfAAAguaRUGPJ4PIrFYgf67Nbaipwu975uie3FMGLyePY/ogQAAJJPSoWhwsICBf3bB/psdn6hYtGIttZXD92HEQkrLy/v0OcBAADWS6kw1H3ypDaWlw702azsHNW0ntBrf/8V+TfXZRgxLc9N7ztcGYahwMaqjh07dqA+AABAckmtMNR1UhH/xoE//+gPv1e+vHx98wt/rL/6D5/Va3//FUX3OfcnuL0lr9ut6urqA/cBAACSR0o9TXbixAkF1pZlGDE5HPvPcRneTD38jh+T3nHwHlbmZ9TV1SmHw3HwkwAAgKSRUiNDra2taqip1uLUhGU9rM+M633veY9l1wcAAPGVUmHI4XDoJz/yYa1MjVhy/Y2VJWW6DD399NOWXB8AAMRfSoUhSfrBH/xBucIBrS8tJPzaM4O9+tD7/zmP1QMAkEZSLgz5fD798i/+giaunVcsGk3YdecmRlSQ4dBHfuInEnZNAABw9FIuDEnSu971Lj18plvjNy4n5HqhgF8LA1f1W5/5tHw+X0KuCQAAEiMlw5DD4dCnf/3X5Nhc1uzY8JFeKxqJaOjii/rAe9+jBx544EivBQAAEi8lw5AklZWV6b9+/o+0OdGvufGjCUSRcFj9rz2ntz78gH7h//75I7kGAACwlsMwDMPqJg7j+vXr+umP/Rs5C8tVe/yknM745Lut9VWNXX5V73jqCX3m078htzullmQCAAD3KeXDkCRNTk7qVz/567raP6i6kw8qp6DowOcyjJgm+q5ra3ZM/9e/+Zg+/KEPxS1gAQCA5JMWYUiSYrGYvvzlL+vf/Yf/JFdOoUrrW5RXXHrfK0VHwiHNjA5qc3Zc7S1N+uynf0P19fVH3DUAALBa2oSh2xYXF/WVr35Vzzz7F9oIhJWRW6ScwmLlFhYrMzvnTjiKRiLaXF3W+sqiguurCqwu6LGHH9KHPvB+Pfroo4wGAQBgE2kXhm6LRCJ69dVX1dPTows9l9Xbe0Mbm5tyud0yYjFJhmpratXd1alTXV164okn2HwVAAAbStswdDfDMLS9va1QKCSXy6XMzExlZGRY3RYAALCYbcIQAADAbpgYAwAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbI0wBAAAbO3/B9EmAGD3gAGLAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -1221,14 +1179,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 18, "metadata": { "scrolled": true }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1250,12 +1208,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1282,7 +1240,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1296,40 +1254,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -1818,7 +1755,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1832,40 +1769,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -2351,12 +2267,12 @@ "source": [ "### Colormaps\n", "\n", - "In many instances, particularly when visualizing numerical data, the use of color gradients to represent values can greatly enhance the clarity and effectiveness of a plot. `pathpyG` addresses this need through its native support for `colormaps`. When the colors of node or edge elements are defined using `int` or `float` values, `pathpyG` automatically assigns colors based on these colormaps, effectively interpolating the correct color value for each element. By default, `pathpyG` offers a simple colormap that transitions from red to green, sufficient for many basic visualization needs. However, for more customized or advanced styling, users have the option to utilize any colormap from the extensive color palettes provided by `matplotlib`. Thit library offer a wide range of color schemes, enabling you to select the perfect palette to convey the nuances of your data. " + "In many instances, particularly when visualizing numerical data, the use of color gradients to represent values can greatly enhance the clarity and effectiveness of a plot. `pathpyG` addresses this need through its native support for `colormaps`. When the colors of node or edge elements are defined using `int` or `float` values, `pathpyG` automatically assigns colors based on these colormaps, effectively interpolating the correct color value for each element. By default, `pathpyG` offers a simple colormap that transitions from red to green, sufficient for many basic visualization needs. However, for more customized or advanced styling, users have the option to utilize any colormap from the extensive color palettes provided by `matplotlib`. This library offers a wide range of color schemes, enabling you to select the perfect palette to convey the nuances of your data." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -2370,40 +2286,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -2894,14 +2789,14 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Plot saved to /tmp/tmplufyx35m/test_plot.html\n", + "Plot saved to /tmp/tmp0s9o1q_6/test_plot.html\n", "File exists: True\n" ] } @@ -2925,7 +2820,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -2934,7 +2829,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -2948,40 +2843,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -3458,7 +3332,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -3472,40 +3346,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -3992,7 +3845,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -4010,7 +3863,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -4024,40 +3877,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -4663,7 +4495,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 36, "metadata": { "scrolled": true }, @@ -4679,40 +4511,13 @@ "}\n", "\n", "\n", - "
\n", - "\n", + "
\n", "" + "\n", + " \n", + " " ] }, "metadata": {}, @@ -5313,7 +5124,7 @@ ], "metadata": { "kernelspec": { - "display_name": "pathpyg", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -5327,7 +5138,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.18" + "version": "3.13.12" } }, "nbformat": 4, From 1c2c305a996a56c055cbec887ac573f7b4b44d38 Mon Sep 17 00:00:00 2001 From: Vineet Bansal Date: Wed, 9 Sep 2026 10:25:28 -0400 Subject: [PATCH 14/14] tweaks --- docs/tutorial/paths_higher_order.ipynb | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/docs/tutorial/paths_higher_order.ipynb b/docs/tutorial/paths_higher_order.ipynb index 48aae73b..9c934a3e 100644 --- a/docs/tutorial/paths_higher_order.ipynb +++ b/docs/tutorial/paths_higher_order.ipynb @@ -78,13 +78,13 @@ "}\n", "\n", "\n", - "
\n", + "
\n", "\n", " " ] @@ -757,13 +757,13 @@ "}\n", "\n", "\n", - "
\n", + "
\n", "\n", " " ] @@ -1252,7 +1252,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Why are data on paths and walks interesting in the first place. The answer is that they provide information on the **causal topology of complex systems**, i.e. which nodes can possibly causally influence each other via paths that follow the arrow of time. This information is lost if we were to split paths into an (unordered) collection of dyadyic interactions between pairs of nodes, i.e. if we were to only onsider links.\n", + "Why are data on paths and walks interesting in the first place? The answer is that they provide information on the **causal topology of complex systems**, i.e. which nodes can possibly causally influence each other via paths that follow the arrow of time. This information is lost if we were to split paths into an (unordered) collection of dyadic interactions between pairs of nodes, i.e. if we were to only onsider links.\n", "\n", "To illustrate this, let us assume that the four walks above tell us which paths information (or whatever you may be interested in) can take in the simple graph above. That is, we observe something moving from `a` via `c` to `d` and from `b` via `c` to `e`, and each of those events occur four times. However, we never observed that something moving from `a` to `c` ended up in `d`. And neither did we observe that something moving from `b` to `c` ended up in `e`. This means that - assuming that we completely observed all walks or paths - there is no way that `a` can causally influence `e` or that `b` could causally influence `d` via the center node `c`. Note that this is not what we would assume if we consider possible paths in the topology of the underlying graph, where paths of length two exist between all four pairs of nodes (`a`, `d`), (`a`, `e`), (`b`, `d`), (`b`, `e`).\n", "\n",