diff --git a/notebook/num_nodes_and_time.ipynb b/notebook/num_nodes_and_time.ipynb new file mode 100644 index 000000000..a0fda673a --- /dev/null +++ b/notebook/num_nodes_and_time.ipynb @@ -0,0 +1,274 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -U git+https://github.com/wmayner/pyphi.git@feature/iit-4.0" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "import numpy as np\n", + "import pyphi" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "n_nodes = 6" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(n_nodes, n_states) = (1, 2)\n", + "(n_nodes, n_states) = (2, 4)\n", + "(n_nodes, n_states) = (3, 8)\n", + "(n_nodes, n_states) = (4, 16)\n", + "(n_nodes, n_states) = (5, 32)\n", + "(n_nodes, n_states) = (6, 64)\n", + "(n_nodes, n_states) = (7, 128)\n", + "(n_nodes, n_states) = (8, 256)\n" + ] + } + ], + "source": [ + "n_nodes_max = 8\n", + "for n in range(1, n_nodes_max + 1):\n", + " n_states = 2 ** n\n", + " print(f\"(n_nodes, n_states) = {n, n_states}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(64, 64) 6\n" + ] + } + ], + "source": [ + "def generate_states_with_binary_state(n_nodes, seed=42):\n", + " \"\"\"\n", + " Generates a matrix of random probabilities and a binary state vector with reproducibility.\n", + " Each row of the random probabilities matrix sums to 1.\n", + " The state vector is binary (0 or 1).\n", + " \n", + " Parameters:\n", + " - n_nodes: The number of nodes.\n", + " - seed: The seed for the random number generator to ensure reproducibility.\n", + " \n", + " Returns:\n", + " - random_probs: A (2^n_nodes, 2^n_nodes) numpy array where each row sums to 1.\n", + " - binary_state: A tuple representing a binary (0 or 1) state with n_nodes elements.\n", + " \"\"\"\n", + " np.random.seed(seed)\n", + " \n", + " matrix_size = 2 ** n_nodes\n", + " \n", + " # Generate random numbers for the matrix\n", + " random_matrix = np.random.rand(matrix_size, matrix_size)\n", + " # Normalize each row to sum to 1\n", + " random_probs = random_matrix / random_matrix.sum(axis=1)[:, np.newaxis]\n", + " \n", + " # Generate the binary state vector\n", + " binary_state_array = np.random.randint(2, size=(n_nodes, 1))\n", + " binary_state = tuple(binary_state_array.flatten())\n", + " \n", + " return random_probs, binary_state\n", + "\n", + "# Generate with binary state\n", + "tpm, state = generate_states_with_binary_state(n_nodes, seed=42)\n", + "# print(tpm.shape, state.shape)\n", + "print(tpm.shape, len(state))\n", + "# print(tpm)\n", + "# print(\"===========\")\n", + "# print(state)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 2, 2, 2, 2, 2, 6) (64, 64)\n" + ] + } + ], + "source": [ + "sbn_tpm = pyphi.convert.state_by_state2state_by_node(tpm)\n", + "sbs_tpm = pyphi.convert.state_by_node2state_by_state(sbn_tpm)\n", + "\n", + "print(sbn_tpm.shape, sbs_tpm.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "φ_s = -8.904744115994914e-05\n", + " Φ = 3.771928248186974\n" + ] + } + ], + "source": [ + "pyphi.config.PROGRESS_BARS = False\n", + "pyphi.config.PARALLEL = False\n", + "pyphi.config.SHORTCIRCUIT_SIA = False\n", + "\n", + "# Defining a substrate\n", + "# node_labels = (\"A\", \"B\", \"C\")\n", + "\n", + "# TPM in state-by-node format (see `help(pyphi.Network)` for information on TPM\n", + "# representations).\n", + "# tpm = np.array(\n", + "# [\n", + "# [1, 0, 0],\n", + "# [0, 1, 0],\n", + "# [1, 1, 1],\n", + "# [0, 1, 1],\n", + "# [0, 0, 0],\n", + "# [1, 1, 0],\n", + "# [0, 0, 1],\n", + "# [1, 0, 1],\n", + "# ]\n", + "# )\n", + "\n", + "# The network's adjacency matrix. In its absence, PyPhi will assume all-to-all\n", + "# connectivity. PyPhi uses the \"from-to\" convention: a \"1\" in entry (i,j) means\n", + "# there is a directed edge from unit i to unit j.\n", + "\n", + "# NOTE: If the adjacency matrix indicates a connection between units when there\n", + "# is no causal connection according to the TPM, the analysis will correctly\n", + "# determine that; however, if the matrix specifies the *lack* of a connection,\n", + "# PyPhi will assume no causal influence and short-circuit the analysis, even if\n", + "# the TPM implies that there is.\n", + "# connectivity_matrix = np.array([\n", + "# [1, 1, 0,], # A->A, A->B\n", + "# [0, 1, 1,], # B->B, B->C\n", + "# [1, 1, 1,], # C->A, C->B, C->C\n", + "# ])\n", + "\n", + "# network = pyphi.Network(tpm, cm=connectivity_matrix, node_labels=node_labels)\n", + "# network = pyphi.Network(tpm)\n", + "network = pyphi.Network(sbs_tpm)\n", + "# network\n", + "# System Irreducibility Analysis: identifying complexes\n", + "## Intrinsicality: Define a candidate system\n", + "### A=ON, B=OFF, C=OFF (Abc in Figure 7).\n", + "# state = (1, 0, 0)\n", + "\n", + "# subsystem_backward = pyphi.Subsystem(\n", + "# network,\n", + "# state,\n", + "# nodes=node_labels,\n", + "# backward_tpm=True\n", + "# )\n", + "subsystem_backward = pyphi.Subsystem(\n", + " network,\n", + " state,\n", + " backward_tpm=True\n", + ")\n", + "\n", + "# subsystem_forward = pyphi.Subsystem(\n", + "# network,\n", + "# state,\n", + "# nodes=node_labels\n", + "# )\n", + "subsystem_forward = pyphi.Subsystem(\n", + " network,\n", + " state,\n", + ")\n", + "\n", + "## Composition: Unfolding Φ-structure\n", + "### Cause-effect structure and big Φ\n", + "phi_structure = pyphi.new_big_phi.phi_structure(subsystem_forward)\n", + "# phi_structure\n", + "\n", + "#### φ_s\n", + "print(f\"φ_s = {phi_structure.sia.phi}\")\n", + "\n", + "#### Big Φ (sum of distinctions and relations' small φ)\n", + "print(f\" Φ = {phi_structure.big_phi}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\n4 nodes: 5.8s\\n5 nodes: 2m31.9s\\n'" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "4 nodes: 5.8s\n", + "5 nodes: 2m31.9s\n", + "6 nodes: 133m19.7s\n", + "\"\"\"" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "iit", + "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.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +}