"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "third_order_edge_index = pp.algorithms.lift_order.lift_order_edge_index(edge_index=line_graph.data.edge_index, num_nodes=line_graph.n)\n",
+ "third_order_data = Data(edge_index=third_order_edge_index, node_sequence=torch.cat([line_graph.data.node_sequence[line_graph.data.edge_index[0]], line_graph.data.node_sequence[line_graph.data.edge_index[1]][:, -1:]], dim=1))\n",
+ "third_order_mapping = pp.IndexMap([tuple(seq) for seq in graph.mapping.to_ids(third_order_data.node_sequence).tolist()])\n",
+ "third_order_graph = pp.Graph(data=third_order_data, mapping=third_order_mapping)\n",
+ "pp.plot(third_order_graph, node_label=third_order_graph.nodes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ce852a2f",
+ "metadata": {},
+ "source": [
+ "Note that above, we constructed the `node_sequence` for the third-order graph by concatenating the sequences of the two nodes that form each edge in the second-order graph. However, only the first node in the sequence of the higher-order source and the last node in the sequence of the higher-order target node are different. The middle nodes are the same for both higher-order nodes since they represent the overlapping part of the paths.\n",
+ "\n",
+ "### Under the Hood of `lift_order_edge_index`\n",
+ "\n",
+ "Let us now take a closer look at how the `lift_order_edge_index` function works under the hood. The whole function essentially only needs 10 lines of code and looks as follows:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "adb82d39",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def lift_order_edge_index(edge_index: torch.Tensor, num_nodes: int ) -> torch.Tensor:\n",
+ " outdegree = degree(edge_index[0], dtype=torch.long, num_nodes=num_nodes)\n",
+ " outdegree_per_dst = outdegree[edge_index[1]]\n",
+ " num_new_edges = outdegree_per_dst.sum()\n",
+ " ho_edge_srcs = torch.repeat_interleave(outdegree_per_dst)\n",
+ " ptrs = cumsum(outdegree, dim=0)[:-1]\n",
+ " ho_edge_dsts = torch.repeat_interleave(ptrs[edge_index[1]], outdegree_per_dst)\n",
+ " idx_correction = torch.arange(num_new_edges, dtype=torch.long)\n",
+ " idx_correction -= cumsum(outdegree_per_dst, dim=0)[ho_edge_srcs]\n",
+ " ho_edge_dsts += idx_correction\n",
+ " return torch.stack([ho_edge_srcs, ho_edge_dsts], dim=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b90b7b2",
+ "metadata": {},
+ "source": [
+ "However, what the function does exactly is obfuscated by the heavy use of tensor operations. Let us break down the function step-by-step to understand what is happening internally.\n",
+ "\n",
+ "\n",
+ "
Note
\n",
+ "
\n",
+ " Due to the high complexity of the tensor operations, we will maintain to lines of explanations that try to explain the same concepts with different words. One explanation line will be added to the code snippets as comments and the other explanation line will be provided in the markdown cells between the code snippets.\n",
+ "
\n",
+ "
\n",
+ "
Edge index must be sorted!
\n",
+ "
\n",
+ " The lift_order_edge_index function assumes that the input edge_index is sorted by source nodes. This is not enforced by the function itself, because we ensure that the edge indices are sorted whenever we create a PathpyG.Graph object. This step is crucial for the correct functioning of the lift_order_edge_index function.\n",
+ "
\n",
+ "
\n",
+ "
Note
\n",
+ "
\n",
+ " This helps us because for the line graph transformation, we need to transform each edge into a node and then connect these nodes (previously edges) if a node in the original graph connects them. Therefore, we need to create a higher-order edge for each combination of incoming and outgoing edges for each node in the original graph. The outdegree of the target node tells us how many outgoing edges there are for each target node, which directly translates to how many higher-order edges we need to create for each incoming edge.\n",
+ "
\n",
+ "
\n",
+ "
Cumulative Sum
\n",
+ "
\n",
+ " There is one cumsum implementation in PyTorch and one in PyTorch Geometric. The one in PyTorch Geometric starts with an initial zero value, while the one in PyTorch does not. This means that the torch.cumsum function will give us the end pointers of the edges for each node, while the torch_geometric.utils.cumsum function will give us the start pointers (including a last pointer that is equal to the total number of edges). Therefore, we use the torch_geometric.utils.cumsum function here and remove the last entry afterwards.\n",
+ "
\n",
+ "
\n",
+ "\n",
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "tedges = [\n",
+ " (\"a\", \"b\", 1),\n",
+ " (\"a\", \"b\", 2),\n",
+ " (\"b\", \"a\", 3),\n",
+ " (\"b\", \"c\", 3),\n",
+ " (\"d\", \"c\", 4),\n",
+ " (\"a\", \"b\", 4),\n",
+ " (\"c\", \"b\", 4),\n",
+ " (\"c\", \"d\", 5),\n",
+ " (\"b\", \"a\", 5),\n",
+ " (\"c\", \"b\", 6),\n",
+ "]\n",
+ "t = pp.TemporalGraph.from_edge_list(tedges)\n",
+ "pp.plot(t, node_label=t.nodes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "951a8ffa",
+ "metadata": {},
+ "source": [
+ "We can create a second-order graph from this temporal graph using the `lift_order_temporal` function. This second-order graph is typically referred to as an event graph. Each node in the graph is an event (edge) in the original temporal graph and two events are connected if they can follow each other in time respecting a maximum time difference `delta`. Here, we set `delta=2` which means that two events can be connected if the time difference between them is at most 2 time units."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "7c0d6265",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████| 6/6 [00:00<00:00, 3495.74it/s]\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ "\n",
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "event_edge_index = pp.algorithms.temporal.lift_order_temporal(t, delta=2)\n",
+ "event_mapping = pp.IndexMap(t.temporal_edges)\n",
+ "event_data = Data(edge_index=event_edge_index, node_sequence=graph.data.edge_index.t())\n",
+ "event_graph = pp.Graph(data=event_data, mapping=event_mapping)\n",
+ "pp.plot(event_graph, node_label=event_graph.nodes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1a2075aa",
+ "metadata": {},
+ "source": [
+ "Starting with the event graph, we have a static higher-order representation of the temporal graph that we can use to create higher-order models. For each following lift-order transformations, we can use the same principles as described in the previous section on order-lifting and line graph transformations. \n",
+ "\n",
+ "#### Internals of the `lift_order_temporal` Function\n",
+ "\n",
+ "The simplest way to implement the `lift_order_temporal` function would be to first create the full higher-order edge index using the `lift_order_edge_index` function and then filter out the edges that do not respect the temporal ordering. The filter function could look as follows:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "42866664",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def filter_time_respecting_edges(event_edge_index: torch.Tensor, timestamps: torch.Tensor, delta: int) -> torch.Tensor:\n",
+ " # Subtract timestamps of the two events to get the time difference\n",
+ " time_diff = timestamps[event_edge_index[1]] - timestamps[event_edge_index[0]]\n",
+ " # Create masks for filtering\n",
+ " # Remove non-time-respecting higher-order edges\n",
+ " non_negative_mask = time_diff > 0\n",
+ " # Remove edges that are too far apart in time based on delta\n",
+ " delta_mask = time_diff <= delta\n",
+ " # Combine masks to get the final time-respecting edges\n",
+ " time_respecting_mask = non_negative_mask & delta_mask\n",
+ " # Filter the event_edge_index using the time_respecting_mask\n",
+ " return event_edge_index[:, time_respecting_mask]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bdb6d4c0",
+ "metadata": {},
+ "source": [
+ "We can combine the above filter function with the `lift_order_edge_index` function to create a lift-order function for temporal graphs as follows:\n",
+ "\n",
+ "\n",
+ "
Warning
\n",
+ "
\n",
+ " If we use the standard lift_order_edge_index function, we need to ensure that the input edge index is sorted by source nodes because the edge_index of a TemporalGraph is sorted by time and not by source nodes.\n",
+ "
\n",
+ "
\n",
+ "\n",
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Sort by source node indices\n",
+ "sorted_edge_index, time = sort_edge_index(t.data.edge_index.as_tensor(), t.data.time)\n",
+ "# Lift the edge index to the second order\n",
+ "second_order_edge_index = pp.algorithms.lift_order.lift_order_edge_index(edge_index=sorted_edge_index, num_nodes=t.n)\n",
+ "# Filter the edges based on the lifted edge index\n",
+ "filtered_edge_index = filter_time_respecting_edges(second_order_edge_index, timestamps=time, delta=2)\n",
+ "# Create `pp.Graph` from the filtered edge index\n",
+ "filtered_event_mapping = pp.IndexMap([tuple([*t.mapping.to_ids(edge).tolist(), timestamp.item()]) for edge, timestamp in zip(sorted_edge_index.t(), time)])\n",
+ "filtered_event_data = Data(edge_index=filtered_edge_index, node_sequence=sorted_edge_index.t())\n",
+ "filtered_event_graph = pp.Graph(data=filtered_event_data, mapping=filtered_event_mapping)\n",
+ "pp.plot(filtered_event_graph, node_label=filtered_event_graph.nodes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fc3ff7c7",
+ "metadata": {},
+ "source": [
+ "\n",
+ "
Note
\n",
+ "
\n",
+ " The indexing of the above implementation is different from the one currently implemented in PathpyG. So while the illustrations look identical, the actual indices of the higher-order nodes will differ.\n",
+ "
\n",
+ "
\n",
+ "\n",
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "path_mapping = pp.IndexMap(list(\"abcde\"))\n",
+ "paths = pp.PathData(mapping=path_mapping)\n",
+ "paths.append_walk(list(\"ab\"))\n",
+ "paths.append_walk(list(\"abd\"))\n",
+ "paths.append_walk(list(\"abec\"))\n",
+ "paths.append_walk(list(\"dbecb\"))\n",
+ "pp.plot(\n",
+ " pp.Graph.from_edge_index(paths.data.edge_index), node_label=paths.mapping.to_ids(paths.data.node_sequence).tolist()\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "528a61b3",
+ "metadata": {},
+ "source": [
+ "`pp.PathData` is the core class for working with paths in PathpyG. It allows us to gather a collection of paths that are all walks on the same underlying graph. All paths are stored using one `edge_index` internally. Thus, two nodes in a path that both correspond to the same node in the underlying graph will **not** share the same index in the path graph. Instead, each occurrence of a node in a path is represented by a separate node in the path graph. This allows us to represent paths that visit the same node multiple times without ambiguity. The information about the underlying graph is stored in the internal `PathData.data.node_sequence` tensor, similar to higher-order graphs. Let us look at the example above to illustrate this:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "id": "fe8c6e97",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The paths represented using edge index look as follows:\n",
+ "\tInternal [0, 1]: Underlying graph edge ['a', 'b']\n",
+ "\tInternal [2, 3]: Underlying graph edge ['a', 'b']\n",
+ "\tInternal [3, 4]: Underlying graph edge ['b', 'd']\n",
+ "\tInternal [5, 6]: Underlying graph edge ['a', 'b']\n",
+ "\tInternal [6, 7]: Underlying graph edge ['b', 'e']\n",
+ "\tInternal [7, 8]: Underlying graph edge ['e', 'c']\n",
+ "\tInternal [9, 10]: Underlying graph edge ['d', 'b']\n",
+ "\tInternal [10, 11]: Underlying graph edge ['b', 'e']\n",
+ "\tInternal [11, 12]: Underlying graph edge ['e', 'c']\n",
+ "\tInternal [12, 13]: Underlying graph edge ['c', 'b']\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"The paths represented using edge index look as follows:\")\n",
+ "for edge in paths.data.edge_index.t():\n",
+ " print(\n",
+ " f\"\\tInternal {edge.tolist()}: Underlying graph edge {paths.mapping.to_ids(paths.data.node_sequence[edge].view(-1)).tolist()}\"\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c265f3f1",
+ "metadata": {},
+ "source": [
+ "`PathData` additionally stores some metadata about the paths so that you can easily access information about which nodes belong to which path. This includes\n",
+ "\n",
+ "- `dag_weight`: A tensor that stores the weight of each path (i.e., the number of times the path was observed).\n",
+ "- `dag_num_edges`: A tensor that stores the number of edges in each path.\n",
+ "- `dag_num_nodes`: A tensor that stores the number of nodes in each path.\n",
+ "\n",
+ "Using this information, you can, e.g., access the second path in the collection as follows:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "id": "ad15e43f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a', 'b', 'd']"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "start = paths.data.dag_num_nodes[:1].sum().item()\n",
+ "end = start + paths.data.dag_num_nodes[1].item()\n",
+ "paths.mapping.to_ids(paths.data.node_sequence[start:end].view(-1)).tolist()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cca15ee",
+ "metadata": {},
+ "source": [
+ "Lastly, since we are using an `edge_index` internally, the `lift_order_edge_index` function works out-of-the-box for paths. A second-order representation of the paths can be created as follows:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "id": "993d5278",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ "\n",
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "second_order_edge_index = pp.algorithms.lift_order.lift_order_edge_index(\n",
+ " edge_index=paths.data.edge_index, num_nodes=paths.data.num_nodes\n",
+ ")\n",
+ "second_order_paths = pp.Graph.from_edge_index(edge_index=second_order_edge_index)\n",
+ "pp.plot(\n",
+ " second_order_paths,\n",
+ " node_label=paths.mapping.to_ids(paths.data.node_sequence[paths.data.edge_index.t()].squeeze()).tolist(),\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "de496c21",
+ "metadata": {},
+ "source": [
+ "## Multi-Order Models\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8ac717b0",
+ "metadata": {},
+ "source": [
+ "With the concepts above, we can now create multi-order models using the `MultiOrderModel` class. This class allows us to create higher-order models of arbitrary order from a given base temporal graph or paths. Let's look at an example of creating a multi-order model from a temporal graph:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "id": "20835496",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████| 6/6 [00:00<00:00, 2312.82it/s]\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ "\n",
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "m_t = pp.MultiOrderModel.from_temporal_graph(t, max_order=2)\n",
+ "pp.plot(m_t.layers[2], node_label=m_t.layers[2].nodes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "94f6db38",
+ "metadata": {},
+ "source": [
+ "We can see that the second-order graph created by the `MultiOrderModel` is different from the one created by the `lift_order_temporal` function directly. This is because the `MultiOrderModel` higher-order DeBruijn graph representation. This representation merges higher-order nodes that correspond to the same path in the original graph. This means that temporal edges that appear in the event graph as different nodes will be merged into one node in the DeBruijn graph if they correspond to the same path in the original graph. This results in a more compact representation of the higher-order graph.\n",
+ "\n",
+ "\n",
+ "The same is true for paths. We can create a multi-order model from a collection of paths as follows:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "id": "55aef58f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ "\n",
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "m_p = pp.MultiOrderModel.from_path_data(paths, max_order=2)\n",
+ "pp.plot(m_p.layers[2], node_label=m_p.layers[2].nodes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9f29b62d",
+ "metadata": {},
+ "source": [
+ "We can see that the higher-order node `a->b` which appeared thrice in the second-order graph created by the `lift_order_edge_index` function is now merged into one node in the DeBruijn graph representation."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "90dcd56d",
+ "metadata": {},
+ "source": [
+ "### Internals of the `MultiOrderModel` Class\n",
+ "\n",
+ "Let us now take a closer look at how the `MultiOrderModel` class works under the hood. We already saw that the `MultiOrderModel` merges higher-order nodes from the line/event graph transformations. \n",
+ "\n",
+ "This is done in 3 distinct steps which we will go through using the paths example above:\n",
+ "1. **Order Lifting**: First, we create the higher-order edge index using the appropriate lift-order function (`lift_order_edge_index` or `lift_order_temporal`) depending on whether we are working with paths or temporal graphs in the first order and `lift_order_edge_index` for the second order and beyond regardless of the input type.\n",
+ "\n",
+ "\n",
+ "
Note
\n",
+ "
\n",
+ " While we merge the higher-order nodes and aggregate the higher-order edges for each order, we need to use the original higher-order edge index to create the next order. This is because the transitivity of paths is only preserved in the original higher-order edge index.\n",
+ "
\n",
+ "
\n",
+ "\n",
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "third_order_paths.mapping = pp.IndexMap([tuple(mapping.to_ids(v).tolist()) for v in third_order_paths.data.node_sequence])\n",
+ "pp.plot(third_order_paths, node_label=third_order_paths.nodes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1c7e4d0f",
+ "metadata": {},
+ "source": [
+ "These steps can be repeated for each order until we reach the desired maximum order for the `MultiOrderModel`.\n",
+ "\n",
+ "## Other Tensor-based Implementations\n",
+ "\n",
+ "The concepts from above can also be useful to implement other functionalities using tensor operations. \n",
+ "\n",
+ "### Longest Path Extraction\n",
+ "\n",
+ "One example is the extraction of all longest paths from a directed acyclic graph (DAG). This can be done by iterating through all nodes in the DAG in topological order at the same time. We provide an example implementation below:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "id": "06f0820e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def get_all_paths_DAG(g: pp.Graph) -> dict:\n",
+ " \"\"\"Calculate all existing paths from any root node to any leaf node in a directed acyclic graph (DAG).\"\"\"\n",
+ " paths_of_length = {}\n",
+ " edge_index = g.data.edge_index.as_tensor()\n",
+ "\n",
+ " # calculate degrees\n",
+ " out_degree = degree(edge_index[0], num_nodes=g.n, dtype=torch.long)\n",
+ " in_degree = degree(edge_index[1], num_nodes=g.n, dtype=torch.long)\n",
+ "\n",
+ " # identify root nodes with in-degree zero\n",
+ " roots = torch.where(in_degree == 0)[0]\n",
+ " leafs = out_degree == 0\n",
+ "\n",
+ " # create path tensor that contains all paths that are not yet at a leaf node\n",
+ " paths = roots.unsqueeze(1)\n",
+ " # remove all paths that are already at a leaf node\n",
+ " paths_of_length[1] = paths[leafs[roots]].cpu().tolist()\n",
+ " # continue all paths that are not at a leaf node\n",
+ " paths = paths[~leafs[roots]]\n",
+ " # remember nodes that haven't been traversed yet\n",
+ " nodes = roots[~leafs[roots]]\n",
+ "\n",
+ " ptrs = cumsum(out_degree, dim=0)\n",
+ "\n",
+ " # count all longest paths in DAG\n",
+ " step = 1\n",
+ " while nodes.size(0) > 0 or step > g.n:\n",
+ " idx_repeat = torch.repeat_interleave(out_degree[nodes])\n",
+ " next_idx = torch.repeat_interleave(ptrs[nodes], out_degree[nodes])\n",
+ " idx_correction = (\n",
+ " torch.arange(next_idx.size(0), device=edge_index.device) - cumsum(out_degree[nodes], dim=0)[idx_repeat]\n",
+ " )\n",
+ " next_idx += idx_correction\n",
+ " next_nodes = edge_index[1][next_idx]\n",
+ " paths = torch.cat([paths[idx_repeat], next_nodes.unsqueeze(1)], dim=1)\n",
+ " paths_of_length[step] = paths[leafs[next_nodes]].tolist()\n",
+ " paths = paths[~leafs[next_nodes]]\n",
+ " nodes = next_nodes[~leafs[next_nodes]]\n",
+ " step += 1\n",
+ "\n",
+ " return paths_of_length"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7ec1f513",
+ "metadata": {},
+ "source": [
+ "The function above starts at all root nodes (nodes with no incoming edges) and iteratively traverses all possible next nodes while keeping track of all current paths. Whenever a path reaches a leaf node (a node with no outgoing edges), it is added to the list of longest paths and removed from the current paths. This continues until all paths have reached a leaf node.\n",
+ "\n",
+ "\n",
+ "
Tip
\n",
+ "
\n",
+ " Getting the next nodes for all current paths is done using a similar indexing trick as in the lift_order_edge_index function. This allows us to efficiently get all next nodes for all current paths in one go using tensor operations.\n",
+ "
\n",
+ "
\n",
- "\n",
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/plain": [
- ""
- ]
- },
- "execution_count": 138,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "event_graph = temporal_event_graph(t, delta=1)\n",
- "pp.plot(event_graph, node_label = [v for v in event_graph.nodes])"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 179,
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "100%|██████████| 3/3 [00:00<00:00, 2910.69it/s]\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "defaultdict(.()>,\n",
- " {'d-tgt': 0.0,\n",
- " 'c-tgt': 0.0,\n",
- " 'c-d-2.0': 2.0,\n",
- " 'a-c-1.0': 3.0,\n",
- " 'e-tgt': 0.0,\n",
- " 'c-e-4.0': 2.0,\n",
- " 'b-c-3.0': 3.0})"
- ]
- },
- "execution_count": 179,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "betweenness_brandes(event_graph, sources=['a-src', 'b-src', 'c-src'])"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 182,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "tensor([[0, 1, 3, 1],\n",
- " [1, 2, 1, 4]])\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "100%|██████████| 4/4 [00:00<00:00, 2712.57it/s]\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "tensor([[ 0, 2, 4, 5, 7, 5, 0, 1, 2, 3],\n",
- " [ 1, 3, 0, 1, 2, 3, 10, 11, 10, 13]])\n",
- "{4, 5, 7}\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- " 0%| | 0/3 [00:00 1\u001b[0m \u001b[43mtemporal_betweenness_brandes\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdelta\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n",
- "Cell \u001b[0;32mIn[180], line 56\u001b[0m, in \u001b[0;36mtemporal_betweenness_brandes\u001b[0;34m(g, delta)\u001b[0m\n\u001b[1;32m 53\u001b[0m bw \u001b[38;5;241m=\u001b[39m defaultdict(\u001b[38;5;28;01mlambda\u001b[39;00m: \u001b[38;5;241m0.0\u001b[39m)\n\u001b[1;32m 54\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m s \u001b[38;5;129;01min\u001b[39;00m tqdm(src_indices):\n\u001b[0;32m---> 56\u001b[0m fo_src \u001b[38;5;241m=\u001b[39m \u001b[43mfo_src\u001b[49m(s, g, src_indices, tgt_indices) \n\u001b[1;32m 57\u001b[0m dist_eg \u001b[38;5;241m=\u001b[39m defaultdict(\u001b[38;5;28;01mlambda\u001b[39;00m: \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 58\u001b[0m dist_eg[s] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n",
- "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'fo_src' referenced before assignment"
- ]
- }
- ],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": 75,
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "100%|██████████| 1157/1157 [01:15<00:00, 15.43it/s]\n",
- " 8%|▊ | 25/327 [13:32<2:43:34, 32.50s/it]"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Unexpected exception formatting exception. Falling back to standard exception\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "\n",
- "Traceback (most recent call last):\n",
- " File \"/opt/conda/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 3526, in run_code\n",
- " exec(code_obj, self.user_global_ns, self.user_ns)\n",
- " File \"/tmp/ipykernel_3320/540718842.py\", line 1, in \n",
- " temporal_betweenness_brandes(t_sp, delta=3600)\n",
- " File \"/tmp/ipykernel_3320/1211725645.py\", line 36, in temporal_betweenness_brandes\n",
- " return betweenness_brandes(event_graph, src_indices)\n",
- " File \"/tmp/ipykernel_3320/2494254184.py\", line -1, in betweenness_brandes\n",
- "KeyboardInterrupt\n",
- "\n",
- "During handling of the above exception, another exception occurred:\n",
- "\n",
- "Traceback (most recent call last):\n",
- " File \"/opt/conda/lib/python3.10/site-packages/IPython/core/interactiveshell.py\", line 2120, in showtraceback\n",
- " stb = self.InteractiveTB.structured_traceback(\n",
- " File \"/opt/conda/lib/python3.10/site-packages/IPython/core/ultratb.py\", line 1435, in structured_traceback\n",
- " return FormattedTB.structured_traceback(\n",
- " File \"/opt/conda/lib/python3.10/site-packages/IPython/core/ultratb.py\", line 1326, in structured_traceback\n",
- " return VerboseTB.structured_traceback(\n",
- " File \"/opt/conda/lib/python3.10/site-packages/IPython/core/ultratb.py\", line 1173, in structured_traceback\n",
- " formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,\n",
- " File \"/opt/conda/lib/python3.10/site-packages/IPython/core/ultratb.py\", line 1088, in format_exception_as_a_whole\n",
- " frames.append(self.format_record(record))\n",
- " File \"/opt/conda/lib/python3.10/site-packages/IPython/core/ultratb.py\", line 970, in format_record\n",
- " frame_info.lines, Colors, self.has_colors, lvals\n",
- " File \"/opt/conda/lib/python3.10/site-packages/IPython/core/ultratb.py\", line 792, in lines\n",
- " return self._sd.lines\n",
- " File \"/opt/conda/lib/python3.10/site-packages/stack_data/utils.py\", line 145, in cached_property_wrapper\n",
- " value = obj.__dict__[self.func.__name__] = self.func(obj)\n",
- " File \"/opt/conda/lib/python3.10/site-packages/stack_data/core.py\", line 698, in lines\n",
- " pieces = self.included_pieces\n",
- " File \"/opt/conda/lib/python3.10/site-packages/stack_data/utils.py\", line 145, in cached_property_wrapper\n",
- " value = obj.__dict__[self.func.__name__] = self.func(obj)\n",
- " File \"/opt/conda/lib/python3.10/site-packages/stack_data/core.py\", line 649, in included_pieces\n",
- " pos = scope_pieces.index(self.executing_piece)\n",
- " File \"/opt/conda/lib/python3.10/site-packages/stack_data/utils.py\", line 145, in cached_property_wrapper\n",
- " value = obj.__dict__[self.func.__name__] = self.func(obj)\n",
- " File \"/opt/conda/lib/python3.10/site-packages/stack_data/core.py\", line 628, in executing_piece\n",
- " return only(\n",
- " File \"/opt/conda/lib/python3.10/site-packages/executing/executing.py\", line 164, in only\n",
- " raise NotOneValueFound('Expected one value, found 0')\n",
- "executing.executing.NotOneValueFound: Expected one value, found 0\n"
- ]
- }
- ],
- "source": [
- "temporal_betweenness_brandes(t_sp, delta=3600)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "base",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.10.13"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/docs/tutorial/temporal_clusters.html b/docs/tutorial/temporal_clusters.html
deleted file mode 100644
index c7af53cbd..000000000
--- a/docs/tutorial/temporal_clusters.html
+++ /dev/null
@@ -1,306 +0,0 @@
-
-
-
-
-
\ No newline at end of file
diff --git a/docs/tutorial/temporal_shortest_paths.ipynb b/docs/tutorial/temporal_shortest_paths.ipynb
deleted file mode 100644
index fd99737ae..000000000
--- a/docs/tutorial/temporal_shortest_paths.ipynb
+++ /dev/null
@@ -1,845 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [],
- "source": [
- "import pathpyG as pp\n",
- "from torch_geometric.utils import cumsum, coalesce, degree, sort_edge_index\n",
- "import torch\n",
- "\n",
- "from scipy.sparse.csgraph import bellman_ford, dijkstra\n",
- "import numpy as np\n",
- "\n",
- "from collections import defaultdict\n",
- "\n",
- "\n",
- "from tqdm import tqdm"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Temporal Graph with 327 nodes, 11636 unique edges and 754032 events in [1385982080.0, 1386345600.0]\n",
- "\n",
- "Graph attributes\n",
- "\tdst\t\t -> torch.Size([754032])\n",
- "\tsrc\t\t -> torch.Size([754032])\n",
- "\tt\t\t -> torch.Size([754032])\n",
- "\n",
- "1157\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/opt/conda/lib/python3.10/site-packages/torch_geometric/data/storage.py:450: UserWarning: Unable to accurately infer 'num_nodes' from the attribute set '{'dst', 'src', 't'}'. Please explicitly set 'num_nodes' as an attribute of 'data' to suppress this warning\n",
- " warnings.warn(\n"
- ]
- }
- ],
- "source": [
- "t_sp = pp.io.read_csv_temporal_graph('sociopatterns_highschool_2013.tedges', header=False).to_undirected()\n",
- "print(t_sp)\n",
- "print(torch.unique(t_sp.data.t).size(0))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Temporal Graph with 68 nodes, 752 unique edges and 2090 events in [899.0, 1796.0]\n",
- "\n",
- "Graph attributes\n",
- "\tdst\t\t -> torch.Size([2090])\n",
- "\tsrc\t\t -> torch.Size([2090])\n",
- "\tt\t\t -> torch.Size([2090])\n",
- "\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/opt/conda/lib/python3.10/site-packages/torch_geometric/data/storage.py:450: UserWarning: Unable to accurately infer 'num_nodes' from the attribute set '{'dst', 'src', 't'}'. Please explicitly set 'num_nodes' as an attribute of 'data' to suppress this warning\n",
- " warnings.warn(\n"
- ]
- }
- ],
- "source": [
- "t_ants = pp.io.read_csv_temporal_graph('../data/ants_2_2_val.tedges', header=False)\n",
- "print(t_ants)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "100%|██████████| 594/594 [00:00<00:00, 5479.47it/s]"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Created temporal event DAG with 1181 nodes and 4023 edges\n",
- "[[ 0. 1. inf ... inf inf inf]\n",
- " [ 1. 0. inf ... inf inf inf]\n",
- " [ 5. 3. 0. ... 2. inf inf]\n",
- " ...\n",
- " [inf inf inf ... 0. inf inf]\n",
- " [inf inf inf ... inf 0. inf]\n",
- " [inf inf inf ... 1. inf 0.]]\n",
- "{'JJJJ': 1399.0180458430464, 'WGG_': 1491.1753968253968, '_Y_B': 1461.7166666666667, 'HHHH': 996.0666666666666, 'WGRB': 1834.2047619047619, 'WYWY': 1540.441666666667, 'WY_G': 761.1371794871794, 'XXXX': 1670.8789682539682, 'LLLL': 1182.7095238095237, 'FFFF': 1062.2448773448773, 'WYG_': 1978.7333333333331, 'WW__': 1790.2027777777776, 'WRWB': 1743.196428571429, 'AAAA': 581.3047619047619, 'WGYW': 1155.8297619047619, 'WBYY': 968.8944444444444, '_R__': 880.7575396825396, 'WYBG': 1448.1039682539683, 'W__W': 1546.319877344877, 'RRRR': 924.1214285714285, 'WYRW': 1601.938095238095, 'WYYB': 865.6825396825396, 'WG_W': 1494.8178571428573, 'WRR_': 1195.2853174603176, 'W__G': 867.9182900432901, '_WRR': 622.8873015873016, 'WY_R': 1549.3750000000002, '_YYY': 1706.9047619047617, 'WRGG': 1571.4158730158733, 'WWGY': 1374.6964285714284, 'WW_W': 1325.6428571428573, 'W_W_': 842.7908730158728, 'WYYR': 798.6825396825395, 'ZZZZ': 662.777922077922, 'W_RG': 1339.8936507936507, 'WBGW': 512.55, 'WBGG': 1543.3130952380955, 'WWRY': 965.0658730158731, 'W___': 518.640909090909, 'VVVV': 394.82142857142856, 'WGGY': 402.0, 'WG__': 402.0, 'WY__': 1094.4130952380951, 'W_GY': 847.5990842490843, 'WYWW': 383.8191197691197, 'OOOO': 866.3738095238094, 'W_BG': 1306.0214285714287, 'TTTT': 549.4, 'WBWY': 1183.2944444444443, 'WWY_': 1060.354761904762, 'WBGR': 67.0, 'WGWY': 597.4166666666666, 'PPPP': 1146.8166666666664, 'WGGW': 917.4214285714285, 'EEEE': 617.1976190476189, '__YR': 134.0, 'WYYG': 548.8972582972583, 'WGGG': 207.70000000000002, 'IIII': 409.81666666666666, 'MMMM': 201.0, 'UUUU': 67.0, 'W_WG': 67.0, 'WYY_': 134.0, 'WWR_': 134.0, 'QQQQ': 415.4, 'WR__': 1117.5440476190474, 'W_GW': 167.5, 'AAAB': 0.0}\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "\n"
- ]
- }
- ],
- "source": [
- "c = pp.algorithms.centrality.temporal_closeness_centrality(t_ants, delta=60)\n",
- "print(c)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 47,
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "100%|██████████| 17/17 [00:00<00:00, 5773.07it/s]"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Created temporal event DAG with 38 nodes and 47 edges\n",
- "(9, 38)\n",
- "(9, 9)\n",
- "[[ 0. 1. 1. 3. 3. inf 1. 2. inf]\n",
- " [inf 0. 1. 2. 2. 1. inf inf 1.]\n",
- " [ 2. inf 0. 1. 1. 1. 3. 1. 1.]\n",
- " [inf inf inf 0. inf inf inf inf inf]\n",
- " [inf inf inf inf 0. inf inf inf inf]\n",
- " [ 1. inf inf inf inf 0. 2. 1. inf]\n",
- " [inf inf inf inf inf inf 0. 1. inf]\n",
- " [inf inf inf inf inf 1. inf 0. 1.]\n",
- " [inf 1. inf inf inf inf inf inf 0.]]\n",
- "{'a': 12.0, 'b': 16.0, 'c': 16.0, 'd': 14.666666666666666, 'e': 14.666666666666666, 'f': 24.0, 'g': 14.666666666666666, 'h': 28.0, 'i': 24.0}\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "\n"
- ]
- }
- ],
- "source": [
- "tedges = [('a', 'b', 1), ('b', 'c', 5), ('c', 'd', 9), ('c', 'e', 9),\n",
- " ('c', 'f', 11), ('f', 'a', 13), ('a', 'g', 18), ('b', 'f', 21),\n",
- " ('a', 'g', 26), ('c', 'f', 27), ('h', 'f', 27), ('g', 'h', 28),\n",
- " ('a', 'c', 30), ('a', 'b', 31), ('c', 'h', 32), ('f', 'h', 33),\n",
- " ('b', 'i', 42), ('i', 'b', 42), ('c', 'i', 47), ('h', 'i', 50)]\n",
- "t = pp.TemporalGraph.from_edge_list(tedges)\n",
- "c = pp.algorithms.centrality.temporal_closeness_centrality(t, 5)\n",
- "print(c)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 49,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Temporal Graph with 5 nodes, 6 unique edges and 6 events in [0.0, 3.0]\n",
- "\n",
- "Graph attributes\n",
- "\tdst\t\t -> torch.Size([6])\n",
- "\tt\t\t -> torch.Size([6])\n",
- "\tsrc\t\t -> torch.Size([6])\n",
- "\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/opt/conda/lib/python3.10/site-packages/torch_geometric/data/storage.py:450: UserWarning: Unable to accurately infer 'num_nodes' from the attribute set '{'dst', 't', 'src'}'. Please explicitly set 'num_nodes' as an attribute of 'data' to suppress this warning\n",
- " warnings.warn(\n"
- ]
- }
- ],
- "source": [
- "t = pp.TemporalGraph.from_edge_list([(0,1,0), (0,2,0), (1,2,1), (1,3,1), (3,4,2), (1,4,3)])\n",
- "print(t)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "100%|██████████| 4/4 [00:00<00:00, 262.99it/s]"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Created temporal event DAG with 17 nodes and 15 edges\n",
- "{0.0: 0.0, 1.0: 4.0, 2.0: 8.0, 3.0: 6.0, 4.0: 9.333333333333332}\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "\n"
- ]
- }
- ],
- "source": [
- "c = pp.algorithms.centrality.temporal_closeness_centrality(t, delta=1)\n",
- "print(c)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [],
- "source": [
- "# old code with explosive memory usage due to computation of all second-order edges irrespective of time stamps\n",
- "def lift_order_not_efficient(g: pp.TemporalGraph, delta=1):\n",
- " # first-order edge index\n",
- " edge_index, timestamps = sort_edge_index(g.data.edge_index, g.data.t)\n",
- " node_sequence = torch.arange(g.data.num_nodes, device=edge_index.device).unsqueeze(1)\n",
- " print(edge_index)\n",
- " # second-order edge index with time-respective filtering\n",
- " null_model_edge_index = pp.MultiOrderModel.lift_order_edge_index(edge_index, num_nodes=node_sequence.size(0)) \n",
- " # Update node sequences\n",
- " node_sequence = torch.cat([node_sequence[edge_index[0]], node_sequence[edge_index[1]][:, -1:]], dim=1)\n",
- " # Remove non-time-respecting higher-order edges\n",
- " time_diff = timestamps[null_model_edge_index[1]] - timestamps[null_model_edge_index[0]]\n",
- " non_negative_mask = time_diff > 0\n",
- " delta_mask = time_diff <= delta\n",
- " time_respecting_mask = non_negative_mask & delta_mask\n",
- " edge_index = null_model_edge_index[:, time_respecting_mask]\n",
- " return edge_index"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [],
- "source": [
- "# new memory-efficient code\n",
- "def lift_order_efficient(g: pp.TemporalGraph, delta: int = 1):\n",
- "\n",
- " # first-order edge index\n",
- " edge_index, timestamps = g.data.edge_index, g.data.t\n",
- " # print(edge_index)\n",
- "\n",
- " indices = torch.arange(0, edge_index.size(1), device=g.data.edge_index.device)\n",
- "\n",
- " unique_t = torch.unique(timestamps, sorted=True)\n",
- " second_order = []\n",
- "\n",
- " # lift order: find possible continuations for edges in each time stamp\n",
- " for i in tqdm(range(unique_t.size(0))):\n",
- " t = unique_t[i]\n",
- " #print('timestamp index ', i)\n",
- " #print('timestamp ', t)\n",
- " \n",
- " # find indices of all source edges that occur at unique timestamp t\n",
- " src_time_mask = (timestamps == t)\n",
- " src_edges = edge_index[:,src_time_mask]\n",
- " src_edge_idx = indices[src_time_mask]\n",
- " #print(src_edges)\n",
- " #print(src_edge_idx)\n",
- "\n",
- " # find indices of all edges that can possibly continue edges occurring at time t for the given delta\n",
- " dst_time_mask = (timestamps > t) & (timestamps <= t+delta)\n",
- " dst_edges = edge_index[:,dst_time_mask] \n",
- " dst_edge_idx = indices[dst_time_mask]\n",
- " #print(dst_edges)\n",
- " #print(dst_edge_idx)\n",
- "\n",
- " if dst_edge_idx.size(0)>0 and src_edge_idx.size(0)>0:\n",
- "\n",
- " # compute second-order edges between src and dst idx for all edges where dst in src_edges matches src in dst_edges \n",
- " x = torch.cartesian_prod(src_edge_idx, dst_edge_idx).t()\n",
- " src_edges = torch.index_select(edge_index, dim=1, index=x[0])\n",
- " dst_edges = torch.index_select(edge_index, dim=1, index=x[1])\n",
- " #print(src_edges)\n",
- " #print(dst_edges)\n",
- " ho_edge_index = x[:,torch.where(src_edges[1,:] == dst_edges[0,:])[0]]\n",
- " second_order.append(ho_edge_index)\n",
- " #print(ho_edge_index) \n",
- " \n",
- " # #print('dst', dst)\n",
- " # src_mask = (edge_index[:,mask][0]==dst)\n",
- " # ctd = edge_index[:,mask][:,src_mask]\n",
- " # #print('continuations', ctd)\n",
- " # ctd_indices = torch.where(edge_index[:,mask][0]==dst)[0] \n",
- " # #print('ctd indx', ctd_indices)\n",
- " # count += ctd_indices.size(0)\n",
- " ho_index = torch.cat(second_order, dim=1) \n",
- " return ho_index"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [],
- "source": [
- "def fo_nodes(ho_edge, g):\n",
- " src_edge = ho_edge[0]\n",
- " dst_edge = ho_edge[1]\n",
- " return g.data.edge_index[:,src_edge][0], g.data.edge_index[:,dst_edge][0], g.data.edge_index[:,dst_edge][1]\n",
- "\n",
- "\n",
- "def temporal_shortest_paths_all(g: pp.TemporalGraph, delta: int):\n",
- " # generate temporal event DAG\n",
- " edge_index = lift_order_efficient(g, delta)\n",
- "\n",
- " # Add indices of first-order nodes as src and dst of paths in TEG\n",
- " src_edges_src = g.data.edge_index[0,:] + g.data.edge_index.size(1)\n",
- " src_edges_dst = torch.arange(0, g.data.edge_index.size(1)) \n",
- " dst_edges_src = torch.arange(0, g.data.edge_index.size(1))\n",
- " dst_edges_dst = g.data.edge_index[1,:] + 2*g.data.edge_index.size(1)\n",
- "\n",
- " src_edges = torch.stack([src_edges_src, src_edges_dst])\n",
- " dst_edges = torch.stack([dst_edges_src, dst_edges_dst])\n",
- " edge_index = torch.cat([edge_index, src_edges, dst_edges], dim=1)\n",
- "\n",
- " event_graph = pp.Graph.from_edge_index(edge_index)\n",
- " \n",
- " # initialize distance matrix \n",
- " dist = torch.full((g.n, event_graph.n), float(\"inf\"), device=g.data.edge_index.device)\n",
- "\n",
- " # predecessor lists\n",
- " pred = defaultdict(lambda: defaultdict(list))\n",
- "\n",
- " # Fastest known single source SP in DAG (Cormen, Leiserson): single scan of edges in DAG\n",
- " # trick: index of second-order nodes = topological sorting of event DAG assuming that edges are given in chronological order \n",
- " # scan second-order nodes in topological order and relax distances between first-order nodes\n",
- "\n",
- " # TODO: correct algorithm\n",
- " for src in tqdm(g.nodes):\n",
- " dist[g.mapping.to_idx(src), g.mapping.to_idx(src) + g.data.edge_index.size(1)] = 0\n",
- " for v in event_graph.nodes:\n",
- " for w in event_graph.successors(v):\n",
- " dist[g.mapping.to_idx(src), w] = min(dist[g.mapping.to_idx(src), w], dist[g.mapping.to_idx(src), v]+1)\n",
- " \n",
- " dist_fo = dist[:,2*g.m:] - 1\n",
- " dist_fo.fill_diagonal_(0)\n",
- " return dist_fo, pred\n",
- "\n",
- "\n",
- "def temporal_shortest_paths(g: pp.TemporalGraph, delta: int):\n",
- " # generate temporal event DAG\n",
- " edge_index = lift_order_efficient(g, delta) \n",
- "\n",
- " # Add indices of g.n first-order nodes as source nodes of paths in augmented TEG\n",
- " src_edges_src = g.m + g.data.edge_index[0,:]\n",
- " src_edges_dst = torch.arange(0, g.data.edge_index.size(1))\n",
- "\n",
- " # Add indices of g.n first-order nodes as target nodes of paths in augmented TEG\n",
- " dst_edges_src = torch.arange(0, g.data.edge_index.size(1))\n",
- " dst_edges_dst = g.m + g.n + g.data.edge_index[1,:]\n",
- "\n",
- " src_edges = torch.stack([src_edges_src, src_edges_dst])\n",
- " dst_edges = torch.stack([dst_edges_src, dst_edges_dst])\n",
- " edge_index = torch.cat([edge_index, src_edges, dst_edges], dim=1)\n",
- "\n",
- " event_graph = pp.Graph.from_edge_index(edge_index, num_nodes=g.m + 2 * g.n)\n",
- " m = event_graph.sparse_adj_matrix()\n",
- " print(m.shape)\n",
- " # compute shortest paths from all source nodes to all nodes \n",
- " dist, pred = dijkstra(m, directed=True, indices = np.arange(g.m, g.m+g.n), return_predecessors=True, unweighted=True)\n",
- " print(dist.shape)\n",
- " print(g.n + g.m)\n",
- " # we are only interested in target nodes, whose indices start at G.m + G.n\n",
- " dist_fo = dist[:,g.m+g.n:] - 1\n",
- " np.fill_diagonal(dist_fo, 0)\n",
- " pred_fo = pred[:,g.n+g.m:]\n",
- " return dist_fo, pred_fo\n",
- "\n",
- "\n",
- " \n",
- "def temporal_closeness_centrality(g: pp.TemporalGraph, delta: int) -> dict:\n",
- "\n",
- " centralities = dict()\n",
- " dist, _ = temporal_shortest_paths(g, delta)\n",
- " for x in g.nodes:\n",
- " centralities[x] = sum((g.n - 1) / dist[np.arange(g.n)!=x, g.mapping.to_idx(x)])\n",
- "\n",
- " return centralities"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "100%|██████████| 594/594 [00:00<00:00, 6304.91it/s]"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "(1181, 1181)\n",
- "(68, 1181)\n",
- "1113\n",
- "(68, 68)\n",
- "68\n",
- "1045\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "\n"
- ]
- }
- ],
- "source": [
- "dist, pred = temporal_shortest_paths(t_ants, delta=30)\n",
- "print(dist.shape)\n",
- "print(t_ants.n)\n",
- "print(t_ants.m)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {},
- "outputs": [
- {
- "ename": "NameError",
- "evalue": "name 'idx' is not defined",
- "output_type": "error",
- "traceback": [
- "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43midx\u001b[49m[:,\u001b[38;5;241m1\u001b[39m]\n",
- "\u001b[0;31mNameError\u001b[0m: name 'idx' is not defined"
- ]
- }
- ],
- "source": [
- "idx[:,1]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "edge_index = lift_order_efficient(t)\n",
- "print(edge_index)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 50,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "tensor([[0, 0, 1, 1, 3, 1],\n",
- " [1, 2, 2, 3, 4, 4]])\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "100%|██████████| 4/4 [00:00<00:00, 2955.30it/s]"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "(16, 16)\n",
- "(5, 16)\n",
- "11\n",
- "[[ 0. 1. 1. 2. 3.]\n",
- " [inf 0. 1. 1. 1.]\n",
- " [inf inf 0. inf inf]\n",
- " [inf inf inf 0. 1.]\n",
- " [inf inf inf inf 0.]]\n",
- "[[-9999 0 1 3 4]\n",
- " [-9999 -9999 2 3 5]\n",
- " [-9999 -9999 -9999 -9999 -9999]\n",
- " [-9999 -9999 -9999 -9999 4]\n",
- " [-9999 -9999 -9999 -9999 -9999]]\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "\n"
- ]
- }
- ],
- "source": [
- "print(t.data.edge_index)\n",
- "dist, pred = temporal_shortest_paths(t, delta=1)\n",
- "\n",
- "print(dist)\n",
- "print(pred)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 51,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "array([ 3., 1., inf, 1., 0.])"
- ]
- },
- "execution_count": 51,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "dist[:,4]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "t.mapping.node_ids"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(temporal_closeness_centrality(t, delta=1))\n",
- "print(t.n)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "temporal_shortest_paths(t_sp, delta=3600)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "edge_index[0,:]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "t.data.edge_index[:,edge_index[0,:]][0]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "t.data.edge_index[:,edge_index[1,:]][1]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "#print(t.data.edge_index)\n",
- "print(t_sp)\n",
- "g = temporal_shortest_paths(t_sp, delta=300)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "indeg = degree(g.data.edge_index[1])\n",
- "roots = torch.where(indeg==0)[0]\n",
- "print(roots)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "def traverse(g, path):\n",
- " if g.get_successors(path[-1]).size(0) == 0:\n",
- " pass\n",
- " else:\n",
- " for w in g.successors(path[-1]):\n",
- " traverse(g, path + (w,))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "i = 0\n",
- "for x in roots:\n",
- " print(x)\n",
- " traverse(g, (x,))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "ho_index = lift_order_not_efficient(t, delta=1)\n",
- "print(ho_index)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "ho_index = lift_order_efficient(t, delta=1)\n",
- "print(ho_index)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "print(t.data.edge_index)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "node_sequence = torch.arange(t.data.num_nodes, device=t.data.edge_index.device).unsqueeze(1)\n",
- "print(node_sequence)\n",
- "node_sequence = torch.cat([node_sequence[t.data.edge_index[0]], node_sequence[t.data.edge_index[1]][:, -1:]], dim=1)\n",
- "print(node_sequence)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "lift_order_not_efficient(t_sp, delta=300)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "lift_order_efficient(t_sp, delta=300)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "lift_order_not_efficient(t_sp, delta=300)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "x = torch.cartesian_prod(torch.tensor([0,1]), torch.tensor([1,3])).t()\n",
- "# edge 0 = 0->1\n",
- "# edge 1 = 1->2\n",
- "# edge 2 = 0->1\n",
- "\n",
- "# combination 0,1: 0->1, 1->2\n",
- "# combination 0,2: 0->1, 0->1\n",
- "print(x)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "src_edges = torch.index_select(t.data.edge_index, dim=1, index=x[0])\n",
- "print(src_edges)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "dst_edges = torch.index_select(t.data.edge_index, dim=1, index=x[1])\n",
- "print(dst_edges)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- " #select all indices where \n",
- "torch.where(src_edges[1,:] == dst_edges[0,:])[0]\n",
- "x[:,torch.where(src_edges[1,:] == dst_edges[0,:])[0]]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "base",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.10.13"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/docs/tutorial/wl.ipynb b/docs/tutorial/wl.ipynb
deleted file mode 100644
index 31b21ad07..000000000
--- a/docs/tutorial/wl.ipynb
+++ /dev/null
@@ -1,250 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [],
- "source": [
- "import pathpyG as pp\n",
- "import torch\n",
- "from torch_geometric import EdgeIndex"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "EdgeIndex([[0, 1, 1],\n",
- " [1, 2, 3]], sparse_size=(4, 4), nnz=3, sort_order=row)\n",
- "EdgeIndex([[0, 1, 1],\n",
- " [1, 2, 3]], sparse_size=(4, 4), nnz=3, sort_order=row)\n",
- "EdgeIndex([[0, 0, 1, 1, 1, 1],\n",
- " [1, 1, 2, 3, 2, 3]], sparse_size=(4, 4), nnz=6, sort_order=row)\n",
- "Directed graph with 4 nodes and 6 edges\n",
- "\n",
- "Graph attributes\n",
- "\tnum_nodes\t\t\n",
- "\n"
- ]
- }
- ],
- "source": [
- "g1 = pp.Graph.from_edge_index(torch.tensor([[0,1,1],[1,2,3]]), mapping=pp.IndexMap(['a', 'b', 'c', 'd']))\n",
- "print(g1.data.edge_index)\n",
- "g2 = pp.Graph.from_edge_index(torch.tensor([[0,1,1],[1,2,3]]), mapping=pp.IndexMap(['a', 'b', 'c', 'd']))\n",
- "print(g2.data.edge_index)\n",
- "g = g1 + g2\n",
- "print(g.data.edge_index)\n",
- "print(g)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "EdgeIndex([[0, 1, 1],\n",
- " [1, 2, 3]], sparse_size=(4, 4), nnz=3, sort_order=row)\n",
- "EdgeIndex([[0, 1, 1],\n",
- " [1, 2, 3]], sparse_size=(4, 4), nnz=3, sort_order=row)\n",
- "EdgeIndex([[0, 1, 1, 4, 5, 5],\n",
- " [1, 2, 3, 5, 6, 7]], sparse_size=(8, 8), nnz=6, sort_order=row)\n",
- "Directed graph with 8 nodes and 6 edges\n",
- "\n",
- "Graph attributes\n",
- "\tnum_nodes\t\t\n",
- "\n"
- ]
- }
- ],
- "source": [
- "g1 = pp.Graph.from_edge_index(torch.tensor([[0,1,1],[1,2,3]]), mapping=pp.IndexMap(['a', 'b', 'c', 'd']))\n",
- "print(g1.data.edge_index)\n",
- "g2 = pp.Graph.from_edge_index(torch.tensor([[0,1,1],[1,2,3]]), mapping=pp.IndexMap(['e', 'f', 'g', 'h']))\n",
- "print(g2.data.edge_index)\n",
- "g = g1 + g2\n",
- "print(g.data.edge_index)\n",
- "print(g)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "EdgeIndex([[0, 1, 1],\n",
- " [1, 2, 3]], sparse_size=(4, 4), nnz=3, sort_order=row)\n",
- "EdgeIndex([[0, 1, 1],\n",
- " [1, 2, 3]], sparse_size=(4, 4), nnz=3, sort_order=row)\n",
- "EdgeIndex([[0, 0, 1, 1, 1, 1],\n",
- " [1, 1, 2, 3, 4, 5]], sparse_size=(6, 6), nnz=6, sort_order=row)\n",
- "Directed graph with 6 nodes and 6 edges\n",
- "\n",
- "Graph attributes\n",
- "\tnum_nodes\t\t\n",
- "\n"
- ]
- }
- ],
- "source": [
- "g1 = pp.Graph.from_edge_index(torch.tensor([[0,1,1],[1,2,3]]), mapping=pp.IndexMap(['a', 'b', 'c', 'd']))\n",
- "print(g1.data.edge_index)\n",
- "g2 = pp.Graph.from_edge_index(torch.tensor([[0,1,1],[1,2,3]]), mapping=pp.IndexMap(['a', 'b', 'g', 'h']))\n",
- "print(g2.data.edge_index)\n",
- "g = g1 + g2\n",
- "print(g.data.edge_index)\n",
- "print(g)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {},
- "outputs": [],
- "source": [
- "def num_labels(d):\n",
- " return len(set(d.values()))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 35,
- "metadata": {},
- "outputs": [],
- "source": [
- "from typing import Tuple, List"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 45,
- "metadata": {},
- "outputs": [],
- "source": [
- "def WL_test(g1: pp.Graph, g2: pp.Graph) -> Tuple[bool, List[str], List[str]]:\n",
- " \"\"\"Run Weisfeiler-Leman test on two graphs\"\"\"\n",
- " if g1.mapping is None or g2.mapping is None:\n",
- " raise Exception('Graphs must contain IndexMap that assigns node IDs')\n",
- " if len(set(g1.mapping.node_ids).intersection(g2.mapping.node_ids)) > 0:\n",
- " raise Exception('node identifiers of graphs must not overlap')\n",
- " g_combined = g1 + g2\n",
- " # initialize labels of all ndoes to zero\n",
- " fingerprint = { v:'0' for v in g_combined.nodes }\n",
- " labels = {} \n",
- " label_count = 1\n",
- " stop = False\n",
- " while not stop:\n",
- " new_fingerprint = {} \n",
- " for node in g_combined.nodes:\n",
- " # create new label based on own label and sorted labels of all neighbors\n",
- " n_label = [fingerprint[x] for x in g_combined.successors(node)]\n",
- " n_label.sort()\n",
- " label = str(fingerprint[node]) + str(n_label)\n",
- " # previously unknown label\n",
- " if label not in labels:\n",
- " # create a new label based on next consecutive number\n",
- " labels[label] = label_count\n",
- " label_count += 1 \n",
- " new_fingerprint[node] = labels[label] \n",
- " if len(set(fingerprint.values())) == len(set(new_fingerprint.values())):\n",
- " # we processed all nodes in both graphs without encountering a new label, so we stop\n",
- " stop = True\n",
- " else:\n",
- " # update fingerprint and continue\n",
- " fingerprint = new_fingerprint.copy()\n",
- " fingerprint_1 = [fingerprint[v] for v in g1.nodes]\n",
- " fingerprint_1.sort()\n",
- " fingerprint_2 = [fingerprint[v] for v in g2.nodes]\n",
- " fingerprint_2.sort()\n",
- " if fingerprint_1 == fingerprint_2:\n",
- " return True, fingerprint_1, fingerprint_2\n",
- " return False, fingerprint_1, fingerprint_2"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 46,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "(True, [3, 4, 5], [3, 4, 5])"
- ]
- },
- "execution_count": 46,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "g1 = pp.Graph.from_edge_list([('a', 'b'), ('b', 'c')])\n",
- "g2 = pp.Graph.from_edge_list([('y', 'z'), ('x', 'y')])\n",
- "WL_test(g1, g2)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 26,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "2"
- ]
- },
- "execution_count": 26,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "d = {'a': 0, 'b': 1, 'c': 0}\n",
- "num_labels(d)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "base",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.10.13"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/docs/tutorial/xx_temporal_centralities.ipynb b/docs/tutorial/xx_temporal_centralities.ipynb
deleted file mode 100644
index 147599da9..000000000
--- a/docs/tutorial/xx_temporal_centralities.ipynb
+++ /dev/null
@@ -1,522 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Running on cpu\n"
- ]
- }
- ],
- "source": [
- "import torch\n",
- "\n",
- "import pathpyG as pp"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Put this as his in conftest as 'simple_paths_centralities'\n",
- "paths = pp.WalkData()\n",
- "paths.add(torch.tensor([[2, 1, 3], [1, 3, 5]])) \n",
- "paths.add(torch.tensor([[0, 1], [1, 3]])) \n",
- "paths.add(torch.tensor([[3], [4]]))\n",
- "\n",
- "simple_paths_centralities = paths"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [],
- "source": [
- "# paths = pp.PathData()\n",
- "# paths.add_walk(torch.tensor([[0,2,3],[2,3,4]]),freq=3) # A -> C -> D\n",
- "# paths.add_walk(torch.tensor([[0,2],[2,3]])) # A -> C -> D\n",
- "# paths.add_walk(torch.tensor([[1,2],[2,4]])) # B -> C -> E\n",
- "# paths.add_walk(torch.tensor([[4],[5]]))\n",
- "# paths.add_walk(torch.tensor([[1,2],[2,4]])) # B -> C -> E\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "(tensor([[[0, 1],\n",
- " [1, 3],\n",
- " [2, 1]],\n",
- " \n",
- " [[1, 3],\n",
- " [3, 5],\n",
- " [1, 3]]]),\n",
- " tensor([1., 1., 1.]))"
- ]
- },
- "execution_count": 5,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "index, edge_weights = paths.edge_index_k_weighted(k=2)\n",
- "index, edge_weights"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {},
- "outputs": [],
- "source": [
- "index, edge_weights = paths.edge_index_k_weighted(k=1)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {},
- "outputs": [],
- "source": [
- "from collections import defaultdict\n",
- "\n",
- "def node_traversals(paths):\n",
- " \"\"\"Calculates the number of times any path traverses each of the nodes.\n",
- "\n",
- " Parameters\n",
- " ----------\n",
- " paths: Paths\n",
- "\n",
- " Returns\n",
- " -------\n",
- " dict\n",
- " \"\"\"\n",
- " traversals = defaultdict(lambda: 0)\n",
- " for path_id, path_edgelist in paths.paths.items():\n",
- " path_seq = paths.walk_to_node_seq(path_edgelist)\n",
- " for node in path_seq:\n",
- " traversals[node.item()] += paths.path_freq[path_id]\n",
- " return traversals"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "metadata": {},
- "outputs": [],
- "source": [
- "from pathpyG.algorithms.centrality import node_traversals"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {},
- "outputs": [
- {
- "ename": "RecursionError",
- "evalue": "maximum recursion depth exceeded while calling a Python object",
- "output_type": "error",
- "traceback": [
- "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[0;31mRecursionError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mnode_traversals\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpaths\u001b[49m\u001b[43m)\u001b[49m\n",
- "File \u001b[0;32m/workspaces/pathpyG/src/pathpyG/algorithms/centrality.py:311\u001b[0m, in \u001b[0;36m__getattr__..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m r\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 311\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mwrapper\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
- "File \u001b[0;32m/workspaces/pathpyG/src/pathpyG/algorithms/centrality.py:311\u001b[0m, in \u001b[0;36m__getattr__..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m r\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 311\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mwrapper\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
- " \u001b[0;31m[... skipping similar frames: __getattr__..wrapper at line 311 (2968 times)]\u001b[0m\n",
- "File \u001b[0;32m/workspaces/pathpyG/src/pathpyG/algorithms/centrality.py:311\u001b[0m, in \u001b[0;36m__getattr__..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m r\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 311\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mwrapper\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
- "File \u001b[0;32m/workspaces/pathpyG/src/pathpyG/algorithms/centrality.py:299\u001b[0m, in \u001b[0;36m__getattr__..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 298\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[0;32m--> 299\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 300\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mDid not find method \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m with no arguments\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 301\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(args[\u001b[38;5;241m0\u001b[39m], TemporalGraph):\n",
- "\u001b[0;31mRecursionError\u001b[0m: maximum recursion depth exceeded while calling a Python object"
- ]
- }
- ],
- "source": [
- "node_traversals(paths)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 13,
- "metadata": {},
- "outputs": [],
- "source": [
- "from pathpyG.algorithms.centrality import visitation_probabilities"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "metadata": {},
- "outputs": [
- {
- "ename": "RecursionError",
- "evalue": "maximum recursion depth exceeded while calling a Python object",
- "output_type": "error",
- "traceback": [
- "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[0;31mRecursionError\u001b[0m Traceback (most recent call last)",
- "Cell \u001b[0;32mIn[14], line 11\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m traversals_dict[\u001b[38;5;241m4\u001b[39m] \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m9\u001b[39m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m traversals_dict[\u001b[38;5;241m5\u001b[39m] \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m9\u001b[39m\n\u001b[0;32m---> 11\u001b[0m \u001b[43mtest_visitation_probabilities\u001b[49m\u001b[43m(\u001b[49m\u001b[43msimple_paths_centralities\u001b[49m\u001b[43m)\u001b[49m\n",
- "Cell \u001b[0;32mIn[14], line 2\u001b[0m, in \u001b[0;36mtest_visitation_probabilities\u001b[0;34m(simple_paths_centralities)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtest_visitation_probabilities\u001b[39m(simple_paths_centralities):\n\u001b[0;32m----> 2\u001b[0m traversals_dict \u001b[38;5;241m=\u001b[39m \u001b[43mvisitation_probabilities\u001b[49m\u001b[43m(\u001b[49m\u001b[43msimple_paths_centralities\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mset\u001b[39m(traversals_dict\u001b[38;5;241m.\u001b[39mkeys()) \u001b[38;5;241m==\u001b[39m {\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m3\u001b[39m,\u001b[38;5;241m4\u001b[39m,\u001b[38;5;241m5\u001b[39m}\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m traversals_dict[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m9\u001b[39m\n",
- "File \u001b[0;32m/workspaces/pathpyG/src/pathpyG/algorithms/centrality.py:311\u001b[0m, in \u001b[0;36m__getattr__..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m r\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 311\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mwrapper\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
- "File \u001b[0;32m/workspaces/pathpyG/src/pathpyG/algorithms/centrality.py:311\u001b[0m, in \u001b[0;36m__getattr__..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m r\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 311\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mwrapper\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
- " \u001b[0;31m[... skipping similar frames: __getattr__..wrapper at line 311 (2967 times)]\u001b[0m\n",
- "File \u001b[0;32m/workspaces/pathpyG/src/pathpyG/algorithms/centrality.py:311\u001b[0m, in \u001b[0;36m__getattr__..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m r\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 311\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mwrapper\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
- "File \u001b[0;32m/workspaces/pathpyG/src/pathpyG/algorithms/centrality.py:299\u001b[0m, in \u001b[0;36m__getattr__..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 298\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[0;32m--> 299\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 300\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mDid not find method \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m with no arguments\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 301\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(args[\u001b[38;5;241m0\u001b[39m], TemporalGraph):\n",
- "\u001b[0;31mRecursionError\u001b[0m: maximum recursion depth exceeded while calling a Python object"
- ]
- }
- ],
- "source": [
- "def test_visitation_probabilities(simple_paths_centralities):\n",
- " traversals_dict = visitation_probabilities(simple_paths_centralities)\n",
- " assert set(traversals_dict.keys()) == {0,1,2,3,4,5}\n",
- " assert traversals_dict[0] == 1/9\n",
- " assert traversals_dict[1] == 2/9\n",
- " assert traversals_dict[2] == 1/9\n",
- " assert traversals_dict[3] == 3/9\n",
- " assert traversals_dict[4] == 1/9\n",
- " assert traversals_dict[5] == 1/9\n",
- "\n",
- "test_visitation_probabilities(simple_paths_centralities)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 339,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "IndexError occurred. Reached maximum path length of 4\n"
- ]
- }
- ],
- "source": [
- "test_shortest_paths(paths)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 340,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "IndexError occurred. Reached maximum path length of 4\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "defaultdict(.()>,\n",
- " {1: 3.0, 3: 2.0, 0: 0, 2: 0, 4: 0, 5: 0})"
- ]
- },
- "execution_count": 340,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "# @betweenness.register(Paths)\n",
- "def betweenness(paths, normalized=False):\n",
- " \"\"\"Calculates the betweenness of nodes based on observed shortest paths\n",
- " between all pairs of nodes\n",
- "\n",
- " Parameters\n",
- " ----------\n",
- " paths:\n",
- " Paths object\n",
- " normalized: bool\n",
- " normalize such that largest value is 1.0\n",
- "\n",
- " Returns\n",
- " -------\n",
- " dict\n",
- " \"\"\"\n",
- " assert isinstance(paths, pp.PathData), \"argument must be an instance of pathpy.Paths\"\n",
- " node_centralities = defaultdict(lambda: 0)\n",
- "\n",
- " # Log.add('Calculating betweenness in paths ...', Severity.INFO)\n",
- "\n",
- " all_paths = shortest_paths(paths)\n",
- "\n",
- " for s in all_paths:\n",
- " for d in all_paths[s]:\n",
- " for p in all_paths[s][d]:\n",
- " for x in p[1:-1]:\n",
- " if s != d != x:\n",
- " node_centralities[x.item()] += 1.0 / len(all_paths[s][d])\n",
- " if normalized:\n",
- " max_centr = max(node_centralities.values())\n",
- " for v in node_centralities:\n",
- " node_centralities[v] /= max_centr\n",
- " # assign zero values to nodes not occurring on shortest paths\n",
- " nodes = [v.item() for v in paths.edge_index.reshape(-1).unique(dim=0)]\n",
- " for v in nodes:\n",
- " node_centralities[v] += 0\n",
- " # Log.add('finished.')\n",
- " return node_centralities\n",
- "\n",
- "betweenness(paths,normalized=False)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 346,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "IndexError occurred. Reached maximum path length of 4\n"
- ]
- }
- ],
- "source": [
- "def test_betweenness_paths(simple_paths_centralities):\n",
- " bw = betweenness(simple_paths_centralities,normalized=False)\n",
- " # 1 is in the shortest path between 0-5,2-3,2-5\n",
- " assert bw[1] == 3.0\n",
- " # 1 is in the shortest path between 2-5,1-5\n",
- " assert bw[3] == 2.0\n",
- "\n",
- "test_betweenness_paths(paths)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 347,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "IndexError occurred. Reached maximum path length of 4\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "defaultdict(.()>,\n",
- " {0: defaultdict(...()>,\n",
- " {0: 0, 1: 1, 3: 2}),\n",
- " 1: defaultdict(...()>,\n",
- " {1: 0, 3: 1, 5: 2}),\n",
- " 2: defaultdict(...()>,\n",
- " {2: 0, 1: 1, 3: 2, 5: 3}),\n",
- " 3: defaultdict(...()>,\n",
- " {3: 0, 4: 1, 5: 1}),\n",
- " 4: defaultdict(...()>,\n",
- " {4: 0}),\n",
- " 5: defaultdict(...()>,\n",
- " {5: 0})})"
- ]
- },
- "execution_count": 347,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "\n",
- "def distance_matrix(paths):\n",
- " \"\"\"\n",
- " Calculates shortest path distances between all pairs of\n",
- " nodes based on the observed shortest paths (and subpaths)\n",
- " \"\"\"\n",
- " dist = defaultdict(lambda: defaultdict(lambda: _np.inf))\n",
- " # Log.add('Calculating distance matrix based on empirical paths ...', Severity.INFO)\n",
- " nodes = [v.item() for v in paths.edge_index.reshape(-1).unique(dim=0)] # NOTE: modify once set of nodes can be obtained from path obeject\n",
- " for v in nodes:\n",
- " dist[v][v] = 0\n",
- "\n",
- " p_length = 1\n",
- " index, edge_weights = paths.edge_index_k_weighted(k=p_length)\n",
- " sources = index[0]\n",
- " destinations = index[-1]\n",
- " for e, (s, d) in enumerate(zip(sources, destinations)):\n",
- " s = s.item()\n",
- " d = d.item()\n",
- " dist[s][d] = p_length\n",
- " # s_p[s][d] = set({torch.tensor([s,d])})\n",
- " p_length += 1\n",
- " while True: # until max path length\n",
- " try:\n",
- " index, edge_weights = paths.edge_index_k_weighted(k=p_length)\n",
- " sources = index[0, :, 0]\n",
- " destinations = index[1, :, -1]\n",
- " for e, (s, d) in enumerate(zip(sources, destinations)):\n",
- " s = s.item()\n",
- " d = d.item()\n",
- " if p_length < dist[s][d]:\n",
- " # update shortest path length\n",
- " dist[s][d] = p_length\n",
- " p_length += 1\n",
- " except IndexError:\n",
- " print(f\"IndexError occurred. Reached maximum path length of {p_length}\")\n",
- " break\n",
- " return dist\n",
- "distance_matrix(paths)\n",
- " "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 352,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "IndexError occurred. Reached maximum path length of 4\n"
- ]
- }
- ],
- "source": [
- "def test_distance_matrix_paths(simple_paths_centralities):\n",
- " dm = distance_matrix(simple_paths_centralities)\n",
- " assert dm[0] == {0: 0, 1: 1, 3: 2}\n",
- " assert dm[1] == {1: 0, 3: 1, 5: 2}\n",
- " assert dm[2] == {2: 0, 1: 1, 3: 2, 5: 3}\n",
- " assert dm[3] == {3: 0, 4: 1, 5: 1}\n",
- " assert dm[4] == {4: 0}\n",
- " assert dm[5] == {5: 0}\n",
- "\n",
- "test_distance_matrix_paths(paths)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 355,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "IndexError occurred. Reached maximum path length of 4\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "defaultdict(.()>,\n",
- " {1: 2.0, 3: 2.0, 4: 1.0, 5: 1.8333333333333333, 0: 0.0, 2: 0.0})"
- ]
- },
- "execution_count": 355,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "def closeness(paths, normalized=False):\n",
- " \"\"\"Calculates the closeness of nodes based on observed shortest paths\n",
- " between all nodes\n",
- "\n",
- " Parameters\n",
- " ----------\n",
- " paths: Paths\n",
- " normalized: bool\n",
- " normalize such that largest value is 1.0\n",
- "\n",
- " Returns\n",
- " -------\n",
- " dict\n",
- " \"\"\"\n",
- " node_centralities = defaultdict(lambda: 0)\n",
- " distances = distance_matrix(paths)\n",
- " nodes = [v.item() for v in paths.edge_index.reshape(-1).unique(dim=0)] # NOTE: modify once set of nodes can be obtained from path obeject\n",
- "\n",
- " for x in nodes:\n",
- " # calculate closeness centrality of x\n",
- " for d in nodes:\n",
- " if x != d and distances[d][x] < _np.inf:\n",
- " node_centralities[x] += 1.0 / distances[d][x]\n",
- "\n",
- " # assign zero values to nodes not occurring\n",
- " \n",
- " for v in nodes:\n",
- " node_centralities[v] += 0.0\n",
- "\n",
- " if normalized:\n",
- " m = max(node_centralities.values())\n",
- " for v in nodes:\n",
- " node_centralities[v] /= m\n",
- "\n",
- " return node_centralities\n",
- "closeness(paths, normalized=False)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 360,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "IndexError occurred. Reached maximum path length of 4\n"
- ]
- }
- ],
- "source": [
- "def test_closeness_paths(simple_paths_centralities):\n",
- " c = closeness(simple_paths_centralities, normalized=False)\n",
- " assert c[0] == 0.0\n",
- " # 1 reachable from 0 and 2 in one step\n",
- " assert c[1] == 1/1 + 1/1\n",
- " assert c[2] == 0\n",
- " # 3 reachable from 1 in one step, from 0 and 3 in two steps\n",
- " assert c[3] == 1 + 1/2 + 1/2\n",
- " assert c[4] == 1\n",
- " # 5 reachable from 3 in one step, from 1 in two steps, from 2 in three steps\n",
- " assert c[5] == 1 + 1/2 + 1/3\n",
- "test_closeness_paths(paths)"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "base",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.10.13"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/docs/tutorial/xx_test_random_walks.ipynb b/docs/tutorial/xx_test_random_walks.ipynb
deleted file mode 100644
index 2f0900d04..000000000
--- a/docs/tutorial/xx_test_random_walks.ipynb
+++ /dev/null
@@ -1,2423 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Running on cpu\n"
- ]
- }
- ],
- "source": [
- "import pathpyG as pp\n",
- "import torch\n",
- "from pathpyG.processes.random_walk import RandomWalk, HigherOrderRandomWalk\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Undirected graph with 34 nodes and 154 (directed) edges\n",
- "\n",
- "Node attributes\n",
- "\tnode__pos\t\t\n",
- "\tnode_name\t\t\n",
- "\tnode_groups\t\t\n",
- "\n",
- "Graph attributes\n",
- "\turl\t\t\n",
- "\tcitation\t\t\n",
- "\tdescription\t\t\n",
- "\tname\t\t\n",
- "\ttags\t\t\n",
- "\tnum_nodes\t\t\n",
- "\n"
- ]
- }
- ],
- "source": [
- "g = pp.io.read_netzschleuder_network('karate', '77')\n",
- "print(g)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [],
- "source": [
- "rw = RandomWalk(g)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "100%|██████████| 34/34 [00:00<00:00, 347.70it/s]\n"
- ]
- }
- ],
- "source": [
- "data = rw.run_experiment(steps=100,runs=range(34))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " run_id | \n",
- " seed | \n",
- " time | \n",
- " node | \n",
- " state | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " | 0 | \n",
- " 0 | \n",
- " 0 | \n",
- " 0 | \n",
- " 0 | \n",
- " True | \n",
- "
\n",
- " \n",
- " | 1 | \n",
- " 0 | \n",
- " 0 | \n",
- " 0 | \n",
- " 1 | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 2 | \n",
- " 0 | \n",
- " 0 | \n",
- " 0 | \n",
- " 2 | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 3 | \n",
- " 0 | \n",
- " 0 | \n",
- " 0 | \n",
- " 3 | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 4 | \n",
- " 0 | \n",
- " 0 | \n",
- " 0 | \n",
- " 4 | \n",
- " False | \n",
- "
\n",
- " \n",
- " | ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- "
\n",
- " \n",
- " | 7951 | \n",
- " 33 | \n",
- " 33 | \n",
- " 98 | \n",
- " 1 | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 7952 | \n",
- " 33 | \n",
- " 33 | \n",
- " 99 | \n",
- " 0 | \n",
- " True | \n",
- "
\n",
- " \n",
- " | 7953 | \n",
- " 33 | \n",
- " 33 | \n",
- " 99 | \n",
- " 21 | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 7954 | \n",
- " 33 | \n",
- " 33 | \n",
- " 100 | \n",
- " 3 | \n",
- " True | \n",
- "
\n",
- " \n",
- " | 7955 | \n",
- " 33 | \n",
- " 33 | \n",
- " 100 | \n",
- " 0 | \n",
- " False | \n",
- "
\n",
- " \n",
- "
\n",
- "
7956 rows × 5 columns
\n",
- "
\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " run_id | \n",
- " seed | \n",
- " time | \n",
- " node | \n",
- " state | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " | 0 | \n",
- " 0 | \n",
- " a | \n",
- " 0 | \n",
- " a | \n",
- " True | \n",
- "
\n",
- " \n",
- " | 1 | \n",
- " 0 | \n",
- " a | \n",
- " 0 | \n",
- " b | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 2 | \n",
- " 0 | \n",
- " a | \n",
- " 0 | \n",
- " c | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 3 | \n",
- " 0 | \n",
- " a | \n",
- " 0 | \n",
- " d | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 4 | \n",
- " 0 | \n",
- " a | \n",
- " 0 | \n",
- " e | \n",
- " False | \n",
- "
\n",
- " \n",
- " | ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- "
\n",
- " \n",
- " | 105 | \n",
- " 1 | \n",
- " b | \n",
- " 18 | \n",
- " d | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 106 | \n",
- " 1 | \n",
- " b | \n",
- " 19 | \n",
- " f | \n",
- " True | \n",
- "
\n",
- " \n",
- " | 107 | \n",
- " 1 | \n",
- " b | \n",
- " 19 | \n",
- " e | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 108 | \n",
- " 1 | \n",
- " b | \n",
- " 20 | \n",
- " g | \n",
- " True | \n",
- "
\n",
- " \n",
- " | 109 | \n",
- " 1 | \n",
- " b | \n",
- " 20 | \n",
- " f | \n",
- " False | \n",
- "
\n",
- " \n",
- "
\n",
- "
110 rows × 5 columns
\n",
- "
\n",
- "\n",
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "pp.plot(g2);"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 18,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "{0: 'a',\n",
- " 1: 'b',\n",
- " 2: 'c',\n",
- " 3: 'd',\n",
- " 4: 'e',\n",
- " 5: 'f',\n",
- " 6: 'g',\n",
- " 7: 'h',\n",
- " 8: 'i',\n",
- " 9: 'j',\n",
- " 10: 'k',\n",
- " 11: 'l',\n",
- " 12: 'm',\n",
- " 13: 'n',\n",
- " 14: 'o'}"
- ]
- },
- "execution_count": 18,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "g2.mapping.idx_to_id"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 19,
- "metadata": {},
- "outputs": [],
- "source": [
- "g2_ho = pp.HigherOrderGraph(paths2, order = 2)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 20,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- "\n",
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "pp.plot(g2_ho,node_label=[g2_ho.mapping.to_id(x) for x in range(g2_ho.n)]);"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Higher Order Random Walk"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "metadata": {},
- "outputs": [],
- "source": [
- "g3 = pp.Graph.from_edge_list([\n",
- " ['a','b'],\n",
- " ['b','c'],\n",
- " ['c','a'],\n",
- " ['c','d'],\n",
- " ['d','a']\n",
- " ])\n",
- "\n",
- "g3.data['edge_weight'] = torch.tensor([[1],[1],[2],[1],[1]])"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 15,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- "\n",
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "pp.plot(g3, node_label= [g3.mapping.to_id(x) for x in range(g3.n)]);"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 23,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "{'a': 0, 'b': 1, 'c': 2, 'd': 3}"
- ]
- },
- "execution_count": 23,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "g3.mapping.id_to_idx"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 18,
- "metadata": {},
- "outputs": [],
- "source": [
- "paths = pp.DAGData(g3.mapping)\n",
- "paths.append_walk(['a','b','c'],weight=1)\n",
- "paths.append_walk(['b','c','a'],weight=1)\n",
- "paths.append_walk(['b','c','d'],weight=0.2)\n",
- "paths.append_walk(['c','a','b'],weight=1)\n",
- "paths.append_walk(['c','d','a'],weight=0.2)\n",
- "paths.append_walk(['d','a','b'],weight=1)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 19,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "[Data(edge_index=[2, 2], node_sequences=[3, 1], num_nodes=3, weight=1),\n",
- " Data(edge_index=[2, 2], node_sequences=[3, 1], num_nodes=3, weight=1),\n",
- " Data(edge_index=[2, 2], node_sequences=[3, 1], num_nodes=3, weight=0.20000000298023224),\n",
- " Data(edge_index=[2, 2], node_sequences=[3, 1], num_nodes=3, weight=1),\n",
- " Data(edge_index=[2, 2], node_sequences=[3, 1], num_nodes=3, weight=0.20000000298023224),\n",
- " Data(edge_index=[2, 2], node_sequences=[3, 1], num_nodes=3, weight=1)]"
- ]
- },
- "execution_count": 19,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "paths.dags"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 20,
- "metadata": {},
- "outputs": [],
- "source": [
- "m = pp.MultiOrderModel.from_DAGs(paths, max_order=3)\n",
- "g3_ho = m.layers[2]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 22,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- "\n",
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "pp.plot(g3_ho, node_label = [g3_ho.mapping.to_id(x) for x in range(g3_ho.n)]);"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 23,
- "metadata": {},
- "outputs": [],
- "source": [
- "rw = HigherOrderRandomWalk(g3_ho, g3, weight=True)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 24,
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "100%|██████████| 5/5 [00:00<00:00, 511.38it/s]\n"
- ]
- }
- ],
- "source": [
- "data = rw.run_experiment(steps=100, runs=list(g3_ho.nodes))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 25,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " run_id | \n",
- " seed | \n",
- " time | \n",
- " node | \n",
- " state | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " | 0 | \n",
- " 0 | \n",
- " (a, b) | \n",
- " 0 | \n",
- " (a, b) | \n",
- " True | \n",
- "
\n",
- " \n",
- " | 1 | \n",
- " 0 | \n",
- " (a, b) | \n",
- " 0 | \n",
- " (b, c) | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 2 | \n",
- " 0 | \n",
- " (a, b) | \n",
- " 0 | \n",
- " (c, a) | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 3 | \n",
- " 0 | \n",
- " (a, b) | \n",
- " 0 | \n",
- " (c, d) | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 4 | \n",
- " 0 | \n",
- " (a, b) | \n",
- " 0 | \n",
- " (d, a) | \n",
- " False | \n",
- "
\n",
- " \n",
- " | ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- "
\n",
- " \n",
- " | 1020 | \n",
- " 4 | \n",
- " (d, a) | \n",
- " 98 | \n",
- " (b, c) | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 1021 | \n",
- " 4 | \n",
- " (d, a) | \n",
- " 99 | \n",
- " (d, a) | \n",
- " True | \n",
- "
\n",
- " \n",
- " | 1022 | \n",
- " 4 | \n",
- " (d, a) | \n",
- " 99 | \n",
- " (c, d) | \n",
- " False | \n",
- "
\n",
- " \n",
- " | 1023 | \n",
- " 4 | \n",
- " (d, a) | \n",
- " 100 | \n",
- " (a, b) | \n",
- " True | \n",
- "
\n",
- " \n",
- " | 1024 | \n",
- " 4 | \n",
- " (d, a) | \n",
- " 100 | \n",
- " (d, a) | \n",
- " False | \n",
- "
\n",
- " \n",
- "
\n",
- "
1025 rows × 5 columns
\n",
- "