diff --git a/docs/source/cholesky-estimation/large-grf-approximate-cholesky.ipynb b/docs/source/cholesky-estimation/large-grf-approximate-cholesky.ipynb new file mode 100644 index 0000000..e74b358 --- /dev/null +++ b/docs/source/cholesky-estimation/large-grf-approximate-cholesky.ipynb @@ -0,0 +1,1461 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "e0933342-9368-4774-bcbe-b9a8dc615018", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/BERL/Github/venv_sksparse/bin/python\n" + ] + } + ], + "source": [ + "import sys\n", + "print(sys.executable)\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ebac07dc-4366-4221-82f4-d8d7a5120c0e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy as sp\n", + "import networkx as nx\n", + "from gstools import SRF, Exponential\n", + "from gstools.random import MasterRNG\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "import ipywidgets\n", + "import plotly.graph_objects as go\n", + "from tqdm import tqdm\n", + "\n", + "from graphite_maps.enif import EnIF\n", + "from iterative_ensemble_smoother.experimental import AdaptiveESMDA" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a7534184-2d05-41d3-8c06-3867c2632e92", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_field(i, title):\n", + " plt.figure(figsize=(5, 5))\n", + " # Find global min and max across all fields to set color scale\n", + " vmin = np.min([np.min(u) for u in field])\n", + " vmax = np.max([np.max(u) for u in field])\n", + " plt.imshow(field[i], cmap='viridis', vmin=vmin, vmax=vmax)\n", + " plt.title(f\"{title} {i}\")\n", + " plt.colorbar()\n", + " plt.show\n", + "\n", + "def create_flattened_graph(px, py):\n", + " G = nx.Graph()\n", + " for i in range(px):\n", + " for j in range(py):\n", + " index = i * py + j # Flatten the 2D index to a single index\n", + " # Connect to the right neighbor\n", + " if j < py - 1:\n", + " G.add_edge(index, index + 1)\n", + " # Connect to the bottom neighbor\n", + " if i < px - 1:\n", + " G.add_edge(index, index + py)\n", + " return G\n", + "\n", + "def draw_2d_grid_graph(G, dim_x, dim_y, node_size=50):\n", + " pos = {node: (node % dim_y, node // dim_y) for node in G.nodes()}\n", + " plt.figure(figsize=(8, 8))\n", + " nx.draw(G, pos, with_labels=False, node_size=node_size)\n", + " plt.show()\n", + "\n", + "def create_triangular_grid_graph(px, py):\n", + " G = nx.Graph()\n", + " for i in range(px):\n", + " for j in range(py):\n", + " index = i * py + j # Flatten the 2D index to a single index\n", + " # Connect to the right neighbor\n", + " if j < py - 1:\n", + " G.add_edge(index, index + 1)\n", + " # Connect to the bottom neighbor\n", + " if i < px - 1:\n", + " G.add_edge(index, index + py)\n", + " # Connect diagonally to the bottom-right neighbor\n", + " if i < px - 1 and j < py - 1:\n", + " G.add_edge(index, index + py + 1)\n", + " return G\n", + "\n", + "def create_extended_connectivity_grid_graph(px, py):\n", + " G = nx.Graph()\n", + " for i in range(px):\n", + " for j in range(py):\n", + " index = i * py + j # Flatten the 2D index to a single index\n", + " # Connect to right and bottom neighbors (primary connections)\n", + " if j < py - 1:\n", + " G.add_edge(index, index + 1)\n", + " if i < px - 1:\n", + " G.add_edge(index, index + py)\n", + " # Connect diagonally to the bottom-right neighbor (creates triangles)\n", + " if i < px - 1 and j < py - 1:\n", + " G.add_edge(index, index + py + 1)\n", + " \n", + " \n", + "\n", + " return G\n", + "\n", + "def draw_2d_extended_grid_graph(G, dim_x, dim_y, node_size=50):\n", + " pos = {node: (node % dim_y, -node // dim_y) for node in G.nodes()} # Negative y for correct orientation\n", + " plt.figure(figsize=(10, 10))\n", + " nx.draw(G, pos, with_labels=False, node_size=node_size, node_color='skyblue', edge_color='gray')\n", + " plt.gca().invert_yaxis() # Invert y-axis to display the graph in matrix coordinate style\n", + " plt.title(\"Extended Connectivity Grid Graph\")\n", + " plt.show()\n", + "\n", + "def draw_2d_triangular_grid_graph(G, dim_x, dim_y, node_size=50):\n", + " pos = {node: (node % dim_y, -node // dim_y) for node in G.nodes()} # Negative y for correct orientation\n", + " plt.figure(figsize=(8, 8))\n", + " nx.draw(G, pos, with_labels=False, node_size=node_size, node_color='skyblue', edge_color='gray')\n", + " plt.gca().invert_yaxis() # Invert y-axis to display the graph in matrix coordinate style\n", + " plt.title(\"Triangular Grid Graph\")\n", + " plt.show()\n", + "\n", + "def plot_field_from_vector(U_i, px, py, vmin, vmax, title=\"2D Field\"):\n", + " \"\"\"\n", + " Plots a 2D field from a flattened realization.\n", + "\n", + " Parameters:\n", + " - U_i: A flattened 2D field (1D numpy array).\n", + " - px: The x-dimension (width) of the original 2D field.\n", + " - py: The y-dimension (height) of the original 2D field.\n", + " - title: Title of the plot.\n", + " \"\"\"\n", + " # Reshape U_i into its original 2D form\n", + " field_2d = U_i.reshape((px, py))\n", + " \n", + " # Create the plot\n", + " plt.figure(figsize=(6, 5))\n", + " plt.imshow(field_2d, cmap='viridis', aspect='auto', vmin=vmin, vmax=vmax)\n", + " plt.colorbar(label='Value')\n", + " plt.title(title)\n", + " plt.xlabel('X dimension')\n", + " plt.ylabel('Y dimension')\n", + " plt.show()\n", + "\n", + "def plot_field_3d(U_i, px, py, vmin, vmax, title=\"3D Field\", azim=30, file_name=None):\n", + " \"\"\"\n", + " Plots a 3D field from a flattened realization.\n", + "\n", + " Parameters:\n", + " - U_i: A flattened 2D field (1D numpy array).\n", + " - px: The x-dimension (width) of the original 2D field.\n", + " - py: The y-dimension (height) of the original 2D field.\n", + " - vmin: Minimum value for colormap and z-axis.\n", + " - vmax: Maximum value for colormap and z-axis.\n", + " - title: Title of the plot.\n", + " \"\"\"\n", + " # Reshape U_i into its original 2D form\n", + " field_2d = U_i.reshape((px, py))\n", + " \n", + " # Create meshgrid for x and y dimensions\n", + " x = np.linspace(0, px-1, px)\n", + " y = np.linspace(0, py-1, py)\n", + " X, Y = np.meshgrid(x, y)\n", + " \n", + " # Create the plot\n", + " fig = plt.figure(figsize=(8, 6))\n", + " ax = fig.add_subplot(111, projection='3d')\n", + " \n", + " # Plot the surface\n", + " surf = ax.plot_surface(X, Y, field_2d.T, cmap='viridis', edgecolor='none', vmin=vmin, vmax=vmax)\n", + " \n", + " # Add a color bar\n", + " #fig.colorbar(surf, shrink=0.5, aspect=5, label='Value')\n", + " \n", + " ax.set_title(title)\n", + " ax.set_xlabel('X dimension')\n", + " ax.set_ylabel('Y dimension')\n", + " ax.set_zlabel('Values')\n", + " ax.set_zlim(vmin, vmax)\n", + "\n", + " # Set the view angle\n", + " ax.view_init(azim=azim)\n", + "\n", + " if file_name is not None:\n", + " plt.savefig(f\"{file_name}.png\", dpi=300)\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "71619f8a-f0fc-4095-a86c-75cdf7d91243", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "\n", + "def plot_fields_3d(U_is, px, py, vmin, vmax, titles, azim=30, overall_title=\"Overall 3D Fields\", file_name=None):\n", + " \"\"\"\n", + " Plots 3D fields from flattened realizations side-by-side with an overall title.\n", + "\n", + " Parameters:\n", + " - U_is: List of flattened 2D fields (1D numpy arrays).\n", + " - px: The x-dimension (width) of the original 2D fields.\n", + " - py: The y-dimension (height) of the original 2D fields.\n", + " - vmin: Minimum value for colormap and z-axis.\n", + " - vmax: Maximum value for colormap and z-axis.\n", + " - titles: List of titles for each subplot.\n", + " - overall_title: The overall title for the figure.\n", + " - azim: Azimuthal angle for the 3D plot.\n", + " - file_name: Filename to save the figure.\n", + " \"\"\"\n", + " fig = plt.figure(figsize=(24, 6)) # Adjust the figure size as needed\n", + " fig.suptitle(overall_title, fontsize=16) # Set the overall title\n", + "\n", + " axes = [] # List to store axes for color bar adjustment\n", + " for i, (U_i, title) in enumerate(zip(U_is, titles), start=1):\n", + " field_2d = U_i.reshape((px, py))\n", + " x = np.linspace(0, px-1, px)\n", + " y = np.linspace(0, py-1, py)\n", + " X, Y = np.meshgrid(x, y)\n", + " \n", + " ax = fig.add_subplot(1, 4, i, projection='3d') # Adjust for four subplots\n", + " axes.append(ax)\n", + " surf = ax.plot_surface(X, Y, field_2d.T, cmap='viridis', edgecolor='none', vmin=vmin, vmax=vmax)\n", + " ax.set_title(title)\n", + " ax.set_xlabel('X dimension')\n", + " ax.set_ylabel('Y dimension')\n", + " ax.set_zlabel('Values')\n", + " ax.set_zlim(vmin, vmax)\n", + " ax.view_init(azim=azim)\n", + " \n", + " # Adjust the color bar to be shared across all subplots\n", + " #fig.subplots_adjust(right=0.85) # Adjust subplot spacing to fit color bar\n", + " #cbar_ax = fig.add_axes([0.88, 0.15, 0.02, 0.7]) # Position for color bar\n", + " #fig.colorbar(surf, cax=cbar_ax, label='Value')\n", + "\n", + " # Save the plot if a filename is specified\n", + " #if file_name is not None:\n", + " # plt.savefig(f\"{file_name}.png\", dpi=300) # Save figure with high dpi for better resolution\n", + " if file_name is not None:\n", + " plt.savefig(f\"{file_name}.pdf\", format='pdf', bbox_inches='tight')\n", + "\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b8311091-ef12-4bfd-a20b-9a0771f421a3", + "metadata": {}, + "outputs": [], + "source": [ + "px, py = 50, 50\n", + "p = px * py\n", + "n = 100" + ] + }, + { + "cell_type": "markdown", + "id": "41582543-b487-4377-a8f2-d72d4293a2f0", + "metadata": {}, + "source": [ + "# Anisotropic exponential covariance Gaussian field\n", + "\n", + "- variance $\\sigma^2=1$\n", + "- correlation length $\\lambda = (12,3)^T$\n", + "- rotation angle $\\phi = \\pi/8$\n", + "\n", + "see [GSTools tutorial](https://geostat-framework.readthedocs.io/projects/gstools/en/v1.1.1/tutorial_01_srf.html#creating-fancier-fields)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b578c274-10b8-473f-9a8b-ee9cd292b7cd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Simulating fields: 100%|██████████| 100/100 [00:03<00:00, 33.27it/s]\n" + ] + } + ], + "source": [ + "model = Exponential(dim=2, var=1, len_scale=[.12 * px, .03 * px], angles=np.pi/8)\n", + "srf = SRF(model)\n", + "seed = MasterRNG(20170519)\n", + "\n", + "field = []\n", + "x, y = np.arange(px), np.arange(py)\n", + "for i in tqdm(range(n), desc=\"Simulating fields\"):\n", + " field.append(srf.structured([x,y], seed=seed()))\n", + "\n", + "vmin = np.min([np.min(u) for u in field])\n", + "vmax = np.max([np.max(u) for u in field])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c6682d03-890e-4824-86c9-a644cef90c9e", + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def create_selective_connectivity_grid_graph(px, py):\n", + " G = nx.Graph()\n", + " for i in range(px):\n", + " for j in range(py):\n", + " index = i * py + j # Flatten the 2D index to a single index\n", + " # Connect to right and bottom neighbors (primary connections)\n", + " if j < py - 1:\n", + " G.add_edge(index, index + 1)\n", + " if i < px - 1:\n", + " G.add_edge(index, index + py)\n", + " # Connect diagonally to the bottom-right neighbor (creates triangles)\n", + " if i < px - 1 and j < py - 1:\n", + " G.add_edge(index, index + py + 1)\n", + " \n", + " # Add selective connections to neighbors of neighbors\n", + " for index in range(px * py):\n", + " first_order_neighbors = list(G.neighbors(index))\n", + " added_neighbors = set(first_order_neighbors) # Keep track of already directly connected nodes\n", + "\n", + " for neighbor in first_order_neighbors:\n", + " second_order_neighbors = list(G.neighbors(neighbor))\n", + " for second_neighbor in second_order_neighbors:\n", + " if second_neighbor != index and second_neighbor not in added_neighbors:\n", + " G.add_edge(index, second_neighbor)\n", + " added_neighbors.add(second_neighbor)\n", + "\n", + " return G\n", + "\n", + "def draw_2d_selective_grid_graph(G, dim_x, dim_y, node_size=50):\n", + " pos = {node: (node % dim_y, -node // dim_y) for node in G.nodes()} # Adjust node positions\n", + " plt.figure(figsize=(10, 10))\n", + " nx.draw(G, pos, with_labels=False, node_size=node_size, node_color='skyblue', edge_color='gray')\n", + " plt.gca().invert_yaxis() # Invert y-axis for proper orientation\n", + " plt.title(\"Selective Connectivity Grid Graph\")\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3f7ede0a-fbfa-45f7-bcbd-293d8b45139f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph with 2500 nodes and 4900 edges\n" + ] + } + ], + "source": [ + "# Create the graph for the flattened field with separate dimensions\n", + "Graph_u = create_flattened_graph(px, py)\n", + "print(Graph_u)\n", + "#Graph_u.edges(101) " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a85cb3ac-77f2-436d-b39f-630a748051ef", + "metadata": {}, + "outputs": [], + "source": [ + "G = Graph_u.copy() # Work with a copy to preserve the original graph during modifications\n", + "\n", + "# Add selective connections to neighbors of neighbors (up to third order)\n", + "for index in range(px * py):\n", + " first_order_neighbors = list(Graph_u.neighbors(index))\n", + " all_connected_neighbors = set(first_order_neighbors) # Track all directly connected nodes#\n", + "\n", + " for neighbor in first_order_neighbors:\n", + " second_order_neighbors = list(Graph_u.neighbors(neighbor))\n", + " for second_neighbor in second_order_neighbors:\n", + " if second_neighbor != index and second_neighbor not in all_connected_neighbors:\n", + " G.add_edge(index, second_neighbor)\n", + " all_connected_neighbors.add(second_neighbor)\n", + "# # Move to third-order neighbors\n", + "# third_order_neighbors = list(Graph_u.neighbors(second_neighbor))\n", + "# for third_neighbor in third_order_neighbors:\n", + "# if third_neighbor != index and third_neighbor not in all_connected_neighbors:\n", + "# G.add_edge(index, third_neighbor)\n", + "# all_connected_neighbors.add(third_neighbor)#\n", + "\n", + "Graph_u2 = G # Replace the original graph with the modified version if needed" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "47c32fa8-8cd5-463e-9504-89eb047a9643", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the graph -- knowing 2-d structure\n", + "draw_2d_grid_graph(Graph_u, px, py, node_size=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a0101787-bee1-43a6-8525-92c051591338", + "metadata": {}, + "outputs": [], + "source": [ + "U = np.zeros((n,p))\n", + "for i in range(n):\n", + " U[i,:] = field[i].flatten()" + ] + }, + { + "cell_type": "markdown", + "id": "a1ccb34c-1b85-4f43-8c23-6745fdfd0cf7", + "metadata": {}, + "source": [ + "# Compute responses" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d08b6d28-5a67-476e-a95c-e949bdeec1db", + "metadata": {}, + "outputs": [], + "source": [ + "def h(U_i, j, a=1.0, b=5):\n", + " return a * U_i[j] + b" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8ca940d0-83b0-4916-a6a7-a512635bef18", + "metadata": {}, + "outputs": [], + "source": [ + "m = min(px, py) # Number of elements on the diagonal\n", + "Y = np.zeros((n, m))\n", + "a, b = 1.0, 5\n", + "for i in range(n):\n", + " U_i = U[i, :]\n", + " for k in range(m):\n", + " j = k * (py + 1) # Index for the diagonal element in the vectorized field\n", + " Y[i, k] = h(U_i, j, a, b) + 0.1 * np.random.normal()" + ] + }, + { + "cell_type": "markdown", + "id": "905595e8-313e-44f8-a0c9-8857b9a5c015", + "metadata": {}, + "source": [ + "# Create observations -- we observe the diagonal in the 2D-field" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ff3a4fd1-ea2a-479d-9d9d-8229838e1835", + "metadata": {}, + "outputs": [], + "source": [ + "d = np.repeat(8.0, m)\n", + "\n", + "# Be specific about precision of noise\n", + "var_eps = 1.0\n", + "Prec_eps = sp.sparse.diags(\n", + " [np.repeat(1/var_eps, m)], \n", + " offsets=[0],\n", + " shape=(m, m), \n", + " format='csc'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ffff9fff-37aa-498f-88ea-4bd0436fed48", + "metadata": {}, + "source": [ + "# Ensemble information filter" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d0244b98-e4c1-4c10-840c-4f36f16aab79", + "metadata": {}, + "outputs": [], + "source": [ + "# Create EnIF object\n", + "gtmap = EnIF(Graph_u = Graph_u, Prec_eps=Prec_eps)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "1fb75a5b-5996-4c37-916e-4bbe17425bfb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/BERL/Github/venv_sksparse/lib/python3.11/site-packages/scipy/sparse/_index.py:145: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n", + " self._set_arrayXarray(i, j, x)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max degree of graph is: 4\n", + "Permutation optimization took 0.006396770477294922 seconds\n", + "Parameters in precision: 7400\n", + "Parameters in Cholesky factor: 36436\n", + "Starting statistical fitting of precision\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Learning precision Cholesky factor row-by-row: 100%|██████████| 2500/2500 [00:01<00:00, 2442.18it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precision has log-determinant: 2267.48999229266\n", + "Learning sparse linear map of shape (50, 2500)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Learning sparse linear map for each response: 100%|██████████| 50/50 [00:20<00:00, 2.45it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total elements: 125000\n", + "Non-zero elements: 50\n", + "Fraction of non-zeros: 0.0004\n", + "Calculating unexplained variance\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Fit both precision and sparse linear map H\n", + "gtmap.fit(U, Y, learning_algorithm=\"influence-boost\", ordering_method=\"metis\", verbose_level=5)\n", + "prior_prec_est = gtmap.Prec_u.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "cc5320ff-e058-43be-a478-ab4c4fceff02", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mapping realizations to canonical space\n", + "Calculating unexplained variance\n", + "Calculating response residuals\n", + "Sampling with seed=None\n", + "Sampled Gaussian noise with shape (100, 50)\n", + "Total residual variance: 50.52501051744811\n", + "Unexplained variance: 0.5250105174481028\n", + "Measurement variance: 50.0\n", + "Mapping canonical-scaled realizations to moment realization\n" + ] + } + ], + "source": [ + "U_posterior = gtmap.transport(U, Y, d, verbose_level=5)" + ] + }, + { + "cell_type": "markdown", + "id": "6a9ad178-f4f0-43dc-8054-f92109395047", + "metadata": {}, + "source": [ + "### Try incomplete Cholesky" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ef768e90-a91b-41e3-bf11-a6ae6fe55306", + "metadata": {}, + "outputs": [], + "source": [ + "from graphite_maps.precision_estimation import fit_precision_cholesky_approximate, optimize_sparse_affine_kr_map\n", + "from sklearn.preprocessing import StandardScaler" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "c317f9c0-b5a4-45a3-be15-bef52036f661", + "metadata": {}, + "outputs": [], + "source": [ + "scaler_u = StandardScaler()\n", + "U_scaled = scaler_u.fit_transform(U)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "180a7137-35be-444f-b8db-dd193d5c885b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting statistical fitting of precision\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Learning precision Cholesky factor row-by-row: 100%|██████████| 2500/2500 [00:00<00:00, 3765.49it/s]\n" + ] + } + ], + "source": [ + "Prec_u_approx_chol_incomplete = fit_precision_cholesky_approximate(\n", + " U_scaled,\n", + " Graph_u,\n", + " neighbourhood_expansion = 1,\n", + " verbose_level=4,\n", + " use_tqdm=True,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "724f7621-2171-41e2-a6fb-49e0836ac65d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precision u exists. Use `fit_precision` to refit if necessary\n", + "Learning sparse linear map of shape (50, 2500)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Learning sparse linear map for each response: 100%|██████████| 50/50 [00:22<00:00, 2.21it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total elements: 125000\n", + "Non-zero elements: 50\n", + "Fraction of non-zeros: 0.0004\n", + "Calculating unexplained variance\n", + "Mapping realizations to canonical space\n", + "Calculating unexplained variance\n", + "Calculating response residuals\n", + "Sampling with seed=None\n", + "Sampled Gaussian noise with shape (100, 50)\n", + "Total residual variance: 50.52501051744811\n", + "Unexplained variance: 0.5250105174481028\n", + "Measurement variance: 50.0\n", + "Mapping canonical-scaled realizations to moment realization\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Mapping data to moment parametrisation realization-by-realization: 100%|██████████| 100/100 [00:00<00:00, 305.61it/s]\n" + ] + } + ], + "source": [ + "gtmap_scale = EnIF(Prec_u = Prec_u_approx_chol_incomplete, Prec_eps=Prec_eps)\n", + "gtmap_scale.fit(U_scaled, Y, learning_algorithm=\"influence-boost\", ordering_method=\"best\", verbose_level=5)\n", + "U_posterior_scaled = gtmap_scale.transport(U_scaled, Y, d, verbose_level=5, iterative=True)\n", + "U_posterior_chol_incomplete = scaler_u.inverse_transform(U_posterior_scaled)" + ] + }, + { + "cell_type": "markdown", + "id": "389b5ae6-1c1a-4dd8-8c48-cb9878a9aff7", + "metadata": {}, + "source": [ + "## Try expanded incomplete Cholesky" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "39b137c8-d633-4bab-bd64-c8860a9891e5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting statistical fitting of precision\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Learning precision Cholesky factor row-by-row: 100%|██████████| 2500/2500 [00:01<00:00, 1873.44it/s]\n" + ] + } + ], + "source": [ + "Prec_u_approx_chol_incomplete_epxanded = fit_precision_cholesky_approximate(\n", + " U_scaled,\n", + " Graph_u,\n", + " neighbourhood_expansion = 3,\n", + " verbose_level=4,\n", + " use_tqdm=True,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "527ef4aa-5441-4e93-8cd3-3549f59bed9f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precision u exists. Use `fit_precision` to refit if necessary\n", + "Learning sparse linear map of shape (50, 2500)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Learning sparse linear map for each response: 100%|██████████| 50/50 [00:01<00:00, 28.61it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total elements: 125000\n", + "Non-zero elements: 50\n", + "Fraction of non-zeros: 0.0004\n", + "Calculating unexplained variance\n", + "Mapping realizations to canonical space\n", + "Calculating unexplained variance\n", + "Calculating response residuals\n", + "Sampling with seed=None\n", + "Sampled Gaussian noise with shape (100, 50)\n", + "Total residual variance: 50.52501051744811\n", + "Unexplained variance: 0.5250105174481028\n", + "Measurement variance: 50.0\n", + "Mapping canonical-scaled realizations to moment realization\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Mapping data to moment parametrisation realization-by-realization: 100%|██████████| 100/100 [00:00<00:00, 113.81it/s]\n" + ] + } + ], + "source": [ + "gtmap_scale = EnIF(Prec_u = Prec_u_approx_chol_incomplete_epxanded, Prec_eps=Prec_eps)\n", + "gtmap_scale.fit(U_scaled, Y, learning_algorithm=\"influence-boost\", ordering_method=\"best\", verbose_level=5)\n", + "U_posterior_scaled = gtmap_scale.transport(U_scaled, Y, d, verbose_level=5, iterative=True)\n", + "U_posterior_chol_incomplete_expanded = scaler_u.inverse_transform(U_posterior_scaled)" + ] + }, + { + "cell_type": "markdown", + "id": "32408b0a-7bdf-4b5c-9f28-391c50442784", + "metadata": {}, + "source": [ + "## Reverse minmax ordering" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "33e27ab1-32f4-43d5-836f-4603712d9162", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from heapdict import heapdict\n", + "from collections import defaultdict\n", + "import numba as nb\n", + "import time\n", + "from typing import Tuple, List, Dict, Set, Callable\n", + "\n", + "\n", + "# ---------------------------------------------------------------------\n", + "# 1. Numba helpers (ℓ1 / “Manhattan’’ metric only)\n", + "# ---------------------------------------------------------------------\n", + "@nb.njit(inline='always')\n", + "def _manhattan(p: Tuple[float, float], q: Tuple[float, float]) -> float:\n", + " \"\"\"|x₁−x₂| + |y₁−y₂| – fast & in‑lined everywhere.\"\"\"\n", + " dx = p[0] - q[0]\n", + " dy = p[1] - q[1]\n", + " return abs(dx) + abs(dy)\n", + "\n", + "\n", + "@nb.njit\n", + "def _argsort_by_manhat(xk: Tuple[float, float],\n", + " idx: np.ndarray,\n", + " coords: np.ndarray) -> np.ndarray:\n", + " \"\"\"Return the indices `idx` sorted by ℓ1–distance to `xk`.\"\"\"\n", + " d = np.empty(len(idx), dtype=np.float64)\n", + " for t, j in enumerate(idx):\n", + " d[t] = _manhattan(xk, (coords[j, 0], coords[j, 1]))\n", + " order = np.argsort(d)\n", + " return idx[order]\n", + "# ---------------------------------------------------------------------\n", + "\n", + "\n", + "def reverse_maxmin_ordering(\n", + " grid_points: np.ndarray,\n", + " dist_to_boundary: np.ndarray,\n", + " rho: float = 2.0,\n", + " verbose: bool = False\n", + ") -> Tuple[List[int], Dict[int, Set[int]], float]:\n", + " \"\"\"\n", + " Reverse max–min ordering and sparsity pattern based on the ℓ1 (Manhattan)\n", + " metric. Everything else – screening, pruning, truncation – is identical to\n", + " your reference implementation.\n", + " \"\"\"\n", + " N = len(grid_points)\n", + " coords = grid_points.astype(np.float64, copy=False)\n", + "\n", + " # ------------------ state ----------------------------------------\n", + " l = dist_to_boundary.copy()\n", + " selected = np.zeros(N, dtype=np.bool_)\n", + " not_selected = set(range(N))\n", + " ordering_idx = []\n", + " children = defaultdict(list)\n", + " parents = defaultdict(list)\n", + " children_sorted = np.zeros(N, dtype=np.bool_)\n", + "\n", + " heap = heapdict({i: -l_i for i, l_i in enumerate(l)})\n", + "\n", + " tic = time.perf_counter()\n", + "\n", + " # ------------------ first (seed) node ----------------------------\n", + " i0, neg_li = heap.popitem()\n", + " selected[i0] = True\n", + " not_selected.remove(i0)\n", + "\n", + " xi = (coords[i0, 0], coords[i0, 1])\n", + " li = -neg_li\n", + " ordering_idx.append(i0)\n", + "\n", + " # everybody is initially child of i0\n", + " for j in range(N):\n", + " parents[j].append(i0)\n", + " children[i0].append(j)\n", + " if j == i0:\n", + " continue\n", + " dij = _manhattan(xi, (coords[j, 0], coords[j, 1]))\n", + " if dij < l[j]:\n", + " l[j] = dij\n", + " heap[j] = -dij\n", + "\n", + " l_trunc = li # current truncation radius\n", + "\n", + " # ------------------ main loop -----------------------------------\n", + " while heap:\n", + " i, neg_li = heap.popitem()\n", + " if selected[i]:\n", + " continue\n", + " li = -neg_li\n", + " xi = (coords[i, 0], coords[i, 1])\n", + " selected[i] = True\n", + " not_selected.remove(i)\n", + " ordering_idx.append(i)\n", + "\n", + " # ---- choose parent k (Alg. C.1 lines 23‑32) ----------------\n", + " k = i0\n", + " distik = np.inf\n", + " for j in parents[i]:\n", + " dij = _manhattan(xi, (coords[j, 0], coords[j, 1]))\n", + " if (j == i0) or (dij + rho*li <= rho*min(l[j], l_trunc)):\n", + " if dij < distik:\n", + " distik = dij\n", + " k = j\n", + "\n", + " xk = (coords[k, 0], coords[k, 1])\n", + "\n", + " # ---- ensure children[k] sorted once ------------------------\n", + " # Slightly different form paper implementation\n", + " # We sort children of k (once) only if the parent is selected as k\n", + " if not children_sorted[k]:\n", + " arr = np.asarray(children[k], dtype=np.int64)\n", + " children[k] = _argsort_by_manhat(xk, arr, coords).tolist()\n", + " children_sorted[k] = True\n", + "\n", + " r_li = rho * li # only once\n", + " for j in children[k]:\n", + " if j == i:\n", + " continue\n", + " djk = _manhattan((coords[j, 0], coords[j, 1]), xk)\n", + " if djk > distik + r_li: # triangle‑ineq pruning\n", + " break\n", + "\n", + " dij = _manhattan(xi, (coords[j, 0], coords[j, 1]))\n", + "\n", + " if (not selected[j]) and dij < l[j]:\n", + " l[j] = dij\n", + " heap[j] = -dij\n", + "\n", + " if dij <= r_li:\n", + " children[i].append(j)\n", + " parents[j].append(i)\n", + "\n", + " # ---- truncation test (Alg. C.1 lines 43‑49) ----------------\n", + " # This ensures linear space complexity\n", + " # Modification of reference algorithm Schäfer 2020 Algorithm 4.1\n", + " cond = True\n", + " half_ltr = 0.5 * l_trunc\n", + " for j in not_selected:\n", + " if _manhattan(xi, (coords[j, 0], coords[j, 1])) >= half_ltr:\n", + " cond = False\n", + " break\n", + "\n", + " if cond:\n", + " l_trunc *= 0.5\n", + " rho_ltr = rho * l_trunc\n", + " keep = []\n", + " for j in children[i]:\n", + " if (j not in not_selected) or \\\n", + " (_manhattan(xi, (coords[j, 0], coords[j, 1])) <= rho_ltr):\n", + " keep.append(j)\n", + " else: # prune long edge\n", + " parents[j].remove(i)\n", + " children[i] = keep\n", + "\n", + " # --------------- build sparsity sets ----------------------------\n", + " sparsity = defaultdict(set)\n", + " for i, kids in children.items():\n", + " sparsity[i].update(kids)\n", + " sparsity[i].add(i)\n", + "\n", + " toc = time.perf_counter()\n", + " return ordering_idx, sparsity, toc - tic" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "1e49bf2d-7fed-4075-8f10-850de2606efc", + "metadata": {}, + "outputs": [], + "source": [ + "def create_grid_points(p: int) -> np.ndarray:\n", + " \"\"\"\n", + " Creates a list of (i, j) integer coordinates for a p x p grid.\n", + "\n", + " Parameters\n", + " ----------\n", + " p : int\n", + " Size of the grid (number of interior points in each dimension)\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " Array of shape (N, 2) with all (i, j) grid coordinates.\n", + " \"\"\"\n", + " grid = np.array([(i, j) for i in range(p) for j in range(p)], dtype=int)\n", + " return grid\n", + "\n", + "# Define the boundary points (∂Ω) on the conceptual (p+1)x(p+1) grid\n", + "def create_boundary_points(p: int) -> List[Tuple[int, int]]:\n", + " \"\"\"\n", + " Returns the set of points on the boundary of a (p+1)x(p+1) grid\n", + " that are adjacent to the interior p x p grid.\n", + "\n", + " These are all points with at least one coordinate equal to -1 or p.\n", + " \"\"\"\n", + " boundary = []\n", + " for i in range(-1, p + 1):\n", + " boundary.append((i, -1))\n", + " boundary.append((i, p))\n", + " for j in range(0, p):\n", + " boundary.append((-1, j))\n", + " boundary.append((p, j))\n", + " return boundary\n", + "\n", + "def compute_distance_to_boundary(\n", + " interior_points: np.ndarray,\n", + " boundary_points: List[Tuple[int, int]],\n", + " distance_fn: Callable[[Tuple[int, int], Tuple[int, int]], int]\n", + ") -> np.ndarray:\n", + " \"\"\"\n", + " Computes the minimum distance from each interior grid point to the boundary.\n", + "\n", + " Parameters\n", + " ----------\n", + " interior_points : np.ndarray\n", + " Array of shape (N, 2) containing grid coordinates of interior points.\n", + " boundary_points : list of tuple\n", + " List of boundary coordinates.\n", + " distance_fn : callable\n", + " A function that computes distance between two points.\n", + "\n", + " Returns\n", + " -------\n", + " np.ndarray\n", + " Array of shape (N,) where each entry is the distance from an interior point\n", + " to the closest boundary point.\n", + " \"\"\"\n", + " distances = np.array([\n", + " min(distance_fn(tuple(p), b) for b in boundary_points)\n", + " for p in interior_points\n", + " ])\n", + " return distances" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "f87ec48d-a241-41ca-acec-7caf4467ebbe", + "metadata": {}, + "outputs": [], + "source": [ + "# 1. Create grid and data\n", + "p = px # px or py, assumes square\n", + "grid_points = create_grid_points(p)\n", + "\n", + "# Step 2: Create the geometric boundary for a pxp\n", + "boundary_points = create_boundary_points(p)\n", + "\n", + "# Step 3: Compute distance to boundary for each interior point\n", + "dist_to_boundary = compute_distance_to_boundary(\n", + " grid_points,\n", + " boundary_points,\n", + " _manhattan,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "f3c4df43-020c-419e-907b-138da16b5d47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "finished in 1.196 s, ordering length=2500\n" + ] + } + ], + "source": [ + "ordering_revmaxmin, sparsity, wall = reverse_maxmin_ordering(\n", + " grid_points = grid_points, # (N,2) float64\n", + " dist_to_boundary = dist_to_boundary, # (N,)\n", + " rho = 2.0,\n", + " verbose = False\n", + ")\n", + "\n", + "print(f\"finished in {wall:.3f} s, ordering length={len(ordering_revmaxmin)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "35e10bbd-87fd-4df6-bf78-582c9f2338da", + "metadata": {}, + "outputs": [], + "source": [ + "# The ordering_revmaxmin is in fact the actual ordering for KR map (rev-transpose chol)a\n", + "# Create graph for KR\n", + "def kr_graph(sparsity: dict, ordering_revmaxmin_chol: list):\n", + " reverse_ordering = {value: ind for ind, value in enumerate(ordering_revmaxmin_chol)}\n", + " Graph_kr = nx.DiGraph()\n", + " for row in sparsity:\n", + " for col in sparsity[row]:\n", + " row_idx = reverse_ordering[row]\n", + " col_idx = reverse_ordering[col]\n", + " if row_idx >= col_idx: # only lower triangle\n", + " Graph_kr.add_edge(row_idx, col_idx)\n", + " return Graph_kr\n", + "\n", + "Graph_revmaxmin = kr_graph(sparsity, ordering_revmaxmin)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "7ea1619a-faa4-400e-9e6c-33e3457c4db5", + "metadata": {}, + "outputs": [], + "source": [ + "def fit_precision_revmaxmin(\n", + " U: np.ndarray,\n", + " sparsity: dict, \n", + " ordering_revmaxmin_chol: list,\n", + " verbose_level: int = 0,\n", + " use_tqdm=True,\n", + ") -> sp.sparse.csc_matrix:\n", + "\n", + " # Fetch graph for KR map using revmaxmin intended for chol and associate sparsity\n", + " Graph_revmaxmin = kr_graph(sparsity, ordering_revmaxmin_chol)\n", + "\n", + " # Reorder U: rev-revmaxmin = maxmin\n", + " U_reordered = U[:, ordering_revmaxmin_chol]\n", + "\n", + " # Estimate KR map from data\n", + " C = optimize_sparse_affine_kr_map(\n", + " U_reordered,\n", + " Graph_revmaxmin,\n", + " verbose_level=verbose_level - 1,\n", + " use_tqdm=use_tqdm,\n", + " )\n", + " Prec_approx = C.T @ C\n", + "\n", + " # Permute back to before any ordering\n", + " Perm = sp.sparse.eye(Prec_approx.shape[0], format=\"csc\")[ordering_revmaxmin_chol, :]\n", + " Prec_original = Perm.T @ Prec_approx @ Perm\n", + " \n", + " return Prec_original" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "17923968-5019-4023-9655-c4ffd4fd7e08", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting statistical fitting of precision\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Learning precision Cholesky factor row-by-row: 100%|██████████| 2500/2500 [00:01<00:00, 2487.10it/s]\n" + ] + } + ], + "source": [ + "Prec_revmaxmin = fit_precision_revmaxmin(\n", + " U_scaled,\n", + " sparsity,\n", + " ordering_revmaxmin,\n", + " verbose_level=4\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "f10267e1-8562-4900-93ca-01c10af3c169", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precision u exists. Use `fit_precision` to refit if necessary\n", + "Learning sparse linear map of shape (50, 2500)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Learning sparse linear map for each response: 100%|██████████| 50/50 [00:01<00:00, 30.83it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total elements: 125000\n", + "Non-zero elements: 50\n", + "Fraction of non-zeros: 0.0004\n", + "Calculating unexplained variance\n", + "Mapping realizations to canonical space\n", + "Calculating unexplained variance\n", + "Calculating response residuals\n", + "Sampling with seed=None\n", + "Sampled Gaussian noise with shape (100, 50)\n", + "Total residual variance: 50.52501051744811\n", + "Unexplained variance: 0.5250105174481028\n", + "Measurement variance: 50.0\n", + "Mapping canonical-scaled realizations to moment realization\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Mapping data to moment parametrisation realization-by-realization: 100%|██████████| 100/100 [00:00<00:00, 156.90it/s]\n" + ] + } + ], + "source": [ + "gtmap_revmaxmin = EnIF(Prec_u = Prec_revmaxmin, Prec_eps=Prec_eps)\n", + "gtmap_revmaxmin.fit(U_scaled, Y, learning_algorithm=\"influence-boost\", ordering_method=\"best\", verbose_level=5)\n", + "U_posterior_scaled = gtmap_revmaxmin.transport(U_scaled, Y, d, verbose_level=5, iterative=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "cc114b3b-1820-4836-b68e-3eb78e5159d7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "U_posterior_revmaxmin = scaler_u.inverse_transform(U_posterior_scaled)\n", + "plot_fields_3d(\n", + " [ np.mean(U_posterior-U, axis=0),\n", + " np.mean(U_posterior_chol_incomplete-U, axis=0),\n", + " np.mean(U_posterior_chol_incomplete_expanded - U, axis=0),\n", + " np.mean(U_posterior_revmaxmin-U, axis=0),\n", + " ],\n", + " px, py, \n", + " vmin=-1, vmax=vmax, \n", + " titles=['EnIF - Cholesky', \"EnIF - Incomplete+expanded Cholesky\", \"EnIF - Incomplete+expanded Cholesky\", \"EnIF - Chol RevMaxMin\"], \n", + " overall_title=f\"Average ensemble update across the GRF.\",\n", + " #file_name = f\"update_mean_size_{px}x{py}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0d501a93-e319-4e86-b872-563b3a10f837", + "metadata": {}, + "source": [ + "### Visualize ordering on grid" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "0e22ba4f-8deb-4807-bfab-eaaea4bf5330", + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_ordering_on_grid(ordering, shape, title=\"Elimination Order on Grid\"):\n", + " \"\"\"\n", + " Visualizes the elimination order on the 2D grid as a heatmap.\n", + " \"\"\"\n", + " rows, cols = shape\n", + " order_matrix = np.full((rows, cols), np.nan)\n", + " for rank, (i, j) in enumerate(ordering):\n", + " order_matrix[i, j] = rank\n", + "\n", + " plt.figure(figsize=(6, 6))\n", + " plt.imshow(order_matrix, cmap='viridis', origin='upper')\n", + " plt.colorbar(label='Elimination Order')\n", + " plt.title(title)\n", + " plt.axis('off')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "1948501f-4f1b-4a87-8a50-b8efdd0c39a1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_ordering_on_grid(grid_points[ordering_revmaxmin], (px, py))" + ] + }, + { + "cell_type": "markdown", + "id": "4e88c80b-e9cc-4812-b596-f5f5dd386e4a", + "metadata": {}, + "source": [ + "## Testing graphite-maps implementation" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "e5b2e089", + "metadata": {}, + "outputs": [], + "source": [ + "from graphite_maps.cholesky_estimation.reverse_maximin import reverse_maxmin_ordering as reverse_maxmin_package\n", + "\n", + "from time import time" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "3407c855", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "finished in 0.586 s, ordering length=2500\n" + ] + } + ], + "source": [ + "\n", + "tic = time()\n", + "ordering_revmaxmin, sparsity = reverse_maxmin_package(\n", + " grid_points = grid_points, # (N,2) float64\n", + " dist_to_boundary = dist_to_boundary, # (N,)\n", + " rho = 2.0,\n", + " verbose = False\n", + ")\n", + "toc = time()\n", + "wall = toc - tic\n", + "\n", + "print(f\"finished in {wall:.3f} s, ordering length={len(ordering_revmaxmin)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "36f8b6dc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_ordering_on_grid(grid_points[ordering_revmaxmin], (px, py))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fcbed867", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv_sksparse", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/graphite_maps/cholesky_estimation/__init__.py b/graphite_maps/cholesky_estimation/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/graphite_maps/cholesky_estimation/reverse_maximin.py b/graphite_maps/cholesky_estimation/reverse_maximin.py new file mode 100644 index 0000000..b593e13 --- /dev/null +++ b/graphite_maps/cholesky_estimation/reverse_maximin.py @@ -0,0 +1,201 @@ +""" +reverse_maximin.py +================== + +Efficient implementation of the Reverse Maximin Ordering and Sparsity Pattern Construction +from Schäfer et al. (2021), "Sparse Cholesky Factorization by Kullback-Leibler Minimization". + +This module computes a sparsity-preserving, reverse-maximin ordering of variables +suitable for fast and scalable approximate Cholesky factorization. + +The intuition of the algorithm is found in Section 3 of the reference paper. +The implementation follows Algorithm C.1 from Appendix C. +The method is linear in space and near-linear in time (O(nlog^(2d)n)). + +References: +- F. Schäfer, M. Katzfuss, and H. Owhadi, 2021. + "Sparse Cholesky Factorization by Kullback-Leibler Minimization". + https://arxiv.org/abs/2004.14455 +""" + +from collections import defaultdict + +import networkx as nx +import numba as nb +import numpy as np +from heapdict import heapdict + + +# --------------------------------------------------------------------- +# 1. Numba helpers (L1 / Manhattan metric only for now) +# To-do: Include more metrics. +# --------------------------------------------------------------------- +@nb.njit(inline="always") +def _manhattan(p: np.ndarray, q: np.ndarray) -> float: + """L1 or Manhattan distance""" + s = 0.0 + for i in range(len(p)): + s += abs(p[i] - q[i]) + return s + + +@nb.njit +def _argsort_by_manhat( + xk: np.ndarray, idx: np.ndarray, coords: np.ndarray +) -> np.ndarray: + """Return the indices `idx` sorted by L1-distance to `xk`.""" + d = np.empty(len(idx), dtype=np.float64) + for t, j in enumerate(idx): + d[t] = _manhattan(xk, coords[j]) + order = np.argsort(d) + return idx[order] + + +# --------------------------------------------------------------------- + + +def reverse_maxmin_ordering( + grid_points: np.ndarray, + dist_to_boundary: np.ndarray, + rho: float = 2.0, + verbose: bool = False, +) -> tuple[list[int], dict[int, set[int]]]: + """ + Reverse-maximin ordering from Appendix C.1 of Schäfer et al. (2021), "Sparse Cholesky Factorization by Kullback-Leibler Minimization" + """ + N = len(grid_points) + coords = grid_points.astype(np.float64, copy=False) + + l = dist_to_boundary.copy() + selected = np.zeros(N, dtype=np.bool_) + not_selected = set(range(N)) + ordering_idx = [] + children = defaultdict(list) + parents = defaultdict(list) + children_sorted = np.zeros(N, dtype=np.bool_) + + heap = heapdict({i: -l_i for i, l_i in enumerate(l)}) + + # ------------------ first (seed) node ---------------------------- + i0, neg_li = heap.popitem() + selected[i0] = True + not_selected.remove(i0) + + xi = coords[i0] + li = -neg_li + ordering_idx.append(i0) + + # everybody is initially child of i0 + for j in range(N): + parents[j].append(i0) + children[i0].append(j) + if j == i0: + continue + # Update the heap + # In algorithm C.1 there is a sort on dij. + # We moved to conditional sorting. If j is selected as a parent k + dij = _manhattan(xi, coords[j]) + if dij < l[j]: + l[j] = dij + heap[j] = -dij + + l_trunc = li # current truncation radius + + # ------------------ main loop ----------------------------------- + while heap: + i, neg_li = heap.popitem() + if selected[i]: + continue + li = -neg_li + xi = coords[i] + selected[i] = True + not_selected.remove(i) + ordering_idx.append(i) + + # ---- choose parent k (Alg. C.1 lines 28-29) ---------------- + k = i0 + distik = np.inf + for j in parents[i]: + dij = _manhattan(xi, coords[j]) + if ((j == i0) or (dij + rho * li <= rho * min(l[j], l_trunc))) and ( + dij < distik + ): + distik = dij + k = j + + xk = coords[k] + + # ---- ensure children[k] sorted once ------------------------ + # Slightly different form paper implementation + # We sort children of k (once) only if the parent is selected as k + if not children_sorted[k]: + arr = np.asarray(children[k], dtype=np.int64) + children[k] = _argsort_by_manhat(xk, arr, coords).tolist() + children_sorted[k] = True + + r_li = rho * li # only once + for j in children[k]: + if j == i: + continue + djk = _manhattan(coords[j], xk) + # triangle inequality pruning. exit early. slightly different form paper, but otherwise the sorting does not make a lot of sense. + if djk > distik + r_li: + break + + dij = _manhattan(xi, coords[j]) + + if (not selected[j]) and dij < l[j]: + l[j] = dij + heap[j] = -dij + + if dij <= r_li: + children[i].append(j) + parents[j].append(i) + + # ---- truncation test (lines 42-49) ---- + # This ensures linear space complexity + # Modification of reference algorithm Schäfer 2020 Algorithm 4.1 + cond = True + half_ltr = 0.5 * l_trunc + for j in not_selected: + if _manhattan(xi, coords[j]) >= half_ltr: + cond = False + break + + if cond: + l_trunc *= 0.5 + rho_ltr = rho * l_trunc + keep = [] + for j in children[i]: + if (j not in not_selected) or (_manhattan(xi, coords[j]) <= rho_ltr): + keep.append(j) + else: + parents[j].remove(i) + children[i] = keep + + # --------------- build sparsity sets ---------------------------- + sparsity = defaultdict(set) + for i, kids in children.items(): + sparsity[i].update(kids) + sparsity[i].add(i) + + return ordering_idx, sparsity + + +def kr_graph_from_revmaximin(sparsity: dict, ordering_revmaxmin_chol: list): + """ + Builds a directed graph for the KR map from the reverse-maximin ordering and sparsity pattern. + + Returns + ------- + networkx.DiGraph + """ + reverse_ordering = {value: ind for ind, value in enumerate(ordering_revmaxmin_chol)} + Graph_kr = nx.DiGraph() + for row, cols in sparsity.items(): + row_idx = reverse_ordering[row] + for col in cols: + col_idx = reverse_ordering[col] + if row_idx >= col_idx: # only lower triangle + Graph_kr.add_edge(row_idx, col_idx) + return Graph_kr