From a40738a152cf30d60f680376df88fcf29a45b560 Mon Sep 17 00:00:00 2001 From: Louie Date: Tue, 17 Dec 2024 14:12:11 +0100 Subject: [PATCH] Initial non-functionion graphinh attempt --- .../notebooks/Latent_var_notebook.ipynb | 627 ++++++++++++------ 1 file changed, 410 insertions(+), 217 deletions(-) diff --git a/docs/source/notebooks/Latent_var_notebook.ipynb b/docs/source/notebooks/Latent_var_notebook.ipynb index 67f0101c4..b2a3ce762 100644 --- a/docs/source/notebooks/Latent_var_notebook.ipynb +++ b/docs/source/notebooks/Latent_var_notebook.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -31,7 +31,95 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Dict, Tuple\n", + "\n", + "from pyhgf.typing import AdjacencyLists, Edges\n", + "from pyhgf.utils import add_edges\n", + "\n", + "\n", + "def add_parent(\n", + " attributes: Dict, edges: Edges, index: int, coupling_type: str, mean: float\n", + ") -> Tuple[Dict, Edges]:\n", + " r\"\"\"Add a new continuous-state parent node to the attributes and edges of an\n", + " existing network.\n", + "\n", + " Parameters\n", + " ----------\n", + " attributes :\n", + " The attributes of the existing network.\n", + " edges :\n", + " The edges of the existing network.\n", + " index :\n", + " The index of the node you want to connect a new parent node to.\n", + " coupling_type :\n", + " The type of coupling you want between the existing node and it's new parent.\n", + " Can be either \"value\" or \"volatility\".\n", + " mean :\n", + " The mean value of the new parent node.\n", + "\n", + " Returns\n", + " -------\n", + " attributes :\n", + " The updated attributes of the existing network.\n", + " edges :\n", + " The updated edges of the existing network.\n", + "\n", + " \"\"\"\n", + " # Get index for node to be added\n", + " new_node_idx = len(edges)\n", + "\n", + " # Add new node to attributes\n", + " attributes[new_node_idx] = {\n", + " \"mean\": mean,\n", + " \"expected_mean\": mean,\n", + " \"precision\": 1.0,\n", + " \"expected_precision\": 1.0,\n", + " \"volatility_coupling_children\": None,\n", + " \"volatility_coupling_parents\": None,\n", + " \"value_coupling_children\": None,\n", + " \"value_coupling_parents\": None,\n", + " \"tonic_volatility\": -4.0,\n", + " \"tonic_drift\": 0.0,\n", + " \"autoconnection_strength\": 1.0,\n", + " \"observed\": 1,\n", + " \"temp\": {\n", + " \"effective_precision\": 0.0,\n", + " \"value_prediction_error\": 0.0,\n", + " \"volatility_prediction_error\": 0.0,\n", + " },\n", + " }\n", + "\n", + " # Add new AdjacencyList with empty values, to Edges tuple\n", + " new_adj_list = AdjacencyLists(\n", + " node_type=2,\n", + " value_parents=None,\n", + " volatility_parents=None,\n", + " value_children=None,\n", + " volatility_children=None,\n", + " coupling_fn=(None,),\n", + " )\n", + " edges = edges + (new_adj_list,)\n", + "\n", + " # Use add_edges to integrate the altered attributes and edges\n", + " attributes, edges = add_edges(\n", + " attributes=attributes,\n", + " edges=edges,\n", + " kind=coupling_type,\n", + " parent_idxs=new_node_idx,\n", + " children_idxs=index,\n", + " )\n", + "\n", + " # Return new attributes and edges\n", + " return attributes, edges\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -41,12 +129,16 @@ "import pymc as pm\n", "import numpy as np\n", "import jax\n", + "import pandas as pd\n", + "import networkx as nx\n", "\n", "from pyhgf import load_data\n", "from pyhgf.distribution import HGFDistribution\n", "from pyhgf.model import HGF, Network\n", "from pyhgf.response import first_level_gaussian_surprise\n", "from pyhgf.utils import beliefs_propagation\n", + "from pyhgf.math import gaussian_surprise\n", + "from copy import deepcopy\n", "# from pyhgf.updates.structure import add_parent\n", "\n", "\n", @@ -55,7 +147,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -65,45 +157,49 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: 'c:\\\\Users\\\\hesse\\\\miniconda3\\\\envs\\\\pymc_env\\\\Lib\\\\site-packages\\\\pyhgf\\\\data\\\\usdchf.txt'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[47], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m timeserie \u001b[38;5;241m=\u001b[39m \u001b[43mload_data\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcontinuous\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;66;03m# latent_hgf = (\u001b[39;00m\n\u001b[0;32m 4\u001b[0m \u001b[38;5;66;03m# Network()\u001b[39;00m\n\u001b[0;32m 5\u001b[0m \u001b[38;5;66;03m# .add_nodes(precision=1e4)\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 11\u001b[0m \u001b[38;5;66;03m# # .add_nodes(precision=1e1, tonic_volatility=-2.0, volatility_children=2)\u001b[39;00m\n\u001b[0;32m 12\u001b[0m \u001b[38;5;66;03m# ).create_belief_propagation_fn()\u001b[39;00m\n\u001b[0;32m 14\u001b[0m latent_hgf \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m 15\u001b[0m Network()\n\u001b[0;32m 16\u001b[0m \u001b[38;5;241m.\u001b[39madd_nodes(precision\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1e4\u001b[39m)\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 22\u001b[0m \u001b[38;5;66;03m# .add_nodes(precision=1e1, tonic_volatility=-2.0, volatility_children=2)\u001b[39;00m\n\u001b[0;32m 23\u001b[0m )\u001b[38;5;241m.\u001b[39mcreate_belief_propagation_fn()\n", - "File \u001b[1;32mc:\\Users\\hesse\\miniconda3\\envs\\pymc_env\\Lib\\site-packages\\pyhgf\\__init__.py:46\u001b[0m, in \u001b[0;36mload_data\u001b[1;34m(dataset)\u001b[0m\n", - "File \u001b[1;32mc:\\Users\\hesse\\miniconda3\\envs\\pymc_env\\Lib\\pkgutil.py:453\u001b[0m, in \u001b[0;36mget_data\u001b[1;34m(package, resource)\u001b[0m\n\u001b[0;32m 451\u001b[0m parts\u001b[38;5;241m.\u001b[39minsert(\u001b[38;5;241m0\u001b[39m, os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mdirname(mod\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__file__\u001b[39m))\n\u001b[0;32m 452\u001b[0m resource_name \u001b[38;5;241m=\u001b[39m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(\u001b[38;5;241m*\u001b[39mparts)\n\u001b[1;32m--> 453\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mloader\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43mresource_name\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32m:1186\u001b[0m, in \u001b[0;36mget_data\u001b[1;34m(self, path)\u001b[0m\n", - "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'c:\\\\Users\\\\hesse\\\\miniconda3\\\\envs\\\\pymc_env\\\\Lib\\\\site-packages\\\\pyhgf\\\\data\\\\usdchf.txt'" - ] - } - ], + "outputs": [], "source": [ - "timeserie = load_data(\"continuous\")\n", + "# from pyhgf.updates.structure import add_parent\n", "\n", - "latent_hgf = (\n", - " Network()\n", - " .add_nodes(precision=1e4)\n", - " .add_nodes(precision=1e4, mean=timeserie[0], tonic_volatility=-13.0, \n", - " value_children=0)\n", - " .add_nodes(precision=1e1, tonic_volatility=-2.0, value_children=1)\n", - " .add_nodes(precision=1e4, mean=timeserie[0], tonic_volatility=-13.0, \n", - " value_children=0)\n", - " # .add_nodes(precision=1e1, tonic_volatility=-2.0, volatility_children=1)\n", - " # .add_nodes(precision=1e4, mean=timeserie[0], tonic_volatility=-13.0, \n", - " # value_children=2)\n", - " # .add_nodes(precision=1e1, tonic_volatility=-2.0, volatility_children=2)\n", - ").create_belief_propagation_fn()" + "def update_structure(\n", + " attributes: Dict, edges: Edges, index: int\n", + ") -> Tuple[Dict, Edges]:\n", + " #Calculate gaussian-surprise\n", + " if index >= 0:\n", + " node_ex_m = (attributes[index]['expected_mean'])\n", + " node_ex_p = (attributes[index]['expected_precision'])\n", + " node_m = (attributes[index]['mean'])\n", + " surprise = gaussian_surprise(x=node_m, \n", + " expected_mean=node_ex_m, \n", + " expected_precision=node_ex_p)\n", + " else:\n", + " return attributes, edges\n", + "\n", + " #Define threshold, and compare against calculated surprise \n", + " # (may need internal storage for accumulated storage)\n", + " if surprise > 800:\n", + " threshold_reached = True\n", + " else:\n", + " threshold_reached = False\n", + " \n", + " #Return attributes and edges\n", + " if threshold_reached is False:\n", + " return attributes, edges\n", + " elif threshold_reached is True:\n", + " print('new node added')\n", + " return add_parent(attributes = attributes, \n", + " edges = edges, \n", + " index = index, \n", + " coupling_type = 'volatility', #Add condition to vary\n", + " mean = 1.0\n", + " )" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -141,100 +237,181 @@ "\n", "\n", "x_2\n", - "\n", - "2\n", + "\n", + "2\n", "\n", - "\n", + "\n", "\n", - "x_2->x_1\n", - "\n", - "\n", + "x_2->x_0\n", + "\n", + "\n", "\n", "\n", "\n", "x_3\n", - "\n", - "3\n", + "\n", + "3\n", "\n", - "\n", + "\n", "\n", - "x_3->x_0\n", - "\n", - "\n", + "x_3->x_2\n", + "\n", + "\n", "\n", "\n", "\n", "x_4\n", - "\n", - "4\n", + "\n", + "4\n", "\n", - "\n", + "\n", "\n", - "x_4->x_3\n", - "\n", - "\n", + "x_4->x_1\n", + "\n", + "\n", "\n", "\n", "\n" ], "text/plain": [ - "" + "" ] }, - "execution_count": 48, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "latent_hgf.plot_network()" + "timeserie = load_data(\"continuous\")\n", + "\n", + "test_hgf = (\n", + " Network()\n", + " .add_nodes(precision=1e4)\n", + " .add_nodes(precision=1e4, mean=timeserie[0], tonic_volatility=-13.0, \n", + " value_children=0)\n", + " .add_nodes(precision=1e1, tonic_volatility=-14.0, volatility_children=0)\n", + " .add_nodes(precision=1e4, mean=timeserie[0], tonic_volatility=-13.0, \n", + " value_children=2)\n", + " .add_nodes(precision=1e1, tonic_volatility=-2.0, volatility_children=1)\n", + " # .add_nodes(precision=1e4, mean=timeserie[0], tonic_volatility=-13.0, \n", + " # value_children=2)\n", + " # .add_nodes(precision=1e1, tonic_volatility=-2.0, volatility_children=2)\n", + ").create_belief_propagation_fn()\n", + "\n", + "attributes, edges, update_sequence = (\n", + " test_hgf.get_network()\n", + ")\n", + "\n", + "# np.random.seed(123)\n", + "# dist_mean, dist_std = 5, 1\n", + "# input_data = np.random.normal(loc=dist_mean, scale=dist_std, size=10000)\n", + "\n", + "aarhus_weather_df = pd.read_csv(\n", + " \"https://raw.githubusercontent.com/ilabcode/hgf-data/main/datasets/weather.csv\"\n", + ")\n", + "aarhus_weather_df.head()\n", + "weather_data = aarhus_weather_df[\"t2m\"][: 24 * 30].to_numpy()\n", + "\n", + "test_hgf.plot_network()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(AdjacencyLists(node_type=2, value_parents=(1,), volatility_parents=(2,), value_children=None, volatility_children=None, coupling_fn=()),\n", + " AdjacencyLists(node_type=2, value_parents=None, volatility_parents=(4,), value_children=(0,), volatility_children=None, coupling_fn=(None,)),\n", + " AdjacencyLists(node_type=2, value_parents=(3,), volatility_parents=None, value_children=None, volatility_children=(0,), coupling_fn=()),\n", + " AdjacencyLists(node_type=2, value_parents=None, volatility_parents=None, value_children=(2,), volatility_children=None, coupling_fn=(None,)),\n", + " AdjacencyLists(node_type=2, value_parents=None, volatility_parents=None, value_children=None, volatility_children=(1,), coupling_fn=()))" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "attributes, edges, update_sequence = (\n", - " latent_hgf.get_network()\n", - ")\n", - "\n", - "new_hgf_attributes, new_hgf_edges = add_parent(attributes, edges, 3, 'volatility')" + "edges" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "7\n", - "6\n" + "new node added\n", + "new node added\n" ] } ], "source": [ - "print(len(new_hgf_attributes))\n", - "print(len(new_hgf_edges))" + "# for each observation\n", + "for value in weather_data:\n", + "\n", + " # interleave observations and masks\n", + " data = (value, 1.0, 1.0)\n", + "\n", + " # update the probabilistic network\n", + " attributes, _ = beliefs_propagation(\n", + " attributes=attributes,\n", + " inputs=data,\n", + " update_sequence=update_sequence,\n", + " edges=edges,\n", + " input_idxs=test_hgf.input_idxs\n", + " )\n", + "\n", + " #Calculate gaussian surprise\n", + " index_vec = []\n", + " nr = 0\n", + " for node in edges:\n", + " index_vec.append(nr)\n", + " nr = nr+1\n", + "\n", + "\n", + " for idx in index_vec:\n", + " attributes, edges = update_structure(attributes = attributes, edges = edges, index = idx)\n", + " \n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(AdjacencyLists(node_type=2, value_parents=(1,), volatility_parents=(2, 5, 6), value_children=None, volatility_children=None, coupling_fn=()),\n", + " AdjacencyLists(node_type=2, value_parents=None, volatility_parents=(4,), value_children=(0,), volatility_children=None, coupling_fn=(None,)),\n", + " AdjacencyLists(node_type=2, value_parents=(3,), volatility_parents=None, value_children=None, volatility_children=(0,), coupling_fn=()),\n", + " AdjacencyLists(node_type=2, value_parents=None, volatility_parents=None, value_children=(2,), volatility_children=None, coupling_fn=(None,)),\n", + " AdjacencyLists(node_type=2, value_parents=None, volatility_parents=None, value_children=None, volatility_children=(1,), coupling_fn=()),\n", + " AdjacencyLists(node_type=2, value_parents=None, volatility_parents=None, value_children=None, volatility_children=(0,), coupling_fn=(None,)),\n", + " AdjacencyLists(node_type=2, value_parents=None, volatility_parents=None, value_children=None, volatility_children=(0,), coupling_fn=(None,)))" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "latent_hgf.attributes = new_hgf_attributes\n", - "latent_hgf.edges = new_hgf_edges" + "edges" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -246,16 +423,16 @@ "\n", "\n", - "\n", + "\n", "\n", "hgf-nodes\n", - "\n", + "\n", "\n", "\n", "x_0\n", - "\n", - "0\n", + "\n", + "0\n", "\n", "\n", "\n", @@ -266,205 +443,221 @@ "\n", "\n", "x_1->x_0\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", "\n", "x_2\n", - "\n", - "2\n", + "\n", + "2\n", "\n", - "\n", + "\n", "\n", - "x_2->x_1\n", - "\n", - "\n", + "x_2->x_0\n", + "\n", + "\n", "\n", "\n", "\n", "x_3\n", - "\n", - "3\n", + "\n", + "3\n", "\n", - "\n", + "\n", "\n", - "x_3->x_0\n", - "\n", - "\n", + "x_3->x_2\n", + "\n", + "\n", "\n", "\n", "\n", "x_4\n", - "\n", - "4\n", + "\n", + "4\n", "\n", - "\n", + "\n", "\n", - "x_4->x_3\n", - "\n", - "\n", + "x_4->x_1\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "x_5\n", + "\n", + "5\n", + "\n", + "\n", + "\n", + "x_5->x_0\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "x_6\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "x_6->x_0\n", + "\n", + "\n", "\n", "\n", "\n" ], "text/plain": [ - "" + "" ] }, - "execution_count": 36, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "latent_hgf.plot_network()" + "test_hgf.attributes = attributes\n", + "test_hgf.edges = edges\n", + "\n", + "test_hgf.plot_network()" ] }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "np.random.seed(123)\n", - "dist_mean, dist_std = 5, 1\n", - "input_data = np.random.normal(loc=dist_mean, scale=dist_std, size=1000)" + "def create_hgf_visualization(input_data, attributes_history, edges_history, plot_interval=200):\n", + " \"\"\"\n", + " Create a comprehensive visualization of HGF network and time series\n", + " \n", + " Parameters:\n", + " - input_data: Original input time series\n", + " - attributes_history: List of attributes at each plot interval\n", + " - edges_history: List of edges at each plot interval\n", + " - plot_interval: Number of trials between network snapshots\n", + " \"\"\"\n", + " # Calculate number of subplots\n", + " num_plots = len(attributes_history)\n", + " \n", + " # Create a figure with a grid layout\n", + " # We'll have 3 columns: time series, network, and a placeholder\n", + " fig = plt.figure(figsize=(20, 5 * num_plots))\n", + " grid = fig.add_gridspec(num_plots, 3, width_ratios=[2, 1, 0])\n", + " \n", + " # Plot time series\n", + " for i in range(num_plots):\n", + " ax_series = fig.add_subplot(grid[i, 0])\n", + " \n", + " # Plot input data up to this point\n", + " end_idx = (i + 1) * plot_interval\n", + " ax_series.plot(input_data[:end_idx], label='Input Data')\n", + " ax_series.set_title(f'Time Series at Trial {end_idx}')\n", + " ax_series.set_xlabel('Trial Number')\n", + " ax_series.set_ylabel('Input Value')\n", + " ax_series.legend()\n", + " \n", + " # Plot network structures\n", + " for i in range(num_plots):\n", + " ax_network = fig.add_subplot(grid[i, 1])\n", + " \n", + " # Create a graph from the current network structure\n", + " G = nx.DiGraph()\n", + " \n", + " # Get current attributes and edges\n", + " current_attributes = attributes_history[i]\n", + " current_edges = edges_history[i]\n", + " \n", + " # Add nodes with their current values\n", + " for j, attr in enumerate(current_attributes):\n", + " G.add_node(j, value=attr)\n", + " \n", + " # Add edges\n", + " for edge in current_edges:\n", + " G.add_edge(edge[0], edge[1])\n", + " \n", + " # Draw the network\n", + " pos = nx.spring_layout(G)\n", + " nx.draw(G, pos, with_labels=True, node_color='lightblue', \n", + " node_size=500, ax=ax_network)\n", + " \n", + " # Annotate node values\n", + " node_labels = {node: f'{node}: {attr:.2f}' \n", + " for node, attr in enumerate(current_attributes)}\n", + " nx.draw_networkx_labels(G, pos, labels=node_labels, ax=ax_network)\n", + " \n", + " ax_network.set_title(f'Network Structure at Trial {(i+1)*plot_interval}')\n", + " \n", + " plt.tight_layout()\n", + " return fig" ] }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "# for each observation\n", - "for value in input_data:\n", - "\n", - " # interleave observations and masks\n", - " data = (value, 1.0, 1.0)\n", + "attributes_hist = []\n", + "edges_hist = []\n", "\n", - " # update the probabilistic network\n", - " attributes, _ = beliefs_propagation(\n", - " attributes=attributes,\n", - " inputs=data,\n", - " update_sequence=update_sequence,\n", - " edges=edges,\n", - " input_idxs=latent_hgf.input_idxs\n", - " )\n" + "attributes_hist.append(attributes)\n", + "edges_hist.append(edges)" ] }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 16, "metadata": {}, "outputs": [ + { + "ename": "ValueError", + "evalue": "None cannot be a node", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[16], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mcreate_hgf_visualization\u001b[49m\u001b[43m(\u001b[49m\u001b[43mweather_data\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattributes_hist\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43medges_hist\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[1;32mIn[13], line 48\u001b[0m, in \u001b[0;36mcreate_hgf_visualization\u001b[1;34m(input_data, attributes_history, edges_history, plot_interval)\u001b[0m\n\u001b[0;32m 46\u001b[0m \u001b[38;5;66;03m# Add edges\u001b[39;00m\n\u001b[0;32m 47\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m edge \u001b[38;5;129;01min\u001b[39;00m current_edges:\n\u001b[1;32m---> 48\u001b[0m \u001b[43mG\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madd_edge\u001b[49m\u001b[43m(\u001b[49m\u001b[43medge\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43medge\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 50\u001b[0m \u001b[38;5;66;03m# Draw the network\u001b[39;00m\n\u001b[0;32m 51\u001b[0m pos \u001b[38;5;241m=\u001b[39m nx\u001b[38;5;241m.\u001b[39mspring_layout(G)\n", + "File \u001b[1;32mc:\\Users\\hesse\\miniconda3\\envs\\pymc_env\\Lib\\site-packages\\networkx\\classes\\digraph.py:726\u001b[0m, in \u001b[0;36mDiGraph.add_edge\u001b[1;34m(self, u_of_edge, v_of_edge, **attr)\u001b[0m\n\u001b[0;32m 724\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m v \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_succ:\n\u001b[0;32m 725\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m v \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m--> 726\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNone cannot be a node\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 727\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_succ[v] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39madjlist_inner_dict_factory()\n\u001b[0;32m 728\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pred[v] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39madjlist_inner_dict_factory()\n", + "\u001b[1;31mValueError\u001b[0m: None cannot be a node" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\hesse\\AppData\\Roaming\\Python\\Python312\\site-packages\\IPython\\core\\events.py:93: UserWarning: constrained_layout not applied because axes sizes collapsed to zero. Try making figure larger or Axes decorations smaller.\n", + " func(*args, **kwargs)\n", + "C:\\Users\\hesse\\AppData\\Roaming\\Python\\Python312\\site-packages\\IPython\\core\\pylabtools.py:152: UserWarning: constrained_layout not applied because axes sizes collapsed to zero. Try making figure larger or Axes decorations smaller.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, { "data": { + "image/png": "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", "text/plain": [ - "{-1: {'time_step': Array(1., dtype=float32, weak_type=True)},\n", - " 0: {'autoconnection_strength': Array(0., dtype=float32, weak_type=True),\n", - " 'expected_mean': Array(5.1438637, dtype=float32),\n", - " 'expected_precision': Array(10000., dtype=float32, weak_type=True),\n", - " 'mean': Array(3.8885696, dtype=float32),\n", - " 'observed': Array(1., dtype=float32, weak_type=True),\n", - " 'precision': Array(10000., dtype=float32, weak_type=True),\n", - " 'temp': {'effective_precision': Array(0.9999, dtype=float32, weak_type=True),\n", - " 'value_prediction_error': Array(-0.62764704, dtype=float32),\n", - " 'volatility_prediction_error': Array(3939.408, dtype=float32)},\n", - " 'tonic_drift': Array(0., dtype=float32, weak_type=True),\n", - " 'tonic_volatility': Array(0., dtype=float32, weak_type=True),\n", - " 'value_coupling_children': None,\n", - " 'value_coupling_parents': (Array(1., dtype=float32, weak_type=True),\n", - " Array(1., dtype=float32, weak_type=True)),\n", - " 'volatility_coupling_children': None,\n", - " 'volatility_coupling_parents': None},\n", - " 1: {'autoconnection_strength': Array(1., dtype=float32, weak_type=True),\n", - " 'expected_mean': Array(4.1078835, dtype=float32),\n", - " 'expected_precision': Array(61701.812, dtype=float32, weak_type=True),\n", - " 'mean': Array(4.0203476, dtype=float32),\n", - " 'observed': Array(1, dtype=int32, weak_type=True),\n", - " 'precision': Array(71701.81, dtype=float32, weak_type=True),\n", - " 'temp': {'effective_precision': Array(0.13946642, dtype=float32, weak_type=True),\n", - " 'value_prediction_error': Array(-0.08753586, dtype=float32),\n", - " 'volatility_prediction_error': Array(472.65228, dtype=float32)},\n", - " 'tonic_drift': Array(0., dtype=float32, weak_type=True),\n", - " 'tonic_volatility': Array(-13., dtype=float32, weak_type=True),\n", - " 'value_coupling_children': (Array(1., dtype=float32, weak_type=True),),\n", - " 'value_coupling_parents': (Array(1., dtype=float32, weak_type=True),),\n", - " 'volatility_coupling_children': None,\n", - " 'volatility_coupling_parents': None},\n", - " 2: {'autoconnection_strength': Array(1., dtype=float32, weak_type=True),\n", - " 'expected_mean': Array(0.34866714, dtype=float32),\n", - " 'expected_precision': Array(7.388171, dtype=float32, weak_type=True),\n", - " 'mean': Array(0.26114178, dtype=float32),\n", - " 'observed': Array(1, dtype=int32, weak_type=True),\n", - " 'precision': Array(61709.2, dtype=float32, weak_type=True),\n", - " 'temp': {'effective_precision': Array(0.99988025, dtype=float32, weak_type=True),\n", - " 'value_prediction_error': Array(0., dtype=float32, weak_type=True),\n", - " 'volatility_prediction_error': Array(0., dtype=float32, weak_type=True)},\n", - " 'tonic_drift': Array(0., dtype=float32, weak_type=True),\n", - " 'tonic_volatility': Array(-2., dtype=float32, weak_type=True),\n", - " 'value_coupling_children': (Array(1., dtype=float32, weak_type=True),),\n", - " 'value_coupling_parents': None,\n", - " 'volatility_coupling_children': None,\n", - " 'volatility_coupling_parents': None},\n", - " 3: {'autoconnection_strength': Array(1., dtype=float32, weak_type=True),\n", - " 'expected_mean': Array(1.3846478, dtype=float32),\n", - " 'expected_precision': Array(61701.812, dtype=float32, weak_type=True),\n", - " 'mean': Array(1.2971121, dtype=float32),\n", - " 'observed': Array(1, dtype=int32, weak_type=True),\n", - " 'precision': Array(71701.81, dtype=float32, weak_type=True),\n", - " 'temp': {'effective_precision': Array(0.13946642, dtype=float32, weak_type=True),\n", - " 'value_prediction_error': Array(0., dtype=float32, weak_type=True),\n", - " 'volatility_prediction_error': Array(0., dtype=float32, weak_type=True)},\n", - " 'tonic_drift': Array(0., dtype=float32, weak_type=True),\n", - " 'tonic_volatility': Array(-13., dtype=float32, weak_type=True),\n", - " 'value_coupling_children': (Array(1., dtype=float32, weak_type=True),),\n", - " 'value_coupling_parents': None,\n", - " 'volatility_coupling_children': None,\n", - " 'volatility_coupling_parents': (Array(1., dtype=float32, weak_type=True),\n", - " Array(1., dtype=float32, weak_type=True))},\n", - " 4: {'autoconnection_strength': Array(1., dtype=float32, weak_type=True),\n", - " 'expected_mean': Array(0., dtype=float32, weak_type=True),\n", - " 'expected_precision': Array(1., dtype=float32, weak_type=True),\n", - " 'mean': Array(0., dtype=float32, weak_type=True),\n", - " 'observed': Array(1, dtype=int32, weak_type=True),\n", - " 'precision': Array(1., dtype=float32, weak_type=True),\n", - " 'temp': {'effective_precision': Array(0., dtype=float32, weak_type=True),\n", - " 'value_prediction_error': Array(0., dtype=float32, weak_type=True),\n", - " 'volatility_prediction_error': Array(0., dtype=float32, weak_type=True)},\n", - " 'tonic_drift': Array(0., dtype=float32, weak_type=True),\n", - " 'tonic_volatility': Array(-4., dtype=float32, weak_type=True),\n", - " 'value_coupling_children': None,\n", - " 'value_coupling_parents': None,\n", - " 'volatility_coupling_children': (Array(1., dtype=float32, weak_type=True),),\n", - " 'volatility_coupling_parents': None},\n", - " 5: {'autoconnection_strength': Array(1., dtype=float32, weak_type=True),\n", - " 'expected_mean': Array(0., dtype=float32, weak_type=True),\n", - " 'expected_precision': Array(1., dtype=float32, weak_type=True),\n", - " 'mean': Array(0., dtype=float32, weak_type=True),\n", - " 'observed': Array(1, dtype=int32, weak_type=True),\n", - " 'precision': Array(1., dtype=float32, weak_type=True),\n", - " 'temp': {'effective_precision': Array(0., dtype=float32, weak_type=True),\n", - " 'value_prediction_error': Array(0., dtype=float32, weak_type=True),\n", - " 'volatility_prediction_error': Array(0., dtype=float32, weak_type=True)},\n", - " 'tonic_drift': Array(0., dtype=float32, weak_type=True),\n", - " 'tonic_volatility': Array(-4., dtype=float32, weak_type=True),\n", - " 'value_coupling_children': None,\n", - " 'value_coupling_parents': None,\n", - " 'volatility_coupling_children': (Array(1., dtype=float32, weak_type=True),),\n", - " 'volatility_coupling_parents': None}}" + "
" ] }, - "execution_count": 77, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "attributes" + "create_hgf_visualization(weather_data, attributes_hist, edges_hist, 20)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": {